Résolution de Problèmes-1

Premier renversement
La fonctionFirstReverse(str) prend le paramètrestr qui lui est transmis et renvoie la chaîne

dans l'ordre inverse. Par exemple : si la chaîne d'entrée est "Hello World and Coders", votre programme
doit renvoyer la chaînesredoC dna dlroW olleH.
Exemples
Entrée : "coderbyte"
Sortie : etybredoc
Entrée : "I Love Code"

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

arr.reverse() ;
return arr.join('') ;
}
// garder cet appel de fonction ici

// pour voir comment saisir des arguments en JavaScript, faites défiler vers le bas
FirstReverse(readline()) ;
let newString = '' ;

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

// le code va ici
return str.split('').reverse().join('') ;

Premier factoriel
La fonctionFirstFactorial(num) prend le paramètrenum qui lui est passé et renvoie la factorielle

de ce dernier. Par exemple : sinum= 4, votre programme doit retourner(4 * 3 * 2 * 1)= 24. Pour les cas
de test, la plage sera comprise entre 1 et 18 et l'entrée sera toujours un nombre entier.
Exemples
Entrée : 4
Sortie : 24
Entrée : 8
Sortie : 40320
function FirstFactorial(num) {
let factorial = 1 ;
for (let i = 1 ; i <= num ; i++) {

factoriel *= i ;
}
retourner factorielle ;

FirstFactorial(readline()) ;
// le code va ici
if (num < 0) return NaN ;
return (num > 1) ? PremierFactoriel(num - 1) * num : 1 ;

let answer = 1 ;
for (let index = 1 ; index <= num ; index++) {
answer *= index ;
}
Retourner la réponse ;

Mot le plus long
Faire en sorte que la fonctionLongestWord(sen) prenne le paramètresen transmis et renvoie le mot

le plus grand de la chaîne. Si deux mots ou plus ont la même longueur, le premier mot de la chaîne ayant
cette longueur est renvoyé. Ne tenez pas compte de la ponctuation et supposez que sen ne sera pas vide.
Exemples
Entrée : "fun& !! time"

Sortie : time
Entrée : "J'aime les chiens"

Sortie : amour
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() ;
// le code va ici
return sen ;

Mot le plus long (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)) {
longueur++ ;
word += c ;
} else {
longueur = 0 ;
mot = '' ;
}
if (length > maxLength) {

maxLength = length ;
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 ;
}

Changements de lettres
Demandez à la fonctionLetterChanges(str) de prendre le paramètrestr passé et de le modifier en

utilisant l'algorithme suivant. Remplacez chaque lettre de la chaîne par la lettre qui la suit dans
l'alphabet(par exemple, c devient d, z devient a). Ensuite, chaque voyelle de cette nouvelle chaîne (a, e,
i, o, u) est mise en majuscule et la chaîne modifiée est renvoyée.
Exemples
Entrée : "hello*3"
Sortie : Ifmmp*3
Entrée : "fun times !"
Sortie : gvO Ujnft !
function 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 ;

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

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 voyelles = 'aeiou' ;
let finalString = '' ;
// capitaliser les voyelles

for (let i = 0 ; i < newString.length ; i++) {
if (vowels.includes(newString[i])) {
finalString += newString[i].toUpperCase() ;
} else {
finalString += newString[i] ;
}
}
return finalString ;

str = str.replace(/[a-zA-Z]/g, function(ch) {
si (ch === 'z') retourner '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() ;
});
}

Ajout simple
Demandez à la fonctionSimpleAdding(num) d'additionner tous les nombres compris entre 1 etnum.

Par exemple : si l'entrée est 4, votre programme doit renvoyer 10 car 1 + 2 + 3 + 4 = 10. Pour les cas de
test, le paramètrenum sera un nombre quelconque compris entre 1 et 1000.
Exemples
Entrée : 12
Sortie : 78
Entrée : 140
Sortie : 9870
function SimpleAdding(num) {
if (num === 1) {
retour 1 ;
}
else {
return num + SimpleAdding(num -1) ;
}
}

SimpleAdding(readline()) ;
let sum = 0 ;
for (i = 1 ; i <= num ; i++) {
sum += i ;
}
retourner la somme ;

// le code va ici
if (num < 1) return NaN ;
else if (num === 1) return 1 ;
return SimpleAdding(num - 1) + num ;
}

Lettre en majuscule
La fonctionLetterCapitalize(str) prend le paramètrestr qui lui est transmis et met en

majuscule la première lettre de chaque mot. Les mots ne seront séparés que par un seul espace.
Exemples
Entrée : "hello world"

Sortie : Hello World
Entrée : "j'ai couru là"

Sortie : j'ai couru là
function 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 ;

LetterCapitalize(readline()) ;

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

}
return newString ;
}

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

Symboles simples
Demandez à la fonctionSimpleSymbols(str) de prendre le paramètrestr passé et de déterminer

s'il s'agit d'une séquence acceptable en renvoyant la chaînetrue oufalse. Le paramètrestr sera composé
de symboles+ et= avec plusieurs caractères entre eux(c'est-à-dire++d+===+c++==a) et pour que la
chaîne soit vraie, chaque lettre doit être entourée d'un symbole+. La chaîne de gauche serait donc fausse.
La chaîne ne sera pas vide et comportera au moins une lettre.
Exemples
Entrée : "+d+=3=+s+"
Sortie : true
Entrée : "f++d+"
Sortie : false
function SimpleSymbols(str) {
if (/^[a-zA-Z]/.test(str) || /[a-zA-Z]$/.test(str)) {
retourner faux ;
}
else if (/[^+][a-zA-Z]/.test(str) || /[a-zA-Z][^+]/.test(str)) {
retourner faux ;
}
else {
retourner vrai ;
}

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

retourner "false" ;
}
let result = str.split('').every(letterEval) ;
return result ? 'true' : 'false' ;
function letterEval(letter, index) {

let letters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' ;
if (letters.includes(letter)) {
// Vérifier la présence du premier ou du dernier caractère
if (index === 0 || index === str.length - 1) {
// La lettre est le premier ou le dernier caractère, cas d'échec
retourner faux ;
}
if (str[index - 1] === '+' && str[index + 1] === '+') {

retourner vrai ;
}
} else {
// Ignorer les lettres qui ne sont pas des lettres
retourner vrai ;
}
}

// le code va ici
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 ;
retourner vrai ;
}

Vérifier les numéros
La fonctionCheckNums(num1,num2) prend les deux paramètres passés et renvoie la chaînetrue

sinum2 est supérieur ànum1, sinon elle renvoie la chaînefalse. Si les valeurs des paramètres sont égales
entre elles, la chaîne-1 est renvoyée.
Exemples
Entrée : 3 & num2 = 122

Sortie : true
Entrée : 67 & num2 = 67

Sortie : -1
VIEW CHALLENGE
function CheckNums(num1,num2) {
if (num1 == num2) {
retourner "-1" ;
}
else {
return (num2 > num1) ;
}
}

CheckNums(readline()) ;
if (num2 > num1) {
retourner vrai ;
} else if (num1 === num2) {
retourner '-1' ;
} else {
retourner faux ;
}

// le code va ici
si ((num1 - num2) < 0) retourner vrai ;
else if ((num1 - num2) > 0) return false ;
sinon, retournez -1 ;
}

Convertir le temps
La fonctionTimeConvert(num) prend le paramètrenum et renvoie le nombre d'heures et deminutes

en lequel le paramètre est converti(par exemple, sinum= 63, le résultat doit être 1:3). Séparez le nombre
d'heures et de minutes par deux points.
Exemples
Entrée : 126
Sortie : 2:6
Entrée : 45
Sortie : 0:45
function TimeConvert(num) {
var hours = Math.floor(num/60) ;
var minutes = num % 60 ;
var str = heures + " :" + minutes ;
return str ;
}
TimeConvert(readline()) ;
let hours = Math.floor(num/60) ;

let minutes = num % 60 ;
return hours + ':' + minutes ;

// le code va ici
return Math.floor(num / 60) + ':' + (num % 60) ;

Soupe à l'alphabet
La fonctionAlphabetSoup(str) prend la chaîne de caractèresstr en paramètre et renvoie la chaîne

avec les lettres dans l'ordre alphabétique(par exemple, hello devient ehllo). On suppose que les chiffres
et les symboles de ponctuation ne seront pas inclus dans la chaîne.
Exemples
Sortie : bcdeeorty
Entrée : "hooplah"
Sortie : ahhloop
function AlphabetSoup(str) {
var arrays = str.split("") ;

var reversearrays = arrays.sort() ;
var result = reversearrays.join("") ;
retourner le résultat ;

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

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

// le code va ici
return str.split('').sort(function(ch1, ch2) {
return ch1.charCodeAt(0) - ch2.charCodeAt(0) ;
}).join('') ;
}

Contrôle AB
La fonctionABCheck(str) prend le paramètrestr qui lui est passé et renvoie la chaîne true si les
caractèresa etb sont séparés par exactement 3 positions n'importe où dans la chaîne au moins une
fois(par exemple,"lane borrowed" renverrait true car il y a exactement trois caractères entre a etb).
Sinon, il renvoie la chaîne de caractères false.
Exemples
Entrée : "after badly"

Sortie : false
Entrée : "Laura sobs"

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

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

// recherche d'un
if (str[i] === 'a') {
if (str[i+4] === 'b') {
retourner vrai ;
}
}
if (str[i] === 'b') {

if (str[i+4] === 'a') {
retourner vrai ;
}
}
}
retourner faux ;

// le code va ici
return str.match(/[aA].{3}[bB]/) !== null ;

}

Nombre de voyelles
La fonctionVowelCount(str) prend la chaîne de caractèresstr en paramètre et renvoie le nombre

de voyelles que la chaîne contient(par exemple,"All cows eat grass and moo" renverrait 8). Ne comptez
pas ley comme une voyelle pour ce défi.
Exemples
Entrée : "hello"
Sortie : 2
Sortie : 3
function VowelCount(str) {
var patt = /[aeiou]/gi ;
var arr = str.match(patt) ;
if (arr == null) {
retour 0 ;
}
else {
return arr.length ;
}
}

VowelCount(readline()) ;
let voyelles = 'aeiou' ;

laissez count = 0 ;

if (vowels.includes(str[i])) {
compter++ ;
}
}
retourner le compte ;
}

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

Nombre de mots
Faire en sorte que la fonctionWordCount(str) prenne la chaîne de caractèresstr en paramètre et

renvoie le nombre de mots que la chaîne contient(par exemple, "Ne jamais manger de blé déchiqueté ou
de gâteau" renverrait 6). Les mots seront séparés par des espaces simples.
Exemples
Entrée : "Hello World"

Sortie : 2
Entrée : "one 22 three"

Sortie : 3
function WordCount(str) {
var arr = str.split(" ") ;
var answer = arr.length ;
Retourner la réponse ;

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

// le code va ici
return str.split(' ').length ;
}

Ex Oh
La fonctionExOh(str) prend le paramètrestr qui lui est passé et renvoie la chaînetrue s'il y a un
nombre égal dex et deo, sinon elle renvoie la chaînefalse. Seules ces deux lettres seront saisies dans la
chaîne, sans ponctuation ni chiffres. Par exemple : sistr est "xooxxxxooxo", la sortie doit renvoyerfalse
car il y a 6 x et 5 o.
Exemples
Entrée : "xooxxo"
Sortie : true
Entrée : "x"
Sortie : false
function 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()) ;
// le code va ici
var letters = str.split('') ;
var numOfEx = letters.filter(function(ch) {
return ch === 'x' ;
}).length ;
var numOfOh = letters.filter(function(ch) {
return ch === 'o' ;
}).length ;
return numOfEx === numOfOh ;

ExOh(readline()) ;
Palindrome
La fonctionPalindrome(str) prend le paramètrestr passé et renvoie la chaînetrue si le paramètre

est un palindrome, (la chaîne est la même en avant qu'en arrière) sinon elle renvoie la chaîne false. Par
exemple : "voiture de course" est aussi "voiture de course" à l'envers. La ponctuation et les chiffres ne
feront pas partie de la chaîne.
Exemples
Entrée : "jamais pair ou impair"

Sortie : true
Entrée : "eye"
Sortie : true
function Palindrome(str) {
modified = str.replace(/W/g,"") ;
var arr1 = modified.split("") ;

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

Palindrome(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]) {
retourner faux ;
}
}
retourner vrai ;

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

retourner faux ;
}
}
retourner vrai ;

Arith Geo
La fonctionArithGeo(arr) prend le tableau de nombres stocké dansarr et renvoie la

chaîne"Arithmétique" si la séquence suit un modèle arithmétique ou renvoie"Géométrique" si elle
suit un modèle géométrique. Si la séquence ne suit aucun des deux modèles, il faut renvoyer -1. Une suite
arithmétique est une suite où la différence entre chacun des nombres est constante, alors que dans une
suite géométrique, chaque terme après le premier est multiplié par une constante ou un rapport commun.
Exemple arithmétique : [2, 4, 6, 8] et exemple géométrique : [2, 6, 18, 54]. Des nombres négatifs
peuvent être saisis comme paramètres, 0 ne sera pas saisi et aucun tableau ne contiendra tous les mêmes
éléments.
Exemples
Entrée : [5,10,15]
Sortie : Arithmétique
Entrée : [2,4,16,24]
Sortie : -1
function 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) {
retourner "Arithmétique" ;
}
}
for (var i = 0 ; i < len - 1 ; i++) {

if (arr[i+1] / arr [i] !== geoK) {
pause ;
}
else if (i === len - 2) {
retourner "Géométrique" ;
}
}
retourner -1 ;
}

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

// test arithmétique
for (let i = 2, diff = arr[1] - arr[0] ; i < arr.length ; i++) {
if (arr[i] - arr[i-1] !== diff) {
arithmétique = faux ;
}
}
if (arithmetic) {
return 'Arithmetic' ;
}
let géométrique = vrai ;

// géométrique
for (let i = 2, divisor = arr[1] / arr[0] ; i < arr.length ; i++) {
if (arr[i] / arr[i-1] !== diviseur) {
géométrique = faux ;
}
}
if (geometric) {
return 'Géométrique' ;
}
retourner -1 ;

// le code va ici
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++) {
si (arr[i + 1] - arr[i] !== différence) retournez faux ;
}
retourner vrai ;
};
var isGeo = function(arr) {

var multiplier = arr[1] / arr[0] ;
si (arr[i + 1] / arr[i] !== multiplicateur) retournez faux ;
}
retourner vrai ;
};
if (isArith(arr)) return "Arithmetic" ;

else if (isGeo(arr)) return "Géométrique" ;
sinon, retournez -1 ;
}

Ajout d'un réseau I
La fonctionArrayAdditionI(arr) prend le tableau de nombres stocké dansarr et renvoie la

chaînetrue si toute combinaison de nombres dans le tableau (à l'exception du plus grand nombre) peut
être additionnée pour être égale auplus grand nombre dans le tableau, sinon elle renvoie la chaînefalse.
Par exemple : siarr contient [4, 6, 23, 10, 1, 3], la sortie doit renvoyertrue car 4 + 6 + 10 + 3 = 23. Le
tableau ne sera pas vide, ne contiendra pas tous les mêmes éléments et pourra contenir des nombres
négatifs.
Exemples
Entrée : [5,7,16,1,2]
Sortie : false
Entrée : [3,5,-1,8,12]
Sortie : true
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 === target) {
retourner vrai
}
}
retourner faux
function arrayPrep(arr2) {
arr.sort(function(a, b){
retourner a - b
});
cible = arr2.pop()
retour arr2
}
}

ArrayAdditionI(readline()) ;
// trouver le plus grand nombre

let largestIndex = 0 ;
let largestNumber = 0 ;
for (let i = 0 ; i < arr.length ; i++) {
if (arr[i] > largestNumber) {
plus grandIndex = 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) ;
}
// itère sur toutes les combinaisons de nombres

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 === largestNumber) {

retourner vrai ;
}
}
retourner faux ;
}

