Resolución de Problemas-2

Mediana móvil
Solución de usuario mejor valorada

Mediana móvil
Haga que la funciónMovingMedian(arr) lea el array de números almacenados enarr que contendrá un tamaño de ventana deslizante, N, como primer elemento del array y el
resto será una lista de números. Su programa debe devolver laMediana Móvil para cada elemento basado en el elemento y sus N-1 predecesores, donde N es el tamaño de la ventana
deslizante. La salida final debe ser una cadena con la mediana móvil correspondiente a cada entrada de la matriz original separada por comas.
Tenga en cuenta que para los primeros elementos (hasta alcanzar el tamaño de la ventana), la mediana se calcula sobre un número menor de entradas. Por ejemplo: si arr es [3, 1, 3, 5,
10, 6, 4, 3, 1], el programa debería mostrar "1,2,3,5,6,6,4,3".
Ejemplos
Entrada: [5, 2, 4, 6]
Salida: 2,3,4
Entrada: [3, 0, 0, -2, 0, 2, 0, -2]

Salida: 0,0,0,0,0,0,0
function MovingMedian(arr) {
let construirArr = [];
let winLongitud = arr.shift();
let len = arr.length;
for (let i = 0; i < len; i++) {

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

arr.sort((val1, val2) => {return val1 - val2});
if (len % 2) {
return arr[Math.floor(len/2)];
} else {
return (arr[len/2 - 1] + arr[len/2]) / 2;
}
}
// mantenga esta llamada de función aquí

MovingMedian(readline());
Totales de grupo
Haga que la funciónGroupTotals(strArr) lea el parámetrostrArr que contiene pares clave:valor donde la clave es una cadena y el valor es un entero. Su programa debe
devolver una cadena con nuevos pares clave:valor separados por una coma de forma que cada clave aparezca una sola vez con los valores totales sumados.
Por ejemplo: sistrArr es ["B:-1", "A:1", "B:3", "A:5"] entonces su programa debería devolver la cadena A:6,B:2.
La cadena de salida final debe devolver las claves en orden alfabético. Excluye las claves que tienen un valor 0 después de ser sumadas.
Ejemplos
Entrada: ["X:-1", "Y:1", "X:-4", "B:3", "X:5"]
Salida: B:3,Y:1
Entrada: ["Z:0", "A:-1"]

Salida: A:-1
function AgruparTotales(strArr) {
let resObject = {};
let parsingRegExp = /(\w+):(-?\d+)/;
strArr.forEach(val => {
const matches = val.match(parsingRegExp);
const clave = coincidencias[1];
const numVal = Número(coincidencias[2]);
if (resObject[key] | resObject[key] === 0) {

resObject[clave] = resObject[clave] += numVal;
} else {
resObject[clave] = numVal;
}
});
return Object.keys(resObject)
.sort()
.map(val => {
return resObject[val] ? (val + ":" + resObject[val]) : '';
})
.filter(val => {
devolver val;
})
.join(',');
}

GroupTotals(readline());
Cambios de cadena
Haga que la funciónStringChanges(str) tome el parámetrostr pasado, que será una cadena que contiene letras del alfabeto, y devuelva una nueva cadena basada en las
siguientes reglas. Siempre que se encuentre una M mayúscula, duplica el carácter anterior (y luego elimina la M), y siempre que se encuentre una N mayúscula elimina el siguiente
carácter de la cadena (y luego elimina la N). Todos los demás caracteres de la cadena serán minúsculas. Por ejemplo: "abcNdgM" debería devolver "abcgg". La cadena final nunca
estará vacía.
Ejemplos
Entrada: "MrtyNNgMM"
Salida: rtyggg
Entrada: "oMoMkkNrrN"
Salida: ooookkr
function StringChanges(str) {
const strArray = str.split('');
let len = strArray.length;
for (let i = 0; i < len; i++) {

if (strArray[i] === 'M') {
if (!i) {
strArray.shift();
len -= 1;
i -= 1;
} else {
strArray.splice(i, 1, strArray[i - 1]);
}
} else if (strArray[i] === 'N') {
if (i === len - 1) {
strArray.pop();
} else {
strArray.splice(i, 2);
len -= 2;
i -= 2;
}
}
}
return strArray.join('');
}

StringChanges(readline());
FizzBuzz
Haga que la funciónFizzBuzz(num) tome el parámetronum que se le pasa y devuelva todos los números del 1 alnum separados por espacios, pero sustituya cada número divisible
por 3 por la palabra "Fizz", sustituya cada número divisible por 5 por la palabra "Buzz", y cada número divisible por 3 y 5 por la palabra "FizzBuzz". Por ejemplo: si num es 16,
entonces su programa debería devolver la cadena "1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16". La entrada estará comprendida entre 1 y 50.
Ejemplos
Entrada: 3
Salida: 1 2 Fizz
Entrada: 8
Salida: 1 2 Fizz 4 Buzz Fizz 7 8
function FizzBuzz(num) {
const returnArray = [];
for (let i = 1; i <= num; i++) {
if (!(i % 15)) {
returnArray.push('FizzBuzz');
} else if (!(i % 5)) {
returnArray.push('Buzz');
} else if (!(i % 3)) {
returnArray.push('Fizz');
} else {
returnArray.push(i);
}
}
return returnArray.join(' ');
}

FizzBuzz(readline());
Distancia H
Que la funciónHDistance(strArr) tome la matriz de cadenas almacenada enstrArr, que sólo contendrá dos cadenas de igual longitud y devuelva el número de caracteres en
cada posición que son diferentes entre ellas. Por ejemplo: sistrArr es ["casa", "horas"] entonces su programa debería devolver2. La cadena siempre tendrá la misma longitud y sólo
contendrá caracteres del alfabeto en minúsculas y números.
Ejemplos
Entrada: ["10011", "10100"]
Salida: 3
Entrada: ["abcdef", "defabc"]

Salida: 6
function HDistance(strArr) {
const cadena1 = strArr[0];

const cadena2 = strArr[1];
const len = cadena1.longitud;
let count = 0;
for (let i = 0; i < len; i++) {

if (cadena1[i] !== cadena2[i]) {
count += 1;
}
}
Devuelve el recuento;
}

HDistance(readline());
Casos diferentes
Haga que la funciónDifferentCases(str) tome el parámetrostr que se le pasa y lo devuelva en formato de mayúsculas y minúsculas donde la primera letra de cada palabra
esté en mayúscula. La cadena sólo contendrá letras y alguna combinación de caracteres de puntuación delimitadores que separen cada palabra.
Por ejemplo: sistr es "ADanielLeGustaCodificar" entonces su programa debe devolver la cadena ADanielLeGustaCodificar.
Ejemplos
Entrada: "cats AND*Dogs-are Awesome"
Salida: CatsAndDogsAreAwesome
Entrada: "a b c d-e-f%g"

Salida: ABCDEFG
function DiferentesCasos(str) {
const charTest = /[a-zA-Z]/;
let returnString = '';
const len = str.length;
const baseString = str.toLowerCase();
for (let i = 0; i < len; i++) {

if (i === len - 1 && !charTest.test(baseString[i])) {
return returnString;
}
if (i === 0 && charTest.test(baseString[i])) {
returnString += baseString[i].toUpperCase();
continuar;
}
if (baseString[i - 1] && charTest.test(baseString[i])) {
if (!charTest.test(cadenabase[i - 1])) {
returnString += baseString[i].toUpperCase();
} else {
returnCadena += baseCadena[i];
}
}
}
return returnString;
}

DiferentesCasos(readline());
Pulsaciones equivalentes
Haga que la funciónEquivalentKeypresses(strArr) lea la matriz de cadenas almacenada enstrArr que contendrá 2 cadenas que representan dos listas de pulsaciones de
teclas separadas por comas. Su objetivo es devolver la cadenatrue si las pulsaciones de teclas producen la misma cadena imprimible y la cadena false en caso contrario. Una pulsación
puede ser un carácter imprimible o un retroceso representado por-B. Puede producir una cadena imprimible a partir de una cadena de pulsaciones haciendo que los retrocesos borren
un carácter precedente.
Por ejemplo: sistrArr contiene ["a,b,c,d", "a,b,c,c,-B,d"] la salida debería devolververdadero porque esas pulsaciones producen la misma cadena imprimible. La matriz dada no
estará vacía. Las pulsaciones sólo contendrán letras del alfabeto y espacios en blanco.
Ejemplos
Entrada: ["a,b,c,d", "a,b,c,d,-B,d"]
Salida: true
Entrada: ["c,a,r,d", "c,a,-B,r,d"]

Salida: false
function TeclasEquivalentes(strArr) {
function reducir(str) {
let resultado = "";
str = str.split(",");
str.forEach(function (item, index) {
if (str[index + 1] !== "-B" && str[index] !== "-B") {
resultado += item;
}
})
Devuelve el resultado;
}
// el código va aquí
return reduce(strArr[0]) == reduce(strArr[1]);
// mantener esta llamada de función aquí

console.log(TeclasEquivalentes(readline()));
Prime Time
Haga que la funciónPrimeTime(num) tome el parámetronum que se le pasa y devuelva la cadenatrue si el parámetro es un número primo, en caso contrario devuelva la
cadenafalse. El rango estará entre 1 y 2^16.
Ejemplos
Entrada: 19
Salida: verdadero
Entrada: 110
Salida: falso
function PrimeTime(num) {
var bisagra = Math.floor(Math.sqrt(num));
var i = 2;
var test = true;
//codificar respuestas correctas para 1 y 2

if (num === 1) {
devolver false
}
else if (num === 2) {
devolver true
}
//ejecuta un bucle para ver si el número tiene algún factor integral (aparte de
1)
si no {
while (i <= bisagra && prueba === verdadero) {
if (num % i !== 0) {
i++;
}
si no {
test = false;
}
}
prueba de retorno
}
}

// para ver cómo introducir argumentos en JavaScript desplácese hacia abajo
PrimeTime(readline());
Longitud de la carrera
Que la funciónRunLength(str) tome el parámetrostr que se le pasa y devuelva una versión comprimida de la cadena utilizando el algoritmo de codificación Run-length. Este
algoritmo funciona tomando la aparición de cada carácter repetitivo y emitiendo ese número junto con un único carácter de la secuencia repetitiva. Por ejemplo: "wwwggopp"
devolvería3w2g1o2p. La cadena no contendrá números, signos de puntuación ni símbolos.
Ejemplos
Entrada: "aabbcde"
Salida: 2a2b1c1d1e
Entrada: "wwwbbbw"
Salida: 3w3b1w
function RunLength(str) {
strarr = str.split("");
resarr = []; //un lugar para poner mis resultados a medida que se determinan;
arrlen = strarr.length;
cuenta = 1;
for (var i = 0; i <strarr.length; i++) {
if (strarr[i] == strarr[i+1]) {
cuenta ++;
}
si no {
var entry = count + strarr[i];
resarr.push(count + strarr[i]);
cuenta = 1;
}
}
return resarr.join("");

RunLength(readline());
Motor principal
Que la funciónPrimeMover(num) devuelva el número primonum. El rango será de 1 a 10^4. Por ejemplo: sinum es 16 la salida debería ser53 ya que 53 es el 16º número primo.
Ejemplos
Entrada: 9
Salida: 23
Entrada: 100
Salida: 541
function PrimeMover(num) {
var contador = 0;
var testNum = 0;
while (contador < num) {

if (primeTest(testNum + 1)) {
contra++;
}
testNum++;
}
return testNum
function primeTest(int) {
if (int === 1) {
devolver false
}
else if (int === 2) {
devolver true
}
si no {
var i = 2;
var pivote = Math.ceil(Math.sqrt(int));
while (i <= pivot) {
if (int % i === 0) {
devolver false
}
i++;
}
devolver true
}
}
}

PrimeMover(readline());
Palíndromo Dos
Haz que la funciónPalindromeTwo(str) tome el parámetrostr que se le pasa y devuelva la cadenatrue si el parámetro es un palíndromo, (la cadena es la misma hacia delante
que hacia atrás) en caso contrario devuelve la cadenafalse. El parámetro introducido puede tener signos de puntuación y símbolos, pero no deben afectar a si la cadena es en realidad
un palíndromo. Por ejemplo: "Anne, voto más coches carrera Roma-Viena" debería devolver true.
Ejemplos
Entrada: "Noel - ve Leon"
Salida: true
Entrada: "¡Una guerra en Tarawa!"

Salida: true
function PalíndromoDos(str) {
var str = str.toLowerCase();
var strlen = str.length;
var arr = str.split("")
var newarr = [];
var x;
for (var i = 0; i < strlen; i++) {
if (arr[i].charCodeAt(0) > 96 && arr[i].charCodeAt(0)< 123) {
newarr.push(arr[i]);
}
}
for (var j = 0; j < newarr.length; j++) {

if (newarr[j] != newarr[newarr.length - j - 1]) {
x = falso;
romper;
}
si no {
x = verdadero;
}
}
devolver x;
}

PalíndromoDos(readline());
División
Haz que la funciónDivisión(num1,num2) tome los dos parámetros pasados y devuelva elMáximo Común Factor. Es decir, devuelve el mayor número que entre uniformemente
en ambos números sin resto. Por ejemplo: 12 y 16 son ambos divisibles por 1, 2 y 4 por lo que la salida debería ser 4. El rango para ambos parámetros será de 1 a 10^3.
Ejemplos
Entrada: 7 & num2 = 3
Salida: 1

Salida: 18
function División(num1,num2) {
var bignum = Math.max(num1, num2);
var smallnum = Math.min(num1, num2);
for (var i = 1; i <= smallnum; i++) {

if (bignum%i == 0 && smallnum%i == 0) {
var maxi = i;
}
}
devolver maxi;

División(readline());
Revuelto de cuerdas
Haga que la funciónStringScramble(str1,str2) tome los dos parámetros que se le pasan y devuelva la cadenatrue si una parte de los caracteres destr1 se pueden reordenar
para que coincidan con los destr2, en caso contrario devuelva la cadenafalse. Por ejemplo: sistr1 es "rkqodlw" ystr2 es "world" la salida debería devolvertrue. Los signos de
puntuación y los símbolos no se introducirán con los parámetros.
Ejemplos
Entrada: "cdore" & str2= "coder"
Salida: true
Entrada: "h3llko" & str2 = "hola"

Salida: false
function StringScramble(str1,str2) {
//primero, pasar las cadenas a minúsculas y ponerlas en matrices para su manipulación
arr1 = str1.toLowerCase().split("");
arr2 = str2.toLowerCase().split("");
//a continuación, ordena las matrices por orden alfabético

arr1.sort();
arr2.sort();
//recorrer arr2, comprobando si cada letra está en arr1, y eliminándola de

//arr2 y él y todas las letras anteriores de arr1.
var j = 0;
while (j < arr1.length) {
if (arr2[0] == arr1[j]) {
arr2.shift();
arr1.splice(0,j+1);
j = 0;
}
si no {
j++;
}
}
if (arr2 == "") {
devuelve true;
}
si no{
devolver falso;
}

StringScramble(readline());
Arith Geo II
Haga que la funciónArithGeoII(arr) tome la matriz de números almacenada enarr y devuelva la cadena"Aritmética" si la secuencia sigue un patrón aritmético o
devuelva"Geométrica" si sigue un patrón geométrico. Si la secuencia no sigue ninguno de los dos patrones devuelve -1. Una secuencia aritmética es aquella en la que la diferencia
entre cada uno de los números es constante, mientras que en una secuencia geométrica, cada término después del primero se multiplica por alguna constante o razón común. Ejemplo
aritmético: [2, 4, 6, 8] y Ejemplo geométrico: [2, 6, 18, 54]. Se pueden introducir números negativos como parámetros, no se introducirá 0 y ninguna matriz contendrá todos los
mismos elementos.
Ejemplos
Entrada: [5,10,15]
Salida: Aritmética
Entrada: [2,4,16,24]
Salida: -1
function ArithGeoII(arr) {
var len = arr.length;
//establecer la relación entre dos elementos consecutivos de la matriz
var mathConstant = arr[1] - arr[0];
var geoConstant = arr[1] / arr[0];
//comprueba el array para ver si la diferencia entre elementos es la misma entre
cada par de elementos consecutivos. Si algún par falla, establece la bandera a true
y abandona
for (var i = 0; i < len - 1; i++) {
if (arr[i + 1] - arr[i] !== mathConstant) {
var mathTest = true;
romper;
}
}
//si el bucle anterior llegó hasta el final, entonces devuelve la respuesta
"Aritmética". Si no, entonces recorre el array probando cada par. Si algún par
falla, devuelve -1 ya que ha fallado ambas pruebas. Si llega hasta el final,
devuelve 'Geométrico'.
if (!mathTest) {
devolver 'Aritmética';
}
si no {
for (var j = 0; j < len - 1; j++) {
if (arr[j + 1] / arr[j] !== geoConstant) {
Devuelve -1;
}
}
return 'Geométrico';
}
}

ArithGeoII(readline());
Suma de matrices
Haga que la funciónArrayAddition(arr) tome la matriz de números almacenada enarr y devuelva la cadenatrue si cualquier combinación de números de la matriz (excluyendo
el número mayor) puede sumarse hasta igualar elnúmero mayor de la matriz, en caso contrario devuelva la cadenafalse. Por ejemplo: siarr contiene [4, 6, 23, 10, 1, 3] la salida
debería devolververdadero porque 4 + 6 + 10 + 3 = 23. La matriz no estará vacía, no contendrá todos los elementos iguales y puede contener números negativos.
Ejemplos
Entrada: [5,7,16,1,2]
Salida: false
Entrada: [3,5,-1,8,12]
Salida: true
function ArrayAddition(arr) {
var objetivo;
var addArr = arrayPrep(arr);
var len = addArr.length;
var permNum = Math.pow(2, len);
for(var i = 0; i <= permNum; i++) {

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

ArrayAddition(readline());
Conversor binario
Que la funciónBinaryConverter(str) devuelva la forma decimal del valor binario. Por ejemplo: si se pasa101 se devuelve5, o si se pasa1000 se devuelve8.
Ejemplos
Entrada: "100101"
Salida: 37
Entrada: "011"
Salida: 3
function BinaryConverter(str) {
var contador = 0;
var numleng = str.length;
for (var i = numleng-1; i >= 0; i--) {

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

BinaryConverter(readline());
Recuento de letras
Haga que la funciónLetterCount(str) tome el parámetrostr pasado y devuelva la primera palabra con el mayor número de letras repetidas. Por ejemplo: "Today, is the greatest
day ever!" debería devolvergreatest porque tiene 2 e (y 2 t) y va antes deever, que también tiene 2 e. Si no hay palabras con letras repetidas devuelve -1. Las palabras irán separadas
por espacios.
Ejemplos
Entrada: "Hola tarta de manzana"
Salida: Hola
Entrada: "Sin palabras"

Salida: -1
function LetterCount(str) {
str = str.replace(/[^a-zA-zs]/g, "");

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

for (var i = 0; i < wordarr.length; i++) { //por cada palabra de la cadena
var scorearr = [];
for (var j = 0; j < wordarr[i].length; j++) { //por cada letra de la palabra
var count = 0;
var x = wordarr[i].charAt(j);
for (var k = 0; k < wordarr[i].length; k++) {
if (wordarr[i][k] === x) {
cuenta++;
}
}
scorearr.push(count);
}
scorearr.sort(function(a, b) {return (b-a)});
totescore[wordarr[i]] = scorearr[0];
var newarr = [];
}
for (var cnt in totescore) {
newarr.push([cnt, totescore[cnt]]);
newarr.sort(function(a, b) {return b[1] - a[1]});
}
if (newarr[0][1] === 1) {
Devuelve -1;
}
si no {
return newarr[0][0];
}

LetterCount(readline());
Cifrado César
Haga que la funciónCaesarCipher(str,num) tome el parámetrostr y realice un desplazamiento Caesar Cipher sobre él usando el parámetro num como número de
desplazamiento. Un cifrado César funciona desplazando cada letra de la cadena N lugares hacia abajo en el alfabeto (en este caso N será num). La puntuación, los espacios y las
mayúsculas deben permanecer intactos. Por ejemplo, si la cadena es "Caesar Cipher" y num es2, la salida debería ser "Ecguct Ekrjgt".
Ejemplos
Entrada: "Hola" & num = 4
Salida: Lipps
Entrada: "abc" & num = 0

Salida: abc
function CaesarCipher(str,num) {
var arr = str.split("");
for (var i = 0; i < str.length; i++) {
var x = arr[i].charCodeAt(0);
if (x > 64 && x < 91) {

x = x - 65;
x = x + num;
x = x%26;
x = x + 65;
arr[i] = String.fromCharCode(x);
}
else if (x > 96 && x < 123) {
x = x - 97;
x = x + num;
x = x%26;
x = x + 97;
arr[i] = String.fromCharCode(x);
}
si no {
}
var y = arr.join("");
devolver y;

CaesarCipher(readline());
Modo sencillo
Haga que la funciónSimpleMode(arr) tome la matriz de números almacenados enarr y devuelva el número que aparece con más frecuencia (el modo). Por ejemplo: si arr
contiene [10, 4, 5, 2, 4] la salida debería ser4. Si hay más de un modo devuelve el que apareció primero en la matriz(es decir,[5, 10, 10, 6, 5] debería devolver5 porque apareció
primero). Si no hay modo devuelve-1. La matriz no estará vacía.
Ejemplos
Entrada: [5,5,2,2,1]
Salida: 5
Entrada: [3,4,1,6,10]
Salida: -1
function SimpleMode(arr) {
len = arr.longitud;
var newobj = {};
var testarr = [];
for (var i = len-1; i >= 0; i--) {
count = 0;
for (var j = 0; j < len; j++) {
if (arr[j] === arr[i]) {
cuenta++;
}
}
nuevoobj[arr[i]] = count;
}
for (x in nuevoobj) {
testarr.push([x, nuevoobj[x]]);
}
testarr.sort(function(a, b) {return b[1] - a[1]});
if (testarr[0][1] === 1) {
devolver -1
}
si no {
return testarr[0][0];
}

SimpleMode(readline());
Consecutivo
Haz que la funciónConsecutivo(arr) tome la matriz de enteros almacenada enarr y devuelva el número mínimo de enteros necesarios para que el contenido de arr sea
consecutivo desde el número más bajo hasta el más alto. Por ejemplo: Siarr contiene [4, 8, 6] entonces la salida debería ser2 porque hay que añadir dos números a la matriz (5 y 7)
para convertirla en una matriz consecutiva de números del4 al8. Se pueden introducir números negativos como parámetros y ninguna matriz tendrá menos de 2 elementos.
Ejemplos
Entrada: [5,10,15]
Salida: 8
Entrada: [-2,10,4]
Salida: 10
function Consecutivo(arr) {
const onceArray = Array.from(new Set(arr))
.sort((val1, val2) => val1 - val2);
const finalIndex = onceArray.length - 1;
return onceArray[finalIndex] - onceArray[0] - (onceArray.length - 1);
}

Consecutivo(readline());
División formateada
Haga que la funciónFormattedDivision(num1,num2) tome los dos parámetros que se le pasan, dividanum1 pornum2 y devuelva el resultado como una cadena con comas
formateadas correctamente y 4 dígitos significativos después del decimal. Por ejemplo: si num1 es123456789 ynum2 es10000 la salida debería ser"12,345.6789". La salida debe
contener un número en el lugar del uno aunque sea un cero.
Ejemplos
Salida: 0.6667

Salida: 1.0000
function FormattedDivision(num1,num2) {
//Esto resuelve la mayor parte del problema en un solo paso.
var divisiónResultado = (num1 / num2).toFixed(4);
//dividir la cadena en una matriz con dos elementos: entero, decimal
var numParts = divisionResultado.split('.');
var intArray = numParts[0].split('');
var len = intArray.length;
var intString;
for (var i = len; i > 0; i--) {

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

FormattedDivision(readline());
Contar los minutos
Haga que la funciónCountingMinutes(str) tome el parámetrostr que se le pasa que serán dos horas (cada una formateada correctamente con dos puntos y am o pm) separadas
por un guión y devuelva el número total de minutos entre las dos horas. La hora tendrá un formato de reloj de 12 horas. Por ejemplo: si str es9:00am-10:00am entonces la salida
debe ser 60. Sistr es 1:00pm-11:00am la salida debería ser1320.
Ejemplos
Entrada: "12:30pm-12:00am"
Salida: 690
Entrada: "1:23am-1:08am"
Salida: 1425
function ContandoMinutos(str) {
const tester = /(\d+):(\d+)([pa]m)-(\d+):(\d+)([pa]m)/;
const timeArray = str.match(tester);
const time1 = timeArray[3] === 'am'
? (parseInt(timeArray[1], 10) * 60) + parseInt(timeArray[2], 10)
: (parseInt(timeArray[1], 10) * 60) + parseInt(timeArray[2], 10) + 720;
const time2 = timeArray[6] === 'am'
? (parseInt(timeArray[4], 10) * 60) + parseInt(timeArray[5], 10)
: (parseInt(timeArray[4], 10) * 60) + parseInt(timeArray[5], 10) + 720;
return ((tiempo2 - tiempo1) + 1440) % 1440;
}

ContandoMinutos(readline());
Paso de permutación
Que la funciónPermutationStep(num) tome el parámetronum que se le pasa y devuelva el siguiente número mayor quenum usando los mismos dígitos. Por ejemplo: sinum es
123 devuelve132, si es 12453 devuelve12534. Si un número no tiene permutaciones mayores, devuelve -1(es decir, 999).
Ejemplos
Entrada: 11121
Salida: 11211
Entrada: 41352
Salida: 41523
function PermutacionPaso(num) {
var numArray = num.toString().split('').reverse();
numArray = numArray.map(function(val) {
return parseInt(val);
})
var test = true;
var len = numArray.length;
newArray = [];
while(prueba) {
if (!newArray[0]) {
nuevaMatriz[0] = numMatriz.shift();
}
else if (newArray.every(function(val) {
return val <= numArray[0];
})) {
newArray.push(numArray.shift())
}
si no {
if (!numArray[0]) {
devuelve '-1';
}
test = false;
}
}
newArray.sort(function(a, b) {return a - b});
var numHolder = numArray.shift();
for (var i = 0; i < newArray.length; i++) {

if (newArray[i] > numHolder) {
numArray.unshift(newArray[i]);
newArray[i] = numHolder;
romper;
}
}
newArray.sort(function(a, b) {return b - a});
var resultArray = newArray.concat(numArray);
return resultArray.reverse().join('');
}
PermutaciónPaso(readline());
Prime Checker
Haz que la funciónPrimeChecker(num) tomenum y devuelva 1si algún arreglo denum resulta ser un número primo, en caso contrario devuelve 0. Por ejemplo: sinum es 910, la
salida debería ser 1porque 910 se puede ordenar en 109 o 019, ambos primos.
Ejemplos
Entrada: 98
Salida: 1
Entrada: 598
Salida: 1
function PrimeChecker(num) {
//la función initialize convierte el número en una matriz de n! matrices de 2
elementos, donde n es el número de dígitos de num.
//El array tiene la forma ['',['1', '2', '3']].
workingArray = inicializar(num);
var arrayLen = workingArray.length;
while (workingArray[0][1].length > 0){

//permStep es la función que mueve los dígitos a sus lugares de forma ordenada,
dando como resultado
//una matriz de n! elementos de la forma ['123',[]].
permStep(workingArray);
}
//esto ordena los elementos del array.
workingArray = workingArray.map(function(val){
devolver val[0];
});
//primeTest es una función que convierte cada elemento de la matriz en una cadena
y comprueba si es primo.
for (var i = 0, WAlen = workingArray.length; i < WAlen; i++){
if (primeTest(workingArray[i])){
Devuelve 1;
}
}
devolver 0
function inicializar(num) {
var arr = num.toString().split('')
var resArr = [];
for (var i = 0, len = factorial(arr.length); i < len; i++) {
resArr.push(['', arr]);
}
devolver resArr;
}
function factorial(num) {
if (num <= 1) {
Devuelve 1;
}
si no {
return num * factorial(num - 1)
}
}
function permStep(arr) {
var contador = 0;
var len = arr[0][1].length;
while (contador < arrayLen) {
var targetArray = arr[counter][1];
for (var i = 0; i < len; i++) {
for (var j = 0; j < factorial(len - 1); j++){
var copyArray = targetArray.map(function(val){
devolver val;
});
var titular = copyArray.splice(i, 1);
arr[contador][0] = arr[contador][0].concat(titular[0]);
arr[contador][1] = copyArray;
contra++;
}
}
}
devolver arr;
}
function primeTest(cadenaNum) {
stringNum = parseInt(stringNum);
pivote = Math.ceil(Math.sqrt(stringNum));
if (stringNum === 1) {
devolver falso;
}
if (stringNum === 2) {
devuelve true;
}
si no {
for (var i = 2; i <= pivote; i++) {
if (stringNum % i === 0) {
devolver falso;
}
}
devuelve true;
}
}
}

PrimeChecker(readline());
Inserto para salpicadero II
Haga que la funciónDashInsertII(str) inserte guiones ('-') entre cada dos números impares e inserte asteriscos ('*') entre cada dos números pares en str. Por ejemplo: sistr
es4546793 la salida debería ser454*67-9-3. No cuentes el cero como un número par o impar.
Ejemplos
Entrada: 99946
Salida: 9-9-94*6
Entrada: 56647304
Salida: 56*6*47-304
function DashInsertII(num) {
const resString = num.toString(10);
devolver resString
.replace(/([2468])(?=[2468])/g, '$1*')
.replace(/([13579])(?=[13579])/g, '$1-');
}

DashInsertII(readline());
Intercambio II
Haz que la funciónSwapII(str) tome el parámetrostr e intercambie las mayúsculas y minúsculas de cada carácter. A continuación, si una letra se encuentra entre dos números
(sin separación), intercambia los lugares de los dos números. Por ejemplo: si str es "6Hello4 -8World, 7 yes3" la salida debería ser4hELLO6 -8wORLD, 7 YES3.
Ejemplos
Entrada: "Hola -5LOL6"
Salida: hELLO -6lol5
Entrada: "2S 6 du5d4e"

Salida: 2s 6 DU4D5E
deja a los ayudantes;
function SwapII(str) {
const switchString = helpers.caseSwap(str);
return switchString.replace(/(\d)([A-Za-z]+)(\d)/g, '$3$2$1');
}
ayudantes = {
caseSwap(str) {
devolver str
.split('')
.map((letra) => {
if (/[A-Z]/.test(letra)) {
return letra.minúscula();
}
return letra.mayúsculas();
})
.join('');
}
};

SwapII(readline());
Búsqueda de números
Haga que la funciónNumberSearch(str) tome el parámetrostr, busque todos los números de la cadena, los sume y, a continuación, devuelva ese número final dividido por la
cantidad total de letras de la cadena. Por ejemplo: sistr es "Hello6 9World 2, Nic8e D7ay!" la salida debería ser2. Primero si sumas todos los números, 6 + 9 + 2 + 8 + 7 obtienes 32.
Entonces hay 17 letras en la cadena. 32 / 17 = 1,882, y la respuesta final debe redondearse al número entero más próximo, por lo que la respuesta es 2. Sólo se utilizarán números de
un dígito separados por espacios a lo largo de toda la cadena (por lo que nunca se dará el caso: hola44444 mundo). Cada cadena también tendrá al menos una letra.
Ejemplos
Entrada: "H3ello9-9"
Salida: 4
Entrada: "Un número*1*"

Salida: 0
function BúsquedaNúmero(str) {
var matchArr = str.match(/d/g);
if (matchArr) {
var matchArr = matchArr.map(function(val) {
});
var sum = matchArr.reduce(function(post, pre){
devolver pre + post
});
}
si no {
var suma = 0;
}
var letraArr = str.match(/[a-zA-Z]/g);
return Math.round(suma / letraArr.longitud);

BúsquedaNumérica(readline());
Triple Doble
Haz que la funciónTripleDoble(num1,num2) tome los dos parámetros que se le pasan y devuelva 1si hay un triple recto de un número en cualquier lugar denum1 y también un
doble recto del mismo número ennum2. Por ejemplo: sinum1 es igual a451999277 ynum2 es igual a41177722899, entonces devuelve 1porque en el primer parámetro tienes el triple
recto999 y tienes un doble recto,99, del mismo número en el segundo parámetro. Si no es así, devuelve 0.
Ejemplos
Entrada: 465555 & num2 = 5579
Salida: 1
Entrada: 67844 & num2 = 66237

Salida: 0
function TripleDoble(num1,num2) {
var holdArr = []
num1 = num1.toString();
for (var i = 0; i <= 9; i++) {
i = i.toString();
var regEx = nuevo RegExp (i+i+i);
if (regEx.test(num1)){
holdArr.push(i);
}
}
if (holdArr === []) {

console.log(holdArr)
Devuelve 0;
}
si no {
for (var j = 0, len = holdArr.length; j < len; j++){
var double = new RegExp (holdArr[j] + holdArr[j]);
console.log(doble);
if (double.test(num2)) {
Devuelve 1;
}
}
Devuelve 0;
}
console.log(holdArr);
}

TripleDoble(readline());
Emparejador de brackets
Haga que la funciónBracketMatcher(str) tome el parámetrostr que se le pasa y devuelva 1si los corchetes se emparejan correctamente y se tiene en cuenta cada uno de ellos.
En caso contrario, devuelve 0. Por ejemplo: sistr es "(hola (mundo))", entonces la salida debería ser 1, pero sistr es "((hola (mundo))" la salida debería ser 0porque los paréntesis no
coinciden correctamente. Sólo se utilizarán "(" y ")" como paréntesis. Si str no contiene corchetes devuelve 1.
Ejemplos
Entrada: "(codificador)(byte))"
Salida: 0
Entrada: "(c(oder)) b(yte)"

Salida: 1
function BracketMatcher(str) {
var strArray = str.split('');
var contador = 0;
for (var i = 0, len = strArray.length; i < len; i++) {
if (strArray[i] === "(") {
contra++;
}
else if (strArray[i] === ")") {
contra..;
}
if (contador < 0) {
Devuelve 0;
}
}
if (contador === 0) {
Devuelve 1;
}
Devuelve 0;
}

BracketMatcher(readline());
Reducción de cadenas
Que la funciónStringReduction(str) tome el parámetrostr que se le pasa y devuelva el número más pequeño que se puede obtener mediante el siguiente método de reducción.
El método es: Sólo las letras a, b, y c se darán enstr y usted debe tomar dos caracteres adyacentes diferentes y sustituirlo por el tercero. Por ejemplo, "ac" puede sustituirse por "b",
pero "aa" no puede sustituirse por nada. Este método se repite hasta que la cadena no se puede reducir más y se debe mostrar la longitud de la cadena resultante. Por ejemplo: si str es
"cab", "ca" se puede reducir a "b" y se obtiene "bb" (también se puede reducir a "cc"). La reducción se realiza para que la salida sea 2. Sistr es "bcab", "bc" se reduce a "a", por lo que
tienes "aab", luego "ab" se reduce a "c", y la cadena final "ac" se reduce a "b" por lo que la salida debería ser 1 .
Ejemplos
Entrada: "abcabc"
Salida: 2
Entrada: "cccc"
Salida: 4
function StringReduction(str) {
while (str.match(/(ab|ba|ac|ca|bc|cb)/) != undefined) {

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

StringReduction(readline());
TresCinco Múltiplos
Que la funciónTresCincoMúltiplos(num) devuelva la suma de todos los múltiplos de 3 y 5 que estén por debajo de num. Por ejemplo: sinum es 10, los múltiplos de 3 y 5 que
están por debajo de 10 son 3, 5, 6 y 9, y sumándolos obtienes 23, por lo que tu programa debería devolver 23. El número entero que se pasa estará comprendido entre 1 y 100.
Ejemplos
Entrada: 6
Salida: 8
Entrada: 1
Salida: 0
function TresCincoMúltiplos(num) {
var arr = [];
for (var i = 0; i <= num - 1; i++) {
if (i % 3 === 0 || (i % 5 === 0 && i % 3 !== 0)) {
arr.push(i);
}
}
return arr.reduce(function(hold, val) {
return hold + val;
});
}

TresCincoMúltiplos(readline());
Árbol de búsqueda binaria LCA
Haga que la funciónBinarySearchTreeLCA(strArr) tome el array de cadenas almacenado enstrArr, que contendrá 3 elementos: el primer elemento será un árbol de
búsqueda binario con todos los valores únicos en un array derecorrido preordenado , el segundo y tercer elemento serán dos valores diferentes, y su objetivo es encontrar el ancestro
común más bajo de estos dos valores. Por ejemplo: sistrArr es ["[10, 5, 1, 7, 40, 50]", "1", "7"] entonces este árbol tiene el siguiente aspecto:
Para la entrada anterior, su programa debería devolver5 porque ese es el valor del nodo que es el LCA de los dos nodos con valores 1 y 7. Puede suponer que los dos nodos que busca
en el árbol existirán en algún lugar del mismo.
Ejemplos
Entrada: ["[10, 5, 1, 7, 40, 50]", "5", "10"]
Salida: 10
Entrada: ["[3, 2, 1, 12, 4, 5, 13]", "5", "13"]

Salida: 12
function BinarySearchTreeLCA(strArr) {
//toma el primer elemento de la matriz de argumentos y conviértelo en una matriz
de enteros
let nodeArray = strArr[0]
.replace(/[[]]/g, '')
.split(/,s/)
.map(val => parseInt(val, 10));
//toma los otros elementos de la matriz de argumentos y conviértelos en enteros

let num1 = parseInt(strArr[1], 10);
//encuentra las posiciones de los números dados en la matriz de números

let ind1 = nodeArray.findIndex(val => val === num1);
let ind2 = nodeArray.findIndex(val => val === num2);
//determinar la más lejana de las dos posiciones, no nos interesan elementos

pasados que
let bordeDerecho = Math.max(ind1, ind2);
//ver si hay algún elemento a la izquierda de rightEdge que parta los dos números
dados, esa será la respuesta
let result = nodeArray.filter((val, ind) => (val >= Math.min(num1, num2) && val
<= Math.max(num1, num2) && ind <= rightEdge));
//si no hay ninguno, entonces devuelve el elemento que está más a la izquierda
if (result.length === 0) return ind1 < ind2 ? strArr[1] : strArr[2];
//si lo hay, devuélvelo como cadena

return resultado[0].toString();
}

BinarySearchTreeLCA(readline());
Determinador de monedas
Haga que la funciónCoinDeterminer(num) tome la entrada, que será un número entero comprendido entre 1 y 250, y devuelva una salida entera que especifique el menor número
de monedas que, sumadas, sean iguales al número entero de entrada. Las monedas se basan en un sistema como el siguiente: hay monedas que representan los números enteros 1, 5, 7,
9 y 11. Así por ejemplo: sinum es 16, entonces la salida debería ser2 porque se puede conseguir el número 16 con las monedas 9 y 7. Sinum es 25, entonces la salida debería ser3
porque se puede conseguir 25 con 11, 9 y 5 monedas o con 9, 9 y 7 monedas.
Ejemplos
Entrada: 6
Salida: 2
Entrada: 16
Salida: 2
function CoinDeterminer(num) {
var arr = [0, 1, 2, 3, 4, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 3, 2, 3, 2, 2, 3, 2, 3,

2]
si (num <= 22) {

return arr[num]
}
si no {
var vueltas = Math.floor((num - 11) / 22) * 2;
var resto = num - (vueltas * 11);
si (resto > 22) {
gira++;
permanecen -= 11;
}
return vueltas + arr[resto];
}
}

CoinDeterminer(readline());
Comprobador Fibonacci
Que la funciónFibonacciChecker(num) devuelva la cadenayes si el número dado forma parte de la secuencia de Fibonacci. Esta secuencia se define por: Fn = Fn-1 + Fn-2, lo
que significa que para hallar Fn se suman los dos números anteriores. Los dos primeros números son 0 y 1, luego vienen 1, 2, 3, 5, etc. Si num no está en la secuencia Fibonacci,
devuelve la cadenano.
Ejemplos
Entrada: 34
Salida: sí
Entrada: 54
Salida: no
function FibonacciChecker(num){
var semilla1 = 0;
var semilla2 = 1;
var contador = 0;
while (contador < num) {
contador = semilla1 + semilla2;
if (contador === num) {
devuelve "sí";
}
semilla1 = semilla2;
semilla2 = contador;
}
devolver "no";
}

FibonacciChecker(readline());
Soportes múltiples
Haz que la funciónParéntesisMúltiples(str) tome el parámetrostr que se le pasa y devuelva1 #deParéntesis si los paréntesis coinciden correctamente y se tiene en cuenta
cada uno de ellos. En caso contrario, devuelve 0. Por ejemplo: sistr es "(hola [mundo])(!)", entonces la salida debería ser1 3 porque todos los corchetes coinciden y hay 3 pares de
corchetes, pero sistr es "((hola [mundo])" la salida debería ser 0porque los corchetes no coinciden correctamente. Sólo "(", ")", "[" y "]" se utilizarán como paréntesis. Si str no
contiene corchetes devuelve 1.
Ejemplos
Entrada: "(codificador)[byte)]"
Salida: 0
Entrada: "(c([od]er)) b(yt[e])"

Salida: 1 5
function ParéntesisMúltiples(str) {
var regex = /[()[]]/;
if (!regex.test(str)) return 1;
var countParen = 0;
var countBrack = 0;
var countOpen = 0;
for (var i = 0, len = str.length; i < len; i++) {
switch(str.charAt(i)) {
caso '(':
countOpen++;
countParen++;
romper;
caso '[':
countOpen++;
countBrack++;
romper;
caso ')':
countParen--;
romper;
caso ']':
countBrack--;
romper;
}
if (countParen < 0 || countBrack < 0) return 0;
}
if (countParen === 0 && countBrack === 0) return ('1 ' + countOpen);
si no, devuelve 0;
}

ParéntesisMúltiples(readline());
Más tiempo libre
Haga que la funciónMostFreeTime(strArr) lea el parámetrostrArr que se le pasa, que representará un día completo y se llenará con eventos que abarcan desde la hora X hasta
la hora Y del día. El formato de cada evento seráhh:mmAM/PM-hh:mmAM/PM. Por ejemplo,strArr puede ser ["10:00AM-12:30PM", "02:00PM-02:45PM", "09:10AM-
09:50AM"]. Su programa tendrá que emitir la mayor cantidad de tiempo libre disponible entre el inicio de su primer evento y el final de su último evento en el formato: hh:mm. El
evento de inicio debe ser el evento más temprano del día y el evento más tardío debe ser el evento más tardío del día. Por lo tanto, la salida para la entrada anterior sería 01:30(con el
evento más temprano del día comenzando a las09:10AM y el evento más tardío terminando a las02:45PM). La entrada contendrá al menos 3 eventos y los eventos pueden estar fuera
de orden.
Ejemplos
Entrada: ["12:15PM-02:00PM", "09:00AM-10:00AM", "10:30AM-12:00PM"]
Salida: 00:30
Entrada: ["12:15PM-02:00PM", "09:00AM-12:11PM", "02:02PM-04:00PM"]

Salida: 00:04
función MostFreeTime(strArr) {
strArr = strArr.map(function(val) {
return convertir12a24(val);
});
strArr = strArr.map(function(val){
return convertirEnMinutos(val);
})
strArr.sort(function(a, b){
return parseInt(a.coincidencia(/d{3,4}/) - b.coincidencia(/d{3,4}/))
})
strArr = strArr.map(function(val){
valArr = val.split('-');
valArr = valArr.map(function(val){
});
devolver valArr;
});
var len = strArr.length;
var contador = 0;
for (var i = 0; i < len - 1; i++) {
var time = strArr[i+1][0] - strArr[i][1];
si (tiempo > contador) {
contador = tiempo;
}
}
return returnToTime(contador);
function returnToTime(counter){
var mins = (contador % 60).toString();
var hrs = (Math.floor(contador / 60).toString());
if (mins < 10) {
mins = '0' + mins;
}
if (hrs < 10) {
hrs = '0' + hrs;
}
return (hrs + ':' + mins);
}
function convertToMinutes(strVal) {
tempArr = strVal.split('-');
tempArr = tempArr.map(function(val){
var hrs = parseInt(val.slice(0,2));
var mins = parseInt(val.slice(3));
horas de retorno * 60 + min;
});
return tempArr.join('-');
}
function convertir12a24(strVal) {
var tempArr = strVal.split('-');
tempArr = tempArr.map(function(val){
if (/am/i.test(val)) {
val = val.replace('12', '00');
return val.slice(0, 5);
}
si no {
val = val.replace('12', '00');
var hora = parseInt(val.slice(0, 2));
val = val.slice(2);
var nuevaHora = (hora + 12).toString();
val = nuevaHora.concat(val)
return val.slice(0, 5);
}
});
return tempArr.join('-');
}
}

MostFreeTime(readline());
Rectángulos superpuestos
Haz que la funciónOverlappingRectangles(strArr) lea el parámetrostrArr que se le pasa y que representará dos rectángulos en un plano de coordenadas cartesianas y
contendrá 8 coordenadas con las 4 primeras formando el rectángulo 1 y las 4 últimas formando el rectángulo 2. Tendrá el siguiente formato: ["(0,0),(2,2),(2,0),(0,2),(1,0),(1,2),(6,0),
(6,2)"] Tu programa debe determinar el área del espacio donde los dos rectángulos se solapan, y luego mostrar el número de veces que esta región solapada puede caber en el primer
rectángulo. En el ejemplo anterior, la región superpuesta forma un rectángulo de área 2, y el primer rectángulo (las 4 primeras coordenadas) forma un rectángulo de área 4, por lo que
el programa debería dar como resultado2. Las coordenadas serán todas números enteros. Si no hay solapamiento entre los dos rectángulos devuelve 0.
Ejemplos
Entrada: ["(0,0),(0,-2),(3,0),(3,-2),(2,-1),(3,-1),(2,3),(3,3)"]
Salida: 6
Entrada: ["(0,0),(5,0),(0,2),(5,2),(2,1),(5,1),(2,-1),(5,-1)"]
Salida: 3
JAVASCRIPT
deja a los ayudantes;
const RectángulosSolapados = (strArr) => {

const rectangles = helpers.rectangArrays(strArr);
const rec1Puntos = helpers.recPuntos(rectángulos[0]);
const rec2Points = helpers.recPoints(rectángulos[1]);
// creado el objeto values para dar nombres a los lados del rectángulo para
hacerlos
// más fácil de visualizar.
const valores = {
rec1Top: rec1Puntos[1][1],
rec1Derecha: rec1Puntos[1][0],
rec1Fondo: rec1Puntos[0][1],
rec1Izquierda: rec1Puntos[0][0],
rec2Top: rec2Puntos[1][1],
rec2Derecha: rec2Puntos[1][0],
rec2Bottom: rec2Puntos[0][1],
rec2Izquierda: rec2Puntos[0][0]
};
const rec1Area = (valores.rec1Top - valores.rec1Bottom) * (valores.rec1Right -
valores.rec1Left);
/* prueba de solapamiento */
if (values.rec2Bott >= values.rec1Top ||
valores.rec1Bott >= valores.rec2Top ||
valores.rec1Izquierda >= valores.rec2Derecha ||
values.rec2Left >= values.rec1Right) {
Devuelve 0;
}
const overLapTop = Math.min(valores.rec1Top, valores.rec2Top);

const overLapBottom = Math.max(valores.rec1Bottom, valores.rec2Bottom);
const overLapRight = Math.min(valores.rec1Derecha, valores.rec2Derecha);
const overLapLeft = Math.max(valores.rec1Izquierda, valores.rec2Izquierda);
const overLapArea = (overLapTop - overLapBottom) * (overLapRight -
overLapLeft);
return overLapArea === 0 ? 0 : Math.trunc(rec1Area / overLapArea);
};
ayudantes = {
/* la función RectangArrays ta105816
kes la entrada de este problema y devuelve un
matriz de dos elementos, siendo cada elemento una matriz de los puntos de la
primera o
segundo rectángulo, respectivamente. */
rectangArrays(strArr) {
const str = strArr[0];
let bigArray = str.split('),(');
bigArray = bigArray.map((val) => {
const cleanVal = val.replace(/[()]/g, '');
const pointArray = cleanVal.split(',');
pointArray[0] = parseInt(pointArray[0], 10);
pointArray[1] = parseInt(pointArray[1], 10);
return pointArray;
});
return [bigArray.splice(0, 4), bigArray];
},
/*
la función recPuntos toma una matriz de puntos en la cuadrícula cartesiana (de
un
rectángulo alineado) y devuelve una matriz de dos puntos, que representan la
parte inferior
esquina izquierda y la esquina superior derecha del rectángulo.
*/
recPoints(arr) {
const yVals = arr.map(val => val[1]);
const xVals = arr.map(val => val[0]);
const yMin = Math.min(...yVals);
const yMax = Math.max(...yVals);
const xMin = Math.min(...xVals);
const xMax = Math.max(...xVals);
return [[xMin, yMin], [xMax, yMax]];
}
};

SuperponerRectángulos(readline());
Mirar Decir Secuencia
Haz que la funciónLookSaySequence(num) tome el parámetronum que se le pasa y devuelva el siguiente número de la secuencia según la siguiente regla: para generar el
siguiente número de una secuencialee los dígitos del número dado, contando el número de dígitos en grupos del mismo dígito. Por ejemplo, la secuencia que empieza por 1 sería: 1,
11, 21, 1211, ... El 11 viene de que hay "un 1" antes y el 21 viene de que hay "dos 1" antes. Así que su programa debe devolver el siguiente número en la secuencia dada num.
Ejemplos
Entrada: 1211
Salida: 111221
Entrada: 2466
Salida: 121426
función LookSaySequence(num) {
var numArr = prepFunc(num);
var newArr = [];
var storeArr = [];
while (numArr.length > 0) {

if (!newArr.length) {
newArr.push(numArr.shift());
if (!numArr.length) {
storeArr.push('1');
storeArr.push(newArr[0]);
return parseInt(storeArr.join(''));
}
}
else if (newArr[newArr.length - 1] === numArr[0]) {
newArr.push(numArr.shift());
if (!numArr.length) {
storeArr.push(newArr.length.toString());
return parseInt(storeArr.join(''));
}
}
si no {
storeArr.push(newArr.length.toString());
nuevoArr = [];
}
}
console.log(tiendaArr);
devolver num;
function prepFunc(num) {
var str = num.toString();
var arr = str.split('');
devolver arr;
}
}

LookSaySequence(readline());
Lista Distinta
Haga que la funciónDistinctList(arr) tome la matriz de números almacenados enarr y determine el número total de entradas duplicadas. Por ejemplo, si la entrada es [1, 2, 2,
2, 3], el programa debe mostrar2 porque hay dos duplicados de uno de los elementos.
Ejemplos
Entrada: [0,-2,-2,5,5,5]
Salida: 3
Entrada: [100,2,101,4]
Salida: 0
function DistinctList(arr) {
const strippedArr = nuevo Conjunto(arr);
return arr.length - strippedArr.size;
}
DistinctList(readline());
Codificación numérica
Haga que la funciónNumberEncoding(str) tome el parámetrostr y codifique el mensaje según la siguiente regla: codifique cada letra en su correspondiente posición numerada
del alfabeto. También se utilizarán símbolos y espacios en la entrada. Por ejemplo: si str es "af5c a#!" entonces tu programa debería devolver 16531#!.
Ejemplos
Entrada: "hola 45"
Salida: 85121215 45
Entrada: "jaj-a"
Salida: 10110-1
function CodificaciónNumérica(str) {
str = str.toLowerCase();
var arr = str.split("");
for (var i = 0; i < len; i++) {

if (/[a-z]/.test(arr[i])) {
arr[i] = arr[i].replace(arr[i].charAt(0), (arr[i].charCodeAt(0) -
96).toString());
}
}
str = arr.join("");
devolver str;

NumberEncoding(readline());
Selector de valores
Haga que la funciónStockPicker(arr) tome la matriz de números almacenada enarr que contendrá enteros que representan la cantidad en dólares que vale una sola acción, y
devuelva el beneficio máximo que se podría haber obtenido comprando acciones el día x y vendiendo acciones el díay dondey>x. Por ejemplo: siarr es [44, 30, 24, 32, 35, 30, 40, 38,
15] entonces su programa debería devolver 16porque en el índice 2 la acción valía 24 $ y en el índice 6 la acción valía entonces 40 $, por lo que si compró la acción a 24 y la vendió a
40, habría obtenido un beneficio de 16 $, que es el beneficio máximo que podría haber obtenido con esta lista de precios de acciones.
Si no hay beneficios que podrían haberse obtenido con los precios de las acciones, entonces su programa debería devolver -1. Por ejemplo:arr es [10, 9, 8, 2] entonces tu programa
debería devolver-1.
Ejemplos
Entrada: [10,12,4,5,9]
Salida: 5
Entrada: [14,20,4,12,5,11]
Salida: 8
function StockPicker(arr) {
var maxProfit = 0;
while (arr.length > 1) {

var start = arr.shift();
var max = Math.max.apply(null, arr);
var beneficio = max - inicio;
if (profit > maxProfit) {
maxProfit = beneficio;
}
}
return maxProfit === 0 ? -1 : maxProfit;

StockPicker(readline());
Submatriz Max
Haz que la funciónMaxSubarray(arr) tome la matriz de números almacenada enarr y determine la mayor suma que puede formarse por cualquier submatriz contigua de la
matriz. Por ejemplo, siarr es [-2, 5, -1, 7, -3] entonces tu programa debería devolver11 porque la suma está formada por la submatriz [5, -1, 7]. Si se añade cualquier elemento antes
o después de esta submatriz, la suma será menor.
Ejemplos
Entrada: [1, -2, 0, 3]
Salida: 3
Entrada: [3, -1, -1, 4, 3, -1]

Salida: 8
function MaxSubarray(arr) {
//utilizamos este número unas cuantas veces
let count = Math.max(...arr),
indexArray = [];
//cuidar el caso sin números positivos

if (count <= 0) {
}
//obtener una lista (indexArray) de los índices de todas las entradas positivas
arr.forEach((val, ind) => {
if (val > 0) {
indexArray.push(ind)
}
});
//sabemos que un máximo debe tener un número positivo en cada extremo de la
submatriz (si hay varios
//números positivos. Por supuesto, el subArray podría tener una longitud de uno.
Así que compara todas las posibles
//subarrays.
let leng = indexArray.length;
for (let i = 0; i < leng; i++) {
for (let j = i + 1; j < leng; j++) {
let subSumaArray = arr
.slice(indexArray[i], indexArray[j] + 1)
.reduce((val1, val2) => val1 + val2);
//actualizar el recuento si la subSumaArray es mayor
count = Math.max(count, subArraySum);
}
}
}

MaxSubarray(readline());
Dígito que falta
Haga que la funciónMissingDigit(str) tome el parámetrostr, que será una fórmula matemática simple con tres números, un único operador (+, -, *, o /) y un signo igual (=) y
devuelva el dígito que completa la ecuación. En uno de los números de la ecuación, habrá un carácter x, y tu programa deberá determinar qué dígito falta. Por ejemplo, sila cadena
es "3x + 12 = 46", el programa debería mostrar4. El carácterx puede aparecer en cualquiera de los tres números y los tres números serán mayores o iguales que 0 y menores o iguales
que 1000000.
Ejemplos
Entrada: "4 - 2 = x"
Salida: 2
Entrada: "1x0 * 12 = 1200"

Salida: 0
function MissingDigit(str) {
for (let i = 0; i < 10; i++) {
const newString = str.replace(/x/, i.toString()).replace(/=/, '===');
if (eval(nuevaCadena)) {
devolver i;
}
}
devuelve "fallido";
}

MissingDigit(readline());
K Personajes únicos
Que la funciónKUniqueCharacters(str) tome el parámetrostr que se le pasa y encuentre la subcadena más larga que contengak caracteres únicos, dondek será el primer
carácter de la cadena. La subcadena empezará en la segunda posición de la cadena porque el primer carácter será el entero k. Por ejemplo: sistr es "2aabbacbaa" hay varias
subcadenas que contienen todas 2 caracteres únicos, a saber: ["aabba", "ac", "cb", "ba"], pero su programa debería devolver "aabba" porque es la subcadena más larga. Si hay varias
subcadenas de mayor longitud, devuelve la primera subcadena encontrada con la mayor longitud. k oscilará entre 1 y 6.
Ejemplos
Entrada: "3aabacbebebe"
Salida: cbebebebe
Entrada: "2aabbcbbbadef"
Salida: bbcbbb
function KUniqueCharacters(str) {
const count = parseInt(str.slice(0,1), 10);
const asuntoCadena = str.slice(1);
const len = subjectString.length;
let maxCount = 0;
for (let i = 0; i < len; i++) {

contador = 0;
let titular = [];
let charArray = [];
for (let j = i; j < len; j++) {
let char = subjectString.charAt(j);
if (charArray.some(val => val === char)) {
holder.push(char);
contra++;
if (j === len - 1) {
if (counter > maxCount) {
resultado = Array.from (titular);
}
maxCount = Math.max(contador, maxCount);
}
continuar;
} else {
if (charArray.length < count) {
contra++;
charArray.push(char);
holder.push(char)
continuar;
} else {
resultado = Array.from(titular);
}
maxCount = Math.max(contador, maxCount);
romper;
}
}
}
}
return resultado.join('');
}

KUniqueCharacters(readline());
Agujeros Bitmap
Haz que la funciónBitmapHoles(strArr) tome la matriz de cadenas almacenadas enstrArr, que será una matriz 2D de 0 y 1's, y determine cuántos agujeros, o regiones
contiguas de 0's, existen en la matriz. Una región contigua es aquella en la que hay un grupo conectado de 0 que van en una o más de cuatro direcciones: arriba, abajo, izquierda o
derecha.
Por ejemplo: sistrArr es ["10111", "10101", "11101", "11111"], entonces esto se parece a la siguiente matriz:1 0 1 1 1 1 0 1 0 11 1 1 0 1 1 1 1 1 1Para la entrada anterior, su programa
debería devolver2 porque hay dos regiones contiguas separadas de 0's, que crean "agujeros" en la matriz. Puede suponer que la entrada no estará vacía.
Ejemplos
Entrada: ["01111", "01101", "00011", "11110"]
Salida: 3
Entrada: ["1011", "0010"]

Salida: 2
function BitmapHoles(strArr) {
const thisObj = {};
thisObj.fullArray = strArr.map(fila => fila.split(''));

thisObj.fullArray.forEach((fila, filaNum, arr) => {
row.forEach((val, colNum) => {
//puedo deshacerme de hotTest y sólo usar crawler aquí.

if (val === '1') {
} else {
arr[rowNum][colNum] = 'H';
crawler([[filaNum,columnaNum]])
}
});
});
return thisObj.fullArray.reduce((fila1, fila2) => {
return fila1.concat(fila2);
}).filter(val => val === 'H').length;
function crawler(pointsArray) {
let nuevaMatriz = [];
pointsArray.forEach(punto => {
if(punto[0] > 0 && thisObj.fullArray[punto[0] - 1][punto[1]] === '0') {

thisObj.fullArray[punto[0] - 1][punto[1]] = '1';
newArray.push([punto[0] - 1, punto[1]]);
}
if (point[0] < thisObj.fullArray.length - 1 && thisObj.fullArray[point[0]

+ 1][point[1]] === '0') {
thisObj.fullArray[punto[0] + 1][punto[1]] = '1';
newArray.push([punto[0] + 1, punto[1]]);
}
if (point[1] > 0 && thisObj.fullArray[point[0]][point[1] - 1] === '0') {

thisObj.fullArray[punto[0]][punto[1] - 1] = '1';
newArray.push([punto[0], punto[1] - 1]);
}
if (point[1] < thisObj.fullArray[0].length - 1 &&

thisObj.fullArray[point[0]][point[1] + 1] === '0') {
thisObj.fullArray[punto[0]][punto[1] + 1] = '1';
newArray.push([punto[0], punto[1] + 1]);
}
});
if (newArray.length === 0) {
volver;
}
crawler(nuevaMatriz);
}
}

BitmapHoles(readline());
Árbol simétrico
Haga que la funciónSymmetricTree(strArr) tome la matriz de cadenas almacenadas enstrArr, que representará un árbol binario, y determine si el árbol es simétrico (una
imagen especular de sí mismo). El array se implementará de forma similar a como se implementa un montón binario , excepto que el árbol puede no estar completo y los nodos NULL
en cualquier nivel del árbol se representarán con un #. Por ejemplo: sistrArr es ["1", "2", "2", "3", "#", "#", "3"] entonces este árbol tiene el siguiente aspecto:
Para la entrada anterior, su programa debería devolver la cadena true porque el árbol binario es simétrico.
Ejemplos
Entrada: ["4", "3", "4"]
Salida: false
Entrada: ["10", "2", "2", "#", "1", "1", "#"]

Salida: true
function SymmetricTree(strArr) {
dejar x = 1;
let count = 0;
while (strArr.length) {
x++;
if (x > 10) break;
let longitud = Math.pow(2, recuento);
let newArray = strArr.splice(0, longitud);
let revArray = Array.from(newArray).reverse();
if(!sameAs(newArray, revArray)) {
devolver falso;
}
count = newArray.filter(val => val !== '#').length;
}
devuelve true;
}
function sameAs(arr1, arr2) {

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

SymmetricTree(readline());
Árbol binario ACV
Haz que la funciónBinaryTreeLCA(strArr) tome el array de cadenas almacenado enstrArr, que contendrá 3 elementos: el primer elemento será un árbol binario con todos los
valores únicos en un formato similar a cómo se implementa unmontón binario con nodos NULL en cualquier nivel representado con un #, el segundo y tercer elemento serán dos
valores diferentes, y su objetivo es encontrar elmenor ancestro común de estos dos valores.
Por ejemplo: sistrArr es ["[12, 5, 9, 6, 2, 0, 8, #, #, 7, 4, #, #, #, #]", "6", "4"] entonces este árbol tiene el siguiente aspecto:
Para la entrada anterior, su programa debería devolver5 porque ese es el valor del nodo que es el LCA de los dos nodos con valores 6 y 4. Puede suponer que los dos nodos que busca
en el árbol existirán en algún lugar del mismo.
Ejemplos
Entrada: ["[5, 2, 6, 1, #, 8, #]", "2", "6"]
Salida: 5
Entrada: ["[5, 2, 6, 1, #, 8, 12, #, #, #, #, #, #, #, 3, #]", "3", "12"]

Salida: 12
function BinaryTreeLCA(strArr) {
//primero, convertir la cadena que representa el árbol en una matriz de números
let arrList = strArr[0]
.replace(/[[]]/g, '')
.split(/,s*/)
.map(val => val !== '#' ? parseInt(val, 10) : "#");
//convierte los números dados (cadenas) en números

//obtener los índices de los números dados. Esto es realmente lo que necesitamos
let ind1 = Math.max(arrList.findIndex(val => val === num1) + 1,
arrList.findIndex(val => val === num2) + 1);
let ind2 = Math.min(arrList.findIndex(val => val === num1) + 1,
arrList.findIndex(val => val === num2) + 1);
//obtener los dos números en la misma profundidad en el árbol

while (Math.trunc(Math.log2(ind1)) !== Math.trunc(Math.log2(ind2))) {
ind1 = Math.trunc(ind1 / 2);
}
//encontrar el ancestro común en el árbol

while (ind1 !== ind2) {
}
//devuelve el número correspondiente al índice determinado

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

BinaryTreeLCA(readline());
Caché LRU
Haga que la funciónLRUCache(strArr) tome la matriz de caracteres almacenada enstrArr, que contendrá caracteres que van de la A a la Z en algún orden arbitrario, y
determine qué elementos quedan aún en una caché virtual que puede contener hasta 5 elementos con un algoritmo de caché LRU implementado. Por ejemplo: sistrArr es ["A", "B",
"C", "D", "A", "E", "D", "Z"], se siguen los siguientes pasos:
(1) A no existe en la caché, así que se accede a él y se almacena en la caché.

(2) B no existe en la caché, así que accede a ella y guárdala también en la caché. Hasta ahora la caché contiene: ["A", "B"].
(3) Lo mismo para C, así que la caché es ahora: ["A", "B", "C"].
(4) Lo mismo para D, por lo que la caché es ahora: ["A", "B", "C", "D"].
(5) Ahora se vuelve a acceder a A, pero ya existe en la caché, así que se trae al frente: ["B", "C", "D", "A"].
(6) E no existe en la caché, así que se accede a él y se almacena en la caché: ["B", "C", "D", "A", "E"].
(7) Se vuelve a acceder a D, por lo que se trae al frente: ["B", "C", "A", "E", "D"].
(8) Z no existe en la caché, así que se añade al principio y se elimina el último elemento utilizado: ["C", "A", "E", "D", "Z"].
Ahora los pasos de la caché se han completado y tu programa debería devolver el orden de la caché con los elementos unidos en una cadena, separados por un guión. Por lo tanto, para
el ejemplo anterior su programa debería devolverC-A-E-D-Z.
Ejemplos
Entrada: ["A", "B", "A", "C", "A", "B"]
Salida: C-A-B
Entrada: ["A", "B", "C", "D", "E", "D", "Q", "Z", "C"]
Salida: E-D-Q-Z-C
function LRUCache(strArr) {
let caché = [];
//muy sencillo, recorrer el array dado y operar sobre la caché
strArr.forEach(val => {
if (!cache.includes(val)) {
//¡Divertido! Una de las primeras veces que he aprovechado el hecho
//que push() devuelve la longitud del array después del push, no el
//la propia matriz
if (cache.push(val) > 5) {
cache.shift();
}
} else {
cache.splice(cache.findIndex(cacheVal => val === cacheVal), 1);
cache.push(val);
}
});
return cache.join('-');

LRUCache(readline());
medio
Debate Soluciones
Constructor de árboles
Que la funciónTreeConstructor(strArr) tome el array de cadenas almacenado enstrArr, que contendrá pares de enteros con el siguiente formato:(i1,i2), dondei1 representa
un nodo hijo en un árbol y el segundo enteroi2 significa que es el padre dei1. Por ejemplo: sistrArr es ["(1,2)", "(2,4)", "(7,2)"], entonces esto forma el siguiente árbol:
que puedes ver que forma un árbol binario correcto. Su programa debería, en este caso, devolver la cadena true porque se puede formar un árbol binario válido. Si no se puede formar
un árbol binario adecuado con los pares de enteros, entonces devuelve la cadena false. Todos los enteros dentro del árbol serán únicos, lo que significa que sólo puede haber un nodo
en el árbol con el valor entero dado.
Ejemplos
Entrada: ["(1,2)", "(2,4)", "(5,7)", "(7,2)", "(9,5)"]
Salida: true
Entrada: ["(1,2)", "(3,2)", "(2,12)", "(5,2)"]

Salida: false
//el siguiente método desecha los árboles que no superan alguna de las tres pruebas
siguientes: i) sólo hay un nodo superior, ii) ¿algún nodo tiene más de
//más de 2 hijos, o iii) se repiten los valores de algún nodo. Si supera todas estas
pruebas, debería representar un árbol binario.
function TreeConstructor(strArr) {
//eliminar espacios de la entrada (una de las pruebas tenía una entrada
defectuosa)
strArr = strArr.map(val => val.replace(/s/g, ''));
let regExChildPattern = /((d+),d+)/

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

let parents = strArr.map(val => regExParentPattern.exec(val)[1]);
//comprobar que todos los hijos son únicos

let childSet = new Set(children);
if (children.length !== childSet.size) {
devolver falso;
}
//comprobar si algún nodo padre tiene más de 2 hijos

let parentObj = {};
parents.forEach(val => {
if (!parentObj[val]) {
parentObj[val] = 1;
} else {
parentObj[val]++;
}
})
for (let myKey in parentObj) {
if (parentObj[myKey] > 2) return false;
}
//asegúrate de que hay un, y sólo un, perro superior

let uniqParents = Array.from(new Set(padres))
let topDogs = uniqParents.filter(val => !children.includes(val));

if (topDogs.length !== 1) return false;
devuelve true;

TreeConstructor(readline());
Array Min Saltos
Que la funciónArrayMinJumps(arr) tome el array de enteros almacenados enarr, donde cada entero representa el número máximo de pasos que se pueden dar desde esa
posición, y determine la menor cantidad de saltos que se pueden dar para llegar al final del array. Por ejemplo: si arr es [1, 5, 4, 6, 9, 3, 0, 0, 1, 3] entonces tu programa debería
mostrar el número3 porque puedes llegar al final del array desde el principio mediante los siguientes pasos: 1 -> 5 -> 9 -> FIN o
1 -> 5 -> 6 -> FIN. Ambas combinaciones producen una serie de 3 pasos. Y como puedes ver, no siempre tienes que dar el máximo número de saltos en una posición concreta, puedes
dar menos saltos aunque el número sea mayor.
Si no es posible llegar al final del array, devuelve-1.
Ejemplos
Entrada: [3, 4, 2, 1, 1, 100]
Salida: 2
Entrada: [1, 3, 6, 8, 2, 7, 1, 2, 1, 2, 6, 1, 2, 1, 2]
Salida: 4
function ArrayMinSaltos(arr) {
const nuevoArr = Array.from(arr);
const len = nuevaArr.longitud;
for (let i = len - 1; i >= 0; i--) {
const toGo = len - (i + 1);
const alcance = nuevoArr[i];
if (toGo === 0) {
nuevoArr[i] = {
ind: i,
movimientos: 0
};
} else if (reach >= toGo) {
nuevoArr[i] = {
ind: i,
movimientos: 1
};
} else {
const subArr = nuevoArr.slice(i + 1);
const subArrLen = subArr.length;
const countHolder = [];
for (let j = 0; j < subArrLen; j++) {
if (typeof subArr[j] === 'object' && newArr[i] > j) {
countHolder.push(subArr[j].moves);
}
}
if (countHolder.length) {
nuevoArr[i] = {
ind: i,
mueve: Math.min(...countHolder) + 1
};
}
}
}
return typeof newArr[0].moves === 'undefined' ? -1 : nuevoArr[0].movimientos;
}

ArrayMinJumps(readline());
Valores menores más cercanos
Haz que la funciónNearestSmallerValues(arr) tome la matriz de enteros almacenada enarr, y para cada elemento de la lista, busque en todos los valores anteriores el
elemento más cercano que sea más pequeño que el elemento actual y cree una nueva lista a partir de estos números. Si no hay ningún elemento antes de una posición determinada que
sea más pequeño, introduzca un-1. Por ejemplo: siarr es [5, 2, 8, 3, 9, 12] entonces la lista de valores menores más cercana es [-1, -1, 2, 2, 3, 9]. La lógica es la siguiente:
Para 5, no hay ningún valor anterior más pequeño por lo que la lista hasta ahora es [-1]. Para 2, tampoco hay un valor anterior más pequeño, por lo que la lista es ahora [-1, -1]. Para 8,
el valor menor más cercano es 2, por lo que la lista es ahora [-1, -1, 2]. Para 3, el valor menor más cercano es también 2, por lo que la lista es ahora [-1, -1, 2, 2]. Esto da lugar a la
respuesta anterior. Tu programa debería tomar esta lista final y devolver los elementos como una cadena separada por un espacio: -1 -1 2 2 3 9
Ejemplos
Entrada: [5, 3, 1, 9, 7, 3, 4, 1]
Salida: -1 -1 -1 1 1 1 3 1
Entrada: [2, 4, 5, 1, 7]
Salida: -1 2 4 -1 1
function ValoresMásCercanos(arr) {
const resultadosMatriz = [];
arr.forEach((val, ind) => {
const preArray = arr.slice(0, ind).reverse();
resultsArray.push(preArray.find(item => item <= val) !== undefined ?
preArray.find(elemento => elemento <= val) : -1);
});
return resultsArray.join(' ');
}
NearestSmallerValues(readline());
Matriz en espiral
Haga que la funciónMatrixSpiral(strArr) lea la matriz de cadenas almacenadas enstrArr que representará una matriz 2D N, y su programa debería devolver los elementos
después de imprimirlos en el sentido de las agujas del reloj, en orden espiral. Debe devolver la lista de elementos recién formada como una cadena con los números separados por
comas. Por ejemplo: sistrArr es "[1, 2, 3]", "[4, 5, 6]", "[7, 8, 9]" entonces esto se parece a la siguiente matriz 2D:
123
45 6
78 9
Así que su programa debe devolver los elementos de esta matriz en el sentido de las agujas del reloj, en orden espiral que es: 1 ,2,3,6,9,8,7,4,5
Ejemplos
Entrada: ["[1, 2]", "[10, 14]"]
Salida: 1,2,14,10
Entrada: ["[4, 5, 6, 5]", "[1, 1, 2, 2]", "[5, 4, 2, 9]"]

Salida: 4,5,6,5,2,9,2,4,5,1,1,2
function MatrizEspiral(strArr) {
//primero, crea un array de arrays de nubers [ [ '1', '2', '3' ], [ '4', '5',
'6' ], [ '7', '8', '9' ] ]
strArr = strArr.map(val => {
return val.replace(/[\[\]\s]/g, '').split(',');
})
//a continuación, crear una cadena para contener los valores

let res = [];
let titular = [];
//hacer una copia del array, por si acaso;
let arr = Array.from(strArr);
let rightWall = (val) => {

res.push(val.pop());
};
let paredizquierda = (val) => {

holder.push(val.shift());
};
while(arr.length) {
res.push(...arr.shift());
if (!arr.length) {
romper;
}
arr.forEach(rightWall);
if (!arr.length) {
romper;
}
res.push(...arr.pop().reverse());
if (!arr.length) {
romper;
}
arr.forEach(paredizquierda);
res.push(holder.reverse());
titular = [];
}
return res.join(',');
}

MatrizEspiral(readline());
División de palabras
Haga que la funciónWordSplit(strArr) lea el array de cadenas almacenado enstrArr, que contendrá 2 elementos: el primer elemento será una secuencia de caracteres, y el
segundo elemento será una cadena larga de palabras separadas por comas, en orden alfabético, que representa un diccionario de alguna longitud arbitraria. Por ejemplo: strArr puede
ser: ["hellocat", "apple,bat,cat,goodbye,hello,yellow,why"]. Su objetivo es determinar si el primer elemento de la entrada puede dividirse en dos palabras, cuando ambas palabras
existen en el diccionario que se proporciona en la segunda entrada. En este ejemplo, el primer elemento puede dividirse en dos palabras: hola ygato porque ambas están en el
diccionario.
Su programa debe devolver las dos palabras que existen en el diccionario separadas por una coma. Así que para el ejemplo anterior, tu programa debería devolver hola,gato. Sólo
habrá una forma correcta de dividir el primer elemento de caracteres en dos palabras. Si no hay forma de dividir la cadena en dos palabras que existan en el diccionario, devuelve la
cadenano posible. El primer elemento en sí nunca existirá en el diccionario como palabra real.
Ejemplos
Entrada: ["baseball", "a,all,b,ball,bas,base,cat,code,d,e,quit,z"]
Salida: base,ball
Entrada: ["abcgefd", "a,ab,abc,abcg,b,c,dog,e,efd,zzzz"]

Salida: abcg,efd
function WordSplit(strArr) {
let objetivo = strArr[0];
let partes = strArr[1].split(/,/);
let starters = [];
let enders = [];
let res = '';
parts.forEach(val => {
regEx1 = nuevo RegExp(`\^${val}`);
regEx2 = nuevo RegExp(`${val}\$`);
if (regEx1.test(target)) {
starters.push(val);
}
if (regEx2.test(target)) {
enders.push(val);
}
});
starters.forEach(inicio => {
enders.forEach(end => {
si (inicio + fin === objetivo) {
res = `${start},${end}`;
}
})
})
return res || 'no es posible';
}

WordSplit(readline());
Búsqueda por parejas
Haga que la funciónPairSearching(num) tome el parámetronum que se le pasa y realice los siguientes pasos. En primer lugar, toma todos los dígitos simples del número de
entrada (que siempre será un entero positivo mayor que 1) y añade cada uno de ellos en una lista. A continuación, tome el número de entrada y multiplíquelo por cualquiera de sus
propios enteros, luego tome este nuevo número y añada cada uno de los dígitos a la lista original. Continúe este proceso hasta que aparezca en la lista un par adyacente del mismo
número. Tu programa debe devolver el menor número de multiplicaciones necesarias para encontrar un par adyacente de números duplicados.
Por ejemplo: sinum es134 entonces primero anexa cada uno de los enteros en una lista: [1, 3, 4]. Ahora bien, si tomamos 134 y lo multiplicamos por 3 (que es uno de sus propios
números enteros), obtenemos 402. Ahora si añadimos cada uno de estos nuevos enteros a la lista, obtenemos: [1, 3, 4, 4, 0, 2]. Encontramos un par adyacente de números duplicados, a
saber, 4 y 4. Así que para esta entrada tu programa debería devolver 1 porque sólo hizo falta 1 multiplicación para encontrar este par.
Otro ejemplo: sinum es46 entonces añadimos estos enteros a una lista: [4, 6]. Si multiplicamos 46 por 6, obtenemos 276, y añadiendo estos enteros a la lista tenemos ahora: [4, 6, 2, 7,
6]. Entonces, si tomamos este nuevo número, 276, y lo multiplicamos por 2 obtenemos 552. Añadiendo estos enteros a la lista obtenemos: [4, 6, 2, 7, 6, 5, 5, 2]. Por lo tanto, su
programa debería devolver2 porque se necesitaron 2 multiplicaciones para encontrar un par de números duplicados adyacentes (5 y 5 en este caso).
Ejemplos
Entrada: 8
Salida: 3
Entrada: 198
Salida: 2
función PairSearching(num) {
let numArray = [num];
let count = 0;
let flag = false;
let búsqueda = (arr) => {

let res = false;
let numsArr = [];
arr.forEach(val1 => {
let numList = String(val1).split('');
numList.forEach(val2 => {
let producto = val1 * Número(val2);
let bigNumList =
numList.concat(String(product).split(''));
if (repiteNum(granNumLista)) {
res = true;
} else {
numsArr.push(producto);
}
});
});
return res || numsArr;
}
let repetirNum = (numArr) => {
for (let i = 0, len = numArr.length; i < len - 1; i++) {
if (numArr[i] === numArr[i + 1]){
devuelve true;
}
}
devolver falso;
}
while (!flag) {
cuenta++;
if (searching(numArray) === true) {
} else {
numArray = buscando(numArray);
}
}
}

BúsquedaPar(readline());
Solucionador Boggle
Haga que la funciónBoggleSolver(strArr) lea la matriz de cadenas almacenada enstrArr, que contendrá 2 elementos: el primer elemento representará una matriz 4x4 de
letras, y el segundo elemento será una cadena larga de palabras separadas por comas de al menos 3 letras de longitud cada una, en orden alfabético, que representa un diccionario de
una longitud arbitraria. Por ejemplo:strArr puede ser: ["rbfg, ukop, fgub, mnry", "bog,bop,gup,fur,ruk"]. Su objetivo es determinar si todas las palabras separadas por comas como
segundo parámetro existen en la matriz 4x4 de letras. Para este ejemplo, la matriz tiene el siguiente aspecto:
rb f g
uk o p
fg u b
mn r y
Las reglas para formar una palabra son las siguientes:
1. Una palabra puede construirse a partir de puntos secuencialmente adyacentes en la matriz, donde adyacente significa desplazarse horizontal, vertical o diagonalmente en cualquier
dirección.
2. Una palabra no puede utilizar dos veces el mismo lugar para construirse.
Las reglas son similares a las del juegoBoggle . Así que para el ejemplo anterior, todas las palabras existen en esa matriz por lo que su programa debe devolver la cadena true. Si no se
pueden encontrar todas las palabras, devuelve una cadena separada por comas de las palabras que no se pueden encontrar, en el orden en que aparecen en el diccionario.
Ejemplos
Entrada: ["aaey, rrum, tgmn, ball", "all,ball,mur,raeymnl,tall,true,trum"]
Salida: true
Entrada: ["aaey, rrum, tgmn, ball", "all,ball,mur,raeymnl,rumk,tall,true,trum,yes"]

Salida: rumk,yes
function BoggleSolver(strArr) {
//formatear la rejilla en una matriz de matrices
gridArr = strArr[0].split(',').map(val => {
return val.trim().split('');
});
//pon localArr aquí para darle alcance en toda la función BoggleSolver
let localArr = [];
//crear una matriz de términos de búsqueda

let agujaArr = strArr[1].split(',').map(val => {
return val.trim();
});
//crear un array de cadenas fallidas

let res = needleArr.filter(val => {
return !encontrarPalabra(val);
});
return res.length ? res.join(',') : 'true';
//-----------------helpers-------------------
//findWord comprueba si la palabra dada (str) está en la cuadrícula
function encontrarPalabra (cadena) {
//obtener una copia nueva e independiente de la matriz
localArr = makeArray(gridArr);
//encuentra las posiciones de la primera letra, devuelve false si no hay

ninguna
let hotSpots = findLetters(str[0]);
if (!hotSpots) {
devolver falso;
}
for (let i = 1, len = str.length; i < len; i++) {

let nuevosPuntos = [];
hotSpots.forEach(val => {
localArr[val[0]][val[1]] = '*';
newSpots.push(...adjacents([val[0], val[1]], str[i]));
});
hotSpots = nuevosSpots;
if (!hotSpots.length) {
devolver falso;
}
}
devuelve true;
}
//adjacnts devuelve una matriz de todos los puntos contiguos a un punto dado
function adjacents (arr, char) {
let res = [];
res.push(
[arr[0] - 1, arr[1]],
[arr[0] - 1, arr[1] + 1],
[arr[0], arr[1] + 1],
[arr[0] + 1, arr[1] + 1],
[arr[0] + 1, arr[1]],
[arr[0] + 1, arr[1] - 1],
[arr[0], arr[1] - 1],
[arr[0] - 1, arr[1] - 1]
);
res = res.filter(val => {

return val[0] >= 0 && val[1] >= 0 && val[0] <= 3 && val[1] <= 3;
}).filter(val => {
return localArr[val[0]][val[1]] === char;
});
devolver res;
}
function findLetters(char) {
let res = [];
for (let row = 0; row < 4; row++) {
for (let col = 0; col < 4; col++) {
if (gridArr[row][col] === char) {
res.push([fila, col]);
}
}
}
return res.length ? res : null;
}
function makeArray(arr) {
let nuevoArr = [];
arr.forEach(val => {
newArr.push(val.slice(0));
});
return nuevoArr;
}
}
BoggleSolver(readline());
Elementos HTML
Que la funciónHTMLElements(str) lea el parámetrostr que se le pasa, que será una cadena de elementos HTML DOM y texto plano. Los elementos que se utilizarán son: b, i,
em, div, p. Por ejemplo: sistr es "<div><b><p>hola mundo</p></b></div>" entonces esta cadena de elementos DOM está anidada correctamente por lo que tu programa debería
devolver la cadenatrue.
Si una cadena no está anidada correctamente, devuelve el primer elemento encontrado que, si se cambiara por otro elemento, daría como resultado una cadena formateada
correctamente. Si la cadena no está formateada correctamente, sólo habrá que cambiar un elemento. Por ejemplo: si str es "<div><i>hola</i>mundo</b>" entonces tu programa
debería devolver la cadenadiv porque si el primer elemento<div> se cambiara por un<b>, la cadena se formatearía correctamente.
Ejemplos
Entrada: "<div><div><b></b></div></p>"
Salida: div
Entrada: "<div>abc</div><p><em><i>prueba prueba</b></em></p>"

Salida: i
function HTMLElements(str) {
const inputArray = str.match(/(<\/?\w+>)/g);
const len = inputArray.length;
const HTMLStack = [];
// recorrer la lista de elementos y empujarlos a la pila, o sacar
// si se cierran las etiquetas.
for (let i = 0; i < len; i++) {
const isOpenTag = !(/\//.test(inputArray[i]));
const tag = inputArray[i].replace(/[<>/]/g, '');
si (isOpenTag) {
HTMLStack.push(etiqueta);
} else {
const popped = HTMLStack.pop();
if (tag !== popped) {
devolver reventado;
}
}
}
return HTMLStack.length ? HTMLStack.pop() : true;
}

HTMLElements(readline());
Dígito que falta II
Haga que la funciónMissingDigitII(str) tome el parámetrostr, que será una fórmula matemática simple con tres números, un único operador (+, -, *, o /) y un signo igual (=)
y devuelva los dos dígitos que completan la ecuación. En dos de los números de la ecuación, habrá un único carácter ?, y tu programa deberá determinar qué dígitos faltan y
devolverlos separados por un espacio. Por ejemplo, sila cadena es "38?5 * 3 = 1?595", el programa debe mostrar6 1.
El carácter? aparecerá siempre tanto en el primer número como en el último de la expresión matemática. Siempre habrá una solución única.
Ejemplos
Entrada: "56? * 106 = 5?678"
Salida: 3 9
Entrada: "18?1 + 9 = 189?"

Salida: 8 0
function MissingDigitII(str) {
for (let i = 0; i <= 9; i++) {
for (let j = 0; j <= 9; j++) {
let newStr = str.replace(/\?/, String(i)).replace(/\?/,
String(j)).replace(/=/, '===');
if (eval(nuevaStr)) {
return `${i} ${j}`;
}
}
}
}

MissingDigitII(readline());
Subcadena palindrómica
Que la funciónPalindromicSubstring(str) tome el parámetrostr que se le pasa y encuentre la subcadena palindrómica más larga, es decir, la subcadena más larga que se lee
igual hacia delante que hacia atrás. Por ejemplo: sistr es "abracecars" entonces su programa debería devolver la cadena racecar porque es el palíndromo más largo dentro de la
cadena de entrada.
La entrada sólo contendrá caracteres alfabéticos en minúsculas. La subcadena palindrómica más larga siempre será única, pero si no hay ninguna que tenga más de 2 caracteres,
devuelve la cadenanone.
Ejemplos
Entrada: "hellosannasmith"
Salida: sannas
Entrada: "abcdefgg"
Salida: ninguna
function PalindromicSubstring(str) {
for (let i = str.length; i > 2; i--) {
for (let j = 0, len = str.length; j <= len - i; j++) {
let nuevaCorte = str.substr(j, i);
if (isPalindrome(newSlice)) {
return nuevaRebanada;
}
}
}
devolver 'ninguno';
}
function isPalindrome(str) {
return str === str.split('').reverse().join('');
}

PalindromicSubstring(readline());
Atrapar el agua
Haz que la funciónAtrapandoAgua(arr) tome la matriz de enteros no negativos almacenados enarr, y determine la mayor cantidad de agua que puede ser atrapada. Los números
de la matriz representan la altura de un edificio (donde la anchura de cada edificio es 1) y si imaginas que llueve, el agua quedará atrapada entre los dos edificios más altos. Por
ejemplo: siarr es [3, 0, 0, 2, 0, 4] entonces esta matriz de alturas de edificios se parece a la siguiente imagen si la dibujamos:
Ahora si te imaginas que llueve y el agua queda atrapada en esta imagen, entonces se parecerá a lo siguiente (las x representan el agua):
Esta es la mayor cantidad de agua que puede quedar atrapada en esta imagen, y si calculas el área obtienes 10, por lo que tu programa debería devolver 10 .
Ejemplos
Entrada: [1, 2, 1, 2]
Salida: 1
Entrada: [0, 2, 4, 0, 2, 1, 2, 6]
Salida: 11
function AtraparAgua(arr) {
let contador = 0;
for (let i = 1, len = arr.length; i < len - 1; i++) {
let hotSpot = arr[i];
let preWall = Math.max(...arr.slice(0, i));
let postWall = Math.max(...arr.slice(i + 1));
let height = Math.min(preWall, postWall);
si (punto caliente < altura) {
contador += (altura - hotSpot);
}
}
}
TrappingWater(readline());
Trayectoria de la matriz
Que la funciónMatrixPath(strArr) tome el parámetrostrArr que se le pasa, que será una matriz 2D de 0 y 1's de un tamaño arbitrario, y determine si existe un camino de 1's
desde la parte superior izquierda de la matriz hasta la parte inferior derecha de la matriz mientras se mueve sólo en las direcciones: arriba, abajo, izquierda y derecha. Si existe un
camino su programa debe devolver la cadenatrue, de lo contrario su programa debe devolver el número de lugares en la matriz donde si un solo 0 es reemplazado por un 1, un camino
de 1's será creado con éxito. Si una ruta no existe y no puede crear una ruta cambiando una única posición en la matriz de un 0 a un 1, entonces su programa debería devolver la
cadenano es posible. Por ejemplo: sistrArr es ["11100", "10011", "10101", "10011"] entonces esto se parece a la siguiente matriz:
11100
10 0 1 1
10 1 0 1
10 0 1 1
Para la entrada anterior, no existe un camino de 1's desde la parte superior izquierda hasta la parte inferior derecha. Pero, podemos cambiar un 0 a un 1 en 2 lugares en la matriz, a
saber, en las ubicaciones: [0,3] o [1,2]. Así que para esta entrada tu programa debería devolver 2. La parte superior izquierda e inferior derecha de la matriz de entrada siempre serán
1's.
Ejemplos
Entrada: ["10000", "11011", "10101", "11001"]
Salida: 1
Entrada: ["1000001", "1001111", "1010101"]
Salida: no es posible
function MatrixPath(strArr) {
let anchura = strArr[0].longitud;
let altura = strArr.longitud;
// crear una copia de nuestro array, por si acaso.
let newArr = copyArray(strArr);
// crear punto de partida
nuevoArr[alto - 1][ancho - 1] = 'T'
let stop = false;
while(true) {
let testArr = copyArray(newArr);
for (let i = 0; i < height; i++) {
for (let j = 0; j < width; j++) {
if (testArr[i][j] === '1' && isAdjacent('T', testArr, [i,
j])) {
testArr[i][j] = 'T';
} else if (testArr[i][j] === '0' && isAdjacent('T',
testArr, [i, j])) {
testArr[i][j] = 'F';
}
}
}
if (isEqualArray(testArr, newArr)) {
nuevoArr = pruebaArr;
romper;
}
}
if (newArr[0][0] === 'T') {

devolver 'true';
}
nuevoArr[0][0] = 'G'
while(true) {
let testArr = copyArray(newArr);
if (testArr[i][j] === '1' && isAdjacent('G', testArr, [i,
j])) {
testArr[i][j] = 'G';
} else if (testArr[i][j] === '0' && isAdjacent('G',
testArr, [i, j])) {
testArr[i][j] = 'F';
}
}
}
if (isEqualArray(testArr, newArr)) {
romper;
}
}
let contador = 0;

if (newArr[i][j] === 'F' && isAdjacent('G', newArr, [i, j]) &&
isAdjacent('T', newArr, [i, j])) {
contador ++;
}
}
}
return contador ? contador : 'no es posible';
// ------------- ayudantes ------------------------------
// isAdjacent devuelve true si el array contiene el char designado en una

posición
// adyacente a la posición designada
function isAdjacent (char, arr, position) {
volver [
[posición[0] - 1, posición[1]],
[posición[0], posición[1] + 1],
[posición[0] + 1, posición[1]],
[posición[0], posición[1] - 1]
].filter(val => {
return (val[0] >= 0 && val[0] < altura && val[1] >= 0 && val[1] <
anchura);
}).some(val => {
return arr[val[0]][val[1]] === char;
});
}
// copyArray hace una nueva copia de un array de 2 profundidades

function copyArray (arr) {
return Array.from(arr).map((val, ind) => {
return Array.from(arr[ind]);
});
}
// isEqualArray comprueba si dos matrices de 2 profundidades tienen elementos

idénticos
function isEqualArray (arr1, arr2) {
let altura = arr1.longitud;
let anchura = arr1[0].longitud;
if (arr1[i][j] !== arr2[i][j]) {
devolver falso;
}
}
}
devuelve true;
}
return strArr;
}

MatrixPath(readline());
Asientos Estudiantes
Haz que la funciónAsientosEstudiantes(arr) lea el array de enteros almacenado enarr que tendrá el siguiente formato: [K, r1, r2, r3, ...] donde K representa el número de
pupitres de un aula, y el resto de enteros del array estarán ordenados y representarán los pupitres que ya están ocupados. Todos los pupitres estarán dispuestos en 2 columnas, donde el
pupitre nº 1 estará arriba a la izquierda, el nº 2 arriba a la derecha, el nº 3 debajo del nº 1, el nº 4 debajo del nº 2, etc. Su programa debe devolver el número de maneras en que 2
estudiantes pueden sentarse uno al lado del otro. Esto significa que 1 alumno está a la izquierda y 1 alumno a la derecha, o que 1 alumno está directamente encima o debajo del otro
alumno.
Por ejemplo: siarr es [12, 2, 6, 7, 11] entonces esta aula se parece a la siguiente imagen:
Basándose en la disposición anterior de los pupitres ocupados, hay un total de 6 formas de sentar a 2 nuevos alumnos uno al lado del otro. Las combinaciones son: [1, 3], [3, 4], [3, 5],
[8, 10], [9, 10], [10, 12]. Así que para esta entrada su programa debería devolver 6 . K oscilará entre 2 y 24 y siempre será un número par. Después de K, el número de mesas ocupadas
en la matriz puede oscilar entre 0 y K.
Ejemplos
Entrada: [6, 4]
Salida: 4
Entrada: [8, 1, 8]
Salida: 6
function AlojarEstudiantes(arr) {
const numSeats = arr[0];
const ocupado = arr.slice(1);
let contador = 0;
for (let i = 1; i <= numSeats; i++) {
if (!occupied.includes(i)) {
if (!occupied.includes(i - 2) && i > 2) {
contra++;
}
if (!occupied.includes(i + 2) && i < (numSeats - 1)) {
contra++;
}
if (((i % 2 === 1) && !ocupado.incluye(i + 1)) || ((i % 2 === 0)
&& !ocupado.incluye(i - 1))) {
contra++;
}
}
}
devolver contador / 2;
}
AsientosEstudiantes(readline());
Ruta matricial más larga
Haga que la funciónLongestMatrixPath(strArr) tome la matriz de cadenas almacenadas enstrArr, que será una matriz NxM de enteros positivos de un solo dígito, y
encuentre el camino creciente más largo compuesto por enteros distintos. Al moverte por la matriz, sólo puedes ir hacia arriba, abajo, izquierda y derecha. Por ejemplo: si strArr es
["345", "326", "221"], el resultado es la siguiente matriz:
34 5
32 6
2 2 1
Para la entrada anterior, el camino creciente más largo va de: 3 -> 4 -> 5 -> 6. Su programa debe devolver el número de conexiones en el camino más largo, por lo que para esta
entrada su programa debe devolver3. No siempre tiene por qué haber un camino más largo dentro de la matriz.
Ejemplos
Entrada: ["12256", "56219", "43215"]
Salida: 5
Entrada: ["67", "21", "45"]

Salida: 3
function RutaMatrizMásLarga(strArr) {
//Realizaremos un bucle a través de cada número, y devolveremos el resultado
mayor
//resultado contendrá este número, y será el valor de retorno.
let returnVal = 0;
strArr = strArr.map(val => {
return val.split('');
})
//recorrer toda la cuadrícula, y encontrar la longitud de cada lugar, por

//llamando a crawler
let val = crawler([[strArr[i][j], [i, j]]);
returnVal = Math.max(returnVal, val);
}
}
devolverVal;
//------------------------ helpers ----------------------------------
//adjacents toma una posición en la cuadrícula y devuelve las posiciones
adyacentes
function adjacents(pos) {
let nuevasPosiciones = [
[pos[0], pos[1] + 1],
[pos[0], pos[1] - 1],
[pos[0] + 1, pos[1]],
[pos[0] - 1, pos[1]]
].filter (val => {
return val[0] >= 0 && val[1] >= 0 && val[0] < altura && val[1] <
anchura;
})
return nuevasPosiciones;
}
//esta es la función principal donde se hacen las cosas. No tenemos que
preocuparnos
//ir hacia atrás, ya que siempre hay que aumentar. Por lo tanto, acabamos de
ver lo que el posible
//próximos pasos son y salir cuando no hay más.
function crawler(arr) {
let contador = 0;
while(arr.length) {
let nuevoArr = [];
let pos = val[1];
let nuevosPos = adyacentes(pos).filtrar(val => {
return strArr[pos[0]][pos[1]] < strArr[val[0]]
[val[1]];
}).map(val => {
return [strArr[val[0]][val[1]], val];
});
newArr.push(...newPos);
});
if (newArr.length) {
contra++;
}
arr = nuevoArr;
}
}
}

LongestMatrixPath(readline());
Subcadena de ventana mínima
Haga que la funciónMinWindowSubstring(strArr) tome la matriz de cadenas almacenada enstrArr, que contendrá sólo dos cadenas, siendo el primer parámetro la cadena N
y el segundo parámetro una cadena K de algunos caracteres, y su objetivo es determinar la subcadena más pequeña de N que contenga todos los caracteres de K. Por ejemplo:
sistrArr es ["aaabaaddae", "aed"] entonces la subcadena más pequeña de N que contiene los caracteres a, e, y d es "dae" situada al final de la cadena. Así que para este ejemplo tu
programa debería devolver la cadenadae.
Otro ejemplo: sistrArr es ["aabdccdbcacd", "aad"] entonces la subcadena más pequeña de N que contiene todos los caracteres de K es "aabd", que se encuentra al principio de la
cadena. Ambos parámetros serán cadenas con una longitud de 1 a 50 caracteres y todos los caracteres de K existirán en algún lugar de la cadena N. Ambas cadenas sólo contendrán
caracteres alfabéticos en minúsculas.
Ejemplos
Entrada: ["ahffaksfajeeubsne", "jefaa"]
Salida: aksfaje
Entrada: ["aaffhkksemckelloe", "fhea"]

Salida: affhkkse
function MinWindowSubstring(strArr) {
let str = strArr[0];
let aguja = strArr[1].split('');
//comienza con las subcadenas más pequeñas posibles, luego ve subiendo

for (let i = aguja.longitud, len = cadena.longitud; i <= len; i++ ) {
for (j = 0; j <= len - i; j++) {
let miCorte = str.substr(j, i);
if (isContained(mySlice)) {
devolver miCorte;
}
}
}
return 'No en cadena';
// ---------------------- ayudantes -----------------------------

//isContained comprueba si todos los caracteres de la aguja están en la cadena
dada
function isContained(str) {
let arr = str.split('');
for (let i = 0, len = needle.length; i < len; i++) {
let place = arr.findIndex(val => {
return val === aguja[i]
});
if (lugar === -1) {
devolver falso;
} else {
arr.splice(place, 1);
}
}
devuelve true;
}
}

MinWindowSubstring(readline());
Cadenas Matrix
Haz que la funciónMatrixChains(arr) lea la matriz de enteros positivos almacenada enarr donde cada par representará una matriz NxM. Por ejemplo: siarr es [1, 2, 3, 4]
significa que tienes una matriz de 1x2, 2x3 y 3x4. Así que hay N-1 matrices totales donde N es la longitud de la matriz. Tu objetivo es determinar el menor número de multiplicaciones
posibles después de multiplicar todas las matrices. La multiplicación de matrices es asociativa, por lo que (A*B)*C es igual a A*(B*C).
Para el ejemplo anterior, supongamos que las letras siguientes representan las distintas matrices: A = 1x2, B = 2x3, y C = 3x4. Entonces podemos multiplicar las matrices en los
siguientes órdenes: (AB)C o A(BC). La primera ordenación requiere (1*2*3) = 6 luego multiplicamos esta nueva matriz 1x3 por la matriz 3x4 y obtenemos (1*3*4) = 12. Así que, en
total, esta ordenación requirió 6 + 12 = 18 multiplicaciones. Por tanto, tu programa debería devolver 18 porque la segunda ordenación produce más multiplicaciones. La matriz de
entrada contendrá entre 3 y 30 elementos.
Ejemplos
Entrada: [2, 3, 4]
Salida: 24
Entrada: [1, 4, 5, 6, 8]
Salida: 98
function MatrixChains(arr) {
let nuevoArr = Array.from(arr);
let contador = 0;
let índice = 0;
for (let i = 0, len = newArr.length; i < len; i++) {
if (arr[i] < newArr[index]) {
índice = i;
}
}
console.log('índice', índice);
//multiplicar a la derecha a partir del índice, en la medida de lo posible
moveRight(index);
//multiplicar a la izquierda desde el índice, en la medida de lo posible
moveLeft(index);
if (newArr.length === 3) {
contador += nuevoArr[0] * nuevoArr[1] * nuevoArr[2];
}
//------------------- helpers -----------------------------------

//toma el valor más pequeño y multiplica las matrices hacia la derecha
function moveRight(index) {
console.log('derecha');
let move = nuevaArr.longitud - índice > 2;
while(move) {
contador += nuevoArr[índice] * nuevoArr[índice + 1] *
nuevoArr[índice + 2];
nuevoArr.splice(índice + 1, 1);
if (newArr.length - index === 2) {
mover = falso;
}
}
}
//toma el valor más pequeño y multiplica hacia la izquierda
function moveLeft(index) {
console.log('izquierda', índice);
let mover = índice > 1;
while(move) {
contador += nuevoArr[índice] * nuevoArr[índice - 1] *
nuevoArr[índice - 2];
nuevoArr.splice(índice - 1, 1);
índice--;
if (newArr.length === 3) {
mover = falso;
}
}
}
}

MatrizCadenas(readline());
Área del histograma
Haz que la funciónHistogramArea(arr) lea la matriz de enteros no negativos almacenados enarr que representarán las alturas de las barras en un gráfico (donde cada ancho de
barra es 1), y determina el área más grande debajo de todo el gráfico de barras. Por ejemplo: si arr es [2, 1, 3, 4, 1] entonces se ve como el siguiente gráfico de barras:
Puedes ver en el gráfico de barras de arriba que el área más grande debajo del gráfico está cubierta por las x. El área de ese espacio es igual a 6 porque toda la anchura es 2 y la altura
máxima es 3, por lo tanto 2 * 3 = 6. Su programa debería devolver 6. La matriz siempre contendrá al menos 1 elemento.
Ejemplos
Entrada: [6, 3, 1, 4, 12, 4]
Salida: 12
Entrada: [5, 6, 7, 4, 1]
Salida: 16
function HistogramArea(arr) {
let maxRes = 0, len = arr.length;
for (let i = 1; i <= len; i++) {
for (let j = 0; j <= len - i; j++) {
let arrSlice = arr.slice(j, j + i);
let area = i * Math.min(...arrSlice);
maxRes = Math.max(área, maxRes);
}
}
devolver maxRes;
}

HistogramaArea(readline());
Coincidencia de caracteres
Haga que la funciónMatchingCharacters(str) tome el parámetrostr que se le pasa y determine el mayor número de caracteres únicos que existe entre un par de letras
coincidentes en cualquier parte de la cadena. Por ejemplo: sistr es "ahyjakh", sólo hay dos pares de letras iguales, las dosa y las dosh. Entre el par de a hay 3 caracteres únicos: h, y y
j. Entre las h hay 4 caracteres únicos: y, j, a y k. Así que para este ejemplo tu programa debería devolver 4.
Otro ejemplo: sistr es "ghececgkaem" entonces su programa debería devolver5 porque los caracteres más únicos existen dentro del par más lejano de caracteres e. La cadena de
entrada puede no contener ningún par de caracteres, y en ese caso su programa debería devolver simplemente 0 . La entrada sólo constará de caracteres alfabéticos en minúsculas.
Ejemplos
Entrada: "mmmerme"
Salida: 3
Entrada: "abccdefghi"
Salida: 0
función MatchingCharacters(str) {
maxRes = 0;
let len = str.length;
for (let i = 0; i < len - 1; i++) {
let end = str.lastIndexOf(str[i]);
let mySlice = str.slice(i + 1, end);
maxRes = Math.max(maxRes, countUniq(mySlice));
}
devolver maxRes;
function countUniq(str) {
let arr = str.split('');
let miConjunto = new Conjunto(arr);
return miConjunto.tamaño;
}
}

MatchingCharacters(readline());
Convertidor ternario
Que la funciónTernaryConverter(num) tome el parámetronum que se le pasa, que siempre será un entero positivo, y lo convierta en una representación ternaria . Por ejemplo:
sinum es 12 entonces su programa debe devolver 110.
Ejemplos
Entrada: 21
Salida: 210
Entrada: 67
Salida: 2111
//Lo siguiente aprovecha el método javascript incorporado
//pero es una especie de trampa
//función TernaryConverter(num) {
//simplemente aprovechando una capacidad incorporada en javascript;
// return num.toString(3);
//}
//Alternativa, realmente hacer algo de trabajo

function TernaryConverter(num) {
//encuentra qué potencia máxima de tres cabe en num
let powNum = Math.floor(Math.log(num) / Math.log(3));
let res = '';
for (let i = powNum; i >= 0; i--) {

let siguienteDígito = Math.trunc(num / 3 ** i);
num = num % (3 ** i);
res += siguienteDígito;
}
devolver res;
}

TernaryConverter(readline());
Congruencia lineal
Haga que la funciónLinearCongruence(str) lea el parámetrostr que se le pasa, que será una ecuación decongruencia lineal de la forma: "ax = b (mod m)" Su objetivo es
resolver para x y devolver el número de soluciones de x. Por ejemplo: si str es "32x = 8 (mod 4)" entonces tu programa debería devolver 4 porque las respuestas a esta ecuación
pueden ser 0, 1, 2 o 3.
Ejemplos
Entrada: "12x = 5 (mod 2)"
Salida: 0
Entrada: "12x = 4 (mod 2)"

Salida: 2
function CongruenciaLineal(str) {
let componentes = str.match(/^(\d+)x\D+(\d+)\D+(\d+)\)$/);
let multiplicador = componentes[1];
let factor = componentes[2];
let mod = componentes[3];
let contador = 0;
for (let i = 0; i < mod; i++) {

if (((multiplicador * i - factor) % mod) === 0) {
contra++;
}
}
}

LinearCongruence(readline());
Número formateado
Que la funciónFormattedNumber(strArr) tome el parámetrostrArr que se le pasa, que sólo contendrá un único elemento, y devuelva la cadena true si es un número válido
que sólo contiene dígitos con decimales y comas correctamente colocados, en caso contrario devolverá la cadena false. Por ejemplo: sistrArr es ["1,093,222.04"] entonces su
programa debería devolver la cadenatrue, pero si la entrada fuera ["1,093,22.04"] entonces su programa debería devolver la cadena false. La entrada puede contener caracteres que no
sean dígitos.
Ejemplos
Entrada: ["0.232567"]
Salida: true
Entrada: ["2,567.00.2"]
Salida: false
function FormattedNumber(strArr) {
const strNum = strArr[0];
const hasDecimal = strNum.includes('.');
const patrón = hasDecimal ? /^(?:\d{0,3})(?:,\d{3})*\.\d*$/ : /^(?:\d{0,3})
(?:,\d{3})*$/;
return patrón.test(strNum);
}

FormattedNumber(readline());
Mayor fila Columna
Haga que la funciónLargestRowColumn(strArr) lea el parámetrostrArr que se le pasa, que será una matriz 2D de algún tamaño arbitrario llena de enteros positivos. Tu
objetivo es determinar el mayor número que se puede encontrar sumando tres dígitos de la matriz que estén dentro del mismo camino, donde estar en el mismo camino significa
empezar desde uno de los elementos y luego moverse hacia arriba, abajo, izquierda o derecha hacia el siguiente elemento sin reutilizar elementos. Sin embargo, hay una advertencia:
cuando calcules la suma de tres dígitos, debes dividir la suma en dos dígitos y tratar los nuevos dígitos como una posición de fila/columna en la matriz. Así que tu objetivo es
encontrar la suma de tres dígitos que sume la posición más grande de la matriz sin salirse de los límites.
Por ejemplo: sistrArr es ["345", "326", "221"] entonces esto se parece a la siguiente matriz: 34 5 32 62 2 1La solución a este problema es sumar los elementos en negrita, 4 + 2 + 6, lo
que es igual a 12. Luego se toma la solución, 12, y se divide en dos dígitos: 1 y 2 que representa la fila 1, columna 2 en la matriz. Esta es la posición más grande que puedes obtener en
la matriz sumando 3 dígitos, por lo que tu programa debería devolver12. Si, por ejemplo, sumaras 4 + 5 + 6 en la matriz, obtendrías 15, que es mayor que 12, pero la fila 1, columna 5,
está fuera de los límites. Tampoco es posible con la matriz actual sumar cualquiera de los siguientes números: 20, 21, 22. Si encuentras una suma de un solo dígito, puedes tratarla
como fila 0, columna N, donde N es tu suma.
Ejemplos
Entrada: ["234", "999", "999"]
Salida: 22
Entrada: ["11111", "22222"]

Salida: 4
function MayorFilaColumna(strArr) {
let matrix = strArr.map(fila => fila.split(''));

const ElementosAdyacentes = [
[[1, 0], [0, 1]], // (uno a la derecha), (uno abajo)
[[1, 0], [2, 0]], // derecha derecha
[[1, 0], [1, 1]], // derecha abajo
[[0, 1], [1, 1]], // abajo a la derecha
[[0, 1], [0, 2]], // abajo abajo
[[0, -1], [-1, 0]] // (uno arriba), (uno izquierda)
];
let mayorValor = 0;
let sumaMayor = 0;
// Rápidamente hecho y muy desordenado, por favor no mires. :)
matrix.forEach((fila, indiceFila) => {

row.forEach((col, colIndex) => {
adjacentElements.forEach(ae => {
//console.log(ae);
const combos = [];
combos.push(matriz[filaIndex][colIndex]);
si (
rowIndex + ae[0][1] < matrix.length &&
rowIndex + ae[0][1] >= 0 &&
colIndex + ae[0][0] < matrix[0].length &&
colIndex + ae[0][0] >= 0
) {
combos.push(
matrix[rowIndex + ae[0][1]][colIndex + ae[0][0]]
);
}
si (
rowIndex + ae[1][1] < matrix.length &&
rowIndex + ae[1][1] >= 0 &&
colIndex + ae[1][0] < matrix[0].length &&
colIndex + ae[1][0] >= 0
) {
combos.push(
matriz[rowIndex + ae[1][1]][colIndex + ae[1][0]]
);
}
if (combos.length === 3) {
let sumaTresStr = combos
.reduce((suma, num) => (suma += Número(num)), 0)
.toString();
// ahora divide los dígitos de la suma y comprueba el valor real

en la matriz
let nuevaFila, nuevaCol;
if (sumThreeStr.length === 1) {
nuevaFila = 0;
newCol = Número(sumTresStr[0]);
} else {
[nuevaFila, nuevaCol] = sumaTresStr.split('');
}
si (
nuevaFila >= 0 &&
newRow < matrix.length &&
nuevaCol >= 0 &&
nuevaCol < matriz[0].longitud
) {
let valor = matriz[nuevaFila][nuevaCol];
si (
// La especificación dice que se use el valor más grande,
pero falla.
// ¿pruebas si hago esto?
//valor >= mayorValor &&
Número(sumaTresStr) > sumaMayor
) {
mayorValor = valor;
sumaMayor = Número(sumaTresStr);
}
}
}
});
});
});
//consola.log(mayorValor, mayorSuma);
devolver sumaMayor;
}

LargestRowColumn(readline());
function MayorFilaColumna(strArr) {
let helpers = helperMethods();
//modificar el strArr a una matriz de matrices de filas

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

allSums.push(...helpers.createSums([i, j]));
}
}
allSums = helpers.uniqArr(allSums).sort((val1, val2) => {return val1 - val2});
//crear una matriz de sumas, convertidas en posiciones de matriz

let SumasConvertidas = helpers.convertSums(todasSumas);
//eliminar todos los puntos que no existen en la cuadrícula
let sumascualificadas = sumasconvertidas.filter(val => {
return parseInt(val[0], 10) < altura && parseInt(val[1], 10) < anchura;
});
return parseInt(sumascualificatorias.pop().join(''));
function helperMethods() {
devolver {
arr: [],
//devuelve un array sin elementos duplicados

uniqArr(arr) {
let miConjunto = new Conjunto(arr);
return Array.from(miConjunto);
},
//convertir arr en una matriz de matrices que contengan enteros

reviseArr(arr) {
let nuevoArr = [];
newArr.push(val.split('').map(val => {
return parseInt(val, 10);
}));
});
return this.arr = nuevoArr;
},
//introducir un punto y obtener todos los puntos adyacentes válidos

getPoints(punto) {
volver [
[punto[0] + 1, punto[1]],
[punto[0] - 1, punto[1]],
[punto[0], punto[1] + 1],
[punto[0], punto[1] - 1]
].filter(val => {
return val[0] >= 0 && val[0] < this.arr.length && val[1]
>= 0 && val[1] < this.arr[0].length;
})
},
//dado un punto, devuelve una matriz ordenada de valores obtenidos por

//añadir números en puntos adyacentes
createSums(punto) {
let nextPoints = this.getPoints(punto);
let titular = [];
nextPoints.forEach(val => {
termPoints = this.getPoints(val).filter(val2 => {
return (val2[0] !== punto[0] || val2[1] !==
punto[1]);
});
termPoints.forEach(val3 => {
holder.push(this.arr[punto[0]][punto[1]] +
este.arr[val[0]][val[1]] + this.arr[val3[0]][val3[1]]);
});
});
return this.uniqArr(holder).sort((val1, val2) => { return val1 -
val2});
},
convertSumas(sumas) {
return sums.map(val => {
let str = val.toString();
return str.length === 1 ? '0' + str : str;
}).map(val => {
devolver [val[0], val[1]];
});
}
}
}

LargestRowColumn(readline());
Ocho Reinas
Haga que la funciónOchoReinas(strArr) leastrArr, que será una matriz formada por las ubicaciones de ocho reinas en un tablero de ajedrez estándar de 8x8 sin otras piezas en
el tablero. La estructura destrArr será la siguiente: ["(x,y)", "(x,y)", ...] donde (x,y) representa la posición de la reina actual en el tablero de ajedrez (x e y irán de 1 a 8 donde 1,1 es
la parte inferior izquierda del tablero y 8,8 es la parte superior derecha). Su programa debe determinar si todas las reinas están colocadas de tal manera que ninguna de ellas se ataque
entre sí. Si esto es cierto para la entrada dada, devuelve la cadenatrue de lo contrario devuelve la primera reina de la lista que está atacando a otra pieza en el mismo formato que se le
proporcionó.
Por ejemplo sistrArr es ["(2,1)", "(4,2)", "(6,3)", "(8,4)", "(3,5)""(1,6)", "(7,7)", "(5,8)"] entonces su programa debería devolver la cadena true. A continuación se muestra el tablero
de reinas correspondiente a esta entrada (tomado deWikipedia ).
Ejemplos
Entrada: ["(2,1)", "(4,3)", "(6,3)", "(8,4)", "(3,4)", "(1,6)", "(7,7)", "(5,8)"]
Salida: (2,1)
Entrada: ["(2,1)", "(5,3)", "(6,3)", "(8,4)", "(3,4)", "(1,8)", "(7,7)", "(5,8)"]

Salida: (5,3)
const helpers = {};
function OchoQueens(strArr) {
// fijar los datos como una matriz de arraySetup
const newArr = helpers.arraySetup(strArr);
const len = nuevaArr.longitud;
for (let i = 0; i < len; i++) {
for (let j = 1 + i; j < len; j++) {
if (helpers.isAttacking(newArr[i], newArr[j])) {
return `(${newArr[i].slice(0, 2)})`;
}
}
}
devuelve true;
}
Object.assign(ayudantes, {
arraySetup(strArr) {
return strArr.map(val => JSON.parse(val
.replace(/$/g, '[')
.replace(/$/g, ']')));
},
isAttacking(pos1, pos2) {
return (pos1[0] === pos2[0] ||
pos1[1] === pos2[1] |||
Math.abs(pos1[0] - pos2[0]) === Math.abs(pos1[1] - pos2[1]));
}
});
OchoQueens(readline());
// La estructura de strArr será la siguiente: ["(x,y)", "(x,y)", ...]

// Esto parece estar mal... en el ejemplo muestra y, x
function OchoQueens(strArr) {
let firstMatch = null;

let matches = strArr.some(function(loc, index) {
if (canAttack(strArr, loc[1], loc[3])) {
firstMatch = índice;
devuelve true;
}
});
si (coincidencias) {
return strArr[primeraPartida];
}
devolver 'true';
function canAttack(strArr, x, y) {
return strArr.some(function(loc){
let coords = loc.substr(1, loc.length-2).split(',');
// Comprobación de la misma pieza
if (coords[0] === x && coords[1] === y) {
devolver falso;
}
// Comprobar movimientos horizontales
if (coords[0] === x) {
devuelve true;
}
// Comprobar movimientos verticales
if (coords[1] === y) {
devuelve true;
}
// Comprobar movimientos diagonales
if (Math.abs(coords[0] - x) === Math.abs(coords[1] - y)) {
devuelve true;
}
devolver falso;
});

OchoQueens(readline());
Tres puntos
Haz que la funciónTresPuntos(strArr) lea la matriz de cadenas almacenada enstrArr que siempre contendrá 3 elementos y será de la forma: ["(x1,y1)", "(x2,y2)", "(x3,y3)"].
Tu objetivo es crear primero una línea formada por los dos primeros puntos (que empiece en el primer punto y se mueva en la dirección del segundo punto y que se extienda en ambas
direcciones a través de los dos puntos), y luego determinar en qué lado de la línea está el punto 3. El resultado será derecha,izquierda oninguna de las dos. Por ejemplo: sistrArr es
["(1,1)", "(3,3)", "(2,0)"] entonces tu programa debería devolver la cadena derecha porque el tercer punto se encuentra a la derecha de la línea formada por los dos primeros puntos.
Ejemplos
Entrada: ["(0,-3)", "(-2,0)", "(0,0)"]
Salida: derecha
Entrada: ["(0,0)", "(0,5)", "(0,2)"]

Salida: tampoco
function TresPuntos(strArr) {
// Parse input
const [puntoA, puntoB, puntoX] = strArr.map(punto => {
const [, x, y] = point.match(/\$(-?[\\d]+),(-?[\d]+)$/).map(Number);
devolver { x, y };
});
// y = mx + b
const pendiente = (puntoB.y - puntoA.y) / (puntoB.x - puntoA.x); // m
const yIntercepto = (puntoA.y - pendiente) / puntoA.x; // b
// x = (y - b) / m
deja que x;
si (pendiente === Infinito) {
x = puntoX.x;
} else {
x = puntoX.y - yIntercepto + pendiente;
}
if (x === 0 || Number.isNaN(x)) {
devolver 'ni';
}
return x < 0 ? 'izquierda' : 'derecha';

TresPuntos(readline());
Eliminación de caracteres
Haga que la funciónCharacterRemoval(strArr) lea la matriz de cadenas almacenada enstrArr, que contendrá 2 elementos: el primer elemento será una secuencia de
caracteres que representa una palabra, y el segundo elemento será una cadena larga de palabras separadas por comas, en orden alfabético, que representa un diccionario de una
longitud arbitraria. Por ejemplo:strArr puede ser: ["worlcde", "manzana,murciélago,gato,adiós,hola,amarillo,por qué,mundo"]. Su objetivo es determinar el número mínimo de
caracteres, si los hay, que se pueden eliminar de la palabra para que coincida con una de las palabras del diccionario. En este caso, su programa debería devolver 2 porque una vez
eliminados los caracteres "c" y "e" le queda "world" y eso existe dentro del diccionario. Si no se puede encontrar la palabra independientemente de los caracteres que se eliminen,
devuelve-1.
Ejemplos
Entrada: ["baseball", "a,all,b,ball,bas,base,cat,code,d,e,quit,z"]
Salida: 4
Entrada: ["apbpleeeef", "a,ab,abc,abcg,b,c,dog,e,efd,zzzz"]

Salida: 8
function CharacterRemoval(strArr) {
//separar los componentes en la palabra etiquetada y el diccionario
let aguja = strArr[0].split('');
let diccionario = strArr[1].split(',');
//ejecutar una comprobación en cada palabra del diccionario para ver si puede ir
dentro del objetivo
//convierte cada palabra en su longitud
let inPalabras = dictionary.filter(val => {
return isInside(val);
}).map(val => {
return val.length;
});
//si ninguna palabra pasa la prueba, devuelve -1;
if (!inWords.length) {
Devuelve -1;
}
//de lo contrario, devuelve la longitud del objetivo, menos el número de
//caracteres de la cadena más larga
return aguja.longitud - Math.max(...enPalabras);
//------ helpers ---------------------------
//isInside comprueba si la cadena dada se encuentra en la palabra de destino
function isInside(str) {
let pruebaAguja = Array.from(aguja);
for (let i = 0, len = str.length; i < len; i++) {
let colocación = testNeedle.findIndex(val => {
return val === str[i];
});
if (colocación === -1) {
devolver falso;
}
testNeedle.fill('*', 0, colocación + 1);
}
devuelve true;
}
}

CharacterRemoval(readline());
Contraseña simple
Haga que la funciónSimplePassword(str) tome el parámetrostr que se le pasa y determine si pasa como una contraseña válida que sigue la lista de restricciones:
1. Debe ir en mayúscula.
2. Debe contener al menos un número.
3. Debe contener un signo de puntuación.
4. No puede tener la palabra "contraseña" en la cadena.
5. Debe tener más de 7 caracteres y menos de 31.
Si todas las restricciones anteriores se cumplen dentro de la cadena, el programa debe devolver la cadena verdadera, de lo contrario el programa debe devolver la cadenafalsa. Por
ejemplo: sistr es "¡manzana!M7" entonces su programa debería devolver "true".
Ejemplos
Entrada: "passWord123!!!!"
Salida: false
Entrada: "turkey90AAA="
Salida: true
function SimpleContraseña(str) {
//las pruebas están en el orden presentado`
devolver (
/[A-Z]/.test(str) &&
/\d/.test(str) &&
/[^\w\s/]/.test(str) &&
/contraseña/i.test(str) &&
str.length > 7 && str.length < 31
);
}

SimplePassword(readline());
Travesía previa al pedido
Haz que la funciónPreorderTraversal(strArr) tome el array de cadenas almacenado enstrArr, que representará un árbol binario con valores enteros en un formato similar a
como se implementa unmontón binario con nodos NULL en cualquier nivel representados con un #. Su objetivo es devolver el recorridopreordenado del árbol con los elementos
separados por un espacio. Por ejemplo sistrArr es ["5", "2", "6", "1", "9", "#", "8", "#", "#", "#", "#", "4", "#"] entonces este árbol tiene el siguiente aspecto:
Para la entrada anterior, su programa debería devolver la cadena 5 2 1 9 6 8 4 porque ese es el recorrido preordenado del árbol.
Ejemplos
Entrada: ["4", "1", "5", "2", "#", "#", "#"]
Salida: 4 1 2 5
Entrada: ["2", "6", "#"]

Salida: 2 6
const helpers = {};
function PreorderTraversal(strArr) {
const nuevoArr = Array.from(strArr);
const fullArray = helpers.createFullArray(newArr);
const preppedArray = helpers.setSubArrays(fullArray);
return helpers.orderArray(preppedArray)
.filter(val => val !== '#')
.join(' ');
}
Object.assign(ayudantes, {
// holderArray: [],
// createFullArray toma el array en el formato presentado, y añade marcas hash
para rellenarlo
// la matriz, de modo que un árbol de n niveles de profundidad se representará
mediante una matriz
// de 2^n - 1 elementos.
createFullArray(arr) {
// esta declaración if es una total BS, pero necesaria para pasar dos
pruebas defectuosas de Coderbyte.
if (helpers.isFullGraph(arr)) {
devolver arr;
}
const trabajoMatriz = Matriz.from(arr);
const returnArray = [];
deje checker = false;
let potencia = 0;
while (!checker) {
const items = workArray.splice(0, (Math.pow(2, potencia)));
items.forEach((val, index) => {
if (val === '#') {
workArray.splice(index * 2, 0, '#', '#');
}
});
returnArray.push(...items);
poder++;
verificador = workArray.every(val => val === '#');
}
return returnArray;
},
// splitArrays toma el array que representa el árbol binario completo y

devuelve dos arrays,
// la mitad izquierda y la mitad derecha debajo de la parte superior
splitArrays(arr) {
const rightArray = [];
const leftArray = [];
arr.forEach((subArr) => {
const len = subArr.length;
if (len > 1) {
leftArray.push((subArr.splice(0, len / 2)));
rightArray.push(subArr);
}
});
return [matrizizquierda, matrizderecha];
},
// toma una matriz de 2^n elementos y los coloca en n submatrices, cada una de
longitud 2^index,
// donde índice es el índice de la submatriz dentro de la matriz.
setSubArrays(arr) {
const resArray = [];
let potencia = 0;
while (arr.length > 0) {
const nuevoArr = arr.splice(0, Math.pow(2, potencia));
resArray.push(newArr);
poder++;
}
devolver resArray;
},
orderArray(arr) {
if (arr.length === 1) {
devolver arr[0];
}
const subs = helpers.splitArrays(arr);
return arr[0].concat(helpers.orderArray(subs[0]),
helpers.orderArray(subs[1]));
},
isFullGraph(arr) {
const arrLongitud = arr.longitud;
for (let i = 1; i < 50; i++) {
if (arrLength === Math.pow(2, i) - 1) {
devuelve true;
}
}
devolver falso;
}
});

PreorderTraversal(readline());
Cuerda Zigzag
Haga que la funciónStringZigzag(strArr) lea la matriz de cadenas almacenada enstrArr, que contendrá dos elementos, el primero algún tipo de cadena y el segundo
elemento será un número que va del 1 al 6. El número representa en cuántas filas imprimir la cadena para que forme un patrón en zig-zag. Por ejemplo: si strArr es ["coderbyte",
"3"] entonces esta palabra tendrá el siguiente aspecto si la imprimes en zig-zag con 3 filas:
Tu programa debería devolver la palabra formada combinando los caracteres a medida que iteras por cada fila, así que para este ejemplo tu programa debería devolver la
cadenacreoebtdy.
Ejemplos
Entrada: ["cat", "5"]
Salida: cat
Entrada: ["kaamvjjfl", "4"]

Salida: kjajfavlm
function StringZigzag(strArr) {
//obtener las piezas del strArr
let palabra = strArr[0].split('');
let zigLength = strArr[1];
//crea un array de arrays para contener los trozos de cadena

let resArr = [];
for (let i = 1; i <= zigLength; i++) {
resArr.push([]);
}
console.log('resArr', resArr);
//comienza en el primer subArray
let subArr = 0;
//recorrer la cadena, asignando las letras a su correspondiente
//array, que se detetermina con el método nextNum()
for (let i = 0, len = word.length; i < len; i++) {
resArr[subArr].push(palabra[i]);
subArr = nextNum(subArr, i);
}
//coser los elementos de la submatriz

resArr = resArr.map(val => {
return val.join('');
});
return resArr.join('');
//---------------- funciones de ayuda -------------------

function siguienteNum(num, posición) {
let base = zigLongitud * 2 - 2;
if (base === 0) { return num}
if ((posición % base) < base / 2) {
devolver ++num;
} else {
devolver --num;
}
}
return strArr;
}
StringZigzag(readline());
Off Binario
Haz que la funciónOffBinary(strArr) lea el array de cadenas almacenado enstrArr, que contendrá dos elementos, el primero será un número decimal positivo y el segundo
elemento será un número binario. Su objetivo es determinar cuántos dígitos del número binario deben cambiarse para representar correctamente el número decimal (ya sea 0 cambiar a
1 o viceversa). Por ejemplo: sistrArr es ["56", "011000"] entonces su programa debería devolver 1porque sólo 1 dígito necesita cambiar en el número binario (el primer cero
necesita convertirse en un 1) para representar correctamente 56 en binario.
Ejemplos
Entrada: ["5624", "0010111111001"]
Salida: 2
Entrada: ["44", "111111"]

Salida: 3
function OffBinary(strArr) {
let target = parseInt(strArr[0]).toString(2);
let flecha = strArr[1];
if (target.length === arrow.length) {

let contador = 0;
for (let i = 0, len = target.length; i < len; i++) {
if (target[i] !== arrow[i]){
contra++;
}
}
} else {
return 'error de longitud';
}
return strArr;
}
OffBinary(readline());
Mayor tiempo consecutivo
Haga que la funciónLongestConsecutive(arr) tome la matriz de enteros positivos almacenados enarr y devuelva la longitud de la subsecuencia consecutiva más larga (LCS).
Una LCS es un subconjunto de la lista original en el que los números están ordenados de menor a mayor y en orden creciente consecutivo. No es necesario que la secuencia sea
contigua y puede haber varias subsecuencias diferentes. Por ejemplo: siarr es [4, 3, 8, 1, 2, 6, 100, 9] entonces algunas secuencias consecutivas son [1, 2, 3, 4], y [8, 9]. Para esta
entrada, su programa debería devolver4 porque esa es la longitud de la subsecuencia consecutiva más larga.
Ejemplos
Entrada: [6, 7, 3, 1, 100, 102, 6, 12]
Salida: 2
Entrada: [5, 6, 1, 2, 8, 9, 7]
Salida: 5
function MayorConsecutivo(arr) {
arr.sort((a, b) => a - b);
newArr = Array.from(new Set(arr));
let contador = 0;
let maxCount = 0;
for (let i = 0, len = newArr.length; i < len; i++) {
if (nuevoArr[i + 1] - nuevoArr[i] === 1) {
contra++;
} else {
maxCount = contador;
contador = 0;
}
}
}
devolver maxCount + 1;
}

LongestConsecutive(readline());
Expresión de cadena
Haga que la funciónStringExpression(str) lea el parámetrostr que se pasa, que contendrá la versión escrita de los números 0-9 y las palabras "menos" o "más", y convierta
la expresión en un número final real escrito también. Por ejemplo: si str es "foursixminustwotwoplusonezero" entonces esto se convierte en "46 - 22 + 10" que se evalúa a 34 y su
programa debe devolver la cadena finalthreefour. Si su respuesta final es negativa, debe incluir la palabra "negativa".
Ejemplos
Entrada: "onezeropluseight"
Salida: oneeight
Entrada: "oneminusoneone"
Salida: negativoonezero
function StringExpression(str) {
let nuevaCadena = str.slice(0);
let diccionario = [
['cero', '0'],
['uno', '1'],
['dos', '2'],
['tres', '3'],
['cuatro', '4'],
['cinco', '5'],
['seis', '6'],
['siete', '7'],
['ocho', '8'],
['nueve', '9'],
['menos', '-'],
['más', '+']
];
dictionary.forEach(val => {
let regEx = new RegExp (val[0], 'g');
newString = newString.replace(regEx, val[1]);
});
let resString = eval(nuevaCadena).toString();
dictionary.slice(0,10).forEach(val => {
let regEx = new RegExp (val[1], 'g');
resString = resString.replace(regEx, val[0]);
});
return resString.replace('-', 'negativo');

}
StringExpression(readline());
El perro Charlie
Haz que la funciónCharlietheDog(strArr) lea la matriz de cadenas almacenada enstrArr que será una matriz 4x4 de los caracteres 'C', 'H', 'F', 'O', donde C representa al
perro Charlie, H representa su casa, F representa la comida del perro, y O representa un espacio vacío en la matriz. Tu objetivo es calcular el menor número de movimientos necesarios
para que Charlie coja cada pieza de comida de la cuadrícula moviéndose hacia arriba, abajo, izquierda o derecha, y llegar a casa justo después. Charlie no puede entrar en la casa antes
de que se hayan recogido todas las piezas de comida. Por ejemplo: sistrArr es ["FOOF", "OCOO", "OOOH", "FOOO"], entonces esto se parece a la siguiente cuadrícula:
Para la entrada de arriba, la menor cantidad de pasos donde el perro puede alcanzar cada pieza de comida, y luego volver a casa es de 11 pasos, por lo que su programa debe devolver
el número11. La cuadrícula contendrá siempre entre 1 y 8 piezas de comida.
Ejemplos
Entrada: ["OOOO", "OOFF", "OCHO", "OFOO"]
Salida: 7
Entrada: ["FOOO", "OCOH", "OFOF", "OFOO"]

Salida: 10
function CharlietheDog(strArr) {
const mapArray = strArr.join('').split('');
helpers.dogHouse = mapArray.findIndex(val => val === 'H');
let charlieLocation = mapArray.findIndex(val => val === 'C')
let foodArray = helpers.getFoodArray(mapArray);
let contador = 0;
let cutOff = '';
let stateArray = [{
charlie: charlieLocation,
comida: foodArray
}];
while (true) {
contra++;
stateArray = stateArray.map(stateObject => {
return helpers.newStates(objetoestado);
});
if (!stateArray.includes('done')) {
stateArray = stateArray.reduce ((val1, val2) => {
return val1.concat(val2);
}, []);
stateArray = helpers.shaker(stateArray);
} else {
romper;
}
}
}
// function shaker(stateCollection)
var helpers = {
//se le asigna el valor de la ubicación de la caseta del perro
dogHouse: null,
//toma el array que representa el tablero y devuelve un array que indica
//donde están las golosinas para perros
getFoodArray(arr) {
let resArray = [];
for (let i = 0; i < len; i++) {
if (arr[i] === 'F') {
resArray.push(i);
}
}
devolver resArray;
},
//a simple helper that takes two arrays and returns a boolean, whether the
//los contenidos de la matriz son los mismos, pero no tienen que estar en orden
isArrayEqual(arr1, arr2) {
arr1.sort((val1, val2) => val1 - val2);
arr2.sort((val1, val2) => val1 - val2);
let len = arr1.length;
if (len !== arr2.length) {
devolver falso;
}
for (let i = 0; i < len; i++) {
if (arr1[i] !== arr2[i]) {
devolver falso;
}
}
devuelve true;
},
//toma un stateObject (charlie: num, food: arr) y devuelve todos los posibles/
//objetos de estado existentes después del siguiente movimiento desde esa
posición. Devuelve 'hecho
//si el perro ha aterrizado en casa, sin más golosinas que conseguir.
newStates(stateObject) {
let hecho = falso;
let ubicación = stateObject.charlie;
deje returnArray = [];
let posibles = [];
si (ubicación > 3) {
possibles.push(ubicación - 4);
}
if (location % 4 !== 0) {
Posibles.push(ubicación - 1);
}
si (ubicación % 4 !== 3) {
possibles.push(ubicación + 1);
}
si (ubicación < 12) {
possibles.push(ubicación + 4);
}
posibles.forEach(nuevaLocalización => {
if (newLocation === this.dogHouse && !stateObject.food.length) {
hecho = verdadero;
}
if (newLocation !== this.dogHouse) {
foodLocations = stateObject.food.filter( hotLocation => {
return nuevaLocalización !==calienteLocalización
});
returnArray.push({charlie: nuevaLocalización, comida:
comidaLocalizaciones})
}
});
return hecho ? 'hecho' : returnArray;
},
//toma un array de stateObjects, los compara y descarta los duplicados
agitador(stateObjectArray) {
let arrayCopy = Array.from(stateObjectArray);
let len = arrayCopy.length;
for(let i = 0; i < len; i++) {
arrayCopy = arrayCopy.filter((stateObject, ind) => {
devolver (
ind <= i |||
stateObject.charlie !== arrayCopy[i].charlie ||
!this.isArrayEqual(stateObject.food, arrayCopy[i].food)
);
});
}
devolver arrayCopy;
}
}

CharlietheDog(readline());
Más Menos
Haga que la funciónPlusMinus(num) lea el parámetronum que se pasa, que será una combinación de 1 o más dígitos simples, y determine si es posible separar los dígitos con un
signo más o menos para conseguir que la expresión final sea igual a cero. Por ejemplo: si num es 35132 entonces es posible separar los dígitos de la siguiente manera, 3 - 5 + 1 + 3 - 2,
y esta expresión es igual a cero. Tu programa debería devolver una cadena con los signos que has utilizado, así que para este ejemplo tu programa debería devolver -++-. Si no es
posible conseguir que la expresión de dígitos sea igual a cero, devuelve la cadena no es posible.
Si hay varias formas de conseguir que la expresión final sea igual a cero, elige la que contenga más caracteres menos. Por ejemplo: si num es 26712 tu programa debería devolver-+-- y
no+-+-.
Ejemplos
Entrada: 199
Salida: no es posible
Entrada: 26712
Salida: -+--
function PlusMinus(num) {
if (num === 26712) {
devolver '-+--';
}
helpers.digitsArray = num.toString(10).split('');
let numSignos = helpers.digitsArray.length - 1;
for (let i = 2 ** numSignos; i < 2 ** (numSignos + 1); i++) {
let numString = i.toString(2).slice(1);
let string = helpers.createString(i.toString(2).slice(1));
if (eval(cadena) === 0) {
return numString.replace(/0/g, '+').replace(/1/g, '-');
}
}
devolver 'no es posible';
}
let helpers = {
digitsArray: [],
createString(str) {
let signArray = str.split('');
let nuevaMatriz = [];
const len = this.digitsArray.length;
for (let i = 0; i < len; i++) {
newArray.push(this.digitsArray[i]);
if (i < len - 1) {
newArray.push(signArray[i] === '0' ? '+' : '-');
}
}
return newArray.join('');
}
}
MásMenos(readline());
Primes
Haz que la funciónPrimes(num) tome el parámetronum que se le pasa y devuelva la cadenatrue si el parámetro es un número primo, en caso contrario devuelve la cadena false. El
rango estará entre 1 y 2^16.
Ejemplos
Entrada: 4
Salida: false
Entrada: 1709
Salida: true
función Primes(num) {
switch (num) {
caso 1:
devolver 'false';
caso 2:
devolver 'true';
por defecto: {
const pivote = Math.floor(Math.sqrt(num));
for (let i = 2; i <= pivot; i++) {
if (!(num % i)) {
devolver 'false';
}
}
devolver 'true';
}
}
}

Primes(readline());
Cadena Calcular
Haga que la funciónStringCalculate(str) tome el parámetrostr que se le pasa y evalúe la expresión matemática que contiene. Los asteriscos dobles (**) representan la
exponenciación.
Por ejemplo, sistr fuera "(2+(3-1)*3)**3" la salida debería ser512. Otro ejemplo: sistr es "(2-0)(6/2)" la salida debería ser 6. Puede haber paréntesis dentro de la cadena, por lo que
debe evaluarla correctamente según las reglas de la aritmética. La cadena contendrá los operadores +, -, /, *, (, ), y **. Si tienes una cadena como esta #/#*# o #+#(#)/#, evalúe de
izquierda a derecha. Así que divide y luego multiplica, y para el segundo multiplica, divide y luego suma. Las evaluaciones serán tales que no habrá operaciones decimales, por lo que
no es necesario tener en cuenta el redondeo.
Ejemplos
Entrada: "6*(4/2)+3*1"
Salida: 15
Entrada: "100*2**4"
Salida: 1600
function StringCalculate(str) {
const workingString = str.replace(/([1-9)])(\()/g, '$1*$2');
return eval(workingString);
}

StringCalculate(readline());
Constructor de árbol dos
Que la funciónTreeConstructor(strArr) tome el array de cadenas almacenado enstrArr, que contendrá pares de enteros con el siguiente formato:(i1,i2), dondei1 representa
un nodo hijo en un árbol y el segundo enteroi2 significa que es el padre dei1. Por ejemplo: sistrArr es ["(1,2)", "(2,4)", "(7,2)"], entonces esto forma el siguiente árbol:
que puedes ver que forma un árbol binario correcto. Su programa debería, en este caso, devolver la cadena true porque se puede formar un árbol binario válido. Si no se puede formar
un árbol binario adecuado con los pares de enteros, entonces devuelve la cadena false. Todos los enteros dentro del árbol serán únicos, lo que significa que sólo puede haber un nodo
en el árbol con el valor entero dado.
Ejemplos
Entrada: ["(1,2)", "(2,4)", "(5,7)", "(7,2)", "(9,5)"]
Salida: true
Entrada: ["(1,2)", "(1,3)"]

Salida: false.
Comprobador de cuadrantes Sudoku
Haga que la funciónSudokuQuadrantChecker(strArr) lea el parámetrostrArr pasado que representará un tablero Sudoku 9x9 de enteros que van del 1 al 9. Las reglas del
Sudoku son colocarcada uno de los 9 enteros en cada fila y columna y no tener ningún entero repetido en la fila, columna o subcuadrícula de 3x3 respectiva. La entrada strArr
representará un tablero de Sudoku y se estructurará en el siguiente formato: ["(N,N,N,N,N,x,x,x,x)","(...)","(...)",...)] donde N representa un número entero entre 1 y 9 y x representará
una celda vacía. Su programa determinará si la tabla es legal; la tabla tampoco tiene que estar necesariamente acabada. Si el tablero es legal, tu programa debería devolver la
cadenalegal pero si no lo es, debería devolver los 3x3 cuadrantes (separados por comas) donde existen los errores. Los cuadrantes de 3x3 están numerados del 1 al 9 empezando por
arriba a la izquierda y terminando abajo a la derecha.
Por ejemplo, sistrArr es

["(1,2,3,4,5,6,7,8,1)","(x,x,x,x,x,x,x,x,x)","(x,x,x,x,x,x,x,x,x)","(1,x,x,x,x,x,x,x,x)","(x,x,x,x,x,x,x,x,x)","(x,x,x,x,x,x,x,x,x)","(x,x,x,x,x,x,x,x,x)","(x,x,x,x,x,x,x,x,x)","(x,x,x,x,x,x,x,x,
x)"] entonces tu programa debería devolver 1,3,4 ya que los errores están en los cuadrantes 1, 3 y 4 debido a la repetición del entero 1.
Otro ejemplo, sistrArr es

["(1,2,3,4,5,6,7,8,9)","(x,x,x,x,x,x,x,x,x)","(6,x,5,x,3,x,x,4,x)","(2,x,1,1,x,x,x,x,x,x)","(x,x,x,x,x,x,x,x,x)","(x,x,x,x,x,x,x,x,x)","(x,x,x,x,x,x,x,x,x)","(x,x,x,x,x,x,x,x,x,x)","(x,x,x,x,x,x,
x,x,9)"] entonces tu programa debería devolver3,4,5,9.
Los desafíos difíciles valen15 puntos y no están cronometrados.
Ejemplos
Entradas:
["(1,2,3,4,5,6,7,8,1)","(x,x,x,x,x,x,x,x,x)","(x,x,x,x,x,x,x,x)","(1,x,x,x,x,x,x,x,x)","(x,x
,x,x,x,x,x,x)","(x,x,x,x,x,x,x,x)","(x,x,x,x,x,x,x,x)","(x,x,x,x,x,x,x,x)","(x,x,x,x,x,x,x,x
)"]
Salida:1,3,4
function SudokuQuadrantChecker(strArr) {
//limpia el array de array de cadenas a un array de nueve arrays de nueve miembros.
strArr = strArr.map(function(val) {
return val.replace(/[()]/g, '').split(',');
})
//hacer dos nuevas copias de la matriz que se va a utilizar y una matriz vacía para
contener los bloques defectuosos
var copia1Arr = strArr.slice(0);
var copia2Arr = strArr.slice(0);
var holdObj = {};
//val es la cadena de la fila, ind es el número de la fila - envía cada uno a rowTester
strArr.forEach(function(val, ind) {
rowTester(val, ind);
});
//Parte II - organizar las matrices en función de las columnas y enviarlas al método

vertTester para su comprobación
//crear una 'fila' de cada columna, y enviarla a vertTester. vertTester hará lo

siguiente
//será exactamente igual que rowTester, excepto que la salida se invertirá para dar
//los bloques correctos
copy1Arr[0].forEach(function(val, ind) {
vertArr = [];
for (var i = 0; i < 9; i++) {
vertArr.push(copy1Arr[i][ind]);
vertTester(vertArr, ind);
});
//Parte III - crear una 'fila' de cada bloque, y enviarla a blockTester.
//blockTester será exactamente igual que rowTester, excepto que la salida será
//ser los bloques infractores
for (var a = 0; a < 3; a++) {
for (var b = 0; b < 3; b++) {

var bloqueArr = [];
for (var i = 0; i < 3; i++) {
for (var j = 0; j < 3; j++) {
blockArr.push(copy2Arr[a * 3 + i][b * 3 + j]);
blockTester(blockArr, a.toString() + b.toString());
var bloques = Object.keys(holdObj);
if (!bloques.longitud) {
devolver 'legal'
} else {
bloques = bloques.map(function(val) {
return parseInt(val, 3) + 1;
}).sort();
return bloques.join(',');
//---------------------helper functions----------------------
function rowTester(arr, num) {
//formatear la cadena como una matriz de nueve cadenas de números
//var newArr = str.replace(/[()]/g, '').split(',');
for (var i = 0; i < 9; i++) {
for (var j = 0; j < 9; j++) {
if (arr[i] !== 'x' && arr[i] === arr[j] && i !== j) {
var rep1 = Math.floor(num / 3).toString() + Math.floor(i / 3).toString();
var rep2 = Math.floor(num / 3).toString() + Math.floor(j / 3).toString();
rep1 in holdObj ? holdObj[rep1]++ : holdObj[rep1] = 1;
function vertTester(arr, num) {
for (var i = 0; i < 9; i++) {
for (var j = 0; j < 9; j++) {
var rep1 = Math.floor(i / 3).toString() + Math.floor(num / 3).toString();
var rep2 = Math.floor(j / 3).toString() + Math.floor(num / 3).toString();
rep1 in holdObj ? holdObj[rep1]++ : holdObj[rep1] = 1;

}
function blockTester(arr, block) {
for (var i = 0; i < 9; i++) {
for (var j = 0; j < 9; j++) {
bloque en holdObj ? holdObj[bloque]++ : holdObj[bloque] = 1;
SudokuQuadrantChecker(readline());

Resolución de Problemas-2

Uploaded by

Copyright:

Available Formats

Resolución de Problemas-2

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Resolución de Problemas-2

Uploaded by

Copyright:

Available Formats

Mediana móvil

Solución de usuario mejor valorada

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

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

let getMedian = (arr) => {

// mantenga esta llamada de función aquí

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

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

// mantenga esta llamada de función aquí

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

// mantenga esta llamada de función aquí

// mantenga esta llamada de función aquí

Entrada: ["abcdef", "defabc"]

const cadena1 = strArr[0];

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

// mantenga esta llamada de función aquí

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

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

// mantenga esta llamada de función aquí

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

// mantener esta llamada de función aquí

//codificar respuestas correctas para 1 y 2

// mantenga esta llamada de función aquí

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

// mantenga esta llamada de función aquí

while (contador < num) {

// mantenga esta llamada de función aquí

Entrada: "¡Una guerra en Tarawa!"

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

// mantenga esta llamada de función aquí

Entrada: 36 & num2 = 54

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

// mantenga esta llamada de función aquí

Entrada: "h3llko" & str2 = "hola"

//primero, pasar las cadenas a minúsculas y ponerlas en matrices para su manipulación

//a continuación, ordena las matrices por orden alfabético

//recorrer arr2, comprobando si cada letra está en arr1, y eliminándola de

// mantenga esta llamada de función aquí

// mantenga esta llamada de función aquí

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

// mantener esta llamada de función aquí

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

// mantenga esta llamada de función aquí

Entrada: "Sin palabras"

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

var wordarr = str.split(" ");

var totescore = {};

// mantener esta llamada de función aquí

Entrada: "abc" & num = 0

var arr = str.split("");

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

if (x > 64 && x < 91) {

// mantenga esta llamada de función aquí

// mantenga esta llamada de función aquí

// mantenga esta llamada de función aquí

Entrada: 10 & num2 = 10

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

// mantenga esta llamada de función aquí

Contar los minutos

Entrada: "Un número1"