Problemlösung 1

Erste Rückwärtsfahrt
Lassen Sie die FunktionFirstReverse (str) den übergebenen str -Parameter nehmen und den
String in umgekehrter Reihenfolge zurückgeben. Zum Beispiel: Wenn die Eingabezeichenfolge "Hello
World and Coders" ist, sollte Ihr Programm die Zeichenfolge sredoC dna dlroW olleH zurückgeben.
Beispiele
Input: „coderbyte“
Output: etybredoc
Eingabe: „I Love Code“

Ausgabe: edoC evoL I
funktion FirstReverse(str) {
var arr = str.split('');

arr.reverse();
return arr.join('');
}
//diesen Funktionsaufruf hier behalten

// um zu sehen, wie Argumente in JavaScript eingegeben werden, scrollen Sie nach
unten
FirstReverse(readline());
let newString = '';

for (let i = str.length-1; i >= 0; i--) {
newString += str[i];
}
return newString;
}

// code goes here
return str.split('').reverse().join('');

unten
First Factorial
Lassen Sie die FunktionFirstFactorial (num) den übergebenen Parameter num übernehmen
und das Faktorielle davon zurückgeben. Zum Beispiel: Wenn num = 4, dann sollte Ihr Programm
zurückgeben (4 * 3 * 2 * 1) = 24. Für die Testfälle liegt der Bereich zwischen 1 und 18 und die Eingabe
ist immer eine ganze Zahl.
Beispiele
Eingang: 4
Ausgang: 24
Eingang: 8
Ausgang: 40320
funktion FirstFactorial(num) {
let factorial = 1;
for (let i = 1; i <= num; i++) {

faktoriell *= i;
}
faktorielle Rückgabe;

FirstFactorial(readline());
// code goes here

if (num < 0) return NaN;
return (num > 1) ? FirstFactorial(num - 1) * num : 1;

unten
let answer = 1;
for (let index = 1; index <= num; index++) {
answer *= index;
}
antwort zurückgeben;

Längstes Wort
Lassen Sie die FunktionLongestWord (sen) den übergebenen sen-Parameter nehmen und das
größte Wort in der Zeichenfolge zurückgeben. Wenn es zwei oder mehr Wörter gibt, die die gleiche
Länge haben, geben Sie das erste Wort aus der Zeichenfolge mit dieser Länge zurück. Satzzeichen
ignorieren und davon ausgehen, dass sen nicht leer ist.
Beispiele
Eingabe: "Spaß&!! Zeit"

Ausgabe: Zeit
Input: „Ich liebe Hunde“

Output: Liebe
function LongestWord(sen) {
sen = sen.trim();
sen = sen.replace(/[â-zA-Zsd]/g, '');
var arr = sen.split(' ');
arr.sort(function(a, b) {return b.length - a.length});
return arr.shift();
// code goes here

return sen;

unten
LongestWord(readline());
let validCharacters =
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
let maxLength = 0;
let longestWord = '';
for (let i = 0, length = 0, word = ''; i < sen.length; i++) {

let c = sen[i];
if (validCharacters.includes(c)) {
length++;
word += c;
} else {
length = 0;
word = '';
}
if (length > maxLength) {

maxLength = Länge;
longestWord = word;
}
}
return longestWord;

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

Brief-Änderungen
Lassen Sie die Funktion LetterChanges (str) den übergebenen Parameter str mit dem folgenden
Algorithmus ändern. Ersetzen Sie jeden Buchstaben in der Zeichenfolge durch den folgenden
Buchstaben im Alphabet (d. h. c wird zu d, z wird zu a). Dann jeden Vokal in dieser neuen Zeichenfolge
(a, e, i, o, u) groß schreiben und schließlich diese modifizierte Zeichenfolge zurückgeben.
Beispiele
Eingabe: "Hallo*3"
Ausgabe: Ifmmp*3
Input: „Fun Times!“
Ausgabe: gvO Ujnft!
funktion LetterChanges(str) {
str = str.trim().toLowerCase();
var len = str.length;
var newStr = '';
for (var i = 0; i < len; i++) {

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

unten
LetterChanges(readline());
let validCharacters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
let newString = '';
for (let i = 0; i < str.length; i++) {

if (validCharacters.includes(str[i])) {
let char = str.charCodeAt(i);
newString += (str[i] === 'z' || str[i] === 'Z') ?
String.fromCharCode(char - 25) : String.fromCharCode(char + 1);
} else {
}
}
let vocals = 'aeiou';
let finalString = '';
// Vokale kapitulieren
for (let i = 0; i < newString.length; i++) {
if (vokale.includes(newString[i])) {
finalString += newString[i].toUpperCase();
} else {
finalString += newString[i];
}
}
return finalString;

str = str.replace(/[a-zA-Z]/g, Funktion(ch) {
if (ch === 'z') return 'a';
else if (ch === 'Z') return 'A';
else return String.fromCharCode(ch.charCodeAt(0) + 1);
});
return str.replace(/[aeiou]/g, function(ch) {

return ch.toUpperCase();
});
}

unten
Einfaches Hinzufügen
Lassen Sie die FunktionSimpleAdding (num) alle Zahlen von 1 bis num addieren. Zum Beispiel:
Wenn die Eingabe 4 ist, dann sollte Ihr Programm 10 zurückgeben, weil 1 + 2 + 3 + 4 = 10. Für die
Testfälle wird der Parameter num eine beliebige Zahl von 1 bis 1000 sein.
Beispiele
Eingang: 12
Ausgang: 78
Eingang: 140
Ausgang: 9870
funktion SimpleAdding(num) {
if (num === 1) {
return 1;
}
else {
return num + SimpleAdding(num -1);
}
}

unten
SimpleAdding(readline());
let sum = 0;
for (i = 1; i <= num; i++) {
sum += i;
}
rücksumme;

// code goes here

if (num < 1) return NaN;
else if (num === 1) return 1;
return SimpleAdding(num - 1) + num;

unten
Großbuchstaben
Lassen Sie die FunktionLetterCapitalize (str) den übergebenen

Parameter str übernehmen und den ersten Buchstaben jedes Wortes großschreiben. Wörter werden nur
durch ein Leerzeichen getrennt.
Beispiele
Input: „Hallo Welt“

Output: Hallo Welt
Eingabe: "Ich bin dort gelaufen"

Ausgabe: Ich bin dort gelaufen
funktion LetterCapitalize(str) {
wordarr = str.split(" ");
for (var i = 0, n = wordarr.length; i < n; i++) {

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

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

}
return newString;
}

// code goes here

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

unten
Einfache Symbole
Lassen Sie die Funktion SimpleSymbols(str) den übergebenen Parameter str übernehmen und
bestimmen Sie, ob es sich um eine akzeptable Sequenz handelt, indem Sie entweder die
Zeichenfolge true oder false zurückgeben. Der Parameter str setzt sich aus + und = Symbolen mit
mehreren Zeichen dazwischen zusammen (d. h. ++d+= ==+c + +==a), und damit die Zeichenfolge wahr
ist, muss jeder Buchstabe von einem + Symbol umgeben sein. Die Zeichenfolge auf der linken Seite
wäre also falsch. Die Zeichenfolge ist nicht leer und hat mindestens einen Buchstaben.
Beispiele
Input: "+d+=3=+s+"
Output: true
Eingabe: "f++d+"
Ausgabe: falsch
funktion SimpleSymbols(str) {
if (/^[a-zA-Z]/.test(str) || /[a-zA-Z]$/.test(str)) {
return false;
}
else if (/[^+][a-zA-Z]/.test(str) || /[a-zA-Z][^+]/.test(str)) {
return false;
}
else {
return true;
}

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

return 'false';
}
let result = str.split('').every(letterEval);
return result ? 'true' : 'false';
funktion letterEval(Buchstabe, Index) {

let letters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
if (letters.includes(letter)) {
// Auf erstes oder letztes Zeichen prüfen
if (index === 0 || index === str.length - 1) {
// Letter is first or last char, fail case
return false;
}
if (str[index - 1] === '+' && str[index + 1] === '+') {

return true;
}
} else {
//Non Letters ignorieren
return true;
}
}

// code goes here

if (str.match(/[^+][A-Za-z][^+]/g)) return false;
else if (str.match(/[+][A-Za-z][^+]/g)) return false;
else if (str.match(/[^+][A-Za-z][+]/g)) return false;
return true;
}

unten
Check Nums
Lassen Sie die FunktionCheckNums (num1,num2) beide übergebenen Parameter übernehmen und
die Zeichenfolge true zurückgeben, wenn num2 größer als num1 ist, andernfalls wird die
Zeichenfolge false zurückgegeben. Wenn die Parameterwerte gleich sind, geben Sie die Zeichenfolge -1
zurück.
Beispiele
Eingang: 3 & num2 = 122

Ausgang: wahr

Ausgang: -1
HERAUSFORDERUNG ANZEIGEN
funktion CheckNums(num1,num2) {
if (num1 == num2) {
return "-1";
}
else {
return (num2 > num1);
}
}

unten
CheckNums(readline());
if (num2 > num1) {

return true;
} else if (num1 === num2) {
return '-1';
} else {
return false;
}

// code goes here

if ((num1 - num2) < 0) return true;
else if ((num1 - num2) > 0) return false;
else return -1;
}

unten
Zeitkonvertierung
Lassen Sie die Funktion TimeConvert (num) den übergebenen num -Parameter nehmen und die
Anzahl der Stunden und Minuten zurückgeben, in die der Parameter konvertiert wird (d.
h. wenn num = 63, sollte die Ausgabe 1:3 sein). Trennen Sie die Anzahl der Stunden und Minuten mit
einem Doppelpunkt.
Beispiele
Eingang: 126
Ausgang: 2:6
Eingang: 45
Ausgang: 0:45
funktion TimeConvert(num) {
var hours = Math.floor(num/60);
var minutes = num % 60;
var str = hours + ":" + minutes;
return str;

unten
TimeConvert(readline());
let hours = Math.floor(num/60);

let minutes = num % 60;
rückgabestunden + ':' + Minuten;

// code goes here

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

unten
Buchstabensuppe
Lassen Sie die FunktionAlphabetSoup (str) den übergebenen Zeichenfolgenparameter nehmen

und die Zeichenfolge mit den Buchstaben in alphabetischer Reihenfolge zurückgeben ( d. h. hallo wird
zu ehllo). Angenommen, Zahlen und Satzzeichen werden nicht in der Zeichenfolge enthalten sein.
Beispiele
Eingang: "coderbyte"
Ausgang: bcdeeorty
Eingabe: „hooplah“
Ausgabe: ahhloop
funktion AlphabetSoup(str) {
var arrays = str.split("");

var reversearrays = arrays.sort();
var result = reversearrays.join("");
rückgabeergebnis;

unten
AlphabetSoup(readline());
let letters = str.split('');

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

// code goes here

return str.split('').sort(function(ch1, ch2) {
return ch1.charCodeAt(0) - ch2.charCodeAt(0);
}).join('');
}
unten
AB-Prüfung
Lassen Sie die Funktion ABCheck (str) den übergebenen Parameter str übernehmen und die
Zeichenfolge true zurückgeben, wenn die Zeichen a und b mindestens einmal an genau 3 Stellen in der
Zeichenfolge getrennt sind (d. h. "lane borrowed" würde zu true führen, da zwischen a und b genau drei
Zeichen liegen). Andernfalls wird die Zeichenfolge false zurückgegeben.
Beispiele
Eingabe: „nach schlecht“

Ausgabe: falsch
Eingabe: „Laura schluchzt“

Ausgabe: wahr
function ABCheck(str) {
patt = /(a...b|b...a)/
return patt.test(str);

unten
ABCheck(readline());
if (str.length < 5) {
return false;
}
console.log(str.length);
for (let i = 0; i < str.length-4; i++) {

// suche nach einem
if (str[i] === 'a') {
if (str[i+4] === 'b') {
return true;
}
}
if (str[i] === 'b') {
if (str[i+4] === 'a') {
return true;
}
}
}
return false;

// code goes here
return str.match(/[aA].{3}[bB]/) !== null;

}

unten
Vokalzählung
Lassen Sie die FunktionVowelCount (str) den übergebenen String-String-Parameter nehmen

und die Anzahl der Vokale zurückgeben, die der String enthält (d. h. "Alle Kühe fressen Gras und Moo"
würde 8 zurückgeben). Zähle y nicht als Vokal für diese Herausforderung.
Beispiele
Eingabe: "Hallo"
Ausgabe: 2
Eingang: "Coderbyte"
Ausgang: 3
function VowelCount(str) {
var patt = /[aeiou]/gi;
var arr = str.match(patt);
if (arr == null) {
return 0;
}
else {
return arr.length;
}
}

unten
VowelCount(readline());
let vocals = 'aeiou';

let count = 0;

if (vokale.includes(str[i])) {
count++;
}
}
rückgabezählung;
}

// code goes here

return str.split('').filter(function(ch) {
return ['a', 'e', 'i', 'o', 'u'].indexOf(ch.toLowerCase()) > -1;
}).length;

unten
Word Count
Lassen Sie die Funktion WordCount(str) den übergebenen String-Parameter nehmen und die
Anzahl der Wörter zurückgeben, die der String enthält (z. B. "Niemals zerkleinerten Weizen oder
Kuchen essen" würde 6 zurückgeben). Wörter werden durch einzelne Leerzeichen getrennt.
Beispiele
Input: „Hello World“

Output: 2
Eingang: "eins 22 drei"
Ausgang: 3
funktion WordCount(str) {
var arr = str.split(" ");
var answer = arr.length;
antwort zurückgeben;

unten
WordCount(readline());
return str.split(' ').length;
}

// code goes here

return str.split(' ').length;

unten
Ex Oh
Lassen Sie die FunktionExOh (str) den übergebenen Parameter str übernehmen und die
Zeichenfolge true zurückgeben, wenn es eine gleiche Anzahl von x und o gibt, andernfalls geben Sie die
Zeichenfolge false zurück. Nur diese beiden Buchstaben werden in die Zeichenfolge eingegeben, keine
Satzzeichen oder Zahlen. Zum Beispiel: Wenn str "xooxxxxooxo" ist, dann sollte die
Ausgabe false zurückgeben, weil es 6 x und 5 o gibt.
Beispiele
Input: "xooxxo"
Output: true
Eingang: "x"
Ausgang: false
funktion ExOh(str) {
var regExPatternX = /x/gi;
var regExPatternO = /o/gi;
var arrayXLen = str && str.match(regExPatternX) ?

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

}

ExOh(readline());
let xCount = 0;
let oCount = 0;

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

ExOh(readline());
// code goes here

var letters = str.split('');
var numOfEx = letters.filter(Funktion(ch) {
return ch === 'x';
}).length;
var numOfOh = letters.filter(Funktion(ch) {
return ch === 'o';
}).length;
return numOfEx === numOfOh;

unten
ExOh(readline());
Palindrom
Lassen Sie die Funktion Palindrom(str) den übergebenen Parameter str übernehmen und die
Zeichenfolge true zurückgeben, wenn der Parameter ein Palindrom ist (die Zeichenfolge ist vorwärts
und rückwärts gleich), andernfalls wird die Zeichenfolge false zurückgegeben. Zum Beispiel: „racecar“
ist auch „racecar“ rückwärts. Satzzeichen und Zahlen sind nicht Teil der Zeichenfolge.
Beispiele
Eingabe: "nie ungerade oder gerade"

Ausgabe: wahr
Eingabe: „Auge“
Ausgabe: wahr
function Palindrome(str) {
modifiziert = str.replace(/W/g,"");
var arr1 = modified.split("");

var arr2 = arr1;
arr2 = arr2.reverse();
str2 = arr2.join("");
return modified == str2;

unten
Palindrom(readline());
str = str.replace(/ /g, '');

for (let i = 0, max = Math.floor(str.length/2); i < max; i++) {
if (str[i] !== str[str.length-1-i]) {
return false;
}
}
return true;

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

return false;
}
}
return true;

Arith Geo
Lassen Sie die FunktionArithGeo (arr) das in arr gespeicherte Zahlenarray nehmen und die
Zeichenfolge "Arithmetic" zurückgeben, wenn die Sequenz einem arithmetischen Muster folgt,
oder "Geometric" zurückgeben, wenn sie einem geometrischen Muster folgt. Wenn die Sequenz keinem
der beiden Muster folgt, geben Sie -1 zurück. Eine arithmetische Sequenz ist eine Sequenz, bei der die
Differenz zwischen jeder der Zahlen konsistent ist, wobei wie in einer geometrischen Sequenz jeder
Term nach dem ersten mit einem konstanten oder gemeinsamen Verhältnis multipliziert wird.
Rechenbeispiel: [2, 4, 6, 8] und geometrisches Beispiel: [2, 6, 18, 54]. Negative Zahlen können als
Parameter eingegeben werden, 0 wird nicht eingegeben und kein Array enthält alle gleichen Elemente.
Beispiele
Eingabe: [5,10,15]
Ausgabe: Arithmetik
Eingabe: [2,4,16,24]
Ausgabe: -1
funktion ArithGeo(arr) {
var len = arr.length;
var arithK = arr[1] - arr[0];
var geoK = arr[1] / arr[0];
for (var i = 0; i < len - 1; i++) {

if (arr[i+1] - arr [i] !== arithK) {
pause;
}
else if (i === len - 2) {
return "Arithmetik";
}
}
for (var i = 0; i < len - 1; i++) {

if (arr[i+1] / arr [i] !== geoK) {
pause;
}
else if (i === len - 2) {
return "Geometrisch";
}
}
return -1;
}

unten
ArithGeo(readline());
let arithmetic = true;

// test arithmetic
for (let i = 2, diff = arr[1] - arr[0]; i < arr.length; i++) {
if (arr[i] - arr[i-1] !== diff) {
arithmetic = false;
}
}
if (arithmetic) {
return 'Arithmetik';
}
let geometric = true;

// geometrisch
for (let i = 2, divisor = arr[1] / arr[0]; i < arr.length; i++) {
if (arr[i] / arr[i-1] !== Divisor) {
geometrisch = falsch;
}
}
if (geometric) {
return 'Geometrisch';
}
return -1;

// code goes here

var isArith = function(arr) {
if (arr.length < 2) return -1;
var difference = arr[1] - arr[0];
for (var i = 1; i < arr.length - 1; i++) {
if (arr[i + 1] - arr[i] !== difference) return false;
}
return true;
};
var isGeo = function(arr) {

var Multiplikator = arr[1] / arr[0];
if (arr[i + 1] / arr[i] !== Multiplikator) return false;
}
return true;
};
if (isArith(arr)) return "Arithmetik";

else if (isGeo(arr)) return "Geometrisch";
else return -1;
}

unten
Array-Addition I
Lassen Sie die Funktion ArrayAdditionI (arr) das in arr gespeicherte Zahlenarray nehmen und
die Zeichenfolge true zurückgeben, wenn eine beliebige Zahlenkombination im Array (ohne die größte
Zahl) addiert werden kann, um der größten Zahl im Array zu entsprechen, andernfalls wird die
Zeichenfolge false zurückgegeben. Zum Beispiel: Wenn arr [4, 6, 23, 10, 1, 3] enthält, sollte die
Ausgabe true zurückgeben, weil 4 + 6 + 10 + 3 = 23. Das Array ist nicht leer, enthält nicht die gleichen
Elemente und kann negative Zahlen enthalten.
Beispiele
Eingabe: [5,7,16,1,2]
Ausgabe: falsch
Eingabe: [3,5,-1,8,12]
Ausgabe: wahr
function ArrayAdditionI(arr) {
var target;
var addArr = arrayPrep(arr);
var len = addArr.length;
var permNum = Math.pow(2, len);
console.log('test0 ', permNum, target, addArr);
for(var i = 0; i <= permNum; i++) {

permStr = (i).toString(2);
strlen = permStr.length;
var counter = 0;
for(var j = 0; j < strlen; j++) {
if(permStr[j] === '1') {
counter += addArr[j];
}
}
if (counter === Ziel) {
return true
}
}
return false
function arrayPrep(arr2) {
arr.sort(Funktion(a, b){
return a - b
});
target = arr2.pop()
return arr2
}
}

unten
ArrayAdditionI(readline());
//größte Zahl finden

let largestIndex = 0;
let largestNumber = 0;
for (let i = 0; i < arr.length; i++) {
if (arr[i] > largestNumber) {
largestIndex = i;
largestNumber = arr[i];
}
}
arr.splice(largestIndex, 1);
let combos = [];

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

let num = i.toString(2);
while (num.length < size) {
num = '0' + num;
}
combos.push(num);
}
//über alle Zahlenkombinationen iterieren

for (let i = 0; i < combos.length; i++) {
let sum = 0;
for (let j = 0; j < combos[i].length; j++) {
if (combos[i][j] === '1') {
sum += arr[j];
}
}
if (sum === größteZahl) {

return true;
}
}
return false;
}

// code goes here

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

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

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

