5 લાક્ષણિક JavaScript ઇન્ટરવ્યુ કાર્યો: વિશ્લેષણ અને ઉકેલો

અનુવાદક તરફથી: તમારા માટે એક લેખ પ્રકાશિત કર્યો મારિયા એન્ટોનીએટા પેર્ના, જે સામાન્ય JavaScript કાર્યો વિશે વાત કરે છે, મોટાભાગે ઇન્ટરવ્યુ દરમિયાન વિકાસકર્તા અરજદારોને ઓફર કરવામાં આવે છે. લેખ ઉપયોગી થશે, સૌ પ્રથમ, શિખાઉ પ્રોગ્રામરો માટે.

ટેક કંપનીઓના ઇન્ટરવ્યુ લાંબા સમયથી ટોક ઓફ ધ ટાઉન રહ્યા છે. આ આશ્ચર્યજનક ન હોવું જોઈએ - સફળતાપૂર્વક ઇન્ટરવ્યુ પાસ કરવાથી તમને સારી નોકરી મેળવવાની તક મળે છે. પરંતુ આ એટલું સરળ નથી, કારણ કે જટિલ સમસ્યાઓને વારંવાર હલ કરવાની જરૂર છે.

તદુપરાંત, મોટેભાગે, આમાંના મોટાભાગના કાર્યો અરજદાર જે કાર્ય કરશે તેનાથી સંબંધિત નથી, પરંતુ તેમને હજી પણ હલ કરવાની જરૂર છે. કેટલીકવાર તમારે Google અથવા અન્ય કોઈ સ્ત્રોત સાથે તપાસ કર્યા વિના, બોર્ડ પર કરવું પડશે. હા, પરિસ્થિતિ ધીમે ધીમે બદલાઈ રહી છે, અને કેટલીક કંપનીઓ આવા ઇન્ટરવ્યુ છોડી રહી છે, પરંતુ ઘણા નોકરીદાતાઓ હજુ પણ આ પરંપરાને વળગી રહ્યા છે. આ લેખ સામાન્ય JavaScript કાર્યોના વિશ્લેષણ માટે સમર્પિત છે જેનો ઉપયોગ નોકરી શોધનારાઓ માટેના કાર્યો તરીકે થાય છે.

અમે યાદ કરાવીએ છીએ: Habrના તમામ વાચકો માટે - Habr પ્રોમો કોડનો ઉપયોગ કરીને કોઈપણ સ્કિલબોક્સ કોર્સમાં નોંધણી કરતી વખતે 10 રૂબલ ડિસ્કાઉન્ટ.

સ્કિલબોક્સ ભલામણ કરે છે: પ્રેક્ટિકલ કોર્સ "મોબાઇલ ડેવલપર પ્રો".

મુખ્ય વસ્તુ એ છે કે તમારા ઇન્ટરવ્યુ માટે સંપૂર્ણ તૈયારી કરવી.

હા, અમે કાર્યોને જોવાનું શરૂ કરીએ તે પહેલાં, ચાલો કેટલીક સામાન્ય ઇન્ટરવ્યુ તૈયારી ટિપ્સ જોઈએ.

મુખ્ય વસ્તુ અગાઉથી તૈયાર કરવાનું છે. તમે એલ્ગોરિધમ્સ અને ડેટા સ્ટ્રક્ચર્સને કેટલી સારી રીતે યાદ રાખો છો તેનું પરીક્ષણ કરો અને તે ક્ષેત્રોમાં તમારા જ્ઞાનને બહેતર બનાવો કે જેનાથી તમે ખૂબ પરિચિત નથી. ઘણા ઓનલાઈન પ્લેટફોર્મ છે જે તમને ઈન્ટરવ્યુ માટે તૈયાર કરવામાં મદદ કરી શકે છે. અમે સલાહ આપીએ છીએ geeksforgeeks, પ્રમ્પ, Interviewing.io и કોડસિગ્નલ.

