5 സാധാരണ JavaScript അഭിമുഖ ജോലികൾ: വിശകലനവും പരിഹാരങ്ങളും

വിവർത്തകനിൽ നിന്ന്: നിങ്ങൾക്കായി ഒരു ലേഖനം പ്രസിദ്ധീകരിച്ചു സാധാരണ ജാവാസ്ക്രിപ്റ്റ് ടാസ്ക്കുകളെ കുറിച്ച് സംസാരിക്കുന്ന മരിയ അന്റോണിയറ്റ പെർന, മിക്കപ്പോഴും അഭിമുഖങ്ങളിൽ ഡെവലപ്പർ അപേക്ഷകർക്ക് വാഗ്ദാനം ചെയ്യുന്നു. ലേഖനം, ഒന്നാമതായി, പുതിയ പ്രോഗ്രാമർമാർക്ക് ഉപയോഗപ്രദമാകും.

ടെക് കമ്പനികളിലെ അഭിമുഖങ്ങൾ വളരെക്കാലമായി നഗരത്തിലെ സംസാരവിഷയമാണ്. ഇത് ആശ്ചര്യപ്പെടേണ്ടതില്ല - ഒരു അഭിമുഖം വിജയകരമായി വിജയിക്കുന്നത് നിങ്ങൾക്ക് ഒരു നല്ല ജോലി നേടാനുള്ള അവസരം നൽകുന്നു. എന്നാൽ ഇത് അത്ര ലളിതമല്ല, കാരണം സങ്കീർണ്ണമായ പ്രശ്നങ്ങൾ പലപ്പോഴും പരിഹരിക്കേണ്ടതുണ്ട്.

മാത്രമല്ല, മിക്കപ്പോഴും, ഈ ജോലികളിൽ ഭൂരിഭാഗവും അപേക്ഷകൻ ചെയ്യുന്ന ജോലിയുമായി ബന്ധപ്പെട്ടതല്ല, പക്ഷേ അവ ഇപ്പോഴും പരിഹരിക്കേണ്ടതുണ്ട്. ചിലപ്പോൾ നിങ്ങൾ അത് ബോർഡിൽ ചെയ്യേണ്ടിവരും, Google അല്ലെങ്കിൽ മറ്റേതെങ്കിലും ഉറവിടം പരിശോധിക്കാതെ. അതെ, സ്ഥിതി ക്രമേണ മാറുകയാണ്, ചില കമ്പനികൾ അത്തരം അഭിമുഖങ്ങൾ ഉപേക്ഷിക്കുന്നു, എന്നാൽ പല തൊഴിലുടമകളും ഇപ്പോഴും ഈ പാരമ്പര്യം പാലിക്കുന്നു. തൊഴിലന്വേഷകർക്കുള്ള ടാസ്ക്കുകളായി ഉപയോഗിക്കപ്പെടുന്ന സാധാരണ ജാവാസ്ക്രിപ്റ്റ് ടാസ്ക്കുകളുടെ വിശകലനത്തിനായി ഈ ലേഖനം നീക്കിവച്ചിരിക്കുന്നു.

ഞങ്ങൾ ഓർമ്മിപ്പിക്കുന്നു: "Habr"-ന്റെ എല്ലാ വായനക്കാർക്കും - "Habr" പ്രൊമോഷണൽ കോഡ് ഉപയോഗിച്ച് ഏതെങ്കിലും സ്കിൽബോക്സ് കോഴ്സിൽ ചേരുമ്പോൾ 10 റൂബിൾസ് കിഴിവ്.

സ്കിൽബോക്സ് ശുപാർശ ചെയ്യുന്നു: പ്രായോഗിക കോഴ്സ് "മൊബൈൽ ഡെവലപ്പർ PRO".

നിങ്ങളുടെ അഭിമുഖത്തിന് നന്നായി തയ്യാറെടുക്കുക എന്നതാണ് പ്രധാന കാര്യം.

അതെ, ടാസ്‌ക്കുകൾ നോക്കാൻ തുടങ്ങുന്നതിനുമുമ്പ്, ചില പൊതുവായ അഭിമുഖ തയ്യാറെടുപ്പ് നുറുങ്ങുകൾ നോക്കാം.

