5 ტიპიური JavaScript ინტერვიუს ამოცანა: ანალიზი და გადაწყვეტილებები

მთარგმნელისგან: გამოაქვეყნა სტატია თქვენთვის მარია ანტონიეტა პერნა, რომელიც საუბრობს საერთო JavaScript ამოცანების შესახებ, ყველაზე ხშირად სთავაზობენ დეველოპერის განმცხადებლებს გასაუბრების დროს. სტატია სასარგებლო იქნება, პირველ რიგში, დამწყები პროგრამისტებისთვის.

ტექნოლოგიურ კომპანიებში ინტერვიუები დიდი ხანია აქტუალურია. ეს გასაკვირი არ უნდა იყოს - ინტერვიუს წარმატებით ჩაბარება გაძლევთ შესაძლებლობას მიიღოთ კარგი სამუშაო. მაგრამ ეს არც ისე მარტივია, რადგან რთული პრობლემების გადაჭრა ხშირად საჭიროა.

უფრო მეტიც, ყველაზე ხშირად, ამ ამოცანების უმეტესობა არ არის დაკავშირებული იმ სამუშაოსთან, რომელსაც განმცხადებელი შეასრულებს, მაგრამ ისინი მაინც უნდა გადაჭრას. ზოგჯერ თქვენ უნდა გააკეთოთ ეს დაფაზე, Google-თან ან სხვა წყაროსთან შემოწმების გარეშე. დიახ, ვითარება თანდათან იცვლება და ზოგიერთი კომპანია ტოვებს ასეთ ინტერვიუებს, მაგრამ ბევრი დამსაქმებელი მაინც იცავს ამ ტრადიციას. ეს სტატია ეძღვნება ტიპიური JavaScript ამოცანების ანალიზს, რომლებიც ხშირად გამოიყენება სამუშაოს მაძიებელთათვის.

შეგახსენებთ: "Habr"-ის ყველა მკითხველისთვის - ფასდაკლება 10 რუბლიდან Skillbox-ის ნებისმიერ კურსზე ჩარიცხვისას "Habr" სარეკლამო კოდის გამოყენებით.

Skillbox გირჩევთ: პრაქტიკული კურსი "Mobile Developer PRO".

მთავარია საფუძვლიანად მოემზადოთ თქვენი ინტერვიუსთვის.

დიახ, სანამ ამოცანების შესწავლას დავიწყებთ, მოდით გადავხედოთ ინტერვიუს მომზადების ზოგად რჩევას.

მთავარია წინასწარ მოემზადოთ. შეამოწმეთ რამდენად კარგად გახსოვთ ალგორითმები და მონაცემთა სტრუქტურები და გააუმჯობესეთ თქვენი ცოდნა იმ სფეროებში, რომლებსაც არც თუ ისე კარგად იცნობთ. არსებობს მრავალი ონლაინ პლატფორმა, რომელიც დაგეხმარებათ მოემზადოთ ინტერვიუებისთვის. ჩვენ ვურჩევთ geeksforgeeks, პრამპი, ინტერვიუ.io и CodeSignal.

ღირს ვისწავლოთ გადაწყვეტილების ხმამაღლა თქმა. მიზანშეწონილია აცნობოთ განმცხადებლებს იმის შესახებ, რასაც აკეთებთ და არა მხოლოდ დაფაზე დაწეროთ (ან ჩაწერეთ კოდი კომპიუტერში, ასევე ჩუმად). ამ გზით, თუ კოდში შეცდომას უშვებთ, მაგრამ გამოსავალი ზოგადად სწორია, შეგიძლიათ გაზარდოთ წარმატების შანსები.

პრობლემის გადაჭრამდე უნდა გაიგოთ. ზოგიერთ შემთხვევაში, თქვენ შეიძლება ზედაპირულად გაიგოთ დავალება და შემდეგ არასწორი გზით წახვიდეთ. შესაძლოა ღირდეს ინტერვიუერისთვის რამდენიმე დამაზუსტებელი კითხვის დასმა.

