Rezolvarea Problemelor-1

Primul revers
Puneți funcția FirstReverse(str) să preia parametrul str transmis și să returneze șirul în ordine
inversată. De exemplu: dacă șirul de intrare este "Hello World and Coders", atunci programul dvs. ar
trebui să returneze șirul sredoC dna dlroW olleH.
Exemple
Intrare: "coderbyte"
Ieșire: etybredoc
Intrare: "I Love Code"

Ieșire: edoC evoL I
funcția FirstReverse(str) {
var arr = str.split('');

arr.revers();
returnare arr.join('');
}
Păstrați această funcție sunați aici

pentru a vedea cum să introduceți argumente în JavaScript, derulați în jos
FirstReverse(readline());
fie newString = '';

pentru (fie i = str.length-1; i >= 0; i--) {
newString += str[i];
}
returnați newString;
}

Codul merge aici
returnare str.split('').reverse().join('');

Primul factorial
Puneți funcția FirstFactorial(num) să ia parametrul num trecut și să returneze factorialul

acestuia. De exemplu: dacă num = 4, atunci programul dvs. ar trebui să revină (4 * 3 * 2 * 1) = 24.
Pentru cazurile de testare, intervalul va fi cuprins între 1 și 18, iar intrarea va fi întotdeauna un număr
întreg.
Exemple
Intrare: 4
Ieșire: 24
Intrare: 8
Ieșire: 40320
funcția FirstFactorial(num) {
fie factorial = 1;
pentru (fie i = 1; i <= num; i++) {

factorial *= i;
}
returnare factorială;

FirstFactorial(readline());
Codul merge aici

dacă (num < 0) returnează NaN;
întoarcere (num > 1) ? FirstFactorial(num - 1) * num : 1;

să răspundă = 1;
pentru (fie index = 1; index <= num; index++) {
răspuns * = index;
}
răspuns de întoarcere;

Cel mai lung cuvânt
Puneți funcția LongestWord(sen) să preia parametrul sen transmis și să returneze cel mai mare
cuvânt din șir. Dacă există două sau mai multe cuvinte care au aceeași lungime, returnați primul cuvânt
din șirul cu acea lungime. Ignorați punctuația și presupuneți că sen nu va fi gol.
Exemple
Intrare: "distracție&!! timp"

Ieșire: timp
Intrare: "Îmi plac câinii"

Ieșire: dragoste
funcția 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});
întoarcere arr.shift();
Codul merge aici

întoarcere sen;

Cel mai lungcuvânt(linie de citire());
let validCharacters =
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
fie maxLength = 0;
fie cel mai lungCuvânt = '';
pentru (fie i = 0, lungime = 0, cuvânt = ''; i < sen.length; i++) {

fie c = sen[i];
dacă (validCharacters.includes(c)) {
lungime++;
cuvânt += c;
} altceva {
lungime = 0;
cuvânt = '';
}
dacă (lungime > maxLength) {

maxLength = lungime;
cel mai lungCuvânt = cuvânt;
}
}
întoarceți cel mai lungCuvânt;

var tăiat = sen.replace(/[^\w]/g, ' ');
cuvinte var = trimmed.split(/\s+/);
var longestWord = words.sort(function(a, b) {return b.length - a.length;}) [0];
întoarceți cel mai lungCuvânt;
}

Modificări ale scrisorilor
Solicitați funcției LetterChanges (str) să ia parametrul str transmis și să îl modifice folosind

următorul algoritm. Înlocuiți fiecare literă din șir cu litera care o urmează în alfabet ( adică.c devine d, z
devine a). Apoi scrieți cu majusculă fiecare vocală din acest nou șir (a, e, i, o, u) și, în final, returnați
acest șir modificat.
Exemple
Intrare: "hello*3"
Ieșire: Ifmmp*3
Intrare: "vremuri distractive!"
Ieșire: gvO Ujnft!
funcția LetterChanges(str) {
str = str.trim().toLitere mici();

var len = str.lungime;
var newStr = '';
pentru (var i = 0; i < len; i++) {

dacă (/[a-ce-gi-mo-su-y]/.test(str[i])) {
newStr += String.fromCharCode(((str[i].charCodeAt(0) - 18) % 26) + 97)
}
altfel dacă (/[zdhnt]/.test(str[i])) {
newStr += String.fromCharCode(((str[i].charCodeAt(0) - 18) % 26) + 65);
}
altfel {
newStr += str[i];
}
}
întoarcere newStr;

LetterChanges(readline());
let validCharacters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
fie newString = '';

pentru (fie i = 0; i < str.length; i++) {
dacă (validCharacters.includes(str[i])) {
fie char = str.charCodeAt(i);
newString += (str[i] === 'z' || str[i] === 'Z') ?
String.fromCharCode(char - 25) : String.fromCharCode(char + 1);
} altceva {
}
}
vocale fie = 'aeiou';
fie finalString = '';
Capitlize vocale
pentru (fie i = 0; i < newString.length; i++) {
if (vocale.includes(newString[i])) {
finalString += newString[i].toUpperCase();
} altceva {
finalString += newString[i];
}
}
returnează finalString;

str = str.replace(/[a-zA-Z]/g, function(ch) {
dacă (ch === "z") returnează "a";
altfel dacă (ch === "Z") returnează "A";
altfel returnați String.fromCharCode(ch.charCodeAt(0) + 1);
});
return str.replace(/[aeiou]/g, function(ch) {

returnați ch.toUpperCase();
});
}

Adăugare simplă
Funcția SimpleAdding (num) adună toate numerele de la 1 la num. De exemplu: dacă intrarea este
4, atunci programul dvs. ar trebui să returneze 10, deoarece 1 + 2 + 3 + 4 = 10. Pentru cazurile de
testare, parametrul num va fi orice număr de la 1 la 1000.
Exemple
Intrare: 12
Ieșire: 78
Intrare: 140 Ieșire: 9870
funcția SimpleAdding(num) {
dacă (num === 1) {
returnarea 1;
}
altfel {
return num + SimpleAdding(num -1);
}
}

SimpleAdding(readline());
fie suma = 0;
pentru (i = 1; i <= num; i++) {
suma += i;
}
suma returnată;

Codul merge aici

dacă (num < 1) returnează NaN;
altfel dacă (num === 1) returnează 1;
returnați SimpleAdding(num - 1) + num;
}

Scrisoare cu majusculă
Puneți funcția LetterCapitalize(str) să preia parametrul str transmis și să scrie cu majusculă

prima literă a fiecărui cuvânt. Cuvintele vor fi separate de un singur spațiu.
Exemple
Intrare: "salut lume"

Ieșire: Hello World
Intrare: "Am alergat acolo"

Ieșire: Am fugit acolo
funcția LetterCapitalize(str) {
wordarr = str.split(" ");
pentru (var i = 0, n = wordarr.length; i < n; i++) {

wordarr[i] = wordarr[i][0].toUpperCase() + wordarr[i].slice(1);
}
str = wordarr.join(" ");
str. de întoarcere;

LetterCapitalize(readline());
fie newString = '';

pentru (fie i = 0, newWord = true; i < str.length; i++) {
dacă (nouWord) {
newString += str[i].toUpperCase();
} altceva {
}
newWord = (str[i] === ' ') ? adevărat : fals;

}
}

Codul merge aici

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

Simboluri simple
Puneți funcția SimpleSymbols(str) să ia parametrul str transmis și să determine dacă este o

secvență acceptabilă returnând șirul adevărat sau fals. Parametrul str va fi compus din + și =
simboluri cu mai multe caractere între ele (adică.++D+===+C++==A) și pentru ca șirul să fie adevărat,
fiecare literă trebuie să fie înconjurată de un simbol +. Deci șirul din stânga ar fi fals. Șirul nu va fi gol
și va avea cel puțin o literă.
Exemple
Intrare: "+d+=3=+s+"
Ieșire: adevărat
Intrare: "f++d+"
Ieșire: false
funcția SimpleSymbols(str) {
if (/^[a-zA-Z]/.test(str) || /[a-zA-Z]$/.test(str)) {
returnează fals;
}
altfel dacă (/[^+][a-zA-Z]/.test(str) || /[a-zA-Z][^+]/.test(str)) {
returnează fals;
}
altfel {
întoarcere adevărată;
}

SimpleSymbols(readline());
dacă (str === '') {

returnează mențiunea "false";
}
let result = str.split('').every(letterEval);
Rezultatul returnării ? "true": "false";
funcția letterEval(letter, index) {

litere = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
dacă (letters.includes(letter)) {
Verificați dacă există primul sau ultimul caracter
if (index === 0 || indice === str.length - 1) {
Letter este primul sau ultimul char, fail case
returnează fals;
}
if (str[index - 1] === '+' &; str[index + 1] === '+') {

}
} altceva {
Ignorarea non-literelor
}
}

Codul merge aici

dacă (str.match(/[^+][A-Za-z][^+]/g)) returnează false;
altfel dacă (str.match(/[+][A-Za-z][^+]/g)) returnează false;
altfel dacă (str.match(/[^+][A-Za-z][+]/g)) returnează false;
}

Verificați Nums
Puneți funcția CheckNums(num1,num2) să ia ambii parametri trecuți și să returneze șirul true dacă num2
este mai mare decât num1, altfel returnați șirul false. Dacă valorile parametrilor sunt egale între ele,
returnați șirul -1.
Exemple
Intrare: 3 & num2 = 122

Ieșire: adevărat

Ieșire: -1
VEZI PROVOCAREA
funcția CheckNums(num1,num2) {
dacă (num1 == num2) {

returnează "-1";
}
altfel {
întoarcere (num2 > num1);
}
}

CheckNums(readline());
dacă (num2 > num1) {
} altfel dacă (num1 === num2) {
returnează "-1";
} altceva {
returnează fals;
}

Codul merge aici

dacă ((num1 - num2) < 0) returnează true;
altfel dacă ((num1 - num2) > 0) returnează false;
altfel returnează -1;
}

Conversia timpului
Puneți funcția TimeConvert (num) să ia parametrul num transmis și să returneze numărul de ore și
minute pe care parametrul le convertește în (adică. dacă num = 63, atunci ieșirea ar trebui să fie 1:3).
Separați numărul de ore și minute cu un colon.
Exemple
Intrare: 126
Ieșire: 2:6
Intrare: 45 Ieșire: 0:45
funcția TimeConvert(num) {
var ore = Math.floor(num/60);
var minute = num % 60;
Var Str = ore + ":" + minute;
}
TimeConvert(readline());
let hours = Math.floor(num/60);

fie minute = num % 60;
ore de întoarcere + ':' + minute;

Codul merge aici

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

Supă alfabet
Puneți funcția AlphabetSoup(str) să ia parametrul str string transmis și să returneze șirul cu

literele în ordine alfabetică (adică.salut devine ehllo). Să presupunem că numerele și simbolurile de
punctuație nu vor fi incluse în șir.
Exemple
Ieșire: bcdeeorty
Intrare: "hooplah"
Ieșire: ahhloop
funcția AlphabetSoup(str) {
matrice var = str.split("");

var inversearrays = arrays.sort();
rezultat var = reversearrays.join("");
rezultatul returnării;

AlphabetSoup(readline());
Fie litere = str.split('');

return letters.sort().join('');

Codul merge aici

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

Verificare AB
Puneți funcția ABCheck(str) să ia parametrul str transmis și să returneze șirul adevărat dacă
caracterele a și b sunt separate de exact 3 locuri oriunde în șir cel puțin o dată (adică. "Lane Borrowed"
ar rezulta adevărat, deoarece există exact trei caractere între A și B). În caz contrar, returnați șirul false.
Exemple
Intrare: "după prost"

Ieșire: fals
Intrare: "Laura suspină"

Ieșire: adevărat
funcția ABCheck(str) {
Patt = /(a... b|b... a)/
returnare patt.test(str);

ABCheck(readline());
dacă (str.length < 5) {
returnează fals;
}
consola.log(str.length);
pentru (fie I = 0; i < str.length-4; i++) {

Căutați un
if (str[i] === 'a') {
dacă (str[i+4] === 'b') {
}
}
dacă (str[i] === 'b') {

dacă (str[i+4] === 'a') {
}
}
}
returnează fals;

Codul merge aici
return str.match(/[aA].{ 3}[bB]/) !== nul;

}

Număr de vocale
Funcția VowelCount(str) ia parametrul str string transmis și returnează numărul de vocale pe care
le conține șirul (adică."Toate vacile mănâncă iarbă și moo" s-ar întoarce 8). Nu numărați y ca vocală
pentru această provocare.
Exemple
Intrare: "salut"
Ieșire: 2
Ieșire: 3
funcția VowelCount(str) {
var patt = /[aeiou]/gi;
var arr = str.match(patt);
dacă (arr == null) {

returnare 0;
}
altfel {
întoarcere arr.length;
}
}

Număr vocal(linie de citire());
vocale fie = 'aeiou';

fie count = 0;

if (vocale.includes(str[i])) {
număr++;
}
}
numărul de returnări;
}

Codul merge aici
return str.split('').filter(function(ch) {
returnează ['a', 'e', 'i', 'o', 'u'].indexOf(ch.toLowerCase()) > -1;
}).lungime;

Număr de cuvinte
Puneți funcția WordCount(str) să ia parametrul str string transmis și să returneze numărul de cuvinte
pe care le conține șirul (de exemplu, "Nu mâncați niciodată grâu mărunțit sau prăjitură" ar returna 6).
Cuvintele vor fi separate prin spații unice.
Exemple
Intrare: "Hello World"

Ieșire: 2
Intrare: "unu 22 trei"

Ieșire: 3
funcția WordCount(str) {
var arr = str.split(" ");
răspuns var = arr.length;
răspuns de întoarcere;

Număr de cuvinte(linie de citire());
retur str.split(' ').length;
}

Codul merge aici

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

Ex Oh
Puneți funcția ExOh(str) să ia parametrul str transmis și să returneze șirul true dacă există un
număr egal de x și o, altfel returnați șirul false. Numai aceste două litere vor fi introduse în șir, fără
semne de punctuație sau numere. De exemplu: dacă str este "xooxxxxooxo", atunci ieșirea ar trebui să
returneze falsă, deoarece există 6 x și 5 o.
Exemple
Intrare: "xooxxo"
Ieșire: adevărat
Intrare: "x"
Ieșire: false
funcția ExOh(str) {
var regExPatternX = /x/gi;
var regExPatternO = /o/gi;
var arrayXLen = str && str.match(regExPatternX) ?

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

}

ExOh(linie de citire());
fie xCount = 0;
fie oCount = 0;

dacă (str[i] === 'x') {
xCount++;
}
dacă (str[i] === 'o') {
oCount++;
}
}
return (xCount === oCount) ? adevărat : fals;

Codul merge aici

litere var = str.split('');
var numOfEx = letters.filter(function(ch) {
întoarcere ch === 'x';
}).lungime;
var numOfOh = letters.filter(function(ch) {
Întoarcere ch === 'O';
}).lungime;
returnează numOfEx === numOfOh;

Palindrom
Puneți funcția Palindrome(str) să ia parametrul str transmis și să returneze șirul true dacă parametrul
este un palindrom, (șirul este același înainte ca și înapoi) altfel returnați șirul false. De exemplu:
"mașină de curse" este, de asemenea, "mașină de curse" înapoi. Punctuația și numerele nu vor face parte
din șir.
Exemple
Intrare: "niciodată impar sau par"

Ieșire: adevărat
Intrare: "ochi"
Ieșire: adevărat
funcția Palindrome(str) {
modificat = str.replace(/W/g,"");
var arr1 = modificat.split("");

var arr2 = arr1;
arr2 = arr2.revers();
str2 = arr2.join("");
Retur modificat == Str2;

Palindrom(linie de citire());
str = str.replace(/ /g, '');
pentru (fie i = 0, max = Math.floor(str.length/2); i < max; i++) {

dacă (str[i] !== str[str.length-1-i]) {
returnează fals;
}
}

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

returnează fals;
}
}

Arith Geo
Puneți funcția ArithGeo(arr) să ia matricea de numere stocate în arr și să returneze șirul

"Aritmetic" dacă secvența urmează un model aritmetic sau să returneze "Geometric" dacă urmează un
model geometric. Dacă secvența nu urmează niciunul dintre modele, returnați -1. O secvență aritmetică
este una în care diferența dintre fiecare dintre numere este consistentă, unde, ca într-o secvență
geometrică, fiecare termen după primul este înmulțit cu un raport constant sau comun. Exemplu
aritmetic: [2, 4, 6, 8] și Exemplu geometric: [2, 6, 18, 54]. Numerele negative pot fi introduse ca
parametri, 0 nu va fi introdus și nicio matrice nu va conține toate aceleași elemente.
Exemple
Intrare: [5,10,15]
Ieșire: Aritmetică
Intrare: [2,4,16,24]
Ieșire: -1
funcția ArithGeo(arr) {
var len = arondisment;
var arithK = arr[1] - arr[0];
var geoK = arr[1] / arr[0];
pentru (var i = 0; i < len - 1; i++) {

dacă (arr[i+1] - arr [i] !== arithK) {
sparge;
}
altfel dacă (i === len - 2) {
returnați "Aritmetica";
}
}
pentru (var i = 0; i < len - 1; i++) {

dacă (arr[i+1] / arr [i] !== geoK) {
sparge;
}
altfel dacă (i === len - 2) {
returnați "Geometric";
}
}
întoarcere -1;
}

ArithGeo(readline());
fie aritmetică = adevărat;

Aritmetica testului
pentru (fie i = 2, diff = arr[1] - arr[0]; i < arr.length; i++) {
dacă (arr[i] - arr[i-1] !== dif) {
aritmetică = fals;
}
}
dacă (aritmetică) {
returnați "aritmetica";
}
fie geometric = adevărat;

Geometrice
pentru (fie i = 2, divizor = arr[1] / arr[0]; i < arr.length; i++) {
dacă (arr[i] / arr[i-1] !== divizor) {
geometric = fals;
}
}
dacă (geometric) {
returnați "Geometric";
}
întoarcere -1;

Codul merge aici

var isArith = funcție(arr) {
dacă (arr.length < 2) returnează -1;
diferența var = arr[1] - arr[0];
pentru (var i = 1; i < arr.length - 1; i++) {
dacă (arr[i + 1] - arr[i] !== diferență) returnează false;
}
};
var isGeo = funcție(arr) {

multiplicator var = arr[1] / arr[0];
dacă (arr[i + 1] / arr[i] !== multiplicator) returnează false;
}
};
dacă (isArith(arr)) returnează "Aritmetică";

altfel dacă (isGeo(arr)) returnează "Geometric";
altfel returnează -1;
}

Adunare matrice I
Setați funcția ArrayAdditionI(arr) să preia matricea de numere stocate în arr și să returneze șirul
true dacă orice combinație de numere din matrice (excluzând cel mai mare număr) poate fi adunată
pentru a egala cel mai mare număr din matrice, altfel returnați șirul false. De exemplu: dacă arr
conține [4, 6, 23, 10, 1, 3] ieșirea ar trebui să returneze true deoarece 4 + 6 + 10 + 3 = 23. Matricea nu
va fi goală, nu va conține toate aceleași elemente și poate conține numere negative.
Exemple
Intrare: [5,7,16,1,2]
Ieșire: false
Intrare: [3,5,-1,8,12]
Ieșire: adevărată
funcția ArrayAdditionI(arr) {
ținta VAR;
var addArr = arrayPrep(arr);
var len = addArr.length;
var permNum = Math.pow(2, len);
console.log('test0 ', permNum, target, addArr);
pentru(var i = 0; i <= permNum; i++) {

permStr = (i).toString(2);
strlen = permStr.length;
contor var = 0;
pentru(var j = 0; j < strlen; j++) {
if(permStr[j] === '1') {
contor += addArr[j];
}
}
dacă (contor === țintă) {
Întoarceți-vă adevărat
}
}
returnează fals
funcția arrayPrep(arr2) {
arr.sort(function(a, b){
returnează a - b
});
țintă = arr2.pop()
Returnare arr2
}
}
ArrayAdditionI(readline());
Găsiți cel mai mare număr

fie largestIndex = 0;
fie cel mai mareNumăr = 0;
pentru (fie i = 0; i < arr.length; i++) {
if (arr[i] > largestNumber) {
largestIndex = i;
cel mai mareNumăr = arr[i];
}
}
arr.splice(cel mai mareIndex, 1);
fie combo-uri = [];

fie size = arr.length;
pentru (fie i = 0, max = Math.pow(2, dimensiune); i < max; i++) {

fie num = i.toString(2);
în timp ce (num.length < size) {
num = '0' + num;
}
combos.push(num);
}
Iterează peste toate combinațiile de numere

