Solução de Problemas-1

Primeiro reverso
Faça com que a função FirstReverse(str) pegue o parâmetro str que está sendo passado e retorne
a string em ordem inversa. Por exemplo: se a string de entrada for "Hello World and Coders", então seu
programa deve retornar a string sredoC dna dlroW olleH.
Exemplos
Entrada: "coderbyte"
Saída: etybredoc
Entrada: "I Love Code"

Saída: edoC evoL I
função FirstReverse(str) {
var arr = str.split('');

arr.reverso();
retornar arr.join('');
}
manter esta chamada de função aqui

para ver como inserir argumentos em JavaScript, role para baixo
FirstReverse(linha de leitura());
deixe newString = '';

para (deixe i = str.length-1; i >= 0; i--) {
newString += str[i];
}
retornar newString;
}

código vai aqui
retornar str.split('').reverse().join('');

Primeiro fatorial
Faça com que a função FirstFactorial(num) pegue o parâmetro num que está sendo passado e
retorne o fatorial dele. Por exemplo: se num = 4, então seu programa deve retornar (4 * 3 * 2 * 1) = 24.
Para os casos de teste, o intervalo será entre 1 e 18 e a entrada será sempre um inteiro.
Exemplos
Entrada: 4
Saída: 24
Entrada: 8
Saída: 40320
função FirstFactorial(num) {
seja fatorial = 1;
para (deixe i = 1; i <= núm; i++) {

fatorial *= i;
}
fatorial de retorno;

PrimeiroFatorial(readline());
código vai aqui

se (num < 0) retornar NaN;
retorno (num > 1) ? PrimeiroFatorial(num - 1) * núm : 1;

deixe a resposta = 1;
para (deixe índice = 1; índice <= núm; índice++) {
resposta *= índice;
}
retorno de resposta;

Palavra mais longa
Faça com que a função LongestWord(sen) pegue o parâmetro sen que está sendo passado e retorne a
maior palavra na cadeia de caracteres. Se houver duas ou mais palavras com o mesmo comprimento,
retorne a primeira palavra da cadeia de caracteres com esse comprimento. Ignore a pontuação e assuma
que sen não estará vazio.
Exemplos
Entrada: "fun&!! time"

Saída: tempo
Entrada: "Eu amo cachorros"

Saída: amor
função LongestWord(sen) {
sen = sen.trim();
sen = sen.replace(/[â-zA-Zsd]/g, '');
var arr = sen.split(' ');
arr.sort(function(a, b) {return b.length - a.length});
retorno arr.shift();
código vai aqui

retorno sen;

LongestWord(linha de leitura());
let validCharacters =
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
deixe maxLength = 0;
let longestWord = '';
para (deixe i = 0, comprimento = 0, palavra = ''; i < sen.length; i++) {

Seja C = Sen[i];
if (validCharacters.includes(c)) {
comprimento++;
palavra += c;
} else {
comprimento = 0;
palavra = '';
}
if (comprimento > maxLength) {

maxLength = comprimento;
longestWord = palavra;
}
}
retornar por mais tempo;

var trimmed = sen.replace(/[^\w]/g, ' ');
var palavras = trimmed.split(/\s+/);
var longestWord = words.sort(function(a, b) {return b.length - a.length;}) [0];
retornar por mais tempo;
}

Alterações de Carta
Faça com que a função LetterChanges(str) pegue o parâmetro str que está sendo passado e
modifique-o usando o algoritmo a seguir. Substitua cada letra na cadeia de caracteres pela letra que a
segue no alfabeto (ou seja.c passa a ser d, z passa a ser a). Em seguida, coloque cada vogal em
maiúsculas nesta nova cadeia de caracteres (a, e, i, o, u) e, finalmente, retorne essa cadeia modificada.
Exemplos
Entrada: "hello*3"
Saída: Ifmmp*3
Entrada: "momentos divertidos!"
Saída: gvO Ujnft!
função LetterChanges(str) {
str = str.trim().toLowerCase();
var len = str.comprimento;
var newStr = '';
para (var i = 0; i < len; i++) {

if (/[a-ce-gi-mo-su-y]/.test(str[i])) {
newStr += String.fromCharCode((((str[i].charCodeAt(0) - 18) % 26) + 97)
}
senão se (/[zdhnt]/.test(str[i])) {
newStr += String.fromCharCode((((str[i].charCodeAt(0) - 18) % 26) + 65);
}
senão {
newStr += str[i];
}
}
retornar newStr;

LetterChanges(linha de leitura());
let validCharacters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

para (deixe i = 0; i < str.length; i++) {
if (validCharacters.includes(str[i])) {
deixe char = str.charCodeAt(i);
newString += (str[i] === 'z' || str[i] === 'Z') ?
String.fromCharCode(char - 25) : String.fromCharCode(char + 1);
} else {
}
}
vogais = 'aeiou';
deixe finalString = '';
vogais capitlize
for (let i = 0; i < newString.length; i++) {
if (vogais.includes(newString[i])) {
finalString += newString[i].toUpperCase();
} else {
finalString += newString[i];
}
}
retornar finalString;

str = str.replace(/[a-zA-Z]/g, function(ch) {
se (ch === 'z') retornar 'a';
senão se (ch === 'Z') retornar 'A';
caso contrário, retorne String.fromCharCode(ch.charCodeAt(0) + 1);
});
return str.replace(/[aeiou]/g, function(ch) {

retornar ch.toUpperCase();
});
}

Adição simples
Faça com que a função SimpleAdding(num) some todos os números de 1 a num. Por exemplo: se a
entrada for 4, então seu programa deve retornar 10 porque 1 + 2 + 3 + 4 = 10. Para os casos de teste, o
parâmetro num será qualquer número de 1 a 1000.
Exemplos
Entrada: 12
Saída: 78
Entrada: 140 Saída: 9870
função SimpleAdding(num) {
if (num === 1) {
retorno 1;
}
senão {
return num + SimpleAdding(num -1);
}
}

SimpleAdding(linha de leitura());
deixe a soma = 0;
para (i = 1; i <= num; i++) {
soma += i;
}
soma de devolução;

código vai aqui

se (num < 1) retornar NaN;
senão se (num === 1) retornar 1;
retornar SimpleAdding(num - 1) + num;
}

Letra maiúscula
Faça com que a função LetterCapitalize(str) pegue o parâmetro str que está sendo passado e
coloque em maiúsculas a primeira letra de cada palavra. As palavras serão separadas por apenas um
espaço.
Exemplos
Entrada: "hello world"

Saída: Hello World
Entrada: "Eu corri lá"

Saída: Eu corri lá
função LetterCapitalize(str) {
wordarr = str.split(" ");
para (var i = 0, n = wordarr.length; i < n; i++) {

wordarr[i] = wordarr[i][0].toUpperCase() + wordarr[i].slice(1);
}
str = wordarr.join(" ");
Retorno Str;

LetterCapitalize(linha de leitura());

for (let i = 0, newWord = true; i < str.length; i++) {
if (newWord) {
newString += str[i].toUpperCase();
} else {
}
newWord = (str[i] === ' ') ? verdadeiro : falso;

}
retornar newString;
}

código vai aqui

retornar str.split(/s+/).map(function(word) {
return word[0].toUpperCase() + word.slice(1);
}).join(' ');
}

Símbolos simples
Faça com que a função SimpleSymbols(str) pegue o parâmetro str que está sendo passado e
determine se é uma sequência aceitável retornando a cadeia de caracteres true ou false. O parâmetro
str será composto por símbolos + e = com vários caracteres entre eles (ou seja.++d+===+c++==a) e
para que a cadeia de caracteres seja verdadeira, cada letra deve ser cercada por um símbolo +. Assim, a
cadeia à esquerda seria falsa. A cadeia de caracteres não estará vazia e terá pelo menos uma letra.
Exemplos
Entrada: "+d+=3=+s+"
Saída: true
Entrada: "f++d+"
Saída: false
função SimpleSymbols(str) {
if (/^[a-zA-Z]/.test(str) || /[a-zA-Z]$/.test(str)) {
retornar false;
}
else if (/[^+][a-zA-Z]/.test(str) || /[a-zA-Z][^+]/.test(str)) {
retornar false;
}
senão {
retorno verdadeiro;
}

SimpleSymbols(readline());
if (str === '') {

retornar 'falso';
}
deixe resultado = str.split('').every(letterEval);
retorno resultado ? 'verdadeiro' : 'falso';
letra de funçãoEval(letra, índice) {

deixe letras = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
if (letters.includes(letter)) {
Verificar o primeiro ou o último caractere
if (índice === 0 || índice === str.length - 1) {
A letra é o primeiro ou o último caractere, caso de falha
retornar false;
}
if (str[index - 1] === '+' && str[index + 1] === '+') {

retorno verdadeiro;
}
} else {
Ignorar que não são letras
retorno verdadeiro;
}
}

código vai aqui

se (str.match(/[^+][A-Za-z][^+]/g)) retornar false;
senão se (str.match(/[+][A-Za-z][^+]/g)) retornar false;
senão se (str.match(/[^+][A-Za-z][+]/g)) retornar false;
retorno verdadeiro;
}

Verificar Nums
Faça com que a função CheckNums(num1,num2) pegue ambos os parâmetros que estão sendo
passados e retorne a string true se num2 for maior que num1, caso contrário, retorne a string false. Se
os valores dos parâmetros forem iguais entre si, retorne a cadeia de caracteres -1.
Exemplos
Entrada: 3 & num2 = 122

Saída: true

Saída: -1
VER DESAFIO
função CheckNums(num1,num2) {
if (num1 == num2) {
retorno "-1";
}
senão {
retorno (num2 > num1);
}
}

CheckNums(readline());
if (num2 > num1) {
retorno verdadeiro;
} else if (num1 === num2) {
retorno '-1';
} else {
retornar false;
}

código vai aqui

se ((num1 - num2) < 0) retornar true;
senão se ((num1 - num2) > 0) retornar false;
senão retornar -1;
}

Tempo de conversão
Faça com que a função TimeConvert(num) pegue o parâmetro num que está sendo passado e retorne
o número de horas e minutos em que o parâmetro converte (ou seja. se num = 63, então a saída deve ser
1:3). Separe o número de horas e minutos com dois pontos.
Exemplos
Entrada: 126
Saída: 2:6
Entrada: 45 Saída: 0:45
função TimeConvert(num) {
var horas = Math.floor(num/60);
var minutos = num % 60;
var str = horas + ":" + minutos;
Retorno Str;
}

TimeConvert(linha de leitura());
deixe horas = Math.floor(num/60);

deixe minutos = num % 60;
horas de retorno + ':' + minutos;

código vai aqui

retorno Math.floor(num / 60) + ':' + (num % 60);

Sopa de letrinhas
Faça com que a função AlphabetSoup(str) pegue o parâmetro str string que está sendo passado e
retorne a string com as letras em ordem alfabética (ou seja. Olá torna-se Ehllo). Suponha que números e
símbolos de pontuação não serão incluídos na cadeia de caracteres.
Exemplos
Saída: bcdeeorty
Entrada: "hooplah"
Saída: ahhloop
função AlphabetSoup(str) {
matrizes var = str.split("");

var reversearrays = matrizes.sort();
var result = reversearrays.join("");
resultado de retorno;

AlphabetSoup(linha de leitura());
deixe letras = str.split('');

letras de retorno.sort().join('');

código vai aqui

retornar str.split('').sort(function(ch1, ch2) {
retornar ch1.charCodeAt(0) - ch2.charCodeAt(0);
}).join('');
}

Verificação AB
Faça com que a função ABCheck(str) pegue o parâmetro str que está sendo passado e retorne a string
true se os caracteres a e b estiverem separados por exatamente 3 lugares em qualquer lugar da string pelo
menos uma vez (ou seja. "Lane emprestada" resultaria em true porque há exatamente três caracteres
entre a e b). Caso contrário, retorne a cadeia de caracteres false.
Exemplos
Entrada: "depois de mal"

Saída: false
Entrada: "Laura soluça"

Saída: true
função ABCheck(str) {
patt = /(a... b|b... a)/
retorno patt.test(str);

ABCheck(linha de leitura());
if (str.length < 5) {
retornar false;
}
console.log(str.length);
para (deixe i = 0; i < str.length-4; i++) {

procure um
if (str[i] === 'a') {
if (str[i+4] === 'b') {
retorno verdadeiro;
}
}
if (str[i] === 'b') {

if (str[i+4] === 'a') {
retorno verdadeiro;
}
}
}
retornar false;

código vai aqui
return str.match(/[aA].{ 3}[bB]/) !== nulo;

}

Contagem de Vogais
Faça com que a função VowelCount(str) pegue o parâmetro str string que está sendo passado e
retorne o número de vogais que a string contém (ou seja. "Todas as vacas comem capim e moo" voltaria
8). Não conte y como vogal para este desafio.
Exemplos
Entrada: "hello"
Saída: 2
Saída: 3
função VowelCount(str) {
var patt = /[aeiou]/gi;
var arr = str.match(patt);
if (arr == null) {
retorno 0;
}
senão {
retorno arr.length;
}
}

VogalCount(readline());
vogais = 'aeiou';
let count = 0;

if (vogais.includes(str[i])) {
contagem++;
}
}
contagem de retornos;
}

código vai aqui
retornar str.split('').filter(function(ch) {
retornar ['a', 'e', 'i', 'o', 'u'].indexOf(ch.toLowerCase()) > -1;
}).comprimento;

Contagem de palavras
Faça com que a função WordCount(str) pegue o parâmetro str string que está sendo passado e
retorne o número de palavras que a string contém (por exemplo, "Never eat shredded wheat or cake"
retornaria 6). As palavras serão separadas por espaços individuais.
Exemplos
Entrada: "Hello World"

Saída: 2
Entrada: "um 22 três"

Saída: 3
função WordCount(str) {
var arr = str.split(" ");
resposta var = arr.comprimento;
retorno de resposta;

WordCount(linha de leitura());
retorno str.split(' ').length;
}

código vai aqui

retorno str.split(' ').length;
}

Ex Ah
Faça com que a função ExOh(str) pegue o parâmetro str que está sendo passado e retorne a string
true se houver um número igual de x's e o's, caso contrário, retorne a string false. Apenas essas duas
letras serão inseridas na string, sem pontuação ou números. Por exemplo: se str é "xooxxxxooxo",
então a saída deve retornar false porque existem 6 x's e 5 o's.
Exemplos
Entrada: "xooxxo"
Saída: true
Entrada: "x"
Saída: false
função ExOh(str) {
var regExPatternX = /x/gi;
var regExPatternO = /o/gi;
var arrayXLen = str && str.match(regExPatternX) ?

str.match(regExPatternX).length : 0;
var arrayOLen = str && str.match(regExPatternO) ?
str.match(regExPatternO).length : 0;
return arrayXLen === arrayOLen;

}

ExOh(linha de leitura());
deixe xCount = 0;
deixe oCount = 0;

if (str[i] === 'x') {
xCount++;
}
if (str[i] === 'o') {
oContagem++;
}
}
return (xCount === oCount) ? verdadeiro : falso;

código vai aqui

var letras = str.split('');
var numOfEx = letras.filter(function(ch) {
retorno ch === 'x';
}).comprimento;
var numOfOh = letras.filter(function(ch) {
retorno ch === 'o';
}).comprimento;
return numOfEx === numOfOh;

Palíndromo
Faça com que a função Palindrome(str) pegue o parâmetro str que está sendo passado e retorne a
string true se o parâmetro for um palíndromo (a string é a mesma para frente que para trás ) caso
contrário, retorne a string false. Por exemplo: "carro de corrida" também é "carro de corrida" para trás.
Pontuação e números não farão parte da cadeia de caracteres.
Exemplos
Entrada: "nunca ímpar ou par"

Saída: verdadeiro
Entrada: "olho"
Saída: true
função Palindrome(str) {
modificado = str.replace(/W/g,"");
var arr1 = modified.split("");

var arr2 = arr1;
arr2 = arr2.reverso();
str2 = arr2.join("");
retorno modificado == str2;

Palíndromo(readline());
str = str.replace(/ /g, '');
para (let i = 0, max = Math.floor(str.length/2); i < max; i++) {

if (str[i] !== str[str.length-1-i]) {
retornar false;
}
}
retorno verdadeiro;

str = str.replace(/ /g, '');

retornar false;
}
}
retorno verdadeiro;

Arith Geo
Já a função ArithGeo(arr) pega a matriz de números armazenados em arr e retorna a string

"Arithmetic" se a sequência segue um padrão aritmético ou retorna "Geometric" se segue um padrão
geométrico. Se a sequência não seguir nenhum dos padrões, retorne -1. Uma sequência aritmética é
aquela em que a diferença entre cada um dos números é consistente, onde como em uma sequência
geométrica, cada termo após o primeiro é multiplicado por alguma razão constante ou comum. Exemplo
aritmético: [2, 4, 6, 8] e Exemplo geométrico: [2, 6, 18, 54]. Números negativos podem ser inseridos
como parâmetros, 0 não será inserido e nenhuma matriz conterá todos os mesmos elementos.
Exemplos
Entrada: [5,10,15]
Saída: Aritmética
Entrada: [2,4,16,24]
Saída: -1
função ArithGeo(arr) {
var len = arr.comprimento;
var arithK = arr[1] - arr[0];
var geoK = arr[1] / arr[0];
para (var i = 0; i < len - 1; i++) {

if (arr[i+1] - arr [i] !== arithK) {
quebrar;
}
senão se (i === len - 2) {
retorno "Aritmética";
}
}
para (var i = 0; i < len - 1; i++) {

if (arr[i+1] / arr [i] !== geoK) {
quebrar;
}
senão se (i === len - 2) {
retornar "Geométrico";
}
}
retorno -1;
}

ArithGeo(linha de leitura());
deixe a aritmética = verdadeiro;

aritmética de teste
para (deixe i = 2, diff = arr[1] - arr[0]; i < arr.length; i++) {
if (arr[i] - arr[i-1] !== diff) {
aritmética = falso;
}
}
if (aritmética) {
retorno 'Aritmética';
}
deixe geométrico = verdadeiro;

geométrico
para (deixe i = 2, divisor = arr[1] / arr[0]; i < arr.length; i++) {
if (arr[i] / arr[i-1] !== divisor) {
geométrico = falso;
}
}
if (geométrico) {
retorno 'Geométrico';
}
retorno -1;

código vai aqui

var isArith = função(arr) {
se (arr.length < 2) retornar -1;
diferença var = arr[1] - arr[0];
para (var i = 1; i < arr.length - 1; i++) {
se (arr[i + 1] - arr[i] !== diferença) retornar false;
}
retorno verdadeiro;
};
var isGeo = função(arr) {

multiplicador var = arr[1] / arr[0];
se (arr[i + 1] / arr[i] !== multiplicador) retornar false;
}
retorno verdadeiro;
};
se (isArith(arr)) retornar "Aritmética";

senão se (isGeo(arr)) retornar "Geométrico";
senão retornar -1;
}

Adição de matriz I
Faça com que a função ArrayAdditionI(arr) pegue a matriz de números armazenados em arr e
retorne a cadeia de caracteres true se qualquer combinação de números na matriz (excluindo o maior
número) puder ser adicionada para igualar o maior número na matriz, caso contrário, retorne a string
false. Por exemplo: se arr contiver [4, 6, 23, 10, 1, 3] a saída deve retornar true porque 4 + 6 + 10 + 3
= 23. A matriz não estará vazia, não conterá todos os mesmos elementos e poderá conter números
negativos.
Exemplos
Entrada: [5,7,16,1,2]
Saída: false
Entrada: [3,5,-1,8,12]
Saída: true
função ArrayAdditionI(arr) {
alvo do VAR;
var addArr = arrayPrep(arr);
var len = addArr.length;
var permNum = Math.pow(2, len);
console.log('test0 ', permNum, target, addArr);
for(var i = 0; i <= permNum; i++) {

permStr = (i).toString(2);
strlen = permStr.length;
contador var = 0;
for(var j = 0; j < strlen; j++) {
if(permStr[j] === '1') {
contador += addArr[j];
}
}
if (contador === alvo) {
retornar true
}
}
retornar false
função arrayPrep(arr2) {
arr.sort(função(a, b){
retornar a - b
});
destino = arr2.pop()
Retorno ARR2
}
}

ArrayAdditionI(readline());
encontrar o maior número

let largestIndex = 0;
deixe maiorNúmero = 0;
para (deixe i = 0; i < arr.length; i++) {
if (arr[i] > largestNumber) {
maiorÍndice = i;
maiorNúmero = arr[i];
}
}
arr.splice(maiorÍndice, 1);
deixe combos = [];