// le code va ici
vartedArr = 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(sum) ;
}
return sums.indexOf(largest) !== -1 ;

}

Compte de lettres I
Demandez à la fonctionLetterCountI(str) de prendre le paramètrestr passé et de renvoyer le

premier mot avec le plus grand nombre de lettres répétées. Par exemple : "Today, is the greatest day ever
!" devrait renvoyer "greatest" parce qu'il contient 2 e (et 2 t) et qu'il précède "ever" qui contient
également 2 e. S'il n'y a pas de mots avec des lettres répétées, il renvoie-1. Les mots sont séparés par des
espaces.
Exemples
Entrée : "Hello apple pie"

Sortie : Hello
Entrée : "Pas de mots"

Sortie : -1
function 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]) {
contre++ ;
}
else {
if (counter > maxcount) {
maxcount = counter ;
compteur = 1 ;
}
}
}
newarr.push([arr[i], maxcount])
maxcount = 0 ;
}
newarr.sort(function(a, b) {return b[1] - a[1]}) ;
if (newarr[0][1] == 1) {
retourner -1 ;
}
else {
return newarr[0][0] ;
}
}

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 :
++compte-lettres[mots[i][j]] ;
if (letterCount[words[i][j]] >= 2 && letterCount[words[i][j]] >
largestCount) {
largestCount = letterCount[words[i][j]] ;
}
}
if (largestCount > bestCount) {

bestCount = largestCount ;
meilleurmot = mots[i] ;
}
}
return (bestWord === '') ? -1 : bestWord ;

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

word = word.toLowerCase() ;
var letters = [] ;
pour (lettre du mot) {
if (letters[letter]) {
letters[letter] += 1 ;
} else {
letters[letter] = 1 ;
}
}
les lettres de retour ;
});
var greatestCounts = counts.map(function(word) {

var greatest = 0 ;
for (letter in word) {
if (word[letter] > greatest) {
plus grand = mot[lettre] ;
}
}
retourner le plus grand ;
});
var greatest = Math.max.apply(null, greatestCounts) ;

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

Second GreatLow
La fonctionSecondGreatLow(arr) prend le tableau de nombres stocké dansarr et renvoie

respectivement l'avant-dernier et l'avant-dernier plus grand nombres, séparés par un espace. Par
exemple : siarr contient [7, 7, 12, 98, 106], la sortie devrait être12 98. Le tableau ne sera pas vide et
contiendra au moins 2 nombres. Cela peut s'avérer délicat s'il n'y a que deux chiffres !
Exemples
Entrée : [1, 42, 42, 180]

Sortie : 42 42
Entrée : [4, 90]

Sortie : 90 4
function SecondGreatLow(arr) {
arr.sort(function(a, b) {return a - b}) ;
arr = lonely(arr) ;
var newlen = arr.length ;
return arr[1] + ' ' + arr[newlen - 2]
function 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 ;
}
}
retour de la sortie
}
}

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

if (arr[i] !== arr[0]) {
second = arr[i] ;
pause ;
}
}
let pénultième = arr[arr.length - 2] ;

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

SecondGreatLow(readline()) ;
// le code va ici
sorted = arr.sort(function(a,b){return a-b;}) ;
var greatest = sorted[sorted.length - 1] ;
var lowest = sorted[0] ;
var secondGreatest, secondLowest ;
for (var i = 0 ; i < sorted.length ; i++) {

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

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

}

SecondGreatLow(readline()) ;
Division Stringified
La fonctionDivisionStringified(num1,num2) doit prendre les deux paramètres passés,

divisernum1 parnum2 et renvoyer le résultat sous forme de chaîne de caractères avec des virgules
correctement formatées. Si une réponse ne comporte que 3 chiffres, le nombre est retourné sans
virgule(par exemple, 2 / 3 devrait donner "1"). Par exemple : sinum1 est123456789 etnum210000, la
sortie doit être"12,346".
Exemples
Entrée : 5 & num2 = 2

Sortie : 3
Entrée : 6874 & num2 = 67

Sortie : 103
VIEW CHALLENGE
function 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("") ;
}
return nouvelle chaîne ;

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

for (let i = 0 ; i < temp.length ; i++) {
if (i % 3 === 2 && i != temp.length-1) { // nécessité d'une virgule ensuite
newString = ',' + temp[i] + newString ;
} else {
newString = temp[i] + newString ;
}
}
//console.log(newString) ;
return newString ;
}

// le code va ici
var format = function(num) {
var result = '' ;
var whole = Math.round(num) ;
si (entier === 0) retour 0 ;
while (whole > 0) {

result = (result === '' ? '' : ',') + result ;
résultat = (entier % 1000) + résultat ;
whole = Math.floor(whole / 1000) ;
}
}
return format(num1 / num2) ;

}

Compter les minutes I
Que la fonctionCountingMinutesI(str) prenne le paramètrestr qui lui est passé et qui sera deux
heures (chacune correctement formatée avec deux points et am ou pm) séparées par un trait d'union et
renvoie le nombre total de minutes entre les deux heures. L'heure est indiquée au format 12 heures. Par
exemple : sistr est9:00am-10:00am, la sortie doit être 60. Sistr est13h00-11h00, le résultat doit
être1320.
Exemples
Entrée : "12:30pm-12:00am"
Sortie : 690
Entrée : "1:23am-1:08am"
Sortie : 1425
Solutions pour Compter les minutes I
JAVASCRIPT
VIEW CHALLENGE
function 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) {
heure1 = heure1 + 12 ;
}
if (ampm2 == "pm" && hour2 != 12) {
heure2 = heure2 + 12 ;
}
if (hour1 == 12 && ampm1 == "am") {
heure1 = 0 ;
}
if (hour2 == 12 && ampm2 == "am") {
heure2 = 0 ;
}
var time1 = (hour1*60) + min1 ;
var time2 = (hour2*60) + min2 ;
var diff = time2 - time1 ;
if (diff < 0) {
diff = diff + (60 * 24) ;
}
retour diff ;

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

let paires = currentValue.split(':') ;
let time = ((paires[1][2] === 'a') ? parseInt(paires[0]) % 12 :
parseInt(paires[0]) % 12 + 12) * 60 + parseInt(paires[1][0] + paires[1][1]) ;
l'heure de retour ;
});
let diff = times[1] - times[0] ;

return (diff < 0) ? diff + 1440 : diff ;
}
// le code va ici
var times = str.split('-') ;
var from = times[0], to = times[1] ;
function parseMinutes(timeStr) {
var time = timeStr.match(/d+/g) ;
var hour = parseInt(time[0]), minute = parseInt(time[1]) ;
var ampm = (timeStr.match(/[a|p]m/g)[0] === 'am') ? 0 : 1 ;
si (heure === 12) heure = 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 ;

}

Moyenne Mode
Demandez à la fonctionMeanMode(arr) de prendre le tableau de nombres stocké dansarr et de

renvoyer 1si lemode est égal à lamoyenne, 0s'ils ne sont pas égaux entre eux(par exemple, [5, 3, 3, 3, 1]
devrait renvoyer 1 car le mode (3) est égal à la moyenne (3)).[5, 3, 3, 3, 1] devrait renvoyer 1 car le
mode (3) est égal à la moyenne (3)). Le tableau ne sera pas vide, ne contiendra que des nombres entiers
positifs et ne contiendra pas plus d'un mode.
Exemples
Entrée : [1, 2, 3]
Sortie : 0
Entrée : [4, 4, 4, 6, 2]
Sortie : 1
function MeanMode(arr) {
len = arr.length
//Étape 1 : déterminer la moyenne - explicite
function mean(arr) {
var count = 0 ;
for (var i = 0 ; i < len ; i++) {
count += arr[i]
}
console.log (count / len)
return count / len
}
//Etape 2 : déterminer le mode. Nous devons compter combien il y a de chaque type
dans le tableau. Une alternative consiste à maintenir un compteur, à trier le
tableau et à compter jusqu'à ce qu'un élément change, en gardant trace du nombre
maximum et de la valeur associée. La méthode suivante est beaucoup plus simple, en
supposant que l'on ait une connaissance de base des objets javascript. Il attribue
une clé à chaque nouvelle entrée et tient le compte du nombre d'entrées, puis crée un
tableau des paires clé-valeur créées.
function mode(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 = [] ;
for (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] ;
}
//Comparer la moyenne et le mode
return mode(arr) == mean(arr) ? 1 : 0 ;
}

MeanMode(readline()) ;
// Mode recherche
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 !
compter++ ;
if (count > mostOccurances) {
mostOccurances = count ;
mode = arr[j] ;
}
}
}
}
// Trouver la moyenne
laissez moyenne = 0 ;
mean += arr[i] ;
}
mean = Math.round(mean/arr.length) ;
return (mean === mode) ? 1 : 0 ;

// le code va ici
function mode(arr) {
var counts = [], mode, maxCount = 0 ;
for (num of arr) {
num = num + ' ' ;
if (counts[num]) counts[num]++ ;
else counts[num] = 1 ;
}
for (num in counts) {

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

}

Insertion dans le tableau de bord
La fonctionDashInsert(str) insère des tirets ('-') entre les deux nombres impairs destr. Par
exemple : sistr est454793, la sortie devrait être4547-9-3. Ne comptez pas le zéro comme un nombre
impair.
Exemples
Entrée : 99946
Sortie : 9-9-946
Entrée : 56730
Sortie : 567-30
function DashInsert(num) {
var strnum = num.toString() ;
var arr = strnum.split("") ;
for (i = 0 ; i < arr.length ; i++) {

arr[i] = parseInt(arr[i]) ;
}
for (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("") ;
retourner x ;

DashInsert(readline()) ;
function 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 ;
}

function DashInsert(str) {
// le code va ici
chiffres = str.split('') ;
function 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('') ;
}

Cas d'échange
La fonctionSwapCase(str) doit prendre le paramètrestr et intervertir la casse de chaque caractère.

Par exemple : sistr est "Hello World", la sortie devrait êtrehELLO wORLD. Laissez les chiffres et les
symboles tels qu'ils sont.
Exemples
Entrée : "Hello-LOL"
Sortie : hELLO-lol
Entrée : "Sup DUDE !!?"

Sortie : 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 ;

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

const UPPER = 'ABCDEFGHIJKLMNOPWRSTUVWXYZ' ;

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

// le code va ici
return str.split('').map(function(letter) {
if (letter === letter.toLowerCase()) return letter.toUpperCase() ;
else if (letter === letter.toUpperCase()) return letter.toLowerCase() ;
sinon renvoyer la lettre ;
}).join('') ;
}

Addition de nombres
La fonctionNumberSearch(str) prend le paramètrestr, recherche tous les nombres de la chaîne,

les additionne, puis renvoie le nombre final. Par exemple : sistr est "88Hello 3World !", la sortie
devrait être91. Vous devrez faire la différence entre les nombres à un chiffre et les nombres à plusieurs
chiffres, comme dans l'exemple ci-dessus. Ainsi, "55Hello" et "5Hello 5" devraient renvoyer deux
réponses différentes. Chaque chaîne contient au moins une lettre ou un symbole.
Exemples
Entrée : "75Nombre9"
Sortie : 84
Entrée : "10 2Un nombre*1*"

Sortie : 13
VIEW CHALLENGE
function NumberAddition(str) {
var sum = 0 ;
var count = 0 ;
var strArr = function(str) {
//supprimez les non chiffres et remplacez-les par des espaces pour les
séparer
str = str.replace(/[^0-9]/g, ' ') ;
//supprimez les espaces précédents et finaux
str = str.trim() ;
//transforme les espaces doubles en espaces simples, jusqu'à ce qu'il n'y ait
plus d'espaces doubles
while (str.indexOf(' ') !== -1) {
str = str.replace(/ss/g, ' ') ;
}
//Retourne un tableau de chaînes de nombres sans espaces ;
return str.split(' ') ;
}
//appelle la fonction strArr sur l'entrée de l'utilisateur et la stocke comme
"préparée"
var prepped = strArr(str) ;
//transforme chaque chaîne de chiffres en un nombre
prepped = prepped.map(function(val) {
return val ? parseInt(val) : 0 ;
})
console.log('preppedmap', prepped) ;
//exécute la méthode reduce pour additionner tous les nombres
var ans = prepped.reduce(function(firstval, lastval){
return firstval + lastval
})
retour ans
}
NumberAddition(readline()) ;
let DIGITS = '0123456789' ;

let nombres = [] ;
// Trouver d'abord les nombres

for (let i = 0, number = '' ; i < str.length ; i++) {
if (!DIGITS.includes(str[i])) {
if (number !== '') {
nombres.push(nombre) ;
}
nombre = '' ;
} else {
number += str[i] ;
// cas particulier pour le dernier caractère

if (i === str.length-1) {
nombres.push(nombre) ;
}
}
}
let sum = 0 ;
for (let i = 0 ; i < numbers.length ; i++) {
sum += parseInt(numbers[i]) ;
}
}

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

Troisième plus grand
La fonctionThirdGreatest(strArr) prend le tableau de chaînes de caractères stocké dansstrArr

et renvoie letroisième plus grand motqu'il contient. Par exemple, si strArr est ["hello", "world",
"before", "all"] sistrArr est ["hello", "world", "before", "all"], votre résultat devrait êtreworld car
"before" a 6 lettres, et "hello" et "world" en ont toutes deux 5. a 6 lettres, et "hello" et "world" en ont 5,
mais la sortie devrait êtreworld parce qu'il est apparu comme le dernier mot de 5 lettres dans le tableau.
SistrArr était ["hello", "world", "after", "all"], le résultat devrait êtreafter parce que les trois premiers
mots ont tous 5 lettres, donc il faut renvoyer le dernier. Le tableau comportera au moins trois chaînes et
chaque chaîne ne contiendra que des lettres.
Exemples
Entrée : ["coder", "byte", "code"]

Sortie : code
Entrée : ["abc", "defg", "z", "hijk"]

Sortie : abc
function ThirdGreatest(strArr) {
strArr.sort(function(a, b) {return b.length - a.length}) ;
return strArr[2] ;
}

Troisième plus grand(readline()) ;
strArr.sort(function(a,b){return b.length - a.length}) ;
return strArr[2] ;

Troisième plus grand(readline()) ;
// le code va ici
return strArr.sort(function(a, b) {
return (b.length - a.length) ;
})[2];

ThirdGreatest(readline()) ;
Pouvoirs de deux
La fonctionPowersofTwo(num) prend le paramètrenum qui lui est passé, qui sera un entier, et
renvoie la chaînetrue s'il s'agit d'une puissance de deux. Si ce n'est pas le cas, la chaîne de
caractèresfalse est renvoyée. Par exemple, si l'entrée est 16, votre programme doit renvoyer la chaîne
true, mais si l'entrée est 22, la sortie doit être la chaîne false.
Exemples
Entrée : 4
Sortie : vrai
Entrée : 124
Sortie : faux
function 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"}
}
}
// le code va ici
retourner ans ;

PowersofTwo(readline()) ;
return Number.isInteger(Math.log(num) / Math.log(2)) ? true : false ;

}

// le code va ici
si (num === 1) retourner vrai ;
else {
return (num % 2 === 0) ? PowersofTwo(num / 2) : false ;
}
}

Persistance des additifs
La fonctionAdditivePersistence(num) prend le paramètrenum passé, qui sera toujours un entier