if (bitMask[j] === '1') {
sum += sortedArr[j];
}
}
sums.push(Summe);
}
return sums.indexOf(größter) !== -1;

}

unten
Buchstabenanzahl I
Lassen Sie die FunktionLetterCountI (str) den übergebenen Parameter str übernehmen und
das erste Wort mit der größten Anzahl an wiederholten Buchstaben zurückgeben. Zum Beispiel: "Heute
ist der größte Tag aller Zeiten!" sollte am größten zurückkommen, weil er 2 e's (und 2 t's) hat und er
vor je kommt, der auch 2 e's hat. Wenn keine Wörter mit sich wiederholenden Buchstaben vorhanden
sind, geben Sie -1 zurück. Wörter werden durch Leerzeichen getrennt.
Beispiele
Eingabe: „Hallo Apfelkuchen“

Ausgabe: Hallo
Eingabe: „Keine Worte“

Ausgabe: -1
funktion LetterCountI(str) {
var arr = str.toLowerCase().split(" ");
var n = arr.length;
var counter = 1;
var maxcount = 0;
var newarr = [];
for (var i = 0; i < n; i++) {

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

if (wordarr[j] == wordarr[j+1]) {
zähler++;
}
else {
if (counter > maxcount) {
maxcount = Zähler;
counter = 1;
}
}
}
newarr.push([arr[i], maxcount])
maxcount = 0;
}
newarr.sort(function(a, b) {return b[1] - a[1]});
if (newarr[0][1] == 1) {
return -1;
}
else {
return newarr[0][0];
}
}

unten
LetterCountI(readline());
let words = str.split(' ');
let bestCount = 0;
let bestWord = '';
for (let i = 0; i < words.length; i++) {

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

bestCount = largestCount;
bestWord = Wörter[i];
}
}
return (bestWord === '') ? -1 : bestWord;

// code goes here

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

word = word.toLowerCase();
var letters = [];
für (Buchstabe des Wortes) {
if (letters[letter]) {
letters[letter] += 1;
} else {
letters[letter] = 1;
}
}
rückbriefe;
});
var greatestCounts = counts.map(Funktion(Wort) {

var greatest = 0;
für (Buchstabe in Wort) {
if (word[letter] > greatest) {
greatest = word[letter];
}
}
rendite am größten;
});
var greatest = Math.max.apply(null, greatestCounts);

if (greatest <= 1) return -1;
return words[greatestCounts.indexOf(greatest)];
}

unten
Zweites GreatLow
Lassen Sie die Funktion SecondGreatLow (arr) das in arr gespeicherte Zahlenarray
nehmen und die zweitniedrigste bzw. zweitgrößte Zahl durch ein Leerzeichen getrennt zurückgeben.
Zum Beispiel: Wenn arr [7, 7, 12, 98, 106] enthält, sollte die Ausgabe 12 98 sein. Das Array ist nicht
leer und enthält mindestens 2 Zahlen. Es kann schwierig werden, wenn es nur zwei Zahlen gibt!
Beispiele
Eingang: [1, 42, 42, 180]

Ausgang: 42 42
Eingang: [4, 90]

Ausgang: 90 4
funktion SecondGreatLow(arr) {
arr.sort(function(a, b) {return a - b});
arr = einsam(arr);
var newlen = arr.length;
return arr[1] + ' ' + arr[newlen - 2]
funktion Lonely(arr) {
var len = arr.length;
var testobj = {};
var output = [];
var count = 0;
for (var i = 0; i < len; i++) {
var holder = arr[i];
if (!testobj[holder]) {
testobj[holder] = true;
output[count++] = holder;
}
}
rücklaufausgang
}
}

unten
SecondGreatLow(readline())
arr = arr.slice().sort((a, b) => a - b);
let second = arr[1];

if (arr[i] !== arr[0]) {
second = arr[i];
pause;
}
}
let vorletzte = arr[arr.length - 2];

for (let i = arr.length - 2; i >= 0; i--) {
if (arr[i] !== arr[arr.length - 1]) {
vorletzte = arr[i];
pause;
}
}
return second + ' ' + vorletzte;

SecondGreatLow(readline());
// code goes here

var sorted = arr.sort(function(a,b){return a-b;});
var greatest = sortiert[sorted.length - 1];
var niedrigste = sortiert[0];
var secondGreatest, secondLowest;
for (var i = 0; i < sorted.length; i++) {

if (sorted[i] !== niedrigste) {
secondLowest = sortiert[i];
pause;
}
}
for (var i = sorted.length - 1; i >= 0; i--) {

if (sorted[i] !== greatest) {
secondGreatest = sortiert[i];
pause;
}
}
return secondLowest + " " + secondGreatest;

}

unten
SecondGreatLow(readline());
Division Stringified
Lassen Sie die FunktionDivisionStringified (num1,num2) beide übergebenen Parameter

übernehmen, teilen Sie num1 durch num2 und geben Sie das Ergebnis als String mit korrekt
formatierten Kommas zurück. Wenn eine Antwort nur 3 Ziffern lang ist, geben Sie die Zahl ohne
Kommas zurück (d. h. 2/3 sollte "1" ausgeben). Zum Beispiel:
Wenn num1 123456789 und num2 10000 ist, sollte die Ausgabe "12,346" sein.
Beispiele

Ausgang: 3

Ausgang: 103
funktion DivisionStringified(num1,num2) {
var res = Math.round(num1/num2);

var string = res.toString();
var numleng = string.length;
var newstring = string;
if (numleng > 3) {
var arr = string.split("");
for (var i= numleng - 3; i > 0; i = i - 3) {
arr.splice(i, 0, ",");
}
var newstring = arr.join("");
}
newstring zurückgeben;

unten
DivisionStringified(readline());
let quotientString = Math.round(num1 / num2).toString();
let temp = quotientString.split('').reverse();

let newString = '';
for (let i = 0; i < temp.length; i++) {
if (i % 3 === 2 && i != temp.length-1) { // need comma next
newString = ',' + temp[i] + newString;
} else {
newString = temp[i] + newString;
}
}
//console.log(newString);
return newString;
}

// code goes here

var format = function(num) {
var result = '';
var whole = Math.round(num);
if (whole === 0) ergibt 0;
while (whole > 0) {

result = (result === '' ? '' : ',') + result;
result = (whole % 1000) + result;
whole = Math.floor(whole / 1000);
}
rückgabeergebnis;
}
rückgabeformat(num1 / num2);
}

unten
Zählminuten I
Lassen Sie die Funktion CountingMinutesI (str ) den übergebenen STR-Parameter zweimal
(jeweils richtig mit einem Doppelpunkt und am oder pm formatiert) durch einen Bindestrich trennen und
die Gesamtzahl der Minuten zwischen den beiden Zeiten zurückgeben. Die Uhrzeit wird in einem 12-
Stunden-Format angezeigt. Zum Beispiel: Wenn str 9:00 Uhr -10:00Uhr ist, dann sollte die
Ausgabe 60 sein. Wenn str 13:00 -11:00 Uhr ist, sollte die Ausgabe 1320 sein.
Beispiele
Eingang: „12:30- 12:00Uhr“

Ausgang: 690
Input: "1:23am-1:08am"
Output: 1425
Lösungen für das Zählen von Minuten I
JAVASCRIPT
funktion CountingMinutesI(str) {
var seps = str.split("-");
var col1 = seps[0].indexOf(":");
var col2 = seps[1].indexOf(":");
var hour1 = parseInt(seps [0].slice(0, col1));
var hour2 = parseInt(seps[1].slice(0, col2));
var min1 = parseInt(seps[0].slice(col1+1, col1+3));
var min2 = parseInt(seps[1].slice(col2+1, col2+3));
var ampm1 = seps[0].slice(-2);
var ampm2 = seps[1].slice(-2);
if (ampm1 == "pm" && hour1 != 12) {
hour1 = Stunde1 + 12;
}
if (ampm2 == "pm" && hour2 != 12) {
hour2 = hour2 + 12;
}
if (hour1 == 12 && ampm1 == "am") {
hour1 = 0;
}
if (hour2 == 12 && ampm2 == "am") {
hour2 = 0;
}
var time1 = (hour1*60) + min1;
var time2 = (hour2*60) + min2;
var diff = time2 - time1;
if (diff < 0) {
diff = diff + (60 * 24);
}
return-Diff;

unten
CountingMinutesI(readline());
let times = str.split('-');
times = times.map(Funktion(currentValue, index, array){

let pairs = currentValue.split(':');
let time = ((Paare[1][2] === 'a') ? parseInt(Paare[0]) % 12 :
parseInt(Paare[0]) % 12 + 12) * 60 + parseInt(Paare[1][0] + Paare[1][1]);
rückgabezeit;
});
let diff = times[1] - times[0];

return (diff < 0) ? diff + 1440 : diff;
}

// code goes here

var times = str.split('-');
var von = mal[0], bis = mal[1];
funktion parseMinutes(timeStr) {
var time = timeStr.match(/d+/g);
var hour = parseInt(Zeit[0]), minute = parseInt(Zeit[1]);
var ampm = (timeStr.match(/[a|p]m/g)[0] === 'am') ? 0 : 1;
if (hour === 12) hour = 0;
return (hour + ampm * 12) * 60 + Minute;

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

var difference = toMinutes - fromMinutes;
var oneDayInMinutes = 24 * 60;
return (difference < 0) ? oneDayInMinutes + difference : difference;

}

unten
Mittlerer Modus
Lassen Sie die Funktion MeanMode (arr) das in arr gespeicherte Zahlenarray nehmen
und 1 zurückgeben, wenn der Modus gleich dem Mittelwert ist, 0, wenn sie nicht gleich sind (d. h. [5, 3,
3, 3, 1] sollte 1 zurückgeben, weil der Modus (3) gleich dem Mittelwert (3) ist). Das Array ist nicht leer,
enthält nur positive ganze Zahlen und nicht mehr als einen Modus.
Beispiele
Eingang: [1, 2, 3]
Ausgang: 0
Eingang: [4, 4, 4, 6, 2]
Ausgang: 1
funktion MeanMode(arr) {
len = arr.length
//Schritt 1: Mittelwert ermitteln - selbsterklärend
funktionsmittelwert (arr) {
var count = 0;
for (var i = 0; i < len; i++) {
count += arr[i]
}
console.log (count / len)
rückgabezähler/ len
}
//Schritt 2: Bestimmen Sie den Modus. Wir müssen zählen, wie viele von jedem Typ
im Array sind. Eine Alternative besteht darin, einen Zähler am Laufen zu halten, das
Array zu sortieren und dann zu zählen, bis sich ein Element ändert, wobei die
maximale Anzahl und der zugehörige Wert im Auge behalten werden. Das Folgende ist
ein viel einfacherer Weg, vorausgesetzt, man hat eine grundlegende Vertrautheit mit
Javascript-Objekten. Es macht jeden neuen Eintrag zu einem Schlüssel und zählt, wie
viele davon vorhanden sind, und erstellt dann ein Array der erstellten Schlüssel-
Wert-Paare.
funktionsmodus(arr) {
var obj = {};
for (var i = 0, len = arr.length; i < len; i++) {
if (obj[arr[i]] === undefined) {
obj[arr[i]] = 1;
}
else {
obj[arr[i]]++;
}
}
var objarr = [];
für (x in obj) {
objarr.push([x, obj[x]]);
}
objarr.sort(function(a, b) {return b[1] - a[1]});
console.log(objarr[0][0]);
return objarr[0][0];
}
//Vergleichen Sie den Mittelwert und den Modus
return mode(arr) == mean(arr)? 1: 0;
}

MeanMode(readline());
// Suchmodus
let mostOccurances = 0;
let mode = 0;
let marco = arr[i];
for (let j = i+1, count = 0; j < arr.length; j++) {
if (marco === arr[j]) {
// match!
count++;
if (count > mostOccurances) {
mostOccurances = count;
mode = arr[j];
}
}
}
}
//Mittelwert finden
let mean = 0;
mean += arr[i];
}
mean = Math.round(mean/arr.length);
return (mean === mode) ? 1 : 0;

// code goes here

funktionsmodus(arr) {
var counts = [], mode, maxCount = 0;
for (num of arr) {
num = num + ' ';
if (counts[num]) counts[num]++;
else counts[num] = 1;
}
für (Anzahl der Zählungen) {

if (counts[num] > 1 && counts[num] > maxCount) {
mode = parseInt(num);
maxCount = counts[num];
}
}
rückgabemodus;
}
funktionsmittelwert (arr) {
return arr.reduce(function(a,b) {return a+b;}, 0) / arr.length;
}
return mode(arr) === mean(arr) ? 1 : 0;

}

unten
Armaturenbrett-Eins
Lassen Sie die FunktionDashInsert (str) Bindestriche ('-') zwischen jeweils zwei ungeraden
Zahlen in str einfügen. Zum Beispiel: Wenn str 454793 ist, sollte die Ausgabe 4547-9-3 sein. Zähle
die Null nicht als ungerade Zahl.
Beispiele
Eingang: 99946
Ausgang: 9-9-946
Eingang: 56730
Ausgang: 567-30
funktion DashInsert(num) {
var strnum = num.toString();
var arr = strnum.split("");
for (i = 0; i < arr.length; i++) {

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

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

unten
DashInsert(readline());
funktion DashInsert(str) {
let newString = str[0];
for (let i = 1, lastOdd = str[0] % 2; i < str.length; i++) {

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

funktion DashInsert(str) {
// code goes here

var digits = str.split('');
funktion isOdd(n) {
return parseInt(n) % 2 === 1;
}
for (var i = 0; i < digits.length - 1; i++) {

if ( isOdd(Digits[i]) && isOdd(Digits[i+1]) ) {
digits.splice(i + 1, 0, '-');
i++;
}
}
return digits.join('');
}

unten
Tauschkoffer
Lassen Sie die FunktionSwapCase (str) den str-Parameter nehmen und die
Groß-/Kleinschreibung jedes Zeichens vertauschen. Zum Beispiel: Wenn str "Hello World" ist, sollte
die Ausgabe hELLO wORLD sein. Lassen Sie Zahlen und Symbole so bleiben, wie sie sind.
Beispiele
Eingabe: „Hello-LOL“
Ausgabe: hELLO-lol
Eingabe: „Sup DUDE!!?“

Output: sUP dude!!?
function SwapCase(str) {
arr = str.split("");
for (var i = 0; i < arr.length; i++) {
if (arr[i] == arr[i].toUpperCase()) {
arr[i] = arr[i].toLowerCase();
}
else if (arr[i] == arr[i].toLowerCase()) {
arr[i] = arr[i].toUpperCase();
}
}
str = arr.join("");
return str;

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

const UPPER = 'ABCDEFGHIJKLMNOPWRSTUVWXYZ';
let newString = '';

if (LOWER.includes(str[i])) {
newString += str[i].toUpperCase();
} else if (UPPER.includes(str[i])) {
newString += str[i].toLowerCase();
} else {
}
}
return newString;
}

// code goes here

return str.split('').map(Funktion(Buchstabe) {
if (letter === letter.toLowerCase()) return letter.toUpperCase();
else if (letter === letter.toUpperCase()) return letter.toLowerCase();
sonst Rückschreiben;
}).join('');
}

unten
Zahlenhinzufügung
Lassen Sie die FunktionNumberSearch (str) den Parameter str verwenden, suchen Sie nach
allen Zahlen in der Zeichenfolge, fügen Sie sie zusammen und geben Sie diese endgültige Zahl zurück.
Zum Beispiel: Wenn str "88Hello 3World!" ist, sollte die Ausgabe 91 sein. Sie müssen zwischen
einstelligen Zahlen und mehrstelligen Zahlen wie im obigen Beispiel unterscheiden. "55Hello" und
"5Hello 5" sollten also zwei verschiedene Antworten zurückgeben. Jede Zeichenfolge enthält mindestens
einen Buchstaben oder ein Symbol.
Beispiele
Eingang: "75Number9"
Ausgang: 84
Eingang: "10 2One Nummer*1*"

Ausgang: 13
funktion NumberAddition(str) {
var sum = 0;
var count = 0;
var strArr = function(str) {
//Nimm die Nicht-Ziffern heraus und ersetze sie durch Leerzeichen, um sie
getrennt zu halten
str = str.replace(/[^0-9]/g, ' ');
//alle vorherigen oder letzten Leerzeichen entfernen
str = str.trim();
//Doppelte Leerzeichen in einzelne Leerzeichen umwandeln, bis keine Doppelten
mehr übrig sind
while (str.indexOf(' ') !== -1) {
str = str.replace(/ss/g, ' ');
}
//ein Array von Zahlenzeichenfolgen ohne Leerzeichen zurückzugeben;
return str.split(' ');
}
//Rufen Sie die strArr-Funktion auf der Benutzereingabe auf und speichern Sie sie
als "vorbereitet"
var prepped = strArr(str);
//jede Zahlenfolge in eine Zahl verwandeln
prepped = prepped.map(Funktion(Wert) {
return val ? parseInt(val): 0;
})
console.log( 'preppedmap', vorbereitet);
//Führen Sie die Reduce-Methode aus, um alle Zahlen zu addieren
var ans = prepped.reduce(Funktion(firstval, lastval){
return firstval + lastval
})
rückgabe ans
}

unten
NumberAddition(readline());
let DIGITS = '0123456789';

let numbers = [];
// First find numbers

for (let i = 0, number = ''; i < str.length; i++) {
if (!DIGITS.includes(str[i])) {
if (number !== '') {
numbers.push(number);
}
number = '';
} else {
number += str[i];
// Sonderfall für letztes Zeichen

if (i === str.length-1) {
numbers.push(number);
}
}
}
let sum = 0;
for (let i = 0; i < numbers.length; i++) {
sum += parseInt(Zahlen[i]);
}
rücksumme;
}

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

Am drittgrößten
Lassen Sie die FunktionThirdGreatest (strArr) das in strArr gespeicherte Array von Strings
nehmen und das drittgrößte Wort darin zurückgeben. Also zum Beispiel: Wenn strArr ["hello",
"world", "before", "all"] ist, sollte Ihre Ausgabe Welt sein, weil "before" 6 Buchstaben lang ist und
"hello" und "world" beide 5 sind, aber die Ausgabe sollte Welt sein, weil sie als das letzte 5-
Buchstaben-Wort im Array erscheint. Wenn strArr ["hello", "world", "after", "all"] war, sollte die
Ausgabe nachher sein, da die ersten drei Wörter alle 5 Buchstaben lang sind, geben Sie also den letzten
zurück. Das Array hat mindestens drei Zeichenfolgen und jede Zeichenfolge enthält nur Buchstaben.
Beispiele
Eingabe: ["Coder","Byte","Code"]
Ausgabe: Code
Eingabe: ["abc","defg","z","hijk"]
Ausgabe: abc
funktion ThirdGreatest(strArr) {
strArr.sort(function(a, b) {return b.length - a.length});
return strArr[2];
}

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

// code goes here

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

unten
Zweierpotenzen
Lassen Sie die FunktionPowersofTwo (num) den übergebenen Parameter num, der eine ganze
Zahl ist, nehmen und die Zeichenfolge true zurückgeben, wenn es sich um eine Zweierpotenz handelt.
Wenn dies nicht der Fall ist, wird die Zeichenfolge false zurückgegeben. Zum Beispiel, wenn die
Eingabe 16 ist, dann sollte Ihr Programm die Zeichenfolge true zurückgeben, aber wenn die Eingabe 22
ist, dann sollte die Ausgabe die Zeichenfolge false sein.
Beispiele
Eingang: 4
Ausgang: wahr
Eingang: 124
Ausgang: false
funktion PowersofTwo(num) {
if (num < 2){

ans = "false";
}
else {
while (num >= 2){
var test = num%2;
if (test == 0){
num = num/2
ans = "true";}
else{
num = 0;
ans = "false"}
}
}
// code goes here
return ans;
}
unten
PowersofTwo(readline());
return Number.isInteger(Math.log(num) / Math.log(2)) ? true : false;

// code goes here

if (num === 1) return true;
else {
return (num % 2 === 0) ? PowersofTwo(num / 2) : false;
}
}

unten
Additive Persistenz
Lassen Sie die Funktion AdditivePersistenz(num) den übergebenen num -Parameter, der immer
eine positive ganze Zahl sein wird, nehmen und seine additive Persistenz zurückgeben, die die Anzahl
der Male ist, die Sie die Ziffern in num hinzufügen müssen, bis Sie eine einzelne Ziffer erreichen. Zum
Beispiel: Wenn num 2718 ist, dann sollte Ihr Programm 2 zurückgeben, weil 2 + 7 + 1 + 8 = 18 und 1 +
8 = 9 und Sie bei 9 anhalten.
Beispiele
Eingang: 4
Ausgang: 0
Eingang: 19
Ausgang: 2
funktion AdditivePersistenz(num) {
funktion arrprep(numb) {
var numstr = numb.toString();
var arr = numstr.split('');
var numarr = arr.map(function(val) {
return parseInt(val)
})
rücksendungsnummer
}
funktionszusatz (arr) {
var redux = arr.reduce(Funktion(a, b){
return a + b })
retourenreduzierung
}
var count = 0;
while (num > 9) {

num = addup(arrprep(num));
count++;
}
rückgabezähler

unten
AdditivePersistenz(readline());
num = num.toString();
let count = 0;
while (count < 10000) { // harter Stopp

if (num.length === 1) {
pause;
}
count++;
let sum = 0;
for (let i = 0; i < num.length; i++) {
sum += parseInt(num[i]);
}
num = sum.toString();
}
rückgabezählung;
}