deixe tamanho = arr.length;
para (let i = 0, max = Math.pow(2, size); i < max; i++) {

let num = i.toString(2);
enquanto (num.length < tamanho) {
núm = '0' + núm;
}
combos.push(núm);
}
iterar em todos os combos de números

para (deixe i = 0; i < combos.length; i++) {
deixe a soma = 0;
for (deixe j = 0; j < combos[i].length; j++) {
if (combos[i][j] === '1') {
soma += arr[j];
}
}
if (soma === largestNumber) {

retorno verdadeiro;
}
}
retornar false;
}

código vai aqui

var sortedArr = arr.sort(function(a,b) {return a-b;});
var maior = sortedArr.pop();
somas var = [];
para (i = 0; i < Math.pow(2, sortedArr.length); i++) {

soma var = 0;
var bitMask = i.toString(2).split('');
enquanto (bitMask.length < sortedArr.length) {

bitMask.unshift('0');
}
para (j = 0; j < bitMask.length; j++) {

if (bitMask[j] === '1') {
soma += classificadoArr[j];
}
}
sums.push(soma);
}
retorno somas.indexOf(maior) !== -1;

}

Contagem de Letras I
Faça com que a função LetterCountI(str) pegue o parâmetro str que está sendo passado e retorne
a primeira palavra com o maior número de letras repetidas. Por exemplo: "Hoje, é o melhor dia de todos
os tempos!" deve voltar maior porque tem 2 e's (e 2 t's) e vem antes de sempre que também tem 2 e's.
Se não houver palavras com letras repetidas, retorne -1. As palavras serão separadas por espaços.
Exemplos
Entrada: "Olá torta de maçã"

Saída: Olá
Entrada: "Sem palavras"

Saída: -1
função LetterCountI(str) {
var arr = str.toLowerCase().split(" ");
var n = arr.comprimento;
contador var = 1;
var maxcount = 0;
var newarr = [];
para (var i = 0; i < n; i++) {

wordarr = arr[i].split("");
wordarr.sort();
for (var j = 0; j < wordarr.length; j++) {

if (wordarr[j] == wordarr[j+1]) {
contador++;
}
senão {
if (contador > maxcount) {
maxcount = contador;
contador = 1;
}
}
}
newarr.push([arr[i], maxcount])
contagem máxima = 0;
}
newarr.sort(função(a, b) {return b[1] - a[1]});
if (newarr[0][1] == 1) {
retorno -1;
}
senão {
Retorno Newarr[0][0];
}
}

LetterCountI(linha de leitura());
deixe as palavras = str.split(' ');
deixe bestCount = 0;
deixe bestWord = '';
para (deixe i = 0; i < words.length; i++) {

deixe letterCount = [];
let largestCount = 0;
for (deixe j = 0; j < palavras[i].length; j++) {
letterCount[words[i][j]] = (letterCount[words[i][j]] === undefined) ? 1 :
++letterCount[palavras[i][j]];
if (letterCount[words[i][j]] >= 2 && letterCount[words[i][j]] >
largestCount) {
largestCount = letraCount[palavras[i][j]];
}
}
if (largestCount > bestCount) {

bestCount = maiorContagem;
bestWord = palavras[i];
}
}
retorno (bestWord === '') ? -1 : bestWord;

código vai aqui

var words = str.replace(/[Â-Za-zs]/g, '').split(/s+/);
var contagens = words.map(function(word) {

word = palavra.toLowerCase();
var letras = [];
para (letra da palavra) {
if (letras[letra]) {
letras[letra] += 1;
} else {
letras[letra] = 1;
}
}
cartas de retorno;
});
var greatestCounts = counts.map(function(word) {

var maior = 0;
for (letra em palavra) {
if (palavra[letra] > maior) {
maior = palavra[letra];
}
}
retorno maior;
});
var greatest = Math.max.apply(null, greatestCounts);

se (maior <= 1) retornar -1;
retornar palavras[greatestCounts.indexOf(greatest)];
}

Segundo GreatLow
Faça com que a função SecondGreatLow(arr) pegue a matriz de números armazenados em arr e
retorne o segundo menor e o segundo maiores números, respectivamente, separados por um espaço. Por
exemplo: se arr contiver [7, 7, 12, 98, 106] a saída deve ser 12 98. A matriz não estará vazia e conterá
pelo menos 2 números. Pode ficar complicado se houver apenas dois números!
Exemplos
Entrada: [1, 42, 42, 180]

Saída: 42 42
Entrada: [4, 90]

Saída: 90 4
função SecondGreatLow(arr) {
arr.sort(função(a, b) {retornar a - b});
arr = solitário(arr);
var newlen = arr.comprimento;
retorno arr[1] + ' ' + arr[newlen - 2]
função solitária(arr) {
var len = arr.comprimento;
var testobj = {};
saída var = [];
contagem de var = 0;
var titular = arr[i];
if (!testobj[titular]) {
testobj[holder] = verdadeiro;
output[count++] = titular;
}
}
saída de retorno
}
}

SecondGreatLow(linha de leitura())
arr = arr.slice().sort((a, b) => a - b);
deixe segundo = arr[1];

for (deixe i = 1; i < arr.length; i++) {
if (arr[i] !== arr[0]) {
segundo = arr[i];
quebrar;
}
}
deixe penúltimo = arr[arr.length - 2];

para (deixe i = arr.length - 2; i >= 0; i--) {
if (arr[i] !== arr[arr.length - 1]) {
penúltimo = arr[i];
quebrar;
}
}
retorno segundo + ' ' + penúltimo;

SecondGreatLow(linha de leitura());
código vai aqui

var sorted = arr.sort(function(a,b){return a-b;});
var maior = sorted[sorted.length - 1];
var menor = classificado[0];
var segundoMaior, segundoMenor;
para (var i = 0; i < sorted.length; i++) {

if (sorted[i] !== mais baixo) {
secondLowest = classificado[i];
quebrar;
}
}
para (var i = sorted.length - 1; i >= 0; i--) {

if (sorted[i] !== maior) {
secondGreatest = classificado[i];
quebrar;
}
}
retorno segundoMais baixo + " " + segundoMaior;

}

SecondGreatLow(linha de leitura());
Divisão Stringified
Faça com que a função DivisionStringified(num1,num2) pegue os dois parâmetros que estão
sendo passados, divida num1 por num2 e retorne o resultado como uma cadeia de caracteres com
vírgulas formatadas corretamente. Se uma resposta tiver apenas 3 dígitos, retorne o número sem vírgulas
(ou seja.2/3 deve sair "1"). Por exemplo: se num1 é 123456789 e num2 é 10000 a saída deve ser
"12.346".
Exemplos

Saída: 3

Saída: 103
VER DESAFIO
função DivisionStringified(num1,num2) {
var res = Math.round(num1/num2);

var string = res.toString();
var numleng = string.length;
var newstring = cadeia de caracteres;
if (numleng > 3) {
var arr = string.split("");
para (var i= numleng - 3; i > 0; i = i - 3) {
arr.splice(i, 0, ",");
}
var newstring = arr.join("");
}
retornar newstring;

DivisionStringified(linha de leitura());
deixe quocienteString = Math.round(num1 / num2).toString();
deixe temp = quotientString.split('').reverse();

para (deixe i = 0; i < temp.length; i++) {
if (i % 3 === 2 && i != temp.length-1) { // precisa de vírgula seguinte
newString = '," + temp[i] + newString;
} else {
newString = temp[i] + newString;
}
}
console.log(newString);
retornar newString;
}

código vai aqui

formato var = function(num) {
resultado var = '';
var inteiro = Math.round(num);
se (inteiro === 0) retornar 0;
enquanto (inteiro > 0) {

resultado = (resultado === '' ? '' : ',') + resultado;
resultado = (% inteiro 1000) + resultado;
inteiro = Math.floor(inteiro / 1000);
}
}
formato de retorno (num1 / num2);

}

Contagem de Minutos I
Faça com que a função CountingMinutesI(str) pegue o parâmetro str que está sendo passado, que
será duas vezes (cada uma formatada corretamente com dois pontos e am ou pm) separada por um hífen
e retorne o número total de minutos entre os dois tempos. O horário será em formato de relógio de 12
horas. Por exemplo: se str é 9:00am-10:00am, então a saída deve ser 60. Se str é 1:00pm-11:00am a
saída deve ser 1320.
Exemplos
Entrada: "12:30pm-12:00am"
Saída: 690
Entrada: "1:23am-1:08am"
Saída: 1425
Soluções para Contagem de Minutos I
JAVASCRIPT
VER DESAFIO
função CountingMinutesI(str) {
var seps = str.split("-");
var col1 = seps[0].indexOf(":");
var col2 = seps[1].indexOf(":");
var hour1 = parseInt(seps [0].slice(0, col1));
var hour2 = parseInt(seps[1].slice(0, col2));
var min1 = parseInt(seps[0].slice(col1+1, col1+3));
var min2 = parseInt(seps[1].slice(col2+1, col2+3));
var ampm1 = seps[0].slice(-2);
var ampm2 = seps[1].slice(-2);
if (ampm1 == "pm" && hour1 != 12) {
hora1 = hora1 + 12;
}
if (ampm2 == "pm" && hour2 != 12) {
hora2 = hora2 + 12;
}
if (hour1 == 12 && ampm1 == "am") {
hora1 = 0;
}
if (hour2 == 12 && ampm2 == "am") {
hora2 = 0;
}
var time1 = (hora1*60) + min1;
var time2 = (hora2*60) + min2;
var diff = tempo2 - tempo1;
if (diff < 0) {
diff = diff + (60 * 24);
}
diff de retorno;

CountingMinutesI(linha de leitura());
deixe os tempos = str.split('-');
times = times.map(function(currentValue, index, array){

deixe pares = currentValue.split(':');
deixe o tempo = ((pares[1][2] === 'a') ? parseInt(pares[0]) % 12 :
parseInt(pares[0]) % 12 + 12) * 60 + parseInt(pares[1][0] + pares[1][1]);
tempo de retorno;
});
deixe diff = tempos[1] - vezes[0];

retorno (diff < 0) ? diff + 1440 : difusão;
}
código vai aqui

var vezes = str.split('-');
var de = vezes[0], a = vezes[1];
função parseMinutes(timeStr) {
tempo var = timeStr.match(/d+/g);
var hora = parseInt(tempo[0]), minuto = parseInt(tempo[1]);
var ampm = (timeStr.match(/[a|p]m/g)[0] === 'am') ? 0 : 1;
se (hora === 12) hora = 0;
retorno (hora + ampm * 12) * 60 + minuto;

}
var fromMinutes = parseMinutes(from), toMinutes = parseMinutes(to);

var diferença = toMinutes - fromMinutes;
var oneDayInMinutes = 24 * 60;
retorno (diferença < 0) ? oneDayInMinutes + diferença: diferença;

}

Modo médio
Faça com que a função MeanMode(arr) pegue a matriz de números armazenados em arr e retorne 1 se
o modo for igual à média, 0 se eles não forem iguais entre si (ou seja.[5, 3, 3, 3, 1] deve retornar 1
porque a moda (3) é igual à média (3)). A matriz não estará vazia, conterá apenas inteiros positivos e não
conterá mais de um modo.
Exemplos
Entrada: [1, 2, 3]
Saída: 0
Entrada: [4, 4, 4, 6, 2]
Saída: 1
função MeanMode(arr) {
len = arr.comprimento
Passo 1: determinar a média - autoexplicativo
média da função (arr) {
contagem += arr[i]
}
console.log (contagem / len)
contagem de retorno / len
}
Passo 2: determine o modo. Precisamos contar quantos de cada tipo estão na
matriz. Uma alternativa é manter um contador ativo, classificar a matriz e, em
seguida, contar até que um item mude, mantendo o controle da contagem máxima e do
valor associado. O seguinte é uma maneira muito mais fácil, supondo que se tenha uma
familiaridade básica com objetos javascript. Ele faz de cada nova entrada uma chave
e mantém a contagem de quantos de cada há e, em seguida, faz uma matriz dos pares
chave-valor criados.
modo de função (arr) {

var obj = {};
para (var i = 0, len = arr.length; i < len; i++) {
if (obj[arr[i]] === undefined) {
obj[arr[i]] = 1;
}
senão {
obj[arr[i]]++;
}
}
var objarr = [];
para (x em obj) {
objarr.push([x, obj[x]]);
}
objarr.sort(function(a, b) {return b[1] - a[1]});
console.log(objarr[0][0]);
retorno objarr[0][0];
}
Compare a média e a moda
modo de retorno(arr) == média(arr)? 1: 0;
}

MeanMode(linha de leitura());
Modo de localização
deixe maisOcorrências = 0;
modo let = 0;
deixe marco = arr[i];
para (deixe j = i+1, count = 0; j < arr.length; j++) {
if (marco === arr[j]) {
fósforo!
contagem++;
if (contagem > mostOccurances) {
mostOccurances = contagem;
modo = arr[j];
}
}
}
}
Encontrar média
deixe a média = 0;
média += arr[i];
}
média = Math.round(média/arr.comprimento);
return (média === modo) ? 1 : 0;

código vai aqui

modo de função (arr) {
var counts = [], modo, maxCount = 0;
for (num de arr) {
núm = núm + ' ';
if (counts[num]) counts[num]++;
outras contagens[num] = 1;
}
para (num em contagens) {

if (counts[num] > 1 && counts[num] > maxCount) {
mode = parseInt(num);
maxCount = contagens[num];
}
}
modo de retorno;
}
média da função (arr) {

return arr.reduce(function(a,b) {return a+b;}, 0) / arr.length;
}
modo de retorno(arr) === mean(arr) ? 1 : 0;

}

Inserção de traço
Faça com que a função DashInsert(str) insira traços ('-') entre cada dois números ímpares em str.
Por exemplo: se str é 454793 a saída deve ser 4547-9-3. Não conte zero como um número ímpar.
Exemplos
Entrada: 99946 Saída: 9-9-946
Entrada: 56730 Saída: 567-30
função DashInsert(num) {
var strnum = num.toString();
var arr = strnum.split("");
para (i = 0; i < arr.length; i++) {

arr[i] = parseInt(arr[i]);
}
para (i = 0; i < arr.length - 1; i++) {

if (arr[i]%2 == 1 && arr[i + 1]%2 == 1) {
arr.splice(i+1, 0, "-");
}
}
x = arr.join("");
retorno x;

DashInsert(linha de leitura());
função DashInsert(str) {
deixe newString = str[0];
para (let i = 1, lastOdd = str[0] % 2; i < str.length; i++) {

if (str[i] % 2 === 1 && lastOdd === 1) {
newString += '-' + str[i];
} else {
}
lastOdd = str[i] % 2;
}
retornar newString;
}

função DashInsert(str) {
código vai aqui

var dígitos = str.split('');
função isOdd(n) {
retorno parseInt(n) % 2 === 1;
}
para (var i = 0; i < dígitos.comprimento - 1; i++) {

if ( isOdd(digits[i]) && isOdd(digits[i+1]) ) {
dígitos.splice(i + 1, 0, '-');
i++;
}
}
retornar digits.join('');
}

Caso de troca
Faça com que a função SwapCase(str) pegue o parâmetro str e troque o caso de cada caractere. Por
exemplo: se str é "Hello World" a saída deve ser hELLO wORLD. Que os números e símbolos
permaneçam como estão.
Exemplos
Entrada: "Hello-LOL"
Saída: hELLO-lol
Entrada: "Sup DUDE!? "

Saída: cara sUP!?
função SwapCase(str) {
arr = str.split("");
para (var i = 0; i < arr.length; i++) {
if (arr[i] == arr[i].toUpperCase()) {
arr[i] = arr[i].toLowerCase();
}
else if (arr[i] == arr[i].toLowerCase()) {
arr[i] = arr[i].toUpperCase();
}
}
str = arr.join("");
Retorno Str;

SwapCase(linha de leitura());
const LOWER = 'abcdefghijklmnopqrstuvwxyz';

const UPPER = 'ABCDEFGHIJKLMNOPWRSTUVWXYZ';

if (LOWER.includes(str[i])) {
newString += str[i].toUpperCase();
} else if (UPPER.includes(str[i])) {
newString += str[i].toLowerCase();
} else {
}
}
retornar newString;
}
código vai aqui

return str.split('').map(function(letter) {
if (letra === letter.toLowerCase()) return letter.toUpperCase();
else if (letra === letter.toUpperCase()) return letter.toLowerCase();
outra carta de retorno;
}).join('');
}

Adição de Número
Faça com que a função NumberSearch(str) pegue o parâmetro str, procure todos os números na
cadeia de caracteres, adicione-os e retorne esse número final. Por exemplo: se str é "88Hello 3World!"
a saída deve ser 91. Você terá que diferenciar entre números de um dígito e números de vários dígitos,
como no exemplo acima. Assim, "55Hello" e "5Hello 5" devem retornar duas respostas diferentes. Cada
cadeia de caracteres conterá pelo menos uma letra ou símbolo.
Exemplos
Entrada: "75Number9"
Saída: 84
Entrada: "10 2Um número*1*"

Saída: 13
VER DESAFIO
função NumberAddition(str) {
soma var = 0;
var strArr = função(str) {
retire os não-dígitos e substitua por espaços para manter separados
str = str.replace(/[^0-9]/g, ' ');
Tire todos os espaços anteriores ou finais
str = str.trim();
Transforme quaisquer espaços duplos em espaços individuais, até que não
restem mais duplos
enquanto (str.indexOf(' ') !== -1) {
str = str.replace(/ss/g, ' ');
}
retornar uma matriz de cadeias de caracteres numéricas sem espaços;
retorno str.split(' ');
}
chamar a função strArr na entrada do usuário e armazenar como "preparado"
var prepped = strArr(str);
transformar cada cadeia numérica em um número
prepped = prepped.map(function(val) {
retorno val ? parseInt(val): 0;
})
console.log( 'preppedmap', preparado);
Execute o método Reduce para somar todos os números
var ans = prepped.reduce(function(firstval, lastval){
Retorno FirstVal + LastVal
})
retornar ans
}

NumberAddition(linha de leitura());
deixe DÍGITOS = '0123456789';

deixe os números = [];
Primeiro encontre números

para (deixe i = 0, número = ''; i < str.length; i++) {
se (! DIGITS.includes(str[i])) {
if (número !== '') {
numbers.push(número);
}
número = '';
} else {
número += str[i];
caso especial para o último char

if (i === str.length-1) {
numbers.push(número);
}
}
}
deixe a soma = 0;
para (deixe i = 0; i < numbers.length; i++) {
soma += parseInt(numbers[i]);
}
}

números var = str.match(/\d+/g) || [];
return numbers.reduce(function(sum, number) {return sum + Number(number)}, 0);
}

Terceiro Maior
Faça com que a função ThirdGreatest(strArr) pegue a matriz de cadeias de caracteres armazenadas
em strArr e retorne a terceira maior palavra dentro dela. Então, por exemplo: se strArr é ["hello",
"world", "before", "all"] sua saída deve ser world porque "before" tem 6 letras, e "hello" e "world" são
ambos 5, mas a saída deve ser world porque apareceu como a última palavra de 5 letras na matriz. Se
strArr foi ["olá", "mundo", "depois", "tudo"] a saída deve ser depois porque as três primeiras palavras
têm todas as 5 letras, então retorne a última. A matriz terá pelo menos três cadeias de caracteres e cada
cadeia de caracteres conterá apenas letras.
Exemplos
Entrada: ["coder","byte","code"]
Saída: código
Entrada: ["abc","defg","z","hijk"]
Saída: abc
função ThirdGreatest(strArr) {
strArr.sort(function(a, b) {return b.length - a.length});
retorno strArr[2];
}

ThirdGreatest(linha de leitura());
strArr.sort(function(a,b){return b.length - a.length});
retorno strArr[2];

código vai aqui

return strArr.sort(function(a, b) {
retorno (b.length - a.length);
})[2];