positif, et renvoie sa persistance additive, qui est le nombre de fois que vous devez ajouter les chiffres
denum jusqu'à ce que vous atteigniez un seul chiffre. Par exemple : sinum est2718, votre programme
doit renvoyer2 car 2 + 7 + 1 + 8 = 18 et 1 + 8 = 9 et vous vous arrêtez à 9.
Exemples
Entrée : 4
Sortie : 0
Entrée : 19
Sortie : 2
VIEW CHALLENGE
function AdditivePersistence(num) {
function arrprep(numb) {
var numstr = numb.toString() ;
var arr = numstr.split('') ;
var numarr = arr.map(function(val) {
return parseInt(val)
})
retour numarr
}
function addup(arr) {
var redux = arr.reduce(function(a, b){
return a + b })
retour redux
}
var count = 0 ;
while (num > 9) {

num = addup(arrprep(num)) ;
compter++ ;
}
Retourner le compte

AdditivePersistence(readline()) ;
num = num.toString() ;
laissez count = 0 ;
while (count < 10000) { // arrêt brutal

if (num.length === 1) {
pause ;
}
compter++ ;
let sum = 0 ;
for (let i = 0 ; i < num.length ; i++) {
sum += parseInt(num[i]) ;
}
num = sum.toString() ;
}
}

// le code va ici
function 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) {
résultat = addDigits(résultat) ;
compter++ ;
}
}

Persistance multiplicative
La fonctionMultiplicativePersistence(num) prend le paramètrenum passé, qui sera toujours

un entier positif, et renvoie sa persistance multiplicative, qui est le nombre de fois que vous devez
multiplier les chiffres denum jusqu'à ce que vous atteigniez un seul chiffre. Par exemple : sinum est39,
votre programme doit renvoyer3 car 3 * 9 = 27 puis 2 * 7 = 14 et enfin 1 * 4 = 4 et vous vous arrêtez à 4.
Exemples
Entrée : 4
Sortie : 0
Entrée : 25
Sortie : 2
function MultiplicativePersistence(num) {
function numprep(num) {
var strnum = num.toString() ;
var arr = strnum.split('') ;
var numarr = arr.map(function(val) {
return parseInt(val)}) ;
retour numarr
}
function multnums(arr) {
var newnum = arr.reduce(function(a, b) {
return a * b})
retour du nouveau numéro
}
// le code va ici
var count = 0 ;
while (num > 9) {

num = multnums(numprep(num)) ;
count++
}
Retourner le compte
}

MultiplicativePersistence(readline()) ;
laissez count = 0 ;
while(1) {
if (num.length === 1) {
pause ;
}
compter++ ;
let sum = 1 ;
sum *= parseInt(num[i]) ;
}
num = sum.toString() ;
}

// le code va ici
function 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) ;
compter++ ;
}
}

Hors ligne Minimum

Demandez à la fonctionOffLineMinimum(strArr) de prendre le paramètrestrArr passé, qui sera
un tableau d'entiers allant de 1...n et la lettre "E", et de renvoyer le sous-ensemble correct en fonction
des règles suivantes. L'entrée se fera dans le format suivant : ["I", "I", "E", "I",.. : ["I", "I", "E", "I",...,
"E",..., "I"] où les "I" représentent des entiers et le "E" signifie qu'il faut retirer le plus petit entier de
l'ensemble. Une fois terminé, votre programme doit renvoyer ce nouvel ensemble avec des entiers
séparés par des virgules. Par exemple : sistrArr est ["5", "4", "6", "E", "1", "7", "E", "E", "3", "2"],
votre programme doit renvoyer4,1,5.
Exemples
Entrée : ["1", "2", "E", "E", "3"]
Sortie : 1,2
Entrée : ["4", "E", "1", "E", "2", "E", "3", "E"]
Sortie : 4,1,2,3
function 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, count) ;
strArr.shift() ;
holdArr = holdArr.concat(headArr) ;
holdArr.sort(function(a, b) {return a - b}) ;
ans.push(holdArr.shift()) ;
compte = 0 ;
}
else {
compter++ ;
}
}
return ans.join(',') ;
}

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') {
// ne rien faire
} else {
// le numéro ne fait rien
}
}
function removeSmallest(strArr, maxIndex) {
let plus petitIndex = 0 ;

let smallestNumber = null ;
strArr.forEach(function(value,index){
if (index > maxIndex) {
retour ;
}
if (value !== 'E' && value !== 'R') {
if (smallestNumber === null || parseInt(value) < smallestNumber) {
plus petitIndex = index ;
smallestNumber = parseInt(value) ;
}
}
});
strArr[smallestIndex] = 'R' ;
return smallestNumber ;
}
return result.join(',') ;

// le code va ici
var arr = [], result = [] ;
var log = "" ;
for (item of 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(',') ;
}

Changement de séquence
Demandez à la fonctionChangingSequence(arr) de prendre le tableau de nombres stocké dansarr

et de renvoyer l'indice auquel les nombres cessent d'augmenter et commencent à diminuer ou cessent de
diminuer et commencent à augmenter. Par exemple : siarr est [1, 2, 4, 6, 4, 3, 1], votre programme doit
renvoyer3 car 6 est le dernier point du tableau où les nombres étaient croissants et le nombre suivant
commence une séquence décroissante. Le tableau contiendra au moins 3 nombres et il ne peut contenir
qu'une seule séquence, croissante ou décroissante. S'il n'y a qu'une seule séquence dans le tableau, votre
programme doit renvoyer-1. L'indexation doit commencer par 0.
Exemples
Entrée : [-4, -2, 9, 10]

Sortie : -1
Entrée : [5, 4, 3, 2, 10, 11]

Sortie : 3
function ChangingSequence(arr) {
//d'abord, déterminer s'il s'agit d'une séquence croissante ou décroissante
var type = arr[1] - arr[0] > 0 ? 'croissant' : 'décroissant' ;
//définir un index maximum pour le tableau, afin d'éviter qu'il ne déborde

var maxInd = arr.length - 1 ;
//code pour un tableau croissant

if (type === 'increasing') {
//findIndex est une méthode d'itération de tableau qui a été introduite avec
ES6. Il renvoie
//la première valeur pour laquelle le callback renvoie une valeur fausse.
var index = arr.findIndex(function(val, ind) {
while (ind < maxInd) {
return val > arr[ind + 1] ;
}
retourner faux ;
});
l'indice de retour ;
}
if (type === 'decreasing') {

var index = arr.findIndex(function(val, ind) {
while (ind < maxInd) {
return val < arr[ind + 1]
}
retour 0 ;
});
l'indice de retour ;
}
}

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

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

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

if (increasing) {
si (arr[i] > arr[i + 1]) retour i ;
} else {
si (arr[i] < arr[i + 1]) retour i ;
}
}
retourner -1 ;
}

Chevauchement des gammes
La fonctionOverlappingRanges(arr) prend le tableau de nombres stocké dansarr qui contiendra

5 entiers positifs, les deux premiers représentant une plage de nombres (a à b), les deux suivants
représentant également une autre plage d'entiers (c à d), et un 5ème élément final (x) qui sera également
un entier positif, et renvoie la chaînetrue si les deux ensembles de plages se chevauchent d'au moins x
nombres. Par exemple : siarr est [4, 10, 2, 6, 3], votre programme doit renvoyer la chaînetrue. La
première série de nombres est 4, 5, 6, 7, 8, 9, 10 et la deuxième série de nombres est 2, 3, 4, 5, 6. Le
dernier élément du tableau est 3, et il y a 3 nombres qui se chevauchent dans les deux plages : 4, 5 et 6.
Si les deux plages ne se chevauchent pas d'au moins x nombres, votre programme doit renvoyer la chaîne
de caractèresfalse.
Exemples
Entrée : [5,11,1,5,1]
Sortie : true
Entrée : [1,8,2,4,4]
Sortie : false
function 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()) ;
laissez count = 0 ;
for (let i = arr[0] ; i <= arr[1] ; i++) {
if (i >= arr[2] && i <= arr[3]) {
compter++ ;
}
}
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 ;
// détermine le chevauchement entre deux plages

// un nombre négatif signifie qu'il n'y a pas de chevauchement
function overlap(range1, range2) {
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] ;
}
}
return overlap(range1, range2) >= minimumOverlap ;

}

Super-augmentation
Demandez à la fonctionSuperincreasing(arr) de prendre le tableau de nombres stocké dansarr

et de déterminer si le tableau forme une séquence superincrémentale où chaque élément du tableau est
plus grand que la somme de tous les éléments précédents. Le tableau ne comprendra que des nombres
entiers positifs. Par exemple : siarr est [1, 3, 6, 13, 54], votre programme devrait renvoyer la chaîne
"true" car elle forme une séquence superincrémentale. Si une séquence superincrémentale n'est pas
formée, votre programme doit renvoyer la chaîne "false"
Exemples
Entrée : [1,2,3,4]
Sortie : false
Entrée : [1,2,5,10]
Sortie : true
function Superincreasing(arr) {
var maxInd = arr.length - 1 ;
var target ;
var sum ;
for (var i = maxInd ; i > 0 ; i--) {

cible = arr.pop()
sum = arr.reduce(function(val1, val2) {
retourner val1 + val2 ;
});
if (sum >= target) {
retourner "false" ;
}
};
retourner 'true' ;
}
Superincreasing(readline()) ;
for (let i = 0, sum = 0 ; i < arr.length ; i++) {

if (arr[i] <= sum) {
retourner faux ;
}
sum += arr[i] ;
}
retourner vrai ;
}

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

si (arr[i] <= total) retour faux ;
total += arr[i] ;
}
retourner vrai ;
}

Distance de Hamming
La fonctionHammingDistance(strArr) doit prendre le tableau de chaînes de caractères stocké

dansstrArr, qui ne contiendra que deux chaînes de caractères de même longueur, et renvoyer la
distance de Hamming qui les sépare. La distance de Hamming est le nombre de positions où les
caractères correspondants sont différents. Par exemple : sistrArr est ["coder", "codec"], votre
programme doit renvoyer 1. La chaîne sera toujours de même longueur et ne contiendra que des
caractères minuscules de l'alphabet et des chiffres.
Exemples
Entrée : ["10011", "10100"]

Sortie : 3
Entrée : ["helloworld", "worldhello"]

Sortie : 8
function HammingDistance(strArr) {
laissez count = 0 ;
for (let i = 0 ; i < strArr[0].length ; i++) {
if (strArr[0][i] !== strArr[1][i]) {
count++
}
}
}

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

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

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

Surface du rectangle
Solution pour les utilisateurs les mieux notés
function 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) {
retour 0 ;
} else {
return (Math.abs(obj.x1 - obj.x2) * Math.abs(obj.y1 - obj.y2)) ;
}
}

RectangleArea(readline()) ;
// Parse l'entrée dans un tableau

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)) ;
retourner [x,y] ;
});
let point = coords.shift() ;

let x = point[0] ;
let y = point[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) ;
}
});
retourner deltaX * deltaY ;

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

}

Bitwise One
La fonctionBitwiseOne(strArr) prend le tableau de chaînes stocké dansstrArr, qui ne

contiendra que deux chaînes de même longueur représentant des nombres binaires, et renvoie une chaîne
binaire finale qui a effectué l'opération bitwise OR sur les deux chaînes. Une opération de OU binaire
place un 0 dans la nouvelle chaîne lorsqu'il y a des zéros dans les deux chaînes binaires, sinon elle place
un 1 à cet endroit. Par exemple : sistrArr est ["1001", "0100"], votre programme doit renvoyer la
chaîne "1101"
Exemples
Entrée : ["100", "000"]

Sortie : 100
Entrée : ["00011", "01010"]

Sortie : 01011
VIEW CHALLENGE
function 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' ;
}
}
retour de la sortie ;
}


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

Autres produits
La fonctionAutresProduits(arr) prend le tableau de nombres stocké dansarr et renvoie une

nouvelle liste des produits de tous les autres nombres du tableau pour chaque élément. Par exemple :
siarr est [1, 2, 3, 4, 5], le nouveau tableau, dont chaque emplacement est le produit de tous les autres
éléments, est [120, 60, 40, 30, 24]. Les calculs suivants ont été effectués pour obtenir cette réponse :
[(2*3*4*5), (1*3*4*5), (1*2*4*5), (1*2*3*5), (1*2*3*4)]. Vous devez générer ce nouveau tableau et
renvoyer les nombres sous la forme d'une chaîne de caractères reliée par un trait d'union : 120-60-40-30-
24. Le tableau contiendra au maximum 10 éléments et au moins 1 élément composé uniquement d'entiers
positifs.
Exemples
Entrée : [1,4,3]
Sortie : 12-3-4
Entrée : [3,1,2,6]
Sortie : 12-36-18-6
function OtherProducts(arr) {
let holdArray = [] ;
arr.forEach((val, ind, theArray) => {
newArray = Array.from(theArray)
newArray.splice(ind,1)
holdArray[ind] = newArray.reduce((val1, val2) => val1 * val2) ;

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

Autres produits(readline()) ;
let results = [] ;
let product = 1 ;
for (let j = 0 ; j < arr.length ; j++) {
if (i !== j) {
product *= arr[j] ;
}
}
results.push(product) ;
}
return results.join('-') ;
}

function product(arr) {
return arr.reduce((a,b) => a * b) ;
}
var products = [] ;
var other = arr.slice(0, i).concat(arr.slice(i + 1)) ;
produits.push(produit(autre)) ;
}
return products.join('-') ;
}

Tri par vagues
La fonctionWaveSorting(arr) prend le tableau d'entiers positifs stocké dansarr et renvoie la

chaînetrue si les nombres peuvent être arrangés selon un modèle de vague :a1 > a2 < a3 > a4 < a5 > ...,
sinon elle renvoie la chaînefalse. Par exemple, siarr est : [0, 1, 2, 4, 1, 4], alors un ordre d'onde
possible des nombres est : [2, 0, 4, 1, 4, 1]. Pour cette entrée, votre programme doit donc renvoyer la
chaîne de caractèrestrue. Le tableau d'entrée contiendra toujours au moins 2 éléments. D'autres
exemples sont donnés ci-dessous comme exemples de cas de test.
Exemples
Entrée : [0, 1, 2, 4, 1, 1, 1]
Sortie : false
Entrée : [0, 4, 22, 4, 14, 4, 2]

Sortie : true
function WaveSorting(arr) {
//En y réfléchissant, le résultat souhaité sera possible tant que nous n'aurons
pas un seul chiffre.
/plus de fois que d'autres nombres pour les briser
//obtient le nombre total de numéros

let length = arr.length ;
//obtient le nombre d'entrées pour chaque numéro

let countObj = {} ;
arr.forEach(val => {
if (!countObj[val]) {
countObj[val] = 1 ;
} else {
countObj[val]++ ;
}
});
/faire un tableau de nos résultats, afin de trouver le maximum

let countArr = [] ;
for (let key in countObj) {
countArr.push(countObj[key]) ;
}
//trouve le maximum - plus besoin d'utiliser apply() !

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

WaveSorting(readline()) ;
arr = arr.sort((a,b) => a - b).reverse() ;
newArr = [] ;
let demi-longueur = 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 {
// Recherche et prend le prochain élément plus petit que arr[i]
for (let j = 1 ; j < arr.length ; j++) {
if (arr[j] < arr[0]) {
newArr.push(arr.splice(j, 1)) ;
pause ;
}
}
}
// Vérifier si le nouvel Arr est trié par vagues

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

// trouver le nombre de l'élément le plus fréquent, qui est le mode

function mostFrequent(arr) {
arr.sort() ;
var most = 0 ;
var fréquence = 1 ;
if (arr[i] === arr[i + 1]) {
fréquence++ ;
if (frequency > most) {
le plus = la fréquence ;
}
} else {
fréquence = 1 ;
}
}
retourner le plus ;
}
// tant que l'on peut mettre un autre nombre entre le même nombre, cela
fonctionne
return mostFrequent(arr) < (arr.length / 2) ;
}

Correspondance des tableaux
La fonctionArrayMatching(strArr) doit lire le tableau de chaînes de caractères stocké