// code goes here

funktion addDigits(num) {
return num.toString().split('').map(function(num) {
return parseInt(num);
}).reduce(function(a, b) {return a + b;}, 0);
}
var result = num;

var count = 0;
while (result > 9) {
result = addDigits(result);
count++;
}
rückgabezählung;
}

unten
Multiplikative Persistenz
Lassen Sie die Funktion Multiplikative Persistenz (num) den übergebenen num -Parameter,
der immer eine positive ganze Zahl sein wird, nehmen und seine multiplikative Persistenz zurückgeben,
die die Anzahl der Male ist, die Sie die Ziffern in num multiplizieren müssen, bis Sie eine einzelne
Ziffer erreichen. Zum Beispiel: Wenn num 39 ist, dann sollte Ihr Programm 3 zurückgeben, weil 3 * 9 =
27, dann 2 * 7 = 14 und schließlich 1 * 4 = 4 und Sie bei 4 anhalten.
Beispiele
Eingang: 4
Ausgang: 0
Eingang: 25
Ausgang: 2
funktion Multiplikative Persistenz (num) {
funktion numprep(num) {
var strnum = num.toString();
var arr = strnum.split('');
var numarr = arr.map(function(val) {
return parseInt(val)});
rücksendungsnummer
}
function multnums(arr) {
var newnum = arr.reduce(Funktion(a, b) {
return a * b})
return newnum
}
// code goes here
var count = 0;
while (num > 9) {

num = multnums(numprep(num));
count++
}
rückgabezähler
}

unten
Multiplikative Persistenz (readline());
let count = 0;
while(1) {
if (num.length === 1) {
pause;
}
count++;
let sum = 1;
sum *= parseInt(num[i]);
}
num = sum.toString();
}
rückgabezählung;

// code goes here

funktion multiplyDigits(num) {
return num.toString().split('').map(function(num) {
return parseInt(num);
}).reduce(function(a, b) {return a * b;}, 1);
}
var result = num;
var count = 0;
while (result > 9) {
result = multiplyDigits(result);
count++;
}
rückgabezählung;
}

unten
Offline-Minimum
Lassen Sie die Funktion OffLineMinimum (strArr) den übergebenen strArr-

Parameter nehmen, der ein Array von ganzen Zahlen im Bereich von 1...n und dem Buchstaben "E"
ist, und geben Sie die richtige Teilmenge basierend auf den folgenden Regeln zurück. Die Eingabe
erfolgt in folgendem Format: ["I", "I","E","I",..., "E",...,"I"] wobei das I für ganze Zahlen steht und das E
bedeutet, dass die kleinste ganze Zahl, die derzeit im gesamten Satz vorhanden ist, herausgenommen
wird. Wenn Sie fertig sind, sollte Ihr Programm diesen neuen Satz mit durch Kommas getrennten
Ganzzahlen zurückgeben. Zum Beispiel: Wenn strArr ["5", "4", "6", "E", "1", "7", "E", "E", "3", "2"]
ist, dann sollte Ihr Programm 4,1,5 zurückgeben.
Beispiele
Eingabe: ["1","2","E","E","3"]
Ausgabe: 1,2
Eingabe: ["4","E","1","E","2","E","3","E"]
Ausgabe: 4,1,2,3
funktion OffLineMinimum(strArr) {
var len = strArr.length;
var count = 0;
var holdArr = [];
var ans = [];
for(var i = 0; i < len; i++) {

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

unten
OffLineMinimum(readline());
let result = [];

for (let i = 0; i < strArr.length; i++) {
if (strArr[i] === 'E') {
result.push(removeSmallest(strArr, i));
} else if (strArr[i] === 'R') {
//Nichts tun
} else {
// number do nothing
}
}
funktion removeSmallest(strArr, maxIndex) {
let smallestIndex = 0;
let smallestNumber = null;
strArr.forEach(Funktion(Wert,Index){
if (index > maxIndex) {
rückgabe;
}
if (value !== 'E' && value !== 'R') {
if (leastNumber === null || parseInt(value) < smallestNumber) {
smallestIndex = index;
leastNumber = parseInt(Wert);
}
}
});
strArr[smallestIndex] = 'R';
kleinsteZahl zurückgeben;
}
return result.join(',');

// code goes here
var arr = [], result = [];
var log = "";
für (Artikel von strArr) {
if (item === 'E') {
result.push(arr.shift());
} else {
arr.push(parseInt(item));
arr = arr.sort(function(a, b) {return a - b});
}
}
return result.join(',');
}

unten
Reihenfolge ändern
Lassen Sie die Funktion ChangingSequence(arr) das in arr gespeicherte Zahlenarray nehmen
und den Index zurückgeben, bei dem die Zahlen aufhören zu steigen und anfangen zu fallen oder
aufhören zu fallen und anfangen zu steigen. Zum Beispiel: Wenn arr [1, 2, 4, 6, 4, 3, 1] ist, dann sollte
Ihr Programm 3 zurückgeben, weil 6 der letzte Punkt im Array ist, an dem die Zahlen ansteigen und die
nächste Zahl eine abnehmende Sequenz beginnt. Das Array enthält mindestens 3 Zahlen und darf nur
eine einzige Sequenz enthalten, die zu- oder abnimmt. Wenn es nur eine einzige Sequenz im Array gibt,
sollte Ihr Programm -1 zurückgeben. Die Indizierung sollte mit 0 beginnen.
Beispiele
Eingang: [-4, -2, 9, 10]

Ausgang: -1
Eingang: [5, 4, 3, 2, 10, 11]

Ausgang: 3
function ChangingSequence(arr) {
//Bestimmen Sie zunächst, ob es sich um eine zunehmende oder abnehmende Sequenz
handelt
var type = arr[1] - arr[0] > 0 ? 'ansteigend' : 'absteigend';
//Legen Sie einen maximalen Index des Arrays fest, um ein Überlaufen zu
verhindern
var maxInd = arr.length - 1;
//Code für ein zunehmendes Array

if (type === 'ansteigend') {
//findIndex ist eine Array-Iterationsmethode, die mit ES6 eingeführt wurde.
Es kehrt zurück
//der erste Wert, für den der Rückruf false zurückgibt.
var index = arr.findIndex(Funktion(val, ind) {
while (ind < maxInd) {
return val > arr[ind + 1];
}
return false;
});
renditeindex;
}
if (type === 'abnehmend') {

var index = arr.findIndex(Funktion(val, ind) {
while (ind < maxInd) {
return val < arr[ind + 1]
}
return 0;
});
renditeindex;
}
}

ChangingSequence(readline());
let index = null;

let mode = (arr[1] - arr[0] > 0) ? true : false;
if (arr[i] - arr[i-1] > 0 !== Modus) {
index = i-1;
pause;
}
}
return (index === null) ? -1 : index;
}

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

wenn (ansteigend) {
if (arr[i] > arr[i + 1]) return i;
} else {
if (arr[i] < arr[i + 1]) return i;
}
}
return -1;
}

Überlappende Bereiche
Lassen Sie die Funktion OverlappingRanges (arr) das in arr gespeicherte Zahlenarray nehmen,
das 5 positive ganze Zahlen enthält, wobei die ersten beiden einen Zahlenbereich (a bis b) darstellen, die
nächsten 2 auch einen anderen ganzen Zahlenbereich (c bis d) darstellen, und ein letztes fünftes Element
(x), das ebenfalls eine positive ganze Zahl ist, und die Zeichenfolge TRUE zurückgeben, wenn sich
beide Sätze von Bereichen um mindestens x Zahlen überlappen. Zum Beispiel: Wenn arr [4, 10, 2, 6, 3]
ist, dann sollte Ihr Programm die Zeichenfolge true zurückgeben. Der erste Zahlenbereich ist 4, 5, 6, 7,
8, 9, 10 und der zweite Zahlenbereich ist 2, 3, 4, 5, 6. Das letzte Element im Array ist 3, und es gibt 3
Zahlen, die sich zwischen beiden Bereichen überlappen: 4, 5 und 6. Wenn sich beide Bereiche nicht um
mindestens x Zahlen überlappen, sollte Ihr Programm die Zeichenfolge false zurückgeben.
Beispiele
Eingabe: [5,11,1,5,1]
Ausgabe: wahr
Eingabe: [1,8,2,4,4]
Ausgabe: falsch
funktion OverlappingRanges(arr) {
var target = arr.pop();
var MaxLowerBound = Math.max(arr[0], arr[2]);
var MinUpperBound = Math.min(arr[1], arr[3]);
var range = MinUpperBound - MaxLowerBound + 1;
return range >= target ? 'true' : 'false';

}

OverlappingRanges(readline());
let count = 0;
for (let i = arr[0]; i <= arr[1]; i++) {
if (i >= arr[2] && i <= arr[3]) {
count++;
}
}
return (count >= arr[4]) ? true : false;
}

var range1 = [arr[0], arr[1]]; // (a, b)
var range2 = [arr[2], arr[3]]; // (c, d)
var minimumOverlap = arr[4] - 1;
// bestimmt die Überlappung zwischen zwei Bereichen

// eine negative Zahl bedeutet, dass es keine Überlappung gibt
funktionsüberschneidung (Bereich1, Bereich2) {
if (range1[0] < range2[0]) {
// a----b
// c----d
return (range1[1] > range2[1] ? range2[1] : range1[1]) - range2[0];
} else {
// a----b
// c---d
return (range2[1] > range1[1] ? range1[1] : range2[1]) - range1[0];
}
}
rücklaufüberlappung (Bereich1, Bereich2) >= minimumOverlap;

}

Supererhöhend
Lassen Sie die FunktionSupererhöhend (arr) das in arr gespeicherte Zahlenarray nehmen und
bestimmen, ob das Array eine supererhöhende Sequenz bildet, bei der jedes Element im Array größer als
die Summe aller vorherigen Elemente ist. Das Array besteht nur aus positiven ganzen Zahlen. Zum
Beispiel: Wenn arr [1, 3, 6, 13, 54] ist, dann sollte Ihr Programm die Zeichenfolge "true" zurückgeben,
weil es eine supererhöhende Sequenz bildet. Wenn keine überhöhte Sequenz gebildet wird, sollte Ihr
Programm die Zeichenfolge "false" zurückgeben
Beispiele
Eingabe: [1,2,3,4]
Ausgabe: falsch
Eingabe: [1,2,5,10]
Ausgabe: wahr
funktion Superincreasing(arr) {
var maxInd = arr.length - 1;
var target;
var sum;
für (var i = maxInd; i > 0; i--) {

target = arr.pop()
sum = arr.reduce(Funktion(val1, val2) {
return val1 + val2;
});
if (sum >= soll) {
return 'false';
}
};
return 'true';
}
Supererhöhend(readline());
for (let i = 0, sum = 0; i < arr.length; i++) {

if (arr[i] <= sum) {
return false;
}
sum += arr[i];
}
return true;
}

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

if (arr[i] <= total) return false;
total += arr[i];
}
return true;
}

Hamming-Abstand
Lassen Sie die FunktionHammingDistance (strArr) das in strArr gespeicherte Array

von Strings nehmen, das nur zwei Strings gleicher Länge enthält, und geben Sie den Hamming-Abstand
zwischen ihnen zurück. Der Hamming-Abstand ist die Anzahl der Positionen, an denen die
entsprechenden Zeichen unterschiedlich sind. Zum Beispiel: Wenn strArr ["coder", "codec"] ist, dann
sollte Ihr Programm 1 zurückgeben. Die Zeichenfolge ist immer gleich lang und enthält nur
Kleinbuchstaben aus dem Alphabet und Zahlen.
Beispiele
Eingabe: ["10011", "10100"]

Ausgabe: 3
Eingabe: ["helloworld", "worldhello"]

Ausgabe: 8
funktion HammingDistance(strArr) {
let count = 0;
for (let i = 0; i < strArr[0].length; i++) {
if (strArr[0][i] !== strArr[1][i]) {
count++
}
}
rückgabezählung;
}

HammingDistance(readline());
var word1 = strArr[0],
word2 = strArr[1],
len = word1.length,
count = 0;
for (var i = 0; i < len; i++) {

if (word1[i] !== word2[i]) {
count++;
}
}
rückgabezählung;
}

var hammingDistance = 0;
for (var i = 0; i < strArr[0].length; i++) {
if (strArr[0][i] !== strArr[1][i]) {
hammingDistance++;
}
}
hammingDistance zurückgeben;
}

Rechteckbereich
Am besten bewertete Benutzerlösung
funktion RectangleArea(strArr) {
var obj = {};
obj.x1 = parseInt(strArr[0].match(/((-*d+)/)[1], 10);
obj.y1 = parseInt(strArr[0].match(/(-*d+))/)[1], 10);
for (var i = 1; i < 3; i++) {

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

RectangleArea(readline());
//Eingabe in Array analysieren

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

sei x = Punkt[0];
sei y = Punkt[1];
let deltaX = 0;
let deltaY = 0;
coords.forEach(function(val){
if (x === val[0]) {
deltaY = Math.abs(val[1] - y);
}
if (y === val[1]) {
deltaX = Math.abs(val[0] - x);
}
});
return deltaX * deltaY;

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

}

Bitweise Eins
Lassen Sie die FunktionBitwiseOne (strArr) das in strArr gespeicherte Array von Strings
nehmen, das nur zwei Strings gleicher Länge enthält, die Binärzahlen darstellen, und einen endgültigen
Binärstring zurückgeben, der die bitweise ODER-Verknüpfung auf beiden Strings durchgeführt hat. Eine
bitweise ODER-Operation platziert eine 0 in der neuen Zeichenfolge, wobei es Nullen in beiden
Binärzeichenfolgen gibt, andernfalls platziert sie eine 1 an dieser Stelle. Zum Beispiel:
Wenn strArr ["1001", "0100"] ist, dann sollte Ihr Programm die Zeichenfolge "1101" zurückgeben
Beispiele
Eingabe: ["100", "000"]

Ausgabe: 100
Eingabe: ["00011", "01010"]
Ausgabe: 01011
funktion BitwiseOne(strArr) {
var str1 = strArr[0];
var str2 = strArr[1];
var newStr = '';
len = str1.length;
for (var i = 0; i < len; i++) {

if(str1.charAt(i) === '1' || str2.charAt(i) === '1') {
newStr = newStr += '1';
} else {
newStr = newStr += '0';
}
}
return newStr;
}

BitwiseOne(readline());
var output = '';
if (strArr[0][i] === '1' || strArr[1][i] === '1') {
output += '1';
} else {
output += '0';
}
}
rücklaufausgang;
}

let newString = '';

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

Andere Produkte
Lassen Sie die Funktion OtherProducts (arr) das in arr gespeicherte Zahlenarray nehmen
und eine neue Liste der Produkte aller anderen Zahlen im Array für jedes Element zurückgeben. Zum
Beispiel: Wenn arr [1, 2, 3, 4, 5] ist, dann ist das neue Array, wobei jede Position im neuen Array das
Produkt aller anderen Elemente ist, [120, 60, 40, 30, 24]. Die folgenden Berechnungen wurden
durchgeführt, um diese Antwort zu erhalten: [(2*3 * 4*5), (1*3 * 4*5), (1*2*4*5), (1*2*3*5),
(1*2*3*4)]. Sie sollten dieses neue Array generieren und dann die Zahlen als Zeichenfolge mit einem
Bindestrich zurückgeben: 120-60-40-30-24. Das Array enthält höchstens 10 Elemente und mindestens 1
Element mit nur positiven ganzen Zahlen.
Beispiele
Eingang: [1,4,3]
Ausgang: 12-3-4
Eingabe: [3,1,2,6]
Ausgabe: 12-36-18-6
funktion AndereProdukte(arr) {
let holdArray = [];
arr.forEach((val, ind, theArray) => {

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

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

OtherProducts(readline());
let results = [];

let product = 1;
for (let j = 0; j < arr.length; j++) {
if (i !== j) {
product *= arr[j];
}
}
results.push(Produkt);
}
gibt results.join('-') zurück;
}

funktionsprodukt (arr) {
return arr.reduce((a,b) => a * b);
}
var products = [];
var other = arr.slice(0, i).concat(arr.slice(i + 1));
products.push(Produkt(andere));
}
products.join ('-') zurückgeben;
}

Wellensortierung
Lassen Sie die Funktion WaveSorting (arr) das in arr gespeicherte Array positiver Ganzzahlen
nehmen und die Zeichenfolge true zurückgeben, wenn die Zahlen in einem Wellenmuster angeordnet
werden können: a1 > a2 < a3 > a4 < a5 > ..., andernfalls geben Sie die Zeichenfolge false zurück. Zum
Beispiel, wenn arr ist: [0, 1, 2, 4, 1, 4], dann ist eine mögliche Wellenordnung der Zahlen: [2, 0, 4, 1,
4, 1]. Für diese Eingabe sollte Ihr Programm also den String true zurückgeben. Das Eingabearray enthält
immer mindestens 2 Elemente. Weitere Beispiele sind unten als Beispiel-Testfälle aufgeführt.
Beispiele
Eingabe: [0, 1, 2, 4, 1, 1, 1]
Ausgabe: falsch
Eingabe: [0, 4, 22, 4, 14, 4, 2]

Ausgabe: wahr
funktion WaveSorting(arr) {
//Wenn wir darüber nachdenken, wird das gewünschte Ergebnis möglich sein, solange
wir keine Nummer haben
//öfter als andere Zahlen, um es aufzubrechen
//Gesamtanzahl der Zahlen abrufen

let length = arr.length;
//die Anzahl der Einträge für jede Nummer abrufen

let countObj = {};
arr.forEach(val => {
if (!countObj[val]) {
countObj[val] = 1;
} else {
countObj[val]++;
}
});
//eine Reihe unserer Ergebnisse erstellen, damit wir den maximalen

let countArr = [];
for (let key in countObj) {
countArr.push(countObj[key]);
}
//finde das Maximum - du musst nicht mehr apply() verwenden!

let maxCount = Math.max(...countArr);
return maxCount > length/2 ? false : true;

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

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

if (i % 2 === 0) {
newArr.push(arr.splice(0, 1));
} else {
// Look and take next element smaller than arr[i]
for (let j = 1; j < arr.length; j++) {
wenn (arr[j] < arr[0]) {
newArr.push(arr.splice(j, 1));
pause;
}
}
}
// Check if new Arr is wave sorted

for (let i = 0; i < newArr.length-1; i++) {
if (i % 2 === 0) {
// i > i+1 = wahr
if (parseInt(newArr[i]) <= parseInt(newArr[i+1])) {
return false;
}
} else {
// i < i+1 = wahr
if (parseInt(newArr[i]) >= parseInt(newArr[i+1])) {
return false;
}
}
}
return true;
}

// finden Sie die Anzahl des häufigsten Elements, nämlich den Modus
funktion mostFrequent(arr) {
arr.sort();
var most = 0;
var frequency = 1;
if (arr[i] === arr[i + 1]) {
frequenz++;
if (frequency > most) {
most = Frequenz;
}
} else {
frequency = 1;
}
}
am meisten zurückzugeben;
}
// Solange wir eine andere Zahl zwischen die gleiche Zahl setzen können,
funktioniert es
return mostFrequent(arr) < (arr.length / 2);
}

Array-Matching
Lassen Sie die FunktionArrayMatching (strArr) das in strArr gespeicherte Array von Strings
lesen, das nur zwei Elemente enthält, die beide ein Array positiver Ganzzahlen darstellen. Zum Beispiel:
Wenn strArr ["[1, 2, 5, 6]", "[5, 2, 8, 11]"] ist, dann repräsentieren beide Elemente in der Eingabe
zwei ganzzahlige Arrays, und Ihr Ziel für diese Herausforderung ist es, die Elemente an entsprechenden
Stellen aus beiden Arrays hinzuzufügen. Für die Beispieleingabe sollte Ihr Programm die folgenden
Ergänzungen vornehmen: [(1 + 5), (2 + 2), (5 + 8), (6 + 11)], die dann gleich [6, 4, 13, 17] sind. Ihr
Programm sollte dieses resultierende Array schließlich in einem String-Format zurückgeben, wobei jedes
Element durch einen Bindestrich getrennt ist: 6-4-13-17.
Wenn die beiden Arrays nicht die gleiche Anzahl von Elementen aufweisen, hängen Sie die
verbleibenden Elemente einfach an das neue Array an (Beispiel unten). Beide Arrays haben das Format:
[e1, e2, e3, ...], wobei mindestens ein Element in jedem Array vorhanden ist.
Beispiele
Eingabe: ["[5, 2, 3]", "[2, 2, 3, 10, 6]"]

