Mula sa tagasalin: naglathala ng artikulo para sa iyo , kadalasang iniaalok sa mga aplikante ng developer sa panahon ng mga panayam. Ang artikulo ay magiging kapaki-pakinabang, una sa lahat, sa mga baguhan na programmer.
Ang mga panayam sa mga kumpanya ng teknolohiya ay matagal nang pinag-uusapan. Hindi ito dapat nakakagulat - ang matagumpay na pagpasa sa isang panayam ay nagbibigay sa iyo ng pagkakataong makakuha ng magandang trabaho. Ngunit ito ay hindi gaanong simple, dahil ang mga kumplikadong problema ay madalas na kailangang malutas.
Bukod dito, kadalasan, karamihan sa mga gawaing ito ay hindi nauugnay sa trabaho na gagawin ng aplikante, ngunit kailangan pa rin nilang lutasin. Minsan kailangan mong gawin ito sa board, nang hindi nagsusuri sa Google o anumang iba pang pinagmulan. Oo, ang sitwasyon ay unti-unting nagbabago, at ang ilang mga kumpanya ay nag-abandona sa gayong mga panayam, ngunit maraming mga tagapag-empleyo ay sumusunod pa rin sa tradisyong ito. Ang artikulong ito ay nakatuon sa pagsusuri ng mga karaniwang gawain sa JavaScript na kadalasang ginagamit bilang mga gawain para sa mga naghahanap ng trabaho.
Pinapaalala namin sa iyo: para sa lahat ng mga mambabasa ng "Habr" - isang diskwento na 10 rubles kapag nag-enroll sa anumang kurso sa Skillbox gamit ang code na pang-promosyon ng "Habr".
Inirerekomenda ng Skillbox ang: Praktikal na kurso .
Ang pangunahing bagay ay maghanda nang husto para sa iyong pakikipanayam.
Oo, bago natin simulan ang pagtingin sa mga gawain, tingnan natin ang ilang pangkalahatang mga tip sa paghahanda ng panayam.
Ang pangunahing bagay ay upang maghanda nang maaga. Subukan kung gaano mo kahusay na naaalala ang mga algorithm at istruktura ng data, at pagbutihin ang iyong kaalaman sa mga lugar na hindi mo masyadong pamilyar. Mayroong maraming mga online na platform na makakatulong sa iyong maghanda para sa mga panayam. Payo namin , , и .
Ito ay nagkakahalaga ng pag-aaral na sabihin ang desisyon nang malakas. Maipapayo na sabihin sa mga aplikante ang tungkol sa iyong ginagawa, at hindi lamang isulat sa pisara (o i-type ang code sa computer, tahimik din). Sa ganitong paraan, kung nagkamali ka sa code, ngunit sa pangkalahatan ay tama ang solusyon, maaari mong dagdagan ang iyong mga pagkakataong magtagumpay.
Kailangan mong maunawaan ang problema bago mo simulan ang paglutas nito. Sa ilang mga kaso, maaari mong maunawaan ang isang gawain nang mababaw at pagkatapos ay pumunta sa maling landas. Maaaring sulit na magtanong ng ilang mga katanungan sa paglilinaw sa tagapanayam.
Kailangan mong magsanay sa pagsulat ng code sa pamamagitan ng kamay, hindi sa PC. Nangyayari na sa panahon ng mga panayam ang aplikante ay binibigyan ng isang marker at isang whiteboard, kung saan walang mga pahiwatig o awtomatikong pag-format. Kapag naghahanap ng solusyon, sulit na isulat ang iyong code sa isang piraso ng papel o direkta sa pisara. Kung itatago mo ang lahat sa iyong ulo, maaaring makakalimutan mo ang isang bagay na mahalaga.
Mga gawain sa template sa JavaScript
Ang ilan sa mga gawaing ito ay malamang na pamilyar sa iyo. Nagkaroon ka ng mga panayam kung saan kailangan mong lutasin ang isang katulad na bagay, o magsanay sa mga ito habang nag-aaral ng JavaScript. Buweno, ngayon ay oras na upang malutas ang mga ito muli, at may isang detalyadong paliwanag ng proseso.
Palindrome
Ang palindrome ay isang salita, pangungusap o pagkakasunud-sunod ng mga character na binasa nang eksakto pareho sa karaniwang direksyon at sa kabilang direksyon. Halimbawa, ang "Anna" ay isang palindrome, ngunit ang "talahanayan" at "John" ay hindi.
Staging
Binigyan ng string; kailangan mong magsulat ng isang function na nagbibigay-daan sa iyong ibalik ang true kung ang string ay isang palindrome, at false kung hindi. Sa kasong ito, kailangan mong isaalang-alang ang mga puwang at mga bantas.
palindrome('karera') === totoo
palindrome('table') === false
Suriin natin ang gawain
Ang pangunahing ideya dito ay upang baligtarin ang string. Kung ang "reverse" na string ay ganap na magkapareho sa orihinal, pagkatapos ay nakatanggap kami ng palindrome at ang function ay dapat na bumalik na totoo. Kung hindi, mali.
desisyon
Narito ang code na lumulutas sa palindrome.
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('')
}Ang unang hakbang ay i-convert ang mga character sa input string sa lower case. Ito ay isang garantiya na ang programa ay ihahambing ang mga character sa kanilang sarili, at hindi kaso o anumang bagay.
Ang pangalawang hakbang ay upang baligtarin ang linya. Hindi ito mahirap gawin: kailangan mong i-convert ito sa isang array gamit ang .split() method (String library). Pagkatapos ay binabaligtad namin ang array gamit ang .reverse() (Array library). Ang huling hakbang ay i-convert ang reverse array sa isang string gamit ang .join() (Array library).
Ngayon ang kailangan mo lang gawin ay ihambing ang "reverse" na string sa orihinal na string, ibabalik ang resulta na totoo o mali.
FizzBuzz
Isa sa mga pinakasikat na gawain sa mga panayam.
Staging
Kailangan mong magsulat ng function na nagpi-print ng mga numero mula 1 hanggang n papunta sa console, kung saan ang n ay isang integer na kinukuha ng function bilang parameter, na may mga sumusunod na kundisyon:
- output fizz sa halip na multiple ng 3;
- output buzz sa halip na mga numero na multiple ng 5;
- fizzbuzz na output sa halip na mga numero na multiple ng parehong 3 at 5.
Halimbawa
Fizzbuzz(5)
Resulta
// 1
// 2
// fizz
// 4
//buzz
Suriin natin ang gawain
Ang pangunahing bagay dito ay isang paraan upang makahanap ng maramihang gamit ang JavaScript. Maaari itong ipatupad gamit ang modulus operator o ang natitira - %, na nagpapahintulot sa iyo na ipakita ang natitira kapag hinahati ang dalawang numero. Kung ang natitira ay 0, nangangahulugan ito na ang unang numero ay isang multiple ng pangalawa.
Ang 12% 5 // 2 -> 12 ay hindi multiple ng 5
Ang 12% 3 // 0 -> 12 ay multiple ng 3
Kaya, kung hahatiin mo ang 12 sa 5, makakakuha ka ng 2 na may natitirang 2. Kung hahatiin mo ang 12 sa 3, makakakuha ka ng 4 na may natitirang 0. Sa unang kaso, ang 12 ay hindi multiple ng 5, sa pangalawa. Ang , 12 ay isang multiple ng 3.
desisyon
Ang pinakamainam na solusyon ay ang sumusunod na 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)
}
}
}Ang function ay nagsasagawa ng mga kinakailangang pagsusuri gamit ang mga conditional statement at gumagawa ng resulta na kinakailangan ng user. Sa problema, ito ay nagkakahalaga ng pagbibigay pansin sa pagkakasunud-sunod ng kung...ibang mga pahayag: magsimula sa isang dobleng kundisyon (&&) at magtatapos sa kaso kung saan ang maraming numero ay hindi mahanap. Bilang resulta, saklaw namin ang lahat ng mga opsyon.
Anagram
Ito ang pangalan para sa isang salita na naglalaman ng lahat ng mga titik ng isa pang salita sa parehong numero, ngunit sa ibang pagkakasunud-sunod.
Staging
Kailangan nating magsulat ng isang function na nagsusuri kung ang dalawang string ay mga anagram, at ang kaso ay hindi mahalaga. Tanging mga character ang binibilang; hindi isinasaalang-alang ang mga puwang o mga bantas.
anagram('finder', 'Friend') -> totoo
anagram('hello', 'bye') -> false
Suriin natin ang gawain
Ang mahalagang bagay na dapat isaalang-alang dito ay kailangan mong suriin ang bawat titik sa dalawang linya ng input at ang kanilang numero sa bawat linya.
finder —> f: 1 kaibigan —> f: 1
ako: 1 r: 1
n: 1 ako: 1
d: 1 e: 1
e: 1 n: 1
r: 1 d: 1
Upang mag-imbak ng data ng anagram, dapat kang pumili ng istraktura tulad ng literal na object ng JavaScript. Ang susi sa kasong ito ay ang karakter ng liham, ang halaga ay ang bilang ng mga pag-uulit nito sa kasalukuyang linya.
Mayroong iba pang mga kondisyon:
- Kailangan mong tiyakin na ang kaso ng mga titik ay hindi isinasaalang-alang kapag naghahambing. I-convert lang namin ang parehong mga string sa lower o upper case.
- Ibinubukod namin ang lahat ng hindi character mula sa paghahambing. Pinakamabuting makatrabaho .
desisyon
// 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
}Bigyang-pansin ang paggamit sa snippet sa itaas. Ang pamamaraang ito ay nagbabalik ng isang array na naglalaman ng mga pangalan o key sa parehong pagkakasunud-sunod na lumilitaw ang mga ito sa object. Sa kasong ito, ang array ay magiging ganito:
['f', 'i', 'n', 'd', 'e', r']
Sa ganitong paraan makukuha natin ang mga katangian ng bagay nang hindi kinakailangang gumawa ng bulk loop. Sa isang problema, maaari mong gamitin ang paraang ito sa property na .length upang suriin kung ang parehong mga string ay may parehong bilang ng mga character - ito ay isang mahalagang tampok ng mga anagram.
Maghanap ng mga patinig
Isang medyo simpleng gawain na madalas lumalabas sa mga panayam.
Staging
Kailangan mong magsulat ng isang function na kumukuha ng string bilang argumento at ibabalik ang bilang ng mga patinig na nakapaloob sa string.
Ang mga patinig ay “a”, “e”, “i”, “o”, “u”.
Halimbawa:
findVowels('hello') // —> 2
findVowels('why') // —> 0
desisyon
Narito ang pinakasimpleng opsyon:
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
}Mahalagang bigyang pansin ang paggamit ng .includes() na pamamaraan. Ito ay magagamit para sa parehong mga string at array. Dapat itong gamitin upang matukoy kung ang isang array ay naglalaman ng isang tiyak na halaga. Ang pamamaraang ito ay nagbabalik ng true kung ang array ay naglalaman ng tinukoy na halaga, at mali kung hindi.
Mayroong mas maikling solusyon sa problema:
const findVowels = str => {
const matched = str.match(/[aeiou]/gi)
return matched ? matches.length : 0
}Gumagamit ito ng .match() na paraan, na nagbibigay-daan sa iyong magpatupad ng mahusay na paghahanap. Kung ang isang regular na expression bilang argumento ng pamamaraan ay matatagpuan sa loob ng tinukoy na string, kung gayon ang return value ay isang hanay ng mga tumutugmang character. Well, kung walang mga tugma, ang .match() ay nagbabalik ng null.
Fibonacci
Isang klasikong gawain na makikita sa mga panayam sa iba't ibang antas. Ito ay nagkakahalaga ng paggunita na ang Fibonacci sequence ay isang serye ng mga numero kung saan ang bawat kasunod ay ang kabuuan ng naunang dalawa. Kaya, ang unang sampung numero ay ganito ang hitsura: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34.
Staging
Kailangan mong magsulat ng isang function na nagbabalik ng nth record sa isang tiyak na pagkakasunud-sunod, na ang n ay ang numero na ipinasa bilang argumento sa function.
fibonacci(3) // —> 2
Ang gawaing ito ay nagsasangkot ng paglalakad sa isang loop sa dami ng beses na tinukoy sa argumento, ibinabalik ang halaga sa naaangkop na posisyon. Ang ganitong paraan ng paglalagay ng problema ay nangangailangan ng paggamit ng mga loop. Kung gagamit ka sa halip ng recursion, maaaring masiyahan ang tagapanayam at bigyan ka ng ilang karagdagang puntos.
desisyon
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]
}Sa hanay ng mga resulta, ang unang dalawang numero ay nakapaloob sa serye dahil ang bawat entry sa sequence ay ang kabuuan ng nakaraang dalawang numero. Sa pinakadulo simula walang dalawang numero na maaaring kunin upang makuha ang susunod na numero, kaya ang loop ay hindi maaaring awtomatikong bumuo ng mga ito. Ngunit, tulad ng alam natin, ang unang dalawang numero ay palaging 0 at 1. Samakatuwid, maaari mong manual na simulan ang hanay ng mga resulta.
Tulad ng para sa recursion, ang lahat ay mas simple at mas kumplikado sa parehong oras:
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)
}Patuloy naming tinatawag ang fibonacci(), na nagpapasa ng mas maliit at mas maliliit na numero bilang mga argumento. Huminto kami kapag ang naipasa na argumento ay 0 o 1.
Pagbubuhos
Malamang, naranasan mo na ang alinman sa mga gawaing ito kung nainterbyu ka para sa isang frontend o JavaScript developer job (lalo na kung ito ay nasa junior level). Ngunit kung hindi mo pa nakikita ang mga ito, maaaring maging kapaki-pakinabang ang mga ito sa hinaharap - hindi bababa sa para sa pangkalahatang pag-unlad.
Inirerekomenda ng Skillbox ang:
- Nag-apply online na kurso .
- Online na kurso .
- Praktikal na kurso sa taon .
Pinagmulan: www.habr.com