Fan de oersetter: publisearre in artikel foar jo , meastentiids oanbean oan ûntwikkelders oanfregers tidens ynterviews. It artikel sil nuttich wêze, earst fan alles, foar begjinnende programmeurs.
Ynterviews by techbedriuwen binne al lang it praat fan 'e stêd. Dit soe net ferrassend wêze moatte - it suksesfolle trochjaan fan in ynterview jout jo de kâns om in goede baan te krijen. Mar dit is net sa ienfâldich, om't komplekse problemen faak moatte wurde oplost.
Boppedat binne de measte fan dizze taken net relatearre oan it wurk dat de oanfreger sil útfiere, mar se moatte noch oplost wurde. Soms moatte jo it op it boerd dwaan, sûnder te kontrolearjen mei Google of in oare boarne. Ja, de situaasje feroaret stadichoan, en guon bedriuwen ferlitte sokke ynterviews, mar in protte wurkjouwers hâlde noch oan dizze tradysje. Dit artikel is wijd oan 'e analyze fan typyske JavaScript-taken dy't faak wurde brûkt as taken foar wurksykjenden.
Wy herinnerje: foar alle lêzers fan "Habr" - in koarting fan 10 roebel by it ynskriuwen fan in Skillbox-kursus mei de promoasjekoade "Habr".
Skillbox advisearret: Praktyske kursus .
It wichtichste is om jo yngeand tariede op jo ynterview.
Ja, foardat wy nei de taken begjinne te sjen, litte wy nei guon algemiene tips foar tarieding foar ynterviews sjen.
It wichtichste is om fan tefoaren te meitsjen. Test hoe goed jo algoritmen en gegevensstruktueren ûnthâlde, en ferbetterje jo kennis yn gebieten dêr't jo net al te bekend mei binne. D'r binne in protte online platfoarms dy't jo kinne helpe tariede op ynterviews. Wy advisearje , , и .
It is it wurdich te learen om it beslút lûdop te sizzen. It is oan te rieden om oanfregers te fertellen oer wat jo dogge, en net allinich op it boerd te skriuwen (of koade yn te typen yn 'e kompjûter, ek stil). Op dizze manier, as jo in flater meitsje yn 'e koade, mar de oplossing is oer it generaal korrekt, kinne jo jo kânsen op súkses ferheegje.
Jo moatte it probleem begripe foardat jo begjinne om it op te lossen. Yn guon gefallen kinne jo in taak oerflakkich begripe en dan it ferkearde paad delgean. It kin de muoite wurdich wêze om in pear ferdúdlikjende fragen te stellen oan 'e ynterviner.
Jo moatte oefenje mei it skriuwen fan koade mei de hân, net op in PC. It bart dat by ynterviews de oanfreger in marker en in whiteboard krijt, wêr't gjin hints of automatyske opmaak binne. As jo nei in oplossing sykje, is it de muoite wurdich om jo koade op in stik papier of direkt op it boerd te skriuwen. As jo alles yn 'e holle hâlde, kinne jo wat wichtichs ferjitte.
Template taken yn JavaSkript
Guon fan dizze taken binne jo wierskynlik al bekend. Jo hawwe of ynterviews hân wêr't jo wat ferlykbers moatte oplosse, of jo hawwe oefene by it learen fan JavaScript. No, no is it tiid om se wer op te lossen, en mei in detaillearre útlis fan it proses.
Palindroom
In palindroom is in wurd, sin of opienfolging fan tekens dy't krekt itselde lêzen wurdt sawol yn 'e gewoane rjochting as yn 'e tsjinoerstelde rjochting. Bygelyks, "Anna" is in palindroom, mar "tafel" en "John" binne net.
Staging
In string jûn; jo moatte skriuwe in funksje wêrmei jo werom te jaan wier as de tekenrige is in palindroom, en falsk as net. Yn dit gefal moatte jo rekken hâlde mei spaasjes en ynterpunksjes.
palindrome('racecar') === wier
palindrome('tabel') === falsk
Litte wy de taak analysearje
It wichtichste idee hjir is om de snaar omkeare. As de "omkearde" string folslein identyk is oan 'e oarspronklike, dan hawwe wy in palindroom krigen en de funksje moat wier weromkomme. As net, falsk.
beslút
Hjir is de koade dy't it palindroom oplost.
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('')
}De earste stap is om de tekens yn 'e ynfierstring te konvertearjen nei lytse letters. Dit is in garânsje dat it programma sil ferlykje de karakters sels, en net gefal of wat oars.
De twadde stap is om de line te kearen. Dit is net dreech te dwaan: jo moatte it omsette yn in array mei de .split() metoade (String bibleteek). Dan wy keare de rige mei help .reverse () (Array bibleteek). De lêste stap is in omsette de omkearde array nei in tekenrige mei .join () (Array bibleteek).
No alles wat jo hoege te dwaan is de "omkearde" tekenrige te fergelykjen mei de orizjinele tekenrige, it resultaat wier of falsk werom te jaan.
FizzBuzz
Ien fan 'e populêrste taken yn ynterviews.
Staging
Jo moatte in funksje skriuwe dy't nûmers fan 1 oant n printet nei de konsole, wêrby't n in hiel getal is dat de funksje as parameter nimt, mei de folgjende betingsten:
- útfier fizz ynstee fan multiples fan 3;
- útfier buzz ynstee fan nûmers dy't multiples fan 5;
- fizzbuzz-útfier ynstee fan nûmers dy't multiples binne fan sawol 3 as 5.
Foarbyld:
Fizzbuzz (5)
resultaat
// 1
// 2
// fûgel
// 4
//buzz
Litte wy de taak analysearje
It wichtichste ding hjir is in manier om multiples te finen mei JavaScript. It kin ymplementearre wurde mei de modulusoperator of de rest - %, wêrtroch jo de rest sjen kinne by it dielen fan twa nûmers. As de rest 0 is, betsjut it dat it earste getal in mearfâld is fan it twadde.
12% 5 // 2 -> 12 is gjin mearfâldichheid fan 5
12% 3 // 0 -> 12 is meardere fan 3
Dus, as jo diele 12 troch 5, krije jo 2 mei in rest fan 2. As jo diele 12 troch 3, krije jo 4 mei in rest fan 0. Yn it earste gefal is 12 gjin mearfâld fan 5, yn it twadde , 12 is in mearfâld fan 3.
beslút
De optimale oplossing soe de folgjende koade wêze:
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)
}
}
}De funksje fiert de nedige kontrôles út mei betingsten útspraken en produseart it resultaat dat nedich is troch de brûker. Yn it probleem is it wurdich omtinken te jaan oan de folchoarder fan de if...else-útspraken: begjinne mei in dûbele betingst (&&) en einigje mei it gefal dêr't meardere nûmers net fûn wurde koenen. As gefolch, wy dekke alle opsjes.
Anagram
Dit is de namme foar in wurd dat alle letters fan in oar wurd yn itselde nûmer befettet, mar yn in oare folchoarder.
Staging
Wy moatte in funksje skriuwe dy't kontrolearret oft twa snaren anagrammen binne, en de saak makket neat út. Allinnich karakters wurde teld; spaasjes of ynterpunksjes wurde net yn rekken brocht.
anagram('finder', 'freon') —> wier
anagram('hallo', 'bye') —> false
Litte wy de taak analysearje
It wichtige ding om hjir te beskôgjen is dat jo elke letter yn 'e twa ynfierrigels moatte kontrolearje en har nûmer yn elke rigel.
finder —> f: 1 freon —> f: 1
ik:1 r:1
n:1 yn:1
d:1 e:1
e:1 n:1
r:1 d:1
Om anagramgegevens op te slaan, moatte jo in struktuer kieze lykas in letterlik JavaScript-objekt. De kaai yn dit gefal is it karakter fan 'e brief, de wearde is it oantal werhellingen yn' e hjoeddeistige line.
Der binne oare betingsten:
- Jo moatte derfoar soargje dat it gefal fan brieven net yn rekken brocht wurdt by it fergelykjen. Wy konvertearje gewoan beide snaren nei lytse of haadletters.
- Wy slúte alle net-karakters út fan 'e fergeliking. Bêste om mei te wurkjen .
beslút
// 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
}Soarch omtinken foar it gebrûk yn it snippet hjirboppe. Dizze metoade jout in array werom mei nammen of kaaien yn deselde folchoarder dat se yn it objekt ferskine. Yn dit gefal sil de array sa wêze:
['f', 'ik', 'n', 'd', 'e', 'r']
Op dizze manier krije wy de eigenskippen fan it objekt sûnder in bulk loop te dwaan. Yn in probleem kinne jo dizze metoade brûke mei de eigenskip .length om te kontrolearjen oft beide stringen itselde oantal tekens hawwe - dit is in wichtich skaaimerk fan anagrammen.
Sykje foar lûden
In frij simpele taak dy't faak komt yn ynterviews.
Staging
Jo moatte in funksje skriuwe dy't in tekenrige as argumint nimt en it oantal lûden werombringt dat yn 'e tekenrige sit.
De lûden binne "a", "e", "i", "o", "u".
Foarbyld:
findVwels('hello') // —> 2
findVwels('wêrom') // —> 0
beslút
Hjir is de ienfâldichste opsje:
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
}It is wichtich om omtinken te jaan oan it brûken fan de metoade .includes (). It is beskikber foar sawol snaren as arrays. It moat brûkt wurde om te bepalen oft in array in bepaalde wearde befettet. Dizze metoade jout wier as de array de oantsjutte wearde befettet, en falsk as it net docht.
D'r is in koartere oplossing foar it probleem:
const findVowels = str => {
const matched = str.match(/[aeiou]/gi)
return matched ? matches.length : 0
}Dit brûkt de metoade .match(), wêrmei jo in effisjint sykjen útfiere kinne. As in reguliere ekspresje as metoade argumint wurdt fûn binnen de opjûne tekenrige, dan is de weromkommende wearde in array fan oerienkommende karakters. No, as der gjin wedstriden binne, dan jout .match () nul.
fibonacci
In klassike taak dy't te finen is yn ynterviews op ferskate nivo's. It is it wurdich te ûnthâlden dat de Fibonacci-sekwinsje in searje nûmers is wêrby't elke folgjende de som fan 'e foarige twa is. Dus, de earste tsien nûmers sjogge der sa út: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34.
Staging
Jo moatte in funksje skriuwe dy't it n-de rekord yn in bepaalde folchoarder werombringt, wêrby't n it nûmer is dat as argumint foar de funksje trochjûn wurdt.
fibonacci(3) // —> 2
Dizze taak omfiemet in kuier troch in lus it oantal kearen oantsjutte yn it argumint, werom de wearde op de passende posysje. Dizze manier om it probleem te stellen fereasket it gebrûk fan loops. As jo ynstee rekursje brûke, kin it de ynterviewer behaagje en jo in pear ekstra punten jaan.
beslút
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]
}Yn de resultaten array binne de earste twa nûmers befette yn 'e searje, om't elke yngong yn' e folchoarder de som is fan 'e foarige twa nûmers. Oan it begjin binne d'r gjin twa nûmers dy't kinne wurde nommen om it folgjende nûmer te krijen, sadat de lus se net automatysk kin generearje. Mar, sa't wy witte, de earste twa nûmers binne altyd 0 en 1. Dêrom kinne jo inisjalisearje de resultaten array mei de hân.
Wat rekurzje oanbelanget, is alles tagelyk ienfâldiger en komplisearre:
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)
}Wy bliuwe ropt fibonacci (), trochjaan lytsere en lytsere nûmers as arguminten. Wy stopje as it trochjûn argumint 0 of 1 is.
konklúzje
Meast wierskynlik hawwe jo ien fan dizze taken al tsjinkaam as jo binne ynterviewd foar in frontend- of JavaScript-ûntwikkeldersbaan (benammen as it op it juniornivo is). Mar as jo se net binne tsjinkaam, kinne se yn 'e takomst nuttich wêze - teminsten foar algemiene ûntwikkeling.
Skillbox advisearret:
- Oanfrege online kursus .
- Online kursus .
- Praktyske jierkursus .
Boarne: www.habr.com