Poderes de dois
Faça com que a função PowersofTwo(num) pegue o parâmetro num que está sendo passado, que será
um inteiro, e retorne a string true se for uma potência de dois. Se não for, retorne a cadeia de caracteres
false. Por exemplo, se a entrada for 16, seu programa deve retornar a cadeia de caracteres true, mas se a
entrada for 22, a saída deve ser a string false.
Exemplos
Entrada: 4
Saída: true
Entrada: 124
Saída: false
função PowersofTwo(num) {
if (num < 2){

ans = "falso";
}
senão {
enquanto (num >= 2){
teste var = num%2;
if (teste == 0){
núm = núm/2
ans = "verdadeiro";}
senão{
núm = 0;
ans = "falso"}
}
}
código vai aqui
retorno ans;

PowersofTwo(linha de leitura());
return Number.isInteger(Math.log(num) / Math.log(2)) ? verdadeiro : falso;

código vai aqui

se (num === 1) retornar verdadeiro;
senão {
retorno (num % 2 === 0) ? PowersofTwo(num / 2) : falso;
}
}

Persistência Aditiva
Faça com que a função AdditivePersistence(num) pegue o parâmetro num que está sendo
passado que sempre será um inteiro positivo e retorne sua persistência aditiva que é o número de vezes
que você deve adicionar os dígitos em num até atingir um único dígito. Por exemplo: se num é 2718,
então seu programa deve retornar 2 porque 2 + 7 + 1 + 8 = 18 e 1 + 8 = 9 e você para em 9.
Exemplos
Entrada: 4
Saída: 0
Entrada: 19
Saída: 2
VER DESAFIO
função AdditivePersistence(num) {
função arrprep(numb) {
var numstr = numb.toString();
var arr = numstr.split('');
var numarr = arr.map(função(val) {
return parseInt(val)
})
Retornar Numarr
}
função addup(arr) {
var redux = arr.reduce(função(a, b){
retornar a + b })
Retorno Redux
}
enquanto (num > 9) {
num = addup(arrprep(num));
contagem++;
}
contagem de retornos

AdditivePersistence(readline());
núm = num.toString();
let count = 0;
enquanto (contagem < 10000) { // parada dura

if (num.length === 1) {
quebrar;
}
contagem++;
deixe a soma = 0;
para (deixe i = 0; i < num.length; i++) {
soma += parseInt(num[i]);
}
num = soma.toString();
}
}

código vai aqui

função addDigits(num) {
return num.toString().split('').map(function(num) {
retorno parseInt(num);
}).reduce(function(a, b) {return a + b;}, 0);
}
resultado var = num;

enquanto (resultado > 9) {
resultado = addDigits(resultado);
contagem++;
}
}

Persistência Multiplicativa
Faça com que a função MultiplicativePersistence(num) pegue o parâmetro num que está
sendo passado que sempre será um inteiro positivo e retorne sua persistência multiplicativa que é o
número de vezes que você deve multiplicar os dígitos em num até chegar a um único dígito. Por
exemplo: se num é 39, então seu programa deve retornar 3 porque 3 * 9 = 27, depois 2 * 7 = 14 e
finalmente 1 * 4 = 4 e você para em 4.
Exemplos
Entrada: 4
Saída: 0
Entrada: 25
Saída: 2
função MultiplicativePersistence(num) {
função numprep(num) {
var strnum = num.toString();
var arr = strnum.split('');
var numarr = arr.map(função(val) {
return parseInt(val)});
Retornar Numarr
}
função multnums(arr) {
var newnum = arr.reduce(função(a, b) {
retornar a * b})
retornar newnum
}
código vai aqui
enquanto (num > 9) {

num = multnums(numprep(num));
contagem++
}
contagem de retornos
}

Persistência Multiplicativa(linha de leitura());
let count = 0;
enquanto(1) {
if (num.length === 1) {
quebrar;
}
contagem++;
deixe a soma = 1;
soma *= parseInt(num[i]);
}
num = soma.toString();
}

código vai aqui

função multiplyDigits(num) {
return num.toString().split('').map(function(num) {
retorno parseInt(num);
}).reduce(function(a, b) {return a * b;}, 1);
}
resultado var = num;

enquanto (resultado > 9) {
resultado = multiplicarDígitos(resultado);
contagem++;
}
}

Mínimo Off Line

Faça com que a função OffLineMinimum(strArr) pegue o parâmetro strArr que está sendo
passado, que será uma matriz de inteiros que varia de 1...n e a letra "E", e retorne o subconjunto correto
com base nas regras a seguir. A entrada será no seguinte formato: ["I","I","E","I",...,"E",...,"I"] onde o I's
representa inteiros e o E significa retirar o menor inteiro atualmente em todo o conjunto. Quando
terminar, seu programa deve retornar esse novo conjunto com inteiros separados por vírgulas. Por
exemplo: se strArr é ["5","4","6","E","1","7","E","E","3","2"] então seu programa deve retornar 4,1,5.
Exemplos
Entrada: ["1","2","E","E","3"]
Saída: 1,2
Entrada: ["4","E","1","E","2","E","3","E"]
Saída: 4,1,2,3
função OffLineMinimum(strArr) {
var len = strArr.length;
var holdArr = [];
var ans = [];
for(var i = 0; i < len; i++) {

if (strArr[count] === "E") {
var headArr = strArr.splice(0, contagem);
strArr.shift();
holdArr = holdArr.concat(cabeçaArr);
holdArr.sort(function(a, b) {return a - b});
ans.push(holdArr.shift());
contagem = 0;
}
senão {
contagem++;
}
}
retornar ans.join(',');
}

OffLineMinimum(readline());
deixe resultado = [];

for (let i = 0; i < strArr.length; i++) {
if (strArr[i] === 'E') {
result.push(removeSmallest(strArr, i));
} else if (strArr[i] === 'R') {
não fazer nada
} else {
número não fazer nada
}
}
função removeSmallest(strArr, maxIndex) {
deixe menorÍndice = 0;
let smallestNumber = null;
strArr.forEach(function(value,index){
if (índice > maxIndex) {
retornar;
}
if (valor !== 'E' && valor !== 'R') {
if (smallestNumber === null || parseInt(value) < smallestNumber) {
menorÍndice = índice;
smallestNumber = parseInt(valor);
}
}
});
strArr[menorÍndice] = 'R';
retornar menorNúmero;
}
return result.join(',');

código vai aqui

var arr = [], resultado = [];
var log = "";
para (item de strArr) {
if (item === 'E') {
resultado.push(arr.shift());
} else {
arr.push(parseInt(item));
arr = arr.sort(function(a, b) {return a - b});
}
}
return result.join(',');
}

Alterando a sequência
Faça com que a função ChangingSequence(arr) pegue a matriz de números armazenados em arr e
retorne o índice no qual os números param de aumentar e começam a diminuir ou param de diminuir e
começam a aumentar. Por exemplo: se arr é [1, 2, 4, 6, 4, 3, 1], então seu programa deve retornar 3
porque 6 é o último ponto na matriz onde os números estavam aumentando e o próximo número começa
uma sequência decrescente. A matriz conterá pelo menos 3 números e poderá conter apenas uma única
sequência, aumentando ou diminuindo. Se houver apenas uma única sequência na matriz, seu programa
deverá retornar -1. A indexação deve começar com 0.
Exemplos
Entrada: [-4, -2, 9, 10]

Saída: -1
Entrada: [5, 4, 3, 2, 10, 11]

Saída: 3
função ChangingSequence(arr) {
Primeiro, determine se é uma sequência crescente ou decrescente
tipo var = arr[1] - arr[0] > 0 ? «crescente» : «decrescente»;
definir um índice máximo da matriz, para evitar transbordamentos

var maxInd = arr.comprimento - 1;
código para uma matriz crescente

if (tipo === 'aumentando') {
findIndex é um método de iteração de matriz que veio com ES6. Ele retorna
O primeiro valor para o qual o retorno de chamada retorna false.
var index = arr.findIndex(function(val, ind) {
enquanto (ind < maxInd) {
retorno val > arr[ind + 1];
}
retornar false;
});
índice de retorno;
}
if (tipo === 'diminuindo') {

var index = arr.findIndex(function(val, ind) {
enquanto (ind < maxInd) {
Retorno Val < Arr[ind + 1]
}
retorno 0;
});
índice de retorno;
}
}

ChangingSequence(linha de leitura());
let index = nulo;

deixe modo = (arr[1] - arr[0] > 0) ? verdadeiro : falso;
if (arr[i] - arr[i-1] > 0 !== modo) {
índice = i-1;
quebrar;
}
}
return (índice === null) ? -1 : índice;
}

var crescente = arr[0] < arr[1];

se (aumentando) {
se (arr[i] > arr[i + 1]) retornar i;
} else {
se (arr[i] < arr[i + 1]) retornar i;
}
}
retorno -1;
}

Intervalos sobrepostos
Já a função OverlappingRanges(arr) pega a matriz de números armazenados em arr que conterá 5

inteiros positivos, os dois primeiros representando um intervalo de números (a a b), os 2 seguintes
também representando outro intervalo de inteiros (c a d), e um 5º elemento final (x ) que também será
um inteiro positivo, e retorne a cadeia de caracteres true se ambos os conjuntos de intervalos se
sobreporem por pelo menos x números. Por exemplo: se arr for [4, 10, 2, 6, 3], seu programa deve
retornar a cadeia de caracteres true. O primeiro intervalo de números são 4, 5, 6, 7, 8, 9, 10 e o segundo
intervalo de números são 2, 3, 4, 5, 6. O último elemento na matriz é 3 e há 3 números que se sobrepõem
entre ambos os intervalos: 4, 5 e 6. Se ambos os intervalos não se sobreporem por pelo menos x
números, seu programa deverá retornar a cadeia de caracteres false.
Exemplos
Entrada: [5,11,1,5,1]
Saída: true
Entrada: [1,8,2,4,4]
Saída: false
função OverlappingRanges(arr) {
alvo var = arr.pop();
var MaxLowerBound = Matemática.max(arr[0], arr[2]);
var MinUpperBound = Math.min(arr[1], arr[3]);
intervalo var = MinUpperBound - MaxLowerBound + 1;
intervalo de retorno >= destino ? 'verdadeiro' : 'falso';

}

OverlappingRanges(linha de leitura());
let count = 0;
para (deixe i = arr[0]; i <= arr[1]; i++) {
if (i >= arr[2] && i <= arr[3]) {
contagem++;
}
}
retorno (contagem >= arr[4]) ? verdadeiro : falso;
}

var intervalo1 = [arr[0], arr[1]]; a, b)
var range2 = [arr[2], arr[3]]; c, d)
var mínimoOverlap = arr[4] - 1;
determina a sobreposição entre dois intervalos

um número negativo significa que não há sobreposição
sobreposição de função(intervalo1, intervalo2) {
if (intervalo1[0] < intervalo2[0]) {
a----b
c----d
retorno (intervalo1[1] > intervalo2[1] ? intervalo2[1] : intervalo1[1]) -
intervalo2[0];
} else {
a----b
c---d
retorno (intervalo2[1] > intervalo1[1] ? intervalo1[1] : intervalo2[1]) -
intervalo1[0];
}
}
retorno overlap(range1, range2) >= minimumOverlap;

}

Superaumento
Faça com que a função Superincreasing (arr) pegue a matriz de números armazenados em arr e
determine se a matriz forma uma sequência supercrescente onde cada elemento na matriz é maior do que
a soma de todos os elementos anteriores. A matriz consistirá apenas de inteiros positivos. Por exemplo:
se arr é [1, 3, 6, 13, 54], então seu programa deve retornar a cadeia de caracteres "true" porque ela
forma uma sequência supercrescente. Se uma sequência supercrescente não for formada, seu programa
deverá retornar a sequência de caracteres "false"
Exemplos
Entrada: [1,2,3,4]
Saída: false
Entrada: [1,2,5,10]
Saída: true
função Superincreasing (arr) {
var maxInd = arr.comprimento - 1;
alvo do VAR;
soma var;
para (var i = maxInd; i > 0; i--) {

alvo = arr.pop()
soma = arr.reduce(função(val1, val2) {
retornar val1 + val2;
});
if (soma >= destino) {
retornar 'falso';
}
};
retorno 'verdadeiro';
}
Supercrescente(readline());
for (let i = 0, sum = 0; i < arr.length; i++) {

if (arr[i] <= soma) {
retornar false;
}
soma += arr[i];
}
retorno verdadeiro;
}


se (arr.length < 2) retornar false;
if (arr.length === 2) retornar arr[0] < arr[1];
se (arr[0] >= arr[1]) retornar false;
var total = arr[0] + arr[1];

se (arr[i] <= total) retornar false;
total += arr[i];
}
retorno verdadeiro;
}

Distância Hamming
Faça com que a função HammingDistance(strArr) pegue a matriz de strings armazenadas em

strArr, que conterá apenas duas strings de comprimento igual e retorne a distância Hamming entre
elas. A distância de Hamming é o número de posições onde os caracteres correspondentes são diferentes.
Por exemplo: se strArr é ["coder", "codec"] então seu programa deve retornar 1. A cadeia de
caracteres será sempre de igual comprimento e conterá apenas caracteres minúsculos do alfabeto e
números.
Exemplos
Entrada: ["10011", "10100"]

Saída: 3
Entrada: ["helloworld", "worldhello"]
Saída: 8
função HammingDistance(strArr) {
let count = 0;
for (let i = 0; i < strArr[0].length; i++) {
if (strArr[0][i] !== strArr[1][i]) {
contagem++
}
}
}

HammingDistance(linha de leitura());
var palavra1 = strArr[0],
palavra2 = strArr[1],
len = palavra1.length,
contagem = 0;

if (word1[i] !== word2[i]) {
contagem++;
}
}
}

var hammingDistância = 0;
for (var i = 0; i < strArr[0].length; i++) {
if (strArr[0][i] !== strArr[1][i]) {
hammingDistância++;
}
}
retorno dificultadoDistância;
}

Área do retângulo
Solução de usuário mais bem avaliada
função RectangleArea(strArr) {
var obj = {};
obj.x1 = parseInt(strArr[0].match(/((-*d+)/)[1], 10);
obj.y1 = parseInt(strArr[0].match(/(-*d+))/)[1], 10);
para (var i = 1; i < 3; i++) {

if (obj.x1 !== parseInt(strArr[i].match(/((-*d+)/)[1], 10)) {
obj.x2 = parseInt(strArr[i].match(/((-*d+)/)[1], 10);
}
if (obj.y1 !== parseInt(strArr[i].match(/(-*d+))/)[1], 10)) {
obj.y2 = parseInt(strArr[i].match(/(-*d+))/)[1], 10);
}
}
if (Object.keys(obj).length !== 4) {
retorno 0;
} else {
retorno (Math.abs(obj.x1 - obj.x2) * Math.abs(obj.y1 - obj.y2));
}
}

RectangleArea(readline());
Analisar entrada na matriz

deixe coords = strArr.map(function(val){
deixe coords = val.split(' ');
deixe x = parseInt(coords[0].substr(1, coords[0].length-1));
deixe y = parseInt(coords[1].substr(0, coords[1].length-1));
retorno [x,y];
});
deixe ponto = coords.shift();

deixe x = ponto[0];
Seja y = ponto[1];
deixe deltaX = 0;
deixe deltaY = 0;
coords.forEach(function(val){
if (x === val[0]) {
deltaY = Math.abs(val[1] - y);
}
if (y === val[1]) {
deltaX = Math.abs(val[0] - x);
}
});
retorno deltaX * deltaY;

var pontos = strArr.map(str => str.match(/\d+/g));
var minX = pontos.mapa(ponto => ponto[0]).sort()[0];
var minY = pontos.mapa(ponto => ponto[1]).sort()[0];
var maxX = pontos.map(ponto => ponto[0]).sort().reverse()[0];
var maxY = pontos.map(ponto => ponto[1]).sort().reverse()[0];
retorno (maxX - minX) * (maxY - minY);

}

Bitwise Um
Faça com que a função BitwiseOne(strArr) pegue a matriz de cadeias de caracteres armazenadas em
strArr, que conterá apenas duas cadeias de caracteres de comprimento igual que representam números
binários, e retorne uma cadeia de caracteres binária final que executou a operação bit a bit OU em ambas
as cadeias de caracteres. Uma operação bit a bit OR coloca um 0 na nova cadeia de caracteres onde há
zeros em ambas as cadeias binárias, caso contrário, ela coloca um 1 nesse ponto. Por exemplo: se
strArr é ["1001", "0100"], então seu programa deve retornar a cadeia de caracteres "1101"
Exemplos
Entrada: ["100", "000"]

Saída: 100
Entrada: ["00011", "01010"]

Saída: 01011
VER DESAFIO
função BitwiseOne(strArr) {
var str1 = strArr[0];
var str2 = strArr[1];
var newStr = '';
len = str1.length;

if(str1.charAt(i) === '1' || str2.charAt(i) === '1') {
newStr = newStr += '1';
} else {
newStr = newStr += '0';
}
}
retornar newStr;
}
BitwiseOne(linha de leitura());
saída var = '';
if (strArr[0][i] === '1' || strArr[1][i] === '1') {
saída += '1';
} else {
saída += '0';
}
}
saída de retorno;
}


newString += parseInt(strArr[0][i]) || parseInt(strArr[1][i]);
}
retornar newString;
}

Outros Produtos
Faça com que a função OtherProducts(arr) pegue a matriz de números armazenados em arr e
retorne uma nova lista dos produtos de todos os outros números na matriz para cada elemento. Por
exemplo: se arr é [1, 2, 3, 4, 5], então a nova matriz, onde cada local na nova matriz é o produto de
todos os outros elementos, é [120, 60, 40, 30, 24]. Para obter essa resposta foram realizados os seguintes
cálculos: [(2*3*4*5), (1*3*4*5), (1*2*4*5), (1*2*3*5), (1*2*3*4)]. Você deve gerar essa nova matriz
e, em seguida, retornar os números como uma cadeia de caracteres unida por um hífen: 120-60-40-30-24.
A matriz conterá no máximo 10 elementos e pelo menos 1 elemento somente de inteiros positivos.
Exemplos
Entrada: [1,4,3]
Saída: 12-3-4
Entrada: [3,1,2,6]
Saída: 12-36-18-6
função OtherProducts(arr) {
deixe holdArray = [];
arr.forEach((val, ind, theArray) => {

newArray = Array.from(theArray)
newArray.splice(ind,1)
holdArray[ind] = newArray.reduce((val1, val2) => val1 * val2);

})
retornar holdArray.join('-');
}

OutrosProdutos(readline());
deixe resultados = [];

deixar produto = 1;
for (deixe j = 0; j < arr.length; j++) {
se (i !== j) {
produto *= arr[j];
}
}
results.push(produto);
}
retornar resultados.join('-');
}

função produto(arr) {
retorno arr.reduce((a,b) => a * b);
}
produtos var = [];
var other = arr.slice(0, i).concat(arr.slice(i + 1));
products.push(produto(outro));
}
devolver produtos.join('-');
}

Classificação de Ondas
Faça com que a função WaveSorting(arr) pegue a matriz de inteiros positivos armazenados em arr
e retorne a string true se os números puderem ser organizados em um padrão de onda: a1 > a2 < a3 > a4
< a5 > ..., caso contrário, retorne a string false. Por exemplo, se arr é: [0, 1, 2, 4, 1, 4], então uma
possível ordenação de onda dos números é: [2, 0, 4, 1, 4, 1]. Então, para essa entrada, seu programa deve
retornar a cadeia de caracteres true. A matriz de entrada sempre conterá pelo menos 2 elementos. Mais
exemplos são dados abaixo como exemplos de casos de teste.
Exemplos
Entrada: [0, 1, 2, 4, 1, 1, 1]
Saída: false
Entrada: [0, 4, 22, 4, 14, 4, 2]

Saída: true
função WaveSorting(arr) {
pensando nisso, o resultado desejado será possível desde que não tenhamos um
número único
mais vezes do que outros números para quebrá-lo
obter o número total de números

deixe comprimento = arr.comprimento;
obter o número de entradas para cada número

deixe countObj = {};
arr.forEach(val => {
if (!countObj[val]) {
countObj[val] = 1;
} else {
countObj[val]++;
}
});
Faça uma matriz de nossos resultados, para que possamos encontrar o máximo
deixe contarArr = [];
for (deixe a chave em countObj) {
countArr.push(countObj[chave]);
}
Encontre o Max - não precisa mais usar apply()!

deixe maxCount = Math.max(... Conde;
retornar maxCount > comprimento/2 ? falso : verdadeiro;

WaveSorting(linha de leitura());
arr = arr.sort((a,b) => a - b).reverse();

newArr = [];
deixe halfLength = Math.floor(arr.length / 2);
newArr = [];
para (deixe i = 0, n = arr.length; i < n; i++) {

Se (i % 2 === 0) {
newArr.push(arr.splice(0, 1));
} else {
Olhe e tome o próximo elemento menor que arr[i]
for (deixe j = 1; j < arr.length; j++) {
if (arr[j] < arr[0]) {
newArr.push(arr.splice(j, 1));
quebrar;
}
}
}
Verificar se o novo Arr está classificado por onda

for (let i = 0; i < newArr.length-1; i++) {
Se (i % 2 === 0) {
i > i+1 = verdadeiro
if (parseInt(newArr[i]) <= parseInt(newArr[i+1])) {
retornar false;
}
} else {
i < i+1 = verdadeiro
if (parseInt(newArr[i]) >= parseInt(newArr[i+1])) {
retornar false;
}
}
}
retorno verdadeiro;
}

Encontre a contagem do elemento mais frequente, que é o modo

função mostFrequent(arr) {
arr.sort();
var mais = 0;
frequência var = 1;
if (arr[i] === arr[i + 1]) {
frequência++;
if (frequência > mais) {
maioria = frequência;
}
} else {
frequência = 1;
}
}
devolver a maioria;
}
contanto que possamos colocar algum outro número entre o mesmo número, ele
funciona
retorno maisFrequent(arr) < (arr.length / 2);
}