નિર્ણયને મોટેથી બોલવાનું શીખવા યોગ્ય છે. તમે શું કરો છો તેના વિશે અરજદારોને જણાવવાની સલાહ આપવામાં આવે છે, અને માત્ર બોર્ડ પર લખો નહીં (અથવા કમ્પ્યુટરમાં કોડ લખો, શાંતિથી પણ). આ રીતે, જો તમે કોડમાં ભૂલ કરો છો, પરંતુ ઉકેલ સામાન્ય રીતે સાચો હોય, તો તમે તમારી સફળતાની તકો વધારી શકો છો.

તમે તેને હલ કરવાનું શરૂ કરો તે પહેલાં તમારે સમસ્યાને સમજવાની જરૂર છે. કેટલાક કિસ્સાઓમાં, તમે કોઈ કાર્યને ઉપરછલ્લી રીતે સમજી શકો છો અને પછી ખોટા માર્ગે જઈ શકો છો. ઇન્ટરવ્યુઅરને થોડા સ્પષ્ટતા પ્રશ્નો પૂછવા યોગ્ય છે.

તમારે હાથથી કોડ લખવાની પ્રેક્ટિસ કરવાની જરૂર છે, પીસી પર નહીં. એવું બને છે કે ઇન્ટરવ્યુ દરમિયાન અરજદારને માર્કર અને વ્હાઇટબોર્ડ આપવામાં આવે છે, જ્યાં કોઈ સંકેતો અથવા સ્વચાલિત ફોર્મેટિંગ નથી. જ્યારે કોઈ ઉકેલ શોધી રહ્યા હોય, ત્યારે તે કાગળના ટુકડા પર અથવા સીધા બોર્ડ પર તમારો કોડ લખવા યોગ્ય છે. જો તમે બધું તમારા મગજમાં રાખો છો, તો તમે કંઈક મહત્વપૂર્ણ ભૂલી શકો છો.

JavaScript માં નમૂના કાર્યો

આમાંના કેટલાક કાર્યો કદાચ તમને પહેલેથી જ પરિચિત છે. તમે ક્યાં તો ઇન્ટરવ્યુ લીધા છે જ્યાં તમારે કંઈક આવું જ ઉકેલવું પડ્યું છે, અથવા JavaScript શીખતી વખતે તેના પર પ્રેક્ટિસ કરી છે. ઠીક છે, હવે તેમને ફરીથી હલ કરવાનો સમય છે, અને પ્રક્રિયાના વિગતવાર સમજૂતી સાથે.

પેલિન્ડ્રોમ

પેલિન્ડ્રોમ એ એક શબ્દ, વાક્ય અથવા અક્ષરોનો ક્રમ છે જે સામાન્ય દિશામાં અને વિરુદ્ધ દિશામાં બરાબર સમાન રીતે વાંચવામાં આવે છે. ઉદાહરણ તરીકે, "અન્ના" એ પેલિન્ડ્રોમ છે, પરંતુ "ટેબલ" અને "જ્હોન" નથી.

સ્ટેજીંગ

એક શબ્દમાળા આપેલ; તમારે એક ફંક્શન લખવાની જરૂર છે જે તમને જો શબ્દમાળા પેલિન્ડ્રોમ હોય તો સાચું પરત કરવા દે છે અને જો ન હોય તો ખોટું. આ કિસ્સામાં, તમારે જગ્યાઓ અને વિરામચિહ્નો ધ્યાનમાં લેવાની જરૂર છે.

પેલિન્ડ્રોમ('રેસકાર') === સાચું
પેલિન્ડ્રોમ('ટેબલ') === ખોટું

ચાલો કાર્યનું વિશ્લેષણ કરીએ

અહીં મુખ્ય વિચાર શબ્દમાળાને વિપરીત કરવાનો છે. જો "વિપરીત" શબ્દમાળા સંપૂર્ણપણે મૂળ સમાન હોય, તો અમને પેલિન્ડ્રોમ પ્રાપ્ત થયો છે અને કાર્ય સાચું આવવું જોઈએ. જો નહિં, તો ખોટા.

નિર્ણય

અહીં એક કોડ છે જે પેલિન્ડ્રોમને હલ કરે છે.

const palindrome = str => {
  // turn the string to lowercase
  str = str.toLowerCase()
  // reverse input string and return the result of the
  // comparisong
  return str === str.split('').reverse().join('')
}