pentru (fie i = 0; i < combos.length; i++) {
fie suma = 0;
pentru (fie j = 0; j < combo-uri[i].length; j++) {
dacă (combo-uri[i][j] === '1') {
suma += arr[j];
}
}
dacă (sumă === largestNumber) {

}
}
returnează fals;
}

Codul merge aici

var sortedArr = arr.sort(function(a,b) {return a-b;});
var cel mai mare = sortedArr.pop();
sume var = [];
pentru (i = 0; i < Math.pow(2, sortedArr.length); i++) {

suma var = 0;
var bitMask = i.toString(2).split('');
în timp ce (bitMask.length < sortedArr.length) {

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

dacă (bitMask[j] === '1') {
suma += sortatArr[j];
}
}
sums.push(sumă);
}
returnează sums.indexOf(cel mai mare) !== -1;

}

Numărul literelor I
Funcția LetterCountI(str) preia parametrul str transmis și returnează primul cuvânt cu cel mai
mare număr de litere repetate. De exemplu: "Astăzi, este cea mai măreață zi vreodată!" ar trebui să se
întoarcă cel mai mare pentru că are 2 e (și 2 t) și vine înainte de a avea și 2 e. Dacă nu există cuvinte cu
litere repetate, returnați -1. Cuvintele vor fi separate prin spații.
Exemple
Intrare: "Bună ziua plăcintă cu mere"

Ieșire: Bună ziua
Intrare: "Fără cuvinte"

Ieșire: -1
funcția LetterCountI(str) {
var arr = str.toLowerCase().split(" ");
var n = arr.length;
contor var = 1;
var maxcount = 0;
var newarr = [];
pentru (var i = 0; i < n; i++) {

wordarr = arr[i].split("");
wordarr.sort();
pentru (var j = 0; j < wordarr.length; j++) {
dacă (wordarr[j] == wordarr[j+1]) {
contra++;
}
altfel {
dacă (counter > maxcount) {
maxcount = contor;
contor = 1;
}
}
}
newarr.push([arr[i], maxcount])
maxcount = 0;
}
newarr.sort(function(a, b) {return b[1] - a[1]});
dacă (newarr[0][1] == 1) {
întoarcere -1;
}
altfel {
returnează newarr[0][0];
}
}

LetterCountI(readline());
fie cuvinte = str.split(' ');
fie bestCount = 0;
fie bestWord = '';
pentru (fie i = 0; i < words.length; i++) {

fie letterCount = [];
fie largestCount = 0;
pentru (fie j = 0; j < cuvinte[i].length; j++) {
letterCount[words[i][j]] = (letterCount[words[i][j]] === nedefinit) ? 1 :
++letterCount[cuvinte[i][j]];
dacă (letterCount[words[i][j]] >= 2 &&; letterCount[words[i][j]] >
largestCount) {
largestCount = letterCount[cuvinte[i][j]];
}
}
dacă (largestCount > bestCount) {

bestCount = largestCount;
bestWord = cuvinte[i];
}
}
return (bestWord === '') ? -1 : cel mai bun cuvânt;

Codul merge aici

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

word = word.toLowerCase();
litere var = [];
pentru (litera cuvântului) {
dacă (litere[literă]) {
litere[scrisoare] += 1;
} altceva {
litere[scrisoare] = 1;
}
}
scrisori de returnare;
});
var greatestCounts = counts.map(function(word) {

var cel mai mare = 0;
pentru (litera în cuvânt) {
dacă (cuvânt[literă] > cel mai mare) {
cel mai mare = cuvânt[literă];
}
}
returnează cel mai mare;
});
var greatest = Math.max.apply(null, greatestCounts);

dacă (cel mai mare <= 1) întoarcere -1;
returnează cuvinte[greatestCounts.indexOf(cel mai mare)];
}

Al doilea GreatLow
Funcția SecondGreatLow(arr) preia matricea de numere stocate în arr și returnează al doilea

cel mai mic și, respectiv, al doilea cel mai mare numere, separate printr-un spațiu. De exemplu: dacă
arr conține [7, 7, 12, 98, 106], ieșirea ar trebui să fie 12 98. Matricea nu va fi goală și va conține cel
puțin 2 numere. Poate deveni dificil dacă există doar două numere!
Exemple
Intrare: [1, 42, 42, 180]

Ieșire: 42 42
Intrare: [4, 90]

Ieșire: 90 4
funcția SecondGreatLow(arr) {
arr.sort(funcție(a, b) {returnează a - b});
arr = singuratic(arr);
var newlen = arondisment;
Întoarcere arr[1] + ' ' + arr[Newlen - 2]
funcția lonely(arr) {
var len = arondisment;
var testobj = {};
ieșire var = [];
numărul var = 0;
titular var = arr[i];
dacă (!testobj[holder]) {
testobj[holder] = adevărat;
output[count++] = titular;
}
}
Returnarea ieșirii
}
}

SecondGreatLow(readline())
arr = arr.slice().sort((a, b) => a - b);
fie secundă = arr[1];

dacă (arr[i] !== arr[0]) {
al doilea = arr[i];
sparge;
}
}
fie penultimul = arr[arr.length - 2];

pentru (fie i = arr.length - 2; i >= 0; i--) {
dacă (arr[i] !== arr[arr.length - 1]) {
penultimul = arr[i];
sparge;
}
}
returnează al doilea + ' ' + penultimul;

SecondGreatLow(readline());
Codul merge aici

var sortat = arr.sort(function(a,b){return a-b;});
var cel mai mare = sortat[sortat.lungime - 1];
var cel mai mic = sortat[0];
var secondCel mai mare, al doileaCel mai mic;
pentru (var i = 0; i < sorted.length; i++) {

dacă (sortat[i] !== cel mai mic) {
secondLowest = sortat[i];
sparge;
}
}
pentru (var i = sortat.lungime - 1; i >= 0; i--) {

dacă (sortat[i] !== cel mai mare) {
secondGreatest = sortat[i];
sparge;
}
}
returnați al doileaCel mai mic + " " " + al doileaCel mai mare;
}

SecondGreatLow(readline());
Diviziune înșirată
Puneți funcția DivisionStringified(num1,num2) să ia ambii parametri trecuți, să împartă

num1 la num2 și să returneze rezultatul ca un șir cu virgule formatate corect. Dacă un răspuns are doar
3 cifre, returnați numărul fără virgule (adică.2 / 3 ar trebui să emită "1"). De exemplu: dacă num1 este
123456789 și num2 este 10000, ieșirea ar trebui să fie "12.346".
Exemple

Ieșire: 3

Ieșire: 103
VEZI PROVOCAREA
funcția DivisionStringified(num1,num2) {
var res = Math.round(num1/num2);

șir var = res.toString();
var numleng = string.length;
var newstring = șir;
dacă (numleng > 3) {

var arr = șir.split("");
pentru (var i = numleng - 3; i > 0; i = i - 3) {
arr.splice(i, 0, ",");
}
var newstring = arr.join("");
}
returnați șirul nou;

DivisionStringified(readline());
fie quotientString = Math.round(num1 / num2).toString();
fie temp = câtString.split('').reverse();

fie newString = '';
pentru (fie i = 0; i < temp.length; i++) {
dacă (i % 3 === 2 && i != temp.length-1) { // aveți nevoie de virgulă în
continuare
newString = ',' + temp[i] + newString;
} altceva {
newString = temp[i] + newString;
}
}
consolă.log(newString);
}

Codul merge aici

Var format = funcție(num) {
rezultat var = '';
var întreg = Math.round(num);
dacă (întreg === 0) returnează 0;
în timp ce (întreg > 0) {

rezultat = (rezultat === '' ? '' : ',') + rezultat;
rezultat = (% întreg 1000) + rezultat;
întreg = Math.floor(întreg / 1000);
}
}
format de returnare(num1 / num2);

}

Numărarea minutelor I
Puneți funcția CountingMinutesI(str) să ia parametrul str trecut, care va fi de două ori

(fiecare formatat corect cu două puncte și am sau pm) separate printr-o cratimă și să returneze numărul
total de minute între cele două ori. Ora va fi într-un format de ceas de 12 ore. De exemplu: dacă str
este 9:00am-10:00am, atunci ieșirea ar trebui să fie 60. Dacă str este 1:00pm-11:00am ieșirea ar
trebui să fie 1320.
Exemple
Intrare: "12:30pm-12:00am"
Ieșire: 690
Intrare: "1:23am-1:08am"
Ieșire: 1425
Soluții pentru numărarea minutelor I
JAVASCRIPT
VEZI PROVOCAREA
funcția 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);
dacă (ampm1 == "pm" &&; oră1 != 12) {
oră1 = oră1 + 12;
}
dacă (ampm2 == "pm" && oră2 != 12) {
oră2 = oră2 + 12;
}
dacă (ora1 == 12 && ampm1 == "am") {
oră1 = 0;
}
dacă (hour2 == 12 && ampm2 == "am") {
oră2 = 0;
}
timp var1 = (oră1*60) + min1;
timp var2 = (oră2*60) + min2;
var diff = timp2 - timp1;
dacă (dif< 0) {
diff = diff + (60 * 24);
}
retur diff;

CountingMinutesI(readline());
fie ori = str.split('-');
times = times.map(function(currentValue, index, array){

let pairs = currentValue.split(':');
let time = ((perechi[1][2] === 'a') ? parseInt(perechi[0]) % 12 :
parseInt(perechi[0]) % 12 + 12) * 60 + parseInt(perechi[1][0] + perechi[1][1]);
timpul de întoarcere;
});
fie diff = ori[1] - ori[0];

retur (diff < 0) ? dif + 1440 : dif;
}
Codul merge aici

ori var = str.split('-');
var de la = ori[0], la = ori[1];
funcția parseMinutes(timeStr) {
timp var = timpStr.match(/d+/g);
var hour = parseInt(time[0]), minute = parseInt(time[1]);
var ampm = (timeStr.match(/[a|p]m/g)[0] === 'am') ? 0 : 1;
dacă (ora === 12) oră = 0;
retur (oră + ampm * 12) * 60 + minut;

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

diferența var = laMinute - de laMinute;
var oneDayInMinutes = 24 * 60;
întoarcere (diferență < 0) ? oneDayInMinutes + diferență : diferență;

}

Modul mediu
Puneți funcția MeanMode (arr) să ia matricea de numere stocate în arr și să returneze 1 dacă
modul este egal cu media, 0 dacă nu sunt egale între ele (adică.[5, 3, 3, 3, 1] ar trebui să returneze 1
deoarece modul (3) este egal cu media (3)). Matricea nu va fi goală, va conține doar numere întregi
pozitive și nu va conține mai mult de un mod.
Exemple
Intrare: [1, 2, 3]
Ieșire: 0
Intrare: [4, 4, 4, 6, 2]
Ieșire: 1
funcția MeanMode(arr) {
len = arr.length
Pasul 1: determinați media - auto-explicativă
funcția mean(arr) {
numărul var = 0;
număr += arr[i]
}
consolă.log (count / len)
Număr de retur / LEN
}
Pasul 2: determinați modul. Trebuie să numărăm câte din fiecare tip sunt în
matrice. O alternativă este să mențineți un contor în funcțiune, să sortați matricea
și apoi să numărați până când un element se schimbă, ținând evidența numărului maxim
și a valorii asociate. Următorul este un mod mult mai ușor, presupunând că cineva
are o familiaritate de bază cu obiectele javascript. Face din fiecare intrare nouă o
cheie și ține cont de câte din fiecare există, apoi face o serie de perechi cheie-
valoare create.
Function Mode (ARR) {

var obj = {};
pentru (var i = 0, len = arr.length; i < len; i++) {
if (obj[arr[i]] === nedefinit) {
obj[arr[i]] = 1;
}
altfel {
obj[arr[i]]++;
}
}
var objarr = [];
pentru (x în obj) {
objarr.push([x, obj[x]]);
}
objarr.sort(function(a, b) {return b[1] - a[1]});
consolă.log(objarr[0][0]);
returnează objarr[0][0];
}
Comparați media și modul
Mod de întoarcere (ARR) == Medie (ARR)? 1: 0;
}

MeanMode(readline());
Modul Găsire
fie majoritateaApariții = 0;
mod let = 0;
fie marco = arr[i];
pentru (fie j = i+1, count = 0; j < arr.length; j++) {
if (marco === arr[j]) {
chibrit!
număr++;
dacă (numărați > majoritateaApariții) {
mostOccurances = count;
mod = arr[j];
}
}
}
}
Găsiți media
fie medie = 0;
media += arr[i];
}
medie = Math.round(medie/arr.lungime);
întoarcere (medie === mod) ? 1 : 0;

Codul merge aici

Function Mode (ARR) {
var counts = [], mode, maxCount = 0;
pentru (num de arr) {
num = num + ' ';
dacă (counts[num]) counts[num]++;
else counts[num] = 1;
}
pentru (num în numere) {

dacă (counts[num] > 1 &&; counts[num] > maxCount) {
mode = parseInt(num);
maxCount = numere[num];
}
}
modul de întoarcere;
}
funcția mean(arr) {
return arr.reduce(function(a,b) {return a+b;}, 0) / arr.length;
}
Mod de întoarcere(arr) === medie(arr) ? 1 : 0;

}

Inserție bord
Funcția DashInsert(str) inserează liniuțe ('-') între fiecare două numere impare din str. De
exemplu: dacă str este 454793 ieșirea ar trebui să fie 4547-9-3. Nu numărați zero ca număr impar.
Exemple
Intrare: 99946 Ieșire: 9-9-946
Intrare: 56730 Ieșire: 567-30
funcția DashInsert(num) {
var strnum = num.toString();
var arr = strnum.split("");
pentru (i = 0; i < arr.length; i++) {

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

dacă (arr[i]%2 == 1 &&; arr[i + 1]%2 == 1) {
arr.splice(I+1, 0, "-");
}
}
x = arr.join("");
returnează x;

DashInsert(readline());
funcția DashInsert(str) {
fie newString = str[0];
pentru (fie i = 1, lastOdd = str[0] % 2; i < str.length; i++) {

dacă (str[i] % 2 === 1 && lastOdd === 1) {
newString += '-' + str[i];
} altceva {
}
lastOdd = str[i] % 2;
}
}

funcția DashInsert(str) {
Codul merge aici

cifre var = str.split('');
funcția isOdd(n) {
returnează parseInt(n) % 2 === 1;
}
pentru (var i = 0; i < cifre.lungime - 1; i++) {

dacă ( isOdd(digits[i]) &&; isOdd(digits[i+1]) ) {
digits.splice(i + 1, 0, '-');
I++;
}
}
returnează digits.join('');
}

Cutie swap
Setați funcția SwapCase (str) să ia parametrul str și să schimbe cazul fiecărui caracter. De exemplu:
dacă str este "Hello World" ieșirea ar trebui să fie hELLO wORLD. Lăsați numerele și simbolurile să
rămână așa cum sunt.
Exemple
Intrare: "Hello-LOL"
Ieșire: hELLO-lol
Intrare: "Sup DUDE!? "

Rezultat: sUP tipule!?
funcția SwapCase(str) {
arr = str.split("");
pentru (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].toMajuscule();
}
}
str = arr.join("");

SwapCase(readline());
const LOWER = 'abcdefghijklmnopqrstuvwxyz';

const UPPER = 'ABCDEFGHIJKLMNOPWRSTUVWXYZ';
fie newString = '';

dacă (LOWER.includes(str[i])) {
newString += str[i].toUpperCase();
} else if (UPPER.includes(str[i])) {
newString += str[i].toLowerCase();
} altceva {
}
}
}
Codul merge aici

return str.split('').map(function(letter) {
if (letter === letter.toLowerCase()) return letter.toUpperCase();
else if (letter === letter.toUpperCase()) return letter.toLowerCase();
altfel scrisoare de returnare;
}).join('');
}

Adăugarea numărului
Setați funcția NumberSearch(str) să ia parametrul str, să caute toate numerele din șir, să le adune,
apoi să returneze acel număr final. De exemplu: dacă str este "88Hello 3World!" ieșirea ar trebui să fie
91. Va trebui să faceți diferența între numerele cu o singură cifră și numerele cu mai multe cifre, ca în
exemplul de mai sus. Deci, "55Hello" și "5Hello 5" ar trebui să returneze două răspunsuri diferite.
Fiecare șir va conține cel puțin o literă sau un simbol.
Exemple
Intrare: "75Number9"
Ieșire: 84
Intrare: "10 2Un număr*1*"

Ieșire: 13
VEZI PROVOCAREA
funcția NumberAddition(str) {
suma var = 0;
numărul var = 0;
var strArr = function(str) {
Scoateți non-cifrele și înlocuiți-le cu spații pentru a păstra separate
str = str.replace(/[^0-9]/g, ' ');
decolați orice spații precedente sau finale
str = str.trim();
transformați orice spații duble în spații simple, până când nu mai rămân
duble
în timp ce (str.indexOf(' ') !== -1) {
str = str.replace(/ss/g, ' ');
}
returnează o matrice de șiruri numerice fără spații;
retur str.split(');
}
apelați funcția strArr la intrarea utilizatorului și stocați ca "prepped"
var prepped = strArr(str);
Transformarea fiecărui șir numeric într-un număr
prepped = prepped.map(function(val) {
întoarcere val ? parseInt(val): 0;
})
consolă.log( 'preppedmap', prepped);
Rulați metoda Reducere pentru a aduna toate numerele
var ans = prepped.reduce(function(firstval, lastval){
returnare firstval + lastval
})
returnează ans
}

NumberAddition(readline());
fie DIGITS = '0123456789';

fie numere = [];
Primele numere de găsire

pentru (fie i = 0, number = ''; i < str.length; i++) {
dacă (! DIGITS.includes(str[i])) {
dacă (număr !== '') {
numbers.push(număr);
}
număr = '';
} altceva {
număr + = str[i];
Caz special pentru ultimul caracter

Dacă (I === Str.Length-1) {
numbers.push(număr);
}
}
}
fie suma = 0;
pentru (fie i = 0; i < numbers.length; i++) {
suma += parseInt(numere[i]);
}
suma returnată;
}

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

Al treilea cel mai mare
Puneți funcția ThirdGreatest (strArr) să ia matricea de șiruri stocate în strArr și să returneze

al treilea cuvânt ca mărime din acesta. Deci, de exemplu: dacă strArr este ["salut", "lume",
"înainte", "toate"] rezultatul dvs. ar trebui să fie lume, deoarece "înainte" are 6 litere, iar "salut" și
"lume" sunt ambele 5, dar ieșirea ar trebui să fie lume, deoarece a apărut ca ultimul cuvânt de 5 litere
din matrice. Dacă strArr a fost ["salut", "lume", "după", "toate"] ieșirea ar trebui să fie după,
deoarece primele trei cuvinte au toate 5 litere, deci returnați-l pe ultimul. Matricea va avea cel puțin trei
șiruri și fiecare șir va conține doar litere.
Exemple
Intrare: ["coder","byte","code"]
Ieșire: cod
Intrare: ["abc","defg","z","hijk"]
Ieșire: abc
funcția ThirdGreatest(strArr) {
strArr.sort(function(a, b) {return b.length - a.length});
returnează strArr[2];
}

ThirdGreatTest(readline());
strArr.sort(function(a,b){return b.length - a.length});
returnează strArr[2];

Codul merge aici

return strArr.sort(function(a, b) {
întoarcere (b.lungime - a.lungime);
})[2];

Puterile a doi
Puneți funcția PowersofTwo (num) să ia parametrul num care va fi un întreg și să returneze șirul
adevărat dacă este o putere de doi. Dacă nu este returnați șirul false. De exemplu, dacă intrarea este 16,
atunci programul dvs. ar trebui să returneze șirul adevărat, dar dacă intrarea este 22, atunci ieșirea ar
trebui să fie șirul fals.
Exemple
Intrare: 4
Ieșire: adevărat
Intrare: 124
Ieșire: false
funcția PowersofTwo(num) {
dacă (num < 2){

ans = "fals";
}
altfel {
în timp ce (num >= 2){
testul VAR = num%2;
dacă (test == 0){
num = num/2
ans = "adevărat";}
altfel{
num = 0;
ans = "fals"}
}
}
Codul merge aici
returnează ans;

PowersofTwo(readline());
returnează Number.isInteger(Math.log(num) / Math.log(2)) ? adevărat : fals;

Codul merge aici

dacă (num === 1) returnează true;
altfel {
întoarcere (num % 2 === 0) ? PowersofTwo (num / 2) : fals;
}
}

Persistența aditivă
Puneți funcția AdditivePersistence(num) să ia parametrul num transmis, care va fi întotdeauna