Correspondência de matriz
Faça com que a função ArrayMatching(strArr) leia a matriz de cadeias de caracteres armazenadas
em strArr que conterá apenas dois elementos, ambos representando uma matriz de inteiros positivos.
Por exemplo: se strArr for ["[1, 2, 5, 6]", "[5, 2, 8, 11]"], então ambos os elementos na entrada
representam duas matrizes inteiras, e seu objetivo para esse desafio é adicionar os elementos em locais
correspondentes de ambas as matrizes. Para a entrada de exemplo, seu programa deve fazer as seguintes
adições: [(1 + 5), (2 + 2), (5 + 8), (6 + 11)] que então é igual a [6, 4, 13, 17]. Seu programa deve
finalmente retornar essa matriz resultante em um formato de cadeia de caracteres com cada elemento
separado por um hífen: 6-4-13-17.
Se as duas matrizes não tiverem a mesma quantidade de elementos, basta acrescentar os elementos
restantes à nova matriz (exemplo mostrado abaixo). Ambas as matrizes estarão no formato: [e1, e2,
e3, ...] onde pelo menos um elemento existirá em cada matriz.
Exemplos
Entrada: ["[5, 2, 3]", "[2, 2, 3, 10, 6]"]

Saída: 7-4-6-10-6
Entrada: ["[1, 2, 1]", "[2, 1, 5, 2]"]

Saída: 3-3-6-2
função ArrayMatching(strArr) {
strArr = strArr.map(val => val.replace(/[[]]/g, '')
.split(/s*,s*/).map(val1 => parseInt(val1, 10)));
deixe resArr = [];

deixe arr1 = strArr[0];
deixe arr2 = strArr[1];
let length = Matemática.max(arr1.length, arr2.length);
para (deixe i = 0; i < comprimento; i++) {

if (arr1[i] && arr2[i]) {
resArr[i] = arr1[i] + arr2[i];
} else {
resArr[i] = arr1[i] || ARR2[i];
}
}
retornar resArr.join('-');

ArrayMatching(readline());
deixe números1 = strArr[0].substr(1, strArr[0].length-1).split(', ');

deixe números2 = strArr[1].substr(1, strArr[1].length-1).split(', ');
deixe maxLength = (numbers1.length > numbers2.length) ? numbers1.length :

numbers2.length;
deixe resultados = [];
for (let i = 0; i < maxLength; i++) {

deixe num1 = (i < numbers1.length) ? parseInt(números1[i]) : 0;
deixe num2 = (i < numbers2.length) ? parseInt(números2[i]) : 0;
resultados.push(num1 + num2);
}
retornar resultados.join('-');
}

arr1 = strArr[0].match(/\d+/g).map(Número);
arr2 = strArr[1].match(/\d+/g).map(Número);
if (arr1.length > arr2.length) {

arr2 = arr2.concat(nova matriz(arr1.length - arr2.length).fill(0));
} else if (arr1.length < arr2.length) {
arr1 = arr1.concat(nova matriz(arr2.length - arr1.length).fill(0));
}
var soma = [];
para (var i = 0; i < arr1.length; i++) {
sum.push(arr1[i] + arr2[i]);
}
retorno sum.join('-');
}

Reversão binária
Faça com que a função BinaryReversal(str) pegue o parâmetro str que está sendo passado, que
será um inteiro positivo, pegue sua representação binária (acolchoada para o N * 8 bits mais próximo),
inverta essa cadeia de bits e, finalmente, retorne a nova cadeia invertida na forma decimal. Por exemplo:
se str é "47", então a versão binária deste inteiro é 101111 mas nós a preenchemos para ser 00101111.
Seu programa deve reverter essa cadeia binária que então se torna: 11110100 e, finalmente, retornar a
versão decimal dessa cadeia de caracteres, que é 244.
Exemplos
Entrada: "213"
Saída: 171
Entrada: "4567"
Saída: 60296
função BinaryReversal(str) {
deixe núm = parseInt(str, 10)

.toString(2);
deixe comprimento = num.length;
adicionar zeros à esquerda para tornar o número um número integral de bytes

let byteString = '${'0'.repeat(length % 8 === 0 ? 0 : 8 - length % 8)}${num}';
let stringByte = byteString.split('')

.reverso()
.join('');
retornar parseInt(stringByte, 2).toString();

BinaryReversal(readline());
let binário = parseInt(str).toString(2);
deixe o tamanho = Math.ceil(binary.length/8) * 8;

enquanto (binary.length < size) {
binário = '0' + binário;
}

para (deixe i = 0; i < binary.length; i++) {
newString = binário[i] + newString;
}
retornar parseInt(newString, 2);

}

função toBinary(str) {
resultado = Number(str).toString(2);
pad esquerda com 0s à esquerda para torná-lo um múltiplo de 8 dígitos...
if (resultado.comprimento % 8 !== 0)
retornar novo Array(8 - (result.length % 8)).fill(0).join('') + resultado;
senão retornar resultado;
}
função toDecimal(str) {
retorno parseInt(str, 2);
}
retornar paraBinary(str);
var reverso = toBinary(str).split('').reverse().join('');
retornar aDecimal(reverso);
}

Sequência crescente mais longa
Faça com que a função LongestIncreasingSequence(arr) pegue a matriz de inteiros positivos

armazenados em arr e retorne o comprimento da subsequência crescente mais longa (LIS). Um LIS é
um subconjunto da lista original onde os números estão em ordem classificada, do mais baixo para o
mais alto, e estão em ordem crescente. A sequência não precisa ser contígua ou única, e pode haver
várias subsequências diferentes. Por exemplo: se arr é [4, 3, 5, 1, 6], então um LIS possível é [3, 5, 6],
e outro é [1, 6]. Para essa entrada, seu programa deve retornar 3 porque esse é o comprimento da
subsequência crescente mais longa.
Exemplos
Entrada: [9, 9, 4, 2]
Saída: 1
Entrada: [10, 22, 9, 33, 21, 50, 41, 60, 22, 68, 90]
Saída: 7
função LongestIncreasingSequence(arr) {
deixe len = arr.length;
deixe arrHolder = [];
avaliar cada combinação possível de números

for (let i = Math.pow(2, len); i < Math.pow(2, len + 1); i++) {
numArray é um dígito binário, os 0s e 1s que representam se devem ser

incluídos
um número ou não na matriz de combinação. Haverá 2 ^ n combinações
Para obter zeros à esquerda, use números de 2^n a 2^n+1 e, em seguida, corte
o 1 à esquerda
let numArray = i.toString(2).slice(1).split('');
mantenha os números selecionados na matriz newSeq

newSeq = [];
preencher a matriz newSeq

arr.forEach((val, ind) => {
if (numArray[ind] === '1') {
newSeq.push(val);
}
});
incluir a matriz newSeq no arrHolder

arrHolder.push(novoSeq);
}
Remova todas as matrizes que não estão ascendentes (use o ascend() para
determinar)
arrHolder = arrHolder.filter(val => ascendente(val));
Substitua cada matriz de passagem por seu comprimento

deixe arrLength = arrHolder.map(val => val.length);
retornar o maior valor de comprimento

retornar Matemática.max(... arrComprimento);
}
função ascend(inputArr) {
deixe arrlen = inputArr.length;
return inputArr.every((val, ind) => {
if (ind < arrlen - 1) {
return val < inputArr[ind + 1];
}
retorno verdadeiro;
});
}

LongestIncreasingSequence(linha de leitura());
https://stackoverflow.com/questions/2631726/how-to-determine-the-longest-increasing-
subsequence-using-dynamic-programming
Algoritmo usado a partir daqui
deixe lis = [arr[0]];

if (arr[i] > lis[lis.length - 1]) {
lis.push(arr[i]);
continuar;
}
para (deixe j = 0; j < lis.length; j++) {

if (lis[j] >= arr[i]) {
lis[j] = arr[i];
quebrar;
}
}
}
retorno lis.length;

gera n permutações verdadeiras/falsas

Isso será usado para gerar subsequências - para incluir ou não este elemento
função permute(n) {
se (n < 1) retornar null;
se (n < 2) retornar [[verdadeiro], [falso]];
var anterior = permuta(n - 1);
resultado var = [];
for (permutação var do anterior) {
result.push(permutation.concat([verdadeiro]));
result.push(permutation.concat([falso]));
}
}
obter todas as subsequências possíveis
função getSubSequences(arr) {
return permute(arr.length).map(function(permutation) {
resultado var = [];
para (var i = 0; i < permutação.length; i++) {
if (permutação[i]) {
resultado.empurrar(arr[i]);
}
}
});
}
função aumentando(arr) {
return arr.every(function(value, index, arr) {
var prev = (índice === 0) ? 0: arr[índice - 1];
retornar valor de < anterior;
});
}
var maior = 0;
var subSequences = getSubSequences(arr);

for (var subSequence of subSequences) {
if(increasing (subSequence) && subSequence.length > mais longo) {
longest = subSequence.length;
}
}
retorno mais longo;
}

Pares pares pares
Faça com que a função EvenPairs(str) pegue o parâmetro str que está sendo passado e determine
se um par de números pares adjacentes existe em qualquer lugar na cadeia de caracteres. Se existir um
par, retorne a cadeia de caracteres true, caso contrário, retorne false. Por exemplo: se str é
"f178svg3k19k46", então há dois números pares no final da string, "46", então seu programa deve
retornar a string true. Outro exemplo: se str é "7r5gg812", então o par é "812" (8 e 12), então seu
programa deve retornar a string true.
Exemplos
Entrada: "3gy41d216"
Saída: true
Entrada: "f09r27i8e67"
Saída: false
função EvenPairs(str) {
var regEx = /[24680]d*[24680]/
retornar regEx.test(str);

EvenPairs(linha de leitura());
const DÍGITOS = '0123456789';
deixe numberGroups = [];
Obter grupos de dígitos

for (deixe i = 0, digitStr = ''; i < str.length; i++) {
let isDigit = DIGITS.includes(str[i]);
if (isDigit) {
digitStr += str[i];
}
if (digitStr.length > 0 && (i === str.length - 1 || !isDigit)) {

numberGroups.push(digitStr);
digitStr = '';
}
}
Preocupe-se apenas com o comprimento do grupo > 1

numberGroups = numberGroups.filter(v => v.length > 1);
Loop sobre todos os "grupos"

for (let i = 0; i < numberGroups.length; i++) {
Loops aninhados para cada grupo
for (seja j = 0; j < numberGroups[i].length; j++) {
for (deixe k = j + 1; k < numberGroups[i].length; k++) {
let str1 = numberGroups[i].substr(0, j+1);
let str2 = numberGroups[i].substr(j+1, k);
if (parseInt(str1) % 2 === 0 && parseInt(str2) % 2 === 0) {
retorno verdadeiro;
}
}
}
}
retornar false;
}

veja se há mais de dois pares de números pares

função hasEvenPairs(número) {
correspondência não gananciosa de números pares
resultado var = number.toString().match(/\d*?[ 24680]/g);
return (resultado === null) ? false : (resultado.comprimento >= 2);
}
números var = str.match(/\d+/g);
for (var número de números) {
if (hasEvenPairs(number)) retornar true;
}
retornar false;
}

Próximo Palíndromo
Faça com que a função NextPalindrome(num) pegue o parâmetro num que está sendo passado e
retorne o próximo maior número palindrômico. A entrada pode ser qualquer inteiro positivo. Por
exemplo: se num é 24, então seu programa deve retornar 33 porque esse é o próximo maior número que
é um palíndromo.
Exemplos
Entrada: 2
Saída: 3
Entrada: 180
Saída: 181
função NextPalindrome(num) {
deixe contar = num + 1;
enquanto (verdadeiro) {
numString = count.toString();
revString = numString.split('')
.reverso()
.join('');
if (revString === numString) retorna parseInt(numString, 10);
contagem++;
}
}

NextPalindrome(readline());
deixe nextPalindrome = null;

para (deixe i = num + 1; ; i++) {
let string = i.toString();
if (isPalindrome(string)) {
próximoPalíndromo = i;
quebrar;
}
}
retornar em seguidaPalindrome;
função isPalindrome(str) {
retornar false;
}
}
retorno verdadeiro;
}
}

função isPalindrome(num) {
var numStr = num.toString();
return numStr.split('').reverse().join('') === numStr;
}
var nextNum = num + 1;
enquanto (!isPalindrome(nextNum)) {
próximoNum++;
}
retornar nextNum;
}

Maior par
Faça com que a função LargestPair(num) pegue o parâmetro num que está sendo passado e
determine o maior número de dois dígitos dentro do número inteiro. Por exemplo: se num é 4759472
então seu programa deve retornar 94 porque esse é o maior número de dois dígitos. A entrada sempre
conterá pelo menos dois dígitos positivos.
Exemplos
Entrada: 453857
Saída: 85
Entrada: 363223311
Saída: 63
função LargestPair(num) {
deixe numStr = num.toString();
deixe numArr = numStr.split('')

.map(val => parseInt(val, 10));
livrar-se do dígito final, caso seja o maior;

numArr.pop();
deixe maxNum = Matemática.max(... numArr);
let regEx = novo RegExp('${maxNum}\d', 'g');
let matches = numStr.match(regEx);
retornar matches.sort((a, b) => a - b).pop();

}

LargestPair(linha de leitura());
Seja maiorNum = 0;
deixe testNum = parseInt(num[i-1] + num[i]);
if (testNum > largestNum) {
largestNum = testNum;
}
}
retornar maiorNum;
}
var máx = 0;
var numStr = num.toString();
janela de correr com tamanho 2

for (var i = 0; i < numStr.length - 1; i++) {
var testNum = Número(numStr.slice(i, i + 2));
if (testNum > max) {
max = testNum;
}
}
retorno máximo;
}

Caractere não repetitivo
Faça com que a função NonrepeatingCharacter(str) pegue o parâmetro str que está sendo
passado, que conterá apenas caracteres alfabéticos e espaços, e retorne o primeiro caractere não
repetitivo. Por exemplo: se str é "agettkgaeee", então seu programa deve retornar k. A cadeia de
caracteres sempre conterá pelo menos um caractere e sempre haverá pelo menos um caractere não
repetitivo.
Exemplos
Entrada: "abcdef"
Saída: a
Entrada: "hello world hi hey"

Saída: w
função NonrepeatingCharacter(str) {
let len = str.length;
deixe countObj = {}
para (deixe i = 0; i < len; i++) {

if (countObj[str[i]]) {
countObj[str[i]]++;
}
senão {
countObj[str[i]] = 1;
}
}
para (deixe j = 0; j < len; j++) {
if (countObj[str[j]] === 1) retorno str[j];
}
}

NonrepeatingCharacter(readline());
vamos repetirChars = '';

deixe resultado = '';
deixe repetir = falso;
for (deixe j = i+1; j < str.length; j++) {
if (str[i] === str[j] || repeatingChars.includes(str[i])) {
repetição = verdadeiro;
repetindoChars += str[i];
quebrar;
}
}
se (!repetindo) {
resultado = str[i];
quebrar;
}
}
}

str = str.replace(/\s+/g, '');
var contagens = {};
Conte cada letra

para (var i = 0; i < str.length; i++) {
if (str[i] em contagens) {
contagens[str[i]]++;
} else {
contagens[str[i]] = 1;
}
}
devolver a primeira letra com contagem de 1

para (i = 0; i < str.length; i++) {
if (counts[str[i]] === 1) return str[i];
}
}

Duas Somas
Faça com que a função TwoSum(arr) pegue a matriz de inteiros armazenados em arr e determine se
quaisquer dois números (excluindo o primeiro elemento) na matriz podem somar ao primeiro elemento
na matriz. Por exemplo: se arr é [7, 3, 5, 2, -4, 8, 11], então existem na verdade dois pares que somam
o número 7: [5, 2] e [-4, 11]. Seu programa deve retornar todos os pares, com os números separados por
uma vírgula, na ordem em que o primeiro número aparece na matriz. Os pares devem ser separados por
um espaço. Então, para o exemplo acima, seu programa retornaria: 5,2 -4,11
Se não houver dois números que somem o primeiro elemento na matriz, retorne -1
Exemplos
Entrada: [17, 4, 5, 6, 10, 11, 4, -3, -5, 3, 15, 2, 7]

Saída: 6,11 10,7 15,2
Entrada: [7, 6, 4, 1, 7, -2, 3, 12]

Saída: 6,1 4,3
função TwoSum(arr) {
deixe o alvo = arr.shift();
deixe segurar = [];

para (deixe j = i + 1; j < len; j++) {
if (arr[i] + arr[j] === target) {
holdArr.push('${arr[i].toString()},${arr[j].toString()}');
quebrar;
}
}
}
retorno holdArr.length ? holdArr.join(' ') : -1;
}

TwoSum(linha de leitura());
resposta const = arr.shift(arr);

const history = novo Set();
const corresponde = [];
Sem reverso () aqui, os resultados finais serão na ordem

O segundo número aparece na matriz, mas queremos que seja
ordenado pelo primeiro número.
arr.reverso();
arr.forEach(item => {
const elogio = resposta - item;
if (history.has(elogio)) {
matches.push([item, elogio]);
} else {
history.add(item);
}
});
As partidas foram empurradas para a matriz em ordem inversa, então

agora precisamos trocá-los de volta.
matches.reverse();
return (matches.length === 0) ? -1 : matches.map(m => m.join(',')).join(' ');

}

encontrar pares que somem o número fornecido

função findPairs(arr, sum) {
pares var = [];
for (var j = i + 1; j < arr.length; j++) {
if (arr[i] + arr[j] === soma)
pares.push([arr[i], arr[j]]);
}
}
pares de retorno;
}
pares var = [];
var soma = arr[0];
var repouso = arr.fatia(1);
pares = findPairs(repouso, soma);
return (pairs.length === 0) ? -1 : pairs.map(pair => pair.join(',')).join(' ');

}

Dois Bitwise
Faça com que a função BitwiseTwo(strArr) pegue a matriz de cadeias de caracteres armazenadas em
strArr, que conterá apenas duas cadeias de caracteres de comprimento igual que representam números
binários, e retorne uma cadeia de caracteres binária final que executou a operação bit a bit AND em
ambas as cadeias de caracteres. Uma operação bit a bit AND coloca um 1 na nova cadeia de caracteres
onde há um 1 em ambos os locais nas cadeias binárias, caso contrário, coloca um 0 nesse ponto. Por
exemplo: se strArr é ["10111", "01101"], então seu programa deve retornar a cadeia de caracteres
"00101"
Exemplos
Entrada: ["100", "000"]

Saída: 000
Entrada: ["10100", "11100"]

Saída: 10100
função BitwiseTwo(strArr) {
deixe num1 = strArr[0];
deixe num2 = strArr[1];
let len = strArr[0].comprimento;
deixe resStr = '';

if (num1[i] === '1' && num2[i] === '1') {
resStr += '1';
continuar;
}
senão {
resStr += '0';
continuar;
}
}
retorno resStr;
}

BitwiseTwo(linha de leitura());
deixe newStr = '';

newStr += (strArr[0][i] === strArr[1][i] && strArr[0][i] !== '0') ? '1' :
'0';
}
retornar newStr;
}

resultado var = '';
if (strArr[0][i] === '1' && strArr[1][i] === '1') {
resultado += '1';
} else {
resultado += '0';
}
}
}