dansstrArr, qui ne contiendra que deux éléments, représentant tous deux un tableau d'entiers positifs.
Par exemple : sistrArr est ["[1, 2, 5, 6]", "[5, 2, 8, 11]"], les deux éléments de l'entrée représentent
deux tableaux d'entiers, et votre objectif pour ce défi est d'ajouter les éléments des deux tableaux aux
emplacements correspondants. Pour l'entrée de l'exemple, votre programme devrait effectuer les
additions suivantes : [(1 + 5), (2 + 2), (5 + 8), (6 + 11)], ce qui équivaut à [6, 4, 13, 17]. Votre
programme doit enfin renvoyer le tableau résultant sous la forme d'une chaîne de caractères dont chaque
élément est séparé par un trait d'union :6-4-13-17.
Si les deux tableaux n'ont pas le même nombre d'éléments, il suffit d'ajouter les éléments restants au
nouveau tableau (exemple ci-dessous). Les deux tableaux auront le format suivant : [e1, e2, e3, ...] : [e1,
e2, e3, ...] où au moins un élément existera dans chaque tableau.
Exemples
Entrée : ["[5, 2, 3]", "[2, 2, 3, 10, 6]"]

Sortie : 7-4-6-10-6
Entrée : ["[1, 2, 1]", "[2, 1, 5, 2]"]

Sortie : 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 ;
résultats.push(num1 + num2) ;
}
return results.join('-') ;
}

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

arr2 = arr2.concat(new Array(arr1.length - arr2.length).fill(0)) ;
} else if (arr1.length < arr2.length) {
arr1 = arr1.concat(new Array(arr2.length - arr1.length).fill(0)) ;
}
var sum = [] ;
for (var i = 0 ; i < arr1.length ; i++) {
sum.push(arr1[i] + arr2[i]) ;
}
return sum.join('-') ;
}
Renversement binaire
La fonctionBinaryReversal(str) prend le paramètrestr passé, qui sera un entier positif, prend sa

représentation binaire (complétée à N * 8 bits près), inverse cette chaîne de bits, et enfin renvoie la
nouvelle chaîne inversée sous forme décimale. Par exemple : sistr est "47", la version binaire de cet
entier est101111, mais nous le remplaçons par00101111. Votre programme doit inverser cette chaîne
binaire qui devient alors :11110100 et enfin renvoyer la version décimale de cette chaîne, qui est244.
Exemples
Entrée : "213"
Sortie : 171
Entrée : "4567"
Sortie : 60296
function BinaryReversal(str) {
let num = parseInt(str, 10)

.toString(2) ;
let length = num.length ;
//ajoute des zéros en tête pour que le nombre soit un nombre entier d'octets
let byteString = `${'0'.repeat(length % 8 === 0 ? 0 : 8 - length % 8)}${num}` ;
let 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) {
binaire = '0' + binaire ;
}

for (let i = 0 ; i < binary.length ; i++) {
nouvelleChaîne = binaire[i] + nouvelleChaîne ;
}
return parseInt(newString, 2) ;
}

function toBinary(str) {
result = Number(str).toString(2) ;
// le tampon à gauche avec des 0 en tête pour en faire un multiple de 8
chiffres...
if (result.length % 8 !== 0)
return new Array(8 - (result.length % 8)).fill(0).join('') + result ;
else return result ;
}
function toDecimal(str) {
return parseInt(str, 2) ;
}
//return toBinary(str) ;
var reverse = toBinary(str).split('').reverse().join('') ;
return toDecimal(reverse) ;
}

Séquence croissante la plus longue
La fonctionLongestIncreasingSequence(arr) prend le tableau d'entiers positifs stocké

dansarr et renvoie la longueur de la sous-séquence croissante la plus longue (LIS). Un LIS est un sous-
ensemble de la liste originale dans lequel les nombres sont triés par ordre croissant, du plus petit au plus
grand. La séquence ne doit pas nécessairement être contiguë ou unique, et il peut y avoir plusieurs sous-
séquences différentes. Par exemple : siarr est [4, 3, 5, 1, 6], un LIS possible est [3, 5, 6], et un autre est
[1, 6]. Pour cette entrée, votre programme devrait renvoyer3 car c'est la longueur de la plus longue sous-
séquence croissante.
Exemples
Entrée : [9, 9, 4, 2]
Sortie : 1
Entrée : [10, 22, 9, 33, 21, 50, 41, 60, 22, 68, 90]
Sortie : 7
function LongestIncreasingSequence(arr) {
let len = arr.length ;
let arrHolder = [] ;
//évaluer chaque combinaison possible de nombres

for (let i = Math.pow(2, len) ; i < Math.pow(2, len + 1) ; i++) {
//numArray est un chiffre binaire, les 0 et les 1 représentant l'inclusion ou

non des données.
//un nombre ou non dans le tableau de combinaison. Il y aura 2 ^ n
combinaisons
//pour obtenir des zéros initiaux, utilisez des nombres compris entre 2^n et
2^n+1, puis enlevez le 1 initial.
let numArray = i.toString(2).slice(1).split('') ;
//tient les nombres sélectionnés dans le tableau newSeq

newSeq = [] ;
//remplir le tableau newSeq

arr.forEach((val, ind) => {
if (numArray[ind] === '1') {
newSeq.push(val) ;
}
});
// inclure le tableau newSeq dans arrHolder

arrHolder.push(newSeq) ;
}
//supprimez tous les tableaux qui ne sont pas ascendants (utilisez la fonction
ascend() pour le déterminer)
arrHolder = arrHolder.filter(val => ascend(val)) ;
//remplacer chaque tableau passant par sa longueur

let arrLength = arrHolder.map(val => val.length) ;
//Retourne la plus grande valeur de longueur

return Math.max(...arrLength) ;
}
function ascend(inputArr) {
let arrlen = inputArr.length ;
return inputArr.every((val, ind) => {
if (ind < arrlen - 1) {
return val < inputArr[ind + 1] ;
}
retourner vrai ;
});
}

Séquence la plus longue (readline()) ;
// https://stackoverflow.com/questions/2631726/how-to-determine-the-longest-
increasing-subsequence-using-dynamic-programming
// Algorithme utilisé à partir d'ici
let lis = [arr[0]] ;

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

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

// génère n permutations vrai/faux

// ceci sera utilisé pour générer des sous-séquences - inclure cet élément ou non
function permute(n) {
si (n < 1) retourner null ;
if (n < 2) return [[true], [false]] ;
var previous = permute(n - 1) ;
var result = [] ;
for (var permutation of previous) {
result.push(permutation.concat([true])) ;
result.push(permutation.concat([false])) ;
}
}
// obtenir toutes les sous-séquences possibles
function 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]) ;
}
}
});
}
function increasing(arr) {
return arr.every(function(value, index, arr) {
var prev = (index === 0) ? 0 : arr[index - 1] ;
return prev < valeur ;
});
}
var longest = 0 ;
var subSequences = getSubSequences(arr) ;

for (var subSequence of subSequences) {
if(increasing(subSequence) && subSequence.length > longest) {
le plus long = subSequence.length ;
}
}
retourner le plus long ;
}

Paires paires
La fonctionPairesPaires(str) prend le paramètrestr qui lui est transmis et détermine si une

paire de nombres pairs adjacents existe quelque part dans la chaîne. Si une paire existe, elle renvoie la
chaînetrue, sinon elle renvoiefalse. Par exemple : sistr est "f178svg3k19k46", il y a deux nombres
pairs à la fin de la chaîne, "46", et votre programme doit donc renvoyer la chaîne true. Autre exemple :
sistr est "7r5gg812", la paire est "812" (8 et 12) et votre programme doit donc renvoyer la chaîne true.
Exemples
Entrée : "3gy41d216"
Sortie : true
Entrée : "f09r27i8e67"
Sortie : false
function EvenPairs(str) {
var regEx = /[24680]d*[24680]/
return regEx.test(str) ;

EvenPairs(readline()) ;
const DIGITS = '0123456789' ;
let numberGroups = [] ;
// Obtenir des groupes de chiffres

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 = '' ;
}
}
// Ne se préoccupe que de la longueur du groupe > 1

numberGroups = numberGroups.filter(v => v.length > 1) ;
// Boucle sur tous les "groupes"

for (let i = 0 ; i < numberGroups.length ; i++) {
// Boucles imbriquées pour chaque groupe
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) {
retourner vrai ;
}
}
}
}
retourner faux ;
}

// voir s'il y a plus de deux paires de nombres pairs

function hasEvenPairs(number) {
// correspondance non gourmande des nombres pairs
var result = number.toString().match(/\d* ?[24680]/g) ;
return (result === null) ? false : (result.length >= 2) ;
}
var numbers = str.match(/\d+/g) ;
for (var number of numbers) {
si (hasEvenPairs(number)) retournez vrai ;
}
retourner faux ;
}

Prochain palindrome
La fonctionNextPalindrome(num) prend le paramètrenum qui lui est passé et renvoie le plus grand
nombre palindromique suivant. L'entrée peut être n'importe quel nombre entier positif. Par exemple :
sinum est 24, votre programme doit renvoyer33 car c'est le plus grand nombre suivant qui est un
palindrome.
Exemples
Entrée : 2
Sortie : 3
Entrée : 180
Sortie : 181
function NextPalindrome(num) {
let count = num + 1 ;
while (true) {
numString = count.toString() ;
revString = numString.split('')
.reverse()
.join('') ;
if (revString === numString) return parseInt(numString, 10) ;
compter++ ;
}
}

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

for (let i = num + 1 ; ; i++) {
let string = i.toString() ;
if (isPalindrome(string)) {
nextPalindrome = i ;
pause ;
}
}
return nextPalindrome ;
function isPalindrome(str) {
retourner faux ;
}
}
retourner vrai ;
}
}

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

La plus grande paire
Demandez à la fonctionLargestPair(num) de prendre le paramètrenum passé et de déterminer le

plus grand nombre à deux chiffres dans le nombre entier. Par exemple : sinum est4759472, votre
programme doit renvoyer94 car c'est le plus grand nombre à deux chiffres. L'entrée contiendra toujours
au moins deux chiffres positifs.
Exemples
Entrée : 453857
Sortie : 85
Entrée : 363223311
Sortie : 63
function LargestPair(num) {
let numStr = num.toString() ;
let numArr = numStr.split('')

.map(val => parseInt(val, 10)) ;
//se débarrasser du dernier chiffre, au cas où il serait le plus grand ;

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() ;
// fenêtre coulissante de taille 2

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

Caractère non répétitif
Faire en sorte que la fonctionNonrepeatingCharacter(str) prenne le paramètrestr passé, qui

ne contiendra que des caractères alphabétiques et des espaces, et renvoie le premier caractère non
répétitif. Par exemple : sistr est "agettkgaeee", votre programme doit renvoyerk. La chaîne contiendra
toujours au moins un caractère et il y aura toujours au moins un caractère non répétitif.
Exemples
Entrée : "abcdef"
Sortie : a
Entrée : "hello world hi hey"

Sortie : 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] ;
}
}

Caractère non répétitif (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])) {
répéter = vrai ;
repeatingChars += str[i] ;
pause ;
}
}
if (!repeating) {
result = str[i] ;
pause ;
}
}
}

str = str.replace(/\s+/g, '') ;
var counts = {} ;
// compter chaque lettre

for (var i = 0 ; i < str.length ; i++) {
if (str[i] in counts) {
count[str[i]]++ ;
} else {
counts[str[i]] = 1 ;
}
}
// renvoie la première lettre avec un compte de 1

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

Deux Sommes
Demandez à la fonctionTwoSum(arr) de prendre le tableau d'entiers stocké dansarr, et de déterminer

si deux nombres quelconques (à l'exclusion du premier élément) du tableau peuvent s'additionner
jusqu'au premier élément du tableau. Par exemple : siarr est [7, 3, 5, 2, -4, 8, 11], il existe en fait deux
paires dont la somme est égale au nombre 7 : [5, 2] et [-4, 11]. Votre programme doit renvoyer toutes les
paires, les nombres étant séparés par une virgule, dans l'ordre où le premier nombre apparaît dans le
tableau. Les paires doivent être séparées par un espace. Ainsi, pour l'exemple ci-dessus, votre
programme renverrait :5,2 -4,11
S'il n'y a pas deux nombres dont la somme est égale au premier élément du tableau, le programme
renverrait-1.
Exemples
Entrée : [17, 4, 5, 6, 10, 11, 4, -3, -5, 3, 15, 2, 7]

Sortie : 6,11 10,7 15,2
Entrée : [7, 6, 4, 1, 7, -2, 3, 12]

Sortie : 6,1 4,3
function 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] === target) {
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 = [] ;
// Sans reverse() ici, les résultats finaux seront dans l'ordre
// le deuxième nombre apparaît dans le tableau, mais nous voulons qu'il soit
// ordonnés par le premier chiffre.
arr.reverse() ;
arr.forEach(item => {
const compliment = réponse - item ;
if (history.has(compliment)) {
matches.push([item, compliment]) ;
} else {
history.add(item) ;
}
});
// Les correspondances ont été placées dans le tableau dans l'ordre inverse, donc
// nous devons maintenant les inverser.
matches.reverse() ;
return (matches.length === 0) ? -1 : matches.map(m => m.join(',')).join(' ') ;

}

// trouver les paires dont la somme est égale au nombre donné

function findPairs(arr, sum) {
var paires = [] ;
for (var j = i + 1 ; j < arr.length ; j++) {
si (arr[i] + arr[j] === sum)
paires.push([arr[i], arr[j]]) ;
}
}
retourner les paires ;
}
var paires = [] ;
var sum = arr[0] ;
var rest = arr.slice(1) ;
paires = findPairs(rest, sum) ;
return (pairs.length === 0) ? -1 : pairs.map(pair => pair.join(',')).join(' ') ;

}

Deux par bit
La fonctionBitwiseTwo(strArr) doit prendre le tableau de chaînes stocké dansstrArr, qui ne

contiendra que deux chaînes de même longueur représentant des nombres binaires, et renvoyer une
chaîne binaire finale qui a effectué l'opération bitwise AND sur les deux chaînes. Une opération ET
binaire place un 1 dans la nouvelle chaîne lorsqu'il y a un 1 aux deux endroits dans les chaînes binaires,
sinon elle place un 0 à cet endroit. Par exemple : sistrArr est ["10111", "01101"], votre programme
doit renvoyer la chaîne "00101"
Exemples
Entrée : ["100", "000"]

Sortie : 000
Entrée : ["10100", "11100"]

Sortie : 10100
function 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' ;
continuer ;
}
else {
resStr += '0' ;
continuer ;
}
}
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' ;
}
}
}

Comptage des jeux de puissance
Demandez à la fonctionPowerSetCount(arr) de prendre le tableau d'entiers stocké dansarr et de

renvoyer la longueur de l'ensemble de puissance (le nombre de tous les ensembles possibles) qui peut
être généré. Par exemple : siarr est [1, 2, 3], les ensembles suivants forment l'ensemble de puissance :
[]
[1]
[2]
[3]
[1, 2]
[1, 3]
[2, 3]
[1, 2, 3]
Vous pouvez voir ci-dessus que tous les ensembles possibles, ainsi que l'ensemble vide, sont générés.
Par conséquent, pour cette entrée, votre programme doit renvoyer8.
Exemples
Entrée : [1, 2, 3, 4]
Sortie : 16
Entrée : [5, 6]
Sortie : 4
function PowerSetCount(arr) {
return Math.pow(2, len) ;
}
PowerSetCount(readline()) ;
return Math.pow(2, arr.length) ;
}

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

Chiffres du produit
Demandez à la fonctionProductDigits(num) de prendre le paramètrenum passé, qui sera un

nombre entier positif, et de déterminer le plus petit nombre de chiffres à multiplier pour obtenir ce
nombre. Par exemple : sinum est24, vous pouvez multiplier 8 par 3, ce qui donne 24. Votre programme
devrait donc renvoyer2, car il n'y a que 2 chiffres nécessaires au total. Autre exemple : sinum est 90,
vous pouvez multiplier 10 * 9. Dans ce cas, votre programme doit sortir3 car vous ne pouvez pas
atteindre 90 sans utiliser un total de 3 chiffres dans votre multiplication.
Exemples
Entrée : 6
Sortie : 2
Entrée : 23
Sortie : 3
function 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) {
valeur = longueur totale ;
}
}
}
valeur de retour ;
}

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

