Rezolvarea Problemelor-2

Mediana mobilă
Cea mai bine cotată soluție pentru utilizatori

Mediana mobilă
Puneți funcția MovingMedian(arr) să citească matricea de numere stocate în arr care va conține o dimensiune a ferestrei glisante, N, ca prim element din matrice, iar restul va fi o
listă de numere. Programul dvs. ar trebui să returneze mediana mobilă pentru fiecare element pe baza elementului și a predecesorilor săi N-1, unde N este dimensiunea ferestrei
glisante. Rezultatul final trebuie să fie un șir cu mediana mobilă corespunzătoare fiecărei intrări din matricea originală separată prin virgule.
Rețineți că pentru primele câteva elemente (până la atingerea dimensiunii ferestrei), mediana este calculată pe un număr mai mic de intrări. De exemplu: dacă arr este [3, 1, 3, 5, 10,
6, 4, 3, 1], atunci programul dvs. ar trebui să emită "1,2,3,5,6,6,4,3"
Exemple
Intrare: [5, 2, 4, 6]
Ieșire: 2,3,4
Intrare: [3, 0, 0, -2, 0, 2, 0, -2]

Ieșire: 0,0,0,0,0,0,0
funcția MovingMedian(arr) {
fie buildArr = [];
fie winLength = arr.shift();
fie len = arr.length;
pentru (fie i = 0; i < len; i++) {

fie firstIndex = Math.max(0, i - winLength + 1);
fie med = getMedian(arr.slice(firstIndex, i + 1));
buildArr.push(med);
}
return buildArr.join(',');
}
fie getMedian = (arr) => {

arr.sort((val1, val2) => {return val1 - val2});
dacă (lentilă % 2) {
aranjament return[Math.floor(len/2)];
} altceva {
întoarcere (arr[len/2 - 1] + arr[len/2]) / 2;
}
}
Păstrați această funcție sunați aici

În mișcareMedian(readline());
Totaluri grup
Se citește funcția GroupTotals(strArr) în parametrul strArr care conține perechi cheie:valoare, unde cheia este un șir și valoarea este un întreg. Programul ar trebui să returneze
un șir cu perechi noi cheie:valori separate printr-o virgulă, astfel încât fiecare cheie să apară o singură dată cu valorile totale însumate.
De exemplu: dacă strArr este ["B:-1", "A:1", "B:3", "A:5"] atunci programul dvs. ar trebui să returneze șirul A:6,B:2.
Șirul final de ieșire ar trebui să returneze tastele în ordine alfabetică. Excludeți cheile care au valoarea 0 după ce au fost însumate.
Exemple
Intrare: ["X:-1", "Y:1", "X:-4", "B:3", "X:5"]
Ieșire: B:3,Y:1
Intrare: ["Z:0", "A:-1"]

Ieșire: A:-1
funcția GroupTotals(strArr) {
fie resObject = {};
fie parsingRegExp = /(\w+):(-?\d+)/;
strArr.forEach(val => {
const chibrituri = val.match(parsingRegExp);
const cheie = potriviri[1];
const numVal = Număr(potriviri[2]);
if (resObject[key] || resObject[key] === 0) {

resObject[key] = resObject[key] += numVal;
} altceva {
resObject[cheie] = numVal;
}
});
returnează Object.keys(resObject)
.sort()
.map(val => {
returnare resObject[val] ? (val + ":" + resObject[val]) : '';
})
.filter(val => {
returnarea val;
})
.join(',');
}

GroupTotals(readline());
Modificări ale șirurilor
Solicitați funcției StringChanges(str) să ia parametrul str trecut, care va fi un șir care conține litere din alfabet și să returneze un șir nou bazat pe următoarele reguli. Ori de câte
ori se întâlnește o majusculă M, duplicați caracterul anterior (apoi eliminați M) și ori de câte ori se întâlnește un N mare, eliminați următorul caracter din șir (apoi eliminați N). Toate
celelalte caractere din șir vor fi litere mici. De exemplu: "abcNdgM" ar trebui să returneze "abcgg". Șirul final nu va fi niciodată gol.
Exemple
Intrare: "MrtyNNgMM"
Ieșire: rtyggg
Intrare: "oMoMkkNrrN"
Ieșire: ooookkr
funcția StringChanges(str) {
const strArray = str.split('');
let len = strArray.length;

dacă (strArray[i] === 'M') {
dacă (!i) {
strArray.shift();
lentilă -= 1;
i -= 1;
} altceva {
strArray.splice(i, 1, strArray[i - 1]);
}
} else if (strArray[i] === 'N') {
Dacă (i === Len - 1) {
strArray.pop();
} altceva {
strArray.splice(i, 2);
lentilă -= 2;
i -= 2;
}
}
}
return strArray.join('');
}

StringChanges(readline());
FizzBuzz
Puneți funcția FizzBuzz(num) să ia parametrul num trecut și să returneze toate numerele de la 1 la num separate prin spații, dar înlocuiți fiecare număr care este divizibil cu 3 cu
cuvântul "Fizz", înlocuiți fiecare număr care este divizibil cu 5 cu cuvântul "Buzz", și fiecare număr care este divizibil atât cu 3, cât și cu 5 cu cuvântul "FizzBuzz". De exemplu: dacă
num este 16, atunci programul dvs. ar trebui să returneze șirul "1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16". Intrarea va fi în intervalul 1 - 50.
Exemple
Intrare: 3
Ieșire: 1 2 Fizz
Intrare: 8 Ieșire: 1 2 Fizz 4 Buzz Fizz 7 8
funcția FizzBuzz(num) {
const returnArray = [];
pentru (fie i = 1; i <= num; i++) {
dacă (!( i % 15)) {
returnArray.push('FizzBuzz');
} altceva dacă (!( i % 5)) {
returnArray.push('Buzz');
} altceva dacă (!( i % 3)) {
returnArray.push('Fizz');
} altceva {
returnArray.push(i);
}
}
returnArray.join(' ');
}

FizzBuzz(linie de citire());
Distanța H
Funcția HDistance(strArr) preia matricea de șiruri stocate în strArr, care va conține doar două șiruri de lungime egală și va returna numărul de caractere din fiecare poziție care
sunt diferite între ele. De exemplu: dacă strArr este ["house", "hours"] atunci programul dvs. ar trebui să returneze 2. Ș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: ["abcdef", "defabc"]

Ieșire: 6
funcția HDistance(strArr) {
const string1 = strArr[0];

const string2 = strArr[1];
const len = șir1,lungime;
fie count = 0;

dacă (șir1[i] !== șir2[i]) {
număr += 1;
}
}
numărul de returnări;
}

HDistance(linie de citire());
Cazuri diferite
Puneți funcția DifferentCases (str) să ia parametrul str transmis și să îl returneze în format majuscule de cămilă în care prima literă a fiecărui cuvânt este scrisă cu majusculă.
Ș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 "Daniel LikeS-coding", atunci programul dvs. ar trebui să returneze șirul DanielLikesCoding.
Exemple
Intrare: "pisici ȘI * câini-sunt minunate"
Ieșire: CatsAndDogsAreAwesome
Intrare: "a b c d-e-f%g"

Ieșire: ABCDEFG
funcția DifferentCases(str) {
const charTest = /[a-zA-Z]/;
let returnString = '';
const len = str.lungime;
const baseString = str.toLowerCase();

dacă (i === len - 1 && !charTest.test(baseString[i])) {
returnare returnString;
}
dacă (i === 0 && charTest.test(baseString[i])) {
returnString += baseString[i].toUpperCase();
continua;
}
dacă (baseString[i - 1] && charTest.test(baseString[i])) {
dacă (!charTest.test(baseString[i - 1])) {
returnString += baseString[i].toUpperCase();
} altceva {
returnString += baseString[i];
}
}
}
returnare returnString;
}

DifferentCases(readline());
Apăsări de taste echivalente
Puneți funcția EquivalentKeypresses (strArr) să citească matricea de șiruri stocate în strArr care va conține 2 șiruri reprezentând două liste separate prin virgulă de apăsări
de taste. Scopul dvs. este să returnați șirul adevărat dacă apăsările de taste produc același șir imprimabil și șirul fals dacă nu. O apăsare de tastă poate fi fie un caracter imprimabil, fie
un backspace reprezentat de -B. Puteți produce un șir imprimabil dintr-un astfel de șir de apăsări de taste solicitând backspace-urilor să șteargă un caracter precedent.
De exemplu: dacă strArr conține ["a,b,c,d", "a,b,c,c,-B,d"] rezultatul ar trebui să returneze true, deoarece acele apăsări de taste produc același șir imprimabil. Matricea dată nu va fi
goală. Apăsările de taste vor conține doar litere din alfabet și backspace.
Exemple
Intrare: ["a,b,c,d", "a,b,c,d,-B,d"]
Ieșire: adevărată
Intrare: ["c,a,r,d", "c,a,-B,r,d"]

