Introducción

1

Desafíos para Entrenar tu Pensamiento Lógico

Desafío 1: Problema

2

Cajas de Frutas

Quiz: Desafío 1: Problema

Desafío 1: Solución

3

Solución al desafío de Cajas de Frutas

Desafío 2: Problema

4

Operación Matemática Oculta

Quiz: Desafío 2: Problema

Desafío 2: Solución

5

Solución al desafío de Operación Matemática Oculta

6

Playground: Operación Matemática Oculta

Desafío 3: Problema

7

Carrera de Automóviles

Quiz: Desafío 3: Problema

Desafío 3: Solución

8

Solución al desafío de Carrera de Automóviles

Desafío 4: Problema

9

Identifica la operación

Quiz: Desafío 4: Problema

Desafío 4: Solución

10

Solución al desafío de identifica la operación

11

Playground: Obtén el factor multiplicador

Desafío 5: Problema

12

Los signos matemáticos

Quiz: Desafío 5: Problema

Desafío 5: Solución

13

Solución al desafío de signos matemáticos

Desafío 6: Problema

14

Operaciones matemáticas

Quiz: Desafío 6: Problema

Desafío 6: Solución

15

Solución al desafío de operaciones matemáticas

Desafío 7: Problema

16

Figuras lógicas

Quiz: Desafío 7: Problema

Desafío 7: Solución

17

Solución al desafío de figuras lógicas

Desafío 8: Problema

18

Identifica la operación

Quiz: Desafío 8: Problema

Desafío 8: Solución

19

Solución al desafío de identifica la operación

Desafío 9: Problema

20

Secuencias de Dominos

Quiz: Desafío 9: Problema

Desafío 9: Solución

21

Solución al desafío de secuencia de dominos

Desafío 10: Problema

22

Une los puntos

Desafío 10: Solución

23

Solución al desafío de une los puntos

Desafío 11: Problema / Solución

24

Playground: Reduce el número a 1 en la menor cantidad de pasos

Desafío 12: Problema / Solución

25

Playground: Imprime los números primos

Desafío 13: Problema

26

Encuentra la lógica del mandato

Quiz: Desafío 13: Problema

Desafío 13: Solución

27

Identifica la lógica - Platzi

Desafío 14: Problema

28

Identifica los números

Quiz: Desafío 14: Problema

Desafío 14: Solución

29

Solución al desafío de identifica los números

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Playground: Obtén el factor multiplicador

11/29

Aportes 196

Preguntas 13

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Bien por los que hacen estos ejercicios como si tuvieran 10 años trabajando en Google pero la verdad mal para quienes de verdad están comenzando y ven que pareciera que deberían ya saber hacer todo esto, esto confunde y desanima un montón, yo ya tengo una carrera universitaria y la metodología para aprender difiere enormemente de esto.

La mejor solución es:

export function solution(numbers) {
  // Tu código aquí 👈
  let x = numbers[0] / 3.0;
  return numbers.every((num) => num % x === 0) && x;
}

Les comparto mi solución:

yo estoy en nivel nada aduras penas hice un hola mundo y mandan a hacer esto por DIOS que dificil es esto de la programacion.

preguntas ??? todas no e aprendido nada jajajajja

hola buen día, esta fue mi solución.

Tarde muchísimo en entenderlo. La guía no me pareció lo bastante clara y en las pruebas se piden 3 resultados diferentes. Me confundí, pero al final lo entendí.

export function solution(numbers) {
  // Tu código aquí 👈
  let factor = 0;
  let mult = [3, 4, 5, 6, 7, 8];
  console.log(numbers);
  for (let i = 0; i < numbers.length; i++) {
    let nextFactor = numbers[i] / mult[i];
    console.log("Factor: " + nextFactor);
    if (factor === 0 || factor === nextFactor) {
      factor = nextFactor;
    } else {
      return false;
    }
  }
  return factor
}

¿Por qué no eligieron Python para los ejercicios?

No entendí esta solución, algien me la puede explicar, por favor.

Yo entendí el ejercicio de la siguiente manera
Investigando hay un método llamado apply(this,arguments) lo que hace este método es dejarnos pasar un array a una función.
en este caso lo que se hizo fue pesarle el array a una función que me multiplica cada valor del array por un factor dado , dando como resultado lo que pedían en el ejercicio.

export function solution(numbers) {
  // Tu código aquí 👈
  const multiplier = numbers[0] / 3;
  for (let i = 3; i <= 8; i++) {
    if (numbers[i - 3] !== i * multiplier) {
      return false;
    }
  }
  return multiplier;
 
}
let arrayResultados = [27,36,45,54,63,72]
solution(arrayResultados)
let numeros = [3, 4, 5, 6, 7, 8, 9];
let multiplicador = 9;

for (let i = 0; i < numeros.length; i++) {
  resultado = multiplicador * numeros[i];
  console.log(resultado);
}

Mi solución:

export function solution(numbers) {
  var x = numbers[0] / 3
  for (var i = 1; i < 6; i++) {
    if (numbers[i] / (i + 3) == x) {
      continue
    }
    else {
      return false
    }
  }
  return x
}