Contagem do conjunto de energia
Faça com que a função PowerSetCount(arr) pegue a matriz de inteiros armazenados em arr e
retorne o comprimento do conjunto de energia (o número de todos os conjuntos possíveis) que podem
ser gerados. Por exemplo: se arr é [1, 2, 3], então os seguintes conjuntos formam o conjunto de
potência:
[][1][2][3][1, 2][1, 3][2, 3][1, 2, 3]
Você pode ver acima de todos os conjuntos possíveis, juntamente com o conjunto vazio, são gerados.
Portanto, para essa entrada, seu programa deve retornar 8.
Exemplos
Entrada: [1, 2, 3, 4]
Saída: 16
Entrada: [5, 6]
Saída: 4
função PowerSetCount(arr) {
retorno Math.pow(2, len);
}

PowerSetCount(linha de leitura());
retorno Math.pow(2, arr.length);
}

retorno Math.pow(2, arr.length);
}

Dígitos do produto
Faça com que a função ProductDigits(num) pegue o parâmetro num que está sendo passado, que
será um inteiro positivo, e determine a menor quantidade de dígitos que você precisa multiplicar para
produzi-lo. Por exemplo: se num é 24, então você pode multiplicar 8 por 3 o que produz 24, então seu
programa deve retornar 2 porque há um total de apenas 2 dígitos que são necessários. Outro exemplo: se
num é 90, você pode multiplicar 10 * 9, então neste caso seu programa deve produzir 3 porque você não
pode chegar a 90 sem usar um total de 3 dígitos em sua multiplicação.
Exemplos
Entrada: 6
Saída: 2
Entrada: 23
Saída: 3
função ProductDigits(num) {
deixe pivotar = Math.sqrt(num);
let value = num.toString().length + 1;
para (deixe i = 1; i <= pivô; i++) {
if (num % i === 0) {
deixe maxFactor = i;
maxCompFactor = núm / maxFactor;
maxFactorString = maxFactor.toString();
maxCompFactorString = maxCompFactor.toString();
deixe totalLength = maxFactorString.length +
maxCompFactorString.length;
if (totalLength < valor) {
valor = totalLength;
}
}
}
valor de retorno;
}

ProductDigits(readline());
deixe pf = primeFactors(num);
if (pf.length === 1) {
retornar pf[0].toString().length + 1;
}
deixar fatores = [];
para (deixe divisor = 0; divisor < pf.length; divisor ++) {

deixe à esquerda = pf.slice(0, divisória);
deixe à direita = pf.slice(divisória, pf.length);
deixe leftProduct = left.reduce((produto, valor) => produto *= valor, 1);

deixe direitoProduto = direito.reduce((produto, valor) => produto *= valor,
1);
fatores.push([leftProduct, rightProduct]);
}
return factors.map(factor => factor.join('').split('').length).reduce((max, val)

=> val < max ? val : max, Número.MAX_SAFE_INTEGER);
função primeFactors(num) {
se (num === 1) retornar 1;
Seja pf = [];
para (deixe i = 2; i <= num; i++) {

if (num % i === 0) {
pf.push(i);
núm /= i;
i = 1;
}
}
retorno pf;
}
}

função getDivisors(num) {
divisores var = [1];
para (var i = 2; i <= num / 2; i++) {
if (num % i === 0) {
divisores.push(i);
}
}
divisores.push(num);
divisores de retorno;
}
var divisores = getDivisors(num);
pares var = [];
para (var i = 0; i < divisores.length / 2; i++) {

pairs.push([divisores[i], divisores[(divisores.comprimento - 1) - i]]);
}
pares de retorno.map(par => ('' + par[0] + par[1]).length).sort()[0];

}

Criador de Palíndromo
Faça com que a função PalindromeCreator(str) pegue o parâmetro str que está sendo passado e
determine se é possível criar uma cadeia de caracteres palindrômica de comprimento mínimo de 3
caracteres removendo 1 ou 2 caracteres. Por exemplo: se str é "abjchba", então você pode remover os
caracteres jc para produzir "abhba", que é um palíndromo. Para este exemplo, seu programa deve
retornar os dois caracteres que foram removidos sem delimitador e na ordem em que aparecem na cadeia
de caracteres, então jc. Se 1 ou 2 caracteres não puderem ser removidos para produzir um palíndromo,
retorne a cadeia de caracteres não possível. Se a string de entrada já for um palíndromo, seu programa
deverá retornar a cadeia de caracteres palíndromo.
A entrada conterá apenas caracteres alfabéticos minúsculos. Seu programa deve sempre tentar criar a
subcadeia palindrômica mais longa removendo 1 ou 2 caracteres (veja o segundo caso de teste de
exemplo como exemplo). Os 2 caracteres removidos não precisam estar adjacentes na cadeia de
caracteres.
Exemplos
Entrada: "mmop"
Saída: não é possível
Entrada: "kjjjhjjj"
Saída: k
função PalindromeCreator(str) {
teste para ver se já é um Palíndromo
if (isPalindrome(str)) {
retorno 'palíndromo';
}
let testArray = str.split('');
deixe res = testArray.splice(i, 1);
let newString = testArray.join('');
if (isPalindrome(newString)) {
console.log('um');
retornar res.join('');
}
}
deixe res = [];
para (deixe j = i; j < len - 1; j++) {
let testArray = str.split('');
res[0] = testArray.splice(i, 1);
res[1] = testArray.splice(j, 1);
let newString = testArray.join('');
if(isPalindrome(newString)) {
retornar res.join('');
}
}
}
retorno 'não possível';
}
----------------Ajudantes---------------------------
deixe newStr = str.split('').reverse().join('');
if (newStr === str) {
retorno verdadeiro;
}
retornar false;
}

PalindromeCreator(readline());
if (isPalindrome(str)) {
retorno 'palíndromo';
}
Criar combos
deixe combos = [];
for (let i = 0, max = Math.pow(2, str.length); i < max; i++) {
deixe combo = i.toString(2);
Filtro para zero, um ou dois 1s (1 representa remoção)

let count = 0;
for (deixe j = 0; j < combo.length; j++) {
if (combo[j] === '1') {
contagem++;
}
}
Muito grande, ignore e vá para a próxima tentativa!
if (contagem > 2) {
continuar;
}
Pad bom combo

enquanto (combo.length < str.length) {
combo = '0' + combo;
}
combos.push(combo);
}
deixe palindromeCombos = [];
Tente remover combos

para (deixe i = 0; i < combos.length; i++) {
deixe tryString = '';
for (deixe j = 0; j < combos[i].length; j++) {
tryString += (combos[i][j] === '1') ? '' : str[j];
}
if (tryString.length >= 3 && isPalindrome(tryString)) {

palindromeCombos.push(combos[i]);
}
}
if (palindromeCombos.length === 0) {
}
Ordenar assim que as duas primeiras letras encontradas sejam devolvidas primeiro
para quando
há vários valores
palindromeCombos.sort(function(a,b){
retorno parseInt(a,2) < parseInt(b,2);
});
Localizar e retornar a remoção mais curta <=> palíndromo mais longo

let shortestCount = null;
deixe shortestCombo = '';
palindromeCombos.forEach(function(combo){
let count = 0;
para (deixe i = 0; i < combo.length; i++) {
if (combo[i] === '1') {
contagem++;
}
}
if (shortestCount === null || count < shortestCount) {
shortestCount = contagem;
shortestCombo = combo;
}
});
deixe resultado = '';

if (shortestCombo[i] === '1') {
resultado += str[i];
}
}
return (str === str.split('').reverse().join('')) ? verdadeiro : falso;
}

return str === str.split('').reverse().join('');
}
se (isPalindrome(str)) retornar 'palíndromo';

Remover um caractere na posição I
var newStr = str.slice(0, i).concat(str.slice(i + 1));
if (isPalindrome(newStr)) {
vertente de retorno[i];
}
}

Remova dois caracteres na posição i e j, onde (i < j)
para (var j = i + 1; j < str.length; j++) {
var newStr2 = str.slice(0, i).concat(str.slice(i + 1,
j)).concat(str.slice(j + 1));
if (isPalindrome(newStr2)) {
retorno str[i] + str[j];
}
}
}
retorno "não possível";
}

Algarismos romanos básicos
Já a função BasicRomanNumerals(str) lê str que será uma cadeia de algarismos romanos. Os

algarismos utilizados são: I para 1, V para 5, X para 10, L para 50, C para 100, D para 500 e M para
1000. Em algarismos romanos, para criar um número como 11 basta adicionar um 1 após o 10, assim
você obtém XI. Mas para criar um número como 19, você usa a notação de subtração , que é adicionar
um I antes de um X ou V (ou adicionar um X antes de um L ou C). Assim, 19 em algarismos romanos é
XIX.
O objetivo do seu programa é retornar o equivalente decimal do algarismo romano dado. Por exemplo: se
str é "XXIV" seu programa deve retornar 24
Exemplos
Entrada: "IV"
Saída: 4
Entrada: "XLVI"
Saída: 46
função BasicRomanNumerals(str) {
deixe letterObj = {
I: 1,
V: 5,
X: 10,
L: 50,
C: 100,
D: 500,
Telefone: 1000
}
deixe res = 0;
if (!letterObj[str[i + 1]] || letterObj[str[i]] >= letterObj[str[i +
1]]) {
res += letraObj[str[i]];
} else {
res += (letterObj[str[i + 1]] - letterObj[str[i]]);
i++;
}
}
retorno res;
}

BasicRomanNumerals(readline());
/*
Símbolo Eu V X L C D M
Valor1 5 10 50 100 500 1,000
*/
const ROMAN_I = 1;
const ROMAN_V = 5;
const ROMAN_X = 10;
const ROMAN_L = 50;
const ROMAN_C = 100;
const ROMAN_D = 500;
const ROMAN_M = 1000;
deixe a soma = 0;

símbolo de let = str[i];
deixe nextSymbol = (i+1 >= str.length) ? nulo : str[i+1];
switch(símbolo) {
caso 'I':
if (nextSymbol === 'V') {
soma += ROMAN_V - ROMAN_I;
i++;
} else if (nextSymbol === 'X') {
soma += ROMAN_X - ROMAN_I;
i++;
} else {
soma += ROMAN_I;
}
quebrar;
caso «V»:
soma += ROMAN_V;
quebrar;
caso «X»:
if (nextSymbol === 'L') {
soma += ROMAN_L - ROMAN_X;
i++;
} else if (nextSymbol === 'C') {
soma += ROMAN_C - ROMAN_X;
i++;
} else {
soma += ROMAN_X;
}
quebrar;
processo «L»:
soma += ROMAN_L;
quebrar;
processo «C»:
if (nextSymbol === 'D') {
soma += ROMAN_D - ROMAN_C;
i++;
} else if (nextSymbol === 'M') {
soma += ROMAN_M - ROMAN_C;
i++;
} else {
soma += ROMAN_C;
}
quebrar;
processo «D»:
soma += ROMAN_D;
quebrar;
processo «M»:
soma += ROMAN_M;
quebrar;
inadimplência:
Carvão ou espaço ilegal
quebrar;
}
}
}

var decimais = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1];
var romans = ['M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV',
'I'];
saída var = 0;
para (var i = 0; i < romans.length; i++) {

Continue correndo enquanto há uma partida no início
enquanto (str.indexOf(romans[i]) === 0) {
saída += decimais[i];
str = str.replace(Romans[i], '');
}
}
saída de retorno;
}

Distribuição de Alimentos
Já a função FoodDistribution(arr) lê a matriz de números armazenados em arr que representará

o nível de fome de diferentes pessoas variando de 0 a 5 (0 significa não ter fome, 5 significa muita
fome). Você também terá N sanduíches para distribuir, que variam de 1 a 20. O formato da matriz será
[N, h1, h2, h3, ...] onde N representa o número de sanduíches que você tem e o resto da matriz
representará os níveis de fome de diferentes pessoas. Seu objetivo é minimizar a diferença de fome entre
cada par de pessoas na matriz usando os sanduíches que você tem disponíveis.
Por exemplo: se arr é [5, 3, 1, 2, 1], isso significa que você tem 5 sanduíches para distribuir. Você pode
distribuí-los na seguinte ordem para as pessoas: 2, 0, 1, 0. Dando esses sanduíches ao povo seus níveis
de fome agora se tornam: [1, 1, 1, 1]. A diferença entre cada par de pessoas agora é 0, o total também é
0, então seu programa deve retornar 0. Nota: Você pode não ter que dar todos, ou mesmo nenhum, de
seus sanduíches para produzir uma diferença minimizada.
Outro exemplo: se arr é [4, 5, 2, 3, 1, 0], então você pode distribuir os sanduíches na seguinte ordem:
[3, 0, 1, 0, 0], o que torna todos os níveis de fome os seguintes: [2, 2, 2, 1, 0]. As diferenças entre cada
par de pessoas agora é: 0, 0, 1, 1 e assim seu programa deve retornar a diferença final minimizada de 2.
Exemplos
Entrada: [5, 2, 3, 4, 5]
Saída: 1
Entrada: [3, 2, 1, 0, 4, 1, 0]
Saída: 4
função FoodDistribution(arr) {
let treats = arr.shift();
deixe myArray = arr.slice(0);
deixe arrMin = arr.sort((val1, val2) => val2 - val1).pop()
deixe len = myArray.length;
verifique se temos guloseimas suficientes para levar todos ao melhor nível

atual
let testCount = myArray.reduce((val1, val2) => {
retorno val1 + val2 - arrMin;
}, 0);
if (testCount <= trata) {
retorno 0;
}
let valQuantArr = objectify(myArray);
para (seja i = 1; i < 25; i++) {

deixe arrayLen = valQuantArr.length;
let resp = flattenMid(valQuantArr, trata, i);
valQuantArr = resp[0];
arrayLen = valQuantArr.length;
trata = resp[1];
enquanto (valQuantArr[0].quant <= i && valQuantArr[0].value >
valQuantArr[1].value && trata >= i) {
if (valQuantArr[0].quant <= trata) {
valQuantArr[0].valor--;
trata -= valQuantArr[0].quant;
valQuantArr = objetivar(valQuantArr);
}
}
enquanto (valQuantArr[arrayLen - 1].quant <= i && valQuantArr[arrayLen -

1].value > valQuantArr[arrayLen - 2].value && trata >= i) {
if (valQuantArr[arrayLen - 1].quant <= trata) {
valQuantArr[arrayLen - 1].valor--;
trata -= valQuantArr[arrayLen - 1].quant;
valQuantArr = objetivar(valQuantArr);
}
}
}
let count = 0;
for (let i = 0, len = valQuantArr.length; i < len - 1; i++) {
count += Math.abs(valQuantArr[i].value - valQuantArr[i + 1].value);
}
}
-----------------Ajudantes-----------------------
flattenMid = (arr, trata, q) => {
índice de let = 0;
enquanto (trata > 0 && índice > -1) {
index = arr.findIndex((val, ind) => {
return val.quant <= q && ind >= 1 && ind < arr.length - 1 &&
val.value > arr[ind - 1].value && val.value > arr[ind + 1].value;
});
if (índice >= 0) {
arr[índice].valor --;
trata -= q;
}
}
retorno [objetivar(arr), trata];
}
transforma uma matriz em um objeto com o valor igual ao número e o

quant sendo o número de vezes que ocorre em uma linha
objetivar = (matriz) => {
se for a matriz de números
if (typeof array[0] === 'número') {
deixe o alvo = [];
deixe o contador = 0;
for (let i = 0, len = array.length; i < len; i++) {
let val = matriz[i];
contador++;
if (array[i] === matriz[i + 1]) {
continuar;
} else {
target.push({
valor: matriz[i],
quant: contador
});
contador = 0;
}
}
meta de retorno;
} else {
se for uma matriz de objetos, transforme-a em uma matriz de números, e
Em seguida, execute-o através do método Objectify
deixe targetArray = [];
array.forEach (val => {
enquanto (val.quant) {
targetArray.push (valor.valor);
Val.Quant--;
}
});
return objectify(targetArray);
}
};

FoodDistribution(readline());
deixe sanduíches = parseInt(arr.shift());
Gerar combos, limitação deste método, máximo de 32 sanduíches

deixe combos = [];
for (let i = 0, max = Math.pow(sandwiches+1, arr.length); i < max; i++) {
deixe combo = i.toString(sanduíches+1);
Soma de dígitos (sanduíches) no combo

deixe comboSum = parseInt(combo.split('').reduce((acumulador, currentValue)
=> acumulador + parseInt(currentValue, sanduíches+1), 0));
Muitos sanduíches
if (comboSum > sanduíches) {
continuar;
}
Também pode adicionar um cheque aqui para remover sanduíches que colocariam
fome < 0
Combos de boas combinações

enquanto (combo.length < arr.length) {
}
if (comboSum <= sanduíches) {

combos.push(combo);
}
}
Encontre a menor diferença de fome
let lowestHungerDifference = null;
combos.forEach(function(combo){
deixe testArr = arr.slice();
testArr[i] -= combo[i];
}
let diff = getHungerDifference(testArr);
lowestHungerDifference = (lowestHungerDifference === null || diff <
lowestHungerDifference) ? diff : menorHungerDifference;
});
retorno mais baixoFomeDiferença;
função getHungerDifference(arr){
deixe diff = 0;
diff += Math.abs(arr[i] - arr[i-1]);
}
diff de retorno;
}

var N = arr[0];
var fomeNíveis = arr.slice(1);
enquanto (N > 0) {
var maxDiferença = 0;
o índice a ser alimentado com um sanduíche em seguida
var maisNecessário = -1;
para (var i = 0; i < hungerLevels.length - 1; i++) {
var diferença = Math.abs(hungerLevels[i + 1] - hungerLevels[i]);
if (diferença > maxDifference) {
maxDifference = diferença;
mostNeeded = (fomeNíveis[i + 1] > fomeNíveis[i]) ? (i + 1) : i;
}
}
Agora sabemos quem precisa tanto do sanduíche. doe-o
if (mostNeeded === -1) {
as diferenças adjacentes são todas 0's, então pare de dar os sanduíches
fora
retorno 0;
} else {
fomeNíveis[maisNecessário] -= 1;
N--;
}
}
calcular a soma das diferenças adjacentes
var somaDeDiferenças = 0;
para (var i = 0; i < hungerLevels.length - 1; i++) {
sumOfDifferences += Math.abs(fomeNíveis[i + 1] - fomeNíveis[i]);
}
retorno somaDeDiferenças;
}

Três Soma
Faça com que a função ThreeSum(arr) pegue a matriz de inteiros armazenados em arr e determine se
três números distintos (excluindo o primeiro elemento) na matriz podem somar ao primeiro elemento na
matriz. Por exemplo: se arr é [8, 2, 1, 4, 10, 5, -1, -1], então existem na verdade três conjuntos de
trigêmeos que somam o número 8: [2, 1, 5], [4, 5, -1] e [10, -1, -1]. Seu programa deve retornar a cadeia
de caracteres true se 3 elementos distintos somam ao primeiro elemento, caso contrário, seu programa
deve retornar a cadeia de caracteres false. A matriz de entrada sempre conterá pelo menos 4 elementos.
Exemplos
Entrada: [10, 2, 3, 1, 5, 3, 1, 4, -4, -3, -2]

Saída: true
Entrada: [12, 3, 1, -5, -4, 7]

Saída: false
função ThreeSum(arr) {
deixe o alvo = arr.shift();
para (deixe i = 0; i < len - 2; i++) {
para (deixe j = i + 1; j < len - 1; j++) {
para (deixe k = i + 2; k < len; k++) {
if (arr[i] + arr[j] + arr[k] === target) {
retornar "verdadeiro";
}
}
}
}
retornar "false"
}

ThreeSum(linha de leitura());
let resposta = parseInt(arr.shift());
Gerar combos
deixe combos = [];
para (deixe i = 0, max = Math.pow(2, arr.length); i < max; i++) {
let digitsSum = parseInt(combo.split('').reduce((acumulador,valor) =>

acumulador + parseInt(value), 0));
if (digitsSoma !== 3) {
continuar;
}
Dígitos do teclado
enquanto (combo.length < arr.length) {
}
combos.push(combo);
}
Combos de teste
deixe goodCombos = [];
deixe a soma = 0;
if (combo[i] === '1') {
soma += parseInt(arr[i]);
}
}
if (soma === resposta) {
goodCombos.push(combo);
}
});
return (goodCombos.length > 0) ? verdadeiro : falso;

var soma = arr[0];
números var = arr.slice(1);
para (var i = 0; i < numbers.length; i++) {

para (var j = i + 1; j < numbers.length; j++) {
para (var k = j + 1; k < numbers.length; k++) {
if (números[i] + números[j] + números[k] === soma) {
retorno 'verdadeiro';
}
}
}
}
retornar 'falso';
}