თქვენ უნდა ივარჯიშოთ კოდის დაწერა ხელით და არა კომპიუტერზე. ხდება ისე, რომ გასაუბრების დროს განმცხადებელს ეძლევა მარკერი და დაფა, სადაც არ არის მინიშნებები ან ავტომატური ფორმატირება. გამოსავლის ძიებისას, ღირს თქვენი კოდის ჩაწერა ფურცელზე ან პირდაპირ დაფაზე. თუ ყველაფერს თავში ინახავ, შეიძლება რაღაც მნიშვნელოვანი დაგავიწყდეს.

შაბლონური ამოცანები JavaScript-ში

ამ ამოცანების ზოგიერთი ნაწილი ალბათ უკვე ნაცნობია თქვენთვის. თქვენ ან გქონდათ ინტერვიუები, სადაც მსგავსი რამის ამოხსნა მოგიწიათ, ან ივარჯიშეთ მათზე JavaScript-ის სწავლისას. კარგად, ახლა დროა მათი გადაჭრა ისევ და პროცესის დეტალური ახსნით.

პალინდრომი

პალინდრომი არის სიტყვა, წინადადება ან სიმბოლოთა თანმიმდევრობა, რომელიც იკითხება ზუსტად ერთნაირად როგორც ჩვეულებრივი, ასევე საპირისპირო მიმართულებით. მაგალითად, "ანა" არის პალინდრომი, მაგრამ "მაგიდა" და "ჯონი" არა.

წარმოება

მოცემულია სტრიქონი; თქვენ უნდა დაწეროთ ფუნქცია, რომელიც საშუალებას მოგცემთ დააბრუნოთ true, თუ სტრიქონი არის პალინდრომი, და false თუ არა. ამ შემთხვევაში, თქვენ უნდა გაითვალისწინოთ სივრცეები და პუნქტუაციის ნიშნები.

palindrome ('racecar') === true
palindrome('table') === false

გავაანალიზოთ დავალება

აქ მთავარი იდეა არის სტრიქონის შებრუნება. თუ „უკუ“ სტრიქონი მთლიანად ორიგინალის იდენტურია, მაშინ ჩვენ მივიღეთ პალინდრომი და ფუნქცია უნდა დაბრუნდეს true. თუ არა, ცრუ.

გადაწყვეტილება

აქ არის კოდი, რომელიც ხსნის პალინდრომს.

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() მეთოდის გამოყენებით (String library). შემდეგ ჩვენ ვაბრუნებთ მასივს .reverse() (Array library) გამოყენებით. ბოლო ნაბიჯი არის საპირისპირო მასივის სტრინგად გადაქცევა .join() (Array ბიბლიოთეკა) გამოყენებით.

ახლა ყველაფერი რაც თქვენ უნდა გააკეთოთ არის შეადაროთ "უკუ" სტრიქონი თავდაპირველ სტრიქონს, დააბრუნოთ შედეგი true ან false.

FizzBuzz

ერთ-ერთი ყველაზე პოპულარული ამოცანა ინტერვიუებში.

წარმოება

თქვენ უნდა დაწეროთ ფუნქცია, რომელიც ბეჭდავს ციფრებს 1-დან n-მდე კონსოლში, სადაც n არის მთელი რიცხვი, რომელსაც ფუნქცია იღებს პარამეტრად, შემდეგი პირობებით:

• გამომავალი fizz ნაცვლად 3-ის ჯერადი;
• 5-ის ჯერადი რიცხვების ნაცვლად გამომავალი ხმაური;
• fizzbuzz გამოაქვს 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 დებულებების თანმიმდევრობას: დაიწყეთ ორმაგი პირობით (&&) და დაასრულეთ იმ შემთხვევით, როდესაც მრავალი რიცხვი ვერ მოიძებნა. შედეგად, ჩვენ ვფარავთ ყველა ვარიანტს.

ანაგრამა

ეს არის სიტყვის სახელი, რომელიც შეიცავს სხვა სიტყვის ყველა ასოს იმავე რიცხვში, მაგრამ განსხვავებული თანმიმდევრობით.

წარმოება

ჩვენ უნდა დავწეროთ ფუნქცია, რომელიც ამოწმებს არის თუ არა ორი სტრიქონი ანაგრამა, და საქმეს მნიშვნელობა არ აქვს. დათვლილია მხოლოდ სიმბოლოები; სივრცეები ან პუნქტუაციის ნიშნები არ არის გათვალისწინებული.