Ieșire: falsă
funcția EquivalentKeypresses(strArr) {
funcția reduce(str) {
să rezulte = "";
str = str.split(",");
str.forEach(funcție (articol, index) {
dacă (str[index + 1] !== "-B" &&; str[index] !== "-B") {
rezultat += element;
}
})
rezultatul returnării;
}
Codul merge aici
return reduce(strArr[0]) == reduce(strArr[1]);

consolă.log(EquivalentKeypresses(readline()));
Oră de maximă audiență
Puneți funcția PrimeTime(num) să preia parametrul num transmis și să returneze șirul true dacă parametrul este un număr prim, altfel returnați șirul false. Intervalul va fi cuprins
între 1 și 2^16.
Exemple
Intrare: 19
Ieșire: adevărat
Intrare: 110
Ieșire: false
funcția PrimeTime(num) {
balama var = Math.floor(Math.sqrt(num));
var i = 2;
testul var = adevărat;
hardcode răspunsuri corecte pentru 1 și 2

dacă (num === 1) {
returnează fals
}
altfel dacă (num === 2) {
Întoarceți-vă adevărat
}
Rulați o buclă pentru a vedea dacă numărul are factori integrali (în afară de 1)
altfel {
în timp ce (i <= balama &&; test === adevărat) {
dacă (num % i !== 0) {
I++;
}
altfel {
test = fals;
}
}
Test de retur
}
}

pentru a vedea cum să introduceți argumente în JavaScript, derulați în jos
PrimeTime(linie de citire());
Lungime rulare
Puneți funcția RunLength(str) să preia parametrul str transmis și să returneze o versiune comprimată a șirului folosind algoritmul de codificare Run-length. Acest algoritm
funcționează luând apariția fiecărui caracter repetitiv și scoțând acel număr împreună cu un singur caracter al secvenței repetitive. De exemplu: "wwwggopp" ar returna 3w2g1o2p.
Șirul nu va conține numere, semne de punctuație sau simboluri.
Exemple
Intrare: "aabbcde"
Ieșire: 2a2b1c1d1e
Intrare: "wwwbbbw"
Ieșire: 3w3b1w
funcția RunLength(str) {
strarr = str.split("");
resarr = []; un loc în care să-mi pun rezultatele pe măsură ce sunt determinate;
arrlen = strarr.length;
număr = 1;
pentru (var i = 0; i <strarr.length; i++) {
if (strarr[i] == strarr[i+1]) {
numărați ++;
}
altfel {
intrare var = număr + strarr[i];
resarr.push(număr + strarr[i]);
număr = 1;
}
}
return resarr.join("");

RunLength(readline());
Motor principal
Funcția PrimeMover(num) returnează alnum-lea număr prim. Intervalul va fi de la 1 la 10^4. De exemplu: dacă num este 16, ieșirea ar trebui să fie 53, deoarece 53 este al 16-lea
număr prim.
Exemple
Intrare: 9
Ieșire: 23
Intrare: 100
Ieșire: 541
funcția PrimeMover(num) {
contor var = 0;
var testNum = 0;
în timp ce (counter < num) {

dacă (primeTest(testNum + 1)) {
contra++;
}
testNum++;
}
test de întoarcereNum
funcția primeTest(int) {
dacă (int === 1) {
returnează fals
}
altfel dacă (int === 2) {
}
altfel {
var i = 2;
var pivot = Math.ceil(Math.sqrt(int));
în timp ce (i <= pivot) {
dacă (int % i === 0) {
returnează fals
}
I++;
}
}
}
}

PrimeMover(linie de citire());
Palindromul doi
Puneți funcția PalindromeTwo(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. Parametrul introdus poate avea semne de punctuație și simboluri, dar acestea nu ar trebui să afecteze dacă șirul este de fapt un palindrom. De exemplu: "Anne,
votez mai multe mașini care concurează Roma-Viena" ar trebui să se adeverească.
Exemple
Intrare: "Noel - vede Leon"
Ieșire: adevărat
Intrare: "Un război la Tarawa!"

Rezultat: adevărat
funcția PalindromeTwo(str) {
var str = str.toLitere mici();
var strlen = str.lungime;
var arr = str.split("")
var newarr = [];
var x;
pentru (var i = 0; i < strlen; i++) {
dacă (arr[i].charCodeAt(0) > 96 &&; arr[i].charCodeAt(0)< 123) {
newarr.push(arr[i]);
}
}
pentru (var j = 0; j < newarr.length; j++) {

dacă (newarr[j] != newarr[newarr.length - j - 1]) {
x = fals;
sparge;
}
altfel {
x = adevărat;
}
}
returnează x;
}

PalindromeTwo(readline());
Divizie
Puneți funcția Division (num1,num2) să ia ambii parametri trecuți și să returneze cel mai mare factor comun. Adică, returnați cel mai mare număr care intră uniform în ambele
numere fără rest. De exemplu: 12 și 16 ambele sunt divizibile cu 1, 2 și 4, deci ieșirea ar trebui să fie 4. Intervalul pentru ambii parametri va fi de la 1 la 10^3.
Exemple
Intrare: 7 & num2 = 3
Ieșire: 1

Ieșire: 18
funcția Diviziune(num1,num2) {
var bignum = matematică.max(num1, num2);
var smallnum = Math.min(num1, num2);
pentru (var i = 1; i <= smallnum; i++) {

dacă (bignum%i == 0 && smallnum%i == 0) {
maxi var = i;
}
}
întoarcere maxi;

Diviziune(linie de citire());
String Scramble
Puneți funcția StringScramble(str1,str2) să ia ambii parametri trecuți și să returneze șirul true dacă o porțiune de caractere str1 poate fi rearanjată pentru a se potrivi cu
str2, altfel returnați șirul false. De exemplu: dacă str1 este "rkqodlw" și str2 este "world", ieșirea ar trebui să returneze true. Punctuația și simbolurile nu vor fi introduse cu
parametrii.
Exemple
Intrare: "cdore" & str2= "coder"
Ieșire: adevărat
Intrare: "h3llko" & str2 = "hello"

Ieșire: false
funcția StringScramble(str1,str2) {
Mai întâi, bateți corzile cu litere mici și puneți-le în matrice pentru manipulare
arr1 = str1.toLowerCase().split("");
arr2 = str2.toLowerCase().split("");
Apoi, sortați matricele în ordine alfabetică

arr1.sort();
arr2.sort();
Treceți în buclă prin ARR2, verificând dacă fiecare literă este în ARR1, apoi
eliminați-o din
arr2 și it și toate scrisorile anterioare de la arr1.
var j = 0;
în timp ce (j < arr1.length) {
dacă (arr2[0] == arr1[j]) {
arr2.schimb();
arr1.splice(0,j+1);
j = 0;
}
altfel {
J++;
}
}
dacă (arr2 == "") {

întoarcere adevărată;
}
altfel{
returnează fals;
}

StringScramble(readline());
Arith Geo II
Puneți funcția ArithGeoII(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 ArithGeoII(arr) {
var len = arondisment;
Stabilirea relației dintre două elemente matrice consecutive
var mathConstant = arr[1] - arr[0];
var geoConstant = arr[1] / arr[0];
Testați matricea pentru a vedea dacă diferența dintre elemente este aceeași între
fiecare pereche de elemente consecutive. Dacă vreuna dintre perechi nu reușește,
setați semnalizarea la true și quit
pentru (var i = 0; i < len - 1; i++) {
dacă (arr[i + 1] - arr[i] !== mathConstant) {
var mathTest = adevărat;
sparge;
}
}
dacă bucla de mai sus a mers până la capăt, atunci răspundeți la "Aritmetică".
Dacă nu, atunci treceți în buclă prin matricea testând fiecare pereche. Dacă vreuna
dintre perechi nu reușește, returnați -1, deoarece nu a reușit ambele teste. Dacă
reușește până la capăt, returnați "Geometric".
dacă (!mathTest) {
returnați "aritmetica";
}
altfel {
pentru (var j = 0; j < len - 1; j++) {
dacă (arr[j + 1] / arr[j] !== geoConstant) {
întoarcere -1;
}
}
returnați "Geometric";
}
}

ArithGeoII(readline());
Adăugare matrice
Setați funcția ArrayAddition(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 returnează ș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 ArrayAddition(arr) {
ținta VAR;
var addArr = arrayPrep(arr);
var len = addArr.length;
var permNum = Math.pow(2, len);
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ă) {
}
}
returnează fals
funcția arrayPrep(arr2) {
arr.sort(function(a, b){
returnează a - b
});
țintă = arr2.pop()
Returnare arr2
}
}

ArrayAddition(readline());
Convertor binar
Au funcția BinaryConverter(str) returna forma zecimală a valorii binare. De exemplu: dacă 101 este trecut returnarea 5 sau dacă 1000 este trecut returnarea 8.
Exemple
Intrare: "100101"
Ieșire: 37
Intrare: "011"
Ieșire: 3
funcția BinaryConverter(str) {
contor var = 0;
var numleng = str.lungime;
pentru (var i = numleng-1; i >= 0; i--) {

var j = numleng-1-i;
var digt = parseInt(str.charAt(i));
var addit = digt * Math.pow(2, j);
contor = contor + aditiv;
}
contor de retur;

BinaryConverter(readline());
Număr de litere
Puneți funcția LetterCount(str) să preia parametrul str transmis și să returneze 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 LetterCount(str) {
str = str.replace(/[^a-zA-zs]/g, "");

str = str.toLitere mici();
var wordarr = str.split(" ");
var totescore = {};

pentru (var i = 0; i < wordarr.length; i++) { //pentru fiecare cuvânt din șir
scor var = [];
pentru (var j = 0; j < wordarr[i].length; j++) { //pentru fiecare literă din
cuvânt
numărul var = 0;
var x = wordarr[i].charAt(j);
pentru (var k = 0; k < wordarr[i].length; k++) {
dacă (wordarr[i][k] === x) {
număr++;
}
}
scorearr.push(număr);
}
scorearr.sort(function(a, b) {return (b-a)});
totescore[wordarr[i]] = scorearr[0];
var newarr = [];
}
pentru (var cnt in totescore) {
newarr.push([CNT, TOTESCORE[CNT]]);
newarr.sort(function(a, b) {return b[1] - a[1]});
}
dacă (newarr[0][1] === 1) {
întoarcere -1;
}
altfel {
returnează newarr[0][0];
}

LetterCount(readline());
Cifrul lui Cezar
Puneți funcția CaesarCipher(str,num) să ia parametrul str și să efectueze o deplasare a cifrului Cezar pe el folosind parametrul num ca număr de deplasare. Un cifru Cezar
funcționează prin deplasarea fiecărei litere din șirul N plasat în jos în alfabet (în acest caz N va fi num). Punctuația, spațiile și scrierea cu majuscule trebuie să rămână intacte. De
exemplu, dacă șirul este "Cifru Cezar" și num este 2, ieșirea ar trebui să fie "Ecguct Ekrjgt".
Exemple
Intrare: "Bună ziua" & num = 4
Ieșire: Lipps
Intrare: "abc" & num = 0

Ieșire: abc
funcția CaesarCipher(str,num) {
var arr = str.split("");
pentru (var i = 0; i < str.length; i++) {
var x = arr[i].charCodeAt(0);
dacă (x > 64 &&; x < 91) {

x = x - 65;
x = x + num;
x = x%26;
x = x + 65;
arr[i] = String.fromCharCode(x);
}
altfel, dacă (x > 96 &&; x < 123) {
x = x - 97;
x = x + num;
x = x%26;
x = x + 97;
arr[i] = String.fromCharCode(x);
}
altfel {
}
var y = arr.join("");
returnarea y;
}
Cezar Cifru (linie de citire());
Mod simplu
Setați funcția SimpleMode (arr) să preia matricea de numere stocate în arr și să returneze numărul care apare cel mai frecvent (modul). De exemplu: dacă arr conține
[10, 4, 5, 2, 4] ieșirea ar trebui să fie 4. Dacă există mai multe moduri, returnați-l pe cel care a apărut mai întâi în matrice ( adică.[5, 10, 10, 6, 5] ar trebui să returneze 5 pentru că a
apărut primul). Dacă nu există niciun mod, returnați -1. Matricea nu va fi goală.
Exemple
Intrare: [5,5,2,2,1]
Ieșire: 5
Intrare: [3,4,1,6,10]
Ieșire: -1
funcția SimpleMode(arr) {
len = arr.length;
var newobj = {};
var testarr = [];
pentru (var i = len-1; i >= 0; i--) {
număr = 0;
pentru (var j = 0; j < len; j++) {
dacă (arr[j] === arr[i]) {
număr++;
}
}
newobj[arr[i]] = număr;
}
pentru (x în newobj) {
testarr.push([x, newobj[x]]);
}
testarr.sort(function(a, b) {return b[1] - a[1]});
dacă (testarr[0][1] === 1) {

retur -1
}
altfel {
test de întoarcere[0][0];
}

SimpleMode(readline());
Consecutiv
Puneți funcția Consecutive(arr) să ia matricea de numere întregi stocate în arr și să returneze numărul minim de numere întregi necesare pentru a face conținutul arr consecutiv
de la cel mai mic număr la cel mai mare număr. De exemplu: Dacă arr conține [4, 8, 6], atunci ieșirea ar trebui să fie 2, deoarece două numere trebuie adăugate la matrice (5 și 7)
pentru a face o matrice consecutivă de numere de la 4 la 8. Numerele negative pot fi introduse ca parametri și nicio matrice nu va avea mai puțin de 2 elemente.
Exemple
Intrare: [5,10,15]
Ieșire: 8
Intrare: [-2,10,4]
Ieșire: 10
funcția Consecutive(arr) {
const onceArray = Array.from(set nou(arr))
.sort((val1, val2) => val1 - val2);
const finalIndex = onceArray.length - 1;
return onceArray[finalIndex] - onceArray[0] - (onceArray.length - 1);
}

Consecutiv(linie de citire());
Diviziune formatată
Puneți funcția FormattedDivision(num1,num2) să ia ambii parametri trecuți, să împartă num1 la num2 și să returneze rezultatul ca un șir cu virgule formatate corect și 4
cifre semnificative după zecimală. De exemplu: dacă num1 este 123456789 și num2 este 10000, ieșirea ar trebui să fie "12.345,6789". Ieșirea trebuie să conțină un număr în locul
unuia, chiar dacă este zero.
Exemple
Ieșire: 0.6667
Intrare: 10 & num2 = 10 Ieșire: 1.0000
funcția FormattedDivision(num1,num2) {
Acest lucru face cea mai mare parte a problemei într-un singur pas simplu!
var divisionResult = (num1 / num2).toFixed(4);
Împărțiți șirul într-o matrice cu două elemente: întreg, zecimal
var numParts = divisionResult.split('.');
var intArray = numParts[0].split('');
var len = intArray.length;
var intString;
pentru (var i = len; i > 0; i--) {

Dacă (i < (len) &&; (len - i + 1) % 3 === 1) {
intArray.splice(i, 0, ',');
intString = intArray.join('');
}
altfel {
intString = (intString)? intString : intArray.join('');
}
}
return intString.concat('.', numParts[1]);
}

FormattedDivision(readline());
Numărarea minutelor
Puneți funcția CountingMinutes(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
funcția CountingMinutes(str) {
tester const = /(\d+):(\d+)([pa]m)-(\d+):(\d+)([pa]m)/;
const timeArray = str.match(tester);
const time1 = timeArray[3] === 'am'
? (parseInt(timeArray[1], 10) * 60) + parseInt(timeArray[2], 10)
: (parseInt(timeArray[1], 10) * 60) + parseInt(timeArray[2], 10) + 720;
const time2 = timeArray[6] === 'am'
? (parseInt(timeArray[4], 10) * 60) + parseInt(timeArray[5], 10)
: (parseInt(timeArray[4], 10) * 60) + parseInt(timeArray[5], 10) + 720;
retur ((time2 - time1) + 1440) % 1440;
}

CountingMinutes(readline());
Pasul de permutare
Setați funcția PermutationStep(num) să ia parametrul num transmis și să returneze următorul număr mai mare decât num folosind aceleași cifre. De exemplu: dacă num este 123
returnează 132, dacă este 12453 returnează 12534. Dacă un număr nu are permutări mai mari, returnați -1 (adică. 999).
Exemple
Intrare: 11121 Ieșire: 11211
Intrare: 41352
Ieșire: 41523
funcția PermutationStep(num) {
var numArray = num.toString().split('').reverse();
numArray = numArray.map(function(val) {
returnează parseInt(val);
})
testul var = adevărat;
var len = numArray.length;
newArray = [];
în timp ce(test) {
dacă (!newArray[0]) {
newArray[0] = numArray.shift();
}
else if (newArray.every(function(val) {
return val <= numArray[0];
})) {
newArray.push(numArray.shift())
}
altfel {
dacă (!numArray[0]) {
returnează "-1";
}
test = fals;
}
}
newArray.sort(function(a, b) {return a - b});
var numHolder = numArray.shift();
pentru (var i = 0; i < newArray.length; i++) {

if (newArray[i] > numHolder) {
numArray.unshift(newArray[i]);
newArray[i] = numHolder;
sparge;
}
}
newArray.sort(funcție(a, b) {return b - a});
var resultArray = newArray.concat(numArray);
return resultArray.reverse().join('');
}
PermutareStep(linie de citire());
Prime Checker
Funcția PrimeChecker(num) ia num și returnează 1 dacă orice aranjament de num iese a fi un număr prim, altfel returnează 0. De exemplu: dacă num este 910, ieșirea ar trebui să
fie 1, deoarece 910 poate fi aranjat în 109 sau 019, ambele fiind numere prime.
Exemple
Intrare: 98
Ieșire: 1
Intrare: 598
Ieșire: 1
funcția PrimeChecker(num) {
Funcția Initialize convertește numărul într-o matrice de N! matrice cu 2
elemente, unde n este numărul de cifre din num.
Matricea are forma ['',['1', '2', '3']].
workingArray = initialize(num);
var arrayLen = workingArray.length;
while (workingArray[0][1].length > 0){

permStep este funcția care mută cifrele în locurile lor într-o manieră ordonată,
rezultând
o matrice de n! elemente de forma ['123',[]].
permStep(matrice de lucru);
}
Acest lucru face ordine în elementele matricei.
workingArray = workingArray.map(function(val){
returnează val[0];
});
primeTest este o funcție pentru a converti fiecare element matrice într-un șir,
apoi testați pentru a vedea dacă este prim.
pentru (var i = 0, WAlen = workingArray.length; i < WAlen; i++){
if (primeTest(workingArray[i])){
returnarea 1;
}
}
retur 0
funcția initialize(num) {
var arr = num.toString().split('')
var resArr = [];
pentru (var i = 0, len = factorial(arr.length); i < len; i++) {
resArr.push(['', arr]);
}
returnare resArr;
}
funcția factorială(num) {
dacă (num <= 1) {
returnarea 1;
}
altfel {
Întoarcere num * factorial(num - 1)
}
}
funcția permStep(arr) {
contor var = 0;
var len = arr[0][1].length;
în timp ce (counter < arrayLen) {
var targetArray = arr[counter][1];
pentru (var i = 0; i < len; i++) {
pentru (var j = 0; j < factorial(len - 1); j++){
var copyArray = targetArray.map(function(val){
returnarea val;
});
var holder = copyArray.splice(i, 1);
arr[counter][0] = arr[counter][0].concat(holder[0]);
arr[counter][1] = copyArray;
contra++;
}
}
}
arr de întoarcere;
}
funcția primeTest(stringNum) {
stringNum = parseInt(stringNum);
pivot = Math.ceil(Math.sqrt(stringNum));
if (stringNum === 1) {
returnează fals;
}
if (stringNum === 2) {
}
altfel {
pentru (var i = 2; i <= pivot; i++) {
if (stringNum % i === 0) {
returnează fals;
}
}
}
}
}

PrimeChecker(readline());
Inserție Dash II
Puneți funcția DashInsertII(str) să insereze liniuțe ('-') între fiecare două numere impare și să introducă asteriscuri ('*' ) între fiecare două numere pare din str. De exemplu: dacă
str este 4546793 ieșirea ar trebui să fie 454 * 67-9-3. Nu numărați zero ca număr impar sau par.
Exemple
Intrare: 99946
Ieșire: 9-9-94 * 6
Intrare: 56647304
Ieșire: 56 * 6 * 47-304
funcția DashInsertII(num) {
const resString = num.toString(10);
returnează resString
.replace(/([2468])(?=[2468])/g, '$1*')
.replace(/([13579])(?=[13579])/g, '$1-');
}

DashInsertII(linie de citire());
Swap II
Setați funcția SwapII(str) să ia parametrul str și să schimbe majusculele fiecărui caracter. Apoi, dacă o literă se află între două numere (fără separare), comutați locurile celor
două numere. De exemplu: dacă str este "6Hello4 -8World, 7 yes3" ieșirea ar trebui să fie 4hELLO6 -8wORLD, 7 YES3.
Exemple
Intrare: "Hello -5LOL6"
Ieșire: hELLO -6lol5
Intrare: "2S 6 du5d4e"

Ieșire: 2s 6 DU4D5E
lăsați ajutoarele;
funcția SwapII(str) {
const switchString = helpers.caseSwap(str);
return switchString.replace(/(\d)([A-Za-z]+)(\d)/g, '$3$2$1');
}
ajutoare = {
caseSwap(str) {
Retur str
.split('')
.map((scrisoare) => {
dacă (/[A-Z]/.test(letter)) {
return letter.toLowerCase();
}
scrisoare de returnare.laMajuscule();
})
.join('');
}
};

SwapII(readline());
Căutare numere
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 împărțit la numărul total de litere din șir. De
exemplu: dacă str este "Hello6 9World 2, Nic8e D7ay!" ieșirea ar trebui să fie 2. În primul rând, dacă adunați toate numerele, 6 + 9 + 2 + 8 + 7 obțineți 32. Apoi, există 17 litere în
șir. 32 / 17 = 1.882, iar răspunsul final trebuie rotunjit la cel mai apropiat număr întreg, deci răspunsul este 2. Doar numerele cu o singură cifră separate prin spații vor fi utilizate pe
întregul șir (Deci acest lucru nu va fi niciodată cazul: hello44444 world). Fiecare șir va avea, de asemenea, cel puțin o literă.
Exemple
Intrare: "H3ello9-9"
Ieșire: 4
Intrare: "Un număr * 1 * "

Ieșire: 0
funcția NumberSearch(str) {
var matchArr = str.match(/d/g);
dacă (matchArr) {
var matchArr = matchArr.map(function(val) {
});
var sum = matchArr.reduce(function(post, pre){
Retur Pre + Post
});
}
altfel {
suma var = 0;
}
var letterArr = str.match(/[a-zA-Z]/g);
returnează Math.round(sumă / literăArondisment);

NumberSearch(readline());
Triplă dublă
Funcția TripleDouble(num1,num2) ia ambii parametri trecuți și returnează 1 dacă există o triplă dreaptă a unui număr în orice loc în num1 și, de asemenea, o dublă dreaptă a
aceluiași număr în num2. De exemplu: dacă num1 este egal cu 451999277 și num2 este egal cu 41177722899, atunci returnează 1 deoarece în primul parametru aveți triplul 999 drept
și aveți un dublu drept, 99, de același număr în al doilea parametru. Dacă nu este cazul, returnați 0.
Exemple
Intrare: 465555 & num2 = 5579
Ieșire: 1
Intrare: 67844 & num2 = 66237

Ieșire: 0
funcția TripleDouble(num1,num2) {
var holdArr = []
num1 = num1.toString();
pentru (var i = 0; i <= 9; i++) {
i = i.toString();
var regEx = noul RegExp (i+i+i);
dacă (regEx.test(num1)){
holdArr.push(i);
}
}
if (holdArr === []) {

consolă.log(holdArr)
returnare 0;
}
altfel {
pentru (var j = 0, len = holdArr.length; j < len; j++){
var dublu = nou RegExp (holdArr[j] + holdArr[j]);
consolă.log(dublă);
dacă (double.test(num2)) {
returnarea 1;
}
}
returnare 0;
}
consolă.log(holdArr);
}

TripleDouble(linie de citire());
Potrivire paranteze
Puneți funcția BracketMatcher(str) să preia parametrul str trecut și să returneze 1 dacă parantezele sunt potrivite corect și fiecare este contabilizată. În caz contrar, returnați 0.
De exemplu: dacă str este "(salut (lume))", atunci ieșirea ar trebui să fie 1, dar dacă str este "((salut (lume))", ieșirea ar trebui să fie 0, deoarece parantezele nu se potrivesc corect.
Numai "(" și ")" vor fi folosite ca paranteze. Dacă str nu conține paranteze returnați 1.
Exemple
Intrare: "(coder)(byte))"
Ieșire: 0
Intrare: "(c(oder)) b(yte)"

Ieșire: 1
funcția BracketMatcher(str) {
var strArray = str.split('');
contor var = 0;
pentru (var i = 0, len = strArray.length; i < len; i++) {
dacă (strArray[i] === "(") {
contra++;
}
else if (strArray[i] === ")") {
contor--;
}
dacă (contor < 0) {
returnare 0;
}
}
dacă (contor === 0) {
returnarea 1;
}
returnare 0;
}

BracketMatcher(readline());
Reducerea șirurilor
Puneți funcția StringReduction(str) să ia parametrul str transmis și să returneze cel mai mic număr pe care îl puteți obține prin următoarea metodă de reducere. Metoda este:
Numai literele a, b și c vor fi date în str și trebuie să luați două caractere adiacente diferite și să le înlocuiți cu al treilea. De exemplu, "ac" poate fi înlocuit cu "b", dar "aa" nu poate
fi înlocuit cu nimic. Această metodă se face în mod repetat până când șirul nu mai poate fi redus și lungimea șirului rezultat trebuie să fie emisă. De exemplu: dacă str este "cabină",
"ca" poate fi redus la "b" și obțineți "bb" (îl puteți reduce și la "cc"). Reducerea se face astfel încât ieșirea ar trebui să fie 2. Dacă str este "bcab", "bc" se reduce la "a", deci aveți
"aab", atunci "ab" se reduce la "c", iar șirul final "ac" este redus la "b", deci ieșirea ar trebui să fie 1.
Exemple
Intrare: "abcabc"
Ieșire: 2
Intrare: "cccc"
Ieșire: 4
funcția StringReduction(str) {
în timp ce (str.match(/(ab|ba|ac|ca|bc|cb)/) != nedefinit) {

str = str.replace(/(ab|ba)/, "c");
str = str.replace(/(bc|cb)/, "a");
str = str.replace(/(ac|ca)/, "b");
}
Codul merge aici

retur str.length;

StringReduction(readline());
ThreeFive multipli
Funcția ThreeFiveMultiples(num) returnează suma tuturor multiplilor de 3 și 5 care sunt sub num. De exemplu: dacă num este 10, multiplii lui 3 și 5 care sunt sub 10 sunt 3, 5,
6 și 9 și adunându-i obțineți 23, deci programul dvs. ar trebui să returneze 23. Numărul întreg trecut va fi între 1 și 100.
Exemple
Intrare: 6
Ieșire: 8
Intrare: 1
Ieșire: 0
funcția ThreeFiveMultiples(num) {
ARR VAR = [];
pentru (var i = 0; i <= num - 1; i++) {
Dacă (i % 3 === 0 || (i % 5 === 0 && i % 3 !== 0)) {
arr.push(i);
}
}
return arr.reduce(function(hold, val) {
retur hold + val;
});
}

ThreeFiveMultiples(readline());
Arborele de căutare binar LCA
Funcția BinarySearchTreeLCA(strArr) ia matricea de șiruri stocate în strArr, care va conține 3 elemente: primul element va fi un arbore de căutare binar cu toate valorile
unice într-o matrice de traversare precomandă , al doilea și al treilea element vor fi două valori diferite, iar scopul tău este să găsești cel mai mic strămoș comun al acestor două valori.
De exemplu: dacă strArr este ["[10, 5, 1, 7, 40, 50]", "1", "7"] atunci acest arbore arată astfel:
Pentru intrarea de mai sus, programul dvs. ar trebui să returneze 5, deoarece aceasta este valoarea nodului care este LCA al celor două noduri cu valorile 1 și 7. Puteți presupune că
cele două noduri pe care le căutați în arbore vor exista undeva în copac.
Exemple
Intrare: ["[10, 5, 1, 7, 40, 50]", "5", "10"]
Ieșire: 10
Intrare: ["[3, 2, 1, 12, 4, 5, 13]", "5", "13"]

Ieșire: 12
funcția BinarySearchTreeLCA(strArr) {
Luați primul element din matricea de argumente și transformați-l într-o matrice
de numere întregi
fie nodeArray = strArr[0]
.replace(/[[]]/g, '')
.split(/,s/)
.map(val => parseInt(val, 10));
Luați celelalte elemente din matricea de argumente și convertiți-le în numere

întregi
fie num1 = parseInt(strArr[1], 10);
Găsiți pozițiile numerelor date în matricea numerică

fie ind1 = nodeArray.findIndex(val => val === num1);
fie ind2 = nodeArray.findIndex(val => val === num2);
Determinați mai departe dintre cele două poziții, nu ne interesează elemente din
trecut
fie rightEdge = Math.max(ind1, ind2);
vedeți dacă există elemente în stânga RightEdge care împart cele două numere
date, acesta va fi răspunsul
let result = nodeArray.filter((val, ind) => (val >= Math.min(num1, num2) && val
<= Math.max(num1, num2) && ind <= rightEdge));
dacă nu există, returnați elementul care este cel mai îndepărtat la stânga
dacă (result.length === 0) returnează ind1 < ind2 ? strArr[1] : strArr[2];
Dacă există, returnați-l ca șir

rezultatul returnării[0].toString();
}

BinarySearchTreeLCA(readline());
Determinant monedă
Puneți funcția CoinDeterminer(num) să ia intrarea, care va fi un număr întreg cuprins de la 1 la 250, și să returneze o ieșire întreagă care va specifica cel mai mic număr de
monede, care, atunci când este adăugat, este egal cu numărul întreg de intrare. Monedele se bazează pe un sistem după cum urmează: există monede reprezentând numerele întregi 1,
5, 7, 9 și 11. De exemplu: dacă num este 16, atunci ieșirea ar trebui să fie 2, deoarece puteți obține numărul 16 cu monedele 9 și 7. Dacă num este 25, atunci ieșirea ar trebui să fie 3,
deoarece puteți obține 25 fie cu 11, 9 și 5 monede, fie cu 9, 9 și 7 monede.
Exemple
Intrare: 6
Ieșire: 2
Intrare: 16
Ieșire: 2
funcția CoinDeterminer(num) {
ARR VAR = [0, 1, 2, 3, 4, 1, 2, 1, 2, 1, 2, 2, 3, 2, 3, 3, 2, 2, 3, 2, 2, 3, 2]
dacă (num <= 22) {

Aranjament de întoarcere[num]
}
altfel {
viraje var = Math.floor((num - 11) / 22) * 2;
var remain = num - (se transformă * 11);
dacă (rămâne > 22) {
viraje ++;
rămân -= 11;
}
întoarcere întoarcere + arr[remain];
}
}

CoinDeterminer(readline());
Fibonacci Checker
Funcția FibonacciChecker(num) returnează șirul da dacă numărul dat face parte din șirul Fibonacci. Această secvență este definită prin: Fn = Fn-1 + Fn-2, ceea ce înseamnă că
pentru a găsi Fn adăugați cele două numere anterioare. Primele două numere sunt 0 și 1, apoi vine 1, 2, 3, 5 etc. Dacă num nu este în șirul Fibonacci, returnați șirul nr.
Exemple
Intrare: 34
Ieșire: da
Intrare: 54
Ieșire: nu
funcția FibonacciChecker(num){
sămânță var1 = 0;
sămânță var2 = 1;
contor var = 0;
în timp ce (counter < num) {
contor = sămânță1 + sămânță2;
dacă (contor === num) {
returnați "da";
}
sămânță1 = sămânță2;
sămânță2 = contor;
}
returnați "nu";
}

FibonacciChecker(readline());
Paranteze multiple
Puneți funcția MultipleBrackets(str) să preia parametrul str trecut și să returneze 1 #ofBrackets dacă parantezele sunt potrivite corect și fiecare este contabilizată. În caz
contrar, returnați 0. De exemplu: dacă str este "(salut [lume])(!) ", atunci ieșirea ar trebui să fie 1 3, deoarece toate parantezele sunt potrivite și există 3 perechi de paranteze, dar
dacă str este "((salut [lume])" ieșirea ar trebui să fie 0, deoarece parantezele nu se potrivesc corect. Numai "(", ")", "[" și "]" vor fi folosite ca paranteze. Dacă str nu conține
paranteze returnați 1.
Exemple
Intrare: "(coder)[octet)]"
Ieșire: 0
Intrare: "(c([od]er)) b(yt[e])"

Ieșire: 1 5
funcția MultipleBrackets(str) {
var regex = /[()[]]/;
dacă (!regex.test(str)) returnează 1;

var countParen = 0;
var countBrack = 0;
var countOpen = 0;
pentru (var i = 0, len = str.length; i < len; i++) {
switch(str.charAt(i)) {
cazul "(':
countOpen++;
countParen++;
sparge;
cazul "[':
countOpen++;
countBrack++;
sparge;
cazul ")":
conteParen--;
sparge;
cazul "]":
conteBrack--;
sparge;
}
dacă (countParen < 0 || countBrack < 0) returnează 0;
}
dacă (countParen === 0 &&; countBrack === 0) return ('1 ' + countOpen);
altfel returnează 0;
}

Paranteze multiple(linie de citire());
Cel mai mult timp liber
Puneți funcția MostFreeTime (strArr) să citească parametrul strArr transmis, care va reprezenta o zi întreagă și va fi umplut cu evenimente care se întind de la X la Y în
timpul zilei. Formatul fiecărui eveniment va fi hh:mmAM/PM-hh:mmAM/PM. De exemplu, strArr poate fi ["10:00AM-12:30PM","02:00PM-02:45PM","09:10AM-09:50AM"].
Programul tău va trebui să ofere cel mai lung timp liber disponibil între începutul primului tău eveniment și sfârșitul ultimului tău eveniment în formatul: hh:mm. Evenimentul de
start ar trebui să fie cel mai timpuriu eveniment al zilei, iar cel mai recent eveniment ar trebui să fie cel mai recent eveniment al zilei. Prin urmare, ieșirea pentru intrarea anterioară ar
fi 01:30 (cel mai vechi eveniment din zi începând cu 09:10AM și cel mai recent eveniment terminându-se la 02:45PM). Intrarea va conține cel puțin 3 evenimente și evenimentele pot
fi defecte.
Exemple
Intrare: ["12:15PM-02:00PM","09:00AM-10:00AM","10:30AM-12:00PM"]
Ieșire: 00:30
Intrare: ["12:15PM-02:00PM","09:00AM-12:11PM","02:02PM-04:00PM"]
Ieșire: 00:04
funcția MostFreeTime(strArr) {
strArr = strArr.map(function(val) {
returnează convert12to24(val);
});
strArr = strArr.map(function(val){
returnează convertToMinutes(val);
})
strArr.sort(function(a, b){
return parseInt(a.match(/d{3,4}/) - b.match(/d{3,4}/))
})
strArr = strArr.map(function(val){
valArr = val.split('-');
valArr = valArr.map(function(val){
});
returnează valArr;
});
var len = strArr.length;
contor var = 0;
pentru (var i = 0; i < len - 1; i++) {
timp var = strArr[i+1][0] - strArr[i][1];
dacă (timp > contor) {
contor = timp;
}
}
returnare returnToTime(counter);
funcția returnToTime(counter){
var mins = (contor % 60).toString();
var hrs = (Math.floor(counter / 60).toString());
dacă (minute < 10) {
minute = '0' + minute;
}
dacă (ore < 10) {
ore = '0' + ore;
}
retur (ore + ':' + minute);
}
funcția convertToMinutes(strVal) {
tempArr = strVal.split('-');
tempArr = tempArr.map(function(val){
var hrs = parseInt(val.slice(0,2));
var mins = parseInt(val.slice(3));
ore de retur * 60 + minute;
});
returnare tempArr.join('-');
}
funcția convert12to24(strVal) {
var tempArr = strVal.split('-');
tempArr = tempArr.map(function(val){
dacă (/am/i.test(val)) {
val = val.replace('12', '00');
returnează val.slice(0, 5);
}
altfel {
val = val.replace('12', '00');
var oră = parseInt(val.slice(0, 2));
val = val.felie(2);
var newHour = (oră + 12).toString();
val = newHour.concat(val)
returnează val.slice(0, 5);
}
});
returnare tempArr.join('-');
}
}

MostFreeTime(readline());
Dreptunghiuri suprapuse
Puneți funcția OverlappingRectangles(strArr) să citească parametrul strArr transmis, care va reprezenta două dreptunghiuri pe un plan de coordonate carteziene și va
conține 8 coordonate, primele 4 alcătuind dreptunghiul 1 și ultimele 4 alcătuind rectangul 2. Acesta va fi în următorul format: ["(0,0),(2,2),(2,0),(0,2),(1,0),(1,2),(6,0),(6,2)"]
Programul dvs. ar trebui să determine zona spațiului în care se suprapun cele două dreptunghiuri și apoi să emită de câte ori această regiune suprapusă poate încăpea în primul
dreptunghi. Pentru exemplul de mai sus, regiunea de suprapunere formează un dreptunghi al ariei 2, iar primul dreptunghi (primele 4 coordonate) formează un dreptunghi al ariei 4,
deci programul dvs. ar trebui să producă 2. Coordonatele vor fi toate întregi. Dacă nu există nicio suprapunere între cele două dreptunghiuri, returnați 0.
Exemple
Intrare: ["(0,0),(0,-2),(3,0),(3,-2),(2,-1),(3,-1),(2,3),(3,3)"]
Ieșire: 6
Intrare: ["(0,0),(5,0),(0,2),(5,2),(2,1),(5,1),(2,-1),(5,-1)"]
Ieșire: 3
JAVASCRIPT
lăsați ajutoarele;
const OverlappingRectangles = (strArr) => {

const dreptunghiuri = helpers.rectangArrays(strArr);
const rec1Points = helpers.recPoints(dreptunghiuri[0]);
const rec2Points = helpers.recPoints(dreptunghiuri[1]);
a creat obiectul valori pentru a da nume laturilor dreptunghiului pentru a le

face
mai ușor de vizualizat.
valori const = {
rec1Top: rec1Puncte[1][1],
rec1Right: rec1Points[1][0],
rec1Bottom: rec1Points[0][1],
rec1Left: rec1Points[0][0],
rec2Top: rec2Points[1][1],
rec2Right: rec2Points[1][0],
rec2Partea de jos: rec2Points[0][1],
rec2Stânga: rec2Points[0][0]
};
const rec1Area = (values.rec1Top - values.rec1Bottom) * (values.rec1Right -
values.rec1Left);
/* test de suprapunere */
if (values.rec2Bott >= values.rec1Top ||
values.rec1Bott >= values.rec2Top ||
values.rec1Left >= values.rec2Right ||
values.rec2Left >= values.rec1Right) {
returnare 0;
}
const overLapTop = Math.min(values.rec1Top, values.rec2Top);

const overLapBottom = Math.max(values.rec1Bottom, values.rec2Bottom);
const overLapRight = Math.min(values.rec1Right, values.rec2Right);
const overLapLeft = Math.max(values.rec1Left, values.rec2Left);
const overLapArea = (overLapTop - overLapBottom) * (overLapRight -
overLapLeft);
retur overLapArea === 0 ? 0 : Math.trunc(rec1Area / overLapArea);
};
ajutoare = {
/* funcția RectangArrays ta105816
kes intrarea acestei probleme și returnează un
matrice cu două elemente, fiecare element fiind o matrice de puncte din primul
sau
al doilea dreptunghi, respectiv. */
rectangArrays(strArr) {
const str = strArr[0];
fie bigArray = str.split('),(');
bigArray = bigArray.map((val) => {
const cleanVal = val.replace(/[()]/g, '');
const pointArray = cleanVal.split(',');
pointArray[0] = parseInt(pointArray[0], 10);
pointArray[1] = parseInt(pointArray[1], 10);
punct de întoarcereArray;
});
return [bigArray.splice(0, 4), bigArray];
},
/*
funcția recPoints ia o serie de puncte pe grila carteziană (a unui
dreptunghi aliniat) și returnează o matrice de două puncte, reprezentând partea
inferioară
colțul din stânga și colțul din dreapta sus al dreptunghiului.
*/
recPoints(arr) {
const yVals = arr.map(val => val[1]);
const xVals = arr.map(val => val[0]);
const yMin = Math.min(... yVals);
const yMax = matematică.max(... yVals);
const xMin = Math.min(... xVals);
const xMax = Matematică.max(... xVals);
returnează [[xMin, yMin], [xMax, yMax]];
}
};
SuprapunereDreptunghiuri(readline());
Uită-te Spune secvență
Funcția LookSaySequence(num) ia parametrul num transmis și returnează următorul număr din secvență conform următoarei reguli: pentru a genera următorul număr dintr-o
secvență citiți cifrele numărului dat, numărând numărul de cifre din grupurile aceleiași cifre. De exemplu, secvența care începe cu 1 ar fi: 1, 11, 21, 1211, ... 11 vine de la faptul că
există "un 1" înaintea lui, iar 21 vine de la faptul că există "doi 1" înaintea lui. Deci, programul dvs. ar trebui să returneze următorul număr din secvența dată num.
Exemple
Intrare: 1211
Ieșire: 111221
Intrare: 2466
Ieșire: 121426
funcția LookSaySequence(num) {
var numArr = prepFunc(num);
var newArr = [];
var storeArr = [];
în timp ce (numArr.length > 0) {

dacă (!newArr.length) {
newArr.push(numArr.shift());
dacă (!numArr.length) {
storeArr.push('1');
storeArr.push(newArr[0]);
returnează parseInt(storeArr.join(''));
}
}
else if (newArr[newArr.length - 1] === numArr[0]) {
newArr.push(numArr.shift());
dacă (!numArr.length) {
storeArr.push(newArr.length.toString());
returnează parseInt(storeArr.join(''));
}
}
altfel {
storeArr.push(newArr.length.toString());
newArr = [];
}
}
consolă.log(storeArr);
Codul merge aici

num de întoarcere;
funcția prepFunc(num) {
var str = num.toString();
var arr = str.split('');
arr de întoarcere;
}
}

LookSaySequence(readline());
Listă distinctă
Funcția DistinctList(arr) preia matricea de numere stocate în arr și determină numărul total de intrări duplicate. De exemplu, dacă intrarea este [1, 2, 2, 2, 3], atunci
programul dvs. ar trebui să iasă 2, deoarece există două duplicate ale unuia dintre elemente.
Exemple
Intrare: [0,-2,-2,5,5,5]
Ieșire: 3
Intrare: [100,2,101,4]
Ieșire: 0
funcția DistinctList(arr) {
const strippedArr = set nou(arr);
întoarcere arr.length - strippedArr.size;
}
DistinctList(readline());
Codificarea numerelor
Solicitați funcției NumberEncoding(str) să ia parametrul str și să codifice mesajul conform următoarei reguli: codificați fiecare literă în poziția numerotată corespunzătoare din
alfabet. Simbolurile și spațiile vor fi, de asemenea, utilizate în intrare. De exemplu: dacă str este "af5c a#!" atunci programul dvs. ar trebui să returneze 1653 1#!.
Exemple
Intrare: "salut 45"
Ieșire: 85121215 45
Intrare: "jaj-a"
Ieșire: 10110-1
funcția NumberEncoding(str) {
str = str.toLitere mici();
var arr = str.split("");
pentru (var i = 0; i < len; i++) {

dacă (/[a-z]/.test(arr[i])) {
arr[i] = arr[i].replace(arr[i].charAt(0), (arr[i].charCodeAt(0) -
96).toString());
}
}
str = arr.join("");
Codul merge aici
str. de întoarcere;

NumberEncoding(readline());
Selector stoc
Puneți funcția StockPicker(arr) să ia matricea de numere stocate în arr care va conține numere întregi care reprezintă suma în dolari pe care o valorează o singură
acțiune și să returneze profitul maxim care ar fi putut fi obținut cumpărând acțiuni în ziua x și vânzând acțiuni în ziua y unde y > x. De exemplu: dacă arr este [44, 30, 24, 32, 35,
30, 40, 38, 15], atunci programul dvs. ar trebui să returneze 16, deoarece la indicele 2 acțiunea valora 24 USD și la indicele 6 acțiunea valora atunci 40 USD, deci dacă ați cumpărat
acțiunea la 24 și ați vândut-o la 40, Ați fi obținut un profit de 16 USD, care este profitul maxim care ar fi putut fi obținut cu această listă de prețuri ale acțiunilor.
Dacă nu există profit care ar fi putut fi realizat cu prețurile acțiunilor, atunci programul dvs. ar trebui să returneze -1. De exemplu: arr este [10, 9, 8, 2] atunci programul dvs. ar
trebui să returneze -1.
Exemple
Intrare: [10,12,4,5,9]
Ieșire: 5
Intrare: [14,20,4,12,5,11]
Ieșire: 8
funcția StockPicker(arr) {
var maxProfit = 0;
în timp ce (arr.length > 1) {

var start = arr.shift();
var max = Math.max.apply(null, arr);
var profit = max - start;
dacă (profit > maxProfit) {
maxProfit = profit;
}
}
returnare maxProfit === 0 ? -1 : maxProfit;

StockPicker(readline());
Submatrice maximă
Funcția MaxSubarray(arr) ia matricea de numere stocate în arr și determină cea mai mare sumă care poate fi formată de orice submatrice contiguă din matrice. De exemplu, dacă
arr este [-2, 5, -1, 7, -3], atunci programul dvs. ar trebui să returneze 11, deoarece suma este formată din submatrice [5, -1, 7]. Adăugarea oricărui element înainte sau după această
submatrice ar face suma mai mică.
Exemple
Intrare: [1, -2, 0, 3]
Ieșire: 3
Intrare: [3, -1, -1, 4, 3, -1]

Ieșire: 8
funcția MaxSubarray(arr) {
Folosim acest număr de câteva ori
fie count = Matematică.max(... Arondisment),
indexArray = [];
Aveți grijă de caz fără numere pozitive

dacă (număr <= 0) {
}
obțineți o listă (indexArray) a indicilor tuturor intrărilor pozitive

arr.forEach((val, ind) => {
dacă (val > 0) {
indexArray.push(ind)
}
});
Știm că un maxim trebuie să aibă un număr pozitiv la fiecare capăt al submatricei
(dacă există mai multe
numere pozitive. Desigur, subArray ar putea avea o lungime de unul. Deci,
comparați toate posibilitățile
submatrice.
let leng = indexArray.length;
pentru (fie i = 0; i < leng; i++) {
pentru (fie j = i + 1; j < leng; j++) {
fie subArraySum = arr
.slice(indexArray[i], indexArray[j] + 1)
.reduce((val1, val2) => val1 + val2);
numărul de actualizări dacă subArraySum este mai mare
count = Math.max(count, subArraySum);
}
}
}

MaxSubarray(linie de citire());
Cifră lipsă
Puneți funcția MissingDigit(str) să ia parametrul str, care va fi o formulă matematică simplă cu trei numere, un singur operator (+, -, * sau /) și un semn egal (= ) și să returneze
cifra care completează ecuația. Într-unul dintre numerele din ecuație, va exista un caracter x, iar programul dvs. ar trebui să determine ce cifră lipsește. De exemplu, dacă str este "3x
+ 12 = 46", atunci programul dvs. ar trebui să producă 4. Caracterul x poate apărea în oricare dintre cele trei numere și toate cele trei numere vor fi mai mari sau egale cu 0 și mai mici
sau egale cu 1000000.
Exemple
Intrare: "4 - 2 = x"
Ieșire: 2
Intrare: "1x0 * 12 = 1200"

Ieșire: 0
funcția MissingDigit(str) {
pentru (fie i = 0; i < 10; i++) {
const newString = str.replace(/x/, i.toString()).replace(/=/, '===');
if (eval(newString)) {
returnarea i;
}
}
returnarea "eșuată";
}

MissingDigit(readline());
K Caractere unice
Puneți funcția KUniqueCharacters(str) să ia parametrul str transmis și să găsească cel mai lung subșir care conține k caractere unice, unde k va fi primul caracter din șir.
Subșirul va începe din a doua poziție din șir, deoarece primul caracter va fi numărul întreg k. De exemplu: dacă str este "2aabbacbaa" există mai multe subșiruri care conțin toate 2
caractere unice, și anume: ["aabba", "ac", "cb", "ba"], dar programul dvs. ar trebui să returneze "aabba" deoarece este cel mai lung subșir. Dacă există mai multe subșiruri mai lungi,
atunci returnați primul subșir întâlnit cu cea mai mare lungime. k va varia de la 1 la 6.
Exemple
Intrare: "3aabacbebebe"Ieșire: cbebebe
Intrare: "2aabbcbbbadef"
Ieșire: bbcbbb
funcția KUniqueCharacters(str) {
const count = parseInt(str.slice(0,1), 10);
const subjectString = str.slice(1);
const len = subjectString.length;
fie maxCount = 0;

contor = 0;
fie titularul = [];
fie charArray = [];
pentru (fie j = i; j < len; j++) {
fie char = subjectString.charAt(j);
dacă (charArray.some(val => val === char)) {
holder.push(char);
contra++;
dacă (j === len - 1) {
if (counter > maxCount) {
rezultat = Array.from (deținător);
}
maxCount = Math.max(contor, maxCount);
}
continua;
} altceva {
dacă (charArray.length < count) {
contra++;
charArray.push(char);
holder.push(char)
continua;
} altceva {
rezultat = Array.from(holder);
}
maxCount = Math.max(contor, maxCount);
sparge;
}
}
}
}
return result.join('');
}

KUniqueCharacters(readline());
Găuri Bitmap
Puneți funcția BitmapHoles (strArr) să ia matricea de șiruri stocate în strArr, care va fi o matrice 2D de 0 și 1 și să determine câte găuri sau regiuni contigue de 0 există în
matrice. O regiune contiguă este una în care există un grup conectat de 0 care merge într-una sau mai multe din cele patru direcții: sus, jos, stânga sau dreapta.
De exemplu: dacă strArr este ["10111", "10101", "11101", "11111"], atunci aceasta arată ca următoarea matrice:1 0 1 1 1 1 0 1 0 1 1 1 1 0 1 1 1 1 1 1 Pentru intrarea de mai sus,
Programul dvs. ar trebui să returneze 2, deoarece există două regiuni contigue separate de 0, care creează "găuri" în matrice. Puteți presupune că intrarea nu va fi goală.
Exemple
Intrare: ["01111", "01101", "00011", "11110"]
Ieșire: 3
Intrare: ["1011", "0010"]

Ieșire: 2
funcția BitmapHoles(strArr) {
const thisObj = {};
thisObj.fullArray = strArr.map(row => row.split(''));

thisObj.fullArray.forEach((rând, rowNum, arr) => {
row.forEach((val, colNum) => {
poate scapa de hotTest si foloseste doar crawlerul aici.

dacă (val === '1') {
} altceva {
arr[rowNum][colNum] = 'H';
crawler([[rowNum,colNum]])
}
});
});
return thisObj.fullArray.reduce((row1, row2) => {
întoarcere rând1.concat(rând2);
}).filter(val => val === 'H').length;
funcția crawler(pointsArray) {
fie newArray = [];
pointsArray.forEach(punct => {
if(point[0] > 0 &&; thisObj.fullArray[point[0] - 1][point[1]] === '0') {

thisObj.fullArray[punct[0] - 1][punct[1]] = '1';
newArray.push([punct[0] - 1, punct[1]]);
}
dacă (punct[0] < thisObj.fullArray.length - 1 &&;

thisObj.fullArray[punct[0] + 1][punct[1]] === '0') {
thisObj.fullArray[punct[0] + 1][punct[1]] = '1';
newArray.push([punct[0] + 1, punct[1]]);
}
dacă (punct[1] > 0 && thisObj.fullArray[punct[0]][punct[1] - 1] === '0')

{
thisObj.fullArray[punct[0]][punct[1] - 1] = '1';
newArray.push([punct[0], punct[1] - 1]);
}
dacă (punct[1] < thisObj.fullArray[0].length - 1 &&;

thisObj.fullArray[point[0]][point[1] + 1] === '0') {
thisObj.fullArray[punct[0]][punct[1] + 1] = '1';
newArray.push([punct[0], punct[1] + 1]);
}
});
dacă (newArray.length === 0) {

restitui;
}
crawler(newArray);
}
}

BitmapHoles(readline());
Arbore simetric
Puneți funcția SymmetricTree (strArr) să ia matricea de șiruri stocate în strArr, care va reprezenta un arbore binar, și să determine dacă arborele este simetric (o imagine în
oglindă a sa). Matricea va fi implementată similar cu modul în care este implementată o grămadă binară , cu excepția faptului că arborele poate să nu fie complet și nodurile NULL de
pe orice nivel al arborelui vor fi reprezentate cu un #. De exemplu: dacă strArr este ["1", "2", "2", "3", "#", "#", "3"] atunci acest arbore arată astfel:
Pentru intrarea de mai sus, programul dvs. ar trebui să returneze șirul adevărat, deoarece arborele binar este simetric.
Exemple
Intrare: ["4", "3", "4"]
Ieșire: false
Intrare: ["10", "2", "2", "#", "1", "1", "#"]

Ieșire: adevărat
funcția SymmetricTree(strArr) {
fie x = 1;
fie count = 0;
în timp ce (strArr.length) {
x++;
dacă (x > 10) rupe;
fie lungime = Math.pow(2, număr);
let newArray = strArr.splice(0, lungime);
fie revArray = Array.from(newArray).reverse();
if(!sameAs(newArray, revArray)) {
returnează fals;
}
count = newArray.filter(val => val !== '#').length;
}
}
funcția sameAs(arr1, arr2) {

întoarcere arr1.every((val, ind) => val === arr2[ind]);
}

Arbore simetric(linie de citire());
Arborele binar LCA
Funcția BinaryTreeLCA(strArr) ia matricea de șiruri stocate în strArr, care va conține 3 elemente: primul element va fi un arbore binar cu toate valorile unice într-un format
similar cu modul în care o grămadă binară este implementată cu noduri NULL la orice nivel reprezentat cu un #, Al doilea și al treilea element vor fi două valori diferite, iar scopul
tău este să găsești cel mai mic strămoș comun al acestor două valori.
De exemplu: dacă strArr este ["["[12, 5, 9, 6, 2, 0, 8, #, #, 7, 4, #, #, #, #]", "6", "4"] atunci acest arbore arată astfel:
Pentru intrarea de mai sus, programul dvs. ar trebui să returneze 5, deoarece aceasta este valoarea nodului care este LCA al celor două noduri cu valorile 6 și 4. Puteți presupune că
cele două noduri pe care le căutați în arbore vor exista undeva în copac.
Exemple
Intrare: ["[5, 2, 6, 1, #, 8, #]", "2", "6"]
Ieșire: 5
Intrare: ["[5, 2, 6, 1, #, 8, 12, #, #, #, #, #, 3, #]", "3", "12"]

Ieșire: 12
funcția BinaryTreeLCA(strArr) {
Mai întâi, convertiți șirul reprezentând arborele într-o matrice de numere
fie arrList = strArr[0]
.replace(/[[]]/g, '')
.split(/,s*/)
.map(val => val !== '#' ? parseInt(val, 10) : "#");
Conversia numerelor date (șiruri de caractere) în numere

Obțineți indicii numerelor date. Aceasta este cu adevărat ceea ce avem nevoie
fie ind1 = Math.max(arrList.findIndex(val => val === num1) + 1,
arrList.findIndex(val => val === num2) + 1);
fie ind2 = Math.min(arrList.findIndex(val => val === num1) + 1,
arrList.findIndex(val => val === num2) + 1);
Obțineți cele două numere la aceeași adâncime în copac

în timp ce (Math.trunc(Math.log2(ind1)) !== Math.trunc(Math.log2(ind2))) {
ind1 = Math.trunc(ind1 / 2);
}
Găsiți strămoșul comun în copac

în timp ce (ind1 !== ind2) {
}
Returnați numărul corespunzător indicelui determinat

return arrList[ind2 - 1].toString();
}

BinaryTreeLCA(readline());
LRU Cache
Puneți funcția LRUCache (strArr) să ia matricea de caractere stocate în strArr, care va conține caractere variind de la A la Z într-o anumită ordine arbitrară și să determine ce
elemente rămân încă într-o memorie cache virtuală care poate conține până la 5 elemente cu un algoritm de cache LRU implementat. De exemplu: dacă strArr este ["A", "B", "C",
"D", "A", "E", "D", "Z"], atunci se iau următorii pași:
(1) A nu există în memoria cache, deci accesați-l și stocați-l în memoria cache.

(2) B nu există în memoria cache, deci accesați-l și stocați-l și în memoria cache. Până în prezent, memoria cache conține: ["A", "B"].
(3) Același lucru este valabil și pentru C, deci cache-ul este acum: ["A", "B", "C"].
(4) Același lucru este valabil și pentru D, deci cache-ul este acum: ["A", "B", "C", "D"].
(5) Acum A este accesat din nou, dar există deja în cache, așa că este adus în față: ["B", "C", "D", "A"].
(6) E nu există în memoria cache, deci accesați-l și stocați-l în memoria cache: ["B", "C", "D", "A", "E"].
(7) D este accesat din nou pentru a fi adus în față: ["B", "C", "A", "E", "D"].
(8) Z nu există în memoria cache, așa că adăugați-l în față și eliminați elementul cel mai puțin utilizat: ["C", "A", "E", "D", "Z"].
Acum pașii de cache au fost finalizați și programul dvs. ar trebui să returneze ordinea cache-ului cu elementele unite într-un șir, separate printr-o cratimă. Prin urmare, pentru
exemplul de mai sus, programul dvs. ar trebui să returneze C-A-E-D-Z.
Exemple
Intrare: ["A", "B", "A", "C", "A", "B"]Ieșire
: C-A-B
Intrare: ["A", "B", "C", "D", "E", "D", "Q", "Z", "C"]Ieșire
: E-D-Q-Z-C
funcția LRUCache(strArr) {
fie cache = [];
Foarte simplu, treceți prin matricea dată și operați pe cache
strArr.forEach(val => {
dacă (!cache.includes(val)) {
distracție! Una dintre primele dăți când am profitat vreodată de acest
fapt
That push() returnează lungimea matricei după împingere, nu
matricea în sine
dacă (cache.push(val) > 5) {
cache.shift();
}
} altceva {
cache.splice(cache.findIndex(cacheVal => val === cacheVal), 1);
cache.push(val);
}
});
returnează cache.join('-');

LRUCache(linie de citire());
Medie
Soluții pentru discuții

Constructor de copaci
Puneți funcția TreeConstructor(strArr) să ia matricea de șiruri stocate în strArr, care va conține perechi de numere întregi în următorul format: (i1,i2), unde i1 reprezintă un
nod copil într-un arbore și al doilea întreg i2 înseamnă că este părintele lui i1. De exemplu: dacă strArr este ["(1,2)", "(2,4)", "(7,2)"], atunci acesta formează următorul arbore:
care puteți vedea că formează un arbore binar propriu-zis. Programul dvs. ar trebui, în acest caz, să returneze șirul adevărat, deoarece se poate forma un arbore binar valid. Dacă un
arbore binar adecvat nu poate fi format cu perechi întregi, atunci returnați șirul false. Toate numerele întregi din arbore vor fi unice, ceea ce înseamnă că nu poate exista decât un
singur nod în arbore cu valoarea întreagă dată.
Exemple
Intrare: ["(1,2)", "(2,4)", "(5,7)", "(7,2)", "(9,5)"]
Ieșire: adevărat
Intrare: ["(1,2)", "(3,2)", "(2,12)", "(5,2)"]

Ieșire: false
Următoarea metodă aruncă copaci care nu reușesc oricare dintre cele trei teste: i)
există un singur nod superior, ii) orice nod are mai multe
mai mult de 2 copii sau iii) sunt orice valori ale nodului repetate. Dacă trece
toate aceste teste, atunci ar trebui să reprezinte un arbore binar.
funcția TreeConstructor(strArr) {
eliminați spațiile din intrare (unul dintre teste a avut intrare greșită)
strArr = strArr.map(val => val.replace(/s/g, ''));
fie regExChildPattern = /((d+),d+)/

fie regExParentPattern = /(d+,(d+))/
let children = strArr.map(val => regExChildPattern.exec(val)[1]);

let parents = strArr.map(val => regExParentPattern.exec(val)[1]);
Verificați pentru a vă asigura că toți copiii sunt unici

let childSet = set nou(copii);
dacă (children.length !== childSet.size) {
returnează fals;
}
Testați dacă un nod părinte are mai mult de 2 copii

fie parentObj = {};
parents.forEach(val => {
dacă (!parentObj[val]) {
parentObj[val] = 1;
} altceva {
părinteObj[val]++;
}
})
pentru (lăsați myKey în parentObj) {
dacă (parentObj[myKey] > 2) returnează false;
}
Asigurați-vă că există un singur câine de top

fie uniqParents = Array.from(set nou(părinți))
fie topDogs = uniqParents.filter(val => !children.includes(val));

dacă (topDogs.length !== 1) returnează false;

TreeConstructor(readline());
Matrice Min salturi
Puneți funcția ArrayMinJumps(arr) să ia matricea de numere întregi stocate în arr, unde fiecare întreg reprezintă numărul maxim de pași care pot fi făcuți din acea poziție și să
determine cel mai mic număr de salturi care pot fi efectuate pentru a ajunge la sfârșitul matricei. De exemplu: dacă arr este [1, 5, 4, 6, 9, 3, 0, 0, 1, 3], atunci programul dvs. ar trebui
să emită numărul 3, deoarece puteți ajunge la sfârșitul matricei de la început prin următorii pași: 1 -> 5 -> 9 -> END sau
1 -> 5 -> 6 -> END. Ambele combinații produc o serie de 3 pași. Și, după cum puteți vedea, nu trebuie întotdeauna să faceți numărul maxim de salturi într-o anumită poziție, puteți
face mai puține salturi, chiar dacă numărul este mai mare.
Dacă nu este posibil să ajungeți la sfârșitul matricei, returnați -1.
Exemple
Intrare: [3, 4, 2, 1, 1, 100]
Ieșire: 2
Intrare: [1, 3, 6, 8, 2, 7, 1, 2, 1, 2, 6, 1, 2, 1, 2]
Ieșire: 4
funcția ArrayMinJumps(arr) {
const newArr = Array.from(arr);
const len = newArr.length;
pentru (fie i = len - 1; i >= 0; i--) {
const toGo = lent - (i + 1);
const reach = newArr[i];
dacă (toGo === 0) {
newArr[i] = {
ind: i,
mutări: 0
};
} altfel dacă (reach >= toGo) {
newArr[i] = {
ind: i,
mutări: 1
};
} altceva {
const subArr = newArr.slice(i + 1);
const subArrLen = subArr.length;
const countHolder = [];
pentru (fie j = 0; j < subArrLen; j++) {
if (typeof subArr[j] === 'object' &&; newArr[i] > j) {
countHolder.push(subArr[j].moves);
}
}
dacă (countHolder.length) {
newArr[i] = {
ind: i,
mutări: Math.min(... countHolder) + 1
};
}
}
}
return typeof newArr[0].moves === 'undefined' ? -1 : newArr[0].moves;
}

ArrayMinJumps(readline());
Cele mai apropiate valori mai mici
Funcția NearestSmallerValues(arr) preia matricea de numere întregi stocate în arr și, pentru fiecare element din listă, căutați toate valorile anterioare pentru cel mai apropiat
element care este mai mic decât elementul curent și creați o nouă listă din aceste numere. Dacă nu există niciun element înaintea unei anumite poziții care este mai mică, introduceți un
-1. De exemplu: dacă arr este [5, 2, 8, 3, 9, 12], atunci cea mai apropiată listă de valori mai mici este [-1, -1, 2, 2, 3, 9]. Logica este următoarea:
Pentru 5, nu există o valoare anterioară mai mică, astfel încât lista de până acum este [-1]. Pentru 2, nu există nici o valoare anterioară mai mică, deci lista este acum [-1, -1]. Pentru 8,
cea mai apropiată valoare mai mică este 2, deci lista este acum [-1, -1, 2]. Pentru 3, cea mai apropiată valoare mai mică este tot 2, deci lista este acum [-1, -1, 2, 2]. Acest lucru
continuă să producă răspunsul de mai sus. Programul dvs. ar trebui să ia această listă finală și să returneze elementele ca un șir separat printr-un spațiu: -1 -1 2 2 3 9
Exemple
Intrare: [5, 3, 1, 9, 7, 3, 4, 1]
Ieșire: -1 -1 -1 1 1 3 1
Intrare: [2, 4, 5, 1, 7]
Ieșire: -1 2 4 -1 1
funcția NearestSmallerValues(arr) {
const resultsArray = [];
arr.forEach((val, ind) => {
const preArray = arr.slice(0, ind).reverse();
resultsArray.push(preArray.find(item => item <= val) !== nedefinit ?
preArray.find(item => item <= val) : -1);
});
returnează rezultateArray.join(' ');
}
NearestSmallerValues(readline());
Spirală matriceală
Puneți funcția MatrixSpiral (strArr) să citească matricea de șiruri stocate în strArr care va reprezenta o matrice 2D N, iar programul dvs. ar trebui să returneze elementele
după imprimarea lor în sensul acelor de ceasornic, în ordine spirală. Ar trebui să returnați lista de elemente nou formată ca un șir cu numerele separate prin virgule. De exemplu: dacă
strArr este "[1, 2, 3]", "[4, 5, 6]", "[7, 8, 9]", atunci aceasta arată ca următoarea matrice 2D: 1 2 3
4 5 6
7 8 9
Deci, programul dvs. ar trebui să returneze elementele acestei matrice într-o ordine spirală în sensul acelor de ceasornic, care este:
1,2,3,6,9,8,7,4,5
Exemple
Intrare: ["[1, 2]", "[10, 14]"]
Ieșire: 1,2,14,10
Intrare: ["[4, 5, 6, 5]", "[1, 1, 2, 2]", "[5, 4, 2, 9]"]

Ieșire: 4,5,6,5,2,9,2,4,5,1,1,2
funcția MatrixSpiral(strArr) {
În primul rând, creați o serie de matrice de nuberi [ [ '1', '2', '3' ],
[ '4', '5', '6' ], [ '7', '8', '9' ]
strArr = strArr.map(val => {
returnează val.replace(/[\[\]\s]/g, '').split(',');
})
Apoi, creați un șir pentru a ține valorile

fie res = [];
fie titularul = [];
faceți o copie a matricei, pentru orice eventualitate;
fie arr = Array.from(strArr);
fie rightWall = (val) => {

res.push(val.pop());
};
fie leftWall = (val) => {

holder.push(val.shift());
};
în timp ce(arr.length) {
res.push(... arr.shift());
dacă (!arr.length) {
sparge;
}
arr.forEach(rightWall);
sparge;
}
res.push(... arr.pop().revers());
sparge;
}
arr.forEach(leftWall);
res.push(holder.reverse());
suport = [];
}
return res.join(',');
}

MatrixSpiral(readline());
Scindarea cuvintelor
Puneți funcția WordSplit (strArr) să citească matricea de șiruri stocate în strArr, care va conține 2 elemente: primul element va fi o secvență de caractere, iar al doilea element
va fi un șir lung de cuvinte separate prin virgulă, în ordine alfabetică, care reprezintă un dicționar de o anumită lungime arbitrară. De exemplu: strArr poate fi: ["hellocat",
"apple,bat,cat,goodbye,hello,yellow,why"]. Scopul dvs. este de a determina dacă primul element din intrare poate fi împărțit în două cuvinte, unde ambele cuvinte există în dicționarul
furnizat în a doua intrare. În acest exemplu, primul element poate fi împărțit în două cuvinte: salut și pisică, deoarece ambele cuvinte sunt în dicționar.
Programul dvs. ar trebui să returneze cele două cuvinte care există în dicționar separate printr-o virgulă. Deci, pentru exemplul de mai sus, programul dvs. ar trebui să returneze
salut,pisică. Va exista o singură modalitate corectă de a împărți primul element al caracterelor în două cuvinte. Dacă nu există nicio modalitate de a împărți șirul în două cuvinte care
există în dicționar, returnați șirul nu este posibil. Primul element în sine nu va exista niciodată în dicționar ca un cuvânt real.
Exemple
Intrare: ["baseball", "a,all,b,ball,bas,base,cat,code,d,e,quit,z"]
Ieșire: bază,minge
Intrare: ["abcgefd", "a,ab,abc,abcg,b,c,dog,e,efd,zzzz"]

Ieșire: abcg,efd
funcția WordSplit(strArr) {
fie target = strArr[0];
fie părți = strArr[1].split(/,/);
fie startere = [];
fie enders = [];
fie res = '';
parts.forEach(val => {
regEx1 = RegExp nou('\^${val}');
regEx2 = RegExp nou('${val}\$');
dacă (regEx1.test(țintă)) {
starters.push(val);
}
dacă (regEx2.test(țintă)) {
enders.push(val);
}
});
starters.forEach(start => {
enders.forEach(end => {
dacă (început + sfârșit === țintă) {
res = '${start},${end}';
}
})
})
returnare res || "nu este posibil";
}

WordSplit(readline());
Căutarea perechilor
Setați funcția PairSearching(num) să ia parametrul num transmis și să efectueze următorii pași. Mai întâi luați toate cifrele unice ale numărului de intrare (care va fi întotdeauna
un întreg pozitiv mai mare decât 1) și adăugați-le pe fiecare într-o listă. Apoi luați numărul de intrare și înmulțiți-l cu oricare dintre numerele sale întregi, apoi luați acest număr nou și
adăugați fiecare cifră la lista inițială. Continuați acest proces până când o pereche adiacentă cu același număr apare în listă. Programul ar trebui să returneze cel mai mic număr de
înmulțiri necesare pentru a găsi o pereche adiacentă de numere dublate.
De exemplu: dacă num este 134, atunci mai întâi adăugați fiecare număr întreg într-o listă: [1, 3, 4]. Acum, dacă luăm 134 și îl înmulțim cu 3 (care este unul dintre propriile sale
numere întregi), obținem 402. Acum, dacă adăugăm fiecare dintre aceste noi numere întregi la listă, obținem: [1, 3, 4, 4, 0, 2]. Am găsit o pereche adiacentă de numere duplicate, și
anume 4 și 4. Deci, pentru această intrare, programul dvs. ar trebui să returneze 1, deoarece a fost nevoie doar de 1 înmulțire pentru a găsi această pereche.
Un alt exemplu: dacă num este 46, atunci adăugăm aceste numere întregi într-o listă: [4, 6]. Dacă înmulțim 46 cu 6, obținem 276, și adăugând aceste numere întregi la lista pe care o
avem acum: [4, 6, 2, 7, 6]. Apoi, dacă luăm acest nou număr, 276, și îl înmulțim cu 2, obținem 552. Adăugând aceste numere întregi în listă obținem: [4, 6, 2, 7, 6, 5, 5, 2]. Prin
urmare, programul dvs. ar trebui să returneze 2, deoarece a fost nevoie de 2 înmulțiri pentru a găsi o pereche de numere duplicate adiacente (5 și 5 în acest caz).
Exemple
Intrare: 8
Ieșire: 3
Intrare: 198
Ieșire: 2
funcția PairSearching(num) {
fie numArray = [num];
fie count = 0;
fie steag = fals;
Fie căutare = (arr) => {

fie res = fals;
fie numsArr = [];
arr.forEach(val1 => {
fie numList = String(val1).split('');
numList.forEach(val2 => {
let product = val1 * Number(val2);
fie bigNumList =
numList.concat(String(product).split(''));
dacă (repeatNum(bigNumList)) {
res = adevărat;
} altceva {
numsArr.push(produs);
}
});
});
returnare res || numsArr;
}
fie repeatNum = (numArr) => {

pentru (fie i = 0, len = numArr.length; i < len - 1; i++) {
if (numArr[i] === numArr[i + 1]){
}
}
returnează fals;
}
în timp ce (!flag) {
număr++;
if (searching(numArray) === true) {
} altceva {
numArray = căutare(numArray);
}
}
}

PairSearching(readline());
Rezolvitor de ochelari
Puneți funcția BoggleSolver (strArr) să citească matricea de șiruri stocate în strArr, care va conține 2 elemente: primul element va reprezenta o matrice de litere 4x4, iar al
doilea element va fi un șir lung de cuvinte separate prin virgulă, fiecare de cel puțin 3 litere, în ordine alfabetică, care reprezintă un dicționar de o anumită lungime arbitrară. De
exemplu: strArr poate fi: ["rbfg, ukop, fgub, mnry", "bog,bop,gup,fur,ruk"]. Scopul tău este să determini dacă toate cuvintele separate prin virgulă ca al doilea parametru există în
matricea de litere 4x4. Pentru acest exemplu, matricea arată după cum urmează:r b f g u k o p
f g
u b
m n r y
Regulile pentru a face un cuvânt sunt următoarele:
1. Un cuvânt poate fi construit din puncte adiacente secvențial din matrice, unde adiacent înseamnă că se mișcă orizontal, vertical sau diagonal în orice direcție.
2. Un cuvânt nu poate folosi aceeași locație de două ori pentru a se construi.
Regulile sunt similare cu jocul lui Boggle . Deci, pentru exemplul de mai sus, toate cuvintele există în acea matrice, astfel încât programul dvs. ar trebui să returneze șirul adevărat.
Dacă toate cuvintele nu pot fi găsite, returnați un șir separat prin virgulă al cuvintelor care nu pot fi găsite, în ordinea în care apar în dicționar.
Exemple
Intrare: ["aaey, rrum, tgmn, ball", "all,ball,mur,raeymnl,tall,true,trum"]
Ieșire: adevărat
Intrare: ["aaey, rrum, tgmn, ball", "all,ball,mur,raeymnl,rumk,tall,true,trum,yes"]

Ieșire: rumk,da
funcția BoggleSolver(strArr) {
Formatarea grilei într-o matrice de matrice
gridArr = strArr[0].split(',').map(val => {
returnează val.trim().split('');
});
pune localArr aici pentru a-i oferi domeniul de aplicare în întreaga funcție
BoggleSolver
fie localArr = [];
Crearea unei matrice de termeni de căutare

let needleArr = strArr[1].split(',').map(val => {
returnează val.trim();
});
Crearea unei matrice de șiruri defecte

fie res = needleArr.filter(val => {
returnează !findWord(val);
});
retur res.length ? res.join(',') : 'adevărat';
-----------------Ajutoare-------------------
findWord verifică dacă cuvântul dat (str) se află în grilă
funcția findWord (str) {
Obțineți o copie proaspătă, independentă a matricei
localArr = makeArray(gridArr);
găsiți locațiile primei litere, returnați fals dacă niciuna

let hotSpots = findLetters(str[0]);
dacă (!hotSpots) {
returnează fals;
}
pentru (fie I = 1, len = str.length; i < len; i++) {

fie newSpots = [];
hotSpots.forEach(val => {
localArr[val[0]][val[1]] = '*';
newSpots.push(... adiacente[[val[0], val[1]], str[i]));
});
hotSpots = newSpots;
dacă (!hotSpots.length) {
returnează fals;
}
}
}
Adjacnts returnează o matrice a tuturor punctelor adiacente într-un punct dat

funcția adiacente (arr, char) {
fie res = [];
res.push(
[arr[0] - 1, arr[1]],
[arr[0] - 1, arr[1] + 1],
[arr[0], arr[1] + 1],
[arr[0] + 1, arr[1] + 1],
[arr[0] + 1, arr[1]],
[arr[0] + 1, arr[1] - 1],
[arr[0], arr[1] - 1],
[arr[0] - 1, arr[1] - 1]
);
res = res.filter(val => {
returnare val[0] >= 0 &&; val[1] >= 0 && val[0] <= 3 &&&val[1] <=
3;
}).filter(val => {
return localArr[val[0]][val[1]] === char;
});
retur res;
}
funcția findLetters(char) {
fie res = [];
pentru (fie rând = 0; rândul < 4; rând++) {
pentru (fie col = 0; col < 4; col++) {
if (gridArr[row][col] === char) {
res.push([rând, col]);
}
}
}
retur res.length ? res : nul;
}
funcția makeArray(arr) {
fie newArr = [];
arr.forEach(val => {
newArr.push(val.slice(0));
});
returnați newArr;
}
}
BoggleSolver(linie de citire());
Elemente HTML
Solicitați funcției HTMLElements(str) să citească parametrul str transmis, care va fi un șir de elemente HTML DOM și text simplu. Elementele care vor fi utilizate sunt: b, i,
em, div, p. De exemplu: dacă str este "<div><b><p>hello world</p></b></div>", atunci acest șir de elemente DOM este imbricat corect, astfel încât programul dvs. ar trebui să
returneze șirul adevărat.
Dacă un șir nu este imbricat corect, returnați primul element întâlnit unde, dacă este schimbat într-un alt element, ar avea ca rezultat un șir formatat corect. Dacă șirul nu este formatat
corect, atunci va fi doar un element care trebuie schimbat. De exemplu: dacă str este "<div><i>hello</i>world</b>", atunci programul dvs. ar trebui să returneze șirul div, deoarece
dacă primul element <div> ar fi schimbat într-un <b>, șirul ar fi formatat corect.
Exemple
Intrare: "<div><div><b></b></div></p>"
Ieșire: div
Intrare: "<div>abc</div><p><em><i>test test test</b></em></p>"

Ieșire: i
funcția HTMLElements(str) {
const inputArray = str.match(/(<\/?\w+>)/g);
const len = inputArray.length;
const HTMLStack = [];
parcurgeți lista de elemente și împingeți-le pe stivă sau trageți
dacă închideți etichetele.
const isOpenTag = ! (/\//.test(inputArray[i]));
const tag = inputArray[i].replace(/[<>/]/g, '');
dacă (isOpenTag) {
HTMLStack.push(etichetă);
} altceva {
const popped = HTMLStack.pop();
dacă (etichetă !== popped) {
întoarcerea a apărut;
}
}
}
returna HTMLStack.length ? HTMLStack.pop() : adevărat;
}

HTMLElements(readline());
Lipsește cifra II
Puneți funcția MissingDigitII(str) să ia parametrul str, care va fi o formulă matematică simplă cu trei numere, un singur operator (+, -, * sau /) și un semn egal (= ) și să
returneze cele două cifre care completează ecuația. În două dintre numerele din ecuație, va exista un singur ?și programul dvs. ar trebui să determine ce cifre lipsesc și să le returneze
separate printr-un spațiu. De exemplu, dacă str este "38?5 * 3 = 1?595", atunci programul dvs. ar trebui să producă 6 1.
De ?Caracterul va apărea întotdeauna atât în primul număr, cât și în ultimul număr din expresia matematică. Va exista întotdeauna o soluție unică.
Exemple
Intrare: "56? * 106 = 5?678"
Ieșire: 3 9
Intrare: "18?1 + 9 = 189?"

Ieșire: 8 0
funcția MissingDigitII(str) {
pentru (fie i = 0; i <= 9; i++) {
pentru (fie j = 0; j <= 9; j++) {
fie newStr = str.replace(/\?/, String(i)).replace(/\?/,
String(j)).replace(/=/, '===');
dacă (eval(newStr)) {
returnează '${i} ${j}';
}
}
}
}

MissingDigitII(readline());
Subșir palindromic
Puneți funcția PalindromicSubstring(str) să ia parametrul str transmis și să găsească cel mai lung subșir palindromic, ceea ce înseamnă cel mai lung subșir care este citit la
fel înainte ca și înapoi. De exemplu: dacă str este "abracecars", atunci programul dvs. ar trebui să returneze mașina de curse cu șir, deoarece este cel mai lung palindrom din șirul de
intrare.
Intrarea va conține numai caractere alfabetice minuscule. Cel mai lung subșir palindromic va fi întotdeauna unic, dar dacă nu există niciunul mai lung de 2 caractere, returnați șirul
niciunul.
Exemple
Intrare: "hellosannasmith"
Ieșire: sannas
Intrare: "abcdefgg"
Ieșire: nici unul
funcția PalindromicSubstring(str) {
pentru (fie i = str.length; i > 2; i--) {
pentru (fie j = 0, len = str.length; j <= len - i; j++) {
fie newSlice = str.substr(j, i);
dacă (isPalindrome(newSlice)) {
returnați newSlice;
}
}
}
returnează "niciunul";
}
funcția isPalindrome(str) {
retur str === str.split('').reverse().join('');
}

PalindromicSubstring(readline());
Captarea apei
Funcția TrappingWater(arr) ia matricea de numere întregi nenegative stocate în arr și determină cea mai mare cantitate de apă care poate fi prinsă. Numerele din matrice
reprezintă înălțimea unei clădiri (unde lățimea fiecărei clădiri este 1) și dacă vă imaginați că plouă, apa va fi prinsă între cele mai înalte două clădiri. De exemplu: dacă arr este [3, 0,
0, 2, 0, 4] atunci această matrice de înălțimi ale clădirii arată ca următoarea imagine dacă o desenăm:
Acum, dacă vă imaginați că plouă și apa este prinsă în această imagine, atunci va arăta ca următoarea (x-urile reprezintă apa):
Aceasta este cea mai mare cantitate de apă care poate fi prinsă în această imagine, și dacă calculați suprafața obțineți 10, deci programul dvs. ar trebui să returneze 10.
Exemple
Intrare: [1, 2, 1, 2]
Ieșire: 1
Intrare: [0, 2, 4, 0, 2, 1, 2, 6]
Ieșire: 11
funcția TrappingWater(arr) {
contor fie = 0;
pentru (fie i = 1, len = arr.length; i < len - 1; i++) {
fie hotSpot = arr[i];
fie preWall = Math.max(... arr.felie(0, i));
fie postWall = Math.max(... arr.felie(i + 1));
let height = Math.min(preWall, postWall);
if (hotSpot < înălțime) {
contor += (înălțime - hotSpot);
}
}
contor de retur;
}
Captarea apei(linie de citire());
Calea matricei
Puneți funcția MatrixPath (strArr) să ia parametrul strArr care va fi o matrice 2D de 0 și 1 de o anumită dimensiune arbitrară și să determine dacă există o cale de 1 din partea
stângă sus a matricei în partea dreaptă jos a matricei în timp ce se deplasează numai în direcțiile: sus, jos, stânga și dreapta. Dacă există o cale, programul ar trebui să returneze șirul
adevărat, altfel programul ar trebui să returneze numărul de locații din matrice unde, dacă un singur 0 este înlocuit cu un 1, o cale de 1 va fi creată cu succes. Dacă nu există o cale și
nu puteți crea o cale schimbând o singură locație din matrice de la 0 la 1, atunci programul dvs. ar trebui să returneze șirul nu este posibil. De exemplu: dacă strArr este ["11100",
"10011", "10101", "10011"] atunci aceasta arată ca următoarea matrice:
1110010011101010
0 1 1 Pentru intrarea de mai sus, nu există o cale de 1
din stânga sus în dreapta jos. Dar, putem schimba un 0 la un 1 din 2 locuri din matrice, și anume la locațiile: [0,3] sau [1,2]. Deci, pentru această intrare, programul dvs. ar trebui să
returneze 2. Partea stângă sus și dreapta jos a matricei de intrare vor fi întotdeauna 1.
Exemple
Intrare: ["10000", "11011", "10101", "11001"]
Ieșire: 1
Intrare: ["1000001", "1001111", "1010101"]
Ieșire: imposibil
funcția MatrixPath(strArr) {
let width = strArr[0].length;
fie înălțime = strArr.length;
Creați o copie a matricei noastre, pentru orice eventualitate.
fie newArr = copyArray(strArr);
Creați un punct de plecare
newArr[înălțime - 1][lățime - 1] = 'T'
să se oprească = fals;
în timp ce(adevărat) {
let testArr = copyArray(newArr);
pentru (fie i = 0; i < înălțime; i++) {
pentru (fie j = 0; j < lățime; j++) {
if (testArr[i][j] === '1' && isAdjacent('T', testArr, [i,
j])) {
testArr[i][j] = 'T';
} else if (testArr[i][j] === '0' && isAdjacent('T',
testArr, [i, j])) {
testArr[i][j] = 'F';
}
}
}
if (isEqualArray(testArr, newArr)) {
newArr = testArr;
sparge;
}
newArr = testArr;
}
if (newArr[0][0] === 'T') {

returnați "adevărat";
}
newArr[0][0] = 'G'
în timp ce(adevărat) {
let testArr = copyArray(newArr);
if (testArr[i][j] === '1' && isAdjacent('G', testArr, [i,
j])) {
testArr[i][j] = 'G';
} else if (testArr[i][j] === '0' && isAdjacent('G',
testArr, [i, j])) {
testArr[i][j] = 'F';
}
}
}
if (isEqualArray(testArr, newArr)) {
newArr = testArr;
sparge;
}
newArr = testArr;
}
contor fie = 0;

dacă (newArr[i][j] === 'F' && isAdjacent('G', newArr, [i, j]) &&
isAdjacent('T', newArr, [i, j])) {
contor ++;
}
}
}
contor de retur ? contor: "nu este posibil";
-------------Ajutoare------------------------------
// isAdjacent returnează true dacă matricea conține caracterul desemnat

într-o poziție
// adiacent poziției desemnate
funcția isAdiacent (char, arr, poziție) {
returnare [
[poziție[0] - 1, poziție[1]],
[poziție[0], poziție[1] + 1],
[poziție[0] + 1, poziție[1]],
[poziție[0], poziție[1] - 1]
].filter(val => {
întoarcere (val[0] >= 0 &&; val[0] < înălțime &&&val[1] >= 0
&&&val[1] lățime <);
}).some(val => {
aranjament de întoarcere[val[0]][val[1]] === char;
});
}
copyArray face o copie nouă a unei matrice cu 2 adâncimi

funcția copyArray (arr) {
return Array.from(arr).map((val, ind) => {
returnează Array.from(arr[ind]);
});
}
isEqualArray verifică dacă două matrice cu 2 adâncimi au elemente identice

funcția isEqualArray (arr1, arr2) {
fie înălțime = arr1.length;
fie lățime = arr1[0].length;
dacă (arr1[i][j] !== arr2[i][j]) {
returnează fals;
}
}
}
}
întoarcere strArr;
}

MatrixPath(readline());
Așezarea elevilor
Puneți funcția SeatingStudents(arr) să citească matricea de numere întregi stocate în arr care va fi în următorul format: [K, r1, r2, r3, ...] unde K reprezintă numărul de bănci
dintr-o clasă, iar restul numerelor întregi din matrice vor fi în ordine sortată și vor reprezenta băncile care sunt deja ocupate. Toate birourile vor fi aranjate în 2 coloane, unde biroul #1
este în stânga sus, biroul #2 este în dreapta sus, biroul #3 este sub #1, biroul #4 este sub #2 etc. Programul dvs. ar trebui să returneze numărul de moduri în care 2 elevi pot fi așezați
unul lângă celălalt. Aceasta înseamnă că 1 elev este în stânga și 1 elev în dreapta sau 1 elev este direct deasupra sau dedesubtul celuilalt student.
De exemplu: dacă arr este [12, 2, 6, 7, 11] atunci această sală de clasă arată ca următoarea imagine:
Pe baza aranjamentului de mai sus al băncilor ocupate, există un total de 6 moduri de a așeza 2 studenți noi unul lângă celălalt. Combinațiile sunt: [1, 3], [3, 4], [3, 5], [8, 10], [9, 10],
[10, 12]. Deci, pentru această intrare, programul dvs. ar trebui să returneze 6. K va varia de la 2 la 24 și va fi întotdeauna un număr par. După K, numărul de birouri ocupate din
matrice poate varia de la 0 la K.
Exemple
Intrare: [6, 4]
Ieșire: 4
Intrare: [8, 1, 8]
Ieșire: 6
funcția SeatingStudents(arr) {
const numScaune = arr[0];
const ocupat = arr.felie(1);
contor fie = 0;
pentru (fie i = 1; i <= numSeats; i++) {
dacă (!occupied.includes(i)) {
dacă (!occupied.includes(i - 2) &&; i > 2) {
contra++;
}
dacă (!occupied.includes(i + 2) &&; i < (numSeats - 1)) {
contra++;
}
Dacă [((i % 2 === 1) && !occupied.includes(i + 1)) || ((i % 2 ===
0) && !occupied.includes(i - 1))) {
contra++;
}
}
}
contor retur / 2;
}
SeatingStudents(readline());
Cea mai lungă cale matriceală
Puneți funcția LongestMatrixPath (strArr) să ia matricea de șiruri stocate în strArr, care va fi o matrice NxM de numere întregi pozitive cu o singură cifră și să găsească cea
mai lungă cale crescătoare compusă din numere întregi distincte. Când vă deplasați prin matrice, puteți merge doar în sus, în jos, la stânga și la dreapta. De exemplu: dacă strArr
este ["345", "326", "221"], atunci aceasta arată ca următoarea matrice:3 4 5 3 2 6
2 2 1 Pentru intrarea de mai sus, cea mai lungă cale de creștere merge de la: 3 -> 4 -> 5
-> 6.
Programul dvs. ar trebui să returneze numărul de conexiuni în cea mai lungă cale, prin urmare, pentru această intrare, programul dvs. ar trebui să returneze 3. S-ar putea să nu existe
neapărat întotdeauna o cale mai lungă în matrice.
Exemple
Intrare: ["12256", "56219", "43215"]
Ieșire: 5
Intrare: ["67", "21", "45"]

Ieșire: 3
funcția LongestMatrixPath(strArr) {
Vom trece prin fiecare număr și vom returna cel mai mare rezultat
Rezultatul va păstra acest număr și va fi valoarea returnată.
fie returnVal = 0;
strArr = strArr.map(val => {
returnează val.split('');
})
Parcurgeți întreaga grilă și găsiți lungimea pentru fiecare loc, după

Apelarea crawlerului
fie val = crawler([[strArr[i][j], [i, j]]]);
returnVal = Math.max(returnVal, val);
}
}
returnare returnVal;
------------------------Ajutoare----------------------------------
adiacent ia o poziție pe grilă și returnează pozițiile adiacente
funcția adjacents(pos) {
fie newPositions = [
[pos[0], pos[1] + 1],
[pos[0], pos[1] - 1],
[pos[0] + 1, pos[1]],
[POS[0] - 1, POS[1]]
].filter (val => {
întoarcere val[0] >= 0 &&&val[1] >= 0 && val[0] < înălțime
&&&val[1] lățime <;
})
returnați noi poziții;
}
Aceasta este funcția principală în care se fac lucrurile. Nu trebuie să ne
facem griji
mergând înapoi, deoarece trebuie să creștem întotdeauna. Deci, vedem doar ce
este posibil
Următorii pași sunt și renunțați atunci când nu mai sunt.
funcția crawler(arr) {
contor fie = 0;
în timp ce(arr.length) {
fie newArr = [];
fie POS = val[1];
fie newPos = adjacents(pos).filter(val => {
return strArr[pos[0]][pos[1]] < strArr[val[0]]
[val[1]];
}).map(val => {
return [strArr[val[0]][val[1]], val];
});
newArr.push(... newPos);
});
dacă (newArr.length) {
contra++;
}
arr = newArr;
}
contor de retur;
}
}

LongestMatrixPath(readline());
Subșir fereastră min
Puneți funcția MinWindowSubstring(strArr) să ia matricea de șiruri stocate în strArr, care va conține doar două șiruri, primul parametru fiind șirul N și al doilea parametru
fiind un șir K al unor caractere, iar scopul dvs. este să determinați cel mai mic subșir al lui N care conține toate caracterele din K. De exemplu: dacă strArr este ["aaabaaddae",
"aed"] atunci cel mai mic subșir al lui N care conține caracterele a, e și d este "dae" situat la sfârșitul șirului. Deci, pentru acest exemplu, programul dvs. ar trebui să returneze șirul
dae.
Un alt exemplu: dacă strArr este ["aabdccdbcacd", "aad"] atunci cel mai mic subșir al lui N care conține toate caracterele din K este "aabd" care se află la începutul șirului. Ambii
parametri vor fi șiruri de caractere variind în lungime de la 1 la 50 de caractere și toate caracterele lui K vor exista undeva în șirul N. Ambele șiruri vor conține numai caractere
alfabetice minuscule.
Exemple
Intrare: ["ahffaksfajeeubsne", "jefaa"]
Ieșire: aksfaje
Intrare: ["aaffhkksemckelloe", "fhea"]

Ieșire: affhkkse
funcția MinWindowSubstring(strArr) {
fie str = strArr[0];
let needle = strArr[1].split('');
Începeți cu cele mai mici subșiruri posibile, apoi mergeți în sus

pentru (fie i = ac.length, len = str.length; i <= len; i++) {
pentru (j = 0; j <= len - i; j++) {
fie mySlice = str.substr(j, i);
dacă (isContained(mySlice)) {
returnați mySlice;
}
}
}
returnați "Nu în șir";
----------------------Ajutoare-----------------------------
isContained verifică dacă toate caracterele din ac se află în șirul dat
funcția isContained(str) {
fie arr = str.split('');
pentru (fie i = 0, len = ac.length; i < len; i++) {
let place = arr.findIndex(val => {
Val de întoarcere === ac[i]
});
dacă (locul === -1) {
returnează fals;
} altceva {
arr.splice(locul, 1);
}
}
}
}

MinWindowSubstring(readline());
Lanțuri matriceale
Puneți funcția MatrixChains(arr) să citească matricea de numere întregi pozitive stocate în arr, unde fiecare pereche va reprezenta o matrice NxM. De exemplu: dacă arr este
[1, 2, 3, 4] înseamnă că aveți o matrice 1x2, 2x3 și 3x4. Deci, există matrice totale N-1 unde N este lungimea matricei. Scopul dvs. este de a determina cel mai mic număr de înmulțiri
posibil după înmulțirea tuturor matricelor. Înmulțirea matriceală este asociativă astfel încât (A*B)*C este egal cu A*(B*C).
Pentru exemplul de mai sus, să presupunem că următoarele litere reprezintă diferitele matrice: A = 1x2, B = 2x3 și C = 3x4. Apoi putem înmulți matricele în următoarele ordine:
(AB)C sau A(BC). Prima comandă necesită (1*2*3) = 6, apoi înmulțim această nouă matrice 1x3 cu matricea 3x4 și obținem (1*3*4) = 12. Deci, în total, această ordonare a necesitat
6 + 12 = 18 înmulțiri. Prin urmare, programul dvs. ar trebui să returneze 18, deoarece a doua comandă produce mai multe înmulțiri. Matricea de intrare va conține între 3 și 30 de
elemente.
Exemple
Intrare: [2, 3, 4]
Ieșire: 24
Intrare: [1, 4, 5, 6, 8]
Ieșire: 98
funcția MatrixChains(arr) {
fie newArr = Array.from(arr);
contor fie = 0;
fie index = 0;
pentru (fie i = 0, len = newArr.length; i < len; i++) {
if (arr[i] < newArr[index]) {
indice = i;
}
}
consolă.log("index", index);
Înmulțiți la dreapta din indice, în măsura în care este posibil
moveRight(index);
Înmulțiți la stânga din index, în măsura în care este posibil
moveLeft(index);
dacă (newArr.length === 3) {

contor += newArr[0] * newArr[1] * newArr[2];
}
contor de retur;
-------------------Ajutoare-----------------------------------
preia cea mai mică valoare și înmulțește matricele îndreptate spre dreapta
funcția moveRight(index) {
consolă.log("dreapta");
fie mutare = newArr.length - indice > 2;
în timp ce(mutare) {
contor += newArr[index] * newArr[index + 1] * newArr[index + 2];
newArr.splice(indice + 1, 1);
if (newArr.length - index === 2) {
mutare = fals;
}
}
}
ia cea mai mică valoare și înmulțește mergând spre stânga
funcția moveLeft(index) {
consolă.log('stânga', index);
fie mutare = index > 1;
în timp ce(mutare) {
contor += newArr[index] * newArr[index - 1] * newArr[index - 2];
newArr.splice(indice - 1, 1);
index--;
dacă (newArr.length === 3) {
mutare = fals;
}
}
}
}

MatrixChains(readline());
Zona histogramei
Puneți funcția HistogramArea(arr) să citească matricea de numere întregi nenegative stocate în arr care va reprezenta înălțimile barelor pe un grafic (unde fiecare lățime a
barei este 1) și să determine cea mai mare suprafață de sub întregul grafic cu bare. De exemplu: dacă arr este [2, 1, 3, 4, 1], atunci acesta arată ca următorul grafic cu bare:
Puteți vedea în graficul cu bare de mai sus că cea mai mare zonă de sub grafic este acoperită de x. Suprafața acelui spațiu este egală cu 6, deoarece întreaga lățime este 2 și înălțimea
maximă este 3, deci 2 * 3 = 6. Programul dvs. ar trebui să returneze 6. Matricea va conține întotdeauna cel puțin 1 element.
Exemple
Intrare: [6, 3, 1, 4, 12, 4]
Ieșire: 12
Intrare: [5, 6, 7, 4, 1]
Ieșire: 16
funcția HistogramArea(arr) {
fie maxRes = 0, len = arr.length;
pentru (fie i = 1; i <= len; i++) {
pentru (fie j = 0; j <= len - i; j++) {
fie arrSlice = arr.slice(j, j + i);
fie aria = i * Math.min(... arrSlice);
maxRes = Math.max(suprafață, maxRes);
}
}
returnează maxRes;
}

HistogramArea(readline());
Potrivirea caracterelor
Funcția MatchingCharacters(str) preia parametrul str transmis și determină cel mai mare număr de caractere unice care există între o pereche de litere potrivite oriunde în
șir. De exemplu: dacă str este "ahyjakh", atunci există doar două perechi de litere potrivite, cele două a și cele două h. Între perechea de a există 3 caractere unice: h, y și j. Între h
există 4 caractere unice: y, j, a și k. Deci, pentru acest exemplu, programul dvs. ar trebui să returneze 4.
Un alt exemplu: dacă str este "ghececgkaem", atunci programul dvs. ar trebui să returneze 5, deoarece cele mai unice caractere există în cea mai îndepărtată pereche de caractere e.
Este posibil ca șirul de intrare să nu conțină perechi de caractere și, în acest caz, programul ar trebui să returneze 0. Intrarea va consta numai din caractere alfabetice minuscule.
Exemple
Intrare: "mmmerme"
Ieșire: 3
Intrare: "abccdefghi"
Ieșire: 0
funcția MatchingCharacters(str) {
maxRes = 0;
fie len = str.length;
pentru (fie i = 0; i < len - 1; i++) {
let end = str.lastIndexOf(str[i]);
fie mySlice = str.slice(i + 1, sfârșit);
maxRes = Math.max(maxRes, countUniq(mySlice));
}
returnează maxRes;
funcția countUniq(str) {
fie arr = str.split('');
fie mySet = set nou(arr);
returnați mySet.size;
}
}

MatchingCharacters(readline());
Convertor ternar
Puneți funcția TernaryConverter(num) să ia parametrul num trecut, care va fi întotdeauna un întreg pozitiv, și să-l convertească într-o reprezentare ternară . De exemplu: dacă
num este 12, atunci programul ar trebui să returneze 110.
Exemple
Intrare: 21
Ieșire: 210
Intrare: 67
Ieșire: 2111
Următoarele profită de metoda javascript încorporată
dar este un fel de înșelăciune
funcția TernaryConverter(num) {
pur și simplu profitând de o capacitate încorporată JavaScript;
// returnează num.toString(3);
//}
Alternativ, făcând de fapt ceva muncă

funcția TernaryConverter(num) {
Aflați ce putere maximă de trei se potrivește în num
fie powNum = Math.floor(Math.log(num) / Math.log(3));
fie res = '';
pentru (fie i = powNum; i >= 0; i--) {

fie nextDigit = Math.trunc(num / 3 ** i);
num = num % (3 ** i);
res += nextDigit;
}
retur res;
}

TernaryConverter(linie de citire());
Congruență liniară
Puneți funcția LinearCongruence(str) să citească parametrul str trecut, care va fi o ecuație liniară de congruență sub forma: "ax = b (mod m)" Scopul tău este să rezolvi pentru
x și să returnezi numărul de soluții la x. De exemplu: dacă str este "32x = 8 (mod 4)", atunci programul dvs. ar trebui să returneze 4, deoarece răspunsurile la această ecuație pot fi 0,
1, 2 sau 3.
Exemple
Intrare: "12x = 5 (mod 2)"
Ieșire: 0
Intrare: "12x = 4 (mod 2)"

Ieșire: 2
funcția LinearCongruence(str) {
fie componente = str.match(/^(\d+)x\D+(\d+)\D+(\d+)\)$/);
fie multiplicator = componente[1];
factor let = componente[2];
fie mod = componente[3];
contor fie = 0;
pentru (fie i = 0; i < mod; i++) {

dacă (((multiplicator * i - factor) % mod) === 0) {
contra++;
}
}
contor de retur;
}

Congruență liniară(linie de citire());
Număr formatat
Solicitați funcției FormattedNumber (strArr) să ia parametrul strArr trecut, care va conține doar un singur element și să returneze șirul true dacă este un număr valid care
conține doar cifre cu zecimale și virgule plasate corect, altfel returnați șirul false. De exemplu: dacă strArr este ["1.093.222,04"], atunci programul dvs. ar trebui să returneze șirul
adevărat, dar dacă intrarea ar fi ["1.093,22.04"], atunci programul dvs. ar trebui să returneze șirul false. Datele introduse pot conține alte caractere decât cifrele.
Exemple
Intrare: ["0.232567"]
Ieșire: adevărat
Intrare: ["2,567.00.2"]
Ieșire: false
funcția FormattedNumber(strArr) {
const strNum = strArr[0];
const hasDecimal = strNum.includes('.');
const pattern = hasDecimal ? /^(?:\ d{0,3})(?:,\d{3})*\.\d*$/ : /^(?:\ d{0,3})
(?:,\d{3})*$/;
model de returnare.test(strNum);
}

FormattedNumber(readline());
Cea mai mare coloană de rânduri
Puneți funcția LargestRowColumn(strArr) să citească parametrul strArr transmis, care va fi o matrice 2D de o anumită dimensiune arbitrară umplută cu numere întregi
pozitive. Scopul tău este să determini cel mai mare număr care poate fi găsit prin adunarea a trei cifre din matrice care se află pe aceeași cale, unde a fi pe aceeași cale înseamnă a
porni de la unul dintre elemente și apoi a trece fie în sus, în jos, la stânga sau la dreapta pe elementul următor fără a reutiliza elementele. Cu toate acestea, o avertizare, și anume atunci
când calculați suma a trei cifre, ar trebui să împărțiți suma în două cifre și să tratați noile cifre ca o poziție rând / coloană în matrice. Deci, scopul tău este de fapt să găsești suma de
trei cifre care însumează cea mai mare poziție din matrice fără a ieși din limite. De exemplu: dacă strArr este ["345", "326", "221"] atunci aceasta arată ca următoarea matrice:
34 5
3 2 6
2 2 1
Soluția la această problemă este de a însuma elementele îngroșate, 4 + 2 + 6, care este egal cu 12. Apoi luați soluția, 12, și o împărțiți în două cifre: 1 și 2 care reprezintă rândul 1,
coloana 2 din matrice. Aceasta este cea mai mare poziție pe care o puteți obține în matrice prin adăugarea a 3 cifre, astfel încât programul dvs. ar trebui să returneze 12. Dacă, de
exemplu, ați aduna 4 + 5 + 6 în matrice, veți obține 15 care este mai mare decât 12, dar rândul 1, coloana 5 este în afara limitelor. De asemenea, nu este posibil cu matricea curentă să
se însumeze la oricare dintre următoarele numere: 20, 21, 22. Dacă găsiți o sumă care este doar o singură cifră, o puteți trata ca rândul 0, coloana N, unde N este suma dvs.
Exemple
Intrare: ["234", "999", "999"]
Ieșire: 22
Intrare: ["11111", "22222"]

Ieșire: 4
funcția LargestRowColumn(strArr) {
let matrix = strArr.map(row => row.split(''));
const adjacentElements = [
[[1, 0], [0, 1]], // (un drept), (unul jos)
[[1, 0], [2, 0]], // dreptul
[[1, 0], [1, 1]], // chiar în jos
[[0, 1], [1, 1]], // dreapta jos
[[0, 1], [0, 2]], // jos
[[0, -1], [-1, 0]] // (unul sus), (unul la stânga)
];
fie cea mai mareValoare = 0;

fie largestSum = 0;
Făcut rapid și foarte dezordonat, vă rugăm să nu vă uitați. :)
matrix.forEach((rând, rowIndex) => {

row.forEach((col, colIndex) => {
adjacentElements.forEach(ae => {
consolă.log(AE);
const combos = [];
combos.push(matrice[rowIndex][colIndex]);
dacă (
rowIndex + ae[0][1] < matrix.length &&
rowIndex + ae[0][1] >= 0 &&
colIndex + ae[0][0] < matrice[0].length &&
colIndex + ae[0][0] >= 0
) {
combos.push(
matrice[rowIndex + ae[0][1]][colIndex + ae[0][0]]
);
}
dacă (
rowIndex + ae[1][1] < matrix.length &&
rowIndex + ae[1][1] >= 0 &&
colIndex + ae[1][0] < matrice[0].length &&
colIndex + ae[1][0] >= 0
) {
combos.push(
matrice[rowIndex + ae[1][1]][colIndex + ae[1][0]]
);
}
dacă (combos.length === 3) {

fie sumThreeStr = combo-uri
.reduce((sumă, num) => (sumă += număr(num)), 0)
.toString();
Acum împărțiți cifrele sumei și verificați valoarea reală în

matrice
lăsați newRow, newCol;
dacă (sumThreeStr.length === 1) {
newRow = 0;
newCol = Număr(sumThreeStr[0]);
} altceva {
[newRow, newCol] = sumThreeStr.split('');
}
dacă (
newRow >= 0 &&
newRow < matrix.length &&
nouCol >= 0 &&
newCol < matrice[0].length
) {
fie value = matrice[newRow][newCol];
dacă (
// ??? Spec spune să folosești cea mai mare valoare, dar
nu reușește
teste dacă fac acest lucru?
valoare >= cea mai marevaloare &&
Număr(sumThreeStr) > largestSum
) {
largestValue = valoare;
largestSum = Număr(sumThreeStr);
}
}
}
});
});
});
consolă.log(largestValue, largestSum);
returnați cea mai mareSumă;

}

LargestRowColumn(readline());
funcția LargestRowColumn(strArr) {
let helpers = helperMethods();
modificați strArr la o matrice de matrice de rânduri

let newArr = helpers.reviseArr(strArr);
fie allSums = [];

allSums.push(... helpers.createSums([i, j]));
}
}
allSums = helpers.uniqArr(allSums).sort((val1, val2) => {return val1 - val2});
Crearea unei matrice de sume, convertite în poziții matrice

let convertedSums = helpers.convertSums(allSums);
Eliminați toate punctele care nu există în grilă

fie qualifyingSums = convertedSums.filter(val => {
return parseInt(val[0], 10) < înălțime && parseInt(val[1], 10) < lățime;
});
returnează parseInt(qualifyingSums.pop().join(''));
funcția helperMethods() {
întoarcere {
Arondisment: [],
Returnarea unei matrice dezbrăcate de toate elementele dublate

uniqArr(arr) {
fie mySet = set nou(arr);
returnați Array.from(mySet);
},
Conversia ARR într-o matrice care conține numere întregi

reviseArr(arr) {
fie newArr = [];
newArr.push(val.split('').map(val => {
returnează parseInt(val, 10);
}));
});
returnează this.arr = newArr;
},
Introduceți un punct și obțineți toate punctele adiacente valide

getPoints(punct) {
returnare [
[punct[0] + 1, subpunct[1]],
[punct[0] - 1, punct[1]],
[punct[0], punct[1] + 1],
[punct[0], punct[1] - 1]
].filter(val => {
returnare val[0] >= 0 &&; val[0] < this.arr.length &&
val[1] >= 0 &&&val[1] < this.arr[0].length;
})
},
dat un punct, returnați o matrice sortată de valori obținute de

Adunarea numerelor în punctele adiacente
createSums(punct) {
fie nextPoints = this.getPoints(punct);
fie titularul = [];
nextPoints.forEach(val => {
termPoints = this.getPoints(val).filter(val2 => {
întoarcere (val2[0] !== punct[0] || val2[1] !==
punct[1]);
});
termPoints.forEach(val3 => {
holder.push(this.arr[punct[0]][punct[1]] +
this.arr[val[0]][val[1]] + this.arr[val3[0]][val3[1]]);
});
});
returnează this.uniqArr(holder).sort((val1, val2) => { return
val1 - val2});
},
convertSums(sums) {
returnează sums.map(val => {
fie str = val.toString();
Intoarcere Str.Lungime === 1 ? '0' + str : str;
}).map(val => {
returnează [val[0], val[1]];
});
}
}
}