creo que estos ejercicios sobran la verdad, o al menos deberian ser opcionales, es como que nos exigen que ya sepamos programar en JavaScript cuando apenas estamos empezando y no hemos visto ningun curso de js.

si esto esta en el comienzo de la carrera de desarrollo web y mas de uno no ha empezado en el mundo del codigo xq confunden mas
EL curso me parece poco orientativo para los que iniciamos. Me ofrecen este curso como INICIO A LA PROGRAMACION y ya te hacen programar en codigo sin bases previas- Una desilucion
Platzi, me podés explicar qué estudio primero antes de hacer este "ejercicio básico"?... porque si esto es básico no me quiero imaginar lo que debe ser el trabajo de un programador Senior... Quiero poder solucionar esto, qué es lo que debo hacer?, qué debo aprender primero para poder solucionar esto?...
Hoy 07/03/2024 no corren las pruebas! No sé que tan mal esta lo que estoy realizando

Buenas a todos, estuvo difícil de sacar solo el ejercicio. Fui mirando comentarios y el que mejor comprendí y mas simple y conciso me pareció es el siguiente.

Hola!!!
Esta es mi solución:


export function solution(numbers) {
return numbers.every((num1, i) => {
const nMtplr = num1 / (i + 3);
return i === 0 || nMtplr === numbers[0] / 3;
}) ? numbers[0] / 3 : false;
}


Explicacion:

La función solution recibe un arreglo llamado numbers como entrada. Está diseñada para encontrar si todos los elementos en el arreglo numbers tienen el mismo multiplicador.

Se utiliza el método every en el arreglo numbers. Este método verifica si todos los elementos del arreglo satisfacen una determinada condición. Itera a través de cada elemento y comprueba si la condición proporcionada se cumple para todos los elementos.

Dentro del método every, tenemos una función flecha que toma dos parámetros: num1 e i. El num1 representa el elemento actual que está siendo procesado, y i es el índice de ese elemento en el arreglo.

En la función flecha, calculamos el siguiente multiplicador nMtplr para el elemento actual. El nMtplr se calcula como num1 / (i + 3). Esto significa que estamos dividiendo el elemento actual por su índice más 3.

A continuación, tenemos una declaración de retorno que determina si el elemento actual cumple con la condición. La condición tiene dos partes:

i === 0: Esto verifica si el elemento actual es el primer elemento del arreglo. Si es el primer elemento, entonces no hay elemento previo con el cual comparar, por lo que retornamos true.
nMtplr === numbers[0] / 3: Esto verifica si el nMtplr del elemento actual es igual al siguiente multiplicador del primer elemento (es decir, numbers[0] / 3). Si son iguales, entonces retornamos true.
El método every retornará true si la condición se cumple para todos los elementos en el arreglo, lo que significa que todos los elementos tienen el mismo multiplicador. De lo contrario, si la condición falla para algún elemento, el método every retornará false.