Ausgabe: 7-4-6-10-6
Eingabe: ["[1, 2, 1]", "[2, 1, 5, 2]"]

Ausgabe: 3-3-6-2
function ArrayMatching(strArr) {
strArr = strArr.map(val => val.replace(/[[]]/g, '')
.split(/s*,s*/).map(val1 => parseInt(val1, 10)));
let resArr = [];

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

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

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

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

numbers2.length;
let results = [];

for (let i = 0; i < maxLength; i++) {
let num1 = (i < numbers1.length) ? parseInt(numbers1[i]) : 0;
let num2 = (i < numbers2.length) ? parseInt(numbers2[i]) : 0;
results.push(num1 + num2);
}
gibt results.join('-') zurück;

}

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

arr2 = arr2.concat(neues Array(arr1.length - arr2.length).fill(0));
} else if (arr1.length < arr2.length) {
arr1 = arr1.concat(neues Array(arr2.length - arr1.length).fill(0));
}
var sum = [];
for (var i = 0; i < arr1.length; i++) {
sum.push(arr1[i] + arr2[i]);
}
sum.join ('-') zurückgeben;
}

Binäre Umkehrung
Lassen Sie die Funktion BinaryReversal (str) den übergebenen Parameter str, der eine positive
ganze Zahl ist, seine binäre Darstellung (auf die nächsten N * 8 Bits aufgefüllt) nehmen, diese Bitfolge
umkehren und dann schließlich die neue umgekehrte Zeichenfolge in Dezimalform zurückgeben. Zum
Beispiel: Wenn str "47" ist, dann ist die binäre Version dieser ganzen Zahl 101111, aber wir füllen sie
mit 00101111 auf. Ihr Programm sollte diese Binärzeichenfolge umkehren, die dann zu: 11110100 wird,
und dann schließlich die Dezimalversion dieser Zeichenfolge zurückgeben, die 244 ist.
Beispiele
Eingang: "213"
Ausgang: 171
Eingang: "4567"
Ausgang: 60296
funktion BinaryReversal(str) {
let num = parseInt(str, 10)

.toString(2);
let length = num.length;
//füge führende Nullen hinzu, um die Zahl zu einer ganzzahligen Anzahl von Bytes
zu machen
let byteString = `${'0'.repeat(length % 8 === 0 ? 0 : 8 - length % 8)}${num}`;
lassen stringByte = byteString.split('')

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

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

while (binary.length < size) {
binary = '0' + binary;
}
let newString = '';

for (let i = 0; i < binary.length; i++) {
newString = binär[i] + newString;
}
return parseInt(newString, 2);

}

function toBinary(str) {
result = Number(str).toString(2);
// Pad links mit führenden 0s, um es zu einem Vielfachen von 8 Ziffern zu
machen...
wenn (result.length % 8 !== 0)
return new Array(8 - (result.length % 8)).fill(0).join('') + result;
sonst Ergebnis zurückgeben;
}
function toDecimal(str) {
return parseInt(str, 2);
}
//return toBinary(str);
var reverse = toBinary(str).split('').reverse().join('');
return toDecimal(reverse);
}

Längste ansteigende Sequenz
Lassen Sie die FunktionLongestIncreasingSequence (arr) das in arr gespeicherte Array

positiver Ganzzahlen nehmen und die Länge der längsten ansteigenden Teilsequenz (Lis) zurückgeben.
Ein Lis ist eine Teilmenge der ursprünglichen Liste, in der die Zahlen in sortierter Reihenfolge vom
niedrigsten zum höchsten und in zunehmender Reihenfolge angeordnet sind. Die Sequenz muss nicht
zusammenhängend oder eindeutig sein, und es kann mehrere verschiedene Teilsequenzen geben. Zum
Beispiel: Wenn arr [4, 3, 5, 1, 6] ist, dann ist ein mögliches Lis [3, 5, 6] und ein anderes [1, 6]. Für
diese Eingabe sollte Ihr Programm 3 zurückgeben, da dies die Länge der am längsten ansteigenden
Teilsequenz ist.
Beispiele
Eingang: [9, 9, 4, 2]
Ausgang: 1
Eingabe: [10, 22, 9, 33, 21, 50, 41, 60, 22, 68, 90]
Ausgabe: 7
function LongestIncreasingSequence(arr) {
let len = arr.length;
let arrHolder = [];
//jede mögliche Zahlenkombination bewerten

for (let i = Math.pow(2, len); i < Math.pow(2, len + 1); i++) {
//numArray ist eine binäre Ziffer, wobei die 0s und 1s darstellen, ob

eingeschlossen werden soll
//eine Zahl oder nicht im Kombinationsfeld. Es wird 2 ^ n Kombinationen
geben
//um führende Nullen zu erhalten, verwenden Sie Zahlen von 2^n bis 2^n+1 und
schneiden Sie dann die führende 1 ab
let numArray = i.toString(2).slice(1).split('');
//die ausgewählten Zahlen im newSeq-Array halten

newSeq = [];
//Füllen Sie das newSeq-Array aus
arr.forEach((val, ind) => {
if (numArray[ind] === '1') {
newSeq.push(val);
}
});
//newSeq-Array in arrHolder aufnehmen

arrHolder.push(newSeq);
}
//Nehmen Sie alle Arrays heraus, die nicht aufsteigend sind (verwenden Sie das
Ascend (), um zu bestimmen)
arrHolder = arrHolder.filter(val => aufsteigend(val));
//Ersetzen Sie jedes durchlaufende Array durch seine Länge

let arrLength = arrHolder.map(val => val.length);
//gibt den größten Längenwert zurück

return Math.max(...arrLength);
}
funktion Ascend(inputArr) {
let arrlen = inputArr.length;
return inputArr.every((val, ind) => {
if (ind < arrlen - 1) {
return val < inputArr[ind + 1];
}
return true;
});
}

LongestIncreasingSequence(readline());
// https://stackoverflow.com/questions/2631726/how-to-determine-the-longest-
increasing-subsequence-using-dynamic-programming
// Von hier aus verwendeter Algorithmus
let lis = [arr[0]];

if (arr[i] > lis[lis.length - 1]) {
lis.push(arr[i]);
fortfahren;
}
for (let j = 0; j < lis.length; j++) {

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

// erzeugt n true/false Permutationen

// dies wird verwendet, um Teilfolgen zu generieren - um dieses Element einzubeziehen
oder nicht
funktion permute(n) {
if (n < 1) return Null;
if (n < 2) return [[wahr], [falsch]];
var previous = permute(n - 1);
var result = [];
for (var permutation of previous) {
result.push(permutation.concat([true]));
result.push(permutation.concat([false]));
}
rückgabeergebnis;
}
// erhalte alle möglichen Unterfolgen

funktion getSubSequences(arr) {
return permute(arr.length).map(function(permutation) {
var result = [];
for (var i = 0; i < permutation.length; i++) {
if (Permutation[i]) {
result.push(arr[i]);
}
}
rückgabeergebnis;
});
}
funktion erhöht(arr) {
return arr.every(function(value, index, arr) {
var prev = (index === 0) ? 0: arr[index - 1];
return prev < value;
});
}
var longest = 0;
var subSequences = getSubSequences(arr);

für (var subSequenz von subSequenzen) {
if(increasing(subSequence) && subSequence.length > längste) {
longest = subSequence.length;
}
}
rendite am längsten;
}

Gleichmäßige Paare
Lassen Sie die FunktionEvenPairs (str) den übergebenen Parameter str nehmen und
bestimmen, ob irgendwo in der Zeichenfolge ein Paar benachbarter gerader Zahlen vorhanden ist. Wenn
ein Paar vorhanden ist, geben Sie die Zeichenfolge true zurück, andernfalls false. Zum Beispiel:
Wenn str "f178svg3k19k46" ist, dann gibt es zwei gerade Zahlen am Ende der Zeichenfolge "46", also
sollte Ihr Programm die Zeichenfolge true zurückgeben. Ein weiteres Beispiel: Wenn str "7r5gg812"
ist, dann ist das Paar "812" (8 und 12), also sollte Ihr Programm die Zeichenfolge true zurückgeben.
Beispiele
Input: "3gy41d216"
Output: true
Eingabe: "f09r27i8e67"
Ausgabe: falsch
funktion EvenPairs(str) {
var regEx = /[24680]d*[24680]/
return regEx.test(str);

EvenPairs(readline());
const DIGITS = '0123456789';
let numberGroups = [];
//Zifferngruppen abrufen
for (let i = 0, digitStr = ''; i < str.length; i++) {
let isDigit = DIGITS.includes(str[i]);
if (isDigit) {
digitStr += str[i];
}
if (digitStr.length > 0 && (i === str.length - 1 || !isDigit)) {

numberGroups.push(digitStr);
digitStr = '';
}
}
//Kümmert sich nur um die Gruppenlänge > 1

numberGroups = numberGroups.filter(v => v.length > 1);
// Schleife über alle "Gruppen"

for (let i = 0; i < numberGroups.length; i++) {
// Verschachtelte Schleifen für jede Gruppe
for (let j = 0; j < numberGroups[i].length; j++) {
for (let k = j + 1; k < numberGroups[i].length; k++) {
let str1 = numberGroups[i].substr(0, j+1);
let str2 = numberGroups[i].substr(j+1, k);
if (parseInt(str1) % 2 === 0 && parseInt(str2) % 2 === 0) {
return true;
}
}
}
}
return false;
}

// prüfen, ob es mehr als zwei Paare gerader Zahlen gibt

funktion hasEvenPairs(number) {
// Nicht-gierige Übereinstimmung gerader Zahlen
var result = number.toString().match(/\d*?[24680]/g);
return (result === null) ? false : (result.length >= 2);
}
var numbers = str.match(/\d+/g);
für (var number of numbers) {
if (hasEvenPairs(number)) return true;
}
return false;
}

Nächstes Palindrom
Lassen Sie die FunktionNextPalindrome (num) den übergebenen Parameter num nehmen und
die nächstgrößte palindromische Zahl zurückgeben. Die Eingabe kann eine beliebige positive ganze Zahl
sein. Zum Beispiel: Wenn num 24 ist, dann sollte Ihr Programm 33 zurückgeben, weil das die
nächstgrößte Zahl ist, die ein Palindrom ist.
Beispiele
Eingang: 2
Ausgang: 3
Eingang: 180
Ausgang: 181
funktion NextPalindrome(num) {
let count = num + 1;
while (true) {
numString = count.toString();
revString = numString.split('')
.reverse()
.join('');
if (revString === numString) return parseInt(numString, 10);
count++;
}
}

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

for (let i = num + 1; ; i++) {
let string = i.toString();
if (isPalindrome(string)) {
nextPalindrome = i;
pause;
}
}
return nextPalindrome;
funktion isPalindrome(str) {
return false;
}
}
return true;
}
}

funktion istPalindrom(num) {
var numStr = num.toString();
return numStr.split('').reverse().join('') === numStr;
}
var nextNum = num + 1;
while (!isPalindrome(nextNum)) {
nextNum++;
}
return nextNum;
}

Größtes Paar
Lassen Sie die FunktionLargestPair (num) den übergebenen Parameter num nehmen und die
größte zweistellige Zahl innerhalb der ganzen Zahl bestimmen. Zum Beispiel: Wenn num 4759472 ist,
sollte Ihr Programm 94 zurückgeben, da dies die größte zweistellige Zahl ist. Die Eingabe enthält immer
mindestens zwei positive Ziffern.
Beispiele
Eingang: 453857
Ausgang: 85
Eingang: 363223311
Ausgang: 63
funktion LargestPair(num) {
let numStr = num.toString();
let numArr = numStr.split('')

.map(val => parseInt(val, 10));
//die Endziffer loswerden, falls sie die größte ist;

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

}

LargestPair(readline());
let largestNum = 0;
let testNum = parseInt(num[i-1] + num[i]);
if (testNum > largestNum) {
largestNum = testNum;
}
}
return largestNum;
}
var max = 0;
var numStr = num.toString();
// Schiebefenster mit Größe 2

for (var i = 0; i < numStr.length - 1; i++) {
var testNum = Nummer(numStr.slice(i, i + 2));
if (testNum > max) {
max = testNum;
}
}
return max;
}

Nicht wiederholendes Zeichen
Lassen Sie die FunktionNonrepeatingCharacter (str) den übergebenen

Parameter str übernehmen, der nur alphabetische Zeichen und Leerzeichen enthält, und geben Sie das
erste nicht wiederholte Zeichen zurück. Zum Beispiel: Wenn str "agettkgaeee" ist, sollte Ihr
Programm k zurückgeben. Die Zeichenfolge enthält immer mindestens ein Zeichen und es gibt immer
mindestens ein sich nicht wiederholendes Zeichen.
Beispiele
Eingabe: „abcdef“
Ausgabe: a
Eingabe: „Hallo Welt hallo“

Ausgabe: w
function NonrepeatingCharacter(str) {
let len = str.length;
let countObj = {}
for (let i = 0; i < len; i++) {

if (countObj[str[i]]) {
countObj[str[i]]++;
}
else {
countObj[str[i]] = 1;
}
}
for (let j = 0; j < len; j++) {
if (countObj[str[j]] === 1) return str[j];
}
}

Nicht wiederholendes Zeichen (readline());
let repeatingChars = '';

let result = '';
let repeating = false;
for (let j = i+1; j < str.length; j++) {
if (str[i] === str[j] || repeatingChars.includes(str[i])) {
repeating = true;
repeatingChars += str[i];
pause;
}
}
if (!repeating) {
result = str[i];
pause;
}
}
rückgabeergebnis;
}

str = str.replace(/\s+/g, '');
var counts = {};
//jeden Buchstaben zählen

for (var i = 0; i < str.length; i++) {
if (str[i] in counts) {
zählt[str[i]]++;
} else {
zählt[str[i]] = 1;
}
}
//den ersten Buchstaben mit der Zählung 1 zurücksenden

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

Zwei Summen
Lassen Sie die FunktionTwoSum (arr) das in arr gespeicherte Array ganzer Zahlen nehmen und
bestimmen, ob zwei beliebige Zahlen (mit Ausnahme des ersten Elements) im Array zum ersten Element
im Array summiert werden können. Zum Beispiel: Wenn arr [7, 3, 5, 2, -4, 8, 11] ist, dann gibt es
tatsächlich zwei Paare, die sich zur Zahl 7 addieren: [5, 2] und [-4, 11]. Ihr Programm sollte alle Paare
mit den durch ein Komma getrennten Zahlen in der Reihenfolge zurückgeben, in der die erste Zahl im
Array erscheint. Paare sollten durch ein Leerzeichen getrennt sein. Für das obige Beispiel würde Ihr
Programm also Folgendes zurückgeben: 5,2 -4,11
Wenn es keine zwei Zahlen gibt, die sich zum ersten Element im Array addieren, geben Sie -1 zurück
Beispiele
Eingabe: [17, 4, 5, 6, 10, 11, 4, -3, -5, 3, 15, 2, 7]

Ausgabe: 6,11 10,7 15,2
Eingabe: [7, 6, 4, 1, 7, -2, 3, 12]

Ausgabe: 6,1 4,3
funktion TwoSum(arr) {
let target = arr.shift();
let holdArr = [];
for (let i = 0; i < len; i++) {

for (let j = i + 1; j < len; j++) {
if (arr[i] + arr[j] === Ziel) {
holdArr.push(`${arr[i].toString()},${arr[j].toString()}`);
pause;
}
}
}
return holdArr.length ? holdArr.join(' ') : -1;
}

TwoSum(readline());
const answer = arr.shift(arr);

const history = new Set();
const matches = [];
// Ohne hier umzukehren(), werden die Endergebnisse in der Reihenfolge

// die zweite Zahl erscheint im Array, aber wir möchten, dass sie
// nach der ersten Zahl geordnet.
arr.reverse();
arr.forEach(item => {
const compliment = answer - item;
if (history.has(compliment)) {
matches.push([item, compliment]);
} else {
history.add(item);
}
});
// Die Übereinstimmungen wurden in umgekehrter Reihenfolge auf das Array

geschoben, so
// Jetzt müssen wir sie zurückschalten.
matches.reverse();
return (matches.length === 0) ? -1 : matches.map(m => m.join(',')).join(' ');

}

TwoSum(readline());
//Paare finden, die zur angegebenen Zahl summieren

function findPairs(arr, sum) {
var pairs = [];
for (var j = i + 1; j < arr.length; j++) {
if (arr[i] + arr[j] === Summe)
pairs.push([arr[i], arr[j]]);
}
}
paare zurückgeben;
}
var pairs = [];
var sum = arr[0];
var rest = arr.slice(1);
paare = Paare finden (Ruhe, Summe);
return (pairs.length === 0) ? -1 : pairs.map(pair => pair.join(',')).join(' ');

}

TwoSum(readline());
Bitweise Zwei
Lassen Sie die FunktionBitwiseTwo (strArr) das in strArr gespeicherte Array

von Zeichenfolgen nehmen, das nur zwei Zeichenfolgen gleicher Länge enthält, die Binärzahlen
darstellen, und eine endgültige Binärzeichenfolge zurückgeben, die die bitweise UND-Operation für
beide Zeichenfolgen ausgeführt hat. Eine bitweise UND-Operation platziert eine 1 in der neuen
Zeichenfolge, wo es eine 1 an beiden Stellen in den Binärzeichenfolgen gibt, andernfalls platziert sie
eine 0 an dieser Stelle. Zum Beispiel: Wenn strArr ["10111", "01101"] ist, dann sollte Ihr Programm
die Zeichenfolge "00101" zurückgeben
Beispiele
Eingabe: ["100", "000"]

Ausgabe: 000
Eingabe: ["10100", "11100"]

Ausgabe: 10100
funktion BitwiseTwo(strArr) {
let num1 = strArr[0];
let num2 = strArr[1];
let len = strArr[0].length;
let resStr = '';
for (let i = 0; i < len; i++) {

if (num1[i] === '1' && num2[i] === '1') {
resStr += '1';
fortfahren;
}
else {
resStr += '0';
fortfahren;
}
}
return resStr;
}

BitwiseTwo(readline());
let newStr = '';

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

var result = '';
if (strArr[0][i] === '1' && strArr[1][i] === '1') {
result += '1';
} else {
result += '0';
}
}
rückgabeergebnis;
}

Zählung des Leistungssatzes
Lassen Sie die FunktionPowerSetCount (arr) das Array der in arr gespeicherten Ganzzahlen
nehmen und die Länge des Leistungssatzes (die Anzahl aller möglichen Sätze) zurückgeben, die
generiert werden können. Zum Beispiel: Wenn arr [1, 2, 3] ist, dann bilden die folgenden Sätze den
Leistungssatz:
[]
[1]
[2]
[3]
[1, 2]
[1, 3]
[2, 3]
[1, 2, 3]
Sie können sehen, dass vor allem mögliche Sätze zusammen mit dem leeren Satz erzeugt werden. Daher
sollte Ihr Programm für diese Eingabe 8 zurückgeben.
Beispiele
Eingang: [1, 2, 3, 4]
Ausgang: 16
Eingang: [5, 6]
Ausgang: 4
funktion PowerSetCount(arr) {
return Math.pow(2, len);
}

PowerSetCount(readline());
return Math.pow(2, arr.length);
}

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

Produktziffern
Lassen Sie die Funktion ProductDigits(num) den übergebenen Parameter num übernehmen, der
eine positive ganze Zahl ist, und bestimmen Sie die geringste Anzahl von Ziffern, die Sie multiplizieren
müssen, um sie zu erzeugen. Zum Beispiel: Wenn num 24 ist, dann können Sie 8 mit 3 multiplizieren,
was 24 ergibt, also sollte Ihr Programm 2 zurückgeben, weil insgesamt nur 2 Ziffern benötigt werden.
Ein weiteres Beispiel: Wenn num 90 ist, können Sie 10 * 9 multiplizieren. In diesem Fall sollte Ihr
Programm 3 ausgeben, da Sie 90 nicht erreichen können, ohne insgesamt 3 Ziffern in Ihrer
Multiplikation zu verwenden.
Beispiele
Eingang: 6
Ausgang: 2
Eingang: 23
Ausgang: 3
funktion ProductDigits(num) {
let pivot = Math.sqrt(num);
let value = num.toString().length + 1;
for (let i = 1; i <= pivot; i++) {
if (num % i === 0) {
let maxFactor = i;
maxCompFactor = num / maxFactor;
maxFactorString = maxFactor.toString();
maxCompFactorString = maxCompFactor.toString();
let totalLength = maxFactorString.length +
maxCompFactorString.length;
if (totalLength < value) {
value = totalLength;
}
}
}
rückgabewert;
}