മുൻകൂട്ടി തയ്യാറാക്കുക എന്നതാണ് പ്രധാന കാര്യം. അൽ‌ഗോരിതങ്ങളും ഡാറ്റാ ഘടനകളും നിങ്ങൾ എത്ര നന്നായി ഓർക്കുന്നുവെന്ന് പരിശോധിക്കുക, നിങ്ങൾക്ക് പരിചിതമല്ലാത്ത മേഖലകളിൽ നിങ്ങളുടെ അറിവ് മെച്ചപ്പെടുത്തുക. അഭിമുഖത്തിന് തയ്യാറെടുക്കാൻ നിങ്ങളെ സഹായിക്കുന്ന നിരവധി ഓൺലൈൻ പ്ലാറ്റ്‌ഫോമുകളുണ്ട്. ഞങ്ങൾ ഉപദേശിക്കുന്നു ഗീക്സ്ഫോർഗീക്കുകൾ, പ്രാമ്പ്, Interviewing.io и കോഡ് സിഗ്നൽ.

തീരുമാനം ഉച്ചത്തിൽ പറയാൻ പഠിക്കുന്നത് മൂല്യവത്താണ്. ബോർഡിൽ എഴുതുക മാത്രമല്ല (അല്ലെങ്കിൽ കമ്പ്യൂട്ടറിൽ കോഡ് ടൈപ്പ് ചെയ്യുക, നിശബ്ദമായും) നിങ്ങൾ ചെയ്യുന്ന കാര്യങ്ങളെക്കുറിച്ച് അപേക്ഷകരോട് പറയുന്നത് നല്ലതാണ്. ഈ രീതിയിൽ, നിങ്ങൾ കോഡിൽ ഒരു തെറ്റ് വരുത്തിയാൽ, പക്ഷേ പരിഹാരം പൊതുവെ ശരിയാണെങ്കിൽ, നിങ്ങൾക്ക് വിജയസാധ്യത വർദ്ധിപ്പിക്കാൻ കഴിയും.

പ്രശ്നം പരിഹരിക്കാൻ തുടങ്ങുന്നതിനുമുമ്പ് നിങ്ങൾ അത് മനസ്സിലാക്കേണ്ടതുണ്ട്. ചില സന്ദർഭങ്ങളിൽ, നിങ്ങൾ ഒരു ജോലി ഉപരിപ്ലവമായി മനസ്സിലാക്കുകയും പിന്നീട് തെറ്റായ പാതയിലേക്ക് പോകുകയും ചെയ്യാം. അഭിമുഖം നടത്തുന്നയാളോട് വ്യക്തമാക്കുന്ന കുറച്ച് ചോദ്യങ്ങൾ ചോദിക്കുന്നത് മൂല്യവത്തായിരിക്കാം.

പിസിയിലല്ല, കൈകൊണ്ട് കോഡ് എഴുതുന്നത് പരിശീലിക്കേണ്ടതുണ്ട്. ഇന്റർവ്യൂ സമയത്ത് അപേക്ഷകന് ഒരു മാർക്കറും വൈറ്റ്ബോർഡും നൽകുന്നു, അവിടെ സൂചനകളോ യാന്ത്രിക ഫോർമാറ്റിംഗോ ഇല്ല. ഒരു പരിഹാരത്തിനായി തിരയുമ്പോൾ, നിങ്ങളുടെ കോഡ് ഒരു കടലാസിലോ നേരിട്ട് ബോർഡിലോ എഴുതുന്നത് മൂല്യവത്താണ്. നിങ്ങൾ എല്ലാം നിങ്ങളുടെ തലയിൽ സൂക്ഷിക്കുകയാണെങ്കിൽ, പ്രധാനപ്പെട്ട എന്തെങ്കിലും നിങ്ങൾ മറന്നേക്കാം.

JavaScript-ലെ ടെംപ്ലേറ്റ് ടാസ്‌ക്കുകൾ

ഈ ടാസ്‌ക്കുകളിൽ ചിലത് നിങ്ങൾക്ക് ഇതിനകം പരിചിതമായിരിക്കാം. നിങ്ങൾക്ക് ഒന്നുകിൽ സമാനമായ എന്തെങ്കിലും പരിഹരിക്കേണ്ട അഭിമുഖങ്ങൾ ഉണ്ടായിട്ടുണ്ട്, അല്ലെങ്കിൽ JavaScript പഠിക്കുമ്പോൾ അവയിൽ പരിശീലിക്കുക. ശരി, ഇപ്പോൾ അവ വീണ്ടും പരിഹരിക്കാനുള്ള സമയമായി, കൂടാതെ പ്രക്രിയയുടെ വിശദമായ വിശദീകരണവും.

പാലിൻഡ്രോം

സാധാരണ ദിശയിലും വിപരീത ദിശയിലും ഒരേപോലെ വായിക്കുന്ന ഒരു വാക്കോ വാക്യമോ അക്ഷരങ്ങളുടെ ക്രമമോ ആണ് പാലിൻഡ്രോം. ഉദാഹരണത്തിന്, "അന്ന" ഒരു പാലിൻഡ്രോം ആണ്, എന്നാൽ "ടേബിൾ", "ജോൺ" എന്നിവയല്ല.