Finalmente, utilizamos el operador ternario (? 😃 para retornar el resultado de la función. Si el método every retorna true (es decir, todos los elementos tienen el mismo multiplicador), entonces retornamos numbers[0] / 3, que es el multiplicador común. Si el método every retorna false (es decir, no todos los elementos tienen el mismo multiplicador), retornamos false para indicar que el arreglo numbers no cumple con la condición de tener el mismo multiplicador.

Esta es mi solucion:

export function solution(numbers) {
  // Tu código aquí 👈
  const arres = numbers.map((item, index) => item / (index + 3))
  const min = Math.min(...arres)
  const max = Math.max(...arres)

  if (min === max) {
    return min
  } else {
    return false
  }
}

Para este caso en específico, aquí lo primero que se me ocurrió.

export function solution(numbers) {
  let numeros = [3, 4, 5, 6, 7, 8];
  let bandera = false;
  let x = 0;
  while (bandera != true) { 
    if (x * numeros[0] == 27) {
      if (x * numeros[1] == 36) {
        if (x * numeros[2] == 45) {
          if (x * numeros[3] == 54) {
            if (x * numeros[4] == 63) {
              if (x * numeros[5] == 72) {
                bandera = true;
              }
            }
          }
        }
      }
    } else { 
      x++;
    }
  }
  console.log("El factor es: " + x);
}
solution();

Comparto mi solución:

export function solution(numbers) {
  const factor = numbers[0] / 3
  for (let i = 0; i < numbers.length; i++) {
    if(numbers[i] % factor != 0) return false
  }
  return factor
}

Mi solucion.

export function solution(numbers) {
  // Tu código aquí 👈
  let resp = numbers[0]/3
  numbers.forEach(n => (n%resp !== 0 && (resp = false)))
  return resp
}
![](https://static.platzi.com/media/user_upload/image-545a545e-88cf-4058-bb68-c40f973cd01e.jpg)esta es mi solucion, no es el codigo mas bonito pero funciona

Les comparto mi código, no es la solución más optimizada comparandose con la de mis compañeros pero es el resultado de mi esfuerzo y conocimiento.
.

export function solution(numbers) {
  // Tu código aquí 👈
  
  let numeros_divisores = [2, 9];
  let no_se_pueden_dividir = [];
  let es_entero;

  for (let n = 0; n < numeros_divisores.length; n++) {

    if (no_se_pueden_dividir.length > 0) {
      no_se_pueden_dividir.splice(0, no_se_pueden_dividir.length);
    };

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

      es_entero = Number.isInteger(numbers[i] / numeros_divisores[n]);

      if (!es_entero) {
        no_se_pueden_dividir.push('error');
      };

    };

    if (no_se_pueden_dividir.length === 0) {
      return numeros_divisores[n];
    };
  };

  return false;
};
uy programadnos difícil che
A mí sí me desaniman este tipo de ejercicios, aunque entiendo la razón de ser de estos.
public class Main{ public static void main(String\[] args) { int valores \[] = {1,2,3,4,5,6}; int multiplicador= 9; for (int valor : valores) { int resultado = valor \* multiplicador; System.out.println("el resultado es" + resultado); } } }
```js export function solution(numbers) { // Tu código aquí 👈 let multiply = [3, 4, 5, 6, 7, 8]; let commonFactor = numbers[0] / multiply[0]; for (let i = 0; i < multiply.length; i++) { let factor = numbers[i] / multiply[i]; if (factor !== commonFactor) { return false; } } return commonFactor; } ```export function solution(numbers) { // Tu código aquí 👈 let multiply = \[3, 4, 5, 6, 7, 8]; let commonFactor = numbers\[0] / multiply\[0]; for (let i = 0; i < multiply.length; i++) { let factor = numbers\[i] / multiply\[i]; if (factor !== commonFactor) { return false; } } return commonFactor;}
Este me costó tiempo, estoy empezando con javascript, hay repuestas elegantes, comparto la mia ![](https://static.platzi.com/media/user_upload/image-7ab7dcd4-cef8-48fe-953e-0e2e2ee6c4c7.jpg)
Cabe aclarar que la pregunta tiene un poco de trampa. Porque el primer array también es divisible entre 3. Pero aquí tenemos la respuesta en una sola línea de código: ```js export const solution = (numbers) => [2, 4, 5, 6, 7, 8, 9].find(f => numbers.every(n => n % f === 0)) ?? false ```Si alguien logra hacerlo mejor, por favor responda a este comentario.
`def solution(a):` ` print(a)` ` aux = 3` ` for i, num in enumerate(a): #num toma el valor del elemento seleccionado del array` ` if num / 9 == aux: #El ciclo for seguira hasta que se termine el array` ` print(num)` ` aux += 1` ` else:` ` print(f"{num} False")` ` aux += 1` `n1 = [27, 36, 45, 54, 63, 72]` `n2 = [27, 36, 45, 54, 42, 72]` `solution(n1)` `solution(n2)`
From a beginner to beginner: ```js function solution(numbers) { // Tu código aquí 👈 var i = 0; var mult1 = [3, 4, 5, 6, 7, 8]; var mult2 = []; var test = true; for (i; i<numbers.length; i++){ mult2[i] = numbers[i] / mult1[i] if (i>=1){ if (mult2[i] != mult2[i-1]){ test = false; } } } //console.log(test); //console.log(mult2); if (test == false){ return test; } else { return mult2[0]; } } solution([27, 36, 45, 54, 42, 72]) ```
Esta es mi solución. La publico porque no veo que se parezca a las que han publicado los demás: ```js export function solution(numbers) { let results = []; let number = [3, 4, 5, 6, 7, 8]; for (let i = 0; i < numbers.length; i++) { let a = numbers[i] / number[i] results.push(a) } let comparaciones = [] for (let i = 0; i < results.length; i++) { if (results[i] == results[i + 1]) { comparaciones.push(1) } } if (comparaciones.length == results.length - 1) { return (results[0]) } else { return (false) } } ```
MI solución es la siguiente así el sistema no la apruebe, pero funciona: ```js export function solution(numbers) { for (let i = 0; i < 9; i++){ let solucion = numbers[i] / (i+3); return solucion; } } ```Recibo recomendaciones.
```js export function solution(numbers) { for (let i = 0; i < 9; i++){ let solucion = numbers[i] / (i+3); return solucion; } } ```export function solution(numbers) { for (let i = 0; i < 9; i++){ let solucion = numbers\[i] / (i+3); return solucion; } }
La verdad fue un gran reto aprendí mucho, pero concuerdo con algunos compañeros que es un cambio radical en el nivel del programa. Dejo mi código espero sea de ayuda.export function solution(numbers) {  // Tu código aquí 👈  let j = 0;  let i = \[3, 4, 5, 6, 7, 8];  let x = numbers\[0] / i\[0];  let y;  do {    y = numbers\[j] / i\[j];    j++;  } while (y == x & j < numbers.length)  if (j == numbers.length) {    return x;  }  else {    return false;  }}```js export function solution(numbers) { // Tu código aquí 👈 let j = 0; let i = [3, 4, 5, 6, 7, 8]; let x = numbers[0] / i[0]; let y; do { y = numbers[j] / i[j]; j++; } while (y == x & j < numbers.length) if (j == numbers.length) { return x; } else { return false; } } ```
```js export function solution(numbers) { let factorMultiplicador = null; for (let i = 3; i <= 8; i++) { let factorActual = numbers[i - 3] / i; if (factorMultiplicador !== null && factorMultiplicador !== factorActual) { return false; } factorMultiplicador = factorActual; } return factorMultiplicador; } ```
Sin conocer la sintaxis de los lenguajes de programación esto es realmente imposible resolver. Deberian profundizar en enseñar la sintaxis.
```js export function solution(numbers) { const factor1 = 3; const factor2 = numbers[0] / factor1; const isInvalid = numbers.some( // (index + factor1) = updated factor1 number (3 - ∞) (item, index) => item / (index + factor1) !== factor2 ); return isInvalid ? false : factor2; } ``` Les comparto mi solución, se podría aplicar una validación para que el numero de `factor1` se limite a 8. Pero lo dejo dinámico de cuerdo a la cantidad de items que el usuario coloque en el array.

Se aceptan críticas constructivas.

export function solution(numbers) {
  // Tu código aquí 👈
  let valorR = numbers[0] / 3;
  let valor;
  var j;
  for (let i = 0, j = 3; i < 6; i++, j++) {
    valor = numbers[i] / j;
    if (valorR != valor) {
      return false;
    }
  }
  return valorR;
}

solution([27, 36, 45, 54, 63, 72])
solution([27, 36, 45, 54, 42, 72])

Mi aporte fue un poco raro. Tuve que investigar algunos metodos de array y luego entre prueba y error pude dar con el resultado. Creo que no lo pensé bien desde el principio ni tampoco hice diagrama de flujo. Que piensan? ```js const array = [27, 36, 45, 54, 63, 72] // tabla del 9 //const array = [6, 8, 10, 12, 14, 16] // tabla del 2 //const array = [21, 28, 35, 42, 49, 56] // tabla del 7 function solution(numbers) { let valor = 0 let arrayX = [] for(let i = 3; i <= 8; i++) { let indexArray = i - 3 valor = numbers[indexArray] / i arrayX.push(valor) } const homogeneo = arrayX .map(el => el === valor) // usar filter, map o reduce .filter(el => !el) console.log(`array_acumulado: ${arrayX}`) //console.log(`Homogeneo? -------> ${homogeneo}`) const incluyeFalse = homogeneo.includes(false) console.log(`incluyeFalse? -------> ${incluyeFalse}`) if (!incluyeFalse) { return valor } else { return false } } let resultado = solution(array) console.log('resultado: ' + resultado); ```const array = \[27, 36, 45, 54, 63, 72] // tabla del 9//const array = \[6, 8, 10, 12, 14, 16] // tabla del 2//const array = \[21, 28, 35, 42, 49, 56] // tabla del 7 function solution(numbers) {    let valor = 0    let arrayX = \[]    for(let i = 3; i <= 8; i++) {            let indexArray = i - 3    valor = numbers\[indexArray] / i    arrayX.push(valor)}     const homogeneo = arrayX       .map(el => el === valor) // usar filter, map o reduce        .filter(el => !el)     console.log(`array\_acumulado: ${arrayX}`)    //console.log(`Homogeneo? -------> ${homogeneo}`)    const incluyeFalse = homogeneo.includes(false)    console.log(`incluyeFalse? -------> ${incluyeFalse}`)       if (!incluyeFalse) {        return valor    } else {        return false    } } let resultado = solution(array)console.log('resultado: ' + resultado);
¿A los cuantos meses o años de estudiar en la plataforma, dirían que obtuvieron la capacidad de resolver este tipo de problemas? Yo llevo 8 días jajaj, tengo muy buenas bases de lógica y matemática, pero, aun no soy capaz de plasmar mis ideas, razonamientos ni soluciones en código. Me ayudaría a guiarme si alguien comparte conmigo su experiencia en Platzi.
Al inicio de este curso dicen OLVIDA EL CODIGO, y eso funciona para personas principiantes como yo, pero cómo es que quieren que escriba codigo cuando esta clase está antes de que me enseñen a utilizar Javascript! Es frustrante que no pueda resolver este problema porque aun no veo cómo hacerlo, busco en internet cómo resolverlo, para no ver la respuesta y hacerlklo por mi cuenta y obviamente aparecen mil conceptos más que en vez de ayudar, confunden.
var arreglo = [27, 36, 45, 54, 63, 72];

function encontrar(arreglo){
  for (var i = 0; i < arreglo.length; i++){
     var aux = i + 3;
    if (arreglo[i] % aux == 0){
      var res = arreglo[i] / aux;
    }else{
      return false
    }
  }
  return res;
}

console.log(encontrar(arreglo));
Mejor así... ![](https://static.platzi.com/media/user_upload/image-384c16e5-5bcf-41f8-9e9f-9426ec7f2e5a.jpg)
Otro solución: `export function solution(numbers) {  // Tu código aquí 👈  const baseNums = [3, 4, 5, 6, 7, 8]  const results = numbers.map((number, index) => number / baseNums[index]);  console.log(results)  const cleanResult = [...new Set(results)]` `  if (cleanResult.length > 1) {    return false;  }   return cleanResult[0]}`
Dejo mi humilde código :) ![](https://static.platzi.com/media/user_upload/image-fc03d324-6519-4f74-abfa-417fcf17cbf3.jpg)
lo logre asi me da 9 ```js export function solution(numbers) { let multiplicado = [3, 4, 5, 6, 7, 8]; let factor = numbers[0] / multiplicado[0]; for (let i = 1; i< multiplicado.length; i++) { let guardaN = numbers[i] / multiplicado[i]; if (factor != guardaN) { return false; } } return factor; } ```

Bien, recorrí cada elemento del array numbers y lo dividí entre 3,4,5… y esos resultados los guardé en el array x, luego de eso comprobé cada elemento del array X con el método every para ver si son iguales.

let x = []
  numbers.forEach((numb, index) => { 
    x.push(numb/(index+3)) //index empieza en 0 así que + 3
  })
  if (x.every((num)=> num === x[0]))  //si todos los elementos son iguales al primero
		{ return x[0] }
  else {return false}
![](https://drive.google.com/file/d/1mU2uv5an6nLDruq0PkI2bM5y7TRmc7Fx/view?usp=drive_link)VACILATELA MI LLAVE 🤠
Creo que para abordar este curso hay que tener conocimientos de otros lenguajes de programación, se resuelven funciones en javascript y por ninguna parte se hablan de funciones, les recomiendo una inteligencia artificial que me ayuda en mis avances , <https://www.useblackbox.io/> , le preguntas como si fuera un profesor y te ayuda mucho, en mi opinión personal deberían organizar mejor los objetivos de forma gradual y explicar primero como debe hacerse las cosas y luego enviar tareas parecidas a los objetivos explicados. Estamos pagando para que nos enseñen de una manera pedagogica. Creo que el que comienza un curso de estos pensando en que va a fortalecer su pensamiento lógico, le agarra idea a la programación. Pero me gusta y estos son los retos que debemos enfrentar.

Mi solucion:

export function solution(numbers) {
  // Tu código aquí 👈
  const arrNum = [3, 4, 5, 6, 7, 8];
  let valoresEncontrados = []

  let valorEncontrado = 0
  for (let i = 0; i < arrNum.length; i++) {
    valorEncontrado = numbers[i] / arrNum[i]
    valoresEncontrados.push(valorEncontrado)
  }
  //console.log(valoresEncontrados)

  let referencia = valoresEncontrados[0]
  let resultado = valoresEncontrados.every(elemento => elemento === referencia);
  if (resultado) {
    console.log(referencia)
  } else {
    console.log(resultado)
  }
}

Esta es mi solución:export function solution(numbers) {  let factor = numbers\[0] / 3;  numbers.forEach((value, index) => {    if (factor) {      factor = factor === value/(index+3) ? factor : false    }  });  return factor} solution(\[27, 36, 45, 54, 63, 72])solution(\[27, 36, 45, 54, 42, 72]) ```js export function solution(numbers) { let factor = numbers[0] / 3; numbers.forEach((value, index) => { if (factor) { factor = factor === value/(index+3) ? factor : false } }); return factor } solution([27, 36, 45, 54, 63, 72]) solution([27, 36, 45, 54, 42, 72]) ```
\#include \<iostream> \#include\<string> //C++ int numeros\[6] = { 27, 36, 45, 54, 63, 72 }; bool f(int(\&arr)\[6], int multiplicador) { bool result{ true }; int multiplicando{ 3 }; for (int i = 0; i < 6 && result; i++) { if (multiplicador != arr\[i] / (multiplicando + i) ) result \*= false; } return result; } int main() { bool resultado = f(numeros, 9); std::cout << std::boolalpha << resultado << '\n'; }
Espero este correcta: `export function solution(numbers) {` ` var i = 0;` ` while (i < 6) { ` ` if (numbers[i] % 9 !== 0) {` ` return false;` ` }` ` i++;` ` }` ` return 9;` `}`
Aquí mi código explicado lo más básico posible que se me ocurrió: ```js export function solution(numbers) { // Tu código aquí 👈 // Declaro esta variable para cambiarla a false si algún factor es distinto let rpta = true // Declaro la lista de números a multiplicar const digits = [3, 4, 5, 6, 7, 8]; // Declaro esta variable como puntero del factor anterior calculado let pre = 0; // Declaro esta variable como puntero del factor actual calculado let post = 0; // Recorremos la lista ingresada en la función for (let i = 0; i < numbers.length; i++){ // Apunto al valor del factor anterior calculado pre = post; // Apunto al valor del factor actual caculado post = numbers[i] / digits[i]; // Esta condición es para comparar los factores calculados a partir del 2do ciclo if (i > 0) { // Esta condición es para comparar si los factores calculados son diferentes if (post != pre) { rpta = false; break; } } } // Esta condición regresa el valor del factor calculado si fue igual en todos los casos, sino regresa el false if (rpta) { return post; } else { return rpta; } } ```
```js function solution(resultados) { let factor = resultados[0] / 3; // Suponemos el primer factor for (let i = 3; i <= 8; i++) { if (resultados[i - 3] !== i * factor) { return false; // Si un resultado no coincide, retorna false } } return factor; } const resultado1 = solution([27, 36, 45, 54, 63, 72]); const resultado2 = solution([27, 36, 45, 54, 42, 72]); console.log(resultado1); // 9 console.log(resultado2); // false ```function solution(resultados) {  let factor = resultados\[0] / 3; // Suponemos el primer factor   for (let i = 3; i <= 8; i++) {    if (resultados\[i - 3] !== i \* factor) {      return false; // Si un resultado no coincide, retorna false    }  }   return factor;} const resultado1 = solution(\[27, 36, 45, 54, 63, 72]);const resultado2 = solution(\[27, 36, 45, 54, 42, 72]); console.log(resultado1); // 9console.log(resultado2); // false
export function solution(numbers) {
  let factors = []
  let compareNumbers = [3, 4, 5, 6, 7, 8]
  let commonFactor
  const allEqual = arr => arr.every(v => v === arr[0])

  for (let i = 0; i < numbers.length; i++) {
    let result = numbers[i] / compareNumbers[i]
    factors.push(result)
  }

  if (allEqual(factors)) {
    commonFactor = factors[0]
  } else {
    return false
  }

  return commonFactor
}

Mi solución

export function solution(numbers) {
  // Tu código aquí 👈
  // Números base
  let base = [3, 4, 5, 6, 7, 8]
  // iniciamos el factor como array
  let factor = []

  // Factor
  for (let i = 0; i < numbers.length; i++) {
    // agregamos el factor al array
    factor.push(numbers[i] / base[i])
    // Evaluamos si cumple con la secuencia
    if (i > 0 && factor[i] != factor[i - 1]) {
      return false
    } 
  }
  return factor[0]
}

Mi solución:

function solution(numbers) {
    let multiplicadorTrue = []
    let multiplicadorFalse = [27, 36, 45, 54, 42, 72]
    for (let i = 3; i <= 8; i++){
        let solucion = i * numbers;
        multiplicadorTrue.push(solucion)
    }
    console.log(numbers);
    if (JSON.stringify(multiplicadorTrue) !== JSON.stringify(multiplicadorFalse)) {
        console.log("False");
    } else {
        console.log("True");
    }
}
solution(9);

Estoy muy orgulloso de haber conseguido completarlo, se me atraganto un poco al principio, pero al final salió la solución.

function producto (factorInicial, factorComun, productos)
{
 for (let i = 0; i < productos.length; i++) 
 {
  let resultado = productos[i] / factorInicial
  if(resultado == factorComun)
  {
   console.log(factorComun)
   factorInicial = factorInicial+1 
  }
  else
  {
   console.log(false)
   //return para dejar de iterar una vez no se cumpla la condición
   return
  }
 }
}

producto(3, 9, [27, 36, 46, 54, 63, 72])
//Mostrará 9 9 false en la consola


esta es mi solución funciona en cualquier caso

Esta es mi solución:

function solution(numbers)
{
    let base = 3;
    let factor;
    let factor2;
    let resultado;
    for(let i = 0; i<numbers.length-1; i++)
    {
        factor = numbers[i] / base;
        base++;
        factor2 = numbers[i+1] / base;
        if(factor!=factor2)
        {
            resultado = false;
            break;
        }
        resultado = factor;
    }
    console.log(resultado);
}
//Factor es 9
solution([27, 36, 45, 54, 63, 72]);
solution([27, 36, 45, 54, 42, 72]);

Hola, les comparto mi solución, cualquier duda pueden escribirme (^-^)/

export function solution(numbers) {
  let valorInicial = 3
  let tamaño = numbers.length
  let multiplicadorBase = numbers[0] / valorInicial

  for (let i = 0; i < tamaño; i++) {
    if (multiplicadorBase != (numbers[i] / valorInicial)) {
      return false
    }
    valorInicial++
  }
  return multiplicadorBase
}

La solucion en python

resultados=[27,36,45,54,63,72]
list=[]
counter=3

while counter<9:
  factor=resultados[counter-3]/counter
  list.append(factor)
  counter+=1
  if factor!=9:
    print(False)
    break
  if len(resultados) == list.count(9):
    print(9)

Mi solución:

export function solution(numbers) {
  const arr = [3, 4, 5, 6, 7, 8]
  let factor = 9
  while (factor > 0) {
    const test = arr.map((item) => item * factor)
    if (test.join('') === numbers.join('')) break 
    factor--
  }
  return factor > 0 ? factor : false
}

.
.
.
.
.
.
.
.

export function solution(results) {
  const possibleFactors = [];

  for (let factor = 2; factor <= 10; factor++) {
    let isValid = true;
    for (let i = 3; i <= 8; i++) {
      if (i * factor !== results[i - 3]) {
        isValid = false;
        break;
      }
    }
    if (isValid) {
      possibleFactors.push(factor);
    }
  }

  if (possibleFactors.length === 1) {
    return possibleFactors[0];
  } else {
    return false;
  }
}

Hola, os comparto mi solución. Un saludo.

export function solution(numbers) {
  // Números del 3 al 8 que servirán como base de comparación
  const base = [3, 4, 5, 6, 7, 8];
  
  // Obtenemos el primer factor para inicializar la comparación
  const factorInicial = numbers[0] / base[0];

  // Verificamos si todos los factores son iguales
  for (let i = 1; i < numbers.length; i++) {
    const factorActual = numbers[i] / base[i];
    if (factorActual !== factorInicial) {
      // Si encontramos un factor diferente, devolvemos false
      return false;
    }
  }

  // Si todos los factores son iguales, devolvemos el factor inicial que es el factor común
  return factorInicial;
}

// Ejemplos de uso:
console.log(solution([27, 36, 45, 54, 63, 72])); // Resultado: 9
console.log(solution([27, 36, 45, 54, 42, 72])); // Resultado: false

export function solution(numbers) {
// Tu código aquí 👈
var fac = 0
var mul = [3, 4, 5, 6, 7, 8];

for (var i = 0; i < mul.length; i++) {
if ((numbers[i] % mul[i]) == 0) {
fac = numbers[i] / mul[i];
}
}

for (i = 0; i < numbers.length; i++) {
if ((mul[i] * fac) == numbers[i]) {

} else { 
  return false;
}

}
return fac;
}

Aqui hice mi solucion no se si esta bien porque no se nada de pruebas y no he llegado a ese rubro por el momento. Asi que voy a mostrar todo lo que se.
![](

export function solution(numbers) {
  //total de numeros en el array
  let cantNumeros = numbers.length;
  //multiplicador
  let i = 10
  for (i; i > 1; i--) {
    //posición en el array
    let p = 0
    for (p ; p < cantNumeros; p++) {
      if (numbers[p] % i === 0) {
        if (p === cantNumeros - 1) {
          return(i)
        }
      } else { break}
    }
  } return(false)
}

Que tal amigos, les comparto mi solución, me encanta ver como hay mil caminos para llegar a la misma solución, saludos!

export function solution(numbers) {
  let i = 3;
  let x = 0;
  let y = 0;
  let verdad = true;
  numbers.forEach(function (entrada) {
    x = entrada / i;
    verdad = verdad === true && (i === 3 || x === y)
    i++;
    y = x;
  })
  if (verdad === false) {
    return verdad;
  }
  return x;
}

Aca les dejo mi solución trate de comentar el código un poco

let solucion = [] //Arreglo que almacena el multiplicador

  for (let i = 1; i <= 9; i++) { // Ciclo que realiza la busqueda del Multiplicador
    let valor = 3 * i //Se toma como Base el 3 por el enunciado
    numbers.forEach(function (elemento, indice, array) { //Se recorre el arreglo por cada iteración del "for"
      if (valor == elemento) //Si la multiplicación es igual al elemento del array se agrega al nuevo arreglo, sino se vuelve a comenzar (NOTA: esta validación se realiza por cada elemento del arreglo recibido)
        solucion.push(i) //Se agrega el valor de 'i' al arreglo solucion
    })
  }
  //Se muestra el multiplicador y el array recibido
  console.log("El número multiplicador es: " + solucion)
  console.log("Para el arreglo " + numbers)

export function solution(numbers) {
// Tu código aquí 👈
let factores = [];
for (let i = 3; i <= 8; i++){
let factor = numbers[i - 3] / i;
factores.push(factor);
}
if (new Set(factores).size === 1) {
return factores[0];
} else {
return false;
}
}

[](

Un poco de mi solucion!

No entendí el ejercicio, entiendo como poder resolverlo, pero las soluciones que ponen en los comentarios y la que dan, no tienen nada que ver con la lógica que desarrollo, no entiendo porque hay un número 3 como constante en las soluciones, pero bueno, a seguir aprendiendo

export function solution(numeros) {
  // Tu código aquí 👈
  let operacion = 0
  let concatenaresultado = ""

  for (let i = 0; i < numeros.length; i++) {
    operacion = numeros[i] * 9;
    concatenaresultado = numeros[i] + "*9=" + operacion
    console.log(concatenaresultado)
  }
}

const numeros = [3, 4, 5, 6, 7, 8, 9];
solution(numeros)

Tardé, pero lo logré

export function solution(numbers) {
  let newarray = [];
  let variable = false;

  for (let i = 3; i <= 8; i++) {
    newarray[i - 3] = numbers[i - 3] / i;
  }
  for (let i = 0; i < 5; i++) {
    if (newarray[0] == newarray[i + 1]) {
      variable = true;
    } else {
      variable = false;
      i = i + 5;
    }
  }

  if (variable == true) {
    return newarray[0];
  } else {
    return variable
  }
}

Mi respuesta:

export function solution(numbers) {
  // Tu código aquí 👈
  let result = false;
  let factor = 0;
  let compareFactor = numbers[0] / 3;

  for (let i = 3; i < 9; i++) {
    let index = i - 3;
    factor = numbers[index] / i;
    if (factor != compareFactor) {
      return result;
    }
    compareFactor = factor;
  }

  return factor;
}

Les Comparto mi solución

export function solution(numbers) {
  let sol = numbers
  let num = [3, 4, 5, 6, 7, 8]
  let Ls = num.length
  let div = 0;
  let res = 0;
  for (let i = 0; i < Ls; i++) {
    div = sol[i] / num[i]
    res = res + div
  }
  res = res / Ls
  if (res % 1 == 0) {
    return res
  } else {
    return false
  }
}

para encontrar el factor tenemos que despejar la x entonces dividimos el resultado del numero mas chico en este ejercicio siempre esta ordenado por lo que va ser el primer elemento del array lo dividimos por 3 y nos da el factor
ahora que ya tenemos el factor debemos comprobar que todos cumplen con este y utilizamos el % para saber si al dividir por el factor o no y que no sobre nada se puede usar un for y hacer el loop por cada elemento del array excluyendo el primer elemento o un every para que quede más corto y si cumple la condición en todos los casos se regresa el factor de lo contrario se regresa false de esta manera es más eficiente

// Más Eficiente
export function solution(numbers) {
  // Tu código aquí 👈
  let factor = numbers[0] / 3
  for (let i = 1; i < numbers.length; i++) {
    if (numbers[i] % factor !== 0) return false
  }
  return factor
}

// usando EVERY
export function solution(numbers) {
  // Tu código aquí 👈
  const factor = numbers[0] / 3
  return numbers.every(num => num % factor === 0) ? factor : false;
}

Comparto mi solución bien larga y acorde a lo que hasta ahora he aprendido

function solution(numbers) {
    const numbersToMulti = [3, 4, 5, 6, 7, 8];

    if (numbers.length !== numbersToMulti.length) {
        return false;
    }

    const firtsNumber = numbersToMulti[0];
    const expectedMultiplier = numbers[0] / firtsNumber;

    for (let i = 1; i < numbersToMulti.length; i++) {
        const actualMultiplier = numbers[i] / numbersToMulti[i];
        if (actualMultiplier !== expectedMultiplier) {
            return false;
        }
    }

    return expectedMultiplier;
}

algo en python por favor

dejo mi solución

export function solution(numbers) {
  // Tu código aquí 👈
  let factor = numbers[0] / 3
  for (let i = 0; i < numbers.length; i++) {
    let factorOp = numbers[i] / (i + 3)
    if (factorOp !== factor) {
      return false;
    }
  }
  return factor
}
function solution(results) {
  let factor = null;
  
  for (let i = 0; i < results.length; i++) {
    const currentFactor = results[i] / (i + 3);
    
    if (factor === null) {
      factor = currentFactor;
    } else if (currentFactor !== factor) {
      return false;
    }
  }
  
  return factor;
}

export function solution(numbers) {
  const divisors = [3,4, 5, 6, 7, 8];
  const multiplier = numbers[0] / 3;


 return  divisors.every((divisor,index) => {
    return divisor * multiplier === numbers[index] 
  }) && multiplier
 
}



export function solution(numbers) {
  const factor = numbers[0] / 3

  const allEqual = numbers.every((num) => num % factor === 0)

  return allEqual && factor

}

segun yo la solucion mas sencilla de entender

export function solution(numbers) {

  let multiplicadores = [3, 4, 5, 6, 7, 8]
  let factor = numbers[0] / 3
  let bandera = true

  for (let i = 0; i < multiplicadores.length; i++) {
    if (numbers[i] / multiplicadores[i] != factor)
      bandera = false
  }

  if (bandera === true)
    return factor
  else
    return false
}

yo lo saque así

export function solution(numbers) {
// Tu código aquí 👈
let factor = 0;
let result = null;
let testValues = [3, 4, 5, 6, 7, 8];
for (let i = 0; i < numbers.length; i++){
let current = numbers[i] / testValues[i];
if (i == 0) {
factor = current;
}
else if(current != factor){
result = false;
break;
}
else {
result = current;
}
}
return result;
}

export function solution(numbers) {
  let rta = new Set();
  let multiply = [3, 4, 5, 6, 7, 8]
  for (let i = 0; i < numbers.length; i++) {
    rta.add(numbers[i] / multiply[i]);
  }
  let rta2 = [...rta];
  if (rta2.length === 1) {
    return rta2[0];
  } else {
    return false
  }
}

La Lógica de prueba tenia un grado de dificultad considerable para mi nivel, pero siento que me costo más comprender como funciona la terminal de platzi para codear (perdón si este no es el nombre adecuado), creo que deberían ser más explicativos con esto.
Pero si aprendí mucho realizando este ejercicio… ahora a seguir con los demás!!

export function solution(numbers) {
let factor = numbers[0]/3;
for (let i = 0; i < numbers.length; i++) {
if (numbers[i] / (i + 3) != factor) {
return false
}
}
return factor
}

Espero que os sirva

export function solution(numbers) {

let x = numbers[0]/3;

for (let i = 0; i < numbers.length; i++) {
if (numbers[i]%x!=0) {
return false
}
else { return x };
};
}

Hola aca les dejo el codigo solución del problema me costo bastante pero lo logre , me demore 4 dias para solucionarlo . A los que se quieren dar por vencidos no se rindan!.

var multiplos = [3, 4, 5, 6, 7, 8];
var resultado = [27,36,45,54,63,72];
var tamano = multiplos.length;

for (var i = 0; i < tamano; i++) {
var x = resultado[i] / multiplos[i];
console.log(multiplos[i] + " * " + x + " = " + resultado[i]);
if (resultado[i] % multiplos[i] == 0) {
console.log(x);
}else{
console.log(false)
}
}

Les comparto mi solución:

export function solution(numbers) {
  let inicio = 3
  const FACTOR = numbers[0] / inicio

  for (const x of numbers)
    if (x / inicio++ != FACTOR)
      return false
  return FACTOR
}
undefined