ProductDigits(readline());
let pf = primeFactors(num);
if (pf.length === 1) {
return pf[0].toString().length + 1;
}
let factors = [];
for (let divider = 0; divider < pf.length; divider ++) {

let left = pf.slice(0, Teiler);
let right = pf.slice(Teiler, pf.length);
let leftProduct = left.reduce((Produkt, Wert) => Produkt *= Wert, 1);

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

val) => val < max ? val : max, Number.MAX_SAFE_INTEGER);
funktion primeFactors(num) {
if (num === 1) return 1;
let pf = [];
for (let i = 2; i <= num; i++) {

if (num % i === 0) {
pf.push(i);
num /= i;
i = 1;
}
}
return pf;
}
}

funktion getDivisors(num) {
var divisors = [1];
for (var i = 2; i <= num / 2; i++) {
if (num % i === 0) {
divisors.push(i);
}
}
divisors.push(num);
teiler zurückzugeben;
}
var divisors = getDivisors(num);
var pairs = [];
for (var i = 0; i < divisors.length / 2; i++) {

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

}

Palindrom-Ersteller
Lassen Sie die Funktion PalindromeCreator(str) den übergebenen str -Parameter nehmen
und bestimmen, ob es möglich ist, eine palindromische Zeichenfolge mit einer Mindestlänge von 3
Zeichen durch Entfernen von 1 oder 2 Zeichen zu erstellen. Zum Beispiel: Wenn str "abjchba" ist,
dann können Sie die Zeichen jc entfernen, um "abhba" zu erzeugen, das ein Palindrom ist. In diesem
Beispiel sollte Ihr Programm die beiden Zeichen, die entfernt wurden, ohne Trennzeichen und in der
Reihenfolge zurückgeben, in der sie in der Zeichenfolge erscheinen, also jc. Wenn 1 oder 2 Zeichen
nicht entfernt werden können, um ein Palindrom zu erzeugen, geben Sie die Zeichenfolge nicht zurück.
Wenn die Eingabezeichenfolge bereits ein Palindrom ist, sollte Ihr Programm die
Zeichenfolge Palindrom zurückgeben.
Die Eingabe enthält nur Kleinbuchstaben. Ihr Programm sollte immer versuchen, die längste
palindromische Teilzeichenfolge zu erstellen, indem Sie 1 oder 2 Zeichen entfernen (siehe als Beispiel
den zweiten Beispiel-Testfall). Die 2 Zeichen, die Sie entfernen, müssen nicht neben der Zeichenfolge
stehen.
Beispiele
Eingabe: „mmop“
Ausgabe: nicht möglich
Eingabe: „kjjjhjj“
Ausgabe: k
function PalindromeCreator(str) {
//test to see if it is a Palindrome already
if (isPalindrome(str)) {
return 'palindrome';
}
for (let i = 0; i < len; i++) {
let testArray = str.split('');
let res = testArray.splice(i, 1);
let newString = testArray.join('');
if (isPalindrome(newString)) {
console.log('one');
return res.join('');
}
}
for (let i = 0; i < len; i++) {
let res = [];
for (let j = i; j < len - 1; j++) {
let testArray = str.split('');
res[0] = testArray.splice(i, 1);
res[1] = testArray.splice(j, 1);
let newString = testArray.join('');
if(isPalindrome(newString)) {
return res.join('');
}
}
}
return 'nicht möglich';
}
//-------------------Helfer---------------------------
let newStr = str.split('').reverse().join('');
if (newStr === str) {
return true;
}
return false;
}

PalindromeCreator(readline());
if (isPalindrome(str)) {
return 'palindrome';
}
//Combos erstellen
let combos = [];
for (let i = 0, max = Math.pow(2, str.length); i < max; i++) {
let combo = i.toString(2);
// Filter für Null, Eins oder Zwei 1s (1 steht für Entfernen)

let count = 0;
for (let j = 0; j < combo.length; j++) {
if (combo[j] === '1') {
count++;
}
}
// Zu groß, ignorieren und zum nächsten Versuch gehen!
if (count > 2) {
fortfahren;
}
// Pad Good Combo

while (combo.length < str.length) {
combo = '0' + combo;
}
combos.push(combo);
}
let palindromeCombos = [];
//Entfernungskombos ausprobieren
for (let i = 0; i < combos.length; i++) {
let tryString = '';
for (let j = 0; j < combos[i].length; j++) {
tryString += (combos[i][j] === '1') ? '' : str[j];
}
if (tryString.length >= 3 && isPalindrome(tryString)) {

palindromeCombos.push(Kombos[i]);
}
}
if (palindromeCombos.length === 0) {
}
// Sortieren Sie so, dass die ersten beiden gefundenen Buchstaben zuerst
zurückgegeben werden, wenn
// es gibt mehrere Werte
palindromeCombos.sort(Funktion(a,b){
return parseInt(a,2) < parseInt(b,2);
});
//Kürzeste Entfernung finden und zurückgeben <=> längstes Palindrom

let shortestCount = null;
letestCombo = '';
palindromeCombos.forEach(Funktion(Combo){
let count = 0;
for (let i = 0; i < combo.length; i++) {
if (combo[i] === '1') {
count++;
}
}
if (shortestCount === null || Anzahl < shortestCount) {
shortestCount = count;
shortestCombo = combo;
}
});
let result = '';

if (shortestCombo[i] === '1') {
result += str[i];
}
}
rückgabeergebnis;
return (str === str.split('').reverse().join('')) ? true : false;
}

return str === str.split('').reverse().join('');
}
if (isPalindrome(str)) return 'Palindrom';

//ein Zeichen an Position i entfernen
var newStr = str.slice(0, i).concat(str.slice(i + 1));
if (isPalindrome(newStr)) {
return str[i];
}
}

//zwei Zeichen an Position i und j entfernen, wobei (i < j)
for (var j = i + 1; j < str.length; j++) {
var newStr2 = str.slice(0, i).concat(str.slice(i + 1,
j)).concat(str.slice(j + 1));
if (isPalindrome(newStr2)) {
return str[i] + str[j];
}
}
}
return "nicht möglich";
}

Grundlegende römische Ziffern
Lassen Sie die Funktion BasicRomanNumerals(str) str lesen, die eine Zeichenfolge aus
römischen Ziffern sein wird. Die verwendeten Ziffern sind: I für 1, V für 5, X für 10, L für 50, C für
100, D für 500 und M für 1000. In römischen Ziffern, um eine Zahl wie 11 zu erstellen, addieren Sie
einfach eine 1 nach der 10, so dass Sie XI erhalten. Um jedoch eine Zahl wie 19 zu erstellen, verwenden
Sie die Subtraktionsnotation , bei der ein I vor einem X oder V addiert wird (oder ein X vor einem L oder
C). 19 in römischen Ziffern ist also XIX.
Das Ziel Ihres Programms ist es, das Dezimaläquivalent der angegebenen römischen Zahl
zurückzugeben. Zum Beispiel: Wenn str "XXIV" ist, sollte Ihr Programm 24 zurückgeben
Beispiele
Eingang: "IV"
Ausgang: 4
Eingang: "XLVI"
Ausgang: 46
funktion BasicRomanNumerals(str) {
let letterObj = {
I: 1,
V: 5,
X: 10,
L: 50,
C: 100,
D: 500,
M: 1000
}
let res = 0;
for (let i = 0; i < len; i++) {
if (!letterObj[str[i + 1]] || letterObj[str[i]] >= letterObj[str[i +
1]]) {
res += letterObj[str[i]];
} else {
res += (letterObj[str[i + 1]] - letterObj[str[i]]);
i++;
}
}
return res;
}

BasicRomanNumerals(readline());
/*
Symbol I V X L C D M
Wert 1 5 10 50 100 500 1,000
*/
const ROMAN_I = 1;
const ROMAN_V = 5;
const ROMAN_X = 10;
const ROMAN_L = 50;
const ROMAN_C = 100;
const ROMAN_D = 500;
const ROMAN_M = 1000;
let sum = 0;

let symbol = str[i];
let nextSymbol = (i+1 >= str.length) ? null : str[i+1];
switch(symbol) {
fall 'I':
if (nextSymbol === 'V') {
sum += ROMAN_V - ROMAN_I;
i++;
} else if (nextSymbol === 'X') {
sum += ROMAN_X - ROMAN_I;
i++;
} else {
sum += ROMAN_I;
}
pause;
fall 'V':
sum += ROMAN_V;
pause;
fall 'X':
if (nextSymbol === 'L') {
sum += ROMAN_L - ROMAN_X;
i++;
} else if (nextSymbol === 'C') {
sum += ROMAN_C - ROMAN_X;
i++;
} else {
sum += ROMAN_X;
}
pause;
fall 'L':
sum += ROMAN_L;
pause;
fall 'C':
if (nextSymbol === 'D') {
sum += ROMAN_D - ROMAN_C;
i++;
} else if (nextSymbol === 'M') {
sum += ROMAN_M - ROMAN_C;
i++;
} else {
sum += ROMAN_C;
}
pause;
fall 'D':
sum += ROMAN_D;
pause;
fall 'M':
sum += ROMAN_M;
pause;
default:
// Illegaler Saibling oder Platz
pause;
}
}
rücksumme;
}

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

//Laufen Sie weiter, während es am Anfang ein Spiel gibt
while (str.indexOf(romans[i]) === 0) {
output += decimals[i];
str = str.replace(romans[i], '');
}
}
rücklaufausgang;
}

Lebensmittelvertrieb
Lassen Sie die Funktion FoodDistribution (arr) das in arr gespeicherte Zahlenfeld lesen,
das das Hungerniveau verschiedener Personen zwischen 0 und 5 darstellt (0 bedeutet überhaupt nicht
hungrig, 5 bedeutet sehr hungrig). Sie werden auch N Sandwiches zum Verschenken haben, die von 1 bis
20 reichen. Das Format des Arrays ist [N, h1, h2, h3, ...], wobei N die Anzahl der Sandwiches darstellt,
die Sie haben, und der Rest des Arrays die Hungerstufen verschiedener Personen darstellt. Ihr Ziel ist es,
den Hungerunterschied zwischen den einzelnen Personen im Array mit den verfügbaren Sandwiches zu
minimieren.
Zum Beispiel: Wenn arr [5, 3, 1, 2, 1] ist, bedeutet dies, dass Sie 5 Sandwiches ausgeben müssen. Sie
können sie in der folgenden Reihenfolge an die Personen verteilen: 2, 0, 1, 0. Wenn man diese
Sandwiches den Menschen gibt, wird ihr Hungerlevel jetzt: [1, 1, 1, 1]. Die Differenz zwischen jedem
Paar von Personen ist jetzt 0, die Summe ist auch 0, also sollte Ihr Programm 0 zurückgeben. Hinweis:
Möglicherweise müssen Sie nicht alle oder sogar nur einige Ihrer Sandwiches ausgeben, um einen
minimierten Unterschied zu erzielen.
Ein weiteres Beispiel: Wenn arr [4, 5, 2, 3, 1, 0] ist, können Sie die Sandwiches in der folgenden
Reihenfolge verteilen: [3, 0, 1, 0, 0], was alle Hungerstufen zu folgenden macht: [2, 2, 2, 1, 0]. Die
Unterschiede zwischen jedem Paar von Personen sind jetzt: 0, 0, 1, 1 und so sollte Ihr Programm die
endgültige minimierte Differenz von 2 zurückgeben.
Beispiele
Eingang: [5, 2, 3, 4, 5]
Ausgang: 1
Eingang: [3, 2, 1, 0, 4, 1, 0]
Ausgang: 4
funktion FoodDistribution(arr) {
let treats = arr.shift();
let myArray = arr.slice(0);
let arrMin = arr.sort((val1, val2) => val2 - val1).pop()
let len = myArray.length;
//check to see if we have enough treats to get everyone to the current best
level
let testCount = myArray.reduce((val1, val2) => {
return val1 + val2 - arrMin;
}, 0);
if (testCount <= treats) {
return 0;
}
let valQuantArr = objectify(myArray);

for (let i = 1; i < 25; i++) {
let arrayLen = valQuantArr.length;
let resp = flattenMid(valQuantArr, treats, i);
valQuantArr = resp[0];
arrayLen = valQuantArr.length;
treats = resp[1];
while (valQuantArr[0].quant <= i && valQuantArr[0].value >
valQuantArr[1].value && treats >= i) {
if (valQuantArr[0].quant <= behandelt) {
valQuantArr[0].value--;
treats -= valQuantArr[0].quant;
valQuantArr = objectify(valQuantArr);
}
}
while (valQuantArr[arrayLen - 1].quant <= i && valQuantArr[arrayLen -

1].value > valQuantArr[arrayLen - 2].value && treats >= i) {
if (valQuantArr[arrayLen - 1].quant <= treats) {
valQuantArr[arrayLen - 1].value--;
treats -= valQuantArr[arrayLen - 1].quant;
valQuantArr = objectify(valQuantArr);
}
}
}
let count = 0;
for (let i = 0, len = valQuantArr.length; i < len - 1; i++) {
count += Math.abs(valQuantArr[i].value - valQuantArr[i + 1].value);
}
rückgabezählung;
}
//-----------------helfers-----------------------
flattenMid = (arr, treats, q) => {
let index = 0;
while (behandelt > 0 && index > -1) {
index = arr.findIndex((val, ind) => {
return val.quant <= q && ind >= 1 && ind < arr.length - 1 &&
val.value > arr[ind - 1].value && val.value > arr[ind + 1].value;
});
if (index >= 0) {
arr[index].value --;
treats -= q;
}
}
return [objektivieren(arr), behandelt];
}
//verwandelt ein Array in ein Objekt mit dem Wert gleich der Zahl, und die
//quant ist die Anzahl der Male, die es in einer Reihe auftritt
objectify = (array) => {
//if it is the array of numbers
if (typeof array[0] === 'number') {
let target = [];
let counter = 0;
for (let i = 0, len = array.length; i < len; i++) {
let val = array[i];
zähler++;
if (array[i] === array[i + 1]) {
fortfahren;
} else {
target.push({
value: array[i],
quant: Zähler
});
counter = 0;
}
}
renditeziel;
} else {
//Wenn es sich um ein Array von Objekten handelt, wandeln Sie es in ein
Array von Zahlen um und
//dann durch die Objectify-Methode laufen lassen
let targetArray = [];
array.forEach (val => {
while (val.quant) {
targetArray.push (Wert);
val.quant--;
}
});
return objectify(targetArray);
}
};

FoodDistribution(readline());
let sandwiches = parseInt(arr.shift());
//Combos generieren, Einschränkung dieser Methode, max. 32 Sandwiches

let combos = [];
for (let i = 0, max = Math.pow(sandwiches+1, arr.length); i < max; i++) {
let combo = i.toString(Sandwiches+1);
// Summe der Ziffern (Sandwiches) in Combo

let comboSum = parseInt(combo.split('').reduce((accumulator, currentValue) =>
accumulator + parseInt(currentValue, sandwiches+1), 0));
// Zu viele Sandwiches
if (comboSum > Sandwiches) {
fortfahren;
}
//Kann hier auch ein Häkchen setzen, um Sandwiches zu entfernen, die Hunger
verursachen würden < 0
// Pad Combos von guten Combos

while (combo.length < arr.length) {
}
if (comboSum <= sandwiches) {

combos.push(combo);
}
}
// Den geringsten Hungerunterschied finden

let lowestHungerDifference = null;
combos.forEach(Funktion(Combo){
let testArr = arr.slice();
testArr[i] -= Combo[i];
}
let diff = getHungerDifference(testArr);
lowestHungerDifference = (lowestHungerDifference === null || diff <
lowestHungerDifference) ? diff : lowestHungerDifference;
});
return lowestHungerDifference;
funktion getHungerDifference(arr){
let diff = 0;
diff += Math.abs(arr[i] - arr[i-1]);
}
return-Diff;
}

var N = arr[0];
var hungerLevels = arr.slice(1);
while (N > 0) {
var maxDifference = 0;
// der Index, der als nächstes mit einem Sandwich gefüttert werden soll
var mostNeeded = -1;
for (var i = 0; i < hungerLevels.length - 1; i++) {
var difference = Math.abs(hungerLevels[i + 1] - hungerLevels[i]);
if (difference > maxDifference) {
maxDifference = Differenz;
mostNeeded = (hungerLevels[i + 1] > hungerLevels[i]) ? (i + 1) : i;
}
}
// Jetzt wissen wir, wer das Sandwich so dringend braucht. Verschenke es
if (mostNeeded === -1) {
// die angrenzenden Unterschiede sind alle 0, also hör auf, die
Sandwiches wegzugeben
return 0;
} else {
hungerLevels[mostNeeded] -= 1;
N--;
}
}
//Summe benachbarter Differenzen berechnen

var sumOfDifferences = 0;
for (var i = 0; i < hungerLevels.length - 1; i++) {
sumOfDifferences += Math.abs(hungerLevels[i + 1] - hungerLevels[i]);
}
sumOfDifferences zurückgeben;
}

Drei Summen
Lassen Sie die FunktionThreeSum (arr) das in arr gespeicherte Array ganzer Zahlen nehmen
und bestimmen, ob drei verschiedene Zahlen (mit Ausnahme des ersten Elements) im Array zum ersten
Element im Array summiert werden können. Zum Beispiel: Wenn arr [8, 2, 1, 4, 10, 5, -1, -1] ist, dann
gibt es tatsächlich drei Sätze von Drillingen, die sich zur Zahl 8 addieren: [2, 1, 5], [4, 5, -1] und [10, -1,
-1]. Ihr Programm sollte den String true zurückgeben, wenn 3 verschiedene Elemente zum ersten
Element addieren, andernfalls sollte Ihr Programm den String false zurückgeben. Das Eingabearray
enthält immer mindestens 4 Elemente.
Beispiele
Eingabe: [10, 2, 3, 1, 5, 3, 1, 4, -4, -3, -2]

Ausgabe: wahr
Eingabe: [12, 3, 1, -5, -4, 7]

Ausgabe: falsch
funktion ThreeSum(arr) {
let target = arr.shift();
for (let i = 0; i < len - 2; i++) {
for (let j = i + 1; j < len - 1; j++) {
for (let k = i + 2; k < len; k++) {
wenn (arr[i] + arr[j] + arr[k] === Ziel) {
return "true";
}
}
}
}
return "false"
}

ThreeSum(readline());
let answer = parseInt(arr.shift());
//Combos generieren
let combos = [];
for (let i = 0, max = Math.pow(2, arr.length); i < max; i++) {
let digitsSum = parseInt(combo.split('').reduce((Akkumulator,Wert) =>

Akkumulator + parseInt(Wert), 0));
if (digitsSum !== 3) {
fortfahren;
}
//PAD-Ziffern
while (combo.length < arr.length) {
}
combos.push(combo);
}
/ /Testkombinationen
let goodCombos = [];
let sum = 0;
if (combo[i] === '1') {
sum += parseInt(arr[i]);
}
}
if (sum === answer) {
goodCombos.push(combo);
}
});
return (goodCombos.length > 0) ? true : false;
}
var sum = arr[0];
var-Nummern = arr.slice(1);
for (var i = 0; i < numbers.length; i++) {

for (var j = i + 1; j < numbers.length; j++) {
for (var k = j + 1; k < numbers.length; k++) {
if (Zahlen[i] + Zahlen[j] + Zahlen[k] === Summe) {
return 'true';
}
}
}
}
return 'false';
}