സ്റ്റേജിംഗ്

ഒരു സ്ട്രിംഗ് നൽകി; സ്ട്രിംഗ് ഒരു പാലിൻഡ്രോം ആണെങ്കിൽ true എന്ന് തിരികെ നൽകാൻ അനുവദിക്കുന്ന ഒരു ഫംഗ്ഷൻ നിങ്ങൾ എഴുതേണ്ടതുണ്ട്. ഈ സാഹചര്യത്തിൽ, നിങ്ങൾ സ്പെയ്സുകളും വിരാമചിഹ്നങ്ങളും കണക്കിലെടുക്കേണ്ടതുണ്ട്.

പാലിൻഡ്രോം('റേസ്കാർ') === സത്യം
palindrome('table') === തെറ്റ്

നമുക്ക് ചുമതല വിശകലനം ചെയ്യാം

സ്ട്രിംഗ് റിവേഴ്സ് ചെയ്യുക എന്നതാണ് ഇവിടെ പ്രധാന ആശയം. "റിവേഴ്സ്" സ്ട്രിംഗ് ഒറിജിനലിനോട് പൂർണ്ണമായും സമാനമാണെങ്കിൽ, ഞങ്ങൾക്ക് ഒരു പാലിൻഡ്രോം ലഭിച്ചു, ഫംഗ്ഷൻ ശരിയാകും. ഇല്ലെങ്കിൽ കള്ളം.

തീരുമാനം

പാലിൻഡ്രോം പരിഹരിക്കുന്ന കോഡ് ഇതാ.

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() (Aray library) ഉപയോഗിച്ച് അറേ റിവേഴ്സ് ചെയ്യുന്നു. .join() (Aray library) ഉപയോഗിച്ച് റിവേഴ്സ് അറേയെ ഒരു സ്ട്രിംഗിലേക്ക് പരിവർത്തനം ചെയ്യുക എന്നതാണ് അവസാന ഘട്ടം.

ഇപ്പോൾ നിങ്ങൾ ചെയ്യേണ്ടത് "റിവേഴ്സ്" സ്ട്രിംഗ് യഥാർത്ഥ സ്ട്രിംഗുമായി താരതമ്യം ചെയ്യുക, ഫലം ശരിയോ തെറ്റോ നൽകുക.

FizzBuzz

അഭിമുഖങ്ങളിലെ ഏറ്റവും ജനപ്രിയമായ ജോലികളിൽ ഒന്ന്.

സ്റ്റേജിംഗ്

കൺസോളിലേക്ക് 1 മുതൽ n വരെയുള്ള സംഖ്യകൾ പ്രിന്റ് ചെയ്യുന്ന ഒരു ഫംഗ്‌ഷൻ നിങ്ങൾ എഴുതേണ്ടതുണ്ട്, ഇവിടെ n എന്നത് ഫംഗ്‌ഷൻ ഒരു പാരാമീറ്ററായി എടുക്കുന്ന ഒരു പൂർണ്ണസംഖ്യയാണ്, ഇനിപ്പറയുന്ന വ്യവസ്ഥകളോടെ:

• 3 ന്റെ ഗുണിതങ്ങൾക്ക് പകരം ഔട്ട്പുട്ട് fizz;
• 5 ന്റെ ഗുണിതങ്ങളായ സംഖ്യകൾക്ക് പകരം ഔട്ട്പുട്ട് buzz;
• 3, 5 എന്നിവയുടെ ഗുണിതങ്ങളായ സംഖ്യകൾക്ക് പകരം fizzbuzz ഔട്ട്പുട്ട്.

ഉദാഹരണം:

Fizzbuzz(5)

ഫലം

// 1
// 2
// ഫിസ്
// 4
//buzz

നമുക്ക് ചുമതല വിശകലനം ചെയ്യാം

ഇവിടെ പ്രധാന കാര്യം 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 r: 1
n: 1 i: 1
ഡി: 1 ഇ: 1
e: 1 n: 1
r: 1 d: 1

അനഗ്രാം ഡാറ്റ സംഭരിക്കുന്നതിന്, നിങ്ങൾ JavaScript ഒബ്ജക്റ്റ് ലിറ്ററൽ പോലുള്ള ഒരു ഘടന തിരഞ്ഞെടുക്കണം. ഈ കേസിലെ പ്രധാന കാര്യം അക്ഷരത്തിന്റെ പ്രതീകമാണ്, നിലവിലെ വരിയിലെ അതിന്റെ ആവർത്തനങ്ങളുടെ എണ്ണമാണ് മൂല്യം.