let left = pf.slice(0, divider) ;
let right = pf.slice(divider, pf.length) ;
let leftProduct = left.reduce((product, value) => product *= value, 1) ;

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

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

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

function getDivisors(num) {
var divisors = [1] ;
for (var i = 2 ; i <= num / 2 ; i++) {
if (num % i === 0) {
diviseurs.push(i) ;
}
}
diviseurs.push(num) ;
return divisors ;
}
var divisors = getDivisors(num) ;
var paires = [] ;
for (var i = 0 ; i < divisors.length / 2 ; i++) {

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

}

Créateur de palindromes
La fonctionPalindromeCreator(str) prend le paramètrestr qui lui est passé et détermine s'il est
possible de créer une chaîne palindromique d'unelongueur minimale de 3 caractères en supprimant 1
ou 2 caractères. Par exemple : sistr est "abjchba", vous pouvez supprimer les caractèresjc pour obtenir
"abhba", qui est un palindrome. Pour cet exemple, votre programme doit renvoyer les deux caractères
qui ont été supprimés sans délimiteur et dans l'ordre où ils apparaissent dans la chaîne, donc jc. Si 1 ou 2
caractères ne peuvent pas être supprimés pour produire un palindrome, la chaîne de caractères
"impossible" est renvoyée. Si la chaîne d'entrée est déjà un palindrome, votre programme doit renvoyer
la chaînepalindrome.
L'entrée ne contiendra que des caractères alphabétiques minuscules. Votre programme doit toujours
tenter de créer la sous-chaîne palindromique la plus longue en supprimant 1 ou 2 caractères (voir le
deuxième exemple de test). Les 2 caractères que vous supprimez ne doivent pas nécessairement être
adjacents dans la chaîne.
Exemples
Entrée : "mmop"
Sortie : impossible
Entrée : "kjjjhjj"
Sortie : k
function PalindromeCreator(str) {
//test pour voir si c'est déjà un palindrome
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('un') ;
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('') ;
}
}
}
renvoie "pas possible" ;
}
//----------------helpers---------------------------
let newStr = str.split('').reverse().join('') ;
if (newStr === str) {
retourner vrai ;
}
retourner faux ;
}

PalindromeCreator(readline()) ;
if (isPalindrome(str)) {
return 'palindrome' ;
}
// Créer des combos

let combos = [] ;
for (let i = 0, max = Math.pow(2, str.length) ; i < max ; i++) {
let combo = i.toString(2) ;
// Filtre pour zéro, un ou deux 1 (1 représente le retrait)

laissez count = 0 ;
for (let j = 0 ; j < combo.length ; j++) {
if (combo[j] === '1') {
compter++ ;
}
}
// Trop grand, ignorer et passer à l'essai suivant !
if (count > 2) {
continuer ;
}
// Bonne combinaison de coussinets

while (combo.length < str.length) {
combo = '0' + combo ;
}
combos.push(combo) ;
}
let palindromeCombos = [] ;
// Essayer des combos de suppression

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(combos[i]) ;
}
}
if (palindromeCombos.length === 0) {
}
// Trier de manière à ce que les deux premières lettres trouvées soient renvoyées
en premier pour le cas où
// il y a plusieurs valeurs
palindromeCombos.sort(function(a,b){
return parseInt(a,2) < parseInt(b,2) ;
});
// Recherche et renvoie l'enlèvement le plus court <=> le palindrome le plus long

let shortestCount = null ;
let shortestCombo = '' ;
palindromeCombos.forEach(function(combo){
laissez count = 0 ;
for (let i = 0 ; i < combo.length ; i++) {
if (combo[i] === '1') {
compter++ ;
}
}
if (shortestCount === null || count < shortestCount) {
le plus court = count ;
shortestCombo = combo ;
}
});
let result = '' ;

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

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

// supprimer un caractère à la position i
var newStr = str.slice(0, i).concat(str.slice(i + 1)) ;
if (isPalindrome(newStr)) {
return str[i] ;
}
}

// supprimer deux caractères aux positions i et j, où (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] ;
}
}
}
retourner "pas possible" ;
}

Chiffres romains de base
La fonctionBasicRomanNumerals(str) doit lirestr qui sera une chaîne de chiffres romains. Les
chiffres utilisés sont :I pour 1,V pour 5,X pour 10,L pour 50,C pour 100,D pour 500 etM pour 1000. En
chiffres romains, pour créer un nombre comme 11, il suffit d'ajouter un 1 après le 10, ce qui donne XI.
Mais pour créer un nombre comme 19, vous utilisez lanotation par soustraction qui consiste à ajouter un
I devant un X ou un V (ou à ajouter un X devant un L ou un C). Ainsi, 19 en chiffres romains est XIX.
Le but de votre programme est de retourner l'équivalent décimal du chiffre romain donné. Par exemple :
sistr est "XXIV", votre programme doit renvoyer24
Exemples
Entrée : "IV"
Sortie : 4
Entrée : "XLVI"
Sortie : 46
function 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()) ;
/*
Symbole I V X L C D M
Valeur 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(symbole) {
cas '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 ;
cas 'V' :
sum += ROMAN_V ;
pause ;
cas '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 ;
cas 'L' :
sum += ROMAN_L ;
pause ;
cas '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 ;
cas 'D' :
sum += ROMAN_D ;
pause ;
cas 'M' :
sum += ROMAN_M ;
pause ;
par défaut :
// Caractère ou espace illégal
pause ;
}
}
}

var decimals = [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++) {

// continue à fonctionner tant qu'il y a une correspondance au début
while (str.indexOf(romans[i]) === 0) {
output += decimals[i] ;
str = str.replace(romans[i], '') ;
}
}
retour de la sortie ;
}

Distribution de denrées alimentaires
Demandez à la fonctionFoodDistribution(arr) de lire le tableau de nombres stocké dansarr, qui

représentera le niveau de faim de différentes personnes sur une échelle de 0 à 5 (0 signifiant pas du tout
faim, 5 signifiant très faim). Vous aurez également N sandwichs à distribuer, compris entre 1 et 20. Le
format du tableau sera [N, h1, h2, h3, ...] où N représente le nombre de sandwichs que vous avez et le
reste du tableau représentera les niveaux de faim de différentes personnes. Votre objectif est de
minimiser la différence de faim entre chaque paire de personnes dans le tableau en utilisant les
sandwichs dont vous disposez.
Par exemple : siarr est [5, 3, 1, 2, 1], cela signifie que vous avez 5 sandwichs à distribuer. Vous pouvez
les distribuer aux personnes dans l'ordre suivant : 2, 0, 1, 0. En donnant ces sandwichs aux personnes,
leur niveau de faim devient maintenant : [1, 1, 1, 1]. La différence entre chaque paire de personnes est
maintenant de 0, le total est également de 0, votre programme doit donc renvoyer 0. Remarque : il n'est
pas forcément nécessaire de distribuer la totalité, ni même une partie, de vos sandwiches pour obtenir
une différence minimale.
Autre exemple : siarr est [4, 5, 2, 3, 1, 0], vous pouvez distribuer les sandwichs dans l'ordre suivant :
[3, 0, 1, 0, 0], ce qui fait que tous les niveaux de faim sont les suivants : [2, 2, 2, 1, 0] : [2, 2, 2, 1, 0].
Les différences entre chaque paire de personnes sont maintenant : 0, 0, 1, 1 et votre programme devrait
donc renvoyer la différence finale minimisée de2.
Exemples
Entrée : [5, 2, 3, 4, 5]
Sortie : 1
Entrée : [3, 2, 1, 0, 4, 1, 0]
Sortie : 4
function FoodDistribution(arr) {
let treats = arr.shift() ;
let myArray = arr.slice(0) ;
let arrMin = arr.sort((val1, val2) => val2 - val1).pop()
let len = myArray.length ;
//vérifie si nous avons assez de friandises pour que tout le monde atteigne le
meilleur niveau actuel
let testCount = myArray.reduce((val1, val2) => {
retour val1 + val2 - arrMin ;
}, 0);
if (testCount <= treats) {
retour 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 <= treats) {
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) ;
}
}
}
laissez count = 0 ;
for (let i = 0, len = valQuantArr.length ; i < len - 1 ; i++) {
count += Math.abs(valQuantArr[i].value - valQuantArr[i + 1].value) ;
}
}
//-----------------helpers-----------------------
flattenMid = (arr, treats, q) => {
let index = 0 ;
while (treats > 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 -- ;
les friandises -= q ;
}
}
return [objectify(arr), treats] ;
}
//transforme un tableau en un objet dont la valeur est égale au nombre, et l'élément

//quantitatif étant le nombre de fois qu'il se produit dans une rangée
objectify = (array) => {
//s'il s'agit d'un tableau de nombres
if (typeof array[0] === 'number') {
let target = [] ;
let counter = 0 ;
for (let i = 0, len = array.length ; i < len ; i++) {
let val = array[i] ;
contre++ ;
if (array[i] === array[i + 1]) {
continuer ;
} else {
target.push({
valeur : array[i],
quant : compteur
});
compteur = 0 ;
}
}
retourner la cible ;
} else {
//s'il s'agit d'un tableau d'objets, le transformer en tableau de
nombres, et
//puis l'exécuter à travers la méthode d'objectivation
let targetArray = [] ;
array.forEach (val => {
while (val.quant) {
targetArray.push (val.value) ;
val.quant-- ;
}
});
return objectify(targetArray) ;
}
};

FoodDistribution(readline()) ;
let sandwiches = parseInt(arr.shift()) ;
// Générer des combos, limitation de cette méthode, 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) ;
// Somme des chiffres (sandwiches) dans le combo

let comboSum = parseInt(combo.split('').reduce((accumulator, currentValue) =>
accumulator + parseInt(currentValue, sandwiches+1), 0)) ;
// Trop de sandwichs
if (comboSum > sandwiches) {
continuer ;
}
// On peut également ajouter une vérification ici pour supprimer les

sandwiches qui mettraient la faim < 0
// Pad combos of good combos

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

}
}
// Trouver la différence de faim la plus faible

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

var N = arr[0] ;
var hungerLevels = arr.slice(1) ;
while (N > 0) {
var maxDifference = 0 ;
// l'index pour le sandwich suivant
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 = différence ;
mostNeeded = (hungerLevels[i + 1] > hungerLevels[i]) ? (i + 1) : i ;
}
}
// Maintenant, nous savons qui a tant besoin de ce sandwich, et nous le
distribuons.
if (mostNeeded === -1) {
// les différences adjacentes sont toutes des 0, alors arrêtez de donner
les sandwiches
retour 0 ;
} else {
hungerLevels[mostNeeded] -= 1 ;
N-- ;
}
}
// calculer la somme des différences adjacentes

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

Trois Sommes
Demandez à la fonctionThreeSum(arr) de prendre le tableau d'entiers stocké dansarr, et de

déterminer si trois nombres distincts (à l'exception du premier élément) du tableau peuvent s'additionner
jusqu'au premier élément du tableau. Par exemple : siarr est [8, 2, 1, 4, 10, 5, -1, -1], il existe en fait
trois ensembles de triplets dont la somme est égale à 8 : [2, 1, 5], [4, 5, -1] et [10, -1, -1]. Votre
programme doit renvoyer la chaînetrue si la somme de 3 éléments distincts est égale au premier élément,
sinon votre programme doit renvoyer la chaînefalse. Le tableau d'entrée contiendra toujours au moins 4
éléments.
Exemples
Entrée : [10, 2, 3, 1, 5, 3, 1, 4, -4, -3, -2]

Sortie : true
Entrée : [12, 3, 1, -5, -4, 7]

Sortie : false
function 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++) {
if (arr[i] + arr[j] + arr[k] === target) {
retourner "true" ;
}
}
}
}
retourner "false"
}

ThreeSum(readline()) ;
let answer = parseInt(arr.shift()) ;
// Générer des combos

let combos = [] ;
for (let i = 0, max = Math.pow(2, arr.length) ; i < max ; i++) {
let digitsSum = parseInt(combo.split('').reduce((accumulator,value) =>

accumulator + parseInt(value), 0)) ;
if (digitsSum !== 3) {
continuer ;
}
// Remplir les chiffres

while (combo.length < arr.length) {
}
}
// Tester les combos

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 numbers = 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 (nombres[i] + nombres[j] + nombres[k] === sum) {
retourner 'true' ;
}
}
}
}
retourner "false" ;
}

Chemin correct
La fonctionCorrectPath(str) doit lire le paramètrestr passé, qui représentera les mouvements

effectués dans une grille de 5 x 5 cellules en partant de la position supérieure gauche. Les caractères de
la chaîne d'entrée seront entièrement composés de :r, l, u, d, ? Chacun des caractères représente la
direction à prendre dans la grille, par exemple : r = droite, l = gauche, u = haut, d = bas. Votre objectif
est de déterminer les caractères que doivent avoir les points d'interrogation pour qu'un chemin soit créé
et aille du haut à gauche de la grille jusqu'en bas à droite sans toucher les cellules déjà parcourues dans
la grille.
Par exemple : sistr est "r?d?drdd", votre programme doit produire la chaîne correcte finale qui
permettra de former un chemin depuis le coin supérieur gauche d'une grille 5x5 jusqu'au coin inférieur
droit. Pour cette entrée, votre programme devrait donc renvoyer la chaînerrdrdrdrdd. Il n'y aura jamais
qu'un seul chemin correct et il y aura toujours au moins un point d'interrogation dans la chaîne d'entrée.
Exemples
Entrée : "???rrurdr ?"

Sortie : dddrrurdrd
Entrée : "drdr??rrddd ?"

Sortie : drdruurrdddd
function CorrectPath(str) {
//Créer un tableau pour contenir les positions des points d'interrogation
let blankArray = [] ;
//inscrire la position des points d'interrogation dans le tableau
str.split('').forEach((val, ind) => {
if (val === '?') {
blankArray.push(ind) ;
}
});
let num = blankArray.length ;
//nous allons essayer chaque possibilité jusqu'à ce que nous en trouvions une
qui fonctionne, ce qui représente 4^num permutations
let total = Math.pow(4, num) ;
for (let i = 0 ; i < total ; i++) {

//se pencher sur chaque permutation, en créant d'abord un nombre
représentatif, puis en traçant le chemin, et enfin en le testant.
let numString = (i + total).toString(4).slice(1) ;
let currentPath = createPath(str, blankArray, numString) ;
if (isPathGood(currentPath)) {
return currentPath ;
}
}
}
isPathGood = (str) => {

//Créer un tableau vide
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++) {

/marquer notre place actuelle comme visitée
testArray[currentLoc[0]][currentLoc[1]] = 1 ;
//modifie la position en fonction de la lettre suivante
let newLoc = currentLoc.slice(0) ;
switch (str[i]) {
cas 'u' :
newLoc[0]-- ;
pause ;
cas 'd' :
newLoc[0]++ ;
pause ;
cas 'r' :
newLoc[1]++ ;
pause ;
cas 'l' :
newLoc[1]-- ;
pause ;
}
//Quitter si l'on est sorti de la carte
if (newLoc.includes (-1) || newLoc.includes (5)) {
retourner faux ;
}
//quitter si l'on se trouve sur un espace déjà visité
if (testArray[newLoc[0]][newLoc[1]] === 1) {
retourner faux ;
}
//Retourne vrai si nous avons atteint la case cible lors de notre
dernier passage
if (newLoc[0] === 4 && newLoc[1] === 4 && i === len - 1) {
retourner vrai ;
}
//mettre à jour notre position pour la prochaine boucle ;
currentLoc = newLoc ;
}
retourner faux ;
};
createPath = (str, blanks, num) => {

let moveArray = ['r', 'l', 'u', 'd'] ;
strArr = str.split('') ;
blanks.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) ;
// Générer des combos, 0-r, 1-d, 2-l, 3-u

let combos = [] ;
for (let i = 0, max = Math.pow(4, numQmarks) ; i < max ; i++) {
// Tampon
while (combo.length < numQmarks) {
}
}
let goodPaths = [] ;
// Essayer les chemins

let comboArray = combo.split('') ;
let tryPath = '' ;
if (str[i] === '?') {
let direction = comboArray.shift() ;
commutateur (direction) {
cas '0' : // droite
tryPath += 'r' ;
pause ;
case '1' : // vers le bas
tryPath += 'd' ;
pause ;
case '2' : // gauche
tryPath += 'l' ;
pause ;
cas '3' : // up
tryPath += 'u' ;
pause ;
par défaut :
// Ne devrait jamais se produire
pause ;
}
} else {
tryPath += str[i] ;
}
}
if (pathGood(tryPath)) {
goodPaths.push(tryPath) ;
}
});
// selon la spécification, goodPaths ne devrait jamais être === 1, mais ce code

peut gérer d'autres cas réels.
return goodPaths[0] ;
// Confirmer/infirmer le bon chemin (avec les Qmarks remplis)

function pathGood(path) {
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]
] ; // but 4,4
for (let i = 0 ; i < path.length ; i++) {

switch (path[i]) {
cas 'r' :
startX++ ;
pause ;
cas 'd' :
startY++ ;
pause ;
cas 'l' :
startX-- ;
pause ;
cas 'u' :
startY-- ;
pause ;
par défaut :
// Ne devrait jamais se produire
pause ;
if (startX < 0 || startX > 4 || startY < 0 || startY > 4 || grid[startY]

[startX] === 1) {
// déjà parcouru ou hors limites
retourner faux ;
}
grid[startY][startX] = 1 ;
}
return (startX === 4 && startY === 4) ? true : false ;
}
}

// vérifier si les directions données peuvent atteindre la ligne d'arrivée

// sans toucher aux positions visitées précédemment
function canNavigate(str) {
var position = [0, 0] ;
var visited = {} ;
switch(str[i]) {
cas 'u' :
position[0]-- ;
si (position[0] < 0) retournez faux ;
pause ;
cas 'd' :
position[0]++ ;
si (position[0] > 4) retournez faux ;
pause ;
cas 'l' :
position[1]-- ;
si (position[1] < 0) retournez faux ;
pause ;
cas 'r' :
position[1]++ ;
if (position[1] > 4) return false ;
pause ;
par défaut :
pause ;
}
if (visited[position[0] + '-' + position[1]]) {
// déjà visité auparavant
retourner faux ;
} else {
// marquer comme visité
visité[position[0] + '-' + position[1]] = i ;
}
}
return (position[0] === 4 && position[1] === 4) ;

}
function findMissingChars(str) {
// d'abord, générer tous les cas possibles : remplacer ? par des directions
var permutations = [''] ;
if (str[i] === '?') {
var newPermutations = [] ;
permutations.forEach(function(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]) ;
}
}
// ne filtrent maintenant que celles qui sont valides

// nous avons besoin d'un résultat net de 4 descentes et de 4 droits
return permutations.filter(function(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 ;
}
}
}

Équilibre des échelles
La fonctionScaleBalancing(strArr) doit lirestrArr qui contiendra deux éléments, le premier

étant les deux poids entiers positifs d'une balance (côté gauche et côté droit) et le second étant une liste
de poids disponibles sous forme d'entiers positifs. Votre objectif est de déterminer si vous pouvez
équilibrer la balance en utilisant le plus petit nombre de poids de la liste, mais en n'utilisant au maximum
que 2 poids. Par exemple : sistrArr est ["[5, 9]", "[1, 2, 6, 7]"], cela signifie qu'il existe une balance
dont le poids est de 5 à gauche et de 9 à droite. Il est en effet possible d'équilibrer cette balance en
ajoutant un 6 au côté gauche de la liste des poids et en ajoutant un 2 au côté droit. Les deux balances
sont maintenant égales à 11 et sont parfaitement équilibrées. Votre programme doit renvoyer une chaîne
séparée par des virgules des poids qui ont été utilisés dans la liste par ordre croissant. Pour cet exemple,
votre programme doit renvoyer la chaîne2,6
Il n'y aura jamais qu'une seule solution et la liste des poids disponibles ne sera pas vide. Il est également
possible d'ajouter deux poids d'un seul côté de la balance pour l'équilibrer. S'il n'est pas possible
d'équilibrer la balance, votre programme doit renvoyer la chaîne de caractères not possible.
Exemples
Entrée : ["[3, 4]", "[1, 2, 7, 7]"]

Sortie : 1
Entrée : ["[13, 4]", "[1, 2, 3, 6, 14]"]

Sortie : 3,6
function ScaleBalancing(strArr) {
//convertir le tableau en quelque chose de plus exploitable
let newArr = strArr.map(val => {
return val.replace(/[\N-[\N]/g, "").split(',').map(val2 => {
return parseInt(val2, 10) ;
}).sort((a, b) => {
retourner a - b ;
});
});
let diff = newArr[0][1] - newArr[0][0] ;

let weights = newArr[1] ;
//faire le test de la solution à poids unique

if (weights.includes(diff)) {
return diff.toString() ;
}
//faire le test des deux poids, un côté
let weight1 = weights.find((val, ind) => {
let newWeights = weights.slice(0) ;
newWeights.splice(ind, 1) ;
return newWeights.includes (diff - val)
});
if (weight1) {
return `${poids1},${diff - poids1}`
}
//faire les deux poids, les différents côtés, le test
weight1 = weights.find(val => {
return weights.includes(diff + val) ;
});
if (weight1) {
return `${poids1},${diff + poids1}`
}
//si rien n'est encore retourné . . .
retournera `not possible` ;

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)) ;
/*
Générer toutes les combinaisons possibles de poids ET les permutations
gauche/droite - 3^n temps
0 - Poids non utilisé
1 - Poids sur le côté gauche
2 - Poids sur le côté droit
*/
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) ;
// Trop de poids, écarter ce combo

