Vum Iwwersetzer: publizéiert en Artikel fir Iech , meeschtens ugebueden fir Entwéckler Bewerberinnen während Interviewen. Den Artikel wäert nëtzlech sinn, éischtens, fir Ufänger Programméierer.
Interviewen bei Techfirmen sinn laang d'Gespréich vun der Stad. Dëst sollt net iwwerraschen - erfollegräich duerch en Interview gëtt Iech d'Méiglechkeet eng gutt Aarbecht ze kréien. Mä dëst ass net sou einfach, well komplex Problemer oft geléist musse ginn.
Desweideren, meeschtens, sinn déi meescht vun dësen Aufgaben net mat der Aarbecht Zesummenhang, datt de Kandidatestatus Leeschtunge wäert, mä si mussen nach geléist ginn. Heiansdo musst Dir et um Bord maachen, ouni mat Google oder all aner Quell ze kontrolléieren. Jo, d'Situatioun ännert sech no an no, an e puer Firmen verloossen esou Interviewen, awer vill Patronen halen nach ëmmer un dës Traditioun. Dësen Artikel ass fir d'Analyse vun typesche JavaScript Aufgaben gewidmet, déi dacks als Aufgabe fir Aarbechtssicher benotzt ginn.
Mir erënneren Iech: fir all Habr Lieser - eng Remise vun 10 Rubel wann Dir Iech an all Skillbox Cours aschreift mat dem Habr Promo Code.
Skillbox recommandéiert: Praktesch Cours .
Den Haapt Saach ass fir Ären Interview grëndlech virzebereeden.
Jo, ier mer ufänken d'Aufgaben ze kucken, kucke mer e puer allgemeng Interview Virbereedungstips.
Den Haapt Saach ass am Viraus ze preparéieren. Test wéi gutt Dir Iech Algorithmen an Datestrukturen erënnert, a verbessert Äert Wëssen a Beräicher mat deenen Dir net zevill vertraut sidd. Et gi vill Online Plattformen déi Iech hëllefen Iech op Interviewen virzebereeden. Mir beroden , , и .
Et ass derwäert ze léieren d'Entscheedung haart ze soen. Et ass unzeroden Bewerberinnen ze soen iwwer wat Dir maacht, an net nëmmen op de Bord ze schreiwen (oder Code an de Computer schreiwen, och roueg). Op dës Manéier, wann Dir e Feeler am Code maacht, awer d'Léisung ass allgemeng richteg, kënnt Dir Är Chancen op Erfolleg erhéijen.
Dir musst de Problem verstoen ier Dir ufänkt et ze léisen. A verschiddene Fäll kënnt Dir eng Aufgab iwwerflächlech verstoen an dann de falsche Wee erof goen. Et kann derwäert sinn e puer Erklärungsfroen un den Interviewer ze stellen.
Dir musst üben de Code mat der Hand ze schreiwen, net op engem PC. Et geschitt datt während Interviewen de Bewerber e Marker an e Whiteboard kritt, wou et keng Hiweiser oder automatesch Formatéierung gëtt. Wann Dir no enger Léisung sicht, ass et derwäert Äre Code op e Stéck Pabeier oder direkt op de Bord ze schreiwen. Wann Dir alles am Kapp hält, kënnt Dir eppes Wichtegs vergiessen.
Schabloun Aufgaben am JavaScript
E puer vun dësen Aufgaben sinn Iech wahrscheinlech scho vertraut. Dir hutt entweder Interviewe gemaach wou Dir eppes ähnleches léise musst, oder Dir hutt drop geübt wärend Dir JavaScript léiert. Gutt, elo ass et Zäit se erëm ze léisen, a mat enger detailléierter Erklärung vum Prozess.
Palindrom
E Palindrom ass e Wuert, Saz oder Sequenz vun Zeechen, déi genee d'selwecht gelies gëtt souwuel an der gewéinlecher Richtung an an der Géigendeel Richtung. Zum Beispill, "Anna" ass e Palindrom, awer "Dësch" an "John" sinn net.
Staging
Gitt e String; Dir musst eng Funktioun schreiwen, déi Iech erlaabt richteg zréckzekommen, wann de String e Palindrom ass, a falsch wann net. An dësem Fall musst Dir d'Plazen an d'Punctuatiounszeechen berücksichtegen.
palindrome('racecar') === richteg
palindrome('Table') === falsch
Loosst eis d'Aufgab analyséieren
D'Haaptiddi hei ass d'String ëmgedréint. Wann de "Reverse" String komplett identesch mat der ursprénglecher ass, hu mir e Palindrom kritt an d'Funktioun soll richteg zréckkommen. Wann net, falsch.
Decisioun
Hei ass de Code deen de Palindrom léist.
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('')
}Den éischte Schrëtt ass d'Zeechen an der Input String op kleng Buschtawen ze konvertéieren. Dëst ass eng Garantie datt de Programm d'Charaktere selwer vergläicht, an net Fall oder soss eppes.
Den zweete Schrëtt ass d'Linn ëmgedréint. Dëst ass net schwéier ze maachen: Dir musst et an eng Array konvertéieren mat der .split () Method (String Bibliothéik). Dann ëmgedréint mir d'Array mat .reverse () (Arraybibliothéik). De leschte Schrëtt ass de ëmgedréint Array an eng String ze konvertéieren mat .join () (Array Bibliothéik).
Elo alles wat Dir maache musst ass de "Reverse" String mat der ursprénglecher String ze vergläichen, d'Resultat richteg oder falsch zréckzeginn.
FizzBuzz
Eng vun de beléifsten Aufgaben an Interviewen.
Staging
Dir musst eng Funktioun schreiwen déi d'Zuelen vun 1 bis n op d'Konsole dréckt, wou n eng ganz Zuel ass déi d'Funktioun als Parameter hëlt, mat de folgende Konditiounen:
- Ausgang fizz amplaz Multiple vun 3;
- Ausgangsbuzz amplaz vun Zuelen déi Multiple vu 5 sinn;
- fizzbuzz Output amplaz Zuelen déi Multiple vu béiden 3 a 5 sinn.
Beispill:
Fizzbuzz (5)
Resultat
// 1
// 2
// fesch
// 4
//buzz
Loosst eis d'Aufgab analyséieren
Den Haapt Saach hei ass e Wee fir Multiple mat JavaScript ze fannen. Et kann ëmgesat ginn mam Modulusoperateur oder de Rescht -%, wat Iech erlaabt de Rescht ze weisen wann Dir zwou Zuelen deelt. Wann de Rescht 0 ass, heescht et datt déi éischt Zuel e Multiple vun der zweeter ass.
12% 5 // 2 -> 12 ass net e Multiple vu 5
12% 3 // 0 -> 12 ass Multiple vun 3
Also wann Dir 12 op 5 deelt, kritt Dir 2 mat engem Rescht vun 2. Wann Dir 12 op 3 deelt, kritt Dir 4 mat engem Rescht vun 0. Am éischte Fall ass 12 kee Multiple vu 5, am zweeten , 12 ass e Multiple vun 3.
Decisioun
Déi optimal Léisung wier de folgende Code:
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)
}
}
}D'Funktioun mécht déi néideg Kontrollen mat bedingte Aussoen a produzéiert d'Resultat erfuerdert vum Benotzer. Am Problem ass et derwäert opmierksam ze maachen op d'Uerdnung vun den if...else Aussoen: Start mat enger duebeler Bedingung (&&) a schléisst mam Fall wou méi Zuelen net fonnt goufen. Als Resultat decken mir all Optiounen.
Anagram
Dëst ass den Numm fir e Wuert dat all Buschtawen vun engem anere Wuert an der selwechter Zuel enthält, awer an enger anerer Uerdnung.
Staging
Mir mussen eng Funktioun schreiwen déi iwwerpréift ob zwee Saiten Anagramme sinn, an de Fall ass egal. Nëmmen Zeeche ginn gezielt; Plazen oder Punktuatiounszeechen ginn net berücksichtegt.
anagram('finder', 'Frënd') —> richteg
anagram('hallo', 'bye') —> falsch
Loosst eis d'Aufgab analyséieren
Déi wichteg Saach hei ze berücksichtegen ass datt Dir all Bréif an den zwou Inputlinnen an hir Zuel an all Zeil kontrolléiere musst.
Finder —> f: 1 Frënd —> f: 1
ech: 1r:1
n:1 ech:1
d:1 e:1
e:1 n:1
r:1 d:1
Fir Anagramdaten ze späicheren, sollt Dir eng Struktur wielen wéi e JavaScript Objet wuertwiertlech. De Schlëssel an dësem Fall ass de Charakter vum Bréif, de Wäert ass d'Zuel vu sengen Wiederholungen an der aktueller Linn.
Et ginn aner Konditiounen:
- Dir musst sécher sinn datt de Fall vu Bréiwer net berücksichtegt gëtt wann Dir vergläicht. Mir konvertéieren einfach béid Saiten op kleng oder iewescht Buschtawen.
- Mir ausschléissen all Net-Charaktere vum Verglach. Beschte mat ze schaffen .
Decisioun
// 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
}Opgepasst op d'Benotzung am Snippet uewen. Dës Method gëtt eng Array zréck mat Nimm oder Schlësselen an der selwechter Uerdnung wéi se am Objet erscheinen. An dësem Fall wäert d'Array esou sinn:
['f', 'ech', 'n', 'd', 'e', 'r']
Op dës Manéier kréie mir d'Eegeschafte vum Objet ouni eng bulk Loop ze maachen. An engem Problem kënnt Dir dës Method mat der .length Eegeschafte benotzen fir ze kontrolléieren ob béid Saiten déiselwecht Unzuel vun Zeechen hunn - dat ass eng wichteg Feature vun Anagrammen.
Sich no Vokaler
Eng zimlech einfach Aufgab, déi dacks an Interviewen opkënnt.
Staging
Dir musst eng Funktioun schreiwen déi e String als Argument hëlt an d'Zuel vun de Vokaler zréckginn déi an der String enthale sinn.
D'Vokaler sinn "a", "e", "i", "o", "u".
Beispill:
findVowels('hallo') // —> 2
findVowels('firwat') // —> 0
Decisioun
Hei ass déi einfachst Optioun:
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
}Et ass wichteg oppassen op d'Benotzung vun der .includes () Method. Et ass verfügbar fir béid Strings an Arrays. Et soll benotzt ginn fir ze bestëmmen ob eng Array e bestëmmte Wäert enthält. Dës Method gëtt richteg zréck wann d'Array de spezifizéierte Wäert enthält, a falsch wann et net ass.
Et gëtt eng méi kuerz Léisung fir de Problem:
const findVowels = str => {
const matched = str.match(/[aeiou]/gi)
return matched ? matches.length : 0
}Dëst benotzt der .match () Method, déi erlaabt Iech eng efficace Sich ëmzesetzen. Wann e reegelméissegen Ausdrock als Method Argument bannent der spezifizéierter String fonnt gëtt, dann ass de Retourwäert eng Array vu passenden Zeechen. Ee, wann et keng Mätscher, dann .match () zréck null.
fibonacci
Eng klassesch Aufgab, déi an Interviewen op verschiddenen Niveauen ze fannen ass. Et ass derwäert ze erënneren datt d'Fibonacci Sequenz eng Serie vun Zuelen ass, wou all spéider d'Zomm vun deenen zwee virdrun ass. Also, déi éischt zéng Zuelen kucken esou aus: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34.
Staging
Dir musst eng Funktioun schreiwen déi den n.e Rekord an enger bestëmmter Sequenz zréckginn, mat n ass d'Zuel déi als Argument un d'Funktioun weidergeleet gëtt.
fibonacci(3) // —> 2
Dës Aufgab beinhalt d'Zuel vun den Zäiten, déi am Argument spezifizéiert sinn, duerch eng Loop ze goen, de Wäert op déi entspriechend Positioun zréckzeginn. Dës Manéier fir de Problem ze stellen erfuerdert d'Benotzung vu Schleifen. Wann Dir amplaz Rekursioun benotzt, kann et den Interviewer gefalen an Iech e puer extra Punkte ginn.
Decisioun
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]
}Am Resultater Array sinn déi éischt zwou Zuelen an der Serie enthale well all Entrée an der Sequenz d'Zomm vun den zwou virdrun Zuelen ass. Am Ufank ginn et keng zwou Zuelen, déi geholl kënne ginn fir déi nächst Nummer ze kréien, sou datt d'Loop se net automatesch generéiere kann. Awer, wéi mir wëssen, sinn déi éischt zwou Zuelen ëmmer 0 an 1. Dofir kënnt Dir d'Resultater Array manuell initialiséieren.
Wat d'Rekursioun ugeet, ass alles méi einfach a méi komplizéiert zur selwechter Zäit:
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)
}Mir ruffen weider fibonacci (), weider méi kleng a méi kleng Zuelen als Argumenter. Mir stoppen wann dat passéiert Argument 0 oder 1 ass.
Konklusioun
Wahrscheinlech hutt Dir schonn eng vun dësen Aufgaben begéint wann Dir fir e Frontend oder JavaScript Entwéckler Job interviewt gouf (besonnesch wann et um Juniorniveau ass). Awer wann Dir se net begéint hutt, kënne se an Zukunft nëtzlech sinn - op d'mannst fir allgemeng Entwécklung.
Skillbox recommandéiert:
- Applizéiert online Course .
- Online Cours .
- Praktesch ee Joer Cours .
Source: will.com