un întreg pozitiv și să returneze persistența aditivului, care este de câte ori trebuie să adăugați cifrele în
num până când ajungeți la o singură cifră. De exemplu: dacă num este 2718, atunci programul dvs. ar
trebui să returneze 2, deoarece 2 + 7 + 1 + 8 = 18 și 1 + 8 = 9 și vă opriți la 9.
Exemple
Intrare: 4
Ieșire: 0
Intrare: 19
Ieșire: 2
VEZI PROVOCAREA
funcția AdditivePersistence(num) {
funcția arrprep(numb) {
var numstr = numb.toString();
var arr = numstr.split('');
var numarr = arr.map(function(val) {
returnează parseInt(val)
})
Întoarcere numarr
}
funcția addup(arr) {
var redux = arr.reduce(function(a, b){
returnează a + b })
Întoarceți redux
}
numărul var = 0;
în timp ce (num > 9) {
num = addup(arrprep(num));
număr++;
}
Numărul de retururi

Persistență aditivă(linie de citire());
num = num.toString();
fie count = 0;
în timp ce (numărați < 10000) { // oprire grea

dacă (num.length === 1) {
sparge;
}
număr++;
fie suma = 0;
pentru (fie i = 0; i < num.length; i++) {
suma += parseInt(num[i]);
}
num = sum.toString();
}
}

Codul merge aici

funcția addDigits(num) {
return num.toString().split('').map(function(num) {
returnează parseInt(num);
}).reduce(funcție(a, b) {returnează a + b;}, 0);
}
rezultat var = num;

numărul var = 0;
în timp ce (rezultat > 9) {
rezultat = addDigits(rezultat);
număr++;
}
}

Persistența multiplicativă
Puneți funcția MultiplicativePersistence(num) să ia parametrul num care va fi întotdeauna

un întreg pozitiv și să returneze persistența multiplicativă, care este de câte ori trebuie să înmulțiți cifrele
în num până când ajungeți la o singură cifră. De exemplu: dacă num este 39, atunci programul dvs. ar
trebui să returneze 3, deoarece 3 * 9 = 27, atunci 2 * 7 = 14 și în final 1 * 4 = 4 și vă opriți la 4.
Exemple
Intrare: 4
Ieșire: 0
Intrare: 25
Ieșire: 2
funcția MultiplicativePersistence(num) {
funcția numprep(num) {
var strnum = num.toString();
var arr = strnum.split('');
var numarr = arr.map(function(val) {
returnează parseInt(val)});
Întoarcere numarr
}
funcția multnums(arr) {
var newnum = arr.reduce(funcție(a, b) {
returnează un * b})
Întoarcere Newnum
}
Codul merge aici
numărul var = 0;
în timp ce (num > 9) {

num = multnums(numprep(num));
conte++
}
Numărul de retururi
}
MultiplicativePersistence(readline());
fie count = 0;
în timp ce(1) {
dacă (num.length === 1) {
sparge;
}
număr++;
fie suma = 1;
sum *= parseInt(num[i]);
}
num = sum.toString();
}

Codul merge aici

funcția multiplyDigits(num) {
return num.toString().split('').map(function(num) {
returnează parseInt(num);
}).reduce(funcție(a, b) {returnează a * b;}, 1);
}
rezultat var = num;

numărul var = 0;
în timp ce (rezultat > 9) {
rezultat = multiplyDigits(rezultat);
număr++;
}
}

Off Line Minim
Puneți funcția OffLineMinimum (strArr) să ia parametrul strArr transmis, care va fi o matrice de

numere întregi variind de la 1...n și litera "E" și să returneze submulțimea corectă pe baza următoarelor
reguli. Intrarea va fi în următorul format: ["I","I","E","I",...,"E",...,"I"] unde I reprezintă numere întregi,
iar E înseamnă scoate cel mai mic întreg din întregul set. Când ați terminat, programul ar trebui să
returneze acel set nou cu numere întregi separate prin virgule. De exemplu: dacă strArr este
["5","4","6","E","1","7","E","E","3","2"] atunci programul dvs. ar trebui să returneze 4,1,5.
Exemple
Intrare: ["1","2","E","E","3"]
Ieșire: 1,2
Intrare: ["4","E","1","E","2","E","3","E"]
Ieșire: 4,1,2,3
funcția OffLineMinimum(strArr) {
var len = strArr.length;
numărul var = 0;
var holdArr = [];
var ans = [];
pentru(var i = 0; i < len; i++) {

if (strArr[count] === "E") {
var headArr = strArr.splice(0, număr);
strArr.shift();
holdArr = holdArr.concat(headArr);
holdArr.sort(function(a, b) {return a - b});
ans.push(holdArr.shift());
număr = 0;
}
altfel {
număr++;
}
}
returnează ans.join(',');
}

OffLineMinimum(readline());
fie rezultat = [];

pentru (fie i = 0; i < strArr.length; i++) {
if (strArr[i] === 'E') {
result.push(removeSmallest(strArr, i));
} else if (strArr[i] === 'R') {
Nu face nimic
} altceva {
numărul nu face nimic
}
}
funcția removeSmallest(strArr, maxIndex) {
fie smallestIndex = 0;
fie smallestNumber = null;
strArr.forEach(function(value,index){
if (index > maxIndex) {
restitui;
}
dacă (valoare!== 'E' &&; valoare !== 'R') {
if (smallestNumber === null || parseInt(value) < smallestNumber) {
smallestIndex = indice;
smallestNumber = parseInt(valoare);
}
}
});
strArr[smallestIndex] = 'R';
returnează cel mai micNumăr;
}
return result.join(',');

Codul merge aici

var arr = [], rezultat = [];
var log = "";
pentru (articol din strArr) {
dacă (articol === "E") {
result.push(arr.shift());
} altceva {
arr.push(parseInt(item));
arr = arr.sort(funcție(a, b) {return a - b});
}
}
return result.join(',');
}

Schimbarea secvenței
Funcția ChangingSequence(arr) preia matricea de numere stocate în arr și returnează indicele la

care numerele încetează să crească și încep să scadă sau se opresc din scădere și încep să crească. De
exemplu: dacă arr este [1, 2, 4, 6, 4, 3, 1], atunci programul dvs. ar trebui să returneze 3, deoarece 6
este ultimul punct din matrice în care numerele au crescut și următorul număr începe o secvență
descrescătoare. Matricea va conține cel puțin 3 numere și poate conține doar o singură secvență,
crescătoare sau descrescătoare. Dacă există o singură secvență în matrice, atunci programul ar trebui să
returneze -1. Indexarea ar trebui să înceapă cu 0.
Exemple
Intrare: [-4, -2, 9, 10]

Ieșire: -1
Intrare: [5, 4, 3, 2, 10, 11]

Ieșire: 3
funcția ChangingSequence(arr) {
În primul rând, determinați dacă este o secvență crescătoare sau descrescătoare
tip var = arr[1] - arr[0] > 0 ? "în creștere": "în scădere";
setați un indice maxim al matricei, pentru a nu se revărsa

var maxInd = arr.length - 1;
Cod pentru o matrice în creștere

if (tastați === 'crescând') {
findIndex este o metodă de iterație matrice care a venit cu ES6. Se întoarce
Prima valoare pentru care apelarea inversă returnează false.
var index = arr.findIndex(function(val, ind) {
în timp ce (ind < maxInd) {
returnare val > arr[ind + 1];
}
returnează fals;
});
indicele de returnare;
}
if (tastați === 'descrescător') {

var index = arr.findIndex(function(val, ind) {
în timp ce (ind < maxInd) {
returnare val < arr[ind + 1]
}
returnare 0;
});
indicele de returnare;
}
}

ChangingSequence(readline());
fie index = nul;

Fie mod = (arr[1] - arr[0] > 0) ? adevărat : fals;
dacă (arr[i] - arr[i-1] > 0 !== mod) {
indice = i-1;
sparge;
}
}
returnare (index === null) ? -1 : indice;
}

creșterea var = arr[0] < arr[1];

dacă (în creștere) {
dacă (arr[i] > arr[i + 1]) returnează i;
} altceva {
dacă (arr[i] < arr[i + 1]) returnează i;
}
}
întoarcere -1;
}

Suprapunerea intervalelor
Funcția OverlappingRanges(arr) ia matricea de numere stocate în arr care va conține 5 numere

întregi pozitive, primele două reprezentând un interval de numere (de la a la b), următoarele 2
reprezentând și un alt interval de numere întregi (de la c la d) și un al 5-lea element final (x ) care va fi,
de asemenea, un întreg pozitiv, și returnează șirul true dacă ambele seturi de intervale se suprapun cu
cel puțin x numere. De exemplu: dacă arr este [4, 10, 2, 6, 3], atunci programul dvs. ar trebui să
returneze șirul adevărat. Primul interval de numere este 4, 5, 6, 7, 8, 9, 10, iar al doilea interval de
numere este 2, 3, 4, 5, 6. Ultimul element din matrice este 3 și există 3 numere care se suprapun între
ambele intervale: 4, 5 și 6. Dacă ambele zone nu se suprapun cu cel puțin x numere, atunci programul ar
trebui să returneze șirul fals.
Exemple
Intrare: [5,11,1,5,1]
Intrare: [1,8,2,4,4]
Ieșire: false
funcția OverlappingRanges(arr) {
țintă var = arr.pop();
var MaxLowerBound = Math.max(arr[0], arr[2]);
var MinUpperBound = Math.min(arr[1], arr[3]);
gama var = MinUpperBound - MaxLowerBound + 1;
intervalul de returnare >= țintă? "true": "false";

}

SuprapunereIntervale(readline());
fie count = 0;
pentru (fie i = arr[0]; i <= arr[1]; i++) {
dacă (i >= arr[2] &&; i <= arr[3]) {
număr++;
}
}
întoarcere (număr >= arr[4]) ? adevărat : fals;
}

gama var1 = [arr[0], arr[1]]; (a, b)
gama var2 = [arr[2], arr[3]]; (c, d)
var minimumSuprapunere = arr[4] - 1;
Determină suprapunerea dintre două intervale

Un număr negativ înseamnă că nu există nicio suprapunere
Suprapunerea funcției (interval1, interval2) {
dacă (range1[0] < range2[0]) {
a----b
c----d
retur (range1[1] > range2[1] ? range2[1] : range1[1]) - range2[0];
} altceva {
a----b
c---d
retur (range2[1] > range1[1] ? range1[1] : range2[1]) - range1[0];
}
}
retur suprapunere (interval1, interval2) >= minimumSuprapunere;

}

Supracreșterea
Puneți funcția Supergrowing (arr) să ia matricea de numere stocate în arr și să determine dacă
matricea formează o secvență supracrescătoare în care fiecare element din matrice este mai mare decât
suma tuturor elementelor anterioare. Matricea va consta numai din numere întregi pozitive. De exemplu:
dacă arr este [1, 3, 6, 13, 54], atunci programul dvs. ar trebui să returneze șirul "true", deoarece
formează o secvență supracrescătoare. Dacă nu se formează o secvență supracrescătoare, atunci
programul dvs. ar trebui să returneze șirul "false"
Exemple
Intrare: [1,2,3,4]
Ieșire: false
Intrare: [1,2,5,10]
funcția Supergrowth(arr) {
var maxInd = arr.length - 1;
ținta VAR;
var sum;
pentru (var i = maxInd; i > 0; i--) {

țintă = arr.pop()
sum = arr.reduce(funcție(val1, val2) {
returnează val1 + val2;
});
dacă (suma >= țintă) {
}
};
returnați "adevărat";
}
Supercreștere(linie de citire());
pentru (fie i = 0, sumă = 0; i < arr.length; i++) {

dacă (arr[i] <= sumă) {
returnează fals;
}
suma += arr[i];
}
}

dacă (arr.length < 2) returnează false;
dacă (arr.length === 2) întoarcere arr[0] < arr[1];
dacă (arr[0] >= arr[1]) returnează false;
var total = arr[0] + arr[1];

dacă (arr[i] <= total) returnează false;
total += arr[i];
}
}

Distanța Hamming
Funcția HammingDistance(strArr) preia matricea de șiruri stocate în strArr, care va conține doar
două șiruri de lungime egală și va returna distanța Hamming dintre ele. Distanța Hamming este numărul
de poziții în care caracterele corespunzătoare sunt diferite. De exemplu: dacă strArr este ["coder",
"codec"] atunci programul dvs. ar trebui să returneze 1. Șirul va avea întotdeauna o lungime egală și va
conține doar caractere minuscule din alfabet și numere.
Exemple
Intrare: ["10011", "10100"]

Ieșire: 3
Intrare: ["helloworld", "worldhello"]

Ieșire: 8
funcția HammingDistance(strArr) {
fie count = 0;
pentru (fie i = 0; i < strArr[0].length; i++) {
dacă (strArr[0][i] !== strArr[1][i]) {
conte++
}
}
}

HammingDistance(readline());
var word1 = strArr[0],
word2 = strArr[1],
len = word1.length,
număr = 0;

dacă (word1[i] !== word2[i]) {
număr++;
}
}
}

var hammingDistanță = 0;
pentru (var i = 0; i < strArr[0].length; i++) {
dacă (strArr[0][i] !== strArr[1][i]) {
hammingDistance++;
}
}
întoarcere hammingDistanță;
}

Suprafața dreptunghiului
Cea mai bine cotată soluție pentru utilizatori
funcția RectangleArea(strArr) {
var obj = {};
obj.x1 = parseInt(strArr[0].match(/((-*d+)/)[1], 10);
obj.y1 = parseInt(strArr[0].match(/(-*d+))/)[1], 10);
pentru (var i = 1; i < 3; i++) {

dacă (obj.x1 !== parseInt(strArr[i].match(/((-*d+)/)[1], 10)) {
obj.x2 = parseInt(strArr[i].match(/((-*d+)/)[1], 10);
}
dacă (obj.y1 !== parseInt(strArr[i].match(/(-*d+))/)[1], 10)) {
obj.y2 = parseInt(strArr[i].match(/(-*d+))/)[1], 10);
}
}
dacă (Object.keys(obj).length !== 4) {
returnare 0;
} altceva {
întoarcere (Math.abs(obj.x1 - obj.x2) * Math.abs(obj.y1 - obj.y2));
}
}

DreptangleArea(readline());
Analizați intrarea în matrice

let coords = strArr.map(function(val){
fie coorduri = val.split(' ');
fie x = parseInt(coords[0].substr(1, coords[0].length-1));
fie y = parseInt(coorduri[1].substr(0, coorduri[1].length-1));
returnează [x,y];
});
să punct = coorduri.shift();
fie x = punct[0];
fie y = punct[1];
fie deltaX = 0;
fie deltaY = 0;
coords.forEach(function(val){
dacă (x === val[0]) {
deltaY = Math.abs(val[1] - y);
}
dacă (y === val[1]) {
deltaX = Math.abs(val[0] - x);
}
});
returna deltaX * deltaY;

var points = strArr.map(str => str.match(/\d+/g));
var minX = points.map(point => point[0]).sort()[0];
var minY = points.map(point => point[1]).sort()[0];
var maxX = points.map(point => point[0]).sort().reverse()[0];
var maxY = points.map(point => point[1]).sort().reverse()[0];
întoarcere (maxX - minX) * (maxY - minY);

}
Unul la nivel de biți
Puneți funcția BitwiseOne(strArr) să ia matricea de șiruri stocate în strArr, care va conține doar
două șiruri de lungime egală care reprezintă numere binare și să returneze un șir binar final care a
efectuat operația bitwise OR pe ambele șiruri. O operație OR la nivel de biți plasează un 0 în noul șir
unde există zerouri în ambele șiruri binare, altfel plasează un 1 în acel loc. De exemplu: dacă strArr
este ["1001", "0100"], atunci programul dvs. ar trebui să returneze șirul "1101"
Exemple
Intrare: ["100", "000"]

Ieșire: 100
Intrare: ["00011", "01010"]

Ieșire: 01011
VEZI PROVOCAREA
funcția BitwiseOne(strArr) {
var str1 = strArr[0];
var str2 = strArr[1];
var newStr = '';
lent = str1.lungime;

if(str1.charAt(i) === '1' || str2.charAt(i) === '1') {
newStr = newStr += '1';
} altceva {
newStr = newStr += '0';
}
}
întoarcere newStr;
}

BitwiseOne(readline());
ieșire var = '';
if (strArr[0][i] === '1' || strArr[1][i] === '1') {
Ieșire + = "1";
} altceva {
ieșire + = "0";
}
}
returnarea producției;
}

fie newString = '';

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

Alte produse
Puneți funcția OtherProducts(arr) să preia matricea de numere stocate în arr și să

returneze o nouă listă a produselor tuturor celorlalte numere din matrice pentru fiecare element. De
exemplu: dacă arr este [1, 2, 3, 4, 5], atunci noua matrice, unde fiecare locație din noua matrice este
produsul tuturor celorlalte elemente, este [120, 60, 40, 30, 24]. Următoarele calcule au fost efectuate
pentru a obține acest răspuns: [(2*3*4*5), (1*3*4*5), (1*2*4*5), (1*2*3*5), (1*2*3*4)]. Ar trebui să
generați această nouă matrice și apoi să returnați numerele ca un șir unit printr-o cratimă: 120-60-40-30-
24. Matricea va conține cel mult 10 elemente și cel puțin 1 element numai din numere întregi pozitive.
Exemple
Intrare: [1,4,3]
Ieșire: 12-3-4
Intrare: [3,1,2,6]
Ieșire: 12-36-18-6
funcția OtherProducts(arr) {
fie holdArray = [];
arr.forEach((val, ind, theArray) => {

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

})
returnează holdArray.join('-');
}

OtherProducts(readline());
fie rezultate = [];

să produs = 1;
pentru (fie j = 0; j < arr.length; j++) {
dacă (i !== j) {
produs *= arr[j];
}
}
results.push(produs);
}
return results.join('-');
}

Produs funcțional(ARR) {
returnare arr.reduce((a,b) => a * b);
}
produse var = [];
var altele = arr.slice(0, i).concat(arr.slice(i + 1));
products.push(produs(altele));
}
return products.join('-');
}

Sortarea valurilor
Puneți funcția WaveSorting(arr) să ia matricea de numere întregi pozitive stocate în arr și

să returneze șirul true dacă numerele pot fi aranjate într-un model de undă: a1 > a2 < a3 > a4 < a5 > ...,
altfel returnați șirul false. De exemplu, dacă arr este: [0, 1, 2, 4, 1, 4], atunci o posibilă ordonare în
undă a numerelor este: [2, 0, 4, 1, 4, 1]. Deci, pentru această intrare, programul dvs. ar trebui să
returneze șirul adevărat. Matricea de intrare va conține întotdeauna cel puțin 2 elemente. Mai multe
exemple sunt prezentate mai jos ca exemple de cazuri de testare.
Exemple
Intrare: [0, 1, 2, 4, 1, 1, 1]
Ieșire: false
Intrare: [0, 4, 22, 4, 14, 4, 2]

funcția WaveSorting(arr) {
Gândindu-ne la asta, rezultatul dorit va fi posibil atâta timp cât nu avem niciun
număr
de mai multe ori decât alte numere pentru a-l descompune
Obțineți numărul total de numere

fie lungime = arr.length;
Obțineți numărul de intrări pentru fiecare număr

fie countObj = {};
arr.forEach(val => {
if (!countObj[val]) {
countObj[val] = 1;
} altceva {
countObj[val]++;
}
});
Faceți o serie a rezultatelor noastre, astfel încât să putem găsi maximul

fie countArr = [];
for (let key in countObj) {
countArr.push(countObj[cheie]);
}
Găsiți maximul - nu mai trebuie să utilizați apply()!

fie maxCount = Math.max(... countArr);
returnare maxCount > lungime/2 ? fals : adevărat;

WaveSorting(readline());
arr = arr.sort((a,b) => a - b).revers();

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

dacă (i % 2 === 0) {
newArr.push(arr.splice(0, 1));
} altceva {
Uită-te și ia următorul element mai mic decât arr[i]
pentru (fie j = 1; j < arr.length; j++) {
dacă (arr[j] < arr[0]) {
newArr.push(arr.splice(j, 1));
sparge;
}
}
}
Verificați dacă noul Arr este sortat în valuri

pentru (fie i = 0; i < newArr.length-1; i++) {
dacă (i % 2 === 0) {
i > i+1 = adevărat
if (parseInt(newArr[i]) <= parseInt(newArr[i+1])) {
returnează fals;
}
} altceva {
i < i+1 = adevărat
if (parseInt(newArr[i]) >= parseInt(newArr[i+1])) {
returnează fals;
}
}
}
}

Găsiți numărul celui mai frecvent element, care este modul

funcția mostFrequent(arr) {
arr.sort();
var most = 0;
frecvența var = 1;
dacă (arr[i] === arr[i + 1]) {
frecvență++;
dacă (frecvența > majoritatea) {
majoritatea = frecvență;
}
} altceva {
frecvență = 1;
}
}
returnează cel mai mult;
}
Atâta timp cât putem pune un alt număr între același număr, funcționează
returnează mostFrecvent(arr) < (arr.length / 2);
}