LargestRowColumn(readline());
Opt regine
Puneți funcția EightQueens (strArr) să citească strArr, care va fi o matrice constând din locațiile a opt regine pe o tablă de șah standard 8x8, fără alte piese pe tablă. Structura
strArr va fi următoarea: ["(x,y)", "(x,y)", ...] unde (x,y) reprezintă poziția reginei actuale pe tabla de șah (x și y vor varia ambele de la 1 la 8, unde 1,1 este partea stângă jos a tablei
de șah și 8,8 este partea dreaptă sus). Programul dvs. ar trebui să determine dacă toate reginele sunt plasate în așa fel încât niciuna dintre ele să nu se atace reciproc. Dacă acest lucru
este valabil pentru intrarea dată, returnați șirul true altfel returnați prima regină din listă care atacă o altă piesă în același format în care a fost furnizată.
De exemplu: dacă strArr este ["(2,1)", "(4,2)", "(6,3)", "(8,4)", "(3,5)", "(1,6)", "(7,7)", "(5,8)"] atunci programul dvs. ar trebui să returneze șirul adevărat. Tabla de șah
corespunzătoare reginelor pentru această intrare este mai jos (preluată de pe Wikipedia ).
Exemple
Intrare: ["(2,1)", "(4,3)", "(6,3)", "(8,4)", "(3,4)", "(1,6)", "(7,7)", "(5,8)"]
Ieșire: (2,1)
Intrare: ["(2,1)", "(5,3)", "(6,3)", "(8,4)", "(3,4)", "(1,8)", "(7,7)", "(5,8)"]