Caminho correto
Faça com que a função CorrectPath(str) leia o parâmetro str que está sendo passado, que
representará os movimentos feitos em uma grade 5x5 de células a partir da posição superior esquerda. Os
caracteres na string de entrada serão inteiramente compostos por: r, l, u, d, ?. Cada um dos caracteres
representa a direção a ser tomada dentro da grade, por exemplo: r = direita, l = esquerda, u = para cima,
d = para baixo. Seu objetivo é determinar quais caracteres os pontos de interrogação devem ser para que
um caminho a ser criado vá do canto superior esquerdo da grade até o canto inferior direito sem tocar
nas células da grade.
Por exemplo: se str é "r?d?drdd", então seu programa deve produzir a sequência de caracteres final
correta que permitirá que um caminho seja formado a partir do canto superior esquerdo de uma grade
5x5 para o canto inferior direito. Para essa entrada, seu programa deve, portanto, retornar a cadeia de
caracteres rrdrdrdd. Haverá apenas um caminho correto e sempre haverá pelo menos um ponto de
interrogação dentro da cadeia de caracteres de entrada.
Exemplos
Entrada: "??? rrurdr?"

Saída: dddrrurdrd
Entrada: "drdr?? rrddd?"

Saída: drdruurrdddd
função CorrectPath(str) {
Criar uma matriz para manter as posições dos pontos de interrogação
deixe blankArray = [];
colocar a posição dos pontos de interrogação na matriz
str.split('').forEach((val, ind) => {
if (val === '?') {
blankArray.push(ind);
}
});
let num = blankArray.length;

vamos tentar cada possibilidade até encontrarmos uma que funcione, Isso será
4^num permutações
deixe total = Math.pow(4, num);
para (deixe i = 0; i < total; i++) {

passar por cada permutação, primeiro criando um número representativo,
depois fazendo o caminho e, em seguida, testando-o
deixe numString = (i + total).toString(4).slice(1);
let currentPath = createPath(str, blankArray, numString);
if (isPathGood(currentPath)) {
retornar currentPath;
}
}
}
isPathGood = (str) => {

criar nossa matriz vazia
deixe testArray = []
para (deixe i = 0; i < 5; i++) {
testArray.push([0, 0, 0, 0, 0])
}

deixe currentLoc = [0, 0];

Marque nossa praça atual como visitada
testArray[currentLoc[0]][currentLoc[1]] = 1;
alterar a posição com base na próxima letra
deixe newLoc = currentLoc.slice(0);
switch (str[i]) {
Processo 'U':
newLoc[0]--;
quebrar;
Caso «D»:
newLoc[0]++;
quebrar;
Processo «R»:
newLoc[1]++;
quebrar;
Processo «L»:
newLoc[1]--;
quebrar;
}
Desista se a gente tiver saído do tabuleiro
if (newLoc.includes (-1) || newLoc.includes (5)) {
retornar false;
}
sair se estivermos em um espaço visitado anteriormente
if (testArray[newLoc[0]][newLoc[1]] === 1) {
retornar false;
}
retornar verdadeiro se estivermos na praça alvo em nossa última ida
if (newLoc[0] === 4 && newLoc[1] === 4 && i === len - 1) {
retorno verdadeiro;
}
atualizar nossa localização para o próximo loop;
currentLoc = novoLoc;
}
retornar false;
};
createPath = (str, espaços em branco, num) => {

deixe moveArray = ['r', 'l', 'u', 'd'];
strArr = str.split('');
blanks.forEach((val, ind) => {
strArr.splice(val, 1, moveArray[num[ind]]);
});
retorno strArr.join('');
};

CorrectPath(linha de leitura());
deixe numQmarks = str.split('').reduce((a,v) => a + (v === '?' | 0), 0);
Gerar combos, 0-r, 1-d, 2-l, 3-u

deixe combos = [];
para (deixe i = 0, max = Math.pow(4, numQmarks); i < max; i++) {
Almofada
enquanto (combo.length < numQmarks) {
}
combos.push(combo);
}
deixe goodPaths = [];
Tente caminhos
deixe comboArray = combo.split('');
deixe tryPath = '';
if (str[i] === '?') {
let direction = comboArray.shift();
Interruptor (direção) {
Processo '0': // Direito
tryPath += 'r';
quebrar;
Processo «1»: // para baixo
tryPath += 'd';
quebrar;
Processo «2»: // Esquerda
tryPath += 'l';
quebrar;
Processo «3»: // acima
tryPath += 'u';
quebrar;
inadimplência:
Nunca deveria acontecer
quebrar;
}
} else {
tryPath += str[i];
}
}
if (pathGood(tryPath)) {
goodPaths.push(tryPath);
}
});
goodPaths de acordo com a especificação só deve ser === 1, mas este código pode
lidar com casos mais verdadeiros
retornar goodPaths[0];
Confirmar/Negar bom caminho (com Qmarks preenchido)

caminho da funçãoGood(caminho) {
deixe startX = 0;
deixe startY = 0;
deixe grade = [
[1,0,0,0,0],
[0,0,0,0,0],
[0,0,0,0,0],
[0,0,0,0,0],
[0,0,0,0,0]
]; Gol 4,4
para (deixe i = 0; i < path.length; i++) {

switch (caminho[i]) {
Processo «R»:
startX++;
quebrar;
Caso «D»:
startY++;
quebrar;
Processo «L»:
startX--;
quebrar;
Processo 'U':
startY--;
quebrar;
inadimplência:
Nunca deveria acontecer
quebrar;
}
if (startX < 0 || startX > 4 || startY < 0 || startY > 4 || grid[startY]
[startX] === 1) {
já viajou ou fora dos limites
retornar false;
}
grid[startY][startX] = 1;
}
return (startX === 4 && startY === 4) ? verdadeiro : falso;
}
}

verificar se as direções dadas podem chegar à linha de chegada

sem tocar em posições visitadas anteriormente
função canNavigate(str) {
var posição = [0, 0];
var visitado = {};
switch(str[i]) {
Processo 'U':
posição[0]--;
se (posição[0] < 0) retornar false;
quebrar;
Caso «D»:
posição[0]++;
se (posição[0] > 4) retornar false;
quebrar;
Processo «L»:
posição[1]--;
se (posição[1] < 0) retornar false;
quebrar;
Processo «R»:
posição[1]++;
se (posição[1] > 4) retornar false;
quebrar;
inadimplência:
quebrar;
}
if (visitado[posição[0] + '-' + posição[1]]) {
já visitou antes
retornar false;
} else {
marcar como visitado
visitado[posição[0] + '-' + posição[1]] = i;
}
}
retorno (posição[0] === 4 && posição[1] === 4);

}
função findMissingChars(str) {
Primeiro, gerar todos os casos possíveis: substituindo ? com instruções
permutações var = [''];
if (str[i] === '?') {
var newPermutations = [];
permutations.forEach(function(permutation) {
newPermutations.push(permutação + 'u');
newPermutations.push(permutação + 'd');
newPermutations.push(permutação + 'l');
newPermutations.push(permutação + 'r');
});
permutações = novasPermutações;
} else {
permutações = permutações.map(permutação => permutação + str[i]);
}
}
agora filtre apenas os válidos

precisamos de um resultado líquido de 4 downs e 4 direitos
retornar permutações.filter(function(permutation) {
var rightCount = permutation.match(/[r]/g) === nulo ? 0 :
permutation.match(/[r]/g).length;
var leftCount = permutation.match(/[l]/g) === null ? 0 :
permutation.match(/[l]/g).length;
var upCount = permutation.match(/[u]/g) === nulo ? 0 :
permutation.match(/[u]/g).length;
var downCount = permutation.match(/[d]/g) === null ? 0 :
permutation.match(/[d]/g).length;
return (rightCount - leftCount === 4) && (downCount - upCount === 4);

});
}
var validPaths = findMissingChars(str);
for (var validPath de validPaths) {

if (canNavigate(validPath)) {
retornar validPath;
}
}
}

Balanceamento de Escala
Já a função ScaleBalancing(strArr) lê strArr que conterá dois elementos, sendo o primeiro os

dois pesos inteiros positivos em uma balança (lados esquerdo e direito) e o segundo elemento sendo
uma lista de pesos disponíveis como inteiros positivos. Seu objetivo é determinar se você pode equilibrar
a balança usando a menor quantidade de pesos da lista, mas usando no máximo apenas 2 pesos. Por
exemplo: se strArr é ["[5, 9]", "[1, 2, 6, 7]"] então isso significa que há uma balança com um peso de
5 no lado esquerdo e 9 no lado direito. Na verdade, é possível equilibrar esta balança adicionando um 6
para o lado esquerdo da lista de pesos e adicionando um 2 para o lado direito. Ambas as escalas serão
agora iguais a 11 e estão perfeitamente equilibradas. Seu programa deve retornar uma sequência
separada por vírgulas dos pesos que foram usados da lista em ordem crescente, portanto, para este
exemplo, seu programa deve retornar a sequência de caracteres 2,6
Haverá apenas uma solução única e a lista de pesos disponíveis não estará vazia. Também é possível
adicionar dois pesos a apenas um lado da balança para equilibrá-la. Se não for possível equilibrar a
escala, seu programa deve retornar a cadeia de caracteres não possível.
Exemplos
Entrada: ["[3, 4]", "[1, 2, 7, 7]"]

Saída: 1
Entrada: ["[13, 4]", "[1, 2, 3, 6, 14]"]

Saída: 3,6
função ScaleBalancing(strArr) {
converter o array para algo mais viável
deixe newArr = strArr.map(val => {
retornar val.replace(/[\[\]]/g, "").split(',').map(val2 => {
retorno parseInt(val2, 10);
}).sort((a, b) => {
retornar a - b;
});
});
let diff = newArr[0][1] - newArr[0][0];

deixe pesos = newArr[1];
Faça o teste da solução de peso único

if (weights.includes(diff)) {
retornar diff.toString();
}
Faça o teste de dois pesos, um lado
deixe weight1 = weights.find((val, ind) => {
deixe newWeights = weights.slice(0);
newWeights.splice(ind, 1);
return newWeights.includes (diff - val)
});
if (peso1) {
retornar '${weight1},${diff - weight1}'
}
fazer os pesos twp, lados diferentes, teste
weight1 = weights.find(val => {
Retornos Weights.Includes(diff + val);
});
if (peso1) {
retornar '${weight1},${diff + weight1}'
}
se nada for devolvido ainda...

ScaleBalancing(linha de leitura());
let objects = strArr[0].substr(1, strArr[0].length-2).split(', ').map(object =>

parseInt(object));
deixe pesos = strArr[1].substr(1, strArr[1].length-2).split(', ').map(weight =>
parseInt(weight));
/*
Gerar todas as combinações possíveis de pesos E permutações de
esquerda/direita - 3^n tempo
0 - Peso não utilizado
1 - Peso do lado esquerdo
2 - Peso do lado direito
*/
deixe combos = [];
para (deixe i = 0, max = Math.pow(3, pesos.comprimento); i < max; i++) {
deixe numWeights = combo.split('').reduce((a,v) => a + (parseInt(v) > 0 | 0),
0);
Muitos pesos, descarte esse combo

if (numWeights > 2) {
continuar;
}
Almofada
enquanto (combo.length < weights.length) {
}
combos.push(combo);
}
console.log(combos);
Combos de teste
deixe goodCombos = [];
deixe à esquerda = objetos[0];
deixe direito = objetos[1];

if (combo[i] === '1') { // Esquerda
esquerda += pesos[i];
}
if (combo[i] === '2') { // Direito
direita += pesos[i];
}
}
if (esquerda === direita) {

goodCombos.push(combo);
}
});
if (goodCombos.length === 0) {
}
Ordenar primeiro por número de pesos físicos utilizados e, em seguida, por peso
total se existirem vários conjuntos
goodCombos.sort(função(a, b){
deixe aCount = a.split('').reduce((ac,v) => ac + (parseInt(v) > 0 | 0), 0);
deixe bCount = b.split('').reduce((ac,v) => ac + (parseInt(v) > 0 | 0), 0);
if (aCount < bCount) {

retorno -1;
}
if (aCount > bCount) {
retorno 1;
}
aCount === bCount -> deve verificar pesos e usar peso total menor
deixe aTotal = 0;
deixe bTotal = 0;
para (deixe i = 0; i < a.length; i++) {
if (a[i] !== '0') {
aTotal += pesos[i];
}
if (b[i] !== '0') {
bTotal += pesos[i];
}
}
retorno aTotal - bTotal;
});
console.log(goodCombos);
deixe oCombo = goodCombos[0];

deixe finalWeights = [];
theCombo.split('').map(function(value, index) {
if (valor !== '0') {
finalWeights.push(pesos[índice]);
}
});
return finalWeights.sort((a,b) => a-b).join(',');

}

pesos var = strArr[1].match(/\d+/g).map(Número);
var weightsOnScale = strArr[0].match(/\d+/g).map(Número);
var leftWeight = pesosOnScale[0];
var rightWeight = pesosOnScale[1];
tente apenas um peso

para (var i = 0; i < pesos.comprimento; i++) {
if (leftWeight < rightWeight) {
if (leftWeight + weights[i] === rightWeight)
pesos de retorno[i];
} else {
if (leftWeight === rightWeight + pesos[i])
pesos de retorno[i];
}
}
Agora tente dois pesos

para (var i = 0; i < pesos.comprimento; i++) {
para (var j = i + 1; j < weights.length; j++) {
adicionar um de cada lado
if (leftWeight + weights[i] === rightWeight + weights[j]) {
pesos de retorno[i] + ',' + pesos[j];
} else if (leftWeight + weights[j] === rightWeight + weights[i]) {
}
adicionar dois no lado mais leve
if (leftWeight < rightWeight) {
if (leftWeight + weights[i] + weights[j] === rightWeight) {
}
} else {
if (leftWeight === rightWeight + weights[i] + weights[j]) {
}
}
}
}
sem solução
}

Três números
Faça com que a função ThreeNumbers(str) pegue o parâmetro str que está sendo passado e
determine se exatamente três inteiros únicos de um dígito ocorrem dentro de cada palavra na cadeia de
caracteres. Os inteiros podem aparecer em qualquer lugar da palavra, mas não podem ser todos
adjacentes uns aos outros. Se cada palavra contiver exatamente 3 inteiros exclusivos em algum lugar
dentro dela, retorne a cadeia de caracteres true, caso contrário, retorne a string false. Por exemplo: se
str é "2hell6o3 wor6l7d2", então seu programa deve retornar "true", mas se a string é "hell268o
w6or2l4d", então seu programa deve retornar "false" porque todos os inteiros são adjacentes uns aos
outros na primeira palavra.
Exemplos
Entrada: "2a3b5 w1o2rl3d g1gg92"

Saída: true
Entrada: "21aa3a ggg4g4g6ggg"

Saída: false
função ThreeNumbers(str) {
const DÍGITOS = '0123456789';
deixe as palavras = str.split(' ');
let result = null;
words.forEach(function(word){
deixe os números = 0;
deixe trêsAdjacente = falso;
deixe usedDigits = '';
para (deixe i = 0; i < word.length; i++) {
Verificar se há dígitos usados
if (usedDigits.includes(word[i])) {
usado! falhar
resultado = falso;
}
if (DIGITS.includes(word[i])) {
números++;
usedDigits += palavra[i];
if (números === 3) {
if (DIGITS.includes(word[i-1]) && DIGITS.includes(word[i-2])) {
threeAdjacent = verdadeiro;
}
}
}
Verifique se há 3 dígitos anteriores adjacentes
}
if (números === 3 && !threeAdjacent) {

resultado = (resultado === nulo) ? true : resultado && verdadeiro;
} else {
resultado = falso;
}
});
}

ThreeNumbers(linha de leitura());
var palavras = str.split(' ');
var numbersOfWords = words.map(word => word.match(/\d+/g));
for (números var de numbersOfWords) {

Verifique exatamente 3 números em cada palavra
var dígitos = números.join('');
if (digits.length !== 3)
retornar false;
não são permitidos 3 números seguidos
if (numbers.length !== numbers.filter(number => number.length < 3).length)
retornar false;
nenhum número duplicado nesses 3 números
if ((dígitos[0] === dígitos[1]) ||
(dígitos[1] === dígitos[2]) ||
(dígitos[2] === dígitos[0]))
retornar false;
}
retorno verdadeiro;
}

deixe matriz = str.split(' ');

for (let i = 0; i < array.length; i++) {
if (/[0-9]{3,}/.exec(array[i]) !== null) {
retornar false;
} else {
Seja n = array[i].match(/[0-9]/g);
if (n[0] === n[1] || n[1] === n[2] || n[0] === n[1]) {
retornar false;
}
}
}
retorno verdadeiro;

Pesquisa do alfabeto
Faça com que a função AlphabetSearching(str) pegue o parâmetro str que está sendo passado e
retorne a cadeia de caracteres true se cada letra do alfabeto inglês existir na cadeia de caracteres, caso
contrário, retorne a string false. Por exemplo: se str é "zacxyjbbkfgtbhdaielqrm45pnsowtuv", então seu
programa deve retornar a cadeia de caracteres true porque todos os caracteres do alfabeto existem nessa
cadeia de caracteres, mesmo que alguns caracteres apareçam mais de uma vez.
Exemplos
Entrada: "abcdefghijklmnopqrstuvwxyyyy"
Saída: false
Entrada: "abc123456kmo"
Saída: false
função AlphabetSearching(str) {
str = str.toLowerCase();
para (deixe i = 97; i < 97 + 26; i++) {
deixe char = String.fromCharCode(i);
if (!str.includes(char)) {
retornar false;
}
}
retorno verdadeiro;
}

AlphabetSearching(linha de leitura());
const LOWER_LETTERS = 'abcdefghijklmnopqrstuvwxyz';
para (deixe i = 0; i < LOWER_LETTERS.length; i++) {

if (!str.includes(LOWER_LETTERS[i])) {
retornar false;
}
}
retorno verdadeiro;
}

função isAlpha(char) {
retornar /[A-Za-z]/.test(char);
}
var foundLetters = [];
if ( isAlpha(str[i]) && (foundLetters.indexOf(str[i]) === -1) ) {
foundLetters.push(str[i]);
}
}
return foundLetters.length === 26;
}

Diferença de tempo
Faça com que a função TimeDifference(strArr) leia a matriz de strings armazenadas em strArr,
que será uma lista não ordenada de tempos em um formato de doze horas assim: HH:MM(am/pm). Seu
objetivo é determinar a menor diferença em minutos entre dois dos tempos da lista. Por exemplo: se
strArr é ["2:10pm", "1:30pm", "10:30am", "4:42pm"] então seu programa deve retornar 40 porque a
menor diferença é entre 13:30 e 14:10 com uma diferença de 40 minutos. A matriz de entrada sempre
conterá pelo menos dois elementos e todos os elementos estarão no formato correto e exclusivos.
Exemplos
Entrada: ["1:10pm", "4:40am", "5:00pm"]

Saída: 230
Entrada: ["10:00am", "11:45pm", "5:00am", "12:01am"]

Saída: 16
função TimeDifference(strArr) {
os tempos manterão nossas diferenças de tempo
deixe os tempos = [];
deixe newStrArr = strArr.map (val => {
let matches = val.match(/^(\d+):(\d+)([ap]m)$/);
deixe horas = parseInt(matches[1], 10);
deixe minutos = parseInt(partidas[2], 10);
deixe metade = fósforos[3];
if (metade === 'am' && horas === 12) {
horas = 0;
}
if (metade === 'pm' && horas !== 12) {
horas += 12;
}
retorno (horas * 60 + minutos);
})
.sort((a, b) => { return a - b});
complicado - segundo exemplo mostra que temos que considerar o primeiro tempo
tanto no dia 0 quanto no dia 1
newStrArr.push(novoStrArr[0] + 24 * 60);
for (let i = 0, len = newStrArr.length; i < len - 1; i ++) {

times.push(newStrArr[i + 1] - novoStrArr[i]);
}
retornar Math.min.apply(null, times);
}

TimeDifference(linha de leitura());
deixe timesInSeconds = [];

strArr.forEach(function(strTime){
deixe par = strTime.split(':');
deixe horas = (par[1][2] === 'a') ? parseInt(par[0]) % 12 : parseInt(par[0])
% 12 + 12;
deixe segundos = parseInt(pair[1].substr(0,2));
deixe totalSeconds = horas * 60 + segundos;
timesInSeconds.push(totalSegundos);
});
Iterar mais de 2^n combos