if (numWeights > 2) {
continuer ;
}
// Tampon
while (combo.length < weights.length) {
}
}
// console.log(combos) ;
// Tester les combos
let goodCombos = [] ;
let left = objets[0] ;
let right = objets[1] ;

if (combo[i] === '1') { // Gauche
left += weights[i] ;
}
if (combo[i] === '2') { // Droite
right += weights[i] ;
}
}
if (left === right) {

goodCombos.push(combo) ;
}
});
if (goodCombos.length === 0) {
}
// Trier d'abord par le nombre de poids physiques utilisés, puis par le poids
total s'il y a plusieurs ensembles.
goodCombos.sort(function(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) {

retourner -1 ;
}
if (aCount > bCount) {
retour 1 ;
}
// aCount === bCount -> doit vérifier les poids et utiliser le poids total le
plus faible
let aTotal = 0 ;
let bTotal = 0 ;
for (let i = 0 ; i < a.length ; i++) {
if (a[i] !== '0') {
aTotal += poids[i] ;
}
if (b[i] !== '0') {
bTotal += poids[i] ;
}
}
retourner aTotal - bTotal ;
});
//console.log(goodCombos) ;
let theCombo = goodCombos[0] ;
let finalWeights = [] ;
theCombo.split('').map(function(value, index) {
if (value !== '0') {
finalWeights.push(weights[index]) ;
}
});
return finalWeights.sort((a,b) => a-b).join(',') ;

}

var weights = strArr[1].match(/\d+/g).map(Number) ;
var weightsOnScale = strArr[0].match(/\d+/g).map(Number) ;
var leftWeight = weightsOnScale[0] ;
var rightWeight = weightsOnScale[1] ;
// n'essayer qu'un seul poids

for (var i = 0 ; i < weights.length ; i++) {
if (leftWeight < rightWeight) {
si (poids gauche + poids[i] === poids droit)
return weights[i] ;
} else {
si (poids gauche === poids droit + poids[i])
return weights[i] ;
}
}
// essayez maintenant deux poids

for (var i = 0 ; i < weights.length ; i++) {
for (var j = i + 1 ; j < weights.length ; j++) {
// en ajouter un de chaque côté
if (leftWeight + weights[i] === rightWeight + weights[j]) {
return weights[i] + ',' + weights[j] ;
else if (leftWeight + weights[j] === rightWeight + weights[i]) {
}
// en ajouter deux plus légères
if (leftWeight < rightWeight) {
if (leftWeight + weights[i] + weights[j] === rightWeight) {
}
} else {
if (leftWeight === rightWeight + weights[i] + weights[j]) {
}
}
}
}
// pas de solution
}

Trois chiffres
Demandez à la fonctionThreeNumbers(str) de prendre le paramètrestr qui lui est transmis et de

déterminer si chaque mot de la chaîne contient exactement trois nombres entiers uniques à un chiffre.
Les nombres entiers peuvent apparaître n'importe où dans le mot, mais ils ne peuvent pas être tous
adjacents les uns aux autres. Si chaque mot contient exactement 3 entiers uniques, alors la chaîne true est
renvoyée, sinon la chaînefalse est renvoyée. Par exemple : sila chaîne est "2hell6o3 wor6l7d2", votre
programme doit renvoyer "true", mais si la chaîne est "hell268o w6or2l4d", votre programme doit
renvoyer "false" parce que tous les entiers sont adjacents les uns aux autres dans le premier mot.
Exemples
Entrée : "2a3b5 w1o2rl3d g1gg92"

Sortie : true
Entrée : "21aa3a ggg4g4g6ggg"

Sortie : false
function ThreeNumbers(str) {
const DIGITS = '0123456789' ;
let words = str.split(' ') ;
let result = null ;
words.forEach(function(word){
let nombres = 0 ;
let threeAdjacent = false ;
let usedDigits = '' ;
for (let i = 0 ; i < word.length ; i++) {
// Vérifier si des chiffres ont été utilisés
if (usedDigits.includes(word[i])) {
// utilisé ! échec
résultat = faux ;
}
if (DIGITS.includes(word[i])) {
numéros++ ;
usedDigits += word[i] ;
if (numbers === 3) {
if (DIGITS.includes(word[i-1]) && DIGITS.includes(word[i-2])) {
threeAdjacent = true ;
}
}
}
// Vérifier la présence de 3 chiffres adjacents précédents
}
if (numbers === 3 && !threeAdjacent) {

result = (result === null) ? true : result && true ;
} else {
résultat = faux ;
}
});
}

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

// vérifier que chaque mot contient exactement 3 chiffres
chiffres = nombres.join('') ;
if (digits.length !== 3)
retourner faux ;
// il n'est pas permis d'avoir 3 chiffres à la suite
if (numbers.length !== numbers.filter(number => number.length < 3).length)
retourner faux ;
// il n'y a pas de doublon dans ces 3 nombres
si ((chiffres[0] === chiffres[1]) ||
(chiffres[1] === chiffres[2]) ||
(chiffres[2] === chiffres[0]))
retourner faux ;
}
retourner vrai ;
}

let array = str.split(' ') ;

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

Recherche dans l'alphabet
La fonctionAlphabetSearching(str) prend le paramètrestr qui lui est passé et renvoie la

chaînetrue si toutes les lettres de l'alphabet anglais existent dans la chaîne, sinon elle renvoie la
chaînefalse. Par exemple : sistr est "zacxyjbbkfgtbhdaielqrm45pnsowtuv", votre programme doit
renvoyer la chaînetrue car tous les caractères de l'alphabet existent dans cette chaîne, même si certains
caractères apparaissent plus d'une fois.
Exemples
Entrée : "abcdefghijklmnopqrstuvwxyyyy"
Sortie : false
Entrée : "abc123456kmo"
Sortie : false
function AlphabetSearching(str) {
str = str.toLowerCase() ;
for (let i = 97 ; i < 97 + 26 ; i++) {
let char = String.fromCharCode(i) ;
if (!str.includes(char)) {
retourner faux ;
}
}
retourner vrai ;
}

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

if (!str.includes(LOWER_LETTERS[i])) {
retourner faux ;
}
}
retourner vrai ;
}
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 ;
}

Différence de temps
Demandez à la fonctionTimeDifference(strArr) de lire le tableau de chaînes de caractères stocké

dansstrArr, qui sera une liste non triée d'heures dans un format de douze heures, comme suit :
HH:MM(am/pm). Votre objectif est de déterminer la plus petite différence en minutes entre deux des
temps de la liste. Par exemple : sistrArr est ["2:10pm", "1:30pm", "10:30am", "4:42pm"], votre
programme devrait renvoyer40 car la plus petite différence se situe entre 1:30pm et 2:10pm avec une
différence de 40 minutes. Le tableau d'entrée contiendra toujours au moins deux éléments et tous les
éléments seront au bon format et uniques.
Exemples
Entrée : ["1:10pm", "4:40am", "5:00pm"]

Sortie : 230
Entrée : ["10:00am", "11:45pm", "5:00am", "12:01am"]

Sortie : 16
function TimeDifference(strArr) {
//times contiendra nos différences de temps
let times = [] ;
let newStrArr = strArr.map (val => {
let matches = val.match(/^(\d+) :(\d+)([ap]m)$/) ;
let hours = parseInt(matches[1], 10) ;
let minutes = parseInt(matches[2], 10) ;
let half = matches[3] ;
if (half === 'am' && hours === 12) {
heures = 0 ;
}
if (half === 'pm' && hours !== 12) {
heures += 12 ;
}
retour (heures * 60 + minutes) ;
})
.sort((a, b) => { return a - b}) ;
//tricky - le deuxième exemple montre qu'il faut tenir compte de l'heure la plus
proche à la fois le jour 0 et le jour 1.
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, times) ;
}

TimeDifference(readline()) ;
let timesInSeconds = [] ;
strArr.forEach(function(strTime){
let pair = strTime.split(':') ;
let hours = (pair[1][2] === 'a') ? parseInt(pair[0]) % 12 : parseInt(pair[0])
% 12 + 12 ;
let seconds = parseInt(pair[1].substr(0,2)) ;
let totalSeconds = heures * 60 + secondes ;
timesInSeconds.push(totalSeconds) ;
});
// Itère sur 2^n combos

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) {
// Tampon
while (combo.length < timesInSeconds.length) {
}
// Interroger chaque combinaison spécifique et la tester

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(pair[0] - pair[1]) ;

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

plus petite différence = diff ;
}
}
}
return smallestDifference ;
}

let array = strArr.map(value => {
let matches = value.match(/^(\d+) :(\d+)([ap]m)$/) ;
let h = parseInt(matches[1], 10) ;
let m = parseInt(matches[2], 10) ;
if (matches[3] === 'am' && h === 12) {
h = 0 ;
else if (matches[3] === 'pm' && h !== 12) {
h += 12 ;
}
retour (60 * h + m) ;
}).sort(function(a, b) {
retourner 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(...times) ;
}
Rangée de triangles
Demandez à la fonctionTriangleRow(num) de prendrenum, qui sera un entier positif représentant

une rangée du triangle de Pascal. Le triangle de Pascal commence par un [1] à la 0e ligne du triangle. La
première ligne est donc [1, 1] et la deuxième ligne est [1, 2, 1]. La ligne suivante commence par 1 et se
termine par 1, et l'intérieur de la ligne est déterminé en ajoutant les k-1 et kème éléments de la ligne
précédente. La rangée suivante du triangle serait alors [1, 3, 3, 1], et ainsi de suite. L'entrée sera un
nombre entier positif et votre but est de retourner la somme de cette ligne. Par exemple : si num est 4,
votre programme doit renvoyer la somme de 1 + 4 + 6 + 4 + 1, soit 16.
Exemples
Entrée : 1
Sortie : 2
Entrée : 2
Sortie : 4
function 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) ;
continuer ;
}
let delta = (i < triangle[row-1].length) ? triangle[row-1][i] : 0 ;
rowArr.push(triangle[row-1][i-1] + delta) ;
}
triangle.push(rowArr) ;
}
return triangle[num].reduce((a,v) => a + v,0) ;
}
// obtenir la nième ligne et la kième colonne du triangle de Pascal

