Playground: Obtén el factor multiplicador

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.

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
}

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);
}

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.

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
}

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;
};

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])

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));

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}

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)
  }
}

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;
  }
}

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;
}