Potrivire matrice
Puneți funcția ArrayMatching(strArr) să citească matricea de șiruri stocate în strArr care va

conține doar două elemente, ambele reprezentând o matrice de numere întregi pozitive. De exemplu:
dacă strArr este ["[1, 2, 5, 6]", "[5, 2, 8, 11]"], atunci ambele elemente din intrare reprezintă două
matrice întregi, iar scopul tău pentru această provocare este să adaugi elementele în locațiile
corespunzătoare din ambele matrice. Pentru intrarea de exemplu, programul dvs. ar trebui să facă
următoarele adăugiri: [(1 + 5), (2 + 2), (5 + 8), (6 + 11)] care apoi este egal cu [6, 4, 13, 17]. Programul
dvs. ar trebui să returneze în cele din urmă această matrice rezultată într-un format șir, cu fiecare
element separat printr-o cratimă: 6-4-13-17.
Dacă cele două matrice nu au aceeași cantitate de elemente, atunci pur și simplu adăugați elementele
rămase pe noua matrice (exemplu prezentat mai jos). Ambele matrice vor fi în formatul: [e1, e2, e3, ...]
unde va exista cel puțin un element în fiecare matrice.
Exemple
Intrare: ["[5, 2, 3]", "[2, 2, 3, 10, 6]"]

Ieșire: 7-4-6-10-6
Intrare: ["[1, 2, 1]", "[2, 1, 5, 2]"]

Ieșire: 3-3-6-2
funcția ArrayMatching(strArr) {
strArr = strArr.map(val => val.replace(/[[]]/g, '')
.split(/s*,s*/).map(val1 => parseInt(val1, 10)));
fie resArr = [];

fie arr1 = strArr[0];
fie arr2 = strArr[1];
fie lungime = Math.max(arr1.length, arr2.length);
pentru (fie i = 0; i < lungime; i++) {

dacă (arr1[i] &&; arr2[i]) {
resArr[i] = arr1[i] + arr2[i];
} altceva {
resArr[i] = arr1[i] || ARR2[i];
}
}
return resArr.join('-');

ArrayMatching(readline());
fie numbers1 = strArr[0].substr(1, strArr[0].length-1).split(', ');

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

numbers2.length;
fie rezultate = [];
pentru (fie i = 0; i < maxLength; i++) {

Fie num1 = (i < numere1.lungime) ? parseInt(numbers1[i]) : 0;
Fie num2 = (i < numere2.lungime) ? parseInt(numbers2[i]) : 0;
results.push(num1 + num2);
}
return results.join('-');
}

arr1 = strArr[0].match(/\d+/g).map(Număr);
arr2 = strArr[1].match(/\d+/g).map(Număr);
dacă (arr1.length > arr2.length) {

arr2 = arr2.concat(matrice nouă(arr1.length - arr2.length).fill(0));
} altfel dacă (arr1.length < arr2.length) {
arr1 = arr1.concat(matrice nouă(arr2.lungime - arr1.lungime).fill(0));
}
suma var = [];
pentru (var i = 0; i < arr1.length; i++) {
sum.push(arr1[i] + arr2[i]);
}
returnare sum.join('-');
}

Inversare binară
Puneți funcția BinaryReversal(str) să ia parametrul str trecut, care va fi un întreg pozitiv, să ia

reprezentarea binară (căptușită la cel mai apropiat N * 8 biți), să inverseze acel șir de biți și apoi să
returneze în cele din urmă noul șir inversat în formă zecimală. De exemplu: dacă str este "47", atunci
versiunea binară a acestui întreg este 101111 dar îl tamponăm pentru a fi 00101111. Programul dvs. ar
trebui să inverseze acest șir binar care apoi devine: 11110100 și apoi să returneze în cele din urmă
versiunea zecimală a acestui șir, care este 244.
Exemple
Intrare: "213"
Ieșire: 171
Intrare: "4567"
Ieșire: 60296
funcția BinaryReversal(str) {
fie num = parseInt(str, 10)

.toString(2);
fie lungime = num.length;
Adăugați zerouri inițiale pentru a face numărul un număr integral de octeți

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

.invers()
.join('');
return parseInt(stringByte, 2).toString();

BinaryReversal(readline());
fie binar = parseInt(str).toString(2);
fie size = Math.ceil(binary.length/8) * 8;

în timp ce (binary.length < size) {
binar = '0' + binar;
}
fie newString = '';

pentru (fie i = 0; i < binary.length; i++) {
newString = binar[i] + newString;
}
returnează parseInt(newString, 2);
}

funcția toBinary(str) {
rezultat = Number(str).toString(2);
pad stânga cu 0 înainte pentru a face un multiplu de 8 cifre ...
dacă (result.length % 8 !== 0)
returnează matrice nouă(8 - (result.length % 8)).fill(0).join('') + rezultat;
altfel rezultatul returnării;
}
funcția toDecimal(str) {
returnează parseInt(str, 2);
}
întoarcere laBinary(str);
var reverse = toBinary(str).split('').reverse().join('');
întoarcere laZecimal(invers);
}

Cea mai lungă secvență crescătoare
Funcția LongestGrowthSequence(arr) preia matricea de numere întregi pozitive stocate în arr și

returnează lungimea celei mai lungi subsecvențe crescătoare (LIS). Un LIS este un subset al listei
originale în care numerele sunt în ordine sortată, de la cel mai mic la cel mai mare și sunt în ordine
crescătoare. Secvența nu trebuie să fie contiguă sau unică și pot exista mai multe subsecvențe diferite.
De exemplu: dacă arr este [4, 3, 5, 1, 6], atunci un posibil LIS este [3, 5, 6], iar altul este [1, 6]. Pentru
această intrare, programul ar trebui să returneze 3, deoarece aceasta este lungimea celei mai lungi
subsecvențe crescătoare.
Exemple
Intrare: [9, 9, 4, 2]
Ieșire: 1
Intrare: [10, 22, 9, 33, 21, 50, 41, 60, 22, 68, 90]
Ieșire: 7
funcția LongestGrowthSequence(arr) {
fie len = arr.length;
fie arrHolder = [];
Evaluați fiecare combinație posibilă de numere

pentru (fie i = Math.pow(2, len); i < Math.pow(2, len + 1); i++) {
numArray este o cifră binară, 0s și 1s reprezentând dacă să includă

un număr sau nu în matricea combinată. Vor exista 2 ^ n combinații
Pentru a obține zerouri inițiale, utilizați numere de la 2^n la 2^n+1, apoi
tăiați 1 inițial
fie numArray = i.toString(2).slice(1).split('');
țineți numerele selectate în noua matriceSeq

newSeq = [];
popularea matricei nouSeq

arr.forEach((val, ind) => {
if (numArray[ind] === '1') {
nouSeq.push(val);
}
});
includeți matricea newSeq în arrHolder

arrHolder.push(nouSeq);
}
scoateți toate matricele care nu sunt ascendente (utilizați ascend() pentru a

determina)
arrHolder = arrHolder.filter(val => ascend(val));
Înlocuiți fiecare matrice care trece cu lungimea sa

let arrLength = arrHolder.map(val => val.length);
Returnarea celei mai mari valori de lungime

returnează Math.max(... arrLength);
}
funcția ascend(inputArr) {
let arrlen = inputArr.length;
return inputArr.every((val, ind) => {
dacă (ind < arrlen - 1) {
return val < inputArr[ind + 1];
}
});
}

LongestCrescătorSequence(readline());
https://stackoverflow.com/questions/2631726/how-to-determine-the-longest-increasing-
subsequence-using-dynamic-programming
Algoritmul folosit de aici
fie lis = [arr[0]];

dacă (arr[i] > lis[lis.length - 1]) {
lis.push(arr[i]);
continua;
}
pentru (fie j = 0; j < lis.length; j++) {

dacă (lis[j] >= arr[i]) {
lis[j] = arr[i];
sparge;
}
}
}
returnează lis.length;

generează n permutări adevărate/false

Aceasta va fi utilizată pentru a genera subsecvențe - pentru a include acest element
sau nu
funcția permute(n) {
dacă (n < 1) returnează null;
dacă (n < 2) returnează [[adevărat], [fals]];
var anterior = permut(n - 1);
rezultat var = [];
pentru (permutarea var a precedentului) {
result.push(permutation.concat([true]));
result.push(permutation.concat([false]));
}
}
Obțineți toate subsecvențele posibile

funcția getSubSequences(arr) {
return permute(arr.length).map(function(permutation) {
rezultat var = [];
pentru (var i = 0; i < permutare.lungime; i++) {
dacă (permutare[i]) {
result.push(arr[i]);
}
}
});
}
funcția crescătoare(arr) {
return arr.every(function(value, index, arr) {
var prev = (indice === 0) ? 0: arr[index - 1];
returnarea valorii < anterioare;
});
}
var cel mai lung = 0;
var subSequences = getSubSequences(arr);

pentru (var subSequence of subSequences) {
if(crescând(subSequence) &&; subSequence.length > cel mai lung) {
cea mai lungă = subSequence.length;
}
}
întoarceți cel mai mult;
}

Perechi pare
Puneți funcția EvenPairs(str) să ia parametrul str transmis și să determine dacă există o pereche de
numere pare adiacente oriunde în șir. Dacă există o pereche, returnați șirul true, altfel returnați false. De
exemplu: dacă str este "f178svg3k19k46", atunci există două numere pare la sfârșitul șirului, "46",
astfel încât programul dvs. ar trebui să returneze șirul adevărat. Un alt exemplu: dacă str este
"7r5gg812", atunci perechea este "812" (8 și 12), astfel încât programul dvs. ar trebui să returneze șirul
adevărat.
Exemple
Intrare: "3gy41d216"
Ieșire: adevărat
Intrare: "f09r27i8e67"
Ieșire: false
funcția EvenPairs(str) {
var regEx = /[24680]d*[24680]/
returnare regEx.test(str);
}
EvenPairs(readline());
const DIGITS = '0123456789';
fie numberGroups = [];
Obțineți grupuri de cifre

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

numberGroups.push(digitStr);
digitStr = '';
}
}
Aveți grijă doar de lungimea grupului > 1

numberGroups = numberGroups.filter(v => v.length > 1);
Buclă peste toate "grupurile"

pentru (fie i = 0; i < numberGroups.length; i++) {
Bucle imbricate pentru fiecare grup
pentru (fie j = 0; j < numberGroups[i].length; j++) {
pentru (fie k = j + 1; k < numberGroups[i].length; k++) {
fie str1 = numberGroups[i].substr(0, j+1);
fie str2 = numărGrupuri[i].substr(j+1, k);
if (parseInt(str1) % 2 === 0 &&; parseInt(str2) % 2 === 0) {
}
}
}
}
returnează fals;
}

Vedeți dacă există mai mult de două perechi de numere pare

funcția hasEvenPairs(număr) {
potrivire non-lacomă a numerelor pare
rezultat var = number.toString().match(/\d*?[ 24680]/g);
întoarcere (rezultat === nul) ? fals : (result.length >= 2);
}
numere var = str.match(/\d+/g);
pentru (numărul var de numere) {
dacă (hasEvenPairs(number)) returnează true;
}
returnează fals;
}

Următor → Palindromul
Puneți funcția NextPalindrome(num) să ia parametrul num trecut și să returneze următorul număr

palindromic ca mărime. Intrarea poate fi orice număr întreg pozitiv. De exemplu: dacă num este 24,
atunci programul dvs. ar trebui să returneze 33, deoarece acesta este următorul cel mai mare număr care
este un palindrom.
Exemple
Intrare: 2
Ieșire: 3
Intrare: 180
Ieșire: 181
funcția NextPalindrome(num) {
fie count = num + 1;
în timp ce (adevărat) {
numString = count.toString();
revString = numString.split('')
.invers()
.join('');
if (revString === numString) returnează parseInt(numString, 10);
număr++;
}
}

NextPalindrome(readline());
fie următorPalindromul = nul;
pentru (fie i = num + 1; ; i++) {
fie șir = i.toString();
dacă (isPalindrome(string)) {
următorPalindrom = i;
sparge;
}
}
întoarceți următorulPalindrome;
funcția isPalindrome(str) {
returnează fals;
}
}
}
}

funcția isPalindrome(num) {
var numStr = num.toString();
return numStr.split('').reverse().join('') === numStr;
}
var nextNum = num + 1;
în timp ce (!isPalindrome(nextNum)) {
nextNum++;
}
întoarceți următorulNum;
}

Cea mai mare pereche
Funcția LargestPair(num) ia parametrul num transmis și determină cel mai mare număr de două
cifre din întregul număr. De exemplu: dacă num este 4759472 atunci programul ar trebui să returneze 94,
deoarece acesta este cel mai mare număr din două cifre. Intrarea va conține întotdeauna cel puțin două
cifre pozitive.
Exemple
Intrare: 453857
Ieșire: 85
Intrare: 363223311
Ieșire: 63
funcția LargestPair(num) {
fie numStr = num.toString();
fie numArr = numStr.split('')

.map(val => parseInt(val, 10));
scapă de cifra finală, în cazul în care este cea mai mare;

numArr.pop();
fie maxNum = Math.max(... numArr);
fie regEx = RegExp nou('${maxNum}\d', 'g');
fie meciuri = numStr.match(regEx);
return matches.sort((a, b) => a - b).pop();

}

LargestPair(readline());
fie largestNum = 0;
let testNum = parseInt(num[i-1] + num[i]);
if (testNum > largestNum) {
largestNum = testNum;
}
}
returnați cel mai mareNum;
}
var max = 0;
var numStr = num.toString();
fereastră glisantă cu dimensiunea 2

pentru (var i = 0; i < numStr.length - 1; i++) {
var testNum = Număr(numStr.slice(i, i + 2));
dacă (testNum > max) {
max = testNum;
}
}
întoarcere maximă;
}

Caracter care nu se repetă
Puneți funcția NonrepeatingCharacter(str) să ia parametrul str trecut, care va conține numai

caractere alfabetice și spații, și să returneze primul caracter care nu se repetă. De exemplu: dacă str
este "agettkgaeee", atunci programul dvs. ar trebui să returneze k. Șirul va conține întotdeauna cel puțin
un caracter și va exista întotdeauna cel puțin un caracter care nu se repetă.
Exemple
Intrare: "abcdef"
Ieșire: a
Intrare: "salut lume hi hei"

Ieșire: w
funcția NonrepeatingCharacter(str) {
fie len = str.length;
fie countObj = {}
pentru (fie i = 0; i < len; i++) {

dacă (countObj[str[i]]) {
countObj[str[i]]++;
}
altfel {
countObj[str[i]] = 1;
}
}
pentru (fie j = 0; j < len; j++) {
dacă (countObj[str[j]] === 1) returnează str[j];
}
}

NonrepeatingCharacter(readline());
fie repeatingChars = '';

să rezulte = '';
fie repetat = fals;
pentru (fie j = i+1; j < str.length; j++) {
dacă (str[i] === str[j] || repeatingChars.includes(str[i])) {
repetare = adevărat;
repeatingChars += str[i];
sparge;
}
}
dacă (se repetă) {
rezultat = str[i];
sparge;
}
}
}

str = str.replace(/\s+/g, '');
numărul var = {};
Numărați fiecare literă

pentru (var i = 0; i < str.length; i++) {
dacă (str[i] în numere) {
contează[str[i]]++;
} altceva {
numere[str[i]] = 1;
}
}
Returnați prima literă cu numărul de 1

pentru (i = 0; i < str.length; i++) {
dacă (counts[str[i]] === 1) return str[i];
}
}

Două sume
Setați funcția TwoSum(arr) să preia matricea de numere întregi stocate în arr și să determine dacă
oricare două numere (excluzând primul element) din matrice pot însuma până la primul element din
matrice. De exemplu: dacă arr este [7, 3, 5, 2, -4, 8, 11], atunci există de fapt două perechi care
însumează numărul 7: [5, 2] și [-4, 11]. Programul dvs. ar trebui să returneze toate perechile, cu
numerele separate printr-o virgulă, în ordinea în care apare primul număr în matrice. Perechile trebuie
separate printr-un spațiu. Deci, pentru exemplul de mai sus, programul dvs. ar returna: 5,2 -4,11
Dacă nu există două numere care însumează primul element din matrice, returnați -1
Exemple
Intrare: [17, 4, 5, 6, 10, 11, 4, -3, -5, 3, 15, 2, 7]

Ieșire: 6,11 10,7 15,2
Intrare: [7, 6, 4, 1, 7, -2, 3, 12]

Ieșire: 6,1 4,3
funcția TwoSum(arr) {
fie target = arr.shift();
let holdArr = [];

pentru (fie j = i + 1; j < len; j++) {
dacă (arr[i] + arr[j] === țintă) {
holdArr.push('${arr[i].toString()},${arr[j].toString()}');
sparge;
}
}
}
întoarcere holdArr.length ? holdArr.join(' ') : -1;
}

TwoSum(readline());
const răspuns = arr.shift(arr);

const history = set nou();
const meciuri = [];
Fără invers() aici, rezultatele finale vor fi în ordine

Al doilea număr apare în matrice, dar vrem să fie
ordonate după primul număr.
arr.revers();
arr.forEach(item => {
const compliment = răspuns - articol;
dacă (history.has(compliment)) {
matches.push([articol, compliment]);
} altceva {
history.add(articol);
}
});
Meciurile au fost împinse pe matrice în ordine inversă, astfel încât

Acum trebuie să le schimbăm înapoi.
chibrituri.invers();
retur (meciuri.lungime === 0) ? -1 : matches.map(m => m.join(',')).join(' ');

}

TwoSum(readline());
Găsiți perechi care însumează numărul dat

funcția findPairs(arr, sum) {
perechi var = [];
pentru (var j = i + 1; j < arr.length; j++) {
dacă (arr[i] + arr[j] === sumă)
pairs.push([arr[i], arr[j]]);
}
}
perechi de întoarcere;
}
perechi var = [];
var sum = arr[0];
var rest = arr.felie(1);
perechi = findPairs(rest, sumă);
întoarcere (perechi.lungime === 0) ? -1 : pairs.map(pair =>

pair.join(',')).join(' ');
}

TwoSum(readline());
Doi biți
Puneți funcția BitwiseTwo (strArr) să ia matricea de șiruri stocate în strArr, care va conține doar
două șiruri de lungime egală care reprezintă numere binare și să returneze un șir binar final care a
efectuat operația AND la nivel de biți pe ambele șiruri. O operație AND la nivel de biți plasează un 1 în
noul șir unde există un 1 în ambele locații din șirurile binare, altfel plasează un 0 în acel loc. De
exemplu: dacă strArr este ["10111", "01101"], atunci programul dvs. ar trebui să returneze șirul
"00101"
Exemple
Intrare: ["100", "000"]

Ieșire: 000
Intrare: ["10100", "11100"]

Ieșire: 10100
funcția BitwiseTwo(strArr) {
fie num1 = strArr[0];
fie num2 = strArr[1];
let len = strArr[0].length;
fie resStr = '';

dacă (num1[i] === '1' &&; num2[i] === '1') {
resStr += '1';
continua;
}
altfel {
resStr += '0';
continua;
}
}
retur resStr;
}

BitwiseTwo(linie de citire());
fie newStr = '';

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

rezultat var = '';
dacă (strArr[0][i] === '1' &&; strArr[1][i] === '1') {
rezultat + = "1";
} altceva {
rezultat += "0";
}
}
}

Număr seturi de alimentare
Puneți funcția PowerSetCount(arr) să preia matricea de numere întregi stocate în arr și să returneze
lungimea setului de puteri (numărul tuturor seturilor posibile) care pot fi generate. De exemplu: dacă
arr este [1, 2, 3], atunci următoarele seturi formează setul de puteri:
[][1][2][3][1, 2][1, 3][2, 3][1, 2, 3]
Puteți vedea mai sus toate seturile posibile, împreună cu setul gol, sunt generate. Prin urmare, pentru
această intrare, programul dvs. ar trebui să returneze 8.
Exemple
Intrare: [1, 2, 3, 4]
Ieșire: 16
Intrare: [5, 6]
Ieșire: 4
funcția PowerSetCount(arr) {
returnează Math.pow(2, len);
}

PowerSetCount(linie de citire());
returnează Math.pow(2, arr.length);
}

returnează Math.pow(2, arr.length);
}

Cifre produs
Puneți funcția ProductDigits(num) să ia parametrul num care va fi un întreg pozitiv și să