ანაგრამა ('მაპოვებელი', 'მეგობარი') —> მართალია
anagram('გამარჯობა', 'მშვიდობით') —> false

გავაანალიზოთ დავალება

აქ გასათვალისწინებელია ის, რომ თქვენ უნდა შეამოწმოთ თითოეული ასო შეყვანის ორ ხაზში და მათი რიცხვი თითოეულ სტრიქონში.

მპოვნელი —> f: 1 მეგობარი —> f: 1
მე: 1 r: 1
n: 1 მე: 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 თვისებით, რათა შეამოწმოთ აქვს თუ არა ორივე სტრიქონს ერთნაირი რაოდენობის სიმბოლო - ეს ანაგრამების მნიშვნელოვანი მახასიათებელია.

ხმოვანთა ძიება

საკმაოდ მარტივი ამოცანა, რომელიც ხშირად ჩნდება ინტერვიუებში.

წარმოება

თქვენ უნდა დაწეროთ ფუნქცია, რომელიც იღებს სტრიქონს არგუმენტად და აბრუნებს ხმოვანთა რაოდენობას, რომლებიც შეიცავს სტრიქონს.
ხმოვნები არის "ა", "ე", "ი", "ო", "უ".

მაგალითი:

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() მეთოდის გამოყენებას. ის ხელმისაწვდომია როგორც სტრიქონებისთვის, ასევე მასივებისთვის. ის უნდა იქნას გამოყენებული იმის დასადგენად, შეიცავს თუ არა მასივი გარკვეულ მნიშვნელობას. ეს მეთოდი აბრუნებს true-ს, თუ მასივი შეიცავს მითითებულ მნიშვნელობას და false-ს, თუ ის არ შეიცავს.

პრობლემის უფრო მოკლე გამოსავალი არსებობს:

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

ეს იყენებს .match() მეთოდს, რომელიც საშუალებას გაძლევთ განახორციელოთ ეფექტური ძებნა. თუ ჩვეულებრივი გამოხატულება, როგორც მეთოდის არგუმენტი, გვხვდება მითითებულ სტრიქონში, მაშინ დაბრუნებული მნიშვნელობა არის შესატყვისი სიმბოლოების მასივი. ისე, თუ არ არის შესატყვისები, მაშინ .match() აბრუნებს null-ს.

Fibonacci

კლასიკური დავალება, რომელიც შეგიძლიათ ნახოთ ინტერვიუებში სხვადასხვა დონეზე. უნდა გვახსოვდეს, რომ ფიბონაჩის მიმდევრობა არის რიცხვების სერია, სადაც ყოველი მომდევნო არის წინა ორის ჯამი. ასე რომ, პირველი ათი რიცხვი ასე გამოიყურება: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34.

წარმოება

თქვენ უნდა დაწეროთ ფუნქცია, რომელიც დააბრუნებს n-ე ჩანაწერს გარკვეული თანმიმდევრობით, 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)
}

ჩვენ ვაგრძელებთ ფიბონაჩის გამოძახებას, არგუმენტებად გადავცემთ უფრო და უფრო მცირე რიცხვებს. ჩვენ ვჩერდებით, როდესაც მიღებული არგუმენტი არის 0 ან 1.

გამოყვანის

დიდი ალბათობით, თქვენ უკვე შეგხვედრიათ რომელიმე ამ ამოცანიდან, თუ გასაუბრება გაქვთ frontend-ის ან JavaScript-ის დეველოპერის სამუშაოზე (განსაკუთრებით, თუ ეს უმცროს დონეზეა). მაგრამ თუ მათ არ შეგხვედრიათ, ისინი შეიძლება სასარგებლო იყოს მომავალში - ყოველ შემთხვევაში ზოგადი განვითარებისთვის.

Skillbox გირჩევთ:

• მიმართა ონლაინ კურსს "პითონის მონაცემთა ანალიტიკოსი".
• ონლაინ კურსი "პროფესიის ფრონტენდის დეველოპერი".
• პრაქტიკული წლის კურსი "PHP დეველოპერი 0-დან PRO-მდე".

წყარო: www.habr.com