Ieșire: (5,3)
const helpers = {};

funcția EightQueens(strArr) {
remediați datele ca o matrice de arraySetup
const newArr = helpers.arraySetup(strArr);
const len = newArr.length;
pentru (fie j = 1 + i; j < len; j++) {
if (helpers.isAttacking(newArr[i], newArr[j])) {
return '(${newArr[i].slice(0, 2)})';
}
}
}
}
Object.assign(ajutoare, {
arraySetup(strArr) {
return strArr.map(val => JSON.parse(val
.replace(/$/g, '[')
.replace(/$/g, ']')));
},
isAttacking(pos1, pos2) {
Retur (POS1[0] === POS2[0] ||
POS1[1] === POS2[1] ||
Math.abs(pos1[0] - pos2[0]) === Math.abs(pos1[1] - pos2[1]));
}
});
EightQueens(readline());
Structura strArr va fi următoarea: ["(x,y)", "(x,y)", ...]

Acest lucru pare a fi greșit ... În exemplu arată y, x
funcția EightQueens(strArr) {
fie firstMatch = null;

fie potriviri = strArr.some(function(loc, index) {
dacă (canAttack(strArr, loc[1], loc[3])) {
firstMatch = index;
}
});
dacă (potriviri) {
returnează strArr[firstMatch];
}
funcția canAttack(strArr, x, y) {
return strArr.some(function(loc){
fie coorduri = loc.substr(1, loc.length-2).split(',');
Verificați aceeași piesă
if (coorduri[0] === x &; coorduri[1] === y) {
returnează fals;
}
Verificați dacă există mișcări orizontale
dacă (coorduri[0] === x) {
}
Verificați dacă există mișcări verticale
dacă (coorduri[1] === y) {
}
Verificați dacă există mișcări diagonale
if (Math.abs(coords[0] - x) === Math.abs(coords[1] - y)) {
}
returnează fals;
});

EightQueens(readline());
Trei puncte
Puneți funcția ThreePoints (strArr) să citească matricea de șiruri stocate în strArr care va conține întotdeauna 3 elemente și va fi sub forma: ["(x1,y1)", "(x2,y2)", "(x3,y3 )"].
Scopul tău este să creezi mai întâi o linie formată din primele două puncte (care începe din primul punct și se mișcă în direcția celui de-al doilea punct și care se întinde în ambele
direcții prin cele două puncte) și apoi să determini pe ce parte a liniei se află punctul 3. Rezultatul va fi fie dreapta, fie stânga, fie niciuna. De exemplu: dacă strArr este ["(1,1)",
"(3,3)", "(2,0)"] atunci programul dvs. ar trebui să returneze șirul la dreapta, deoarece al treilea punct se află la dreapta liniei formate de primele două puncte.
Exemple
Intrare: ["(0,-3)", "(-2,0)", "(0,0)"]
Ieșire: dreapta
Intrare: ["(0,0)", "(0,5)", "(0,2)"]

Ieșire: nici
funcția ThreePoints(strArr) {
Analizați intrarea
const [pointA, pointB, pointX] = strArr.map(point => {
const [, x, y] = point.match(/\$(-?[ \\d]+),(-?[ \\d]+)\$/).map(Număr);
returnează { x, y };
});
y = MX + B
panta const = (punctB.y - punctA.y) / (punctB.x - punctA.x); m
const yIntercept = (punctA.y - pantă) / punctA.x; b
x = (y - b) / m
fie x;
dacă (pantă === Infinit) {
x = punctX.x;
} altceva {
x = pointX.y - yIntercept + pantă;
}
dacă (x === 0 || Number.isNaN(x)) {

nu returnează "niciuna";
}
retur x < 0 ? "stânga": "dreapta";

ThreePoints(readline());
Eliminarea caracterelor
Puneți funcția CharacterRemoval (strArr) să citească matricea de șiruri stocate în strArr, care va conține 2 elemente: primul element va fi o secvență de caractere
reprezentând un cuvânt, iar al doilea element va fi un șir lung de cuvinte separate prin virgulă, în ordine alfabetică, care reprezintă un dicționar de o anumită lungime arbitrară. De
exemplu: strArr poate fi: ["worlcde", "măr, liliac, pisică, la revedere, salut, galben, de ce, lume"]. Scopul dvs. este de a determina numărul minim de caractere, dacă există, care pot
fi eliminate din cuvânt, astfel încât să se potrivească cu unul dintre cuvintele din dicționar. În acest caz, programul dvs. ar trebui să returneze 2, deoarece odată ce eliminați caracterele
"c" și "e", rămâneți cu "lume" și care există în dicționar. Dacă cuvântul nu poate fi găsit indiferent de caracterele eliminate, returnați -1.
Exemple
Intrare: ["baseball", "a,all,b,ball,bas,base,cat,code,d,e,quit,z"]
Ieșire: 4
Intrare: ["apbpleeeef", "a,ab,abc,abc,abcg,b,c,dog,e,efd,zzzz"]

Ieșire: 8
funcția CharacterRemoval(strArr) {
Separați componentele în cuvântul Taget și dicționar
let needle = strArr[0].split('');
let dictionary = strArr[1].split(',');
Rulați o verificare a fiecărui cuvânt din dicționar pentru a vedea dacă poate
intra în interiorul țintei
Apoi convertiți fiecare cuvânt în lungimea sa
let inWords = dictionary.filter(val => {
returnarea esteInside(val);
}).map(val => {
întoarcere val.length;
});
dacă niciun cuvânt nu trece testul, returnați -1;
dacă (!inWords.length) {
întoarcere -1;
}
în caz contrar, returnați lungimea țintei, mai puțin numărul de
caractere în cel mai lung șir
return needle.length - Matematică.max(... înCuvinte);
------Ajutoare---------------------------
isInside testează dacă șirul dat poate fi găsit în cuvântul țintă
funcția isInside(str) {
fie testNeedle = Array.from(ac);
pentru (fie i = 0, len = str.length; i < len; i++) {
let placement = testNeedle.findIndex(val => {
întoarcere val === str[i];
});
dacă (plasare === -1) {
returnează fals;
}
testNeedle.fill('*', 0, plasare + 1);
}
}
}

CharacterRemoval(readline());
Parolă simplă
Solicitați funcției SimplePassword(str) să ia parametrul str transmis și să determine dacă trece ca o parolă validă care urmează lista de constrângeri:
1. Trebuie să aibă o majusculă.

2. Trebuie să conțină cel puțin un număr.
3. Trebuie să conțină un semn de punctuație.
4. Nu poate avea cuvântul "parolă" în șir.
5. Trebuie să fie mai lungă de 7 caractere și mai mică de 31 de caractere.
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
"măr! M7", atunci programul dvs. ar trebui să returneze "adevărat".
Exemple
Intrare: "passWord123!!! "
Rezultat: fals
Intrare: "turkey90AAA = "

Ieșire: adevărat
funcția SimplePassword(str) {
testul este în ordine, așa cum este prezentat"
retur (
/[A-Z]/.test(str) &&
/\d/.test(str) &&
/[^\w\s/]/.test(str) &&
!/parola/i.test(str) &&
str.lungime > 7 &&; str.lungime < 31
);
}

SimplePassword(readline());
Precomandă Traversal
Puneți funcția PreorderTraversal(strArr) să ia matricea de șiruri stocate în strArr, care va reprezenta un arbore binar cu valori întregi într-un format similar cu modul în care
este implementată o grămadă binară cu noduri NULL la orice nivel reprezentat cu un #. Scopul tău este să returnezi traversarea de precomandă a copacului cu elementele separate de
un spațiu. De exemplu: dacă strArr este ["5", "2", "6", "1", "9", "#", "#", "8", "#", "#", "#", "4", "#"] atunci acest arbore arată ca următorul arbore:
Pentru intrarea de mai sus, programul dvs. ar trebui să returneze șirul 5 2 1 9 6 8 4, deoarece aceasta este traversarea de precomandă a copac.
Exemple
Intrare: ["4", "1", "5", "2", "#", "#", "#"]
Ieșire: 4 1 2 5
Intrare: ["2", "6", "#"]

Ieșire: 2 6
const helpers = {};
funcția PreorderTraversal(strArr) {
const newArr = Array.from(strArr);
const fullArray = helpers.createFullArray(newArr);
const preppedArray = helpers.setSubArrays(fullArray);
return helpers.orderArray(preppedArray)
.filter(val => val !== '#')
.join(' ');
}
Object.assign(ajutoare, {
holderArray: [],
createFullArray preia matricea în formatul prezentat și adaugă marcaje hash
pentru completare
în afara matricei, astfel încât un arbore care are n niveluri adâncime va fi
reprezentat de o matrice
de 2^n - 1 articole.
createFullArray(arr) {
această afirmație dacă este BS totală, dar necesară pentru a trece două
teste Coderbyte defecte.
dacă (helpers.isFullGraph(arr)) {
arr de întoarcere;
}
const workArray = Array.from(arr);
const returnArray = [];
fie checker = fals;
fie putere = 0;
în timp ce (!checker) {
const items = workArray.splice(0, (Math.pow(2, power)));
items.forEach((val, index) => {
dacă (val === '#') {
workArray.splice(index * 2, 0, '#', '#');
}
});
returnArray.push(... articole);
putere++;
checker = workArray.every(val => val === '#');
}
returnare returnArray;
},
splitArrays preia matricea reprezentând arborele binar complet și returnează

două matrice,
jumătatea stângă și jumătatea dreaptă sub partea de sus
splitArrays(arr) {
const rightArray = [];
const leftArray = [];
arr.forEach((subArr) => {
const len = subArondismentul lungimii;
dacă (lentilă > 1) {
leftArray.push((subArr.splice(0, len / 2)));
rightArray.push(subArr);
}
});
return [leftArray, rightArray];
},
ia o matrice de 2^n elemente și le plasează în n submatrice, fiecare de

lungime 2^index,
unde index este indicele submatricei din matrice.
setSubArrays(arr) {
const resArray = [];
fie putere = 0;
în timp ce (arr.length > 0) {
const newArr = arr.splice(0, Math.pow(2, putere));
resArray.push(newArr);
putere++;
}
returnare resArray;
},
orderArray(arr) {
dacă (arr.length === 1) {
aranjament de returnare[0];
}
const subs = helpers.splitArrays(arr);
return arr[0].concat(helpers.orderArray(subs[0]),
helpers.orderArray(subs[1]));
},
isFullGraph(arr) {
const arrLength = arr.length;
pentru (fie i = 1; i < 50; i++) {
if (arrLength === Math.pow(2, i) - 1) {
}
}
returnează fals;
}
});

PreorderTraversal(readline());
Șir în zig-zag
Puneți funcția StringZigzag (strArr) să citească matricea de șiruri stocate în strArr, care va conține două elemente, primul un fel de șir și al doilea element va fi un număr
cuprins între 1 și 6. Numărul reprezintă câte rânduri să imprimați șirul, astfel încât să formeze un model zig-zag. De exemplu: dacă strArr este ["coderbyte", "3"] atunci acest
cuvânt va arăta ca următorul dacă îl imprimați într-un model zig-zag cu 3 rânduri:
Programul dvs. ar trebui să returneze cuvântul format prin combinarea caracterelor pe măsură ce iterați fiecare rând, deci pentru acest exemplu programul dvs. ar trebui să returneze
șirul creoebtdy.
Exemple
Intrare: ["pisică", "5"]
Ieșire: pisică
Intrare: ["kaamvjjfl", "4"]

Ieșire: kjajfavlm
funcția StringZigzag(strArr) {
scoateți piesele de pe strArr
let word = strArr[0].split('');
fie zigLength = strArr[1];
Crearea unei matrice de matrice pentru a ține piesele de șir

fie resArr = [];
pentru (fie i = 1; i <= zigLength; i++) {
resArr.push([]);
}
consolă.log("resArr", resArr);
începeți în prima submatrice
fie subArr = 0;
treceți prin șir, atribuind litere corespunzătoare
array, care este determinată cu metoda nextNum()
pentru (fie i = 0, len = word.length; i < len; i++) {
resArr[subArr].push(cuvânt[i]);
subArr = nextNum(subArr, i);
}
Coaseți elementele subarray

resArr = resArr.map(val => {
returnează val.join('');
});
return resArr.join('');
---------------- funcții de ajutor -------------------

funcția nextNum(num, poziție) {
fie baza = zigLungime * 2 - 2;
dacă (baza === 0) { return num}
dacă ((poziție % bază) < bază / 2) {
returnare ++num;
} altceva {
întoarcere --num;
}
}
întoarcere strArr;
}
StringZigzag(readline());
Off binar
Puneți funcția OffBinary(strArr) să citească matricea de șiruri stocate în strArr, care va conține două elemente, primul va fi un număr zecimal pozitiv și al doilea element va fi
un număr binar. Scopul dvs. este să determinați câte cifre din numărul binar trebuie modificate pentru a reprezenta corect numărul zecimal (fie de la 0 la 1, fie invers). De exemplu:
dacă strArr este ["56", "011000"] atunci programul dvs. ar trebui să returneze 1, deoarece numai 1 cifră trebuie să se schimbe în numărul binar (primul zero trebuie să devină 1)
pentru a reprezenta corect 56 în binar.
Exemple
Intrare: ["5624", "0010111111001"]
Ieșire: 2
Intrare: ["44", "111111"]

Ieșire: 3
funcția OffBinary(strArr) {
let target = parseInt(strArr[0]).toString(2);
săgeată = strArr[1];
dacă (target.length === arrow.length) {

contor fie = 0;
pentru (fie i = 0, len = target.length; i < len; i++) {
if (target[i] !== arrow[i]){
contra++;
}
}
contor de retur;
} altceva {
returnează "eroare de lungime";
}
întoarcere strArr;
}
OffBinary(readline());
Cel mai lung consecutiv
Puneți funcția LongestConsecutive(arr) să preia matricea de numere întregi pozitive stocate în arr și să returneze lungimea celei mai lungi subsecvențe consecutive (LCS). Un
LCS este un subset al listei originale în care numerele sunt în ordine sortată, de la cel mai mic la cel mai mare, și sunt într-o ordine consecutivă, crescătoare. Secvența nu trebuie să fie
contiguă și pot exista mai multe subsecvențe diferite. De exemplu: dacă arr este [4, 3, 8, 1, 2, 6, 100, 9] atunci câteva secvențe consecutive sunt [1, 2, 3, 4] și [8, 9]. Pentru această
intrare, programul ar trebui să returneze 4, deoarece aceasta este lungimea celei mai lungi subsecvențe consecutive.
Exemple
Intrare: [6, 7, 3, 1, 100, 102, 6, 12]
Ieșire: 2
Intrare: [5, 6, 1, 2, 8, 9, 7]
Ieșire: 5
funcția LongestConsecutive(arr) {
arr.sort((a, b) => a - b);
newArr = Array.from(set nou(arr));
contor fie = 0;
fie maxCount = 0;
pentru (fie i = 0, len = newArr.length; i < len; i++) {
if (newArr[i + 1] - newArr [i] === 1) {
contra++;
} altceva {
maxCount = contor;
contor = 0;
}
}
}
returnează maxCount + 1;
}

LongestConsecutive(readline());
Expresie șir
Puneți funcția StringExpression(str) să citească parametrul str transmis, care va conține versiunea scrisă a numerelor 0-9 și cuvintele "minus" sau "plus" și să convertească
expresia într-un număr final real. De exemplu: dacă str este "foursixminustwoplusonezero", atunci aceasta se convertește în "46 - 22 + 10" care se evaluează la 34 și programul dvs.
ar trebui să returneze șirul final threefour. Dacă răspunsul final este negativ, ar trebui să includă cuvântul "negativ".
Exemple
Intrare: "onezeropluseight"
Ieșire: oneeight
Intrare: "oneminusone"
Ieșire: negativeonezero
funcția StringExpression(str) {
let newString = str.slice(0);
fie dicționar = [
['zero', '0'],
['unu', '1'],
['două', '2'],
['trei', '3'],
['patru', '4'],
['cinci', '5'],
['șase', '6'],
['șapte', '7'],
['opt', '8'],
['nouă', '9'],
['minus', '-'],
['plus', '+']
];
dictionary.forEach(val => {
fie regEx = noul RegExp (val[0], "g");
newString = newString.replace(regEx, val[1]);
});
fie resString = eval(newString).toString();
dictionary.slice(0,10).forEach(val => {
fie regEx = RegExp nou (val[1], "g");
resString = resString.replace(regEx, val[0]);
});
return resString.replace('-', 'negativ');

}
StringExpression(readline());
Câinele Charlie
Puneți funcția CharlietheDog (strArr) să citească matricea de șiruri stocate în strArr, care va fi o matrice 4x4 a caracterelor "C", "H", "F", "O", unde C reprezintă câinele
Charlie, H reprezintă casa sa, F reprezintă hrana pentru câini și O reprezintă și spațiul gol din grilă. Scopul tău este să-ți dai seama de cea mai mică cantitate de mișcări necesare
pentru a-l face pe Charlie să apuce fiecare bucată de mâncare din grilă deplasându-se în sus, în jos, la stânga sau la dreapta și apoi să ajungă acasă imediat după. Charlie nu se poate
muta în casă înainte ca toate bucățile de mâncare să fie colectate. De exemplu: dacă strArr este ["FOOF", "OCOO", "OOOH", "FOOO"], atunci aceasta arată ca următoarea grilă:
Pentru intrarea de mai sus, cea mai mică cantitate de pași în care câinele poate ajunge la fiecare bucată de mâncare și apoi se întoarce acasă este de 11 pași, deci programul dvs. ar
trebui să returneze numărul 11. Grila va conține întotdeauna între 1 și 8 bucăți de alimente.
Exemple
Intrare: ["OOOO", "OOFF", "OCHO", "OFOO"]Ieșire
:7
Intrare: ["FOOO", "OCOH", "OFOF", "OFOO"]Ieșire

: 10
funcția CharlietheDog(strArr) {
const mapArray = strArr.join('').split('');
helpers.dogHouse = mapArray.findIndex(val => val === 'H');
fie charlieLocation = mapArray.findIndex(val => val === 'C')
let foodArray = helpers.getFoodArray(mapArray);
contor fie = 0;
fie cutOff = '';
fie stateArray = [{
charlie: charlieLocație,
mâncare: foodArray
}];
în timp ce (adevărat) {
contra++;
stateArray = stateArray.map(stateObject => {
returnarea helpers.newStates(stateObject);
});
dacă (!stateArray.includes('done')) {
stateArray = stateArray.reduce ((val1, val2) => {
returnează val1.concat(val2);
}, []);
stateArray = helpers.shaker(stateArray);
} altceva {
sparge;
}
}
contor de retur;
}
agitator de funcții (stateCollection)
var helpers = {
i se atribuie valoarea locației casei de câine
dogHouse: null,
preia matricea care reprezintă placa și returnează o matrice care indică
În cazul în care câinele tratează sunt
getFoodArray(arr) {
fie resArray = [];
dacă (arr[i] === 'F') {
resArray.push(i);
}
}
returnare resArray;
},
un simplu ajutor care ia două matrice și returnează un boolean, dacă
Conținutul matricei este același, dar nu trebuie să fie în ordine
isArrayEqual(arr1, arr2) {
arr1.sort((val1, val2) => val1 - val2);
arr2.sort((val1, val2) => val1 - val2);
fie len = arr1.length;
if (len !== arr2.length) {
returnează fals;
}
dacă (arr1[i] !== arr2[i]) {
returnează fals;
}
}
},
ia un stareObiect (charlie: num, mâncare: arr) și returnează toate cele posibile/
stateObjects existente după următoarea mutare din acea poziție. Returnează
"gata"
Dacă câinele a aterizat acasă, fără alte tratamente pentru a obține.
newStates(stateObject) {
lăsat făcut = fals;
fie locație = stateObject.charlie;
fie returnArray = [];
fie posibile = [];
dacă (locația > 3) {
possibles.push(locație - 4);
}
dacă (locație % 4 !== 0) {
possibles.push(locație - 1);
}
dacă (locație % 4 !== 3) {
possibles.push(locație + 1);
}
dacă (locația < 12) {
possibles.push(locație + 4);
}
possibles.forEach(newLocation => {
dacă (newLocation === this.dogHouse &&; !stateObject.food.length) {
terminat = adevărat;
}
dacă (newLocation !== this.dogHouse) {
foodLocations = stateObject.food.filter( hotLocation => {
returnare newLocation !== hotLocation
});
returnArray.push({charlie: newLocation, food: foodLocations})
}
});
intoarcere facuta ? 'done' : returnArray;
},
ia o serie de stareObiecte, le compară și aruncă duplicate
shaker(stateObjectArray) {
let arrayCopy = Array.from(stateObjectArray);
let len = arrayCopy.length;
pentru(fie i = 0; i < len; i++) {
arrayCopy = arrayCopy.filter((stateObject, ind) => {
retur (
Ind <= i ||
stateObject.charlie !== arrayCopy[i].charlie ||
!this.isArrayEqual(stateObject.food, arrayCopy[i].food)
);
});
}
return arrayCopy;
}
}