determine cea mai mică cantitate de cifre pe care trebuie să o înmulțiți pentru ao produce. De exemplu:
dacă num este 24, atunci puteți înmulți 8 cu 3, ceea ce produce 24, deci programul dvs. ar trebui să
returneze 2, deoarece există un total de numai 2 cifre care sunt necesare. Un alt exemplu: dacă num este
90, puteți înmulți 10 * 9, deci în acest caz programul dvs. ar trebui să emită 3, deoarece nu puteți ajunge
la 90 fără a utiliza un total de 3 cifre în înmulțirea dvs.
Exemple
Intrare: 6
Ieșire: 2
Intrare: 23
Ieșire: 3
funcția ProductDigits(num) {
fie pivot = Math.sqrt(num);
fie value = num.toString().length + 1;
pentru (fie i = 1; i <= pivot; i++) {
dacă (num % i === 0) {
fie maxFactor = i;
maxCompFactor = num / maxFactor;
maxFactorString = maxFactor.toString();
maxCompFactorString = maxCompFactor.toString();
fie totalLength = maxFactorString.length +
maxCompFactorString.length;
if (totalLength < value) {
valoare = totalLungime;
}
}
}
valoarea returnată;
}

ProductDigits(linie de citire());
fie pf = factori prime(num);
dacă (pf.length === 1) {

returnează pf[0].toString().length + 1;
}
fie factori = [];
pentru (fie divizor = 0; divizor < pf.length; divizor ++) {

fie stânga = pf.slice(0, divizor);
fie dreapta = pf.slice(divizor, pf.length);
fie leftProduct = left.reduce((produs, valoare) => produs *= valoare, 1);

let rightProduct = right.reduce((produs, valoare) => produs *= valoare, 1);
factors.push([leftProduct, rightProduct]);
}
return factors.map(factor => factor.join('').split('').length).reduce((max, val)

=> val < max? val : max, Number.MAX_SAFE_INTEGER);
funcția primeFactors(num) {
dacă (num === 1) returnează 1;
fie pf = [];
pentru (fie i = 2; i <= num; i++) {

dacă (num % i === 0) {
pf.push(i);
num /= i;
i = 1;
}
}
returnarea pf;
}
}

funcția getDivisors(num) {
divizori var = [1];
pentru (var i = 2; i <= num / 2; i++) {
dacă (num % i === 0) {
divizori.push(i);
}
}
divizori.push(num);
divizori de întoarcere;
}
divizori var = divizori getdivizori(num);
perechi var = [];
pentru (var i = 0; i < divizori.lungime / 2; i++) {

pairs.push([divizori[i], divizori[(divizori.lungime - 1) - i]]);
}
return pairs.map(pair => ('' + pair[0] + pair[1]).length).sort()[0];

}

Creatorul palindromului
Puneți funcția PalindromeCreator(str) să ia parametrul str transmis și să determine dacă este

posibil să creați un șir palindromic de lungime minimă 3 caractere eliminând 1 sau 2 caractere. De
exemplu: dacă str este "abjchba", atunci puteți elimina caracterele jc pentru a produce "abhba", care
este un palindrom. Pentru acest exemplu, programul ar trebui să returneze cele două caractere care au
fost eliminate fără delimitator și în ordinea în care apar în șir, deci jc. Dacă 1 sau 2 caractere nu pot fi
îndepărtate pentru a produce un palindrom, atunci returnați șirul nu este posibil. Dacă șirul de intrare
este deja un palindrom, programul ar trebui să returneze palindromul șirului.
Intrarea va conține numai caractere alfabetice minuscule. Programul dvs. ar trebui să încerce întotdeauna
să creeze cel mai lung subșir palindromic eliminând 1 sau 2 caractere (a se vedea al doilea exemplu de
caz de test ca exemplu). Cele 2 caractere pe care le eliminați nu trebuie să fie adiacente în șir.
Exemple
Intrare: "mmop"
Ieșire: nu este posibil
Intrare: "kjjjhjjj"
Ieșire: k
funcția PalindromeCreator(str) {
testați pentru a vedea dacă este deja un Palindrom
dacă (isPalindrome(str)) {
returnați "palindromul";
}
let testArray = str.split('');
fie res = testArray.splice(i, 1);
fie newString = testArray.join('');
dacă (isPalindrome(newString)) {
consolă.log("una");
returnare res.join('');
}
}
fie res = [];
pentru (fie j = i; j < len - 1; j++) {
let testArray = str.split('');
res[0] = testArray.splice(i, 1);
res[1] = testArray.splice(j, 1);
fie newString = testArray.join('');
if(isPalindrome(newString)) {
returnare res.join('');
}
}
}
returnarea "nu este posibilă";
}
----------------Ajutoare---------------------------
fie newStr = str.split('').reverse().join('');
if (newStr === str) {
}
returnează fals;
}

PalindromeCreator(readline());
dacă (isPalindrome(str)) {
returnați "palindromul";
}
Creați combinații
fie combo-uri = [];
pentru (fie i = 0, max = Math.pow(2, str.length); i < max; i++) {
fie combo = i.toString(2);
Filtru pentru zero, unu sau doi 1s (1 reprezintă eliminarea)

fie count = 0;
pentru (fie j = 0; j < combo.length; j++) {
dacă (combo[j] === '1') {
număr++;
}
}
Prea mare, ignorați și treceți la următoarea încercare!
dacă (numărați > 2) {
continua;
}
Pad combo bun

în timp ce (combo.length < str.length) {
combo = '0' + combo;
}
combos.push(combo);
}
fie palindromeCombos = [];
Încercați combinațiile de eliminare

pentru (fie i = 0; i < combos.length; i++) {
fie tryString = '';
pentru (fie j = 0; j < combo-uri[i].length; j++) {
tryString += (combo-uri[i][j] === '1') ? '' : str[j];
}
dacă (tryString.length >= 3 &&; isPalindrome(tryString)) {

palindromeCombos.push(combo-uri[i]);
}
}
dacă (palindromeCombos.length === 0) {

}
Sortați astfel încât primele două litere găsite să fie returnate mai întâi pentru
când
Există mai multe valori
palindromeCombos.sort(function(a,b){
returnează parseInt(a,2) < parseInt(b,2);
});
Găsiți și returnați cea mai scurtă îndepărtare < = > mai lungă palindrom
fie shortestCount = null;
fie shortestCombo = '';
palindromeCombos.forEach(function(combo){
fie count = 0;
pentru (fie i = 0; i < combo.length; i++) {
dacă (combo[i] === '1') {
număr++;
}
}
if (shortestCount === null || count < shortestCount) {
shortestCount = număr;
shortestCombo = combo;
}
});
să rezulte = '';
dacă (cel mai scurtCombo[i] === '1') {
rezultat += str[i];
}
}
întoarcere (str === str.split('').reverse().join('')) ? adevărat : fals;
}

retur str === str.split('').reverse().join('');
}
dacă (isPalindrome(str)) returnați "palindrom";

Eliminarea unui caracter din poziția i
var newStr = str.slice(0, i).concat(str.slice(i + 1));
dacă (isPalindrome(newStr)) {
str[i] de întoarcere;
}
}

Eliminați două caractere din poziția I și J, unde (i < j)
pentru (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));
dacă (isPalindrome(newStr2)) {
retur str[i] + str[j];
}
}
}
}

Cifre romane de bază
Aveti functia BasicRomanNumerals(str) read str care va fi un sir de cifre romane. Cifrele
utilizate sunt: I pentru 1, V pentru 5, X pentru 10, L pentru 50, C pentru 100, D pentru 500 și M pentru
1000. În cifrele romane, pentru a crea un număr ca 11, pur și simplu adăugați un 1 după 10, astfel încât
să obțineți XI. Dar pentru a crea un număr ca 19, utilizați notația de scădere care este de a adăuga un I
înainte de un X sau V (sau adăugați un X înainte de un L sau C). Deci 19 în cifre romane este XIX.
Scopul programului dvs. este de a returna echivalentul zecimal al cifrei romane date. De exemplu: dacă
str este "XXIV" programul dvs. ar trebui să returneze 24
Exemple
Intrare: "IV"
Ieșire: 4
Intrare: "XLVI"
Ieșire: 46
funcția BasicRomanNumerals(str) {
fie letterObj = {
I: 1,
V: 5;
X: 10,
L: 50;
C: 100,
D: 500,
M: 1000
}
fie res = 0;
dacă (!letterObj[str[i + 1]] || letterObj[str[i]] >= letterObj[str[i +
1]]) {
res += letterObj[str[i]];
} altceva {
res += (letterObj[str[i + 1]] - letterObj[str[i]]);
I++;
}
}
retur res;
}

BasicRomanNumerals(readline());
/*
Simbol Eu V X L C D M
Valoare 1 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;
fie suma = 0;

fie simbol = str[i];
fie nextSymbol = (i+1 >= str.length) ? null : str[i+1];
comutator(simbol) {
cazul "I":
if (nextSymbol === 'V') {
suma += ROMAN_V - ROMAN_I;
I++;
} else if (nextSymbol === 'X') {
suma += ROMAN_X - ROMAN_I;
I++;
} altceva {
suma += ROMAN_I;
}
sparge;
cazul "V":
suma += ROMAN_V;
sparge;
cazul "X":
if (nextSymbol === 'L') {
suma += ROMAN_L - ROMAN_X;
I++;
} else if (nextSymbol === 'C') {
suma += ROMAN_C - ROMAN_X;
I++;
} altceva {
suma += ROMAN_X;
}
sparge;
cazul "L":
suma += ROMAN_L;
sparge;
cazul "C":
if (nextSymbol === 'D') {
suma += ROMAN_D - ROMAN_C;
I++;
} else if (nextSymbol === 'M') {
suma += ROMAN_M - ROMAN_C;
I++;
} altceva {
suma += ROMAN_C;
}
sparge;
cazul "D":
suma += ROMAN_D;
sparge;
cazul "M":
suma += ROMAN_M;
sparge;
Implicit:
Cărbune sau spațiu ilegal
sparge;
}
}
suma returnată;
}

zecimale var = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1];
var romani = ['M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV',
'I'];
ieșire var = 0;
pentru (var i = 0; i < romani.length; i++) {

Continuați să alergați în timp ce există un meci la început
în timp ce (str.indexOf(romani[i]) === 0) {
ieșire + = zecimale[i];
str = str.replace(romani[i], '');
}
}
returnarea producției;
}

Distribuția produselor alimentare
Funcția FoodDistribution (arr) citește matricea de numere stocate în arr care va reprezenta
nivelul de foame al diferitelor persoane variind de la 0 la 5 (0 însemnând că nu este foame deloc, 5
înseamnă foarte foame). Veți avea, de asemenea, N sandvișuri de oferit, care vor varia de la 1 la 20.
Formatul matricei va fi [N, h1, h2, h3, ...] unde N reprezintă numărul de sandvișuri pe care le aveți, iar
restul matricei va reprezenta nivelurile de foame ale diferitelor persoane. Scopul tău este să minimizezi
diferența de foame dintre fiecare pereche de persoane din matrice folosind sandvișurile pe care le ai la
dispoziție.
De exemplu: dacă arr este [5, 3, 1, 2, 1], înseamnă că aveți 5 sandvișuri de dat. Le puteți distribui în
următoarea ordine oamenilor: 2, 0, 1, 0. Oferind aceste sandvișuri oamenilor, nivelul lor de foame devine
acum: [1, 1, 1, 1]. Diferența dintre fiecare pereche de persoane este acum 0, totalul este, de asemenea, 0,
deci programul dvs. ar trebui să returneze 0. Notă: Este posibil să nu trebuiască să dați toate sau chiar
niciunul dintre sandvișurile dvs. pentru a produce o diferență minimă.
Un alt exemplu: dacă arr este [4, 5, 2, 3, 1, 0] atunci puteți distribui sandvișurile în următoarea ordine:
[3, 0, 1, 0, 0] ceea ce face ca toate nivelurile de foame să fie următoarele: [2, 2, 2, 1, 0]. Diferențele
dintre fiecare pereche de persoane sunt acum: 0, 0, 1, 1 și astfel programul dvs. ar trebui să returneze
diferența finală minimizată de 2.
Exemple
Intrare: [5, 2, 3, 4, 5]
Ieșire: 1
Intrare: [3, 2, 1, 0, 4, 1, 0]
Ieșire: 4
funcția FoodDistribution(arr) {
să trateze = arr.shift();
fie myArray = arr.slice(0);
fie arrMin = arr.sort((val1, val2) => val2 - val1).pop()
fie len = myArray.length;
Verificați dacă avem suficiente recompense pentru a aduce pe toată lumea la

cel mai bun nivel actual
let testCount = myArray.reduce((val1, val2) => {
returnează val1 + val2 - arrMin;
}, 0);
if (testCount <= tratează) {
returnare 0;
}
fie valQuantArr = obiectiv(myArray);
pentru (fie i = 1; i < 25; i++) {

let arrayLen = valQuantArr.length;
let resp = flattenMid(valQuantArr, tratează, i);
valQuantArr = resp[0];
arrayLen = valQuantArr.length;
tratează = resp[1];
în timp ce (valQuantArr[0].quant <= i &&; valQuantArr[0].value >
valQuantArr[1].value &&; tratează >= i) {
if (valQuantArr[0].quant <= tratează) {
valQuantArr[0].value--;
tratează -= valQuantArr[0].quant;
valQuantArr = obiectiv(valQuantArr);
}
}
în timp ce (valQuantArr[arrayLen - 1].quant <= i &&;

valQuantArr[arrayLen - 1].value > valQuantArr[arrayLen - 2].value &&; tratează >= i)
{
if (valQuantArr[arrayLen - 1].quant <= tratează) {
valQuantArr[arrayLen - 1].value--;
tratează -= valQuantArr[arrayLen - 1].quant;
valQuantArr = obiectiv(valQuantArr);
}
}
}
fie count = 0;
pentru (fie i = 0, len = valQuantArr.length; i < len - 1; i++) {
count += Math.abs(valQuantArr[i].value - valQuantArr[i + 1].value);
}
}
-----------------Ajutoare-----------------------
flattenMid = (arr, tratează, q) => {
fie index = 0;
în timp ce (tratează > 0 &&; index > -1) {
index = arr.findIndex((val, ind) => {
returnare val.quant <= q && ind >= 1 && ind < arr.length - 1 &&;
val.value > arr[ind - 1].value &&; val.value > arr[ind + 1].value;
});
dacă (indice >= 0) {
arr[index].value --;
tratează -= q;
}
}
returnează [obiectivează(arr), tratează];
}
transformă o matrice într-un obiect cu valoarea egală cu numărul, iar pictograma

quant fiind de câte ori apare la rând
obiectivare = (matrice) => {
dacă este matricea de numere
if (typeof array[0] === 'number') {
fie țintă = [];
contor fie = 0;
pentru (fie i = 0, len = array.length; i < len; i++) {
fie val = matrice[i];
contra++;
dacă (matrice[i] === matrice[i + 1]) {
continua;
} altceva {
target.push({
valoare: matrice[i],
Quant: contor
});
contor = 0;
}
}
ținta de returnare;
} altceva {
dacă este o matrice de obiecte, transformați-o într-o matrice de numere
și
Apoi rulați-l prin metoda obiectivării
fie targetArray = [];
array.forEach (val => {
în timp ce (val.quant) {
targetArray.push (valoare.val);
val.quant--;
}
});
return obiectivify(targetArray);
}
};

FoodDistribution(readline());
fie sandvișuri = parseInt(arr.shift());
Generați combo-uri, limitarea acestei metode, max 32 sandwich-uri

fie combo-uri = [];
pentru (fie i = 0, max = Math.pow(sandvișuri+1, arr.length); i < max; i++) {
let combo = i.toString(sandvișuri+1);
Suma cifrelor (sandvișuri) în combo

let comboSum = parseInt(combo.split('').reduce((acumulator, currentValue) =>
acumulator + parseInt(currentValue, sandwiches+1), 0));
Prea multe sandvișuri

dacă (comboSum > sandvișuri) {
continua;
}
De asemenea, puteți adăuga un cec aici pentru a elimina sandvișurile care ar

pune foamea < 0
Pad-uri combinate de combinații bune

în timp ce (combo.length < arr.length) {
}
if (comboSum <= sandvișuri) {

combos.push(combo);
}
}
Găsiți cea mai mică diferență de foame

fie lowestHungerDifference = null;
combos.forEach(function(combo){
let testArr = arr.slice();
testArr[i] -= combinație[i];
}
fie diff = getHungerDifference(testArr);
lowestHungerDifference = (cea mai micăHungerDifference === null || diff <
lowestHungerDifference) ? diff : cea mai micăHungerDifference;
});
returnează cel mai micHungerDifference;
funcția getHungerDifference(arr){
fie diff = 0;
diff += Math.abs(arr[i] - arr[i-1]);
}
retur diff;
}

var N = arr[0];
var foameNiveluri = arr.felie(1);
în timp ce (N > 0) {
var maxDiferență = 0;
Indicele care urmează să fie hrănit cu un sandwich
var mostNeeded = -1;
pentru (var i = 0; i < hungerLevels.length - 1; i++) {
diferența var = Math.abs(hungerLevels[i + 1] - hungerLevels[i]);
if (diferența > maxDifference) {
maxDiferență = diferență;
mostNeeded = (hungerLevels[i + 1] > hungerLevels[i]) ? (i + 1): i;
}
}
Acum știm cine are nevoie atât de mult de sandviș. dă-l mai departe
dacă (mostNeeded === -1) {
Diferențele adiacente sunt toate 0, așa că nu mai dați sandvișurile
returnare 0;
} altceva {
hungerLevels[mostNeeded] -= 1;
N--;
}
}
Calculați suma diferențelor adiacente

var sumOfDifferences = 0;
pentru (var i = 0; i < hungerLevels.length - 1; i++) {
sumOfDifferences += Math.abs(hungerLevels[i + 1] - hungerLevels[i]);
}
returnează sumOfDifferences;
}

Trei sume
Setați funcția ThreeSum(arr) să preia matricea de numere întregi stocate în arr și să determine dacă
oricare trei numere distincte (excluzând primul element) din matrice pot însuma până la primul element
din matrice. De exemplu: dacă arr este [8, 2, 1, 4, 10, 5, -1, -1] atunci există de fapt trei seturi de
triplete care însumează numărul 8: [2, 1, 5], [4, 5, -1] și [10, -1, -1]. Programul dvs. ar trebui să
returneze șirul true dacă 3 elemente distincte însumează primul element, altfel programul dvs. ar trebui
să returneze șirul false. Matricea de intrare va conține întotdeauna cel puțin 4 elemente.
Exemple
Intrare: [10, 2, 3, 1, 5, 3, 1, 4, -4, -3, -2]

Intrare: [12, 3, 1, -5, -4, 7]

Ieșire: false
funcția ThreeSum(arr) {
fie target = arr.shift();
pentru (fie i = 0; i < len - 2; i++) {
pentru (fie j = i + 1; j < len - 1; j++) {
pentru (fie k = i + 2; k < len; k++) {
dacă (arr[i] + arr[j] + arr[k] === țintă) {
întoarceți "adevărat";
}
}
}
}
Returnați "fals"
}

ThreeSum(readline());
fie answer = parseInt(arr.shift());

Generați combinații
fie combo-uri = [];
pentru (fie i = 0, max = Math.pow(2, arr.length); i < max; i++) {
fie digitsSum = parseInt(combo.split('').reduce((acumulator,valoare) =>

acumulator + parseInt(valoare), 0));
dacă (digitsSum !== 3) {

continua;
}
Cifre pad
în timp ce (combo.length < arr.length) {
}
combos.push(combo);
}
Combo-uri de testare
fie goodCombos = [];
fie suma = 0;
dacă (combo[i] === '1') {
suma += parseInt(arr[i]);
}
}
dacă (sumă === răspuns) {
goodCombos.push(combo);
}
});
retur (goodCombos.length > 0) ? adevărat : fals;

var sum = arr[0];
numere var = arr.slice(1);
pentru (var i = 0; i < numbers.length; i++) {

pentru (var j = i + 1; j < numbers.length; j++) {
pentru (var k = j + 1; k < numbers.length; k++) {
dacă (numere[i] + numere[j] + numere[k] === sumă) {
returnați "adevărat";
}
}
}
}
}

Calea corectă
Puneți funcția CorrectPath (str) să citească parametrul str trecut, care va reprezenta mișcările
efectuate într-o grilă de celule 5x5 începând din poziția din stânga sus. Caracterele din șirul de intrare
vor fi compuse în întregime din: r, l, u, d, ?. Fiecare dintre caractere reprezintă direcția de urmat în
cadrul grilei, de exemplu: r = dreapta, l = stânga, u = sus, d = jos. Scopul dvs. este să determinați ce
caractere ar trebui să fie semnele de întrebare pentru ca o cale care urmează să fie creată să meargă din
partea stângă sus a grilei până în dreapta jos, fără a atinge celulele parcurse anterior pe celulele din grilă.
De exemplu: dacă str este "r?d?drdd", atunci programul dvs. ar trebui să scoată șirul final corect care
va permite formarea unei căi din stânga sus a unei grile 5x5 în dreapta jos. Pentru această intrare,
programul ar trebui, prin urmare, să returneze șirul rrdrdrdd. Va exista o singură cale corectă și va
exista întotdeauna cel puțin un semn de întrebare în șirul de intrare.
Exemple
Intrare: "??? rrurdr?"

Ieșire: dddrrurdrd
Intrare: "drdr?? RRDDD?"

Rezultat: drdruurrdddd
funcția CorrectPath(str) {
Crearea unei matrice pentru a păstra pozițiile semnelor de întrebare
fie blankArray = [];
Puneți poziția semnelor de întrebare în matrice
str.split('').forEach((val, ind) => {
dacă (val === '?') {
blankArray.push(ind);
}
});
fie num = blankArray.length;
vom încerca fiecare posibilitate până când vom găsi una care funcționează,
Aceasta va fi 4^num permutări
fie total = Math.pow(4, num);
pentru (fie i = 0; i < total; i++) {

parcurgeți fiecare permutare, creând mai întâi un număr reprezentativ,
apoi făcând calea, apoi testând-o
fie numString = (i + total).toString(4).slice(1);
let currentPath = createPath(str, blankArray, numString);
dacă (isPathGood(currentPath)) {
returnare currentPath;
}
}
}
isPathGood = (str) => {

Creați matricea noastră goală
fie testArray = []
pentru (fie i = 0; i < 5; i++) {
testArray.push([0, 0, 0, 0, 0])
}

fie currentLoc = [0, 0];

Marcați piața noastră actuală ca vizitată
testArray[currentLoc[0]][currentLoc[1]] = 1;
Modificați poziția pe baza următoarei litere
fie newLoc = currentLoc.slice(0);
comutator (str[i]) {
Cazul "U":
newLoc[0]--;
sparge;
Cazul "D":
newLoc[0]++;
sparge;
Cazul "R":
newLoc[1]++;
sparge;
Cazul "L":
newLoc[1]--;
sparge;
}
renunțați dacă am ieșit de pe tablă
dacă [newLoc.includes (-1) || newLoc.includes (5)] {
returnează fals;
}
renunțați dacă ne aflăm într-un spațiu vizitat anterior
if (testArray[newLoc[0]][newLoc[1]] === 1) {
returnează fals;
}
Întoarceți-vă adevărat dacă suntem la pătratul țintă la ultima noastră
mișcare
if (newLoc[0] === 4 &&; newLoc[1] === 4 &&; i === len - 1) {
}
actualizați locația noastră pentru următoarea buclă;
currentLoc = newLoc;
}
returnează fals;
};
createPath = (str, spații goale, num) => {

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

CorrectPath(readline());
fie numQmarks = str.split('').reduce((a,v) => a + (v === '?' | 0), 0);
Generați combo-uri, 0-r, 1-d, 2-l, 3-u

fie combo-uri = [];
pentru (fie i = 0, max = Math.pow(4, numQmarks); i < max; i++) {
Pad
în timp ce (combo.length < numQmarks) {
}
combos.push(combo);
}
fie goodPaths = [];
Încercați trasee
fie comboArray = combo.split('');
fie tryPath = '';
if (str[i] === '?') {
fie direcție = comboArray.shift();
comutator (direcție) {
cazul "0": // drept
tryPath + = 'r';
sparge;
cazul "1": // jos
tryPath += 'd';
sparge;
cazul "2": // stânga
tryPath + = 'l';
sparge;
cazul "3": // sus
tryPath + = "u";
sparge;
Implicit:
Nu ar trebui să se întâmple niciodată
sparge;
}
} altceva {
tryPath += str[i];
}
}
dacă (pathGood(tryPath)) {
goodPaths.push(tryPath);
}
});
goodPaths conform specificațiilor ar trebui să fie doar === 1, dar acest cod
poate gestiona mai multe cazuri adevărate
returnați goodPaths[0];
Confirmare/Respingere cale bună (cu Qmarks completate)

funcția pathGood(path) {
fie startX = 0;
fie startY = 0;
fie grilă = [
[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]
]; Obiectivul 4,4
pentru (fie i = 0; i < path.length; i++) {

comutator (cale[i]) {
Cazul "R":
startX++;
sparge;
Cazul "D":
startY++;
sparge;
Cazul "L":
startX--;
sparge;
Cazul "U":
startY--;
sparge;
Implicit:
Nu ar trebui să se întâmple niciodată
sparge;
dacă (startX < 0 || startX > 4 || startY < 0 || startY > 4 ||

grilă[startY][startX] === 1) {
deja parcurse sau în afara limitelor
returnează fals;
}
grilă[startY][startX] = 1;
}
return (startX === 4 && startY === 4) ? adevărat : fals;
}
}

Verificați dacă indicațiile date pot ajunge la linia de sosire

fără a atinge pozițiile vizitate anterior
funcția canNavigate(str) {
poziția var = [0, 0];
var vizitat = {};
comutator(str[i]) {
Cazul "U":
poziție[0]--;
dacă (poziție[0] < 0) returnează false;
sparge;
Cazul "D":
poziție[0]++;
dacă (poziție[0] > 4) returnează false;
sparge;
Cazul "L":
poziție[1]--;
dacă (poziția[1] < 0) returnează false;
sparge;
Cazul "R":
poziție[1]++;
dacă (poziția[1] > 4) returnează false;
sparge;
Implicit:
sparge;
}
dacă (vizitat[poziție[0] + "-" + poziție[1]]) {
deja vizitat înainte
returnează fals;
} altceva {
Marcați ca vizitat
vizitat[poziție[0] + '-' + poziție[1]] = i;
}
}
întoarcere (poziție[0] === 4 &&; poziție[1] === 4);

}
funcția findingChars(str) {
În primul rând, generați toate cazurile posibile: înlocuirea ? cu indicații
permutări var = [''];
if (str[i] === '?') {
var newPermutations = [];
permutations.forEach(function(permutation) {
newPermutations.push(permutare + 'u');
newPermutations.push(permutare + 'd');
newPermutations.push(permutare + 'l');
newPermutations.push(permutare + 'r');
});
permutări = nouPermutări;
} altceva {
permutări = permutations.map(permutation => permutation + str[i]);
}
}
Acum filtrați numai cele valide

Avem nevoie de un rezultat net de 4 coborâșuri și 4 drepturi
return permutations.filter(function(permutation) {
var rightCount = permutation.match(/[r]/g) === null ? 0 :
permutare.potrivire(/[r]/g).lungime;
var leftCount = permutation.match(/[l]/g) === null ? 0 :
permutare.potrivire(/[l]/g).lungime;
var upCount = permutation.match(/[u]/g) === null ? 0 :
permutare.potrivire(/[u]/g).lungime;
var downCount = permutation.match(/[d]/g) === null ? 0 :
permutare.potrivire(/[d]/g).lungime;
return (rightCount - leftCount === 4) && (downCount - upCount === 4);

});
}
var validPaths = findMissingChars(str);
pentru (var validPath of validPaths) {

dacă (canNavigate(validPath)) {
returnați validPath;
}
}
}

Echilibrarea cântarului
Puneți funcția ScaleBalancing(strArr) să citească strArr care va conține două elemente, primul
fiind cele două ponderi întregi pozitive pe o scală de echilibru (partea stângă și partea dreaptă ) și al
doilea element fiind o listă a ponderilor disponibile ca numere întregi pozitive. Scopul tău este să
determini dacă poți echilibra cântarul folosind cea mai mică cantitate de greutăți din listă, dar folosind
cel mult doar 2 greutăți. De exemplu: dacă strArr este ["[5, 9]", "[1, 2, 6, 7]"] atunci aceasta înseamnă
că există o scală de echilibru cu o greutate de 5 pe partea stângă și 9 pe partea dreaptă. De fapt, este
posibil să echilibrați această scală adăugând un 6 în partea stângă din lista de greutăți și adăugând un 2
în partea dreaptă. Ambele scale vor fi acum egale cu 11 și sunt perfect echilibrate. Programul dvs. ar
trebui să returneze un șir separat prin virgulă al greutăților care au fost utilizate din listă în ordine
crescătoare, deci pentru acest exemplu programul dvs. ar trebui să returneze șirul 2,6
Va exista o singură soluție unică și lista greutăților disponibile nu va fi goală. De asemenea, este posibil
să adăugați două greutăți la o singură parte a cântarului pentru ao echilibra. Dacă nu este posibil să
echilibrați scara, atunci programul dvs. ar trebui să returneze șirul nu este posibil.
Exemple
Intrare: ["[3, 4]", "[1, 2, 7, 7]"]

Ieșire: 1
Intrare: ["[13, 4]", "[1, 2, 3, 6, 14]"]

Ieșire: 3,6
funcția ScaleBalancing(strArr) {
Conversia matricei în ceva mai funcțional
let newArr = strArr.map(val => {
return val.replace(/[\[\]]/g, """).split(',').map(val2 => {
returnează parseInt(val2, 10);
}).sort(((a, b) => {
returnează A - B;
});
});
fie diff = newArr[0][1] - newArr[0][0];

fie weights = newArr[1];
efectuați testul soluției cu o singură greutate

dacă (weights.includes(diff)) {
returnează diff.toString();
}
Faceți testul cu două greutăți, pe o parte
fie weight1 = weights.find((val, ind) => {
fie newWeights = weights.slice(0);
newWeights.splice(ind, 1);
return newWeights.includes (diff - val)
});
dacă (greutate1) {
returnează '${weight1},${diff - weight1}'
}
Faceți greutățile TWP, diferite părți, testați
weight1 = weights.find(val => {
greutăți dus-întors.include(diff + val);
});
dacă (greutate1) {
returnează '${weight1},${diff + weight1}'
}
dacă încă nu se returnează nimic...

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

parseInt(object));
fie weights = strArr[1].substr(1, strArr[1].length-2).split(', ').map(weight =>
parseInt(weight));
/*
Generați toate combinațiile posibile de greutăți ȘI permutări de stânga /
dreapta - 3^n timp
0 - Greutate neutilizată
1 - Greutate pe partea stângă
2 - Greutate pe partea dreaptă
*/
fie combo-uri = [];
pentru (fie i = 0, max = Math.pow(3, weights.length); i < max; i++) {
fie numWeights = combo.split('').reduce((a,v) => a + (parseInt(v) > 0 | 0),
0);
Prea multe greutăți, aruncați această combinație

dacă (numWeights > 2) {
continua;
}
Pad
în timp ce (combo.length < weights.length) {
}
combos.push(combo);
}
consolă.log(combo-uri);
Combo-uri de testare
fie goodCombos = [];
fie left = obiecte[0];
fie dreapta = obiecte[1];
if (combo[i] === '1') { // Stânga
stânga += greutăți[i];
}
if (combo[i] === '2') { // Dreapta
dreapta += greutăți[i];
}
}
dacă (stânga === dreapta) {

goodCombos.push(combo);
}
});
dacă (goodCombos.length === 0) {

}
Sortați mai întâi după numărul de greutăți fizice utilizate, apoi după greutatea
totală dacă există mai multe seturi
goodCombos.sort(function(a, b){
fie aCount = a.split('').reduce((ac,v) => ac + (parseInt(v) > 0 | 0), 0);
fie bCount = b.split('').reduce((ac,v) => ac + (parseInt(v) > 0 | 0), 0);
dacă (aCount < bCount) {

întoarcere -1;
}
dacă (aCount > bCount) {
returnarea 1;
}
aCount === bCount -> trebuie să verifice greutățile și să utilizeze o
greutate totală mai mică
fie aTotal = 0;
fie bTotal = 0;
pentru (fie i = 0; i < a.length; i++) {
dacă (a[i] !== '0') {
aTotal += greutăți[i];
}
dacă (b[i] !== '0') {
bTotal += greutăți[i];
}
}
returnează aTotal - bTotal;
});
consolă.log(goodCombos);
fie theCombo = goodCombos[0];