પ્રથમ પગલું એ ઇનપુટ સ્ટ્રિંગમાંના અક્ષરોને લોઅર કેસમાં કન્વર્ટ કરવાનું છે. આ એક ગેરંટી છે કે પ્રોગ્રામ પાત્રોની પોતાની તુલના કરશે, અને કેસ અથવા અન્ય કંઈપણ નહીં.

બીજું પગલું એ લાઇનને વિપરીત કરવાનું છે. આ કરવું મુશ્કેલ નથી: તમારે .split() પદ્ધતિ (સ્ટ્રિંગ લાઇબ્રેરી) નો ઉપયોગ કરીને તેને એરેમાં રૂપાંતરિત કરવાની જરૂર છે. પછી આપણે .reverse() (Array library) નો ઉપયોગ કરીને એરેને રિવર્સ કરીએ છીએ. છેલ્લું પગલું .join() (એરે લાઇબ્રેરી) નો ઉપયોગ કરીને વિપરીત એરેને સ્ટ્રિંગમાં રૂપાંતરિત કરવાનું છે.

હવે તમારે ફક્ત "વિપરીત" સ્ટ્રિંગને મૂળ સ્ટ્રિંગ સાથે સરખાવવાની જરૂર છે, પરિણામ સાચું કે ખોટું પાછું આપીને.

FizzBuzz

ઇન્ટરવ્યુમાં સૌથી લોકપ્રિય કાર્યોમાંનું એક.

સ્ટેજીંગ

તમારે એક ફંક્શન લખવાની જરૂર છે જે કન્સોલ પર 1 થી n સુધીની સંખ્યાઓ છાપે છે, જ્યાં n એ પૂર્ણાંક છે જે ફંક્શન નીચેની શરતો સાથે પરિમાણ તરીકે લે છે:

• 3 ના ગુણાંકને બદલે આઉટપુટ ફિઝ;
• 5 ના ગુણાંકની સંખ્યાને બદલે આઉટપુટ બઝ;
• 3 અને 5 બંનેના ગુણાંકની સંખ્યાને બદલે fizzbuzz આઉટપુટ.

ઉદાહરણ:

ફિઝબઝ(5)

પરિણામ

// 1
// 2
// ફિઝ
// 4
//ગણગણવું

ચાલો કાર્યનું વિશ્લેષણ કરીએ

અહીં મુખ્ય વસ્તુ JavaScript નો ઉપયોગ કરીને ગુણાંક શોધવાની રીત છે. તે મોડ્યુલસ ઓપરેટર અથવા શેષ - % નો ઉપયોગ કરીને અમલમાં મૂકી શકાય છે, જે તમને બે સંખ્યાઓને વિભાજીત કરતી વખતે શેષ બતાવવાની મંજૂરી આપે છે. જો શેષ 0 છે, તો તેનો અર્થ એ છે કે પ્રથમ સંખ્યા બીજાનો ગુણાંક છે.

12% 5 // 2 -> 12 એ 5 નો ગુણાંક નથી
12% 3 // 0 -> 12 એ 3 નો ગુણાંક છે

તેથી, જો તમે 12 ને 5 વડે ભાગશો, તો તમને 2 ના શેષ સાથે 2 મળશે. જો તમે 12 ને 3 વડે ભાગો છો, તો તમને 4 ના શેષ સાથે 0 મળશે. પ્રથમ કિસ્સામાં, 12 એ 5 નો ગુણાંક નથી, બીજામાં , 12 એ 3 નો ગુણાંક છે.

નિર્ણય

શ્રેષ્ઠ ઉકેલ નીચેનો કોડ હશે:

const fizzBuzz = num => {
  for(let i = 1; i <= num; i++) {
    // check if the number is a multiple of 3 and 5
    if(i % 3 === 0 && i % 5 === 0) {
      console.log('fizzbuzz')
    } // check if the number is a multiple of 3
      else if(i % 3 === 0) {
      console.log('fizz')
    } // check if the number is a multiple of 5
      else if(i % 5 === 0) {
      console.log('buzz')
    } else {
      console.log(i)
    }
  }
}