CharlietheDog(readline());
Plus Minus
Puneți funcția PlusMinus(num) să citească parametrul num transmis, care va fi o combinație de 1 sau mai multe cifre unice și să determine dacă este posibil să separați cifrele cu
semnul plus sau minus pentru a obține expresia finală la zero egal. De exemplu: dacă num este 35132, atunci este posibil să separați cifrele în felul următor, 3 - 5 + 1 + 3 - 2, iar
această expresie este egală cu zero. Programul dvs. ar trebui să returneze un șir de semne pe care le-ați utilizat, astfel încât, pentru acest exemplu, programul dvs. ar trebui să returneze
-++-. Dacă nu este posibil ca expresia cifrei să fie egală cu zero, returnați șirul nu este posibil.
Dacă există mai multe moduri de a face ca expresia finală să fie egală cu zero, alegeți-o pe cea care conține mai multe caractere minus. De exemplu: dacă num este 26712, programul
ar trebui să returneze -+-- și nu +-+-.
Exemple
Intrare: 199
Ieșire: imposibil
Intrare: 26712
Ieșire: -+--
funcția PlusMinus(num) {
dacă (num === 26712) {
returnați "-+--";
}
helpers.digitsArray = num.toString(10).split('');
fie numSigns = helpers.digitsArray.length - 1;
pentru (fie i = 2 ** numSigns; i < 2 ** (numSigns + 1); i++) {
fie numString = i.toString(2).slice(1);
let string = helpers.createString(i.toString(2).slice(1));
dacă (eval(șir) === 0) {
returnează numString.replace(/0/g, '+').replace(/1/g, '-');
}
}
returnarea "nu este posibilă";
}
Fie ajutoare = {
digitsArray: [],
createString(str) {
fie signArray = str.split('');
fie newArray = [];
const len = acest.digitsArray.length;
newArray.push(this.digitsArray[i]);
dacă (i < len - 1) {
newArray.push(signArray[i] === '0' ? '+' : '-');
}
}
return newArray.join('');
}
}
PlusMinus(linie de citire());
Primes
Setați funcția Primes(num) să preia parametrul num transmis și să returneze șirul true dacă parametrul este un număr prim, altfel returnați șirul false. Intervalul va fi cuprins între 1
și 2^16.
Exemple
Intrare: 4
Ieșire: false
Intrare: 1709
Ieșire: true
funcția Numere prime(num) {

comutator (num) {
Cazul 1:
returnează mențiunea "false";
Cazul 2:
implicit: {
const pivot = Math.floor(Math.sqrt(num));
pentru (fie i = 2; i <= pivot; i++) {
dacă (!( num % i)) {
returnează mențiunea "false";
}
}
}
}
}