fie finalWeights = [];
theCombo.split('').map(function(value, index) {
dacă (valoare !== '0') {
finalWeights.push(weights[index]);
}
});
return finalWeights.sort((a,b) => a-b).join(',');
}

ponderi var = strArr[1].match(/\d+/g).map(Număr);
var weightsOnScale = strArr[0].match(/\d+/g).map(Număr);
var leftWeight = weightsOnScale[0];
var rightWeight = weightsOnScale[1];
Încercați o singură greutate

pentru (var i = 0; i < weights.length; i++) {
dacă (leftWeight < rightWeight) {
if (leftWeight + weights[i] === rightWeight)
greutăți de întoarcere[i];
} altceva {
if (leftWeight === rightWeight + weights[i])
greutăți de întoarcere[i];
}
}
Acum încercați două greutăți

pentru (var i = 0; i < weights.length; i++) {
pentru (var j = i + 1; j < weights.length; j++) {
Adăugați câte unul pe fiecare parte
if (leftWeight + weights[i] === rightWeight + weights[j]) {
greutăți de întoarcere[i] + ',' + greutăți[j];
} else if (leftWeight + weights[j] === rightWeight + weights[i]) {
}
Adăugați două pe partea mai deschisă
dacă (leftWeight < rightWeight) {
if (leftWeight + weights[i] + weights[j] === rightWeight) {
}
} altceva {
if (leftWeight === rightWeight + weights[i] + weights[j]) {
}
}
}
}
Nicio soluție
}

Trei numere
Puneți funcția ThreeNumbers (str) să ia parametrul str transmis și să determine dacă apar exact
trei numere întregi unice, cu o singură cifră, în fiecare cuvânt din șir. Numerele întregi pot apărea
oriunde în cuvânt, dar nu pot fi toate adiacente unul altuia. Dacă fiecare cuvânt conține exact 3 numere
întregi unice undeva în interiorul acestuia, atunci returnați șirul adevărat, altfel returnați șirul fals. De
exemplu: dacă str este "2hell6o3 wor6l7d2", atunci programul dvs. ar trebui să returneze "true", dar
dacă șirul este "hell268o w6or2l4d", atunci programul dvs. ar trebui să returneze "false", deoarece toate
numerele întregi sunt adiacente unul altuia în primul cuvânt.
Exemple
Intrare: "2a3b5 w1o2rl3d g1gg92"

Ieșire: adevărat
Intrare: "21aa3a ggg4g4g6ggg"

Ieșire: false
funcția ThreeNumbers(str) {
const DIGITS = '0123456789';
fie cuvinte = str.split(' ');
fie rezultat = nul;
words.forEach(function(word){
fie numere = 0;
fie treiAdiacent = fals;
let usedDigits = '';
pentru (fie i = 0; i < word.length; i++) {
Verificați dacă există cifre utilizate
dacă (usedDigits.includes(word[i])) {
folosit! eșua
rezultat = fals;
}
dacă (DIGITS.includes(word[i])) {
numere++;
usedDigits += cuvânt[i];
dacă (numere === 3) {
dacă (DIGITS.includes(word[i-1]) &&; DIGITS.includes(word[i-2]))
{
treiAdiacent = adevărat;
}
}
}
Verificați dacă există 3 cifre precedente adiacente
}
dacă (numere === 3 &&; !threeAdjacent) {

rezultat = (rezultat === nul) ? true : rezultat &&; adevărat;
} altceva {
rezultat = fals;
}
});
}

ThreeNumbers(readline());
var cuvinte = str.split(' ');
var numbersOfWords = words.map(word => word.match(/\d+/g));
pentru (var numere de numereOfWords) {

Verificați exact 3 numere în fiecare cuvânt
var digits = numbers.join('');
dacă (digits.length !== 3)
returnează fals;
Nu sunt permise 3 numere la rând
dacă (numbers.length !== numbers.filter(number => number.length < 3).length)
returnează fals;
Nu există număr duplicat în acele 3 numere
dacă ((cifre[0] === cifre[1]) ||
(cifre[1] === cifre[2]) ||
(cifre[2] === cifre[0]))
returnează fals;
}
}

fie array = str.split(' ');

pentru (fie i = 0; i < array.length; i++) {
if (/[0-9]{3,}/.exec(array[i]) !== null) {
returnează fals;
} altceva {
fie n = matrice[i].match(/[0-9]/g);
dacă (n[0] === n[1] || n[1] === n[2] || n[0] === n[1]) {
returnează fals;
}
}
}

Căutarea alfabetului
Puneți funcția AlphabetSearching(str) să ia parametrul str transmis și să returneze șirul true

dacă fiecare literă a alfabetului englez există în șir, altfel returnați șirul false. De exemplu: dacă str
este "zacxyjbbkfgtbhdaielqrm45pnsowtuv", atunci programul dvs. ar trebui să returneze șirul adevărat,
deoarece fiecare caracter din alfabet există în acest șir, chiar dacă unele caractere apar de mai multe ori.
Exemple
Intrare: "abcdefghijklmnopqrstuvwxyyyy"
Ieșire: false
Intrare: "abc123456kmo"
Ieșire: false
funcția AlphabetSearching(str) {
str = str.toLitere mici();
pentru (fie i = 97; i < 97 + 26; i++) {
fie char = String.fromCharCode(i);
dacă (!str.includes(char)) {
returnează fals;
}
}
}

AlphabetSearching(readline());
const LOWER_LETTERS = 'abcdefghijklmnopqrstuvwxyz';
pentru (fie i = 0; i < LOWER_LETTERS.length; i++) {

dacă (!str.includes(LOWER_LETTERS[i])) {
returnează fals;
}
}
}
funcția isAlpha(char) {
returnează /[A-Za-z]/.test(char);
}
var foundLetters = [];
dacă ( isAlpha(str[i]) && (foundLetters.indexOf(str[i]) === -1) ) {
foundLetters.push(str[i]);
}
}
returnare foundLetters.length === 26;
}

Diferența de fus orar
Puneți funcția TimeDifference (strArr) să citească matricea de șiruri stocate în strArr, care va fi
o listă nesortată de ori într-un format de douăsprezece ore, astfel: HH: MM (am / pm). Scopul tău este să
determini cea mai mică diferență în minute între două dintre timpurile din listă. De exemplu: dacă
strArr este ["2:10pm", "1:30pm", "10:30am", "4:42pm"], atunci programul dvs. ar trebui să returneze
40, deoarece cea mai mică diferență este între 1:30pm și 2:10pm cu o diferență de 40 de minute.
Matricea de intrare va conține întotdeauna cel puțin două elemente și toate elementele vor fi în formatul
corect și unic.
Exemple
Intrare: ["1:10pm", "4:40am", "5:00pm"]

Ieșire: 230
Intrare: ["10:00am", "11:45pm", "5:00am", "12:01am"]

Ieșire: 16
funcția TimeDifference(strArr) {
Vremurile ne vor ține diferențele de timp
fie ori = [];
fie newStrArr = strArr.map (val => {
fie meciuri = val.match(/^(\d+):(\d+)([ap]m)$/);
let hours = parseInt(meciuri[1], 10);
fie minute = parseInt(meciuri[2], 10);
fie jumătate = chibrituri[3];
dacă (jumătate === 'am' && ore === 12) {
ore = 0;
}
Dacă (jumătate === 'PM' && ore !== 12) {
ore += 12;
}
retur (ore * 60 + minute);
})
.sort((a, b) => { return a - b});
Complicat - al doilea exemplu arată că trebuie să luăm în considerare cea mai
timpurie oră atât în ziua 0, cât și în ziua 1
newStrArr.push(newStrArr[0] + 24 * 60);
pentru (fie i = 0, len = newStrArr.length; i < len - 1; i ++) {

times.push(newStrArr[i + 1] - newStrArr[i]);
}
returnați Math.min.apply(null, ori);
}

TimeDifference(readline());
fie timesInSeconds = [];

strArr.forEach(function(strTime){
let pair = strTime.split(':');
Fie ore = (pereche[1][2] === 'a') ? parseInt(pereche[0]) % 12 :
parseInt(pereche[0]) % 12 + 12;
fie secunde = parseInt(pair[1].substr(0,2));
fie totalSeconds = ore * 60 + secunde;
timesInSeconds.push(totalSeconds);
});
Iterează peste 2^n combinații

fie smallestDifference = Number.MAX_VALUE;
pentru (fie i = 0, max = Math.pow(2,timesInSeconds.length); i < max; i++) {
let timesUsed = combo.split('').reduce((a,v) => a + (v === '1' | 0), 0);
if (timesUsed === 2) {
Pad
în timp ce (combo.length < timesInSeconds.length) {
}
Iterează peste fiecare combinație specifică și testează-le

fie diff = 0;
fie pereche = [];
pentru (fie j = 0; j < combo.length; j++) {
dacă (combo[j] === '1') {
pair.push(timesInSeconds[j]);
}
}
fie t1 = Math.abs(pereche[0] - pereche[1]);

fie t2 = Math.abs(Math.min((1440 - pereche[0]), (pereche[0])) +
Math.min((1440 - pereche[1]), (pereche[1])));
diff = Math.min(t1, t2);
if (diff < smallestDifference) {

smallestDifference = dif;
}
}
}
returnează cel mai micDiferență;

}

