Do tradutor: publicamos para você um artigo , frequentemente apresentadas a candidatos desenvolvedores em entrevistas. O artigo será útil, principalmente, para programadores iniciantes.
As entrevistas em empresas de tecnologia há muito se tornaram uma lenda. Não é de se surpreender — passar com sucesso pela entrevista oferece a oportunidade de conseguir um bom emprego. Mas não é tão simples, pois muitas vezes é necessário resolver tarefas complexas.
Além disso, a maioria dessas tarefas não tem relação com o trabalho que o candidato irá realizar, mas ainda assim precisam ser resolvidas. Às vezes, é preciso fazer isso no quadro, sem consultar o Google ou qualquer outra fonte. Sim, a situação está mudando gradualmente, e algumas empresas estão abandonando esse tipo de entrevistas, mas muitos empregadores ainda mantêm essa tradição. Este artigo é dedicado à análise de tarefas típicas de JavaScript que são frequentemente usadas como exercícios para os candidatos.
Lembramos: para todos os leitores do «Habr» — desconto de 10.000 rublos na inscrição em qualquer curso Skillbox com o código promocional «Habr».
A Skillbox recomenda: Curso Prático .
O principal — uma preparação minuciosa para a sua entrevista
Sim, antes de começarmos a analisar as tarefas, vamos discutir algumas dicas gerais para a preparação da entrevista.
O principal — se preparar com antecedência. Verifique o quão bem você se lembra de algoritmos e estruturas de dados, e relembre os conhecimentos nas áreas que não são muito familiares a você. Existem várias plataformas online que podem ajudar na preparação para entrevistas. Recomendamos , , e .
É importante aprender a falar a resolução em voz alta. É desejável que o candidato descreva o que está fazendo, em vez de apenas escrever no quadro (ou digitar código em um computador, também em silêncio). Assim, se você cometer um erro no código, mas o processo de resolução estiver, em geral, correto, suas chances de sucesso podem aumentar.
A tarefa deve ser compreendida antes de começar a resolvê-la. Em alguns casos, pode-se entender superficialmente a tarefa e depois seguir por um caminho errado. Talvez valha a pena fazer algumas perguntas esclarecedoras ao entrevistador.
É necessário praticar escrever código manualmente, e não apenas em um computador. Às vezes, em entrevistas, o candidato recebe um marcador e uma lousa, sem dicas ou formatação automática. Ao buscar uma solução, é bom anotar seu código em um pedaço de papel ou diretamente na lousa. Se tudo ficar na cabeça, é fácil esquecer algo importante.
Tarefas de padrão em JavaScript
Provavelmente, algumas dessas tarefas já são conhecidas para você. Ou você participou de entrevistas onde precisou resolver algo parecido, ou praticou essas tarefas enquanto aprendia JavaScript. Agora é hora de resolvê-las novamente, com uma explicação detalhada do processo.
Palíndromo
Um palíndromo é uma palavra, frase ou sequência de caracteres que é lida da mesma forma, tanto da esquerda para a direita, quanto da direita para a esquerda. Por exemplo, "Anna" é um palíndromo, enquanto "mesa" e "João" não são.
Enunciado
Dada uma string; precisa escrever uma função que retorne true se a string for um palíndromo e false caso contrário. Vale lembrar que espaços e sinais de pontuação devem ser considerados.
palindrome('racecar') === true
palindrome('mesa') === false
Analisando a tarefa
A ideia principal aqui é inverter a string na direção oposta. Se a string "reversa" é idêntica à original, então temos um palíndromo e a função deve retornar true. Caso contrário, deve retornar false.
Solução
Aqui está o código que resolve o problema do palíndromo.
const palindrome = str => {
// transforma a string em minúsculas
str = str.toLowerCase()
// reverte a string de entrada e retorna o resultado da
// comparação
return str === str.split('').reverse().join('')
}O primeiro passo é converter os caracteres da string de entrada para minúsculas. Isso garante que o programa compare exatamente os caracteres e não se preocupe com a caixa ou outras questões.
O segundo passo é reverter a string. Isso não é difícil: é necessário transformá-la em um array usando o método .split() (biblioteca String). Depois, invertemos o array utilizando .reverse() (biblioteca Array). A última etapa é transformar o array invertido em uma string usando .join() (biblioteca Array).
Agora, tudo o que precisa ser feito é comparar a string "reversa" com a original, retornando o resultado true ou false.
FizzBuzz
Uma das tarefas mais populares em entrevistas.
Enunciado
É necessário escrever uma função que imprima no console os números de 1 a n, onde n é um inteiro que a função recebe como parâmetro, com as seguintes condições:
- imprimir fizz em vez de números que são múltiplos de 3;
- exibir buzz em vez de números múltiplos de 5;
- exibir fizzbuzz em vez de números múltiplos de 3 e 5.
Exemplo
Fizzbuzz(5)
Resultado
// 1
// 2
// fizz
// 4
// buzz
Analisando a tarefa
O principal aqui é o método de encontrar múltiplos usando JavaScript. Isso pode ser implementado usando o operador de módulo ou resto — %, que mostra o resto da divisão de dois números. Se o resto for 0, isso significa que o primeiro número é múltiplo do segundo.
12 % 5 // 2 -> 12 não é um múltiplo de 5
12 % 3 // 0 -> 12 é múltiplo de 3
Assim, se dividirmos 12 por 5, obtemos 2 com resto 2. Se dividirmos 12 por 3, obtemos 4 com resto 0. No primeiro caso, 12 não é múltiplo de 5; no segundo, 12 é múltiplo de 3.
Solução
A solução ideal será o seguinte código:
const fizzBuzz = num => {
for(let i = 1; i <= num; i++) {
// verificar se o número é múltiplo de 3 e 5
if(i % 3 === 0 && i % 5 === 0) {
console.log('fizzbuzz')
} // verificar se o número é múltiplo de 3
else if(i % 3 === 0) {
console.log('fizz')
} // verificar se o número é múltiplo de 5
else if(i % 5 === 0) {
console.log('buzz')
} else {
console.log(i)
}
}
}A função realiza as verificações necessárias usando operadores condicionais e fornece o resultado que o usuário precisa. A tarefa aqui é prestar atenção na ordem dos operadores if…else: começando pela condição dupla (&&) e terminando com o caso em que não foram encontrados números múltiplos. Assim, cobrimos todas as possibilidades.
Anagrama
Isso se refere a uma palavra que contém todas as letras de outra palavra na mesma quantidade, mas em uma ordem diferente.
Enunciado
É necessário escrever uma função que verifique se duas strings são anagramas, considerando que a capitalização das letras não importa. Apenas os caracteres devem ser considerados; espaços ou pontuações não são levados em conta.
anagram(‘finder’, ‘Friend’) -> true
anagram(‘hello’, ‘bye’) -> false
Analisando a tarefa
É importante observar que é necessário verificar cada letra nas duas strings de entrada e suas quantidades em cada string.
finder -> f: 1 friend -> f: 1
i: 1 r: 1
n: 1 i: 1
d: 1 e: 1
e: 1 n: 1
r: 1 d: 1
Para armazenar os dados do anagrama, é melhor escolher uma estrutura como um literal de objeto JavaScript. A chave neste caso é o símbolo da letra, e o valor é a quantidade de repetições na string atual.
Existem também outras condições:
- É preciso garantir que a capitalização das letras não seja considerada na comparação. Basta converter ambas as strings para minúsculas ou maiúsculas.
- Exclua da comparação todos os não-caracteres. O melhor é trabalhar com .
Solução
// 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
}Preste atenção no uso de no trecho acima. Este método retorna um array contendo os nomes ou chaves na mesma ordem em que aparecem no objeto. Nesse caso, o array será assim:
[‘f’, ‘i’, ‘n’, ‘d’, ‘e’, ‘r’]
Assim, obtemos as propriedades do objeto sem a necessidade de realizar um ciclo volumoso. Pode-se usar esse método com a propriedade .length — para verificar se ambas as strings têm a mesma quantidade de caracteres — esse é um aspecto importante das anagramas.
Busca de vogais
Uma tarefa bastante simples, que frequentemente aparece em entrevistas.
Enunciado
É necessário escrever uma função que aceite uma string como argumento e retorne a quantidade de vogais contidas na string.
As vogais são “a”, “e”, “i”, “o”, “u”.
Exemplo:
findVowels(‘hello’) // —> 2
findVowels(‘why’) // —> 0
Solução
Aqui está a solução mais simples:
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
}É importante notar o uso do método .includes(). Ele está disponível tanto para strings quanto para arrays. Deve-se usá-lo para identificar se um array contém um determinado valor. Esse método retorna true se o array contiver o valor especificado e false caso contrário.
Há uma solução ainda mais curta para o problema:
const findVowels = str => {
const matched = str.match(/[aeiou]/gi)
return matched ? matches.length : 0
}Aqui é utilizado o método .match(), que permite realizar uma busca eficiente. Se a expressão regular como argumento for encontrada dentro da string especificada, o valor retornado será um array de símbolos correspondentes. Se não houver correspondências, .match() retorna null.
Fibonacci
Um problema clássico que pode ser encontrado em entrevistas de diferentes níveis. Vale lembrar que a sequência de Fibonacci é uma série de números onde cada número subsequente é a soma dos dois anteriores. Assim, os dez primeiros números são: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34.
Enunciado
É necessário escrever uma função que retorne o n-ésimo termo de uma determinada sequência, onde n é o número passado como argumento da função.
fibonacci(3) // —> 2
Esta tarefa envolve a execução de um loop um número de vezes especificado no argumento, retornando o valor na posição correspondente. Essa forma de apresentar o problema requer o uso de loops. Se, em vez disso, você usar recursão, isso pode agradar ao entrevistador e lhe dar alguns pontos extras.
Solução
const fibonacci = num => {
// armazene a sequência de Fibonacci que você vai
// gerar dentro de um array e
// inicialize o array com os dois primeiros
// números da sequência
const result = [0, 1]
for(let i = 2; i <= num; i++) {
// adicione a soma dos dois números
// que precedem a posição de i no array de resultados
// ao final do array de resultados
const prevNum1 = result[i - 1]
const prevNum2 = result[i - 2]
result.push(prevNum1 + prevNum2)
}
// retorne o último valor no array de resultados
return result[num]
}No array de resultados, os dois primeiros números estão contidos na linha, uma vez que cada entrada na sequência consiste na soma de dois números anteriores. No início, não há dois números que possam ser utilizados para obter o próximo número, portanto o loop não pode gerá-los automaticamente. Mas, como sabemos, os dois primeiros números são sempre 0 e 1. Portanto, podemos inicializar o array de resultados manualmente.
Quanto à recursão, a situação é ao mesmo tempo mais simples e mais complexa:
const fibonacci = num => {
// se num for 0 ou 1, retorne num
if(num < 2) {
return num
}
// recursão aqui
return fibonacci(num - 1) + fibonacci(num - 2)
}Continuamos chamando fibonacci(), passando números cada vez menores como argumentos. Paramos quando o argumento passado é 0 ou 1.
Saída
Provavelmente você já se deparou com algum dos problemas mencionados, se participou de entrevistas para desenvolvedor frontend ou JavaScript (especialmente se for no nível júnior). Mas, se eles não apareceram, podem ser úteis no futuro - pelo menos para o seu desenvolvimento geral.
A Skillbox recomenda:
- Curso Online Aplicado .
- Curso online .
- Curso prático de um ano .
Fonte: habr.com