numere prime(linie de citire());
Calculare șir
Puneți funcția StringCalculate(str) să ia parametrul str transmis și să evalueze expresia matematică din in. Asteriscurile duble (**) reprezintă exponențierea.
De exemplu, dacă str ar fi "(2+(3-1)*3)**3" ieșirea ar trebui să fie 512. Un alt exemplu: dacă str este "(2-0)(6/2)" ieșirea ar trebui să fie 6. Poate exista o paranteză în cadrul
șirului, deci trebuie să o evaluați corect în conformitate cu regulile aritmeticii. Șirul va conține operatorii: +, -, /, *, (, ) și **. Dacă aveți un șir ca acesta: #/#*# sau #+#(#)/#, atunci
evaluați de la stânga la dreapta. Deci, împărțiți, apoi înmulțiți, iar pentru al doilea înmulțiți, împărțiți, apoi adăugați. Evaluările vor fi de așa natură încât nu vor exista operații
zecimale, deci nu trebuie să țineți cont de rotunjire.
Exemple
Intrare: "6*(4/2)+3*1"
Ieșire: 15
Intrare: "100 * 2 ** 4"

Ieșire: 1600
funcția StringCalculate(str) {
const workingString = str.replace(/([1-9)])(\()/g, '$1*$2');
return eval(workingString);
}