let smallestDifference = Número.MAX_VALOR;
for (let i = 0, max = Math.pow(2,timesInSeconds.length); i < max; i++) {
deixe timesUsed = combo.split('').reduce((a,v) => a + (v === '1' | 0), 0);
if (timesUsed === 2) {
Almofada
enquanto (combo.length < timesInSeconds.length) {
}
Itere sobre cada combinação específica e teste-as

deixe diff = 0;
deixe par = [];
for (deixe j = 0; j < combo.length; j++) {
if (combo[j] === '1') {
pair.push(temposInSegundos[j]);
}
}
deixe t1 = Math.abs(par[0] - par[1]);

deixe t2 = Math.abs(Math.min((1440 - par[0]), (par[0])) + Math.min((1440
- par[1]), (par[1])));
diff = Matemática.min(t1, t2);
if (diff < smallestDifference) {

menorDiferença = diff;
}
}
}
retorno menorDiferença;
}

let array = strArr.map(value => {
let corresponde = value.match(/^(\d+):(\d+)([ap]m)$/);
deixe h = parseInt(matches[1], 10);
deixe m = parseInt(matches[2], 10);
if (matches[3] === 'am' && h === 12) {
h = 0;
} else if (matches[3] === 'pm' && h !== 12) {
h += 12;
}
retorno (60 * h + m);
}).sort(função(a, b) {
retornar a - b;
});
array.push(matriz[0] + 24 * 60);
deixe os tempos = [];
for (let i = 0; i < array.length - 1; i++) {
times.push(matriz[i+1] - matriz[i]);
}
retornar Math.min(... vezes);
}
Linha Triângulo
Faça com que a função TriangleRow(num) tome num que será um inteiro positivo representando
alguma linha do triângulo de Pascal. O triângulo de Pascal começa com um [1] na 0ª linha do triângulo.
Então a primeira linha é [1, 1] e a segunda linha é [1, 2, 1]. A próxima linha começa com 1 e termina
com 1, e o interior da linha é determinado pela adição dos elementos k-1 e k-ésimo da linha anterior. A
próxima linha no triângulo seria então [1, 3, 3, 1], e assim por diante. A entrada será algum inteiro
positivo e seu objetivo é retornar a soma dessa linha. Por exemplo: se num é 4, então seu programa deve
retornar a soma de 1 + 4 + 6 + 4 + 1 que é 16.
Exemplos
Entrada: 1
Saída: 2
Entrada: 2
Saída: 4
função TriangleRow(num) {
retornar Math.pow(2, num);
}
console.log(TriangleRow(5));

TriangleRow(linha de leitura());
deixe triângulo = [];

para (deixe linha = 0; linha <= núm; linha++) {
deixe rowArr = [];
para (deixe i = 0; i <= linha; i++) {
if (i === 0) {
rowArr.push(1);
continuar;
}
deixe delta = (i < triângulo[linha-1].comprimento) ? triângulo[linha-1]
[i] : 0;
rowArr.push(triângulo[linha-1][i-1] + delta);
}
triângulo.push(rowArr);
}
triângulo de retorno[num].reduce((a,v) => a + v,0);
}
Obter a enésima linha e a k-ésima coluna do triângulo de Pascal

função pascalTriangle(n, k) {
se (n === 0) retornar 1;
if (k === 0 || k === n) retornar 1;
retorno pascalTriangle(n - 1, k - 1) + pascalTriangle(n - 1, k);
}
A resposta fácil - sempre soma até N^2
retorno num * num;
O caminho mais difícil

var rowSum = 0;
para (k = 0; k <= num; k++) {
resultado = pascalTriangle(num, k);
rowSum += resultado;
}
retorno rowSum;
}

Quadrado de Vogais
Faça com que a função VowelSquare(strArr) pegue o parâmetro strArr que está sendo passado,
que será uma matriz 2D de algum tamanho arbitrário preenchida com letras do alfabeto, e determine se
um quadrado 2x2 composto inteiramente de vogais existe na matriz. Por exemplo: strArr é ["abcd",
"eikr", "oufj"] então esta matriz se parece com o seguinte:
ab c d
ei k r
o u f j
Dentro desta matriz há um quadrado 2x2 de vogais começando na segunda linha e primeira coluna, a
saber, ei, ou. Se um quadrado 2x2 de vogais for encontrado, seu programa deve retornar a posição
superior esquerda (linha-coluna) do quadrado, portanto, para este exemplo, seu programa deve retornar
1-0. Se não existir um quadrado 2x2 de vogais, retorne a cadeia de caracteres não encontrada. Se
houver vários quadrados de vogais, retorne aquele que estiver na posição mais à esquerda em toda a
matriz. A matriz de entrada será pelo menos de tamanho 2x2.
Exemplos
Entrada: ["aqrst", "ukaei", "ffooo"]

Saída: 1-2
Entrada: ["gg", "ff"]

Saída: não encontrada
função VowelSquare(strArr) {
strArr = strArr.map(val => {
return val.toLowerCase().replace(/[aeiou]/g, "!");
})
for (deixe r = 0, len = strArr.length; r < len - 1; r++) {
for (deixe c = 0, len = strArr[0].length; c < len - 1; c++) {
if (checkPoint(strArr, [r, c])) {
retornar '${r}-${c}';
}
}
}
retornar 'não encontrado'
função checkPoint(arr, ponto) {

console.log('arr', arr[ponto[0]][ponto[1]]);
console.log('ponto', ponto);
retorno (
arr[ponto[0]][ponto[1]] === '!' &&
arr[ponto[0] + 1][ponto[1]] === '!' &&
arr[ponto[0]][ponto[1] + 1] === '!' &&
arr[ponto[0] + 1][ponto[1] + 1] === '!'
)
}

VogalSquare(linha de leitura());
for (deixe linha = 0; linha < strArr.length-1; row++) {

for (let col = 0; col < strArr[0].length-1; col++) {
if (isVowels2x2(strArr, row, col)) {
Bom! Volte primeiro porque nós
Pesquise em boa ordem
linha de retorno + '-' + col;
}
}
}
retorno 'não encontrado';
função isVowels2x2(strArr, row, col) {

Poderia fazer verificação de limites aqui, mas é feito em main()
if (!isVowel(strArr[row][col])) retornar false;

if (!isVowel(strArr[row+1][col])) retornar false;
if (!isVowel(strArr[row][col+1])) retornar false;
if (!isVowel(strArr[row+1][col+1])) retornar false;
retorno verdadeiro;
}
função isVogal(letra) {
const VOGAIS = 'aeiou';
retornar VOGAIS.includes(letra);
}
}

verificar se cada letra na matriz dada é uma vogal

função allVowels(matrix) {
return matrix.every(row => row.every(letter => 'aeiou'.indexOf(letter) !== -1));
}
matriz var = strArr.map(row => row.split(''));
for (var row = 0; row < matrix.length - 1; row++) {

para (var coluna = 0; coluna < matriz[0].length - 1; column++) {
teste com janelas deslizantes de submatriz 2x2
var subMatrix = matrix.slice(linha, linha + 2).map(rowArr =>
rowArr.slice(coluna, coluna + 2));
if (allVowels(subMatrix)) {
linha de retorno + '-' + coluna;
}
}
}
retorno 'não encontrado';

}

Inimigo mais próximo
Já a função ClosestEnemy(arr) pega a matriz de números armazenados em arr e a partir da posição

na matriz onde um 1 está, retorna o número de espaços à esquerda ou à direita que você deve mover para
alcançar um inimigo que é representado por um 2. Por exemplo: se arr é [0, 0, 1, 0, 0, 2, 0, 2], então
seu programa deve retornar 3 porque o inimigo mais próximo (2) está a 3 espaços de distância do 1. A
matriz conterá qualquer número de 0 e 2, mas apenas um único 1. Ele pode não conter nenhum 2
também, onde nesse caso seu programa deve retornar um 0.
Exemplos
Entrada: [1, 0, 0, 0, 2, 2, 2]
Saída: 4
Entrada: [2, 0, 0, 0, 2, 2, 1, 0]
Saída: 1
função ClosestEnemy(arr) {
se (!arr.includes(2)) {
retorno 0;
}
loc1 = arr.findIndex(val => {
retorno val === 1;
});
para (deixe i = 1, len = arr.length; i < len; i++) {

if (arr[loc1 + i] === 2 || arr[loc1 - i] === 2) {
retorno i;
}
}
retorno loc1;
}

ClosestEnemy(linha de leitura());
deixe herói = -1;

if (arr[i] === 1) { // Herói encontrado
herói = i;
}
}
Direito de pesquisa
deixe deltaRight = indefinido;
for (let i = hero+1; i < arr.length; i++) {
if (arr[i] === 2) { // Inimigo encontrado
deltaDireito = i - herói;
quebrar;
}
}
Pesquisar à esquerda
deixe deltaLeft = indefinido;
para (deixe i = herói-1; i >= 0; i--) {
if (arr[i] === 2) { // Inimigo encontrado
deltaLeft = herói - i;
quebrar;
}
}
if (deltaLeft === undefined && deltaRight === undefined) {
retorno 0;
}
if (deltaLeft === undefined) {

retorno deltaRight;
}
if (deltaRight === undefined) {

retorno deltaLeft;
}
retorno (deltaLeft < deltaRight) ? deltaEsquerda : deltaDireita;

}

índice de 1
var me = arr.indexOf(1);
var minimumDistance = arr.comprimento;

if (arr[i] === 2) {
var distância = Math.abs(i - me);
if (distância < mínimoDistância) {
minimumDistance = distância;
}
}
}
retorno (minimumDistance === arr.length) ? 0 : minimumDistance;

}

Inimigo mais próximo II
Faça com que a função ClosestEnemyII(strArr) leia a matriz de números armazenados em strArr
que será uma matriz 2D que contém apenas os inteiros 1, 0 ou 2. Então, a partir da posição na matriz
onde um 1 está, retorne o número de espaços para a esquerda, direita, para baixo ou para cima, você deve
se mover para alcançar um inimigo que é representado por um 2. Você é capaz de envolver um lado da
matriz para o outro também. Por exemplo: se strArr é ["0000", "1000", "0002", "0002"] então isso se
parece com o seguinte:
0000010000002000
2
Para esta entrada seu programa deve retornar 2 porque o inimigo mais próximo (2) está a 2 espaços de
distância do 1, movendo-se para a esquerda para envolver para o outro lado e, em seguida, movendo-se
para a esquerda para envolver para o outro lado e, em seguida, movendo-se para baixo uma vez. A
matriz conterá qualquer número de 0 e 2, mas apenas um único 1. Ele pode não conter nenhum 2
também, onde nesse caso seu programa deve retornar um 0.
Exemplos
Entrada: ["000", "100", "200"]

Saída: 1
Entrada: ["0000", "2010", "0000", "2002"]

Saída: 2
função ClosestEnemyII(strArr) {
Etapa um - retornar 0 se não houver 2 na matriz
deixe twosies = strArr.filter(val => {
retorno val.includes("2");
});
se (!twosies.length) {
retorno 0;
}
passo dois - obter as coordenadas do 1 (targetX, targetY)
targetY = strArr.findIndex(val => {
retorno val.includes('1');
});
targetX = strArr[targetY].search(/1/);
Passo três Encontre o menor caminho para um 2
deixe res = strArr.length * strArr[0].length;
for (deixe linha = 0, len = strArr[0].length; linha < len; linha++) {

para (col = 0, altura = strArr.length; col < altura; col++) {
if (strArr[row][col] === '2') {
xShift = rowDist(targetX, col, len);
yShift = rowDist(targetY, linha, altura);
res = Math.min(res, xShift + yShift);
}
}
}
retorno res;
}
--------------------Ajudantes----------------------
apesar do nome, use para distância de coluna e linha
função rowDist(y, x, len) {
retornar Math.min(Math.abs(x - y), Math.abs(y - x + len));
}

ClosestEnemyII(linha de leitura());
Encontre o herói
deixe heroY = -1;
deixe heroX = -1;
deixe resultado = strArr[i].indexOf(1);
if (resultado > -1) {
heroX = resultado;
heroY = i;
}
}
if (heroY === -1) {

Nenhum herói existe
retorno -1;
}
console.log(heroY + '-' + heroX);
Verifique se há inimigos
deixe inimigos = [];
deixe resultado = strArr[i].indexOf(2);
if (resultado > -1) {
inimigos.push([i,resultado]);
}
}
if (enemies.length === 0) {
retorno 0;
}
console.log(inimigos);
let closestDistance = Número.MAX_SAFE_INTEGER;
Verifique as distâncias inimigas

para (deixe i = 0; i < inimigos.length; i++) {
deixe inimigoX = inimigos[i][1];
deixe inimigoY = inimigos[i][0];
deixe deltaX = Math.abs(enemyX - heroX);

deixe deltaY = Math.abs(enemyY - heroY);
console.log(deltaY + '-' + deltaX);
Agora verifique os valores de wrap-around

deltaX é max porque se é mais então não nos importamos
let wrapDeltaX = Número.MAX_SAFE_INTEGER;
para (deixe i = 0; i < deltaX; i++) {
if ((enemyX + i) % strArr[0].length === heroX) {
encontrou o herói delta
wrapDeltaX = i;
console.log('wrap-aroundX: ' + i)
}
}
deixe wrapDeltaY = Número.MAX_SAFE_INTEGER;

para (seja i = 0; i < deltaY; i++) {
if ((enemyY + i) % strArr.length === heroY) {
encontrou o herói delta
wrapDeltaY = i;
console.log('wrap-aroundY: ' + i)
}
}
deltaX = (wrapDeltaX < deltaX) ? wrapDeltaX : deltaX;

deltaY = (wrapDeltaY < deltaY) ? wrapDeltaY : deltaY;
distância de saída = deltaX + deltaY;
if (distância < closestDistance) {

closestDistance = distância;
}
}
retorno mais próximoDistância;

Localizar a distância entre dois elementos com determinados índices [linha, coluna]
função getDistance(matrixSize, indices1, indices2) {
var rowDistance = Math.min(Math.abs(indices2[0] - indices1[0]),
Math.abs(indices1[0] - (indices2[0] - matrixSize)));
var columnDistance = Math.min(Math.abs(indices2[1] - indices1[1]),
Math.abs(indices1[1] - (indices2[1] - matrixSize)));
return rowDistance + columnDistance;
}
var matrix = strArr.map(line => line.split('').map(Número));
var minDistance = matriz.comprimento * 2;
Localização de Me: 1
var meÍndices;
Locais dos inimigos: 2's
var inimigosÍndices = [];
identificar os locais de 1 e 2
for (var row = 0; row < matrix.length; row++) {
for (var column = 0; column < matrix[0].length; column++) {
if (matriz[linha][coluna] === 1) {
meIndices = [linha, coluna];
} else if (matrix[row][column] === 2) {
enemiesIndices.push([linha, coluna]);
}
}
}
verificar a distância de mim para cada inimigo

for (var enemyÍndices de inimigosÍndices) {
var distance = getDistance(matrix.length, meIndices, enemyIndices);
if (distância < minDistância) {
minDistância = distância;
}
}
lida com o caso em que não há inimigo

return minDistance === matrix.length * 2 ? 0 : minDistância;
}

Fluxo de números
Faça com que a função NumberStream(str) pegue o parâmetro str que está sendo passado, que
conterá os números de 2 a 9, e determine se há um fluxo consecutivo de dígitos de pelo menos N
comprimento onde N é o valor real do dígito. Em caso afirmativo, retorne a cadeia de caracteres true,
caso contrário, retorne a cadeia de caracteres false. Por exemplo: se str é "6539923335", então seu
programa deve retornar a cadeia de caracteres true porque há um fluxo consecutivo de 3 de
comprimento 3. A cadeia de caracteres de entrada sempre conterá pelo menos um dígito.
Exemplos
Entrada: "5556293383563665"
Saída: false
Entrada: "5788888888882339999"
Saída: true
função NumberStream(str) {
para (seja i = 2; i < 10; i++) {
deixe iChar = i.toString();
deixe agulha = iChar.repeat(i);
if (str.indexOf(agulha) !== -1) {
retorno verdadeiro;
}
}
código vai aqui
retornar false;

NumberStream(linha de leitura());
para (let i = 0, lastDigit = -1, count = 0; i < str.length; i++) {

if (str[i] === lastDigit) {
Fluxo continuado
contagem++;
if (count >= Number(lastDigit)) {
retorno verdadeiro;
}
} else {
Novo fluxo
lastDigit = str[i];
contagem = 1;
}
}
retornar false;
}

gerar padrões primeiro
padrões var = [];
para (var i = 1; i < 10; i++) {
patterns.push(String(i).repeat(i));
}
for (padrão var de padrões) {

if (str.indexOf(pattern) !== -1) {
padrão encontrado
retorno verdadeiro;
}
}
retornar false;
}

Quatro maiores
Faça com que a função LargestFour(arr) pegue a matriz de inteiros armazenados em arr, e
encontre os quatro maiores elementos e retorne sua soma. Por exemplo: se arr é [4, 5, -2, 3, 1, 2, 6, 6],
então os quatro maiores elementos nessa matriz são 6, 6, 4 e 5 e a soma total desses números é 21, então
seu programa deve retornar 21. Se houver menos de quatro números na matriz, seu programa deverá
retornar a soma de todos os números na matriz.
Exemplos
Entrada: [1, 1, 1, -5]

Saída: -2
Entrada: [0, 0, 2, 3, 7, 1]
Saída: 13
função LargestFour(arr) {
deixe newArr = arr.sort((val1, val2) => {
retorno val2 - val1;
})
.splice(0, 4);
return newArr.reduce((val1, val2) => {
retornar val1 + val2;
}, 0);
}

LargestFour(linha de leitura());
return arr.sort((a,b) => b-a).reduce((a,v,i) => a + ((i < 4) ? v : 0), 0);

return arr.sort((a, b) => a < b).slice(0, 4).reduce((soma, v) => soma + v, 0);
}

Personagens distintos
Faça com que a função DistinctCharacters(str) pegue o parâmetro str que está sendo passado e
determine se ele contém pelo menos 10 caracteres distintos, em caso afirmativo, seu programa deve
retornar a cadeia de caracteres true, caso contrário, ele deve retornar a string false. Por exemplo: se str
é "abc123kkmmmm?" então seu programa deve retornar a string false porque essa string contém apenas
9 caracteres distintos: a, b, c, 1, 2, 3, k, m, ? soma 9.
Exemplos
Entrada: "12334bbmma:=6"
Saída: true
Entrada: "eeeemmmmmmmmm1000"
Saída: false
função DistinctCharacters(str) {
let mySet = novo Set(str.split(''));
retornar mySet.size >= 10 ? verdadeiro : falso
}

DistinctCharacters(linha de leitura());
deixe charCodes = [];
if (!charCodes.includes(str.charCodeAt(i))) {
charCodes.push(str.charCodeAt(i));
}
}
return (charCodes.length >= 10) ? verdadeiro : falso;

var distintivos = {};

distintivos[str[i]] = '';
}
retornar Object.keys(distincts).length >= 10;

}

Pontos de interrogação
Faça com que a função QuestionsMarks(str) pegue o parâmetro str string, que conterá números
de um dígito, letras e pontos de interrogação, e verifique se há exatamente 3 pontos de interrogação entre
cada par de dois números que somam 10. Se assim for, então seu programa deve retornar a cadeia de
caracteres true, caso contrário, ele deve retornar a cadeia de caracteres false. Se não houver dois
números que somam 10 na cadeia de caracteres, seu programa também deve retornar falso.
Por exemplo: se str é "arrb6??? 4xxbl5??? eee5" então seu programa deve retornar true porque há
exatamente 3 pontos de interrogação entre 6 e 4, e 3 pontos de interrogação entre 5 e 5 no final da string.
Exemplos
Entrada: "aa6?9"
Saída: false
Entrada: "acc?7?? SSS?3rr1?????? 5"

Saída: verdadeiro
função QuestionsMarks(str) {
deixe numPlaces = [];
presunção de falso, até que a bandeira se torne verdadeira
let flag = falso;
Obter uma matriz de lugares em inteiros de retenção de cadeia de caracteres

para (deixe i = 0, len = str.length; i < len; i++) {
if (/\d/.test(str[i])) {
numPlaces.push(i);
}
}
deixe numCount = numPlaces.length;
para (deixe i = 0; i < numCount - 1; i++) {

if (parseInt(str[numPlaces[i]], 10) + parseInt(str[numPlaces[i + 1]],
10) === 10) {
flag = verdadeiro;
let strSeg = str.slice(numPlaces[i], numPlaces[i + 1]);
strSeg = strSeg.replace(/[^\?] /g, '');

if (strSeg !== '??? ') {
retornar false;
}
}
}
bandeira de retorno;
}