let array = strArr.map(value => {
fie potriviri = value.match(/^(\d+):(\d+)([ap]m)$/);
fie h = parseInt(meciuri[1], 10);
fie m = parseInt(meciuri[2], 10);
if (potriviri[3] === 'am' &&; h === 12) {
h = 0;
} else if (meciuri[3] === 'pm' && h !== 12) {
h + = 12;
}
întoarcere (60 * h + m);
}).sort(funcție(a, b) {
returnează A - B;
});
array.push(matrice[0] + 24 * 60);
fie ori = [];
pentru (fie i = 0; i < array.length - 1; i++) {
times.push(matrice[i+1] - matrice[i]);
}
returnează Math.min(... ori);
}
Rând triunghi
Funcția TriangleRow(num) take num, care va fi un întreg pozitiv reprezentând un rând din
triunghiul lui Pascal. Triunghiul lui Pascal începe cu un [1] la rândul 0 al triunghiului. Atunci primul
rând este [1, 1], iar al doilea rând este [1, 2, 1]. Următorul rând începe cu 1 și se termină cu 1, iar
interiorul rândului este determinat prin adăugarea elementelor k-1 și kth din rândul anterior. Următorul
rând din triunghi ar fi atunci [1, 3, 3, 1] și așa mai departe. Intrarea va fi un număr întreg pozitiv și
obiectivul dvs. este să returnați suma acelui rând. De exemplu: dacă num este 4, atunci programul dvs. ar
trebui să returneze suma de 1 + 4 + 6 + 4 + 1, care este 16.
Exemple
Intrare: 1
Ieșire: 2
Intrare: 2
Ieșire: 4
funcția TriangleRow(num) {
returnează Math.pow(2, num);
}
consolă.log(TriangleRow(5));

TriangleRow(readline());
fie triunghi = [];

pentru (fie rând = 0; rând <= num; rând++) {
fie rowArr = [];
pentru (fie i = 0; i <= rând; i++) {
dacă (i === 0) {
rowArr.push(1);
continua;
}
Fie delta = (i < triunghi[rând-1].lungime) ? triunghi[rând-1][i] : 0;
rowArr.push(triunghi[rând-1][i-1] + delta);
}
triangle.push(rowArr);
}
triunghi de întoarcere[num].reduce((a,v) => a + v,0);
}
Obțineți al n-lea rând și coloana kth a triunghiului lui Pascal

funcția pascalTriunghi(n, k) {
dacă (n === 0) returnează 1;
dacă (k === 0 || k === n) returnează 1;
întoarcere pascalTriunghi(n - 1, k - 1) + pascalTriunghi(n - 1, k);
}
Răspunsul simplu - întotdeauna se rezumă la n^2
returnați num * num;
Calea cea grea

var rowSum = 0;
pentru (k = 0; k <= num; k++) {
rezultat = pascalTriunghi(num, k);
rowSum += rezultat;
}
întoarcere rândSumă;
}

Piața Vocalelor
Puneți funcția VowelSquare(strArr) să ia parametrul strArr transmis, care va fi o matrice 2D de o

dimensiune arbitrară umplută cu litere din alfabet și să determine dacă există un pătrat 2x2 compus în
întregime din vocale în matrice. De exemplu: strArr este ["abcd", "eikr", "oufj"] atunci această
matrice arată astfel:
a b c d
e i k r
o u f j
În cadrul acestei matrice există un pătrat 2x2 de vocale care încep în al doilea rând și prima coloană, și
anume, ei, ou. Dacă se găsește un pătrat de vocale 2x2, programul dvs. ar trebui să returneze poziția din
stânga sus (rând-coloană) a pătratului, deci pentru acest exemplu programul dvs. ar trebui să returneze 1-
0. Dacă nu există un pătrat de vocale 2x2, atunci returnați șirul care nu a fost găsit. Dacă există mai
multe pătrate de vocale, returnați-l pe cel care se află în poziția cea mai din stânga sus din întreaga
matrice. Matricea de intrare va avea cel puțin dimensiunea 2x2.
Exemple
Intrare: ["aqrst", "ukaei", "ffooo"]

Ieșire: 1-2
Intrare: ["gg", "ff"]

Ieșire: nu a fost găsit
funcția VowelSquare(strArr) {
strArr = strArr.map(val => {
return val.toLowerCase().replace(/[aeiou]/g, "!");
})
pentru (fie r = 0, len = strArr.length; r < len - 1; r++) {
pentru (fie c = 0, len = strArr[0].length; c < len - 1; c++) {
dacă (checkPoint(strArr, [r, c])) {
returnează '${r}-${c}';
}
}
}
returnare "nu a fost găsit"
funcția checkPoint(arr, point) {

consolă.log('arr', arr[punct[0]][punct[1]]);
consolă.log("punct", punct);
retur (
arr[punct[0]][punct[1]] === '!' &&
arr[punct[0] + 1][punct[1]] === '!" &&
arr[punct[0]][punct[1] + 1] === '!" &&
arr[punct[0] + 1][punct[1] + 1] === '!"
)
}

VowelSquare(readline());
pentru (fie rând = 0; rând < strArr.length-1; row++) {

pentru (fie col = 0; col < strArr[0].length-1; col++) {
if (isVowels2x2(strArr, row, col)) {
Bun! Întoarceți-vă primul pentru că noi
Căutați într-o ordine bună
rândul de întoarcere + "-" + col;
}
}
}
returnează mențiunea "nu a fost găsit";
funcția isVowels2x2(strArr, row, col) {

Ar putea face limite de verificare aici, dar se face în main()
dacă (!isVowel(strArr[row][col])) returnează false;

dacă (!isVowel(strArr[row+1][col])) returnează false;
dacă (!isVowel(strArr[row][col+1])) returnează false;
dacă (!isVowel(strArr[row+1][col+1])) returnează false;
}
funcția isVowel(letter) {
vocale const = 'aeiou';
returnarea vocalelor.includes(scrisoare);
}
}

Verificați dacă fiecare literă din matricea dată este o vocală

funcția allVowels(matrix) {
return matrix.every(row => row.every(letter => 'aeiou'.indexOf(letter) !== -1));
}
var matrix = strArr.map(row => row.split(''));
pentru (rândul var = 0; rândul < matrice.lungime - 1; rând++) {

pentru (coloana var = 0; coloana < matrice[0].lungime - 1; coloană++) {
Încercare cu ferestre glisante de submatrice 2x2
var subMatrix = matrix.slice(row, row + 2).map(rowArr =>
rowArr.slice(column, column + 2));
dacă (allVowels(subMatrix)) {
rândul de întoarcere + "-" + coloana;
}
}
}
returnează mențiunea "nu a fost găsit";

}

Cel mai apropiat inamic
Puneți funcția ClosestEnemy (arr) să ia matricea de numere stocate în arr și din poziția
din matrice unde este un 1, returnați numărul de spații fie la stânga, fie la dreapta trebuie să vă deplasați
pentru a ajunge la un inamic care este reprezentat de un 2. De exemplu: dacă arr este [0, 0, 1, 0, 0, 0, 2,
0, 2], atunci programul tău ar trebui să returneze 3, deoarece cel mai apropiat inamic (2) este la 3 spații
distanță de 1. Matricea va conține orice număr de 0 și 2, dar numai un singur 1. Este posibil să nu
conțină deloc 2, unde în acest caz programul dvs. ar trebui să returneze un 0.
Exemple
Intrare: [1, 0, 0, 0, 2, 2, 2]
Ieșire: 4
Intrare: [2, 0, 0, 0, 2, 2, 1, 0]
Ieșire: 1
funcția ClosestEnemy(arr) {
dacă (!arr.includes(2)) {
returnare 0;
}
loc1 = arr.findIndex(val => {
întoarcere val === 1;
});
pentru (fie i = 1, len = arr.length; i < len; i++) {

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

ClosestEnemy(readline());
fie erou = -1;

if (arr[i] === 1) { // Erou găsit
erou = i;
}
}
Căutare dreapta
fie deltaRight = nedefinit;
pentru (fie i = hero+1; i < arr.length; i++) {
if (arr[i] === 2) { // Inamic găsit
deltaRight = i - erou;
sparge;
}
}
Căutare stânga
fie deltaLeft = nedefinit;
pentru (fie i = erou-1; i >= 0; i--) {
if (arr[i] === 2) { // Inamic găsit
deltaLeft = erou - i;
sparge;
}
}
if (deltaLeft=== undefined &&; deltaRight === nedefinit) {
returnare 0;
}
if (deltaLeft === nedefinit) {

returnați deltaRight;
}
if (deltaRight === nedefinit) {

returnează deltaLeft;
}
return (deltaLeft < deltaRight) ? deltaStânga : deltaDreapta;

}

Indice de 1
var me = arr.indexOf(1);
var minimumDistance = arr.length;

dacă (arr[i] === 2) {
distanța var = Math.abs(i - me);
if (distance < minimumDistance) {
minimumDistance = distanță;
}
}
}
retur (minimDistanta === arr.length) ? 0 : minimDistanță;

}

Cel mai apropiat inamic II
Puneți funcția ClosestEnemyII (strArr) să citească matricea numerelor stocate în strArr care va
fi o matrice 2D care conține numai numerele întregi 1, 0 sau 2. Apoi, din poziția din matrice unde este
un 1, întoarceți numărul de spații fie la stânga, la dreapta, în jos sau în sus, trebuie să vă deplasați pentru
a ajunge la un inamic care este reprezentat de un 2. Sunteți capabili să înfășurați și o parte a matricei în
cealaltă. De exemplu: dacă strArr este ["0000", "1000", "0002", "0002"] atunci aceasta arată astfel:
000001000000200
0
2 Pentru această intrare, programul dvs. ar trebui să returneze 2,
deoarece cel mai apropiat inamic (2) este la 2
spații distanță de 1, deplasându-vă la stânga pentru a înfășura cealaltă parte și apoi deplasându-vă jos o
dată. Matricea va conține orice număr de 0 și 2, dar numai un singur 1. Este posibil să nu conțină deloc
2, unde în acest caz programul dvs. ar trebui să returneze un 0.
Exemple
Intrare: ["000", "100", "200"]

Ieșire: 1
Intrare: ["0000", "2010", "0000", "2002"]

Ieșire: 2
funcția ClosestEnemyII(strArr) {
Pasul unu - returnați 0 dacă nu există 2 în matrice
fie twosies = strArr.filter(val => {
returnare val.include("2");
});
dacă (!twosies.length) {
returnare 0;
}
pasul doi - obțineți coordonatele 1 (targetX, targetY)
targetY = strArr.findIndex(val => {
returnare val.include('1');
});
targetX = strArr[targetY].search(/1/);
Pasul trei Găsiți cea mai mică cale către un 2
fie res = strArr.length * strArr[0].length;
pentru (fie rând = 0, len = strArr[0].length; rând < len; rând++) {

pentru (col = 0, înălțime = strArr.length; col < înălțime; col++) {
if (strArr[row][col] === '2') {
xShift = rowDist(targetX, col, len);
yShift = rowDist(targetY, rând, înălțime);
res = Math.min(res, xShift + yShift);
}
}
}
retur res;
--------------------Ajutoare----------------------
În ciuda numelui, utilizați pentru distanța coloană și rând
funcția rowDist(y, x, len) {
returnează Math.min(Math.abs(x - y), Math.abs(y - x + len));
}

ClosestEnemyII(readline());
Găsiți eroul
fie heroy = -1;
fie heroX = -1;
let result = strArr[i].indexOf(1);
dacă (rezultat > -1) {
heroX = rezultat;
erou = i;
}
}
dacă (heroY === -1) {

Nu există niciun erou
întoarcere -1;
}
consolă.log(erou + '-' + heroX);
Verificați dacă există dușmani

să lase dușmanii = [];
let result = strArr[i].indexOf(2);
dacă (rezultat > -1) {
enemies.push([i,rezultat]);
}
}
dacă (enemies.length === 0) {

returnare 0;
}
consolă.log(inamici);
fie closestDistance = Număr.MAX_SAFE_INTEGER;
Verificați distanțele inamice

pentru (fie i = 0; i < enemies.length; i++) {
fie inamicX = dușmani[i][1];
fie dușmanY = dușmani[i][0];
fie deltaX = Math.abs(enemyX - heroX);

fie deltaY = Math.abs(enemyY - heroY);
consolă.log(deltaY + '-' + deltaX);
Acum verificați valorile de înfășurare
deltaX este maxim, deoarece dacă este mai mult, atunci nu ne pasă
fie wrapDeltaX = Număr.MAX_SAFE_ÎNTREG;
pentru (fie i = 0; i < deltaX; i++) {
dacă ((enemyX + i) % strArr[0].length === heroX) {
Găsit eroul Delta
wrapDeltaX = i;
consolă.log('înfășurareX: ' + i)
}
}
fie wrapDeltaY = Număr.MAX_SAFE_ÎNTREG;

pentru (fie i = 0; i < deltaY; i++) {
dacă ((enemyY + i) % strArr.length === heroY) {
Găsit eroul Delta
wrapDeltaY = i;
consolă.log('înfășurareY: ' + i)
}
}
deltaX = (wrapDeltaX < deltaX) ? wrapDeltaX : deltaX;

deltaY = (wrapDeltaY < deltaY) ? wrapDeltaY : deltaY;
fie distance = deltaX + deltaY;
if (distance < closestDistance) {

closestDistance = distanță;
}
}
întoarcere aproapeDistanță;

Găsiți distanța dintre două elemente cu indici dați [rând, coloană]

funcția getDistance(matrixSize, indici1, indici2) {
var rowDistance = Math.min(Math.abs(indici2[0] - indici1[0]), Math.abs(indici1[0]
- (indici2[0] - matrixSize)));
var columnDistance = Math.min(Math.abs(indici2[1] - indici1[1]),
Math.abs(indici1[1] - (indici2[1] - matrixSize)));
întoarcere rândDistanță + coloanăDistanță;
}
matrice var = strArr.map(line => line.split('').map(Număr));
var minDistanță = matrice.lungime * 2;
Poziția mea: 1
var meIndici;
Locațiile inamicilor: 2
var enemiesIndici = [];
Identificați locațiile 1 și 2
pentru (rândul var = 0; rândul < matricea.length; rândul++) {
pentru (coloana var = 0; coloana < matrice[0].length; column++) {
dacă (matrice[rând][coloană] === 1) {
meIndici = [rând, coloană];
} else if (matrice[rând][coloană] === 2) {
enemiesIndices.push([rând, coloană]);
}
}
}
Verificați distanța de la mine pentru fiecare inamic

pentru (var enemyIndices of enemiesIndices) {
var distance = getDistance(matrix.length, meIndices, enemyIndices);
if (distanta < minDistant) {
minDistanță = distanță;
}
}
se ocupă de cazul în care nu există inamic

întoarcere minDistanță === matrice.lungime * 2 ? 0 : minDistanță;
}

Flux de numere
Puneți funcția NumberStream(str) să ia parametrul str care va conține numerele de la 2 la 9 și să

determine dacă există un flux consecutiv de cifre de cel puțin N lungime unde N este valoarea reală a
cifrei. Dacă da, returnați șirul true, altfel returnați șirul false. De exemplu: dacă str este
"6539923335", atunci programul dvs. ar trebui să returneze șirul adevărat, deoarece există un flux
consecutiv de 3 de lungime 3. Șirul de intrare va conține întotdeauna cel puțin o cifră.
Exemple
Intrare: "5556293383563665"
Ieșire: false
Intrare: "5788888888882339999"
Ieșire: adevărat
funcția NumberStream(str) {
pentru (fie i = 2; i < 10; i++) {
fie iChar = i.toString();
fie ac = iChar.repeat(i);
if (str.indexOf(ac) !== -1) {
}
}
Codul merge aici
returnează fals;

NumberStream(readline());
pentru (fie i = 0, lastDigit = -1, count = 0; i < str.length; i++) {

if (str[i] === lastDigit) {
Fluxul a continuat
număr++;
if (count >= Number(lastDigit)) {
}
} altceva {
Flux nou
lastDigit = str[i];
număr = 1;
}
}
returnează fals;
}
Generați mai întâi modele
modele var = [];
pentru (var i = 1; i < 10; i++) {
patterns.push(String(i).repeat(i));
}
pentru (modelul var al modelelor) {

if (str.indexOf(pattern) !== -1) {
model găsit
}
}
returnează fals;
}

Cele mai mari patru
Puneți funcția LargestFour(arr) să ia matricea de numere întregi stocate în arr și să găsească cele
mai mari patru elemente și să returneze suma lor. De exemplu: dacă arr este [4, 5, -2, 3, 1, 2, 6, 6],
atunci cele mai mari patru elemente din această matrice sunt 6, 6, 4 și 5, iar suma totală a acestor numere
este 21, deci programul dvs. ar trebui să returneze 21. Dacă există mai puțin de patru numere în matrice,
programul ar trebui să returneze suma tuturor numerelor din matrice.
Exemple
Intrare: [1, 1, 1, -5]

Ieșire: -2
Intrare: [0, 0, 2, 3, 7, 1]
Ieșire: 13
funcția LargestFour(arr) {
fie newArr = arr.sort((val1, val2) => {
returnează val2 - val1;
})
.splice(0, 4);
return newArr.reduce((val1, val2) => {
returnează val1 + val2;
}, 0);
}
LargestFour(linie de citire());
returnează arr.sort((a,b) => b-a).reduce((a,v,i) => a + ((i < 4) ? v: 0), 0);

returnează arr.sort((a, b) => a < b).slice(0, 4).reduce((sumă, v) => sumă + v,
0);
}

Caractere distincte
Solicitați funcției DistinctCharacters(str) să ia parametrul str transmis și să determine dacă

conține cel puțin 10 caractere distincte, dacă da, atunci programul dvs. ar trebui să returneze șirul
adevărat, altfel ar trebui să returneze șirul fals. De exemplu: dacă str este "abc123kkmmmm?" atunci
programul dvs. ar trebui să returneze șirul fals, deoarece acest șir conține doar 9 caractere distincte: a, b,
c, 1, 2, 3, k, m, ? se adaugă până la 9.
Exemple
Intrare: "12334bbmma: = 6 "

Ieșire: adevărat
Intrare: "eeeemmmmmmmmm1000"
Ieșire: false
funcția DistinctCharacters(str) {
let mySet = set nou(str.split(''));
returnare mySet.size >= 10 ? adevărat : fals
}

DistinctCharacters(readline());
fie charCodes = [];
dacă (!charCodes.includes(str.charCodeAt(i))) {
charCodes.push(str.charCodeAt(i));
}
}
return (charCodes.length >= 10) ? adevărat : fals;

distincții var = {};

distincții[str[i]] = '';
}
returnează Object.keys(distincts).length >= 10;

}

Semne de întrebare
Solicitați funcției QuestionsMarks (str) să ia parametrul șir str, care va conține numere cu o
singură cifră, litere și semne de întrebare și să verifice dacă există exact 3 semne de întrebare între
fiecare pereche de două numere care însumează până la 10. Dacă da, atunci programul dvs. ar trebui să
returneze șirul adevărat, altfel ar trebui să returneze șirul fals. Dacă nu există două numere care
însumează până la 10 în șir, atunci programul dvs. ar trebui să returneze și fals.
De exemplu: dacă str este "arrb6??? 4xxbl5??? eee5" atunci programul dvs. ar trebui să revină
adevărat, deoarece există exact 3 semne de întrebare între 6 și 4 și 3 semne de întrebare între 5 și 5 la
sfârșitul șirului.
Exemple
Intrare: "aa6?9"
Ieșire: false
Intrare: "acc?7?? SSS?3rr1?????? 5 "

Ieșire: adevărat
funcția QuestionsMarks(str) {
fie numPlaces = [];
prezumția de fals, până când steagul devine adevărat
fie steag = fals;
Obțineți o matrice de locuri în numere întregi care conțin șiruri

pentru (fie i = 0, len = str.length; i < len; i++) {
dacă (/\d/.test(str[i])) {
numPlaces.push(i);
}
}
fie numCount = numPlaces.length;
pentru (fie i = 0; i < numCount - 1; i++) {

if (parseInt(str[numPlaces[i]], 10) + parseInt(str[numPlaces[i + 1]],
10) === 10) {
steag = adevărat;
fie strSeg = str.slice(numPlaces[i], numPlaces[i + 1]);
strSeg = strSeg.replace(/[^\?] /g, '');

dacă (strSeg !== '??? ') {
returnează fals;
}
}
}
steagul de întoarcere;
}