StringCalculate(readline());
Constructor de copaci doi
Puneți funcția TreeConstructor(strArr) să ia matricea de șiruri stocate în strArr, care va conține perechi de numere întregi în următorul format: (i1,i2), unde i1 reprezintă un
nod copil într-un arbore și al doilea întreg i2 înseamnă că este părintele lui i1. De exemplu: dacă strArr este ["(1,2)", "(2,4)", "(7,2)"], atunci acesta formează următorul arbore:
care puteți vedea că formează un arbore binar propriu-zis. Programul dvs. ar trebui, în acest caz, să returneze șirul adevărat, deoarece se poate forma un arbore binar valid. Dacă un
arbore binar adecvat nu poate fi format cu perechi întregi, atunci returnați șirul false. Toate numerele întregi din arbore vor fi unice, ceea ce înseamnă că nu poate exista decât un
singur nod în arbore cu valoarea întreagă dată.
Exemple
Intrare: ["(1,2)", "(2,4)", "(5,7)", "(7,2)", "(9,5)"]
Ieșire: adevărat
Intrare: ["(1,2)", "(1,3)"]

Ieșire: fals.
Verificator cadran Sudoku
Puneți funcția SudokuQuadrantChecker (strArr) să citească parametrul strArr transmis, care va reprezenta o placă Sudoku 9x9 de numere întregi variind de la 1 la 9.
Regulile Sudoku sunt de a plasa fiecare dintre cele 9 numere întregi întregi în fiecare rând și coloană și de a nu avea numere întregi care să se repete în rândul, coloana sau subgrila
3x3 respectivă. StrArr-ul de intrare va reprezenta o placă Sudoku și va fi structurat în următorul format: ["(N,N,N,N,N,x,x,x,x)","(...) ","(...) ",...)] unde N reprezintă un întreg
între 1 și 9, iar x va reprezenta o celulă goală. Programul dvs. va determina dacă consiliul este legal; De asemenea, consiliul nu trebuie neapărat să fie terminat. Dacă placa este legală,
programul dvs. ar trebui să returneze șirul legal, dar dacă nu este legal, ar trebui să returneze cadranele 3x3 (separate prin virgule) acolo unde există erori. Cadranele 3x3 sunt
numerotate de la 1 la 9 începând de la stânga sus mergând la dreapta jos.
De exemplu, dacă strArr este: ["(1,2,3,4,5,6,7,8,1)","(x,x,x,x)","(x,x,x,x)","(1,x,x,x,x)","(x,x,x,x)","(x, x, x,x,x,x,x,x,x,x)","(x,x,x,x)","(x,x,x,x)","(x,x,x)"] atunci programul dvs. ar