ફંક્શન શરતી નિવેદનોનો ઉપયોગ કરીને જરૂરી તપાસ કરે છે અને વપરાશકર્તા દ્વારા જરૂરી પરિણામ ઉત્પન્ન કરે છે. સમસ્યામાં, if...else સ્ટેટમેન્ટના ક્રમ પર ધ્યાન આપવું યોગ્ય છે: ડબલ શરત (&&) થી શરૂ કરો અને જ્યાં બહુવિધ સંખ્યાઓ શોધી શકાઈ ન હોય તેવા કિસ્સામાં સમાપ્ત કરો. પરિણામે, અમે બધા વિકલ્પો આવરી લઈએ છીએ.

એનાગ્રામ

આ એવા શબ્દનું નામ છે જેમાં બીજા શબ્દના તમામ અક્ષરો સમાન સંખ્યામાં હોય, પરંતુ અલગ ક્રમમાં હોય.

સ્ટેજીંગ

આપણે એક ફંક્શન લખવાની જરૂર છે જે તપાસે છે કે બે સ્ટ્રિંગ્સ એનાગ્રામ છે કે કેમ, અને કેસથી કોઈ ફરક પડતો નથી. માત્ર અક્ષરો ગણાય છે; જગ્યાઓ અથવા વિરામચિહ્નો ધ્યાનમાં લેવામાં આવતા નથી.

એનાગ્રામ('ફાઇન્ડર', 'ફ્રેન્ડ') —> સાચું
એનાગ્રામ('હેલો', 'બાય') —> ખોટું

ચાલો કાર્યનું વિશ્લેષણ કરીએ

અહીં ધ્યાનમાં લેવા જેવી મહત્વની બાબત એ છે કે તમારે બે ઇનપુટ લાઇનમાં દરેક અક્ષર અને દરેક લાઇનમાં તેમની સંખ્યા તપાસવાની જરૂર છે.

શોધક —> f: 1 મિત્ર —> f: 1
i: 1 આર: 1
n: 1 i: 1
d: 1 e: 1
e: 1 n: 1
ર: 1 ડી: 1

એનાગ્રામ ડેટા સ્ટોર કરવા માટે, તમારે જાવાસ્ક્રિપ્ટ ઑબ્જેક્ટ લિટરલ જેવું માળખું પસંદ કરવું જોઈએ. આ કિસ્સામાં ચાવી એ અક્ષરનું પાત્ર છે, મૂલ્ય એ વર્તમાન લાઇનમાં તેના પુનરાવર્તનોની સંખ્યા છે.

અન્ય શરતો છે:

• તમારે એ સુનિશ્ચિત કરવાની જરૂર છે કે સરખામણી કરતી વખતે અક્ષરોના કેસને ધ્યાનમાં લેવામાં ન આવે. અમે બંને સ્ટ્રિંગને લોઅર કે અપરકેસમાં કન્વર્ટ કરીએ છીએ.
• અમે સરખામણીમાંથી બધા બિન-અક્ષરોને બાકાત રાખીએ છીએ. સાથે કામ કરવા માટે શ્રેષ્ઠ નિયમિત અભિવ્યક્તિઓ.

નિર્ણય

// helper function that builds the
// object to store the data
const buildCharObject = str => {
  const charObj = {}
  for(let char of str.replace(/[^w]/g).toLowerCase()) {
    // if the object has already a key value pair
    // equal to the value being looped over,
    // increase the value by 1, otherwise add
    // the letter being looped over as key and 1 as its value
    charObj[char] = charObj[char] + 1 || 1
  }
  return charObj
}
 
// main function
const anagram = (strA, strB) => {
  // build the object that holds strA data
  const aCharObject = buildCharObject(strA)
  // build the object that holds strB data
  const bCharObject = buildCharObject(strB)
 
  // compare number of keys in the two objects
  // (anagrams must have the same number of letters)
  if(Object.keys(aCharObject).length !== Object.keys(bCharObject).length) {
    return false
  }
  // if both objects have the same number of keys
  // we can be sure that at least both strings
  // have the same number of characters
  // now we can compare the two objects to see if both
  // have the same letters in the same amount
  for(let char in aCharObject) {
    if(aCharObject[char] !== bCharObject[char]) {
      return false
    }
  }
  // if both the above checks succeed,
  // you have an anagram: return true
  return true
}