function pascalTriangle(n, k) {
si (n === 0) retourner 1 ;
si (k === 0 || k === n) retour 1 ;
return pascalTriangle(n - 1, k - 1) + pascalTriangle(n - 1, k) ;
}
// la réponse facile - la somme est toujours égale à n^2
//retourne num * num ;
// la manière forte
var rowSum = 0 ;
for (k = 0 ; k <= num ; k++) {
result = pascalTriangle(num, k) ;
rowSum += result ;
}
return rowSum ;
}

Carré vocalique
La fonctionVowelSquare(strArr) prend le paramètrestrArr qui lui est transmis, à savoir une

matrice 2D de taille arbitraire remplie de lettres de l'alphabet, et détermine s'il existe dans la matrice un
carré de 2 x 2 composé entièrement de voyelles.
Par exemple :strArr est ["abcd", "eikr", "oufj"] alors cette matrice ressemble à ce qui suit : ab c d ei k r o
u f jDans cette matrice, il y a un carré 2x2 de voyelles commençant à la deuxième ligne et à la première
colonne, à savoir ei, ou. Si un carré de 2x2 voyelles est trouvé, votre programme doit renvoyer la
position supérieure gauche (ligne-colonne) du carré, donc pour cet exemple, votre programme doit
renvoyer1-0. S'il n'existe pas de carré 2x2 de voyelles, la chaînenon trouvée est renvoyée. S'il y a
plusieurs carrés de voyelles, il renvoie celui qui se trouve à la position la plus en haut à gauche de toute
la matrice. La matrice d'entrée sera au moins de taille 2x2.
Exemples
Entrée : ["aqrst", "ukaei", "ffooo"]

Sortie : 1-2
Entrée : ["gg", "ff"]