Semne de întrebare(readline());
Carcasă de cămilă
Puneți funcția CamelCase (str) să ia parametrul str transmis și să-l returneze în formatul corect al
cazului de cămilă în care prima literă a fiecărui cuvânt este scrisă cu majusculă (cu excepția primei
litere). Șirul va conține doar litere și o combinație de caractere de punctuație delimitatoare care separă
fiecare cuvânt.
De exemplu: dacă str este "BOB iubește-codificarea", atunci programul dvs. ar trebui să returneze șirul
bobLovesCoding.
Exemple
Intrare: "pisici ȘI * câini-sunt minunate"

Ieșire: pisicișicâiniAreAwesome
Intrare: "a b c d-e-f%g"

Ieșire: aBCDEFG
funcția CamelCase(str) {
fie strArr = str.split(/[â-zA-Z]/);
strArr = strArr.map((val, ind) => {
val = val.toLitere mici();
dacă (ind) {
valArr = val.split('');
valArr[0] = valArr[0].toMajuscule();
returnează valArr.join('');
}
returnarea val;
})
return strArr.join('');
}

CamelCase(readline());
Conversia ASCII
Funcția ASCIIConversion(str) preia parametrul str transmis și returnează un nou șir în care
fiecare caracter, în afară de caracterul spațiu, este înlocuit cu codul de caractere zecimal corespunzător.
De exemplu: dacă str este "câine", atunci programul dvs. ar trebui să returneze șirul 100111103
deoarece d = 100, o = 111, g = 103.
Exemple
Intrare: "salut lume"

Ieșire: 104101108108111 119111114108100
Intrare: "abc **"

Ieșire: 979899 4242
funcția ASCIIConversion(str) {
fie myArr = str.split(' ').map(val => {
returnează val.split('').map(val2 => {
returnează val2.charCodeAt(0);
}).join('')
}).join(' ');
returnează myArr;
}

ASCIIConversion(readline());
Simplu Evens
Solicitați funcției SimpleEvens(num) să verifice dacă fiecare număr din parametrul trecut este par.
Dacă da, returnați șirul true, altfel returnați șirul false. De exemplu: dacă num este 4602225 programul
dvs. ar trebui să returneze șirul fals, deoarece 5 nu este un număr par.
Exemple
Intrare: 2222220222
Ieșire: adevărat
Intrare: 20864646452
Ieșire: false
funcția SimpleEvens(num) {
return num.toString(10).search(/[13579]/) === -1 ? "true": "false";
}
SimpleEvens(readline());
Cazul șarpelui
Puneți funcția SnakeCase (str) să ia parametrul str transmis și să-l returneze în formatul corect al
cazului șarpelui, unde fiecare cuvânt este scris cu litere mici și separat de cuvintele adiacente printr-o
subliniere. Șirul va conține doar litere și o combinație de caractere de punctuație delimitatoare care
separă fiecare cuvânt.
De exemplu: dacă str este "BOB iubește-codificarea", atunci programul dvs. ar trebui să returneze șirul
bob_loves_coding.
Exemple
Intrare: "pisici ȘI * câini-sunt minunate"

Ieșire: cats_and_dogs_are_awesome
Intrare: "a b c d-e-f%g"

Ieșire: a_b_c_d_e_f_g
funcția SnakeCase(str) {
return str.split(/[â-zA-Z]/).map(val => {return
val.toLowerCase()}).join('_');
}
SnakeCase(readline());
Găsiți intersecția
Funcția FindIntersection(strArr) citește matricea de șiruri stocate în strArr care va conține

2 elemente: primul element va reprezenta o listă de numere separate prin virgulă sortate în ordine
crescătoare, al doilea element va reprezenta o a doua listă de numere separate prin virgulă (de asemenea
sortate). Scopul dvs. este să returnați un șir separat prin virgulă care conține numerele care apar în
elementele strArr în ordine sortată. Dacă nu există nicio intersecție, returnați șirul false.
De exemplu: dacă strArr conține ["1, 3, 4, 7, 13", "1, 2, 4, 13, 15"] ieșirea ar trebui să returneze
"1,4,13", deoarece acele numere apar în ambele șiruri. Matricea dată nu va fi goală și fiecare șir din
interiorul matricei va fi format din numere sortate în ordine crescătoare și poate conține numere
negative.
Exemple
Intrare: ["1, 3, 4, 7, 13", "1, 2, 4, 13, 15"]

Ieșire: 1,4,13
Intrare: ["1, 3, 9, 10, 17, 18", "1, 4, 9, 10"]

Ieșire: 1,9,10
funcția FindIntersection(input) {
const [firstList, secondList] = input.map( s => s.split(", ") );
const resultMap = {};

rezultat const = [];
pentru ( const numărul firstList ) {

resultMap[ number ] = true;
}
pentru ( const numărul celei de-a doua liste ) {

if ( resultMap[number] ) {
result.push( număr );
}
}
returnare rezultat.lungime ? result.join(",") : fals;

}

consolă.log(FindIntersection(readline()));
Multiplicator de sumă
Puneți funcția SumMultiplier(arr) să ia matricea de numere stocate în arr și să returneze șirul

true dacă oricare două numere pot fi înmulțite, astfel încât răspunsul să fie mai mare decât dublul sumei
tuturor elementelor din matrice. Dacă nu, returnați șirul false. De exemplu: dacă arr este [2, 5, 6, -6,
16, 2, 3, 6, 5, 3], atunci suma tuturor acestor elemente este 42 și dublarea este 84. Există două elemente
în matrice, 16 * 6 = 96 și 96 este mai mare decât 84, deci programul dvs. ar trebui să returneze șirul
adevărat.
Exemple
Intrare: [2, 2, 2, 2, 4, 1]
Ieșire: false
Intrare: [1, 1, 2, 10, 3, 1, 12]

funcția SumMultiplier(arr) {
const țintă = arr.reduce((val1, val2) => val1 + val2, 0) * 2;
arr.sort((num1, num2) => num1 - num2);
const len = arr.length;
const checker = Math.max((arr[0] * arr[1]), (arr[len - 2] * arr[len - 1]));
verificatorul de retur > țintă;
}
SumMultiplier(readline());
Îmbinare șiruri
Solicitați funcției StringMerge(str) să citească parametrul str transmis, care va conține un șir mare
de caractere alfanumerice cu un singur caracter asterisc, împărțind șirul uniform în două șiruri separate.
Scopul dvs. este să returnați un șir nou prin împerecherea caracterelor în locațiile corespunzătoare din
ambele șiruri. De exemplu: dacă str este "abc1*kyoo" atunci programul dvs. ar trebui să returneze șirul
akbyco1o, deoarece o pereche cu k, b perechi cu y etc. Șirul se va împărți întotdeauna uniform cu
asteriscul din centru.
Exemple
Intrare: "aaa * bbb"

Ieșire: ababab
Intrare: "123hg * aaabb"

Ieșire: 1a2a3ahbgb
funcția StringMerge(str) {
const cleanString = str.replace(/[^\w*]/g, '');
const len = (cleanString.length - 1) / 2;
fie newString = '';
const arr = str.split('*');

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

StringMerge(readline());
Unul Decremented
Puneți funcția OneDecremented(str) să numere de câte ori apare o cifră care este exact cu una mai
mică decât cifra anterioară. De exemplu: dacă str este "5655984", atunci programul dvs. ar trebui să
returneze 2, deoarece 5 apare direct după 6 și 8 apare direct după 9. Intrarea va conține întotdeauna cel
puțin 1 cifră.
Exemple
Intrare: "56"
Ieșire: 0
Intrare: "9876541110"
Ieșire: 6
funcția OneDecremented(num) {
contor fie = 0;
fie arr = num.toString().split('');
if (parseInt(val, 10) - parseInt(arr[ind + 1], 10) === 1) {
contra++;
}
})
contor de retur;
}

OneDecremented(readline());
Fuziunea elementelor
Puneți funcția ElementMerger(arr) să ia matricea de numere întregi pozitive stocate în arr și să

efectueze următorul algoritm: obțineți continuu diferența numerelor întregi adiacente pentru a crea o
nouă matrice de numere întregi, apoi faceți același lucru pentru noua matrice până când rămâne un
singur număr și returnați acel număr. De exemplu: dacă arr este [4, 5, 1, 2, 7], atunci luarea diferenței
fiecărei perechi de elemente produce următoarea matrice nouă: [1, 4, 1, 5]. Apoi faceți același lucru
pentru ca această nouă matrice să producă [3, 3, 4] -> [0, 1] -> 1. Deci, pentru acest exemplu, programul
dvs. ar trebui să returneze numărul 1, deoarece asta este ceea ce rămâne la sfârșit.
Exemple
Intrare: [5, 7, 16, 1, 2]

Ieșire: 7
Intrare: [1, 1, 1, 2]
Ieșire: 1
funcția ElementMerger(arr) {
dacă (arr.length === 1) {
aranjament de returnare[0];
} altceva {
newArr = [];
dacă (ind < arr.length - 1) {
newArr.push(Math.abs(val - arr[ind + 1]));
}
})
returnează ElementMerger(newArr);
}
}
ElementMerger(readline());
GCF
Funcția GCF(arr) ia matricea de numere stocate în arr care va conține întotdeauna doar două numere
întregi pozitive și returnează cel mai mare factor comun al acestora. De exemplu: dacă arr este [45,
12], atunci programul dvs. ar trebui să returneze 3. Vor exista întotdeauna două elemente în matrice și
vor fi numere întregi pozitive.
Exemple
Intrare: [1, 6]
Ieșire: 1
Intrare: [12, 28]

Ieșire: 4
funcția GCF(arr) {
fie res = nul;
fie max = Math.max(... arr);
fie min = Math.min(... arr);
pentru (fie i = 1; i <= min; i++) {
dacă (% maxim i === 0 && min % i === 0) {
res = i;
}
}
retur res;
}

GCF(linie de citire());
Număr de serie
Solicitați funcției SerialNumber(str) să preia parametrul str transmis și să determine dacă este un
număr de serie valid cu următoarele constrângeri:
1. Trebuie să conțină trei seturi, fiecare cu trei cifre (de la 1 la 9) separate printr-o perioadă.
2. Primul set de cifre trebuie să însumeze un număr par.
3. Al doilea set de cifre trebuie să însumeze un număr impar.
4. Ultima cifră din fiecare set trebuie să fie mai mare decât cele două cifre anterioare din același set.
Dacă toate restricțiile de mai sus sunt îndeplinite în șir, programul ar trebui să returneze șirul adevărat,
altfel programul ar trebui să returneze șirul fals. De exemplu: dacă str este "224.315.218", atunci
programul dvs. ar trebui să returneze "adevărat".
Exemple
Intrare: "11.124.667"
Ieșire: false
Intrare: "114.568.112"
Ieșire: adevărat
funcția SerialNumber(str) {
Verificați formatul șirului
Fie gol = /^\d{3}\.\d{3}\.\d{3}$/
dacă (!goal.test(str)) {
}
Transformați șirul în trei matrice de câte trei cifre fiecare

fie arr = str.split(/\./).map(val => {
returnează val.split('').map(val2 => {
returnează parseInt(val2, 10);
});
});
Verificați condiția unu

dacă ((arr[0][0] + arr[0][1] + arr[0][2]) % 2) {
}
Verificați condiția a doua

dacă (!( (arr[1][0] + arr[1][1] + arr[1][2]) % 2)) {
}
Verificați condiția a treia

pentru (fie i = 0, len = arr.length; i < len; i++) {
dacă (Math.max(... arr[i]) !== arr[i][2]) {
}
}
Dacă toate condițiile trec fără un fals, atunci întoarceți-vă adevărat
}
SerialNumber(readline());
Perioade de șir
Puneți funcția StringPeriods(str) să ia parametrul str transmis și să determine dacă există un

subșir K care poate fi repetat de N > 1 ori pentru a produce șirul de intrare exact așa cum apare.
Programul dvs. ar trebui să returneze cel mai lung subșir K, iar dacă nu există niciunul, ar trebui să
returneze șirul -1.
De exemplu: dacă str este "abcababcababcab", atunci programul dvs. ar trebui să returneze abcab,
deoarece acesta este cel mai lung subșir care se repetă de 3 ori pentru a crea șirul final. Un alt exemplu:
dacă str este "ababababababab", atunci programul dvs. ar trebui să returneze abababab, deoarece este
cel mai lung subșir. Dacă șirul de intrare conține un singur caracter, programul ar trebui să returneze
șirul -1.
Exemple
Intrare: "abcxabc"
Ieșire: -1
Intrare: "affedaaffed"
Ieșire: -1
funcția StringPeriods(str) {
Vom folosi doar lungimi de subșiruri care se împart uniform în str
const len = str.lungime;
const pivot = Math.max(Math.trunc(Math.sqrt(len)), len);
pentru (fie i = 2; i <= pivot; i++) {
dacă (len % i === 0) {
bloc const = str.slice(0, len / i);
dacă (block.repeat(i) === str) {
bloc de retur;
}
}
}
întoarcere -1;
}

StringPeriods(readline());
Palindrome Swapper
Puneți funcția PalindromeSwapper(str) să ia parametrul str transmis și să determine dacă un

palindrom poate fi creat prin schimbarea a două caractere adiacente din șir. Dacă este posibil să creați un
palindrom, atunci programul dvs. ar trebui să returneze palindromul, dacă nu, atunci returnați șirul -1.
Șirul de intrare va conține numai caractere alfabetice. De exemplu: dacă str este "rcaecar", atunci
puteți crea un palindrom schimbând al doilea și al treilea caracter, astfel încât programul dvs. ar trebui să
returneze șirul de curse care este șirul final palindromic.
Exemple
Intrare: "anna"
Ieșire: anna
Intrare: "kyaak"
Ieșire: caiac
funcția PalindromeSwapper(str) {
fie inputArray = str.split('');
fie strLen = inputArray.length;
let palTester = function(arr) {
dacă (arr[i] !== arr[len - (1 + i)]) {
returnează fals;
}
}
}
pentru (fie i = 0; i < strLen - 1; i++) {
fie newArray = Array.from(inputArray);
newArray.splice(i, 2, newArray[i + 1], newArray[i]);
if (palTester(newArray)) {
return newArray.join('');
}
}
întoarcere -1;
}

PalindromeSwapper(linie de citire());
Eliminarea parantezelor
Solicitați funcției RemoveBrackets(str) să ia parametrul str string trecut, care va conține numai
caracterele "(" și ")", și să determine numărul minim de paranteze care trebuie eliminate pentru a crea
un șir de paranteze potrivite corect. De exemplu: dacă str este "(())))", atunci programul dvs. ar trebui
să returneze numărul 1. Răspunsul ar putea fi 0 și va exista întotdeauna cel puțin un set de paranteze
potrivite în șir.
Exemple
Intrare: "(())()(("
Ieșire: 3
Intrare: "(()("
Ieșire: 2
funcția RemoveBrackets(str) {
să arunce = 0;
contor fie = 0;
fie arr = str.split('');

Un bun exemplu de utilizare a pre++ și pre-- spre deosebire de post++ și post--
contor = arr[i] === '(' ? ++contor : --contor;
dacă (contor < 0) {
aruncări++;
contor = 0;
}
}
aruncări += contor;
aruncări de întoarcere;
}

RemoveBrackets(readline());
Linie de comandă
Puneți funcția CommandLine(str) să preia parametrul str care reprezintă parametrii dați unei
comenzi într-un sistem PDP vechi. Parametrii sunt jetoane alfanumerice (fără spații) urmate de un semn
egal și de valoarea lor corespunzătoare. Mai multe perechi de parametri/valori pot fi plasate pe linia de
comandă cu un singur spațiu între fiecare pereche. Simbolurile și valorile parametrilor nu pot conține
semne egale, dar valorile pot conține spații. Scopul funcției este de a izola parametrii și valorile pentru a
returna o listă de lungimi ale parametrilor și valorilor. Acesta trebuie să furnizeze rezultatul său în
același format și în aceeași ordine, înlocuind fiecare intrare (jetoane și valori) cu lungimea
corespunzătoare.
De exemplu, dacă str este: "SampleNumber = 3234 provider = Dr. M. Welby patient = John Smith
priority = High", atunci funcția dvs. ar trebui să returneze șirul "12 = 4 8 = 12 7 = 10 8 = 4", deoarece
"SampleNumber" este un simbol de 12 caractere cu o valoare de 4 caractere ("3234") urmată de
"furnizor", care este un simbol de 8 caractere urmat de o valoare de 12 caractere ("Dr. M. Welby"), etc.
Exemple
Intrare: "litere = A B Z T numere = 1 2 26 20 combine = true"

Ieșire: 7 = 7 7 = 9 7 = 4
Intrare: "a = 3 b = 4 a = 23 b = a 4 23 c = "

Ieșire: 1 = 1 1 = 1 1 = 2 1 = 6 1 = 0
funcția CommandLine(str) {
fie splitter = /\s(?=\w+=)/
fie wordArr = str.split(splitter);
wordArr = wordArr.map(pereche => {

fie pairArr = pair.split('=');
pairArr = pairArr.map(word => {
returnează word.length.toString();
});
return pairArr.join('=');
});
return wordArr.join(' ');

}

Linie de comandă(linie de citire());
Evaluare pe stele
Solicitați funcției StarRating(str) să ia parametrul str care va fi o evaluare medie între

0.00 și 5.00 și să convertească această evaluare într-o listă de 5 nume de imagini care vor fi afișate într-o
interfață cu utilizatorul pentru a reprezenta evaluarea ca o listă de stele și jumătăți de stele. Evaluările
trebuie rotunjite până la cea mai apropiată jumătate. Există 3 nume de fișiere imagine disponibile:
"plin.jpg", "jumătate.jpg", "gol.jpg". Rezultatul va fi numele celor 5 imagini (fără extensie), de la stânga
la dreapta, separate prin spații. De exemplu: dacă str este "2.36", atunci aceasta ar trebui să fie afișată
de următoarea imagine:
Deci, programul dvs. ar trebui să returneze șirul "plin, plin, jumătate gol, gol".
Exemple
Intrare: "0,38"
Ieșire: jumătate gol gol gol
Intrare: "4.5"
Ieșire: plină plină jumătate completă
funcția StarRating(str) {
fie num = (Math.round(parseFloat(str) * 2)) / 2;
fie starString = '';
fie jumătate = ! (Math.trunc(num) === num);
starString = starString + ' full'.repeat(num);

dacă (jumătate) {
starString += ' jumătate';
}
return (starString + ' empty'.repeat(5 - num)).trim();
}

StarRating(readline());

Rezolvarea Problemelor-1

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Rezolvarea Problemelor-1

Încărcat de

Drepturi de autor:

Formate disponibile

Primul revers

Intrare: "I Love Code"

var arr = str.split('');

Păstrați această funcție sunați aici

fie newString = '';

Păstrați această funcție sunați aici

Păstrați această funcție sunați aici

Puneți funcția FirstFactorial(num) să ia parametrul num trecut și să returneze factorialul

pentru (fie i = 1; i <= num; i++) {

Păstrați această funcție sunați aici

Codul merge aici

Păstrați această funcție sunați aici

Păstrați această funcție sunați aici

Cel mai lung cuvânt

Intrare: "distracție&!! timp"

Intrare: "Îmi plac câinii"

var arr = sen.split(' ');

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

Codul merge aici

Păstrați această funcție sunați aici

pentru (fie i = 0, lungime = 0, cuvânt = ''; i < sen.length; i++) {

dacă (lungime > maxLength) {

întoarceți cel mai lungCuvânt;

Păstrați această funcție sunați aici

Păstrați această funcție sunați aici

Solicitați funcției LetterChanges (str) să ia parametrul str transmis și să îl modifice folosind

str = str.trim().toLitere mici();

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

Păstrați această funcție sunați aici

let validCharacters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

fie newString = '';

vocale fie = 'aeiou';

fie finalString = '';

Păstrați această funcție sunați aici

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

Păstrați această funcție sunați aici

Intrare: 140 Ieșire: 9870

Păstrați această funcție sunați aici

Păstrați această funcție sunați aici

Codul merge aici

Păstrați această funcție sunați aici

Puneți funcția LetterCapitalize(str) să preia parametrul str transmis și să scrie cu majusculă

Intrare: "salut lume"

Intrare: "Am alergat acolo"

wordarr = str.split(" ");

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

Păstrați această funcție sunați aici

fie newString = '';

newWord = (str[i] === ' ') ? adevărat : fals;

Păstrați această funcție sunați aici

Codul merge aici

Păstrați această funcție sunați aici

Puneți funcția SimpleSymbols(str) să ia parametrul str transmis și să determine dacă este o

Păstrați această funcție sunați aici

dacă (str === '') {

let result = str.split('').every(letterEval);

Rezultatul returnării ? "true": "false";

funcția letterEval(letter, index) {

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

Păstrați această funcție sunați aici

Codul merge aici

Păstrați această funcție sunați aici

Intrare: 3 & num2 = 122