Richtiger Pfad
Lassen Sie die Funktion CorrectPath (str ) den übergebenen STR-Parameter lesen, der die
Bewegungen in einem 5x5-Raster von Zellen ab der oberen linken Position darstellt. Die Zeichen in der
Eingabezeichenfolge bestehen vollständig aus: r, l, u, d, ?. Jedes der Zeichen steht für die Richtung, die
innerhalb des Rasters zu nehmen ist, zum Beispiel: r = rechts, l = links, u = oben, d = unten. Ihr Ziel ist
es, zu bestimmen, welche Zeichen die Fragezeichen sein sollten, damit ein Pfad erstellt werden kann, der
von oben links im Raster bis ganz nach unten rechts reicht, ohne zuvor auf Zellen im Raster zu berühren.
Zum Beispiel: Wenn str "r?d?drdd" ist, dann sollte Ihr Programm die endgültige richtige Zeichenfolge
ausgeben, die es ermöglicht, einen Pfad von oben links eines 5x5-Rasters nach unten rechts zu bilden.
Für diese Eingabe sollte Ihr Programm daher den String rrdrdrdd zurückgeben. Es wird immer nur einen
richtigen Pfad geben und es wird immer mindestens ein Fragezeichen innerhalb der Eingabezeichenfolge
geben.
Beispiele
Eingabe: "???rrurdr?"
Ausgang: dddrrurdrd
Eingabe: "drdr??rrddd?"
Ausgabe: drdruurrdddd
function CorrectPath(str) {
//ein Array erstellen, um die Positionen der Fragezeichen zu halten
let blankArray = [];
//Position der Fragezeichen in das Array einfügen
str.split('').forEach((val, ind) => {
if (val === '?') {
blankArray.push(ind);
}
});
let num = blankArray.length;
//Wir werden jede Möglichkeit ausprobieren, bis wir eine gefunden haben, die
funktioniert. Dies werden 4^num Permutationen sein
let total = Math.pow(4, num);
for (let i = 0; i < total; i++) {

//gehen Sie jede Permutation durch, erstellen Sie zuerst eine
repräsentative Zahl, machen Sie dann den Pfad und testen Sie ihn
let numString = (i + total).toString(4).slice(1);
let currentPath = createPath(str, blankArray, numString);
if (isPathGood(currentPath)) {
currentPath zurückgeben;
}
}
}
isPathGood = (str) => {

//Erstellen Sie unser leeres Array
let testArray = []
for (let i = 0; i < 5; i++) {
testArray.push([0, 0, 0, 0, 0])
}

let currentLoc = [0, 0];
for (let i = 0; i < len; i++) {

//markiere unseren aktuellen Platz als besucht
testArray[currentLoc[0]][currentLoc[1]] = 1;
//Ändern Sie die Position basierend auf dem nächsten Buchstaben
let newLoc = currentLoc.slice(0);
switch (str[i]) {
fall 'u':
newLoc[0]--;
pause;
case 'd':
newLoc[0]++;
pause;
case 'r':
newLoc[1]++;
pause;
case 'l':
newLoc[1]--;
pause;
}
//Quit if we have gone off the board
if (newLoc.includes (-1) || newLoc.includes (5)) {
return false;
}
//beenden, wenn wir uns in einem zuvor besuchten Bereich befinden
if (testArray[newLoc[0]][newLoc[1]] === 1) {
return false;
}
//return true if we are at the target square on our last go
if (newLoc[0] === 4 && newLoc[1] === 4 && i === len - 1) {
return true;
}
//aktualisiere unseren Standort für die nächste Schleife;
currentLoc = newLoc;
}
return false;
};
createPath = (str, blanks, num) => {

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

CorrectPath(readline());
let numQmarks = str.split('').reduce((a,v) => a + (v === '?' | 0), 0);
//Kombos generieren, 0-r, 1-d, 2-l, 3-u

let combos = [];
for (let i = 0, max = Math.pow(4, numQmarks); i < max; i++) {
// Pad
while (combo.length < numQmarks) {
}
combos.push(combo);
}
let goodPaths = [];
// Try Paths
let comboArray = combo.split('');
let tryPath = '';
if (str[i] === '?') {
let direction = comboArray.shift();
schalter (Richtung) {
case '0': // right
tryPath += 'r';
pause;
case '1': // nach unten
tryPath += 'd';
pause;
fall '2': // links
tryPath += 'l';
pause;
case '3': // up
tryPath += 'u';
pause;
default:
// Sollte nie passieren
pause;
}
} else {
tryPath += str[i];
}
}
if (pathGood(tryPath)) {
goodPaths.push(tryPath);
}
});
// goodPaths nach der Spezifikation sollte immer nur = == 1 sein, aber dieser
Code kann mehr wahre Fälle behandeln
return goodPaths[0];
// Confirm/Deny good path (with Qmarks filled in)

funktionswegGut (Pfad) {
let startX = 0;
let startY = 0;
let grid = [
[1,0,0,0,0],
[0,0,0,0,0],
[0,0,0,0,0],
[0,0,0,0,0],
[0,0,0,0,0]
]; // Ziel 4,4
for (let i = 0; i < path.length; i++) {

schalter (Pfad[i]) {
case 'r':
startX++;
pause;
case 'd':
startY++;
pause;
case 'l':
startX--;
pause;
fall 'u':
startY--;
pause;
default:
// Sollte nie passieren
pause;
if (startX < 0 || startX > 4 || startY < 0 || startY > 4 || grid[startY]

[startX] === 1) {
// bereits gereist oder außerhalb des zulässigen Bereichs
return false;
}
grid[startY][startX] = 1;
}
return (startX === 4 && startY === 4) ? true : false;
}
}

// Überprüfen Sie, ob die angegebenen Richtungen die Ziellinie erreichen können

// ohne zuvor besuchte Positionen zu berühren
funktion canNavigate(str) {
var position = [0, 0];
var visited = {};
switch(str[i]) {
fall 'u':
position[0]--;
wenn (Position[0] < 0) false zurückgibt;
pause;
case 'd':
position[0]++;
if (position[0] > 4) return false;
pause;
case 'l':
position[1]--;
wenn (Position[1] < 0) false zurückgibt;
pause;
case 'r':
position[1]++;
if (position[1] > 4) return false;
pause;
default:
pause;
}
wenn (besucht[Position[0] + '-' + Position[1]]) {
// bereits besucht
return false;
} else {
//als besucht markieren
besucht[Position[0] + '-' + Position[1]] = i;
}
}
return (position[0] === 4 && position[1] === 4);

}
funktion findMissingChars(str) {
// zuerst alle möglichen Fälle generieren: Ersetzen ? mit Anweisungen
var permutations = [''];
if (str[i] === '?') {
var newPermutations = [];
permutations.forEach(Funktion(Permutation) {
newPermutations.push(Permutation + 'u');
newPermutations.push(Permutation + 'd');
newPermutations.push(Permutation + 'l');
newPermutations.push(Permutation + 'r');
});
permutations = newPermutations;
} else {
permutations = permutations.map(permutation => permutation + str[i]);
}
}
// jetzt nur gültige herausfiltern

// we need a net result of 4 downs and 4 rights
return permutations.filter(Funktion(Permutation) {
var rightCount = permutation.match(/[r]/g) === null ? 0 :
permutation.match(/[r]/g).length;
var leftCount = permutation.match(/[l]/g) === null ? 0 :
permutation.match(/[l]/g).length;
var upCount = permutation.match(/[u]/g) === null ? 0 :
permutation.match(/[u]/g).length;
var downCount = permutation.match(/[d]/g) === null ? 0 :
permutation.match(/[d]/g).length;
return (rightCount - leftCount === 4) && (downCount - upCount === 4);

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

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

Waagenausgleich
Lassen Sie die Funktion ScaleBalancing (strArr) strArr lesen, die zwei Elemente enthält,
wobei das erste die beiden positiven ganzzahligen Gewichte auf einer Waagschale (linke und rechte
Seite) und das zweite Element eine Liste der verfügbaren Gewichte als positive ganze Zahlen ist. Ihr Ziel
ist es, festzustellen, ob Sie die Waage ausgleichen können, indem Sie die geringste Menge an Gewichten
aus der Liste verwenden, aber höchstens 2 Gewichte verwenden. Zum Beispiel: Wenn strArr ["[5, 9]",
"[1, 2, 6, 7]"] ist, dann bedeutet dies, dass es eine Waagschale mit einem Gewicht von 5 auf der linken
Seite und 9 auf der rechten Seite gibt. Es ist tatsächlich möglich, diese Waage auszugleichen, indem man
eine 6 auf der linken Seite aus der Liste der Gewichte und eine 2 auf der rechten Seite hinzufügt. Beide
Skalen haben jetzt den Wert 11 und sind perfekt ausbalanciert. Ihr Programm sollte eine
kommagetrennte Zeichenfolge der Gewichtungen, die aus der Liste verwendet wurden, in aufsteigender
Reihenfolge zurückgeben, daher sollte Ihr Programm für dieses Beispiel die Zeichenfolge
zurückgeben 2,6
Es wird immer nur eine eindeutige Lösung geben und die Liste der verfügbaren Gewichtungen wird
nicht leer sein. Es ist auch möglich, nur auf einer Seite der Waage zwei Gewichte hinzuzufügen, um sie
auszugleichen. Wenn es nicht möglich ist, die Waage auszugleichen, sollte Ihr Programm die
Zeichenfolge nicht zurückgeben.
Beispiele
Eingabe: ["[3, 4]", "[1, 2, 7, 7]"]

Ausgabe: 1
Eingabe: ["[13, 4]", "[1, 2, 3, 6, 14]"]

Ausgabe: 3,6
funktion ScaleBalancing(strArr) {
//Wandeln Sie das Array in etwas Praktischeres um
let newArr = strArr.map(val => {
return val.replace(/[\[\]]/g, "").split(',').map(val2 => {
return parseInt(val2, 10);
}).sort((a, b) => {
return a - b;
});
});
let diff = newArr[0][1] - newArr[0][0];

let weights = newArr[1];
//führen Sie den Single-Gewicht-Lösungstest durch

if (weights.includes(diff)) {
return diff.toString();
}
//do the two-weights, one-side test
let weight1 = weights.find((val, ind) => {
let newWeights = weights.slice(0);
newWeights.splice(ind, 1);
return newWeights.includes (diff - val)
});
if (weight1) {
return `${weight1},${diff - weight1}`
}
//do the twp-weights, different sides, test
weight1 = weights.find(val => {
rückgabegewichte.einschließlich (Diff + Val);
});
if (weight1) {
return `${weight1},${diff + weight1}`
}
//wenn noch nichts zurückgegeben wird. . .
return `nicht möglich`;

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

parseInt(object));
let weights = strArr[1].substr(1, strArr[1].length-2) .split (', ').map(weight =>
parseInt(weight));
/*
Generieren Sie alle möglichen Kombinationen von Gewichten UND Permutationen
von links/rechts - 3^n mal
0 - Gewicht nicht in Gebrauch
1 - Gewicht auf der linken Seite
2 - Gewicht auf der rechten Seite
*/
let combos = [];
for (let i = 0, max = Math.pow(3, weights.length); i < max; i++) {
let numWeights = combo.split('').reduce((a,v) => a + (parseInt(v) > 0 | 0),
0);
// Zu viele Gewichte, verwerfe diese Kombination

if (numWeights > 2) {
fortfahren;
}
// Pad
while (combo.length < weights.length) {
}
combos.push(combo);
}
// console.log(combos);
/ /Testkombinationen
let goodCombos = [];
let left = objects[0];
let right = Objekte[1];

if (combo[i] === '1') { // Links
left += Gewichte[i];
}
if (combo[i] === '2') { // Rechts
rechts += Gewichte[i];
}
}
if (left === right) {

goodCombos.push(combo);
}
});
if (goodCombos.length === 0) {
}
// Sortieren Sie zuerst nach Anzahl der verwendeten physischen Gewichte, dann
nach Gesamtgewicht, wenn mehrere Sätze vorhanden sind
goodCombos.sort(Funktion(a, b){
let aCount = a.split('').reduce((ac,v) => ac + (parseInt(v) > 0 | 0), 0);
let bCount = b.split('').reduce((ac,v) => ac + (parseInt(v) > 0 | 0), 0);
if (aCount < bCount) {

return -1;
}
if (aCount > bCount) {
return 1;
}
// aCount === bCount -> muss Gewichte prüfen und insgesamt weniger Gewicht
verwenden
let aTotal = 0;
let bTotal = 0;
for (let i = 0; i < a.length; i++) {
if (a[i] !== '0') {
aTotal += Gewichte[i];
}
if (b[i] !== '0') {
bGesamt += Gewichte[i];
}
}
return aTotal - bTotal;
});
//console.log(goodCombos);
let theCombo = goodCombos[0];

let finalWeights = [];
theCombo.split('').map(Funktion(Wert, Index) {
if (value !== '0') {
finalWeights.push(Gewichte[Index]);
}
});
return finalWeights.sort((a,b) => a-b).join(',');

}

var weights = strArr[1].match(/\d+/g).map(Anzahl);
var weightsOnScale = strArr[0].match(/\d+/g).map(Zahl);
var leftWeight = weightsOnScale[0];
var rightWeight = weightsOnScale[1];
// Versuchen Sie nur ein Gewicht

for (var i = 0; i < weights.length; i++) {
if (leftWeight < rightWeight) {
if (leftWeight + weights[i] === rightWeight)
gewichte zurückgeben [i];
} else {
if (leftWeight === rechtsGewicht + Gewichte[i])
gewichte zurückgeben [i];
}
}
//Probiere jetzt zwei Gewichte aus

for (var i = 0; i < weights.length; i++) {
for (var j = i + 1; j < weights.length; j++) {
// füge auf jeder Seite eine hinzu
if (leftWeight + weights[i] === rightWeight + weights[j]) {
rückgabegewichte [i] + ',' + Gewichte[j];
} else if (leftWeight + weights[j] === rightWeight + weights[i]) {
}
// addiere zwei auf der leichteren Seite
if (leftWeight < rightWeight) {
if (leftWeight + weights[i] + weights[j] === rightWeight) {
}
} else {
if (leftWeight === rechtsGewicht + Gewichte[i] + Gewichte[j]) {
}
}
}
}
// keine Lösung
}

Drei Zahlen
Lassen Sie die FunktionThreeNumbers (str) den übergebenen str -Parameter nehmen und
bestimmen, ob innerhalb jedes Wortes in der Zeichenfolge genau drei eindeutige, einstellige Ganzzahlen
auftreten. Die ganzen Zahlen können überall im Wort erscheinen, aber sie können nicht alle
nebeneinander liegen. Wenn jedes Wort irgendwo genau 3 eindeutige Ganzzahlen enthält, geben Sie die
Zeichenfolge true zurück, andernfalls die Zeichenfolge false. Zum Beispiel: Wenn str "2hell6o3
wor6l7d2" ist, dann sollte Ihr Programm "true" zurückgeben, aber wenn die Zeichenfolge "hell268o
w6or2l4d" ist, dann sollte Ihr Programm "false" zurückgeben, weil alle ganzen Zahlen im ersten Wort
nebeneinander liegen.
Beispiele
Input: "2a3b5 w1o2rl3d g1gg92"

Output: true
Input: "21aa3a ggg4g4g6ggg"

Output: false
funktion ThreeNumbers(str) {
const DIGITS = '0123456789';
let words = str.split(' ');
let result = null;
words.forEach(Funktion(Wort){
let numbers = 0;
let threeAdnacent = false;
let usedDigits = '';
for (let i = 0; i < word.length; i++) {
// Auf verwendete Ziffern prüfen
if (usedDigits.includes(word[i])) {
// used! fail
result = false;
}
if (DIGITS.includes(word[i])) {
zahlen++;
usedDigits += word[i];
if (numbers === 3) {
if (DIGITS.includes(word[i-1]) && DIGITS.includes(word[i-2])) {
threeAdnacent = true;
}
}
}
// Auf 3 benachbarte vorangestellte Ziffern prüfen
}
if (numbers === 3 && !dreiAngrenzend) {

result = (result === null) ? true : result && true;
} else {
result = false;
}
});
rückgabeergebnis;
}

ThreeNumbers(readline());
var words = str.split(' ');
var numbersOfWords = words.map(word => word.match(/\d+/g));
for (var numbersOfWords) {

// Prüfung auf genau 3 Ziffern in jedem Wort
var digits = numbers.join('');
if (digits.length !== 3)
return false;
// keine 3 Ziffern hintereinander erlaubt
if (numbers.length !== Zahlen.filter(number => number.length < 3).length)
return false;
// keine doppelte Zahl in diesen 3 Zahlen
if ((Digits[0] === Digits[1]) ||
(Ziffern[1] === Ziffern[2]) ||
(Ziffern[2] === Ziffern[0]))
return false;
}
return true;
}

let array = str.split(' ');

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

Alphabetsuche
Lassen Sie die FunktionAlphabetSearching (str) den übergebenen

Parameter str übernehmen und die Zeichenfolge true zurückgeben, wenn jeder einzelne Buchstabe des
englischen Alphabets in der Zeichenfolge vorhanden ist. Andernfalls wird die Zeichenfolge false
zurückgegeben. Beispiel: Wenn str "zacxyjbbkfgtbhdaielqrm45pnsowtuv" ist, sollte Ihr Programm die
Zeichenfolge true zurückgeben, da jedes Zeichen im Alphabet in dieser Zeichenfolge vorhanden ist,
obwohl einige Zeichen mehr als einmal vorkommen.
Beispiele
Eingabe: „abcdefghijklmnopqrstuvwxyyyy“
Ausgabe: false
Eingabe: "abc123456kmo"
Ausgabe: false
funktion AlphabetSearching(str) {
str = str.toLowerCase();
for (let i = 97; i < 97 + 26; i++) {
let char = String.fromCharCode(i);
if (!str.includes(char)) {
return false;
}
}
return true;
}

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

if (!str.includes(LOWER_LETTERS[i])) {
return false;
}
}
return true;
}

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

Zeitdifferenz
Lassen Sie die FunktionTimeDifference (strArr) das in strArr gespeicherte Strings-Array

lesen, das eine unsortierte Liste von Malen in einem zwölfstündigen Format wie folgt sein wird:
HH:MM(am/pm). Ihr Ziel ist es, den kleinsten Unterschied in Minuten zwischen zwei der Zeiten in der
Liste zu bestimmen. Zum Beispiel: Wenn strArr ["14:10Uhr", "13:30Uhr", "10:30 Uhr", "16:42Uhr"]
ist, sollte Ihr Programm 40 zurückgeben, da die kleinste Differenz zwischen 13:30Uhr und 14:10Uhr mit
einer Differenz von 40 Minuten liegt. Das Eingabefeld enthält immer mindestens zwei Elemente und alle
Elemente haben das richtige Format und sind eindeutig.
Beispiele
Eingabe: [„13:10Uhr“, „04:40Uhr“, „17:00Uhr“]

Ausgabe: 230
Eingabe: [„10:00 Uhr“, „23:45Uhr“, „5:00Uhr“, „00:01 Uhr“]

Ausgabe: 16
funktion TimeDifference(strArr) {
//Zeiten halten unsere Zeitunterschiede
let times = [];
lassen Sie newStrArr = strArr.map (val => {
let matches = val.match(/^(\d+):(\d+)([ap]m)$/);
let hours = parseInt(Übereinstimmungen[1], 10);
let minutes = parseInt(entspricht[2], 10);
let half = Übereinstimmungen[3];
if (half === 'am' && hours === 12) {
hours = 0;
}
if (half === 'pm' && hours !== 12) {
stunden += 12;
}
rückkehr (Stunden * 60 + Minuten);
})
.sort((a, b) => { return a - b});
//tricky - zweites Beispiel zeigt, dass wir den frühesten Zeitpunkt sowohl am Tag
0 als auch am Tag 1 berücksichtigen müssen
newStrArr.push(newStrArr[0] + 24 * 60);
for (let i = 0, len = newStrArr.length; i < len - 1; i ++) {

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

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

strArr.forEach(Funktion(strTime){
let pair = strTime.split(':');
let hours = (pair[1][2] === 'a') ? parseInt(pair[0]) % 12 : parseInt(pair[0])
% 12 + 12;
let seconds = parseInt(paar[1].substr(0,2));
let totalSeconds = hours * 60 + seconds;
timesInSeconds.push(totalSeconds);
});
// Iteriere über 2^n Kombos

let smallestDifference = Number.MAX_VALUE;
for (let i = 0, max = Math.pow(2,timesInSeconds.length); i < max; i++) {
let timesUsed = combo.split('').reduce((a,v) => a + (v === '1' | 0), 0);
if (timesUsed === 2) {
// Pad
while (combo.length < timesInSeconds.length) {
}
// Iterieren Sie über jede spezifische Combo und testen Sie sie
let diff = 0;
let pair = [];
for (let j = 0; j < combo.length; j++) {
if (combo[j] === '1') {
pair.push(timesInSeconds[j]);
}
}
let t1 = Math.abs(Paar[0] - Paar[1]);

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

smallestDifference = diff;
}
}
}
gibt die kleinste Differenz zurück;

}

let array = strArr.map(Wert => {
let matches = value.match(/^(\d+):(\d+)([ap]m)$/);
let h = parseInt(Übereinstimmungen[1], 10);
let m = parseInt(Übereinstimmungen[2], 10);
if (matches[3] === 'am' && h === 12) {
h = 0;
} else if (entspricht[3] === 'pm' && h !== 12) {
h += 12;
}
return (60 * h + m);
}).sort(Funktion(a, b) {
return a - b;
});
array.push(array[0] + 24 * 60);
let times = [];
for (let i = 0; i < array.length - 1; i++) {
times.push(array[i+1] - array[i]);
}
return Math.min(...mal);
}
Dreiecksreihe
Lassen Sie die Funktion TriangleRow(num) num nehmen, die eine positive ganze Zahl ist, die eine
Zeile aus Pascals Dreieck darstellt. Pascals Dreieck beginnt mit einem [1] in der 0. Reihe des Dreiecks.
Dann ist die erste Zeile [1, 1] und die zweite Zeile [1, 2, 1]. Die nächste Zeile beginnt mit 1 und endet
mit 1, und die Innenseite der Zeile wird durch Hinzufügen der k-1 und k-ten Elemente aus der
vorherigen Zeile bestimmt. Die nächste Zeile im Dreieck wäre dann [1, 3, 3, 1] und so weiter. Die
Eingabe wird eine positive ganze Zahl sein und Ihr Ziel ist es, die Summe dieser Zeile zurückzugeben.
Zum Beispiel: Wenn num 4 ist, dann sollte Ihr Programm die Summe von 1 + 4 + 6 + 4 + 1 zurückgeben,
was 16 ist.
Beispiele
Eingang: 1
Ausgang: 2
Eingang: 2
Ausgang: 4
funktion TriangleRow(num) {
return Math.pow(2, num);
}
console.log(TriangleRow(5));

