O que você gosta e não gosta no seu trabalho na empresa?
Frontend
/** * Implementar o método times para um objeto numérico. * A função deve aceitar um callback e chamá-lo * um número determinado de vezes com o índice da iteração atual. */ Number.prototype.times = function (callback) { const n = Number(this); for (let i = 0; i < n; i++) { callback(i); } } // Exemplos console.clear(); (3).times(console.log) // 0 // 1 // 2
Há uma árvore com esquilos e corvos. É necessário escrever uma função que encontre todos os esquilos na árvore e retorne seus nomes. Resultado esperado: ['Acorn', 'Sirsalty', 'Macadamia', 'Kernel'].
Como se pode otimizar o algoritmo de interseção?
Há quanto tempo trabalha na empresa?
/** * É necessário escrever uma função strjoin, * que concatena strings usando um separador. */ function strjoin() { // código aqui } console.log(strjoin('a', 'b', 'c')) // 'a.b.c' console.log(strjoin('a', 'b', 'c', 'd', 'e', 'f')) // 'a-b-c-d-e-f'
/* Duas listas ordenadas com intervalos de presença de utilizadores online durante o dia. O início do intervalo é estritamente menor que o fim. É necessário calcular os intervalos em que ambos os utilizadores estiveram online. Os intervalos são indicados em horas, considerando que podem variar de 0 a 24. */ interseção( [[8, 12], [17, 22]], [[5, 11], [14, 18], [20, 23]] )// [[8, 11], [17, 18], [20, 22]] interseção( [[9, 15], [18, 21]], [[10, 14], [21, 22]] )// [[10, 14]] function interseção(usuário1, usuário2) { // seu código aqui }
/* São fornecidas três secções de código. É necessário escrever o resultado de cada console.log. */ var n = 1; function f(n) { n = 3; } f(n); console.log(n); // ?? // ---------------- var obj = { a: 1 }; function f1(o) { o.a = 5; } f1(obj); console.log(obj); // ?? // ---------------- var obj = { a: 1 }; function f2(o) { o = { hello: 1 }; } f2(obj);
Reescreva a função strjoin sem usar parâmetros rest, usando o objeto arguments em seu lugar.
Implementar o método Array.prototype.groupBy, que devolve uma versão estruturada do array de objetos, onde cada chave é o resultado da chamada da função passada, e o valor é um array de elementos correspondentes a essa chave.
Como irão mudar a complexidade assintótica e o consumo de memória na tarefa camelCase → snake_case se o resultado for construído por concatenação de strings em vez de um array de caracteres?
Por que o for...of é destacado a vermelho no TypeScript, mas o for normal não?
// É necessário implementar o método groupBy, que estende os métodos padrão dos arrays. // O método deve retornar uma versão agrupada do array - um objeto, // no qual cada chave é o resultado da execução da função passada fn(arr[i]), // e cada valor é um array contendo todos os elementos do array original com essa chave. // código aqui // Exemplo 1 const array1 = [ { id: 1 }, { id: 1 }, { id: 2 } ]; const fn = (item) => item.id; console.log(array1.groupBy(fn)); // { // 1: [{ id: 1 }, { id : 1 }], // 2: [{ id: 2 }] // } // Exemplo 2 const array2 = [1, 2, 3]; console.log(array2.groupBy(String)); // { // "1": [1], // "2": [2], // "3": [3] // } // Exemplo 3 const array3 = [3.3, 0.5, 1.4]; console.log(array3.groupBy(Math.round)); // { // 3: [3.3], // 1: [0.5, 1.4] // }
Escreva uma função tries(n), que chama a função aus até n vezes: retorna o primeiro resultado bem-sucedido e, se todas as tentativas falharem, lança o última erro.
// É dada uma string composta por letras latinas, espaços e sinais de pontuação. // Uma string é chamada de pangrama se contiver pelo menos uma vez cada uma das 26 letras. Determine se a string é um pangrama. const LETTERS = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']; function isPangram(text) { // seu código aqui } console.log(isPangram(`A pangram or holoalphabetic sentence is a using every letter of a given alphabet at least once.`)); // => console.log(isPangram('Waltz, bad nymph, for quick jigs vex.'))
Na protótipo de uma rede de vendas de publicidade, a venda de espaços publicitários funciona da seguinte forma: os compradores indicam antecipadamente o seu preço, e para cada espaço publicitário respondem se estão dispostos a comprá-lo ou não. É necessário implementar uma função que, antes de vender um espaço publicitário, aguarde a aceitação ou recusa dos compradores com a maior oferta de preço, e depois venda o espaço ao comprador com a maior oferta entre aqueles que aceitaram. A resposta da função deve ser retornada o mais rápido possível. Deve retornar o índice do comprador. Exemplos: Compradores oferecem preços 1, 5, 10 O comprador com oferta de 10 recusou O comprador com oferta de 1 aceitou // Ainda estamos esperando, pois pode responder o comprador com preço 5 O comprador com oferta de 5 aceitou // Escolhemos o comprador com oferta de 5 ------------ Compradores oferecem preços 1, 5, 10 O comprador com oferta de 10 recusou O comprador com oferta de 5 aceitou // Não esperamos mais resposta do comprador com oferta de 1 - ele certamente não será escolhido ------------ Compradores oferecem preços 1, 2 O comprador com oferta de 1 recusou O comprador com oferta de 2 recusou // Não escolhemos nenhum comprador interface Buyer { price: number; accepts: () => Promise<boolean>; } async function bestBuyer(buyers) { const sorted = buyers.map((buyer, index) => ({buyer, index})).sort((a, b) => a.buyer.price - b.buyer.price); const promise = sorted.map(({buyer}) => buyer.accepts()); for (let i = 0; i < sorted.length; i++) { const accepted = await promise[i]; if (accepted) { return sorted[i].index; } } if (await buyers[0].accepts()) { return 0; } return -1; }
// e cada valor é um array que contém todos os elementos do array original com essa chave. // código aqui // Exemplo 1 const array1 = [ { id: 1 }, { id: 1 }, { id: 2 } ]; const fn = (item) => item.id; console.log(array1.groupBy(fn)); // { // 1: [{ id: 1 }, { id: 1 }], // 2: [{ id: 2 }] // } // Exemplo 2 const array2 = [1, 2, 3]; console.log(array2.groupBy(String));
Quais são as limitações da travessia recursiva de uma árvore? Como a travessia em profundidade (DFS) difere da travessia em largura (BFS)? Como pode-se implementar uma travessia de árvore sem recursão?
Por que não se pode usar uma função de seta para groupBy? Qual será o this na seta?
/* É necessário implementar o método intersection, que estende os métodos padrão de conjuntos (Set). O método recebe outro conjunto como entrada e devolve um novo conjunto, que é a interseção do conjunto original e do passado, ou seja, contém apenas os elementos presentes em ambos os conjuntos. */ // seu código const set1 = new Set([1, 2, 3, 4]); const set2 = new Set([3, 4, 5, 6, 7, 8]); console.log(...set1.intersection(set2)) // 3 4 --- Set.prototype.intersection = function (set2) { const result = new Set(); for(const value of this) { if (set2.has(value)) result.add(value); } return result; } const set1 = new Set([1, 2, 3, 4]); const set2 = new Set([3, 4, 5, 6, 7, 8]); console.log(...set1.intersection(set2)) // 3 4