മറ്റ് വ്യവസ്ഥകൾ ഉണ്ട്:

• താരതമ്യപ്പെടുത്തുമ്പോൾ അക്ഷരങ്ങളുടെ കേസ് കണക്കിലെടുക്കുന്നില്ലെന്ന് നിങ്ങൾ ഉറപ്പാക്കേണ്ടതുണ്ട്. ഞങ്ങൾ രണ്ട് സ്ട്രിംഗുകളും ലോവർ അല്ലെങ്കിൽ വലിയ കേസിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു.
• താരതമ്യത്തിൽ നിന്ന് എല്ലാ കഥാപാത്രങ്ങളല്ലാത്തവയും ഞങ്ങൾ ഒഴിവാക്കുന്നു. കൂടെ പ്രവർത്തിക്കുന്നതാണ് നല്ലത് പതിവ് ഭാവങ്ങൾ.

തീരുമാനം

// 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" എന്നിവയാണ് സ്വരാക്ഷരങ്ങൾ.

ഉദാഹരണം:

സ്വരാക്ഷരങ്ങൾ കണ്ടെത്തുക('ഹലോ') // —> 2
സ്വരാക്ഷരങ്ങൾ ('എന്തുകൊണ്ട്') // —> 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() null നൽകുന്നു.

ഫിബൊനാച്ചി

വിവിധ തലങ്ങളിലുള്ള അഭിമുഖങ്ങളിൽ കണ്ടെത്താവുന്ന ഒരു ക്ലാസിക് ടാസ്ക്. ഫിബൊനാച്ചി സീക്വൻസ് എന്നത് സംഖ്യകളുടെ ഒരു ശ്രേണിയാണെന്നത് ഓർക്കേണ്ടതാണ്, അവിടെ ഓരോ തുടർന്നുള്ളതും മുമ്പത്തെ രണ്ടിന്റെ ആകെത്തുകയാണ്. അതിനാൽ, ആദ്യത്തെ പത്ത് സംഖ്യകൾ ഇതുപോലെയാണ്: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34.

സ്റ്റേജിംഗ്

ഫംഗ്‌ഷനിലേക്ക് ഒരു ആർഗ്യുമെന്റായി കൈമാറുന്ന സംഖ്യ n ആയതിനാൽ നിങ്ങൾ ഒരു നിശ്ചിത ശ്രേണിയിൽ nth റെക്കോർഡ് നൽകുന്ന ഒരു ഫംഗ്‌ഷൻ എഴുതേണ്ടതുണ്ട്.

ഫിബൊനാച്ചി(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)
}

ഞങ്ങൾ ഫിബൊനാച്ചി() എന്ന് വിളിക്കുന്നു, ചെറുതും ചെറുതുമായ സംഖ്യകൾ ആർഗ്യുമെന്റുകളായി കൈമാറുന്നു. പാസായ ആർഗ്യുമെന്റ് 0 അല്ലെങ്കിൽ 1 ആകുമ്പോൾ ഞങ്ങൾ നിർത്തുന്നു.

തീരുമാനം

മിക്കവാറും, നിങ്ങൾ ഒരു ഫ്രണ്ടെൻഡ് അല്ലെങ്കിൽ JavaScript ഡവലപ്പർ ജോലിക്ക് വേണ്ടി അഭിമുഖം നടത്തിയിട്ടുണ്ടെങ്കിൽ (പ്രത്യേകിച്ച് അത് ജൂനിയർ തലത്തിലാണെങ്കിൽ) ഈ ടാസ്ക്കുകളിൽ ഏതെങ്കിലും നിങ്ങൾ ഇതിനകം നേരിട്ടിട്ടുണ്ടാകും. എന്നാൽ നിങ്ങൾ അവ കണ്ടിട്ടില്ലെങ്കിൽ, ഭാവിയിൽ അവ ഉപയോഗപ്രദമാകും - കുറഞ്ഞത് പൊതുവായ വികസനത്തിനെങ്കിലും.

സ്കിൽബോക്സ് ശുപാർശ ചെയ്യുന്നു:

• ഓൺലൈൻ കോഴ്സിന് അപേക്ഷിച്ചു "പൈത്തൺ ഡാറ്റ അനലിസ്റ്റ്".
• ഓൺലൈൻ കോഴ്സ് "പ്രൊഫഷൻ ഫ്രണ്ടൻഡ് ഡെവലപ്പർ".
• പ്രായോഗിക വർഷ കോഴ്സ് "0 മുതൽ PRO വരെയുള്ള PHP ഡവലപ്പർ".

അവലംബം: www.habr.com