ઉપયોગ પર ધ્યાન આપો Object.keys() ઉપરના સ્નિપેટમાં. આ પદ્ધતિ ઑબ્જેક્ટમાં જે ક્રમમાં દેખાય છે તે જ ક્રમમાં નામ અથવા કીઓ ધરાવતો એરે આપે છે. આ કિસ્સામાં એરે આના જેવું હશે:

['f', 'i', 'n', 'd', 'e', ​​'r']

આ રીતે આપણે બલ્ક લૂપ કર્યા વિના ઑબ્જેક્ટના ગુણધર્મો મેળવીએ છીએ. સમસ્યામાં, તમે .length ગુણધર્મ સાથે આ પદ્ધતિનો ઉપયોગ કરી શકો છો કે કેમ તે ચકાસવા માટે કે બંને સ્ટ્રીંગમાં સમાન સંખ્યામાં અક્ષરો છે - આ એનાગ્રામનું એક મહત્વપૂર્ણ લક્ષણ છે.

સ્વરો માટે શોધો

એકદમ સરળ કાર્ય જે વારંવાર ઇન્ટરવ્યુમાં આવે છે.

સ્ટેજીંગ

તમારે એક ફંક્શન લખવાની જરૂર છે જે સ્ટ્રિંગને દલીલ તરીકે લે છે અને સ્ટ્રિંગમાં રહેલા સ્વરોની સંખ્યા પરત કરે છે.
સ્વરો છે “a”, “e”, “i”, “o”, “u”.

ઉદાહરણ:

findVowels('hello') // —> 2
findVowels('શા માટે') // —> 0

નિર્ણય

અહીં સૌથી સરળ વિકલ્પ છે:

const findVowels = str => {
  let count = 0
  const vowels = ['a', 'e', 'i', 'o', 'u']
  for(let char of str.toLowerCase()) {
    if(vowels.includes(char)) {
      count++
    }
  }
  return count
}

.includes() પદ્ધતિના ઉપયોગ પર ધ્યાન આપવું મહત્વપૂર્ણ છે. તે શબ્દમાળાઓ અને એરે બંને માટે ઉપલબ્ધ છે. એરે ચોક્કસ મૂલ્ય ધરાવે છે કે કેમ તે નિર્ધારિત કરવા માટે તેનો ઉપયોગ થવો જોઈએ. જો એરેમાં ઉલ્લેખિત મૂલ્ય હોય તો આ પદ્ધતિ સાચી પરત કરે છે અને જો તે ન હોય તો ખોટી.

સમસ્યાનો ટૂંકો ઉકેલ છે:

const findVowels = str => {
  const matched = str.match(/[aeiou]/gi)
  return matched ? matches.length : 0
}

આ .match() પદ્ધતિનો ઉપયોગ કરે છે, જે તમને કાર્યક્ષમ શોધને અમલમાં મૂકવા માટે પરવાનગી આપે છે. જો પદ્ધતિની દલીલ તરીકે નિયમિત અભિવ્યક્તિ ઉલ્લેખિત સ્ટ્રિંગની અંદર જોવા મળે છે, તો વળતર મૂલ્ય એ મેળ ખાતા અક્ષરોની એરે છે. ઠીક છે, જો ત્યાં કોઈ મેળ ન હોય, તો .match() નલ પરત કરે છે.

ફિબોનાકી

એક ઉત્તમ કાર્ય જે વિવિધ સ્તરે ઇન્ટરવ્યુમાં મળી શકે છે. તે યાદ કરવા યોગ્ય છે કે ફિબોનાકી ક્રમ એ સંખ્યાઓની શ્રેણી છે જ્યાં દરેક અનુગામી એક અગાઉના બેનો સરવાળો છે. તેથી, પ્રથમ દસ નંબરો આના જેવો દેખાય છે: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34.