TriangleRow(readline());
let triangle = [];

for (let row = 0; row <= num; row++) {
let rowArr = [];
for (let i = 0; i <= row; i++) {
if (i === 0) {
rowArr.push(1);
fortfahren;
}
let delta = (i < triangle[row-1].length) ? triangle[row-1][i] : 0;
rowArr.push(Dreieck[row-1][i-1] + delta);
}
triangle.push(rowArr);
}
return triangle[num].reduce((a,v) => a + v,0);
}
// Erhalte die n-te Zeile und die k-te Spalte des Pascal-Dreiecks
funktion pascalTriangle(n, k) {
if (n === 0) return 1;
if (k === 0 || k === n) return 1;
return pascalTriangle(n - 1, k - 1) + pascalTriangle(n - 1, k);
}
// die einfache Antwort - sie summiert sich immer zu n^2
//return num * num;
// the hard way

var rowSum = 0;
für (k = 0; k <= num; k++) {
result = pascalTriangle(num, k);
rowSum += result;
}
return rowSum;
}

Vokalquadrat
Lassen Sie die Funktion Vokalquadrat (strArr) den übergebenen strArr-

Parameter nehmen, der eine 2D-Matrix beliebiger Größe ist, die mit Buchstaben aus dem Alphabet
gefüllt ist, und bestimmen Sie, ob ein 2x2-Quadrat, das vollständig aus Vokalen besteht, in der Matrix
vorhanden ist. Zum Beispiel: strArr ist ["abcd", "eikr", "oufj"] dann sieht diese Matrix wie folgt aus:
a b c d
e i k r
o u f j
Innerhalb dieser Matrix gibt es ein 2x2 Quadrat von Vokalen, das in der zweiten Zeile und ersten Spalte
beginnt, nämlich ei, ou. Wenn ein 2x2-Quadrat von Vokalen gefunden wird, sollte Ihr Programm die
obere linke Position (Zeile-Spalte) des Quadrats zurückgeben, also sollte Ihr Programm für dieses
Beispiel 1-0 zurückgeben. Wenn kein 2x2-Vokalquadrat vorhanden ist, geben Sie die Zeichenfolge nicht
gefunden zurück. Wenn es mehrere Vokalquadrate gibt, geben Sie das Vokalquadrat zurück, das sich an
der obersten linken Position in der gesamten Matrix befindet. Die Eingabematrix wird mindestens die
Größe 2x2 haben.
Beispiele
Eingabe: ["aqrst", "ukaei", "ffooo"]

Ausgabe: 1-2
Eingabe: ["gg", "ff"]

Ausgabe: nicht gefunden
funktion Vokalquadrat(strArr) {
strArr = strArr.map(val => {
return val.toLowerCase().replace(/[aeiou]/g, "!");
})
for (let r = 0, len = strArr.length; r < len - 1; r++) {
for (let c = 0, len = strArr[0].length; c < len - 1; c++) {
if (checkPoint(strArr, [r, c])) {
return `${r}-${c}`;
}
}
}
return 'not found'
function checkPoint(arr, point) {

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

Vokalquadrat(readline());
for (let row = 0; row < strArr.length-1; row++) {

for (let col = 0; col < strArr[0].length-1; col++) {
if (isVowels2x2(strArr, row, col)) {
// Gut! Kehren Sie zuerst zurück, weil wir
// searche in a good order
return row + '-' + col;
}
}
}
return 'nicht gefunden';
funktion isVokale2x2(strArr, Zeile, Spalte) {

// Könnte hier Grenzen überprüfen, aber es wird in main() durchgeführt
if (!isVowel(strArr[row][col])) return false;

if (!isVowel(strArr[row+1][col])) return false;
if (!isVowel(strArr[row][col+1])) return false;
if (!isVowel(strArr[row+1][col+1])) return false;
return true;
}
funktion isVokal(Buchstabe) {
const VOKALE = 'aeiou';
return VOWELS.includes(Brief);
}
}

// Überprüfen Sie, ob jeder Buchstabe in der gegebenen Matrix ein Vokal ist
funktion allVokale(Matrix) {
return matrix.every(row => row.every(letter => 'aeiou'.indexOf(letter) !== -1));
}
var matrix = strArr.map(row => row.split(''));
for (var row = 0; row < matrix.length - 1; row++) {

for (var column = 0; column < matrix[0].length - 1; column++) {
// test with sliding windows of 2x2 sub-matrix
var subMatrix = matrix.slice(Zeile, Zeile + 2).map(rowArr =>
rowArr.slice(Spalte, Spalte + 2));
if (allVokale(subMatrix)) {
return row + '-' + column;
}
}
}
return 'nicht gefunden';

}

Nächstliegender Feind
Lassen Sie die Funktion ClosestEnemy(arr) das in arr gespeicherte Zahlenarray nehmen und
geben Sie von der Position im Array, an der eine 1 steht, die Anzahl der Felder zurück, die Sie entweder
nach links oder rechts bewegen müssen, um einen Feind zu erreichen, der durch eine 2 dargestellt wird.
Zum Beispiel: Wenn arr [0, 0, 1, 0, 0, 2, 0, 2] ist, dann sollte Ihr Programm 3 zurückgeben, weil der
nächste Feind (2) 3 Räume von der 1 entfernt ist. Das Array enthält eine beliebige Anzahl von 0en und
2en, aber nur eine einzige 1. Es darf auch keine 2 enthalten, wobei in diesem Fall Ihr Programm eine 0
zurückgeben sollte.
Beispiele
Eingang: [1, 0, 0, 0, 2, 2, 2]
Ausgang: 4
Eingabe: [2, 0, 0, 0, 2, 2, 1, 0]
Ausgabe: 1
funktion ClosestEnemy(arr) {
if (!arr.includes(2)) {
return 0;
}
loc1 = arr.findIndex(val => {
return val === 1;
});
for (let i = 1, len = arr.length; i < len; i++) {

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

ClosestEnemy(readline());
let hero = -1;

if (arr[i] === 1) { //Held gefunden
hero = i;
}
}
// Search right
let deltaRight = undefined;
for (let i = hero+1; i < arr.length; i++) {
if (arr[i] === 2) { //Feind gefunden
deltaRight = i - hero;
pause;
}
}
// Suche links
let deltaLeft = undefined;
for (let i = hero-1; i >= 0; i--) {
if (arr[i] === 2) { //Feind gefunden
deltaLeft = hero - i;
pause;
}
}
if (deltaLeft === undefined && deltaRight === undefined) {

return 0;
}
if (deltaLeft === undefined) {

return deltaRight;
}
if (deltaRight === undefiniert) {

return deltaLeft;
}
return (deltaLeft < deltaRight) ? deltaLeft : deltaRight;

}

// index of 1
var me = arr.indexOf(1);
var minimumDistance = arr.length;

if (arr[i] === 2) {
var distance = Math.abs(i - me);
if (distance < minimumDistance) {
minimumDistance = Abstand;
}
}
}
return (minimumDistance === arr.length) ? 0 : minimumDistance;

}

Nächstliegender Feind II
Lassen Sie die FunktionClosestEnemyII (strArr) die in strArr gespeicherte Zahlenmatrix

lesen, die eine 2D-Matrix ist, die nur die ganzen Zahlen 1, 0 oder 2 enthält. Geben Sie dann von der
Position in der Matrix, an der eine 1 ist, die Anzahl der Felder entweder links, rechts, unten oder oben
zurück, die Sie bewegen müssen, um einen Feind zu erreichen, der durch eine 2 dargestellt wird. Sie
können auch eine Seite der Matrix mit der anderen umwickeln. Zum Beispiel: Wenn strArr ["0000",
"1000", "0002", "0002"] ist, dann sieht das wie folgt aus:
0 0 0 0
1 0 0 0 0 0 0
0 2 0
0 2 Für diese Eingabe sollte Ihr Programm 2 zurückgeben, weil der nächste Feind
(2) 2 Räume von der 1 entfernt ist, indem Sie sich nach links bewegen, um auf die andere Seite zu
wickeln und dann einmal nach unten zu gehen.
Das Array enthält eine beliebige Anzahl von 0en und 2en, aber nur eine einzige 1. Es darf auch keine 2
enthalten, wobei in diesem Fall Ihr Programm eine 0 zurückgeben sollte.
Beispiele
Eingabe: ["000", "100", "200"]

Ausgabe: 1
Eingabe: ["0000", "2010", "0000", "2002"]

Ausgabe: 2
funktion ClosestEnemyII(strArr) {
//step one - return 0 if there is no 2 in the array
let twosies = strArr.filter(val => {
return val.includes("2");
});
if (!twosies.length) {
return 0;
}
//Schritt zwei - die Koordinaten der 1 erhalten (targetX, targetY)
targetY = strArr.findIndex(val => {
return val.includes('1');
});
targetX = strArr[targetY].search(/1/);
//Schritt drei finde den kleinsten Weg zu einer 2
let res = strArr.length * strArr[0].length;
for (let row = 0, len = strArr[0].length; row < len; row++) {

for (col = 0, height = strArr.length; col < height; col++) {
if (strArr[row][col] === '2') {
xShift = rowDist(targetX, col, len);
yShift = rowDist(targetY, row, height);
res = Math.min(res, xShift + yShift);
}
}
}
return res;
//--------------------helfer----------------------
//trotz des Namens, Verwendung für Spalten- und Zeilenabstand
funktion rowDist(y, x, len) {
return Math.min(Math.abs(x - y), Math.abs(y - x + len));
}

ClosestEnemyII(readline());
// Finde den Helden

let heroY = -1;
let heroX = -1;
let result = strArr[i].indexOf(1);
if (result > -1) {
heroX = result;
heroY = i;
}
}
if (heroY === -1) {

// Kein Held vorhanden
return -1;
}
//console.log(heroY + '-' + heroX);
// Nach Feinden suchen

let enemies = [];
let result = strArr[i].indexOf(2);
if (result > -1) {
enemies.push([i,result]);
}
}
if (enemies.length === 0) {
return 0;
}
//console.log(Feinde);
let closestDistance = Number.MAX_SAFE_INTEGER;
// Überprüfen Sie die feindlichen Entfernungen

for (let i = 0; i < enemies.length; i++) {
let enemyX = enemies[i][1];
let enemyY = Feinde[i][0];
let deltaX = Math.abs(enemyX - heroX);

let deltaY = Math.abs(enemyY - heroY);
//console.log(deltaY + '-' + deltaX);
//Prüfen Sie nun die Wrap-around-Werte

// deltaX ist max, denn wenn es mehr ist, dann ist es uns egal
let wrapDeltaX = Number.MAX_SAFE_INTEGER;
for (let i = 0; i < deltaX; i++) {
if ((enemyX + i) % strArr[0].length === heroX) {
//Hero Delta gefunden
wrapDeltaX = i;
//console.log('wrap-aroundX: ' + i)
}
}
let wrapDeltaY = Number.MAX_SAFE_INTEGER;

for (let i = 0; i < deltaY; i++) {
if ((enemyY + i) % strArr.length === heroY) {
//Hero Delta gefunden
wrapDeltaY = i;
//console.log('wrap-aroundY: ' + i)
}
}
deltaX = (wrapDeltaX < deltaX) ? wrapDeltaX : deltaX;

deltaY = (wrapDeltaY < deltaY) ? wrapDeltaY : deltaY;
let distance = deltaX + deltaY;
if (distance < nearestDistance) {

closestDistance = Entfernung;
}
}
return closestDistance;

// Finde den Abstand zwischen zwei Elementen mit vorgegebenen [Zeile, Spalte] Indizes
funktion getDistance(matrixSize, indices1, indices2) {
var rowDistance = Math.min(Math.abs(indices2[0] - indices1[0]),
Math.abs(indices1[0] - (indices2[0] - matrixSize)));
var columnDistance = Math.min(Math.abs(indices2[1] - indices1[1]),
Math.abs(indices1[1] - (indices2[1] - matrixSize)));
return rowDistance + columnDistance;
}
var matrix = strArr.map(line => line.split('').map(Number));
var minDistance = matrix.length * 2;
// Standort von mir: 1
var meIndices;
// Standorte der Feinde: 2
var enemiesIndices = [];
// Identifizieren Sie die Standorte von 1 und 2

for (var row = 0; row < matrix.length; row++) {
for (var column = 0; column < matrix[0].length; column++) {
if (matrix[row][column] === 1) {
meIndices = [Zeile, Spalte];
} else if (matrix[Zeile][Spalte] === 2) {
enemiesIndices.push([Zeile, Spalte]);
}
}
}
// Überprüfen Sie die Entfernung von mir für jeden Feind

für (var enemyIndices of enemiesIndices) {
var distance = getDistance(matrix.length, meIndices, enemyIndices);
if (distance < minDistance) {
minDistance = Entfernung;
}
}
// behandelt den Fall, dass es keinen Feind gibt

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

Nummernstrom
Lassen Sie die Funktion NumberStream (str) den übergebenen Parameter str übernehmen, der
die Zahlen 2 bis 9 enthält, und bestimmen Sie, ob es einen aufeinanderfolgenden Strom von Ziffern von
mindestens N Länge gibt, wobei N der tatsächliche Ziffernwert ist. Wenn ja, geben Sie die
Zeichenfolge true zurück, andernfalls geben Sie die Zeichenfolge false zurück. Zum Beispiel:
Wenn str "6539923335" ist, sollte Ihr Programm die Zeichenfolge true zurückgeben, da es einen
aufeinanderfolgenden Stream von 3 der Länge 3 gibt. Die Eingabezeichenfolge enthält immer
mindestens eine Ziffer.
Beispiele
Eingabe: "5556293383563665"
Ausgabe: falsch
Eingabe: "57888888882339999"
Ausgabe: wahr
funktion NumberStream(str) {
for (let i = 2; i < 10; i++) {
let iChar = i.toString();
let needle = iChar.repeat(i);
if (str.indexOf(needle) !== -1) {
return true;
}
}
// code goes here
return false;

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

if (str[i] === lastDigit) {
// Stream Fortsetzung
count++;
if (count >= Number(lastDigit)) {
return true;
}
} else {
// Neuer Stream
lastDigit = str[i];
count = 1;
}
}
return false;
}

//Muster zuerst generieren
var patterns = [];
for (var i = 1; i < 10; i++) {
patterns.push(String(i).repeat(i));
}
for (var pattern of patterns) {

if (str.indexOf(pattern) !== -1) {
// Muster gefunden
return true;
}
}
return false;
}

Größte Vier
Lassen Sie die FunktionLargestFour (arr) das Array der in arr gespeicherten ganzen Zahlen
nehmen und die vier größten Elemente finden und ihre Summe zurückgeben. Zum Beispiel:
Wenn arr [4, 5, -2, 3, 1, 2, 6, 6] ist, dann sind die vier größten Elemente in diesem Array 6, 6, 4 und 5
und die Gesamtsumme dieser Zahlen ist 21. Ihr Programm sollte also 21 zurückgeben. Wenn es weniger
als vier Zahlen im Array gibt, sollte Ihr Programm die Summe aller Zahlen im Array zurückgeben.
Beispiele
Eingang: [1, 1, 1, -5]

Ausgang: -2
Eingabe: [0, 0, 2, 3, 7, 1]
Ausgabe: 13
funktion LargestFour(arr) {
let newArr = arr.sort((val1, val2) => {
return val2 - val1;
})
.splice(0, 4);
return newArr.reduce((val1, val2) => {
return val1 + val2;
}, 0);
}

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

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

Eindeutige Zeichen
Lassen Sie die FunktionDistinctCharacters (str) den übergebenen

Parameter str übernehmen und bestimmen, ob er mindestens 10 verschiedene Zeichen enthält. Wenn ja,
sollte Ihr Programm die Zeichenfolge true zurückgeben, andernfalls sollte es die Zeichenfolge false
zurückgeben. Zum Beispiel: Wenn str "abc123kkmmmm?" ist, dann sollte Ihr Programm die
Zeichenfolge false zurückgeben, da diese Zeichenfolge nur 9 verschiedene Zeichen enthält: a, b, c, 1, 2,
3, k, m, ? addiert sich zu 9.
Beispiele
Eingabe: "12334bbmma:=6"
Ausgabe: wahr
Eingabe: "eeeemmmmmmmmm1000"
Ausgabe: false
funktion DistinctCharacters(str) {
let mySet = new Set(str.split(''));
return mySet.size >= 10 ? true : false
}
DistinctCharacters(readline());
let charCodes = [];

if (!charCodes.includes(str.charCodeAt(i))) {
charCodes.push(str.charCodeAt(i));
}
}
return (charCodes.length >= 10) ? true : false;

var differcts = {};

differenziert[str[i]] = '';
}
return Object.keys(differcts).length >= 10;

}

Fragezeichen
Lassen Sie die FunktionQuestionsMarks (str) den Parameter str string verwenden, der
einstellige Zahlen, Buchstaben und Fragezeichen enthält, und prüfen Sie, ob sich zwischen jedem Paar
von zwei Zahlen genau 3 Fragezeichen befinden, die sich zu 10 addieren. Wenn ja, dann sollte Ihr
Programm die Zeichenfolge true zurückgeben, andernfalls sollte es die Zeichenfolge false zurückgeben.
Wenn es keine zwei Zahlen gibt, die 10 in der Zeichenfolge ergeben, sollte Ihr Programm
auch false zurückgeben.
Zum Beispiel: Wenn str "arrb6???4xxbl5???eee5" ist, dann sollte Ihr Programm true zurückgeben,
weil es genau 3 Fragezeichen zwischen 6 und 4 und 3 Fragezeichen zwischen 5 und 5 am Ende der
Zeichenfolge gibt.
Beispiele
Eingang: "aa6?9"
Ausgang: false
Input: „acc?7??sss? 3rr1?????5“
Output: true
function QuestionsMarks(str) {
let numPlaces = [];
//Annahme von false, bis Flag auf true gestellt wird
let flag = false;
//Erhalte ein Array von Stellen in Zeichenketten, die ganze Zahlen enthalten
for (let i = 0, len = str.length; i < len; i++) {
if (/\d/.test(str[i])) {
numPlaces.push(i);
}
}
let numCount = numPlaces.length;
for (let i = 0; i < numCount - 1; i++) {

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

if (strSeg !== '???') {
return false;
}
}
}
return flag;
}

QuestionsMarks(readline());
Kamelkoffer
Lassen Sie die Funktion CamelCase(str) den übergebenen Parameter str im richtigen
Kamelgehäuseformat zurückgeben, wobei der erste Buchstabe jedes Wortes großgeschrieben wird (ohne
den ersten Buchstaben). Die Zeichenfolge enthält nur Buchstaben und eine Kombination von
Trennzeichen-Satzzeichen, die jedes Wort trennen.
Zum Beispiel: Wenn str "BOB LOVES-CODING" ist, dann sollte Ihr Programm den String
bobLovesCoding zurückgeben.
Beispiele
Eingabe: "Katzen UND* Hunde sind fantastisch"

Ausgabe: catsAndDogsAreAwesome
Eingang: „a b c d-e-f%g“
Ausgang: aBCDEFG
funktion CamelCase(str) {
let strArr = str.split(/[â-zA-Z]/);
strArr = strArr.map((val, ind) => {
val = val.toLowerCase();
if (ind) {
valArr = val.split('');
valArr[0] = valArr[0].toUpperCase();
return valArr.join('');
}
return val;
})
return strArr.join('');
}

CamelCase(readline());
ASCII-Konvertierung
Lassen Sie die Funktion ASCIIConversion (str) den übergebenen

Parameter str übernehmen und eine neue Zeichenfolge zurückgeben, bei der jedes Zeichen außer dem
Leerzeichen durch den entsprechenden
Dezimalzeichencode https://msdn.microsoft.com/en-us/library/60ecse8t(v=vs.80).aspx ersetzt wird. Zum
Beispiel: Wenn str "dog" ist, dann sollte Ihr Programm die Zeichenfolge 100111103 zurückgeben,
weil d = 100, o = 111, g = 103.
Beispiele
Eingabe: „Hallo Welt“

Ausgabe: 104101108108111 119111114108100
Eingabe: „abc **“