QuestionsMarks(linha de leitura());
Estojo Camel
Faça com que a função CamelCase(str) pegue o parâmetro str que está sendo passado e o retorne no
formato de maiúsculas e minúsculas onde a primeira letra de cada palavra é maiúscula (excluindo a
primeira letra). A cadeia de caracteres conterá apenas letras e alguma combinação de caracteres de
pontuação delimitador separando cada palavra.
Por exemplo: se str é "BOB loves-coding", então seu programa deve retornar a string
bobLovesCoding.
Exemplos
Entrada: "gatos E*Cães-são incríveis"

Saída: catsAndDogsAreAwesome
Entrada: "a b c d-e-f%g"

Saída: aBCDEFG
função CamelCase(str) {
deixe strArr = str.split(/[â-zA-Z]/);
strArr = strArr.map((val, ind) => {
val = val.toLowerCase();
se (ind) {
valArr = val.split('');
valArr[0] = valArr[0].toUpperCase();
retorno valArr.join('');
}
retorno val;
})
retorno strArr.join('');
}

CamelCase(linha de leitura());
Conversão ASCII
Faça com que a função ASCIIConversion(str) pegue o parâmetro str que está sendo passado e
retorne uma nova cadeia de caracteres onde cada caractere, além do caractere de espaço, é substituído
por seu código de caractere decimal correspondente. Por exemplo: se str é "dog", então seu programa
deve retornar a string 100111103 porque d = 100, o = 111, g = 103.
Exemplos
Entrada: "hello world"

Saída: 104101108108111 119111114108100
Entrada: "abc **"

Saída: 979899 4242
função ASCIIConversion(str) {
deixe myArr = str.split(' ').map(val => {
retornar val.split('').map(val2 => {
retorno val2.charCodeAt(0);
}).join('')
}).join(' ');
retornar myArr;
}

ASCIIConversion(linha de leitura());
Evens simples
Faça com que a função SimpleEvens(num) verifique se cada número no parâmetro passed in é par.
Em caso afirmativo, retorne a cadeia de caracteres true, caso contrário, retorne a cadeia de caracteres
false. Por exemplo: se num é 4602225 seu programa deve retornar a sequência de caracteres false
porque 5 não é um número par.
Exemplos
Entrada: 2222220222
Saída: true
Entrada: 20864646452
Saída: false
função SimpleEvens(num) {
return num.toString(10).search(/[13579]/) === -1 ? 'verdadeiro' : 'falso';
}
SimpleEvens(linha de leitura());
Caso Snake
Faça com que a função SnakeCase(str) pegue o parâmetro str que está sendo passado e o devolva
no formato apropriado de caso de cobra, onde cada palavra é rebaixada e separada das palavras
adjacentes por meio de um sublinhado. A cadeia de caracteres conterá apenas letras e alguma
combinação de caracteres de pontuação delimitador separando cada palavra.
Por exemplo: se str é "BOB loves-coding", então seu programa deve retornar a string
bob_loves_coding.
Exemplos
Entrada: "gatos E*Cães-são incríveis"

Saída: cats_and_dogs_are_awesome
Entrada: "a b c d-e-f%g"

Saída: a_b_c_d_e_f_g
função SnakeCase(str) {
return str.split(/[â-zA-Z]/).map(val => {return
val.toLowerCase()}).join('_');
}
SnakeCase(linha de leitura());
Encontrar interseção
Faça com que a função FindIntersection(strArr) leia a matriz de cadeias de caracteres

armazenadas em strArr que conterá 2 elementos: o primeiro elemento representará uma lista de
números separados por vírgulas classificados em ordem crescente, o segundo elemento representará uma
segunda lista de números separados por vírgulas (também classificados). Seu objetivo é retornar uma
cadeia de caracteres separada por vírgulas contendo os números que ocorrem em elementos de strArr
em ordem classificada. Se não houver interseção, retorne a cadeia de caracteres false.
Por exemplo: se strArr contiver ["1, 3, 4, 7, 13", "1, 2, 4, 13, 15"] a saída deve retornar "1,4,13"
porque esses números aparecem em ambas as cadeias de caracteres. A matriz fornecida não estará vazia,
e cada cadeia de caracteres dentro da matriz será de números classificados em ordem crescente e pode
conter números negativos.
Exemplos
Entrada: ["1, 3, 4, 7, 13", "1, 2, 4, 13, 15"]

Saída: 1,4,13
Entrada: ["1, 3, 9, 10, 17, 18", "1, 4, 9, 10"]

Saída: 1,9,10
função FindIntersection(input) {
const [firstList, secondList] = input.map( s => s.split(", ") );
const resultMap = {};

resultado const = [];
for ( número const de firstList ) {

resultMap[ number ] = verdadeiro;
}
for ( const número de secondList ) {

if ( resultMap[número] ) {
result.push( número );
}
}
retornar result.length ? result.join(",") : falso;

}

console.log(FindIntersection(readline()));
Multiplicador de soma
Faça com que a função SumMultiplier(arr) pegue a matriz de números armazenados em arr e
retorne a cadeia de caracteres true se quaisquer dois números puderem ser multiplicados para que a
resposta seja maior que o dobro da soma de todos os elementos na matriz. Caso contrário, retorne a
cadeia de caracteres false. Por exemplo: se arr é [2, 5, 6, -6, 16, 2, 3, 6, 5, 3], então a soma de todos
esses elementos é 42 e duplicar é 84. Há dois elementos na matriz, 16 * 6 = 96 e 96 é maior que 84,
portanto, seu programa deve retornar a cadeia de caracteres true.
Exemplos
Entrada: [2, 2, 2, 2, 4, 1]
Saída: false
Entrada: [1, 1, 2, 10, 3, 1, 12]

Saída: true
função SumMultiplier(arr) {
alvo const = arr.reduce((val1, val2) => val1 + val2, 0) * 2;
arr.sort((num1, num2) => num1 - num2);
const len = arr.comprimento;
verificador const = Matemática.max((arr[0] * arr[1]), (arr[len - 2] * arr[len
- 1]));
verificador de retorno > alvo;
}
SomaMultiplier(readline());
Mesclagem de cadeia de caracteres
Faça com que a função StringMerge(str) leia o parâmetro str que está sendo passado, que conterá
uma grande cadeia de caracteres alfanuméricos com um único caractere asterisco dividindo a cadeia
uniformemente em duas cadeias de caracteres separadas. Seu objetivo é retornar uma nova cadeia de
caracteres emparelhando os caracteres nos locais correspondentes em ambas as cadeias de caracteres. Por
exemplo: se str é "abc1*kyoo", então seu programa deve retornar a string akbyco1o porque a
emparelha com k, b emparelha com y, etc. A corda sempre se dividirá uniformemente com o asterisco no
centro.
Exemplos
Entrada: "aaa*bbb"
Saída: ababab
Entrada: "123hg*aaabb"
Saída: 1a2a3ahbgb
função StringMerge(str) {
const cleanString = str.replace(/[^\w*]/g, '');
const len = (cleanString.length - 1) / 2;
const arr = str.split('*');

newString += arr[0][i] + arr[1][i];
}
retornar newString;
}

StringMerge(linha de leitura());
Um decremente
Faça com que a função OneDecremented(str) conte quantas vezes um dígito aparece que é
exatamente um a menos que o dígito anterior. Por exemplo: se str é "5655984", então seu programa
deve retornar 2 porque 5 aparece diretamente após 6 e 8 aparece diretamente após 9. A entrada sempre
conterá pelo menos 1 dígito.
Exemplos
Entrada: "56"
Saída: 0
Entrada: "9876541110"
Saída: 6
função OneDecremented(num) {
deixe arr = num.toString().split('');
if (parseInt(val, 10) - parseInt(arr[ind + 1], 10) === 1) {
contador++;
}
})
contador de devolução;
}

OneDecremented(readline());
Fusão de elementos
Faça com que a função ElementMerger(arr) pegue a matriz de inteiros positivos armazenados em
arr e execute o seguinte algoritmo: obtenha continuamente a diferença de inteiros adjacentes para criar
uma nova matriz de inteiros e, em seguida, faça o mesmo para a nova matriz até que um único número
seja deixado e retorne esse número. Por exemplo: se arr é [4, 5, 1, 2, 7], então tomar a diferença de
cada par de elementos produz a seguinte nova matriz: [1, 4, 1, 5]. Em seguida, faça o mesmo para que
essa nova matriz produza [3, 3, 4] -> [0, 1] -> 1. Então, para este exemplo, seu programa deve retornar o
número 1, porque é o que resta no final.
Exemplos
Entrada: [5, 7, 16, 1, 2]

Saída: 7
Entrada: [1, 1, 1, 2]
Saída: 1
função ElementMerger(arr) {
if (arr.length === 1) {
retorno arr[0];
} else {
newArr = [];
if (ind < arr.length - 1) {
newArr.push(Math.abs(val - arr[ind + 1]));
}
})
retorno ElementMerger(newArr);
}
}
ElementMerger(readline());
GCF
Faça com que a função GCF(arr) pegue a matriz de números armazenados em arr que sempre conterá
apenas dois inteiros positivos, e retorne o maior fator comum deles. Por exemplo: se arr é [45, 12],
então seu programa deve retornar 3. Sempre haverá dois elementos na matriz e eles serão inteiros
positivos.
Exemplos
Entrada: [1, 6]
Saída: 1
Entrada: [12, 28]
Saída: 4
função GCF(arr) {
deixe res = nulo;
deixe max = Matemática.max(... ARR);
deixe min = Math.min(... ARR);
para (deixe i = 1; i <= min; i++) {
if (max % i === 0 && min % i === 0) {
res = i;
}
}
retorno res;
}

GCF(linha de leitura());
Número de série
Faça com que a função SerialNumber(str) pegue o parâmetro str que está sendo passado e
determine se ele é um número de série válido com as seguintes restrições:
1. Ele precisa conter três conjuntos cada um com três dígitos (1 a 9) separados por um ponto.
2. O primeiro conjunto de dígitos deve somar um número par.
3. O segundo conjunto de dígitos deve somar um número ímpar.
4. O último dígito em cada conjunto deve ser maior do que os dois dígitos anteriores no mesmo
conjunto.
Se todas as restrições acima forem atendidas dentro da cadeia de caracteres, o programa deverá retornar
a cadeia de caracteres true, caso contrário, o programa deverá retornar a string false. Por exemplo: se
str é "224.315.218", então seu programa deve retornar "true".
Exemplos
Entrada: "11.124.667"
Saída: false
Entrada: "114.568.112"
Saída: true
função SerialNumber(str) {
Verifique o formato da cadeia de caracteres
deixe a meta = /^\d{3}\.\d{3}\.\d{3}$/
se (!goal.test(str)) {
retornar 'falso';
}
Transforme a cadeia de caracteres em três matrizes de três dígitos cada

deixe arr = str.split(/\./).map(val => {
retornar val.split('').map(val2 => {
retorno parseInt(val2, 10);
});
});
Verificar condição um
if ((arr[0][0] + arr[0][1] + arr[0][2]) % 2) {
retornar 'falso';
}
verificar condição dois

se (!( (arr[1][0] + arr[1][1] + arr[1][2]) % 2)) {
retornar 'falso';
}
verificar condição três

para (deixe i = 0, len = arr.length; i < len; i++) {
se (Matemática.max(... arr[i]) !== arr[i][2]) {
retornar 'falso';
}
}
Se todas as condições passarem sem um false, retorne true
retorno verdadeiro;
}
SerialNumber(readline());
Períodos de cadeia de caracteres
Faça com que a função StringPeriods(str) pegue o parâmetro str que está sendo passado e
determine se há alguma substring K que possa ser repetida N > 1 vezes para produzir a string de entrada
exatamente como ela aparece. Seu programa deve retornar a substring K mais longa e, se não houver, ela
deve retornar a string -1.
Por exemplo: se str é "abcababcababcab", então seu programa deve retornar abcab porque essa é a
substring mais longa que é repetida 3 vezes para criar a cadeia de caracteres final. Outro exemplo: se
str é "abababababab", então seu programa deve retornar ababab porque é a substring mais longa. Se a
cadeia de caracteres de entrada contiver apenas um único caractere, seu programa deverá retornar a
cadeia de caracteres -1.
Exemplos
Entrada: "abcxabc"
Saída: -1
Entrada: "affedaaffed"
Saída: -1
função StringPeriods(str) {
usaremos apenas comprimentos de substrings que se dividem uniformemente em str
const len = str.comprimento;
const pivot = Matemática.max(Math.trunc(Math.sqrt(len)), len);
para (deixe i = 2; i <= pivô; i++) {
if (len % i === 0) {
bloco const = str.slice(0, len/i);
if (block.repeat(i) === str) {
bloco de retorno;
}
}
}
retorno -1;
}

StringPeriods(linha de leitura());
Trocador de Palíndromo
Faça com que a função PalindromeSwapper(str) pegue o parâmetro str que está sendo passado e
determine se um palíndromo pode ser criado trocando dois caracteres adjacentes na cadeia de caracteres.
Se for possível criar um palíndromo, então seu programa deve retornar o palíndromo, se não retornar a
cadeia de caracteres -1. A cadeia de caracteres de entrada conterá apenas caracteres alfabéticos. Por
exemplo: se str é "rcaecar", então você pode criar um palíndromo trocando o segundo e terceiro
caracteres, então seu programa deve retornar a corda racecar que é a cadeia palindrômica final.
Exemplos
Entrada: "anna"
Saída: anna
Entrada: "kyaak"
Saída: caiaque
função PalindromeSwapper(str) {
let inputArray = str.split('');
let strLen = inputArray.length;
deixe palTester = function(arr) {
if (arr[i] !== arr[len - (1 + i)]) {
retornar false;
}
}
retorno verdadeiro;
}
para (deixe i = 0; i < strLen - 1; i++) {

let newArray = Array.from(inputArray);
newArray.splice(i, 2, newArray[i + 1], newArray[i]);
if (palTester(newArray)) {
retornar newArray.join('');
}
}
retorno -1;
}

PalindromeSwapper(readline());
Remover colchetes
Faça com que a função RemoveBrackets(str) pegue o parâmetro str string que está sendo passado,
que conterá apenas os caracteres "(" e ")", e determine o número mínimo de colchetes que precisam ser
removidos para criar uma cadeia de caracteres de colchetes corretamente correspondentes. Por exemplo:
se str é "(())", então seu programa deve retornar o número 1. A resposta pode ser potencialmente 0, e
sempre haverá pelo menos um conjunto de colchetes correspondentes na cadeia de caracteres.
Exemplos
Entrada: "(())((("
Saída: 3
Entrada: "()("
Saída: 2
função RemoveBrackets(str) {
deixar arremessos = 0;
deixe arr = str.split('');

um bom exemplo do uso de pre++ e pre-- em oposição a post++ e post--
contador = arr[i] === '(' ? ++contador : --contador;
if (contador < 0) {
descartes++;
contador = 0;
}
}
arremessos += contador;
arremessos de retorno;
}

RemoveBrackets(readline());
Linha de comando
Faça com que a função CommandLine(str) tome o parâmetro str que está sendo passado, que
representa os parâmetros dados a um comando em um sistema PDP antigo. Os parâmetros são tokens
alfanuméricos (sem espaços) seguidos por um sinal de igual e por seu valor correspondente. Vários pares
de parâmetros/valores podem ser colocados na linha de comando com um único espaço entre cada par.
Os tokens e valores de parâmetro não podem conter sinais iguais, mas os valores podem conter espaços.
O objetivo da função é isolar os parâmetros e valores para retornar uma lista de comprimentos de
parâmetros e valores. Ele deve fornecer seu resultado no mesmo formato e na mesma ordem,
substituindo cada entrada (tokens e valores) por seu comprimento correspondente.
Por exemplo, se str for: "SampleNumber=3234 provider=Dr. M. Welby patient=John Smith

priority=High", então sua função deve retornar a string "12=4 8=12 7=10 8=4" porque "SampleNumber"
é um token de 12 caracteres com um valor de 4 caracteres ("3234") seguido por "provider" que é um
token de 8 caracteres seguido por um valor de 12 caracteres ("Dr. M. Welby"), etc.
Exemplos
Entrada: "letras=A B Z T números=1 2 26 20 combinar=verdadeiro"

Saída: 7=7 7=9 7=4
Entrada: "a=3 b=4 a=23 b=a 4 23 c="

Saída: 1=1 1=1 1=2 1=6 1=0
função CommandLine(str) {
deixe divisor = /\s(?=\w+=)/
deixe wordArr = str.split(splitter);
wordArr = wordArr.map(par => {

deixe pairArr = par.split('=');
pairArr = pairArr.map(palavra => {
retornar word.length.toString();
});
par de retornoArr.join('=');
});
retornar wordArr.join(' ');

}

Linha de comando(readline());
Classificação por estrelas
Faça com que a função StarRating(str) pegue o parâmetro str que está sendo passado, que será
uma classificação média entre 0,00 e 5,00, e converta essa classificação em uma lista de 5 nomes de
imagem a serem exibidos em uma interface de usuário para representar a classificação como uma lista de
estrelas e meias estrelas. As classificações devem ser arredondadas para a metade mais próxima. Existem
3 nomes de arquivos de imagem disponíveis: "full.jpg", "half.jpg", "empty.jpg". A saída será o nome das
5 imagens (sem a extensão), da esquerda para a direita, separadas por espaços. Por exemplo: se str é
"2.36", então isso deve ser exibido pela seguinte imagem:
Então seu programa deve retornar a string "full full half empty empty".
Exemplos
Entrada: "0.38"
Saída: meio vazio vazio vazio vazio
Entrada: "4.5"
Saída: full full full half
função StarRating(str) {
deixe num = (Math.round(parseFloat(str) * 2)) / 2;
deixe starString = '';
deixa a metade =! (Math.trunc(num) === num);
starString = starString + ' full'.repeat(num);

se (metade) {
starString += ' metade';
}
return (starString + ' empty'.repeat(5 - num)).trim();
}

StarRating(linha de leitura());

Solução de Problemas-1

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Solução de Problemas-1

Enviado por

Direitos autorais:

Formatos disponíveis

Primeiro reverso

Entrada: "I Love Code"

var arr = str.split('');

manter esta chamada de função aqui

deixe newString = '';

manter esta chamada de função aqui

manter esta chamada de função aqui

para (deixe i = 1; i <= núm; i++) {

manter esta chamada de função aqui

código vai aqui

manter esta chamada de função aqui

manter esta chamada de função aqui

Palavra mais longa

Entrada: "fun&!! time"

Entrada: "Eu amo cachorros"

var arr = sen.split(' ');

arr.sort(function(a, b) {return b.length - a.length});

código vai aqui

manter esta chamada de função aqui

para (deixe i = 0, comprimento = 0, palavra = ''; i < sen.length; i++) {

if (comprimento > maxLength) {

retornar por mais tempo;

manter esta chamada de função aqui

manter esta chamada de função aqui

para (var i = 0; i < len; i++) {

manter esta chamada de função aqui

let validCharacters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

deixe newString = '';

deixe finalString = '';

manter esta chamada de função aqui

return str.replace(/[aeiou]/g, function(ch) {

manter esta chamada de função aqui

Entrada: 140 Saída: 9870

manter esta chamada de função aqui

manter esta chamada de função aqui

código vai aqui

manter esta chamada de função aqui

Entrada: "hello world"

Entrada: "Eu corri lá"

wordarr = str.split(" ");

para (var i = 0, n = wordarr.length; i < n; i++) {

manter esta chamada de função aqui

deixe newString = '';

newWord = (str[i] === ' ') ? verdadeiro : falso;

manter esta chamada de função aqui

código vai aqui

manter esta chamada de função aqui

manter esta chamada de função aqui

if (str === '') {

deixe resultado = str.split('').every(letterEval);

retorno resultado ? 'verdadeiro' : 'falso';

letra de funçãoEval(letra, índice) {

if (str[index - 1] === '+' && str[index + 1] === '+') {

manter esta chamada de função aqui

código vai aqui

manter esta chamada de função aqui

Entrada: 3 & num2 = 122

Entrada: 67 & num2 = 67

manter esta chamada de função aqui

manter esta chamada de função aqui

código vai aqui

manter esta chamada de função aqui

Entrada: 45 Saída: 0:45