સ્ટેજીંગ

તમારે ફંક્શન લખવાની જરૂર છે જે ચોક્કસ ક્રમમાં nth રેકોર્ડ પરત કરે છે, જેમાં n એ ફંક્શનને દલીલ તરીકે પસાર કરવામાં આવેલ સંખ્યા છે.

ફિબોનાકી(3) // —> 2

આ કાર્યમાં દલીલમાં નિર્દિષ્ટ કરેલ સંખ્યાની સંખ્યાને લૂપમાંથી પસાર થવું, યોગ્ય સ્થાને મૂલ્ય પરત કરવાનો સમાવેશ થાય છે. સમસ્યા ઉભી કરવાની આ રીત માટે લૂપ્સનો ઉપયોગ જરૂરી છે. જો તમે તેના બદલે રિકર્ઝનનો ઉપયોગ કરો છો, તો તે ઇન્ટરવ્યુઅરને ખુશ કરી શકે છે અને તમને થોડા વધારાના મુદ્દાઓ આપી શકે છે.

નિર્ણય

const fibonacci = num => {
  // store the Fibonacci sequence you're going
  // to generate inside an array and
  // initialize the array with the first two
  // numbers of the sequence
  const result = [0, 1]
 
  for(let i = 2; i <= num; i++) {
    // push the sum of the two numbers
    // preceding the position of i in the result array
    // at the end of the result array
    const prevNum1 = result[i - 1]
    const prevNum2 = result[i - 2]
    result.push(prevNum1 + prevNum2)
  }
  // return the last value in the result array
  return result[num]
}

પરિણામો એરેમાં, પ્રથમ બે સંખ્યાઓ શ્રેણીમાં સમાયેલ છે કારણ કે ક્રમમાં દરેક એન્ટ્રી એ અગાઉની બે સંખ્યાઓનો સરવાળો છે. ખૂબ જ શરૂઆતમાં ત્યાં કોઈ બે નંબરો નથી કે જે આગામી નંબર મેળવવા માટે લઈ શકાય, તેથી લૂપ તેમને આપમેળે જનરેટ કરી શકતું નથી. પરંતુ, જેમ આપણે જાણીએ છીએ, પ્રથમ બે સંખ્યા હંમેશા 0 અને 1 હોય છે. તેથી, તમે પરિણામોની શ્રેણીને જાતે જ આરંભ કરી શકો છો.

પુનરાવર્તનની વાત કરીએ તો, તે જ સમયે બધું સરળ અને વધુ જટિલ છે:

const fibonacci = num => {
  // if num is either 0 or 1 return num
  if(num < 2) {
    return num
  }
  // recursion here
  return fibonacci(num - 1) + fibonacci(num - 2)
}

અમે fibonacci() કહીએ છીએ, દલીલો તરીકે નાની અને નાની સંખ્યાઓ પસાર કરીએ છીએ. જ્યારે પસાર થયેલી દલીલ 0 અથવા 1 હોય ત્યારે અમે રોકીએ છીએ.

નિષ્કર્ષ

મોટે ભાગે, જો તમે ફ્રન્ટએન્ડ અથવા JavaScript ડેવલપર જોબ માટે ઇન્ટરવ્યુ લીધા હોય (ખાસ કરીને જો તે જુનિયર સ્તર પર હોય તો) તમે આમાંથી કોઈપણ કાર્યનો સામનો કરી ચૂક્યા છો. પરંતુ જો તમે તેમને મળ્યા નથી, તો તેઓ ભવિષ્યમાં ઉપયોગી થઈ શકે છે - ઓછામાં ઓછા સામાન્ય વિકાસ માટે.

સ્કિલબોક્સ ભલામણ કરે છે:

• ઓનલાઈન કોર્સ લાગુ કર્યો "પાયથોન ડેટા એનાલિસ્ટ".
• ઓનલાઇન કોર્સ "પ્રોફેશન ફ્રન્ટ એન્ડ ડેવલપર".
• એક વર્ષનો પ્રેક્ટિકલ કોર્સ "0 થી PRO સુધી PHP વિકાસકર્તા".

સોર્સ: www.habr.com