Ausgabe: 979899 4242
function ASCIIConversion(str) {
let myArr = str.split(' ').map(val => {
return val.split('').map(val2 => {
return val2.charCodeAt(0);
}).join('')
}).join(' ');
myArr zurückgeben;
}
ASCIIConversion(readline());
Einfache Evens
Lassen Sie die FunktionSimpleEvens (num) prüfen, ob jede einzelne Zahl im übergebenen
Parameter gerade ist. Wenn ja, geben Sie die Zeichenfolge true zurück, andernfalls geben Sie die
Zeichenfolge false zurück. Zum Beispiel: Wenn num 4602225 ist, sollte Ihr Programm die
Zeichenfolge false zurückgeben, da 5 keine gerade Zahl ist.
Beispiele
Eingang: 2222220222
Ausgang: true
Eingang: 20864646452
Ausgang: false
funktion SimpleEvens(num) {
return num.toString(10).search(/[13579]/) === -1 ? 'true' : 'false';
}
SimpleEvens(readline());
Schlangenetui
Lassen Sie die Funktion SnakeCase (str) den übergebenen str-Parameter im richtigen Snake-
Case-Format zurückgeben, wobei jedes Wort klein geschrieben und durch einen Unterstrich von
benachbarten Wörtern getrennt ist. Die Zeichenfolge enthält nur Buchstaben und eine Kombination von
Trennzeichen-Satzzeichen, die jedes Wort trennen.
Zum Beispiel: Wenn str "BOB LOVES-CODING" ist, dann sollte Ihr Programm die
Zeichenfolge bob_loves_coding zurückgeben.
Beispiele
Input: "Katzen UND*Hunde sind fantastisch"

Output: Katzen_und_Hunde_sind_fantastisch
Eingabe: "a b c d-e-f%g"

Ausgabe: a_b_c_d_e_f_g
funktion SnakeCase(str) {
return str.split(/[â-zA-Z]/).map(val => {return
val.toLowerCase()}).join('_');
}
SnakeCase(readline());
Kreuzung finden
Lassen Sie die Funktion FindIntersection (strArr) das in strArr gespeicherte Strings-Array
lesen, das 2 Elemente enthält: Das erste Element stellt eine Liste von kommaseparierten Zahlen dar, die
in aufsteigender Reihenfolge sortiert sind, das zweite Element stellt eine zweite Liste von
kommaseparierten Zahlen dar (ebenfalls sortiert). Ihr Ziel ist es, eine durch Kommas getrennte
Zeichenfolge zurückzugeben, die die Zahlen enthält, die in Elementen von strArr in sortierter
Reihenfolge vorkommen. Wenn es keine Kreuzung gibt, geben Sie die Zeichenfolge false zurück.
Zum Beispiel: Wenn strArr ["1, 3, 4, 7, 13", "1, 2, 4, 13, 15"] enthält, sollte die Ausgabe "1,4,13"
zurückgeben, da diese Zahlen in beiden Zeichenfolgen erscheinen. Das angegebene Array ist nicht leer,
und jede Zeichenfolge innerhalb des Arrays besteht aus Zahlen, die in aufsteigender Reihenfolge sortiert
sind und negative Zahlen enthalten können.
Beispiele
Eingabe: ["1, 3, 4, 7, 13", "1, 2, 4, 13, 15"]

Ausgabe: 1,4,13
Eingabe: ["1, 3, 9, 10, 17, 18", "1, 4, 9, 10"]

Ausgabe: 1,9,10
funktion FindIntersection(Input) {
const [firstList, secondList] = input.map( s => s.split(", ") );
const resultMap = {};

const result = [];
for ( const number of firstList ) {

resultMap[ number ] = true;
}
for ( const number of secondList ) {

if ( resultMap[number] ) {
result.push( number );
}
}
return result.length ? result.join(",") : false;

}

console.log(FindIntersection(readline()));
Summenmultiplikator
Lassen Sie die FunktionSumMultiplier (arr) das in arr gespeicherte Zahlenarray nehmen und
die Zeichenfolge true zurückgeben, wenn zwei beliebige Zahlen multipliziert werden können, sodass die
Antwort größer als das Doppelte der Summe aller Elemente im Array ist. Wenn nicht, geben Sie die
Zeichenfolge false zurück. Zum Beispiel: Wenn arr [2, 5, 6, -6, 16, 2, 3, 6, 5, 3] ist, dann ist die
Summe all dieser Elemente 42 und verdoppelt 84. Es gibt zwei Elemente im Array, 16 * 6 = 96 und 96
ist größer als 84, daher sollte Ihr Programm die Zeichenfolge true zurückgeben.
Beispiele
Eingabe: [2, 2, 2, 2, 4, 1]
Ausgabe: falsch
Eingabe: [1, 1, 2, 10, 3, 1, 12]

Ausgabe: wahr
funktion SumMultiplier(arr) {
const target = arr.reduce((val1, val2) => val1 + val2, 0) * 2;
arr.sort((num1, num2) => num1 - num2);
const len = arr.length;
const checker = Math.max((arr[0] * arr[1]), (arr[len - 2] * arr[len - 1]));
return checker > target;
}
SumMultiplier(readline());
String-Zusammenführung
Lassen Sie die FunktionStringMerge (str) den übergebenen str -Parameter lesen, der eine
große Zeichenfolge alphanumerischer Zeichen mit einem einzelnen Sternchenzeichen enthält, das die
Zeichenfolge gleichmäßig in zwei separate Zeichenfolgen aufteilt. Ihr Ziel ist es, eine neue Zeichenfolge
zurückzugeben, indem Sie die Zeichen an den entsprechenden Stellen in beiden Zeichenfolgen paaren.
Zum Beispiel: Wenn str "abc1 *kyoo" ist, dann sollte Ihr Programm die
Zeichenfolge akbyco1o zurückgeben, weil a mit k, b mit y usw. paart. Die Zeichenfolge wird immer
gleichmäßig mit dem Stern in der Mitte geteilt.
Beispiele
Eingabe: „aaa*bbb“
Ausgabe: ababab
Eingabe: "123hg*aaabb"
Ausgabe: 1a2a3ahbgb
funktion StringMerge(str) {
const cleanString = str.replace(/[^\w*]/g, '');
const len = (cleanString.length - 1) / 2;
let newString = '';
const arr = str.split('*');
for (let i = 0; i < len; i++) {

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

StringMerge(readline());
Eins dekrementiert
Lassen Sie die FunktionOneDecremented (str) zählen, wie oft eine Ziffer erscheint, die genau
eine weniger als die vorherige Ziffer ist. Zum Beispiel: Wenn str "5655984" ist, dann sollte Ihr
Programm 2 zurückgeben, weil 5 direkt nach 6 und 8 direkt nach 9 erscheint. Die Eingabe enthält immer
mindestens 1 Ziffer.
Beispiele
Eingang: "56"
Ausgang: 0
Eingang: "9876541110"
Ausgang: 6
function OneDecremented(num) {
let counter = 0;
let arr = num.toString().split('');
if (parseInt(val, 10) - parseInt(arr[ind + 1], 10) === 1) {
zähler++;
}
})
rückgabezähler;
}

OneDecremented(readline());
Elementzusammenführung
Lassen Sie die Funktion ElementMerger (arr) das in arr gespeicherte Array positiver
Ganzzahlen nehmen und den folgenden Algorithmus ausführen: Ermitteln Sie kontinuierlich die
Differenz benachbarter Ganzzahlen, um ein neues Array ganzer Zahlen zu erstellen, tun Sie dasselbe für
das neue Array, bis eine einzige Zahl übrig ist, und geben Sie diese Zahl zurück. Zum Beispiel:
Wenn arr [4, 5, 1, 2, 7] ist, dann ergibt die Differenz jedes Elementpaares das folgende neue Array: [1,
4, 1, 5]. Machen Sie dann dasselbe für dieses neue Array, um [3, 3, 4] -> [0, 1] -> 1 zu erzeugen. In
diesem Beispiel sollte Ihr Programm also die Zahl 1 zurückgeben, denn das ist es, was am Ende übrig
bleibt.
Beispiele
Eingang: [5, 7, 16, 1, 2]

Ausgang: 7
Eingang: [1, 1, 1, 2]
Ausgang: 1
funktion ElementMerger(arr) {
if (arr.length === 1) {
return arr[0];
} else {
newArr = [];
if (ind < arr.length - 1) {
newArr.push(Math.abs(val - arr[ind + 1]));
}
})
return ElementMerger(newArr);
}
}
ElementMerger(readline());
GCF
Lassen Sie die Funktion GCF(arr) das in arr gespeicherte Zahlenarray, das immer nur zwei positive
ganze Zahlen enthält, nehmen und den größten gemeinsamen Faktor von ihnen zurückgeben. Zum
Beispiel: Wenn arr [45, 12] ist, sollte Ihr Programm 3 zurückgeben. Es wird immer zwei Elemente im
Array geben und sie werden positive ganze Zahlen sein.
Beispiele
Eingang: [1, 6]
Ausgang: 1
Eingang: [12, 28]

Ausgang: 4
funktion GCF(arr) {
let res = null;
let max = Math.max(...arr);
let min = Math.min(...arr);
for (let i = 1; i <= min; i++) {
wenn (max % i === 0 && min % i === 0) {
res = i;
}
}
return res;
}

GCF(readline());
Seriennummer
Lassen Sie die Funktion SerialNumber(str) den übergebenen Parameter str übernehmen und
bestimmen, ob es sich um eine gültige Seriennummer mit den folgenden Einschränkungen handelt:
1. Es muss drei Sätze mit jeweils drei Ziffern (1 bis 9) enthalten, die durch einen Punkt getrennt sind.
2. Der erste Satz von Ziffern muss sich zu einer geraden Zahl addieren.
3. Der zweite Ziffernsatz muss sich zu einer ungeraden Zahl addieren.
4. Die letzte Ziffer in jedem Satz muss größer sein als die beiden vorherigen Ziffern im selben Satz.
Wenn alle oben genannten Einschränkungen innerhalb der Zeichenfolge erfüllt sind, sollte Ihr Programm
die Zeichenfolge true zurückgeben, andernfalls sollte Ihr Programm die Zeichenfolge false
zurückgeben. Zum Beispiel: Wenn str "224.315.218" ist, dann sollte Ihr Programm "true" zurückgeben.
Beispiele
Eingabe: "11.124.667"
Ausgabe: falsch
Eingabe: "114.568.112"
Ausgabe: wahr
funktion SerialNumber(str) {
//Format der Zeichenfolge prüfen
let goal = /^\d{3}\.\d{3}\.\d{3}$/
if (!goal.test(str)) {
return 'false';
}
//Transformieren Sie die Zeichenfolge in drei Arrays mit jeweils drei Ziffern
let arr = str.split(/\./).map(val => {
return val.split('').map(val2 => {
return parseInt(val2, 10);
});
});
//Bedingung eins prüfen

if ((arr[0][0] + arr[0][1] + arr[0][2]) % 2) {
return 'false';
}
//Bedingung zwei prüfen

if (!((arr[1][0] + arr[1][1] + arr[1][2]) % 2)) {
return 'false';
}
//Bedingung drei prüfen

for (let i = 0, len = arr.length; i < len; i++) {
if (Math.max(...arr[i]) !== arr[i][2]) {
return 'false';
}
}
//wenn alle Bedingungen ohne false durchgehen, dann true zurückgeben
return true;
}
SerialNumber(readline());
String-Perioden
Lassen Sie die Funktion StringPeriods(str) den übergebenen str -Parameter nehmen und
bestimmen, ob es eine Teilzeichenfolge K gibt, die N > 1 Mal wiederholt werden kann, um die
Eingabezeichenfolge genau so zu erzeugen, wie sie erscheint. Ihr Programm sollte die längste
Teilzeichenfolge K zurückgeben, und wenn es keine gibt, sollte es die Zeichenfolge -1 zurückgeben.
Beispiel: Wenn str "abcababcababcab" ist, sollte Ihr Programm abcab zurückgeben, da dies die längste
Teilzeichenfolge ist, die dreimal wiederholt wird, um die letzte Zeichenfolge zu erstellen. Ein weiteres
Beispiel: Wenn str "ababababab" ist, sollte Ihr Programm ababab zurückgeben, da es die längste
Teilzeichenfolge ist. Wenn die Eingabezeichenfolge nur ein einzelnes Zeichen enthält, sollte Ihr
Programm die Zeichenfolge -1 zurückgeben.
Beispiele
Eingang: „abcxabc“
Ausgang: -1
Input: „affedaaffed“
Output: -1
function StringPeriods(str) {
// we will only use lengths of substrings that divide evenly into str
const len = str.length;
const pivot = Math.max(Math.trunc(Math.sqrt(len)), len);
for (let i = 2; i <= pivot; i++) {
if (len % i === 0) {
const block = str.slice(0, len / i);
if (block.repeat(i) === str) {
rücklaufsperre;
}
}
}
return -1;
}

StringPeriods(readline());
Palindrom-Swapper
Lassen Sie die FunktionPalindromeSwapper (str) den übergebenen

Parameter str übernehmen und bestimmen, ob ein Palindrom erstellt werden kann, indem Sie zwei
benachbarte Zeichen in der Zeichenfolge vertauschen. Wenn es möglich ist, ein Palindrom zu erstellen,
sollte Ihr Programm das Palindrom zurückgeben, wenn nicht, dann die Zeichenfolge -1. Die
Eingabezeichenfolge enthält nur alphabetische Zeichen. Zum Beispiel: Wenn str "rcaecar" ist, dann
können Sie ein Palindrom erstellen, indem Sie das zweite und dritte Zeichen vertauschen, so dass Ihr
Programm den String-Rennwagen zurückgeben sollte, der der letzte palindromische String ist.
Beispiele
Eingabe: „anna“
Ausgabe: anna
Eingabe: "kyaak"
Ausgabe: kayak
funktion PalindromeSwapper(str) {
let inputArray = str.split('');
let strLen = inputArray.length;
let palTester = function(arr) {
for (let i = 0; i < len; i++) {
if (arr[i] !== arr[len - (1 + i)]) {
return false;
}
}
return true;
}
for (let i = 0; i < strLen - 1; i++) {

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

PalindromeSwapper(readline());
Halterungen entfernen
Lassen Sie die Funktion RemoveBrackets (str) den übergebenen Parameter str string
übernehmen, der nur die Zeichen "(" und ")" enthält, und bestimmen Sie die Mindestanzahl der
Klammern, die entfernt werden müssen, um eine Zeichenfolge korrekt übereinstimmender Klammern zu
erstellen. Zum Beispiel: Wenn str "(()))" ist, dann sollte Ihr Programm die Zahl 1 zurückgeben. Die
Antwort könnte möglicherweise 0 sein, und es wird immer mindestens einen Satz passender Klammern
in der Zeichenfolge geben.
Beispiele
Input: "(())()(("
Output: 3
Eingang: "(()("
Ausgang: 2
funktion RemoveBrackets(str) {
let throwouts = 0;
let counter = 0;
let arr = str.split('');
for (let i = 0; i < len; i++) {

//ein gutes Beispiel für die Verwendung von Pre++ und Pre-- im Gegensatz zu Post+
+ und Post--
counter = arr[i] === '(' ? ++counter : --counter;
wenn (Zähler < 0) {
throwouts++;
counter = 0;
}
}
throwouts += Zähler;
rückwurf;
}

RemoveBrackets(readline());
Befehlszeile
Lassen Sie die Funktion CommandLine(str) den übergebenen Parameter str übernehmen, der die
Parameter darstellt, die einem Befehl in einem alten PDP-System zugewiesen wurden. Die Parameter
sind alphanumerische Token (ohne Leerzeichen), gefolgt von einem Gleichheitszeichen und ihrem
entsprechenden Wert. Mehrere Parameter/Wertepaare können auf der Befehlszeile mit einem einzigen
Leerzeichen zwischen jedem Paar platziert werden. Parametertoken und -werte dürfen keine
Gleichheitszeichen enthalten, Werte können jedoch Leerzeichen enthalten. Der Zweck der Funktion
besteht darin, die Parameter und Werte zu isolieren, um eine Liste von Parameter- und Wertlängen
zurückzugeben. Es muss sein Ergebnis im gleichen Format und in der gleichen Reihenfolge liefern,
indem es jeden Eintrag (Token und Werte) durch seine entsprechende Länge ersetzt.
Wenn beispielsweise str: "SampleNumber =3234 provider=Dr. M. Welby patient=John Smith

priority=High" lautet, sollte Ihre Funktion die Zeichenfolge "12=4 8=12 7=10 8=4" zurückgeben, da
"SampleNumber" ein 12-Zeichen-Token mit einem 4-Zeichen-Wert ("3234") ist, gefolgt von "provider",
einem 8-Zeichen-Token, gefolgt von einem 12-Zeichen-Wert ("Dr. M. Welby") usw.
Beispiele
Eingabe: "Buchstaben=A B Z T Zahlen=1 2 26 20 kombinieren=wahr"

Ausgabe: 7=7 7=9 7=4
Eingang: "a=3 b=4 a=23 b=a 4 23 c="

Ausgang: 1=1 1=1 1=2 1=6 1=0
function CommandLine(str) {
let splitter = /\s(?=\w+=)/
let wordArr = str.split(Splitter);
wordArr = wordArr.map(Paar => {

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

}

CommandLine(readline());
Sternebewertung
Lassen Sie die Funktion StarRating(str) den STR-Parameter übergeben, der eine
durchschnittliche Bewertung zwischen 0,00 und 5,00 ist, und wandeln Sie diese Bewertung in eine Liste
von 5 Bildnamen um, die in einer Benutzeroberfläche angezeigt werden, um die Bewertung als eine Liste
von Sternen und halben Sternen darzustellen. Die Bewertungen sollten auf die nächste Hälfte
aufgerundet werden. Es stehen 3 Bilddateinamen zur Verfügung: "full.jpg", "half.jpg", "empty.jpg". Die
Ausgabe ist der Name der 5 Bilder (ohne die Erweiterung), von links nach rechts, durch Leerzeichen
getrennt. Zum Beispiel: Wenn str "2.36" ist, dann sollte dies durch das folgende Bild angezeigt
werden:
So sollte Ihr Programm den String "full full half empty empty" zurückgeben.
Beispiele
Eingang: „0.38“
Ausgang: halb leer leer leer leer
Eingang: "4.5"
Ausgang: voll voll voll halb voll
funktion StarRating(str) {
let num = (Math.round(parseFloat(str) * 2)) / 2;
let starString = '';
let half = !(Math.trunc(num) === num);
starString = starString + ' full'.repeat(num);

if (half) {
starString += ' halb';
}
return (starString + ' empty'.repeat(5 - num)).trim();
}

StarRating(readline());

Problemlösung 1

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Problemlösung 1

Hochgeladen von

Copyright:

Verfügbare Formate

Erste Rückwärtsfahrt

Eingabe: „I Love Code“

var arr = str.split('');

//diesen Funktionsaufruf hier behalten

let newString = '';

//diesen Funktionsaufruf hier behalten

//diesen Funktionsaufruf hier behalten

for (let i = 1; i <= num; i++) {

//diesen Funktionsaufruf hier behalten

// code goes here

//diesen Funktionsaufruf hier behalten

//diesen Funktionsaufruf hier behalten

Eingabe: "Spaß&!! Zeit"

Input: „Ich liebe Hunde“

var arr = sen.split(' ');

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

// code goes here

//diesen Funktionsaufruf hier behalten

for (let i = 0, length = 0, word = ''; i < sen.length; i++) {

if (length > maxLength) {

//diesen Funktionsaufruf hier behalten

//diesen Funktionsaufruf hier behalten

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

//diesen Funktionsaufruf hier behalten

let newString = '';

for (let i = 0; i < str.length; i++) {

let vocals = 'aeiou';

let finalString = '';

//diesen Funktionsaufruf hier behalten

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

//diesen Funktionsaufruf hier behalten

//diesen Funktionsaufruf hier behalten

//diesen Funktionsaufruf hier behalten

// code goes here

//diesen Funktionsaufruf hier behalten

Lassen Sie die FunktionLetterCapitalize (str) den übergebenen

Input: „Hallo Welt“

Eingabe: "Ich bin dort gelaufen"

wordarr = str.split(" ");

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

//diesen Funktionsaufruf hier behalten

newWord = (str[i] === ' ') ? true : false;

//diesen Funktionsaufruf hier behalten

// code goes here

//diesen Funktionsaufruf hier behalten

//diesen Funktionsaufruf hier behalten

if (str === '') {

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

return result ? 'true' : 'false';

funktion letterEval(Buchstabe, Index) {

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

//diesen Funktionsaufruf hier behalten

// code goes here

//diesen Funktionsaufruf hier behalten

Eingang: 3 & num2 = 122

Eingang: 67 & num2 = 67

//diesen Funktionsaufruf hier behalten

if (num2 > num1) {

//diesen Funktionsaufruf hier behalten

// code goes here

//diesen Funktionsaufruf hier behalten

//diesen Funktionsaufruf hier behalten

let hours = Math.floor(num/60);