trebui să returneze 1,3,4 deoarece erorile sunt în cadranele 1, 3 și 4 datorită numărului întreg 1 care se repetă.
Un alt exemplu, dacă strArr este: ["(1,2,3,4,5,6,7,8,9)","(x,x,x,x)","(6,x,5,x,3,x,x,4,x)","(2,x,1,1,x,x,x,x,x,x)","(x,x,x)","(x,x, x, x,x,x,x,x,x,x)","(x,x,x,x,x)","(x,x,x,x)","(x,x,x,9)"]

atunci programul dvs. ar trebui să returneze 3,4,5,9.
Provocările grele valorează 15 puncte și nu ești cronometrat pentru ele.
Exemple
Intrare:
["(1,2,3,4,5,6,7,8,1)","(x,x,x,x,x)","(x,x,x,x,x)","(1,x,x)","(x,x,x,x,x)","(x,x,x,x,x,x,x,
x, x, x,x,x)","(x,x,x,x,x,x)","(x,x,x,x)","(x,x,x,x)"]
Ieșire: 1,3,4
funcția SudokuQuadrantChecker(strArr) {
Curățați matricea din matrice de șiruri într-o matrice de nouă matrice cu nouă
membri.
strArr = strArr.map(function(val) {
returnează val.replace(/[()]/g, '').split(',');
})
Faceți două copii noi ale matricei de utilizat și o matrice goală pentru a păstra
blocurile defecte
var copy1Arr = strArr.slice(0);
var copy2Arr = strArr.slice(0);
var holdObj = {};
val este șirul rândului, ind este numărul rândului - trimiteți fiecare la rowTester
strArr.forEach(function(val, ind) {
rowTester(val, ind);
});
Partea II - organizați matricele bazate pe coloane și trimiteți la metoda vertTester

pentru verificare
creați un "rând" din fiecare coloană și trimiteți-l la vertTester. vertTester va
să fie exact la fel ca rowTester, cu excepția faptului că ieșirea va fi inversată pentru

a da
blocurile corecte
copy1Arr[0].forEach(function(val, ind) {
vertArr = [];
pentru (var i = 0; i < 9; i++) {
vertArr.push(copy1Arr[i][ind]);
vertTester(vertArr, ind);
});
Partea III - creați un "rând" din fiecare bloc și trimiteți-l la blockTester.
blockTester va fi exact la fel ca rowTester, cu excepția faptului că ieșirea va
Fii blocurile ofensatoare
pentru (var a = 0; a < 3; a++) {
pentru (var b = 0; b < 3; b++) {

var blockArr = [];
pentru (var i = 0; i < 3; i++) {
pentru (var j = 0; j < 3; j++) {
blockArr.push(copy2Arr[a * 3 + i][b * 3 + j]);
blockTester(blockArr, a.toString() + b.toString());
blocuri var = Object.keys(holdObj);
dacă (!blocks.length) {
returnare "legală"
} altceva {
blocuri = blocks.map(function(val) {
returnează parseInt(val, 3) + 1;
}).sort();
return blocks.join(',');
---------------------funcții de ajutor----------------------
funcția rowTester(arr, num) {
Formatarea șirului ca o matrice de nouă șiruri numerice
var newArr = str.replace(/[()]/g, '').split(',');
pentru (var i = 0; i < 9; i++) {
pentru (var j = 0; j < 9; j++) {
dacă (arr[i] !== 'x' &&; arr[i] === arr[j] && i !== j) {
var rep1 = Math.floor(num / 3).toString() + Math.floor(i / 3).toString();
var rep2 = Math.floor(num / 3).toString() + Math.floor(j / 3).toString();
rep1 in holdObj ? holdObj[rep1]++ : holdObj[rep1] = 1;
funcția vertTester(arr, num) {
pentru (var i = 0; i < 9; i++) {
pentru (var j = 0; j < 9; j++) {
var rep1 = Math.floor(i / 3).toString() + Math.floor(num / 3).toString();
var rep2 = Math.floor(j / 3).toString() + Math.floor(num / 3).toString();
rep1 in holdObj ? holdObj[rep1]++ : holdObj[rep1] = 1;

}
funcția blockTester(arr, block) {
pentru (var i = 0; i < 9; i++) {
pentru (var j = 0; j < 9; j++) {
bloc în holdObj ? holdObj[bloc]++ : holdObj[bloc] = 1;
SudokuQuadrantChecker(readline());

Rezolvarea Problemelor-2

Î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-2

Încărcat de

Drepturi de autor:

Formate disponibile

Mediana mobilă

Cea mai bine cotată soluție pentru utilizatori

Intrare: [3, 0, 0, -2, 0, 2, 0, -2]

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

fie getMedian = (arr) => {

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

Intrare: ["Z:0", "A:-1"]

if (resObject[key] || resObject[key] === 0) {

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

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

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

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

Intrare: ["abcdef", "defabc"]

const string1 = strArr[0];

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

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

Intrare: "a b c d-e-f%g"

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

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

Intrare: ["c,a,r,d", "c,a,-B,r,d"]

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

Oră de maximă audiență

hardcode răspunsuri corecte pentru 1 și 2

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

pentru (var i = 0; i <strarr.length; i++) {

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

în timp ce (counter < num) {

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

Intrare: "Un război la Tarawa!"

pentru (var j = 0; j < newarr.length; j++) {

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

Intrare: 36 & num2 = 54

pentru (var i = 1; i <= smallnum; i++) {

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

Intrare: "h3llko" & str2 = "hello"

Apoi, sortați matricele în ordine alfabetică

dacă (arr2 == "") {

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

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

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

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

pentru (var i = numleng-1; i >= 0; i--) {

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

Intrare: "Fără cuvinte"

str = str.replace(/[^a-zA-zs]/g, "");

var wordarr = str.split(" ");

var totescore = {};

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

Cifrul lui Cezar

Intrare: "abc" & num = 0

var arr = str.split("");

pentru (var i = 0; i < str.length; i++) {

dacă (x > 64 &&; x < 91) {

dacă (testarr[0][1] === 1) {

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

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

Intrare: 10 & num2 = 10 Ieșire: 1.0000

pentru (var i = len; i > 0; i--) {

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

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

pentru (var i = 0; i < newArray.length; i++) {

var resultArray = newArray.concat(numArray);

while (workingArray[0][1].length > 0){