Sortie : introuvable
function VowelSquare(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}` ;
}
}
}
renvoie "non trouvé
function checkPoint(arr, point) {

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

VowelSquare(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)) {
// Bien ! Retourner le premier parce que nous
// recherche dans un bon ordre
return row + '-' + col ;
}
}
}
renvoie "non trouvé" ;
function isVowels2x2(strArr, row, col) {

// On pourrait faire une vérification des bornes ici, mais elle est faite
dans main()
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 ;
retourner vrai ;
}
function isVowel(letter) {
const VOWELS = 'aeiou' ;
return VOWELS.includes(letter) ;
}
}

// vérifie si chaque lettre de la matrice donnée est une voyelle

function allVowels(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 avec fenêtres glissantes de la sous-matrice 2x2
var subMatrix = matrix.slice(row, row + 2).map(rowArr =>
rowArr.slice(column, column + 2)) ;
if (allVowels(subMatrix)) {
return row + '-' + column ;
}
}
}
renvoie "non trouvé" ;

}

L'ennemi le plus proche
La fonctionEnnemi le plus proche(arr) prend le tableau de nombres stocké dansarr et, à

partir de la position dans le tableau où se trouve un 1, renvoie le nombre de cases à gauche ou à droite
que vous devez parcourir pour atteindre un ennemi représenté par un 2. Par exemple : si arr est [0, 0, 1,
0, 0, 2, 0, 2], votre programme doit renvoyer3 car l'ennemi le plus proche (2) est à 3 cases du 1. Le
tableau contiendra un nombre quelconque de 0 et de 2, mais un seul 1. Il se peut également qu'il ne
contienne aucun 2, auquel cas votre programme doit renvoyer un 0.
Exemples
Entrée : [1, 0, 0, 0, 2, 2, 2]
Sortie : 4
Entrée : [2, 0, 0, 0, 2, 2, 1, 0]
Sortie : 1
function ClosestEnemy(arr) {
if (!arr.includes(2)) {
retour 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) {
retour i ;
}
}
retour loc1 ;
}

Ennemi le plus proche(readline()) ;
let hero = -1 ;
if (arr[i] === 1) { // Trouvé le héros
héros = i ;
}
}
// Rechercher à droite
let deltaRight = undefined ;
for (let i = hero+1 ; i < arr.length ; i++) {
if (arr[i] === 2) { // L'ennemi a été trouvé
deltaRight = i - hero ;
pause ;
}
}
// Recherche à gauche
let deltaLeft = undefined ;
for (let i = hero-1 ; i >= 0 ; i--) {
if (arr[i] === 2) { // L'ennemi a été trouvé
deltaLeft = hero - i ;
pause ;
}
}
if (deltaLeft === undefined && deltaRight === undefined) {

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

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

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

}

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

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

}

L'ennemi le plus proche II
La fonctionClosestEnemyII(strArr) doit lire la matrice de nombres stockée dansstrArr. Il

s'agit d'une matrice 2D qui ne contient que les nombres entiers 1, 0 ou 2. Ensuite, à partir de la position
dans la matrice où se trouve un 1, retournez le nombre de cases à gauche, à droite, en bas ou en haut que
vous devez déplacer pour atteindre un ennemi représenté par un 2. Il est également possible d'enrouler la
matrice d'un côté à l'autre. Par exemple : sistrArr est ["0000", "1000", "0002", "0002"], cela
ressemble à ce qui suit :
0 0 0 0 10 0 0
0 0 02
0 0 0
2
Pour cette entrée, votre programme devrait renvoyer2 car l'ennemi le plus proche (2) se trouve à 2
espaces du 1 en se déplaçant vers la gauche pour passer de l'autre côté, puis en se déplaçant vers le bas
une fois. Le tableau contiendra un nombre quelconque de 0 et de 2, mais un seul 1. Il se peut également
qu'il ne contienne aucun 2, auquel cas votre programme devrait renvoyer un 0.
Exemples
Entrée : ["000", "100", "200"]

Sortie : 1
Entrée : ["0000", "2010", "0000", "2002"]

Sortie : 2
function ClosestEnemyII(strArr) {
/première étape - renvoyer 0 s'il n'y a pas de 2 dans le tableau
let twosies = strArr.filter(val => {
return val.includes("2") ;
});
if (!twosies.length) {
retour 0 ;
}
/deuxième étape - obtenir les coordonnées du 1 (cibleX, cibleY)
targetY = strArr.findIndex(val => {
return val.includes('1') ;
});
targetX = strArr[targetY].search(/1/) ;
/troisième étape : trouver le plus petit chemin vers a 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 ;
//--------------------helpers----------------------
//malgré le nom, à utiliser pour la distance entre les colonnes et les lignes
function rowDist(y, x, len) {
return Math.min(Math.abs(x - y), Math.abs(y - x + len)) ;
}

ClosestEnemyII(readline()) ;
// Trouver le héros
let heroY = -1 ;
let heroX = -1 ;
let result = strArr[i].indexOf(1) ;
if (result > -1) {
heroX = result ;
heroY = i ;
}
}
if (heroY === -1) {

// Il n'y a pas de héros
retourner -1 ;
}
//console.log(heroY + '-' + heroX) ;
// Vérifier la présence d'ennemis

let ennemis = [] ;
let result = strArr[i].indexOf(2) ;
if (result > -1) {
ennemis.push([i,result]) ;
}
}
if (enemies.length === 0) {
retour 0 ;
}
//console.log(enemies) ;
let closestDistance = Number.MAX_SAFE_INTEGER ;
// Vérifier les distances entre les ennemis

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

let deltaY = Math.abs(enemyY - heroY) ;
//console.log(deltaY + '-' + deltaX) ;
// Vérifier maintenant les valeurs enveloppantes

// le deltaX est maximal car s'il est supérieur, nous nous en moquons.
let wrapDeltaX = Number.MAX_SAFE_INTEGER ;
for (let i = 0 ; i < deltaX ; i++) {
if ((enemyX + i) % strArr[0].length === heroX) {
// a trouvé le delta du héros
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) {
// a trouvé le delta du héros
wrapDeltaY = i ;
//console.log('wrap-aroundY : ' + i)
}
}
deltaX = (wrapDeltaX < deltaX) ? wrapDeltaX : deltaX ;

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

distance la plus proche = distance ;
}
}
return closestDistance ;

// trouver la distance entre deux éléments dont les indices [ligne, colonne] sont
donnés
function 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 ;
// emplacement du moi : 1
var meIndices ;
// emplacements des ennemis : 2
var enemiesIndices = [] ;
// identifier les emplacements des 1 et des 2

for (var row = 0 ; row < matrix.length ; row++) {
for (var column = 0 ; column < matrix[0].length ; column++) {
if (matrix[row][column] === 1) {
meIndices = [row, column] ;
else if (matrix[row][column] === 2) {
enemiesIndices.push([row, column]) ;
}
}
}
// vérifier la distance qui me sépare de chaque ennemi

for (var enemyIndices of enemiesIndices) {
var distance = getDistance(matrix.length, meIndices, enemyIndices) ;
if (distance < minDistance) {
minDistance = distance ;
}
}
// gère le cas où il n'y a pas d'ennemi

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

Nombre Flux
Demandez à la fonctionNumberStream(str) de prendre le paramètrestr passé, qui contiendra les

chiffres 2 à 9, et de déterminer s'il existe un flux consécutif de chiffres d'une longueur d'au moins N, où
N est la valeur réelle du chiffre. Si c'est le cas, il renvoie la chaînetrue, sinon il renvoie la chaînefalse.
Par exemple : sistr est "6539923335", votre programme doit renvoyer la chaînetrue car il existe un
flux consécutif de 3 de longueur 3. La chaîne d'entrée contiendra toujours au moins un chiffre.
Exemples
Entrée : "5556293383563665"
Sortie : false
Entrée : "5788888888882339999"
Sortie : true
function NumberStream(str) {
for (let i = 2 ; i < 10 ; i++) {
let iChar = i.toString() ;
let needle = iChar.repeat(i) ;
if (str.indexOf(needle) !== -1) {
retourner vrai ;
}
}
// le code va ici
retourner faux ;

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

if (str[i] === lastDigit) {
// Suite du flux
compter++ ;
if (count >= Number(lastDigit)) {
retourner vrai ;
}
} else {
// Nouveau flux
lastDigit = str[i] ;
compter = 1 ;
}
}
retourner faux ;
}
// génère d'abord des motifs
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) {
// modèle trouvé
retourner vrai ;
}
}
retourner faux ;
}

Les quatre plus grands
Demandez à la fonctionLargestFour(arr) de prendre le tableau d'entiers stocké dansarr, de

trouver les quatre éléments les plus grands et de renvoyer leur somme. Par exemple : si arr est [4, 5, -2,
3, 1, 2, 6, 6], les quatre éléments les plus grands de ce tableau sont 6, 6, 4 et 5 et la somme totale de ces
nombres est21, de sorte que votre programme doit renvoyer21. S'il y a moins de quatre nombres dans le
tableau, votre programme doit renvoyer la somme de tous les nombres du tableau.
Exemples
Entrée : [1, 1, 1, -5]

Sortie : -2
Entrée : [0, 0, 2, 3, 7, 1]
Sortie : 13
function LargestFour(arr) {
let newArr = arr.sort((val1, val2) => {
retour val2 - val1 ;
})
.splice(0, 4) ;
return newArr.reduce((val1, val2) => {
retourner 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) ;
}

Caractères distincts
La fonctionCaractèresDistincts(str) prend le paramètrestr passé et détermine s'il contient au

moins 10 caractères distincts. Si c'est le cas, votre programme doit renvoyer la chaîne true, sinon il doit
renvoyer la chaînefalse. Par exemple : sistr est "abc123kkmmmm ?", votre programme doit renvoyer la
chaînefalse car cette chaîne ne contient que 9 caractères distincts : a, b, c, 1, 2, 3, k, m, ? s'additionnent
pour former un total de 9.
Exemples
Entrée : "12334bbmma:=6"
Sortie : true
Entrée : "eeeemmmmmmm1000"
Sortie : false
function 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 distincts = {} ;

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

}

Questions Marques
Demandez à la fonctionQuestionsMarks(str) de prendre en paramètre la chaînestr, qui

contiendra des nombres à un chiffre, des lettres et des points d'interrogation, et de vérifier s'il y a
exactement 3 points d'interrogation entre chaque paire de deux nombres dont la somme est égale à 10. Si
c'est le cas, votre programme doit renvoyer la chaînetrue, sinon il doit renvoyer la chaînefalse. S'il n'y a
pas deux nombres dont la somme est égale à 10 dans la chaîne, votre programme doit également
renvoyerfalse.
Par exemple : sistr est "arrb6???4xxbl5???eee5", votre programme doit renvoyertrue car il y a
exactement 3 points d'interrogation entre 6 et 4, et 3 points d'interrogation entre 5 et 5 à la fin de la
chaîne.
Exemples
Entrée : "aa6?9"
Sortie : false
Entrée : "acc?7??sss?3rr1??????5"
Sortie : true
function QuestionsMarks(str) {
let numPlaces = [] ;
//présomption de faux, jusqu'à ce que le drapeau devienne vrai
let flag = false ;
//obtient un tableau de places dans la chaîne de caractères contenant des nombres

entiers
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) {
drapeau = vrai ;
let strSeg = str.slice(numPlaces[i], numPlaces[i + 1]) ;
strSeg = strSeg.replace(/[^\ ?]/g, '') ;

if (strSeg !== '???') {
retourner faux ;
}
}
}
drapeau de retour ;
}

QuestionsMarks(readline()) ;
Mallette Camel
Faire en sorte que la fonctionCamelCase(str) prenne le paramètrestr qui lui est passé et le renvoie
dans un format camel case correct où la première lettre de chaque mot est en majuscule (à l'exception de
la première lettre). La chaîne ne contiendra que des lettres et une combinaison de caractères de
ponctuation séparant chaque mot.
Par exemple : sistr est "BOB aime le codage", votre programme doit renvoyer la
chaînebobLovesCoding.
Exemples
Entrée : "cats AND*Dogs-are Awesome"

Sortie : catsAndDogsAreAwesome
Entrée : "a b c d-e-f%g"

Sortie : aBCDEFG
function 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('') ;
}
retour val ;
})
return strArr.join('') ;
}

CamelCase(readline()) ;
Conversion ASCII
Faire en sorte que la fonctionASCIIConversion(str) prenne le paramètrestr passé et renvoie une

nouvelle chaîne où chaque caractère, à l'exception du caractère espace, est remplacé par son code de
caractère décimal correspondant. Par exemple : sistr est "chien", votre programme doit renvoyer la
chaîne100111103 car d = 100, o = 111, g = 103.
Exemples
Entrée : "hello world"

Sortie : 104101108108111 119111114108100
Entrée : "abc **"

Sortie : 979899 4242
function ASCIIConversion(str) {
let myArr = str.split(' ').map(val => {
return val.split('').map(val2 => {
return val2.charCodeAt(0) ;
}).join('')
}).join(' ') ;
return myArr ;
}

ASCIIConversion(readline()) ;
Evènements simples
La fonctionSimpleEvens(num) doit vérifier si tous les nombres du paramètre passé sont pairs. Si
c'est le cas, il renvoie la chaînetrue, sinon il renvoie la chaînefalse. Par exemple : sinum est 4602225,
votre programme doit renvoyer la chaînefalse car 5 n'est pas un nombre pair.
Exemples
Entrée : 2222220222
Sortie : true
Entrée : 20864646452
Sortie : false
function SimpleEvens(num) {
return num.toString(10).search(/[13579]/) === -1 ? 'true' : 'false' ;
}
SimpleEvens(readline()) ;
Affaire du serpent
Faire en sorte que la fonctionSnakeCase(str) prenne le paramètrestr qui lui est passé et le renvoie
dans un format snake case approprié où chaque mot est en minuscule et séparé des mots adjacents par un
trait de soulignement. La chaîne ne contiendra que des lettres et une combinaison de caractères de
ponctuation séparant chaque mot.
Par exemple : sistr est "BOB aime le codage", votre programme doit renvoyer la
chaînebob_loves_coding.
Exemples
Entrée : "cats AND*Dogs-are Awesome"

Sortie : cats_and_dogs_are_awesome
Entrée : "a b c d-e-f%g"

Sortie : a_b_c_d_e_f_g
function SnakeCase(str) {
return str.split(/[â-zA-Z]/).map(val => {return val.toLowerCase()}).join('_')
;
}
SnakeCase(readline()) ;
Trouver l'intersection
La fonctionFindIntersection(strArr) doit lire le tableau de chaînes de caractères stocké

dansstrArr qui contiendra 2 éléments : le premier élément représentera une liste de nombres séparés
par des virgules et triés par ordre croissant, le second élément représentera une deuxième liste de
nombres séparés par des virgules (également triés). Votre objectif est de renvoyer une chaîne de
caractères séparée par des virgules contenant les nombres apparaissant dans les éléments de strArr
dans l'ordre trié. S'il n'y a pas d'intersection, la chaîne de caractèresfalse est renvoyée.
Par exemple : sistrArr contient ["1, 3, 4, 7, 13", "1, 2, 4, 13, 15"], la sortie devrait renvoyer "1,4,13"
car ces nombres apparaissent dans les deux chaînes. Le tableau fourni ne sera pas vide, et chaque chaîne
à l'intérieur du tableau sera composée de nombres triés par ordre croissant et pourra contenir des
nombres négatifs.
Exemples
Entrée : ["1, 3, 4, 7, 13", "1, 2, 4, 13, 15"]

Sortie : 1,4,13
Entrée : ["1, 3, 9, 10, 17, 18", "1, 4, 9, 10"]

Sortie : 1,9,10
function 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())) ;
Multiplicateur de somme
La fonctionSumMultiplier(arr) prend le tableau de nombres stocké dansarr et renvoie la

chaînetrue si deux nombres peuvent être multipliés de telle sorte que la réponse soit supérieure au
double de la somme de tous les éléments du tableau. Si ce n'est pas le cas, la chaîne de caractères false
est renvoyée. Par exemple : siarr est [2, 5, 6, -6, 16, 2, 3, 6, 5, 3], la somme de tous ces éléments est 42
et en la doublant, on obtient 84. Il y a deux éléments dans le tableau, 16 * 6 = 96 et 96 est supérieur à 84,
donc votre programme devrait retourner la chaînetrue.
Exemples
Entrée : [2, 2, 2, 2, 4, 1]
Sortie : false
Entrée : [1, 1, 2, 10, 3, 1, 12]

Sortie : true
function 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])) ;
retour vérificateur > cible ;
}
SumMultiplier(readline()) ;
Fusion de chaînes
La fonctionStringMerge(str) doit lire le paramètrestr qui lui est transmis et qui contient une
grande chaîne de caractères alphanumériques avec un seul caractère astérisque qui sépare la chaîne en
deux chaînes distinctes. Votre objectif est de renvoyer une nouvelle chaîne en associant les caractères
situés aux emplacements correspondants dans les deux chaînes. Par exemple : si str est "abc1*kyoo",
votre programme devrait renvoyer la chaîneakbyco1o parce que a va de pair avec k, b va de pair avec y,
etc. La chaîne sera toujours divisée de manière égale avec l'astérisque au centre.
Exemples
Entrée : "aaa*bbb"
Sortie : ababab
Entrée : "123hg*aaabb"
Sortie : 1a2a3ahbgb
function StringMerge(str) {
const cleanString = str.replace(/[^\w*]/g, '') ;
const len = (cleanString.length - 1) / 2 ;
const arr = str.split('*') ;
for (let i = 0 ; i < len ; i++) {

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

StringMerge(readline()) ;
Un décrémenté
Demandez à la fonctionOneDecremented(str) de compter le nombre de fois où apparaît un chiffre

qui est exactement un de moins que le chiffre précédent. Par exemple : sistrest "5655984", votre
programme doit renvoyer2 car 5 apparaît directement après 6 et 8 apparaît directement après 9. L'entrée
contiendra toujours au moins un chiffre.
Exemples
Entrée : "56"
Sortie : 0
Entrée : "9876541110"
Sortie : 6
function OneDecremented(num) {
let counter = 0 ;
let arr = num.toString().split('') ;
if (parseInt(val, 10) - parseInt(arr[ind + 1], 10) === 1) {
contre++ ;
}
})
retourner le compteur ;
}

OneDecremented(readline()) ;
Fusion des éléments
La fonctionElementMerger(arr) prend le tableau d'entiers positifs stocké dansarr et exécute

l'algorithme suivant : elle obtient continuellement la différence des entiers adjacents pour créer un
nouveau tableau d'entiers, puis fait de même pour le nouveau tableau jusqu'à ce qu'il ne reste plus qu'un
seul nombre et renvoie ce nombre. Par exemple : siarr est [4, 5, 1, 2, 7], la différence de chaque paire
d'éléments produit le nouveau tableau suivant : [1, 4, 1, 5]. Faites ensuite la même chose avec ce
nouveau tableau pour obtenir [3, 3, 4] -> [0, 1] -> 1. Ainsi, dans cet exemple, votre programme doit
renvoyer le chiffre 1, car c'est ce qui reste à la fin.
Exemples
Entrée : [5, 7, 16, 1, 2]

Sortie : 7
Entrée : [1, 1, 1, 2]
Sortie : 1
function 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
Demandez à la fonctionGCF(arr) de prendre le tableau de nombres stocké dansarr, qui ne contiendra

toujours que deux entiers positifs, et de renvoyer le plus grand facteur commun de ces nombres. Par
exemple : siarr est [45, 12], votre programme doit renvoyer3. Il y aura toujours deux éléments dans le
tableau et ce seront des nombres entiers positifs.
Exemples
Entrée : [1, 6]
Sortie : 1
Entrée : [12, 28]

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

GCF(readline()) ;
Numéro de série
La fonctionSerialNumber(str) prend le paramètrestr qui lui est transmis et détermine s'il s'agit
d'un numéro de série valide avec les contraintes suivantes :
1. Il doit contenir trois séries de trois chiffres (de 1 à 9) séparées par un point.
2. La première série de chiffres doit être un nombre pair.
3. La deuxième série de chiffres doit être un nombre impair.
4. Le dernier chiffre de chaque série doit être plus grand que les deux chiffres précédents de la même
série.
Si toutes les contraintes ci-dessus sont respectées dans la chaîne, votre programme doit renvoyer la
chaînetrue, sinon votre programme doit renvoyer la chaînefalse. Par exemple : sistr est "224.315.218",
votre programme doit renvoyer "true".
Exemples
Entrée : "11.124.667"
Sortie : false
Entrée : "114.568.112"
Sortie : true
function SerialNumber(str) {
//vérifier le format de la chaîne
let goal = /^\d{3}\\N- \d{3}\N- \N- \N- \N$/
if (!goal.test(str)) {
retourner "false" ;
}
//transforme la chaîne en trois tableaux de trois chiffres chacun

let arr = str.split(/\./).map(val => {
return val.split('').map(val2 => {
return parseInt(val2, 10) ;
});
});
//vérifier la première condition

if ((arr[0][0] + arr[0][1] + arr[0][2]) % 2) {
retourner "false" ;
}
//vérifier la deuxième condition

if ( !((arr[1][0] + arr[1][1] + arr[1][2]) % 2)) {
retourner "false" ;
}
//vérifier la troisième condition

for (let i = 0, len = arr.length ; i < len ; i++) {
if (Math.max(...arr[i]) !== arr[i][2]) {
retourner "false" ;
}
}
//si toutes les conditions sont remplies sans que le résultat soit faux, il
faut renvoyer le résultat vrai
retourner vrai ;
}
SerialNumber(readline()) ;
Périodes de la chaîne
Demandez à la fonctionStringPeriods(str) de prendre le paramètrestr passé et de déterminer

s'il existe une sous-chaîne K qui peut être répétée N > 1 fois pour produire la chaîne d'entrée exactement
telle qu'elle apparaît. Votre programme doit renvoyer la plus longue sous-chaîne K, et s'il n'y en a pas, il
doit renvoyer la chaîne-1.
Par exemple : sistr est "abcababcababcab", votre programme doit renvoyerabcab car il s'agit de la plus
longue sous-chaîne répétée trois fois pour créer la chaîne finale. Autre exemple : si str est
"abababababab", votre programme doit renvoyerababab car il s'agit de la sous-chaîne la plus longue. Si
la chaîne d'entrée ne contient qu'un seul caractère, votre programme doit renvoyer la chaîne -1.
Exemples
Entrée : "abcxabc"
Sortie : -1
Entrée : "affedaaffed"
Sortie : -1
function StringPeriods(str) {
// nous n'utiliserons que les longueurs des sous-chaînes qui se divisent
uniformément en 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) {
bloc de retour ;
}
}
}
retourner -1 ;
}

StringPeriods(readline()) ;
Échangeur de palindromes
Demandez à la fonctionPalindromeSwapper(str) de prendre le paramètrestr passé et de

déterminer si un palindrome peut être créé en échangeant deux caractères adjacents dans la chaîne. S'il
est possible de créer un palindrome, votre programme doit renvoyer le palindrome, sinon il doit renvoyer
la chaîne-1. La chaîne d'entrée ne contiendra que des caractères alphabétiques. Par exemple : si str est
"rcaecar", vous pouvez créer un palindrome en échangeant les deuxième et troisième caractères. Votre
programme devrait donc renvoyer la chaîneracecar, qui est la chaîne palindromique finale.
Exemples
Entrée : "anna"
Sortie : anna
Entrée : "kyaak"
Sortie : kayak
function 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)]) {
retourner faux ;
}
}
retourner vrai ;
}
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('') ;
}
}
retourner -1 ;
}

PalindromeSwapper(readline()) ;
Retirer les supports
La fonctionRemoveBrackets(str) prend la chaîne de caractèresstr qui lui est transmise, laquelle

ne contient que les caractères "(" et ")", et détermine le nombre minimum de parenthèses à supprimer
pour créer une chaîne de parenthèses correctement appariées. Par exemple : si str est "(()))", votre
programme doit renvoyer le nombre 1. La réponse pourrait potentiellement être 0, et il y aura toujours au
moins un ensemble de parenthèses correspondantes dans la chaîne.
Exemples
Entrée : "(())(((("
Sortie : 3
Entrée : "(()("
Sortie : 2
function RemoveBrackets(str) {
let throwouts = 0 ;
let counter = 0 ;
let arr = str.split('') ;
for (let i = 0 ; i < len ; i++) {

//un bon exemple de l'utilisation de pre++ et pre-- par opposition à post++ et
post--
counter = arr[i] === '(' ? ++counter : --counter ;
if (counter < 0) {
les rejets++ ;
compteur = 0 ;
}
}
éliminations += counter ;
les renvois ;
}
RemoveBrackets(readline()) ;
Ligne de commande
Faire en sorte que la fonctionCommandLine(str) prenne en compte le paramètrestr transmis, qui

représente les paramètres donnés à une commande dans un ancien système PDP. Les paramètres sont des
jetons alphanumériques (sans espaces) suivis d'un signe égal et de leur valeur correspondante. Plusieurs
paires de paramètres/valeurs peuvent être placées sur la ligne de commande avec un seul espace entre
chaque paire. Lesjetons de paramètres et lesvaleurs ne peuvent pas contenir de signes égaux, mais
lesvaleurs peuvent contenir des espaces. L'objectif de la fonction est d'isoler les paramètres et les
valeurs pour renvoyer une liste de longueurs de paramètres et de valeurs. Il doit fournir son résultat dans
le même format et dans le même ordre en remplaçant chaque entrée (jetons et valeurs) par sa longueur
correspondante.
Par exemple, sistr est : "SampleNumber=3234 provider=Dr. Welby patient=John Smith priority=High",
votre fonction devrait renvoyer la chaîne "12=4 8=12 7=10 8=4" car "SampleNumber" est un jeton de 12
caractères avec une valeur de 4 caractères ("3234") suivi de "provider" qui est un jeton de 8 caractères
suivi d'une valeur de 12 caractères ("Dr. M. Welby"), etc.
Exemples
Entrée : "letters=A B Z T numbers=1 2 26 20 combine=true"

Sortie : 7=7 7=9 7=4
Entrée : "a=3 b=4 a=23 b=a 4 23 c="

Sortie : 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(pair => {

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

}

CommandLine(readline()) ;
Classement par étoiles
La fonctionStarRating(str) prend le paramètrestr qui lui est transmis et qui sera une note
moyenne comprise entre 0,00 et 5,00, et convertit cette note en une liste de 5 noms d'images à afficher
dans une interface utilisateur pour représenter la note sous la forme d'une liste d'étoiles et de demi-
étoiles. Les notes doivent être arrondies à la moitié la plus proche. Trois noms de fichier image sont
disponibles : "full.jpg", "half.jpg", "empty.jpg". Le résultat sera le nom des 5 images (sans l'extension),
de gauche à droite, séparées par des espaces. Par exemple : sistr est "2.36", cela devrait être affiché par
l'image suivante :
Votre programme devrait donc renvoyer la chaîne "full full half empty empty".
Exemples
Entrée : "0.38"
Sortie : demi-vide vide vide vide
Entrée : "4.5"
Sortie : pleine pleine pleine pleine moitié
function 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 += ' half' ;
}
return (starString + ' empty'.repeat(5 - num)).trim() ;
}

StarRating(readline()) ;

Résolution de Problèmes-1

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Résolution de Problèmes-1

Transféré par

Droits d'auteur :

Formats disponibles

Premier renversement

La fonctionFirstReverse(str) prend le paramètrestr qui lui est transmis et renvoie la chaîne

Entrée : "I Love Code"

var arr = str.split('') ;

// garder cet appel de fonction ici

let newString = '' ;

// garder cet appel de fonction ici

// garder cet appel de fonction ici

La fonctionFirstFactorial(num) prend le paramètrenum qui lui est passé et renvoie la factorielle

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

// garder cet appel de fonction ici

// garder cet appel de fonction ici

// garder cet appel de fonction ici

Mot le plus long

Faire en sorte que la fonctionLongestWord(sen) prenne le paramètresen transmis et renvoie le mot

Entrée : "fun& !! time"

Entrée : "J'aime les chiens"

var arr = sen.split(' ') ;

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

// garder cet appel de fonction ici

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

if (length > maxLength) {

// garder cet appel de fonction ici

// garder cet appel de fonction ici

Demandez à la fonctionLetterChanges(str) de prendre le paramètrestr passé et de le modifier en

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

// garder cet appel de fonction ici

let validCharacters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' ;

let newString = '' ;

let voyelles = 'aeiou' ;

let finalString = '' ;

// capitaliser les voyelles

// garder cet appel de fonction ici

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

// garder cet appel de fonction ici

Demandez à la fonctionSimpleAdding(num) d'additionner tous les nombres compris entre 1 etnum.

// garder cet appel de fonction ici

// garder cet appel de fonction ici

// garder cet appel de fonction ici

La fonctionLetterCapitalize(str) prend le paramètrestr qui lui est transmis et met en

Entrée : "hello world"

Entrée : "j'ai couru là"

wordarr = str.split(" ") ;

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

// garder cet appel de fonction ici

let newString = '' ;

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

// garder cet appel de fonction ici

// garder cet appel de fonction ici

Demandez à la fonctionSimpleSymbols(str) de prendre le paramètrestr passé et de déterminer

// garder cet appel de fonction ici

if (str === '') {

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

return result ? 'true' : 'false' ;

function letterEval(letter, index) {

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

// garder cet appel de fonction ici

// garder cet appel de fonction ici

Vérifier les numéros

La fonctionCheckNums(num1,num2) prend les deux paramètres passés et renvoie la chaînetrue

Entrée : 3 & num2 = 122

Entrée : 67 & num2 = 67

// garder cet appel de fonction ici