Playground: Imprime los números primos

Mi solución… Debo decir que mi lenguaje principal es Python.

export function solution(num) {
  // Tu código aquí 👈
  let result = []
  for (let i = 1; i <= num; i++) {
    let counter = 0
    for (let j = 1; j <= i; j++) {
      if (i % j == 0) {
        counter += 1
      }
    }
    if (counter == 2) {result.push(i)}
  }
  return result
}

💚Solución con Explicación💚

🛡️MURO ANTI-SPOILERS🛡️

🎯Explicación

Primero que nada, en este desafió hay un montón de posibles soluciones, sin embargo, la mayoría recae en el método de validar si un número es primo o no.
La estructura común para resolver este desafío es:

1. Crear un arreglo donde guardar los primos.
2. Recorrer todos los posibles números hasta el número num.
3. Al recorrer los números verificar si es primo, de modo que agreguemos al arreglo los que lo sean.
4. Al terminar de recorrer todos los números retornar el arreglo con los primos.

Si bien, suena sencillo tenemos que pensar que el paso 2 y el paso 3 tienen cosas que tomar en cuenta.

👁️Problema del Paso 2

En el paso 2 de recorrer todos los posibles números puede ser algo bastante ineficiente ya que, supongamos que nuestro num es muy grande como 1 millón, tendríamos que hacer 1 millón ciclos, cosa que es muy costosa. A esto se le puede llamar que se tiene una complejidad O(n) (puedes aprender más de complejidad algorítmica en el Curso de Complejidad Algorítmica con JavaScript).
Entonces, ¿Cómo podemos evitar recorrer todos los números?
En primera el ejercicio nos brinda información muy útil acerca de los primos mencionándonos que todos los primos son números IMPARES por lo que partiendo de eso podemos hacer lo siguiente:

• Si num es mayor o igual a 2, directamente meter a 2 en la lista de primos (ya que en el ejercicio nos menciona que 2 es el único número primo que es PAR.
• Empezar a recorrer los números a verificar desde el número 3 hasta num avanzando de 2 en 2 para así solo evaluar los números IMPARES.

De esta manera mejoraremos el tiempo de ejecución al tener una complejidad menor ya que literalmente estamos evitando revisar la mitad de los números.

👁️ Problema del Paso 3

Ahora para este paso podemos encontrar muchísimas formas de poder verificar si un número es primo o no, podemos ayudarnos de diferentes principios matemáticos o de alguno que otro truco del mundo de la programación.
En mi caso decidí irme por una vertiente sencilla la cual es muy similar al paso anterior el cual es verificar si el número que estamos analizando es divisible entre un conjunto de números menores que él.
Es claro que podríamos recaer en el mismo problema de la complejidad O(n) (que si hubiéramos dejado igual en el anterior paso tendríamos una complejidad cuadrática nada deseable) por lo que para acortarnos el camino de análisis es necesario investigar un poco.
Con un poco de investigación encontré que "los factores primos de un número no son mayores que su raíz cuadrada" y ya ahí nos evitamos hacer el análisis de todos los posibles factores hasta el número que estamos analizando.
Po otro lado, también podemos descartar a todos los números pares ya que como los números que estaremos analizando SIEMPRE serán impares pues es obvio que no tendrán algún factor PAR.
Y de esta manera podremos analizar mejor si es primo o no el número actual (ve el código comentado para que comprendas mejor esta implementación)

🎖️Conclusión

Esta implementación es solo una de muchas posibles, puede que sea más eficiente que unas pero también pueden haber otras, es lo bonito de la programación, podemos encontrar muchos caminos para poder llegar a un mismo destino.
No te rindas! Nunca pares de aprender! y sigue en tu camino de aprendizaje! 💚

Espero mi explicación les haya servido para comprender mejor el desafío y/o inspirarse para crear alguna otra implementación 👀

👾Código

export function solution(num) {
  let primes = []

  //Si num es mayor o igual a 2 de una vez agregamos el 2 como primo
  if (num >= 2)
    primes.push(2)

  //Recorremos todos los posibles impares hasta "num" avanzando de 2 en 2 desde el número 3
  for (let actualNumber = 3; actualNumber <= num; actualNumber += 2){
    //Verificación si numero actual es primo
    let isPrime = true
    for (let divisor = 3; divisor <= Math.sqrt(actualNumber); divisor += 2){
      //Se verifican los divisores impares desde 3 hasta la raíz cuadrada del número actual
      if (actualNumber % divisor == 0) //Si es divisible se descarta
        isPrime=false
    }
    //Guadamos el número sólo si es primo
    if (isPrime)
      primes.push(actualNumber)
  }

  return primes
}

Código JavaScript:

function numPrimos(n) {
	let a, b, c, result = [];
	for (a=1 ; a<=n ; a++)  {
		for (c=0, b=1 ; b<=a; b++)  {
			if (a % b == 0)  c++; 
			if( c>2 )  break; 
		}
		if (c == 2)  result.push(a);
	}
	return result;
}
numPrimos(10);

export function solution(num) {
  // Tu código aquí 👈
  let arr = [];
  // Si es mayor o igual a 2 entonces pushear en el array jeje
  // Nota1: El 2 tambien es primo aunque es par
  if (num >= 2) arr.push(2);
 //Como no necesito validar el 1 entonces inicializo el ciclo desde el 2 y que me tire todos los impares
 / /Nota2: Todos los impares son primos, excepto el 1.
  for (let i = 2; i <= num; i++) {
    if (i % 2 !== 0) {
      arr.push(i);
    }
  }
  return arr;
}

Mi solución

export function solution(num) {
  const primos = [];

  for (let i = 2; i <= num; i++) {
    let esPrimo = true;
    for (let j = 2; j < i; j++) {
      if (i % j === 0) {
        esPrimo = false;
        break;
      }
    }
    if (esPrimo) {
      primos.push(i);
    }
  }

  return primos;

}

No me deja realizar el Examen, al darle presentar me saca al home de platzi

Mi solucion de 14 pasos.

let arreglo = []
  for (let a = 0; a <= num; a++) {
    let res = 0
    for (let i = 1; i <= a; i++) {
      if (a % i == 0) {
        res++
      }
    }
    if (res == 2) {
      arreglo.push(a)
    }
  }
  return arreglo

Mi solicion del problema en python

primos=[1]
numero=int(input("Ingresa un numero => "))
i=1
while i<=numero:
  
    for primo in primos:

        raiz=i**0.5
        if primo<=raiz:

            respuesta=i%primo
        
            if respuesta==0 and primo>1:
                break
        
      
    if (i in primos):
        print()
    elif respuesta > 0:
        primos.append(i)
    elif respuesta==0 and len(primos)<3:
        primos.append(i)
    
    i+=1

i=0
while i<=len(primos)-1:
  
  print(primos[i])
  i+=1

Me re costo pero pude gracias a la comunidad de platzi 💪
Mi codigo:

<export function solution(num) {
  let arrayResult = []

  for (let i = 2; i <= num; i++) {
    let primo = true
    for (let b = 2; b < i; b++) {
      if (i % b === 0) {
        primo = false
      }
    }
    if (primo === true) {
      arrayResult.push(i)
    }

  }

  if (num == 2) {
    arrayResult.splice(arrayResult.length)
    return arrayResult
  } else {
    return arrayResult 
  }
}> 

export function solution(num) {
  // Tu código aquí 👈

  let primos = [];

  // i = numero a evaluar ; j = divisor
  for (let i = 2; i <= num; i++) {
    let primo = true;
    for (let j = 2; j < i; j++) {
      if (i % j === 0) {
        primo = !primo;
        break
      }
    }
    if (primo === true) {
      primos.push(i)
    }
  }

Mi solución JavaScript

function solution(num) {
  // Tu código aquí 👈
  let arr = []
  // Bucle que recorre los números del 2 hasta el número dado 'num'
  for (let i = 2; i <= num; i++){
    if (esprimo(i)) {//llama a la funcion esprimo para verifica si ' i ' es primo
      arr.push(i)
    }
  }

// función que verifica si un número es primo
  function esprimo(n) {
    if (n < 2) return false
    for (let i = 2; i <= n**0.5; i++) {
      if (n % i === 0) return false
    }
    return true
  }

  return arr
}

console.log(solution(5)) // [2, 3, 5]

Aqui mi solución:

function solution(num) {
  var primos = [];
  for(let i = 2; i <= num; i++){
    if(esPrimo(i))
        primos.push(i);
  }
  return primos;
}
//Un número primo es un número entero mayor que 1 
//que solo es divisible por 1 y por sí mismo.
function esPrimo(numero) {
  for (var i = 2; i < numero; i++) {
    if (numero % i === 0) {
      return false;
    }
  }
  return true
}

Mi solucion:

export function solution(num) {
  // Tu código aquí 👈
  var resultado = [];
    for (var i = 2; i <= num; i++){
      var band = 0;
      for (var j = 2; (j < i) && band==0; j++){
        if (i%j == 0) {
          band = 1;
        }
      }
      if (band == 0) {
        resultado.push(i);
      }
    }
    
  return resultado;
}

Este ejercicio estuvo difícil.

function solution(num) {

    let resultado = []

    function numPrimo(n) {
        for (let i = 2; i <= Math.sqrt(n); i++) {
            if (n % i === 0) {
                return false
            }
        }
        return true
    }

    for (let i = 2; i < num; i++) {
        if (numPrimo(i)) {
            resultado.push(i)
        }
    }
    console.log(resultado.length)
}

Costó su momento jsjs, lo estaba interpretando mal, pero aquí esta:

export function solution(num) {
  let allNumbers = []
  for (let i = 2; i <= num; i++) {
    allNumbers.push(i)
  }
  let primos = allNumbers.filter(isPrimo)
  return primos
}

function isPrimo(number) {
  let nDivisores = 0
  for (let n = 1; n <= number; n++) {
    if (number % n === 0) {
      nDivisores = nDivisores + 1
    }
  }
  if (nDivisores==2) {return number}
}

Bueno Mi solución: (creo que funciona para todos los numeros pirmos)

export function solution(num) {
  let primos = [];

  for (let i = 2; i <= num; i++) {
    if (esPrimoInvalido(i)) {
      continue;
    }
    primos.push(i)
  }

  return primos;
}

function esPrimoInvalido(indice) {
  for (let i = 2; i < indice; i++) {
    if (indice % i === 0) {
      return true;
    }
  }
  return false;
}

Nota: si lo desean probar fuera del playground quitene la palabra "export"
Otra nota: si ven que lo pueden mejorar me avisan 👍

Bueno esta es la solución que encontré. El bucle ciclo while se repite mientras “num” sea mayor a 1 (entonces recorre cada valor y “corta” en 1. Si (if) num es igual a 2 (que es el número primo mas pequeño) o (or) num es NO es divisible por 2 (si un número es divisible por cualquier otro número que no sea 1 o el mismo número, entonces no es primo, por lo cuál usé el 2 para detectar si es o no es primo). Si alguna de las dos condiciones anteriores se cumple, se agrega al array (arreglo.unshift(num)) Cabe aclarar que arreglo.unshift(num) agrega al array en orden viceversa al que va encontrando (así se respeta la arregla de que estén ordenados de menor a mayor). Y con “num–” va restando “1” en cada ciclo hasta terminarlo. Espero sirva mi aporte, lo saludos.

export function solution(num) {
const primes = [];

if (num >= 2) {
primes.push(2); // El número 2 es primo y es el único número par primo

for (let i = 3; i <= num; i += 2) {
  let isPrime = true;

  for (let j = 3; j * j <= i; j += 2) {
    if (i % j === 0) {
      isPrime = false;
      break;
    }
  }

  if (isPrime) {
    primes.push(i);
  }
}

}

return primes;

}

Script en Java

public class Code25 {

    public static void main(String[] args) {

        System.out.println(Arrays.toString(solution(30)));

    }

    public static boolean isPrime(int n) {
        if (n < 2) {
            return false;
        }
        for (int i = 2; i < n; i++) {
            if (n % i == 0) {
                return false;
            }
        }
        return true;
    }

    public static int[] solution(int n) {

        int[] prime = new int[n];
        int j = 0;

        for (int i = 2; i <= n; i++) {
            if (isPrime(i)) {
                prime[j] = i;
                j++;
            }
        }
        return prime;
    }

}

Hasta aquí hemos llegado. Me va a tocar ponerme a ver las clases para mejorar mi sintaxis. Tengo asimilado que esto sobrepasa mi lógica y necesito estudiar primero. Volveré

La solución es copiar la respuesta correcta , a veces solo hay q saber copiar una porción de código ajeno ajaja

.
.
.
.
.
.
.
.
.
.
.

function esPrimo(numero) {
  if (numero <= 1) {
    return false;
  }
  if (numero <= 3) {
    return true;
  }
  if (numero % 2 === 0 || numero % 3 === 0) {
    return false;
  }
  let i = 5;
  while (i * i <= numero) {
    if (numero % i === 0 || numero % (i + 2) === 0) {
      return false;
    }
    i += 6;
  }
  return true;
}

export function solution(numero) {
  const primos = [];
  for (let i = 2; i <= numero; i++) {
    if (esPrimo(i)) {
      primos.push(i);
    }
  }
  return primos;
}

Este ejercicio si que tenia su ma o me. La verdad me parece algo raro un cambio fuerte de golpe con lo que no deberia suceder. Bueno asi son las cosas de programacion a seguir.

export function solution(num) {
  // Tu código aquí 👈
  let lista = []

  if (num >= 2) {
    lista.push(2)
  }
  
  for (let i = 2; i <= num; i++) {
    if (i % 2 !== 0) {
      lista.push(i)
    }
  }
  console.log("Tu respuesta es : " + lista)
  return lista
}

solution(5)

mi solucion en JavaScript

export function solution(num) {
  let primos = []

  for (let i = 1; i <= num; i++){
    if (i == 1 || i % 2 == 0 && i !== 2 || i % 3 == 0 && i !== 3 || i % 5 == 0 && i !== 5 || i % 7 == 0 && i !== 7) {
      false
    } else {
      primos.push(i)
    }
  }
  return primos
}

Les comparto mi solucion:

if(num < 2) return [];
const nums = [2];

for (let numero = 3; numero <= num; numero+=2){
    let esPrimo = true;
    for (let i = 2; i <= Math.sqrt(numero); i++) {
      if (numero % i === 0) {
        esPrimo = false;
        break;
      }
    }
    if (esPrimo) {
        nums.push(numero);
    }
  return nums;
  }

Mi solución usando recursividad:

export function solution(num) {
  // Tu código aquí 👈

  let arrayPrimeNumbers = [];

  function findPrimeNumbers(number) {
    let counter = 0;
    if (number === 1) {
      return;
    } else if (number === 2) {
      arrayPrimeNumbers.unshift(number);
    } else if (!(number % 2 === 0)) {
      for (let i = 1; i <= number; i++){
        if (number % i === 0) {
          counter++;
        }
      }

      if (counter === 2) {
        arrayPrimeNumbers.unshift(number);  
      }
           
      findPrimeNumbers(number - 1);
    } else {
      findPrimeNumbers(number - 1);
    }
  }

  findPrimeNumbers(num);
  return arrayPrimeNumbers;
}

function esprimo(num){
  if (num <= 1) {  
    return false;
  } 

  if (num == 2) {
    return true;
  }
  
  for (let i = 2; i<num; i++){
    if (num%i === 0){
      return false;
    }else{
      return true;
    }
  }
}

function imprimirnumerosprimos(num){
  for (let i = 1; i <= num; i++){
    if (esprimo(i) == true){
      console.log(i)
    }
  }
}


imprimirnumerosprimos(2)

Con ayuda de internet y usando la logica

export function solution(num) {
  let arraymay = [];
  while (num > 1) {
    let band = true;
    if (num == 0 || num == 1 || num == 4) band = false;
    for (let x = 2; x < num; x++) {
      if (num % x == 0) { band = false; }
    }
    // Si no se pudo dividir por ninguno de los de arriba, sí es primo
    if (band == true) {
      arraymay.unshift(num);
    }
    num--;
  }
  return arraymay;
}

Mi solución es con un for dentro de otro for

export function solution(num) {
  let number = num
  let primo = []
  let count = 1
  if (number > 1) {
    primo[0] = 2
  }
  for (let n = 3; n <= number; n++) {

    for (let i = 3; i <= n; i++) {
      if ((n % i == 0) && ((n % 1 == 0) && (n % 2 != 0))) {
        primo[count] = n
        count++
      }
    }

  }
  return primo

export function solution(num) {
  // Tu código aquí 👈
  let result = []
  for (let i = 1; i <= num; i++) {
    let counter = 0
    for (let j = 1; j <= i; j++) {
      if (i % j == 0) {
        counter += 1
      }
    }
    if (counter == 2) {result.push(i)}
  }
  return result
}

Mi solución:

export function solution(num) {
  // Create an array filled with zeros
  const numbers = new Array(num + 2).fill(0)

  // Result
  const prime = []

  for (let i = 2; i <= num; i++) { 
    if (!numbers[i]) {
      prime.push(i)
      let pass = i
      do {
        numbers[pass] = 1
        pass += i
      } while (pass <= num)
    }
  }

  return prime
}

Mi aporte

Es la Criba de Eratóstenes, con complejidad O(n log log n)

export function solution(n) {
    let sieve = [], i, j, primes = [];
    for (i = 2; i <= n; ++i) {
        if (!sieve[i]) {
            primes.push(i);
            for (j = i * i; j <= n; j += i) {
                sieve[j] = true;
            }
        }
    }
    return primes;
}

Primero, creo el arreglo.
Luego, meto al arreglo el 2 en caso de que el número sea mayor o igual a 2.
Por ultimo, verifico que sea primo desde el 2 hasta el num.

export function solution(num) {
  // Tu código aquí 👈
  let result = []
  if (num >= 2) result.push(2);
  for (let i = 2; i <= num; i++){
    if (i % 2 !== 0) {
      result.push(i);
    }
  }
  return result;
}

aqui va la mia

function solution(num) {
  var resp = [];
  let isValid = true;
  if (num > 2) {
    for (let j = 2; j <= num; j++) {
      for (let i = 2; i <= (num / 2); i++) {
        if ((j != i) && j % i == 0) {
          isValid = false;
          break;
        }
      }
      if (isValid) {
        resp.push(j);
      }
      else {
        isValid = true;
      }
    }

  }
  else if(num == 2) {
    resp.push(2);
  }
  return resp;
}

Me demoré una hora haciendo esto, pero al menos lo hice:

export function solution(num) {
  // Tu código aquí 👈
  function isPrime(num) {
    if (num === 1 || num === 0) {
      return false;
    } else if (num === 2) {
      return true;
    }
    let p = 2;
    let bool = true;
    while (p > 1 && p < num) {
      if (num % p == 0) {
        bool = false;
      }
      p++;
    }
    return bool;
  }

  let n = num;
  const primos = [];

  for (let i = 0; i <= num; i++) {
    if (isPrime(n) == true) {
      primos.unshift(n);
    }
    console.log(`La n: ${n}`);
    n--;
  }
  return primos;
}

Mi solución
_
_
_
_
_

export function solution(num) {
  // Tu código aquí 👈
  const primos = [];
  for (let i = 2; i <= num; i++){
    if (i === 2 || i === 3 || i=== 5) primos.push(i);
    if (i % 2 === 1 && i % 3 !== 0 && i % 5 !== 0) primos.push(i);
  }
  return primos;
}

Mi solución

export function solution(num) {
  // Tu código aquí 👈
  let primos = [];
  let contador = 0;
  num = parseInt(num)
  while (num > 0) {
    if (num % 2 == 1 && num > 1) {
      primos.push(num);
    }
    else if (num == 2 && num > 1)
    {
      primos.push(num);
    }
    contador++
    num--
    if (contador > 4)
    {
      break
    }
  }
  primos.sort((a, b) => a - b)
  return primos
}

No suelo aportar, pero me gustó mi solución, se las dejo aquí.

function solution(num) {
    if (num === 1) return []
    let currentNumber = 2
    const primeNumbers = [];
    while (currentNumber <= num) {
        const isPrime = primeNumbers.every(primeNumber => currentNumber % primeNumber !== 0);
        if (isPrime) primeNumbers.push(currentNumber);
        currentNumber++;
    }
    return primeNumbers;
}

En vez de comprobar con todos los números anteriores al número actual lo comparo con los números primos calculados previamente, si es divisible entre alguno de los anteriores entonces no es primo, si no es divisible, entonces lo agrego a los números primos para comparar en los siguientes números

Mi solución:

export function solution(num) {
  let primeNumber = num;
  let primeNumbers = [];

  if ((primeNumber === 2 || primeNumber % 2 !== 0) && primeNumber !== 1) {
    primeNumbers.push(primeNumber);
    if (primeNumber === 2) {
      return primeNumbers;
    }

    while (primeNumber > 2) {
      if (primeNumber !== 2) {
        if (primeNumber === 3) {
          primeNumber = primeNumber - 1
        } else {
          primeNumber = primeNumber - 2;
        }
        if ((primeNumber % 2 !== 0 || primeNumber === 2) && primeNumber !== 1) {
          primeNumbers.push(primeNumber);
        }
      }
    }

    primeNumbers.sort(function (a, b) { return a - b });
    return primeNumbers;
  } else {
    return primeNumbers;
  }
}

Mi solución

function solution(num) {
    let primos = [];
    let rango = []
    for (let i = 0; i <= num; i++) {
        rango.push(i)
    }
    rango.forEach(element => {
        if (element == 0 || element == 1 || element == 4) {
            return false
        }
        for (let x = 2; x < element / 2; x++) {
            if (element % x == 0) return false;
        }
        primos.push(element)
    });
    console.log(primos);
}
solution(100)

mi aporte

export function solution(num) {
  let arr = []
  for (let i = 2; i <= num; i++) {
    if (prime(i)) {
      arr.push(i);
    }
  }
  return arr;
}

function prime(num) {
  for (let i = 2; i < num; i++) {
    if (num % i == 0) {
      return false;
    }
  }
  return true;
} 

me doy cuenta que para la lpgica matematica no es mi fuerte, lo mio es el ctrl+c ctrl+v

aquí mi aporte:

export function solution(num) {
  let primos = [];
  for (let i = 2; i <= num; i++) {
    let esPrimo = true;
    for (let j = 2; j <= i - 1; j++) {
      if (i % j == 0) {
        esPrimo = false;
        break;
      }
    }
    if (esPrimo) {
      primos.push(i);
    }
  }
  return(primos);
}

Ahí vamos:

function esPrimo(num) {
  if (num < 2 || num % 2 === 0 && num !== 2) {
    return false;
  }  
  //console.log(num);
  return true;
}

function numerosPrimos(num) {
  let Primos = [];
  for (let i = 2; i <= num; i++) {
    if (esPrimo(i)) {
      Primos.push(i);
    }
  }
  return Primos;
}

function solution(num) {
var primos = []
if (num >= 2) {
primos.push(2)
}
if (num >= 3) {
primos.push(3)
}
if (num >= 5) {
primos.push(5)
}
if (num >= 7) {
primos.push(7)
}
for (i=2;i<=num;i++){
if (i % 2 != 0 && i % 3 != 0 && i % 5 != 0 && i % 7 != 0) {
primos.push(i)
}
}
return(primos)
}

Holi!! mi solution 😃

export function solution(num) {

  let number = 0;
  let arrPrimos = [2];
  if (num <= 1) return [];
  if (num == 2) return arrPrimos;

  //check if the number is even
  if (num % 2 == 0) {

    number = num - 1;
    while (number > 2) {
      arrPrimos.push(number)
      number = number - 2;
    }

    return arrPrimos.sort((a, b) => (a - b));
  }

  // if the number is odd
  else {

    number = parseInt(num);
    while (number > 2) {
      arrPrimos.push(number)
      number = number - 2;
    }

    return arrPrimos.sort((a, b) => (a - b));
  }
}


solution(5);

No es necesario comparar todos los números previos al número ingresado, basta llegar hasta la raíz cuadrada de este, eso nos ahorra pasos en la solución.
Criba de Eratóstenes

Saludos!!! Este es mi aporte, una forma de resolverlos es a través de la recursividad, en este caso ocupe scheme de lenguaje, aclarando no devuelvo arreglo directamente sino imprimo con la recursividad los valores que voy validando primos hasta el imite que le pasamos:

export function solution(num) {
let result = [];
for (let a = 2; a <= num; a++) {
if (a % 2 == 1 || a == 2) result.push(a) ;
}
return result;
}

Mi solución

export function solution(num) {
let primos=[]
for (let i = 2; i <= num; i++){
let contador=2
for (let j = 2; j < i; j++){
if (i % j == 0) {
contador++
break
}
}
if (contador == 2) {
primos.push(i)
}
}
return primos

Lo hice en python, no se que lenguaje tiene esto para hacer la prueba:

const solution = (num) => {
  if(num == 1) return [];
  let prime = [2];
  for(let i = 3; i <= num; i += 2) if(!prime.find(n => i % n == 0)) prime.push(i);
  return prime;
}

function solution(num) {
  let res = [];
  for (let i = 2; i <= num; i++) {
    primo(i) ? res.push(i) : null;
  }
return res;
}

function primo(numero) {
  for (let i = 2; i < numero; i++) {
    if (numero % i === 0) {
      return false;
    }
  }
  return numero !== 1;
}

My solution was:

export function solution(num) {
  const animals = [];
  let resp = 2;
  while (num >= resp) {
    if (resp % 2 != 0 || resp == 2) {
      console.log(resp)
      animals.push(resp);
    } resp++;
  }
  return animals;
}

Les comparto mi solución.

export function solution(num) {
  let result = [];
  for (let e = 2; e <= num; e++) {
    if (e % 2 == 1 || e == 2) result.push(e);
  }
  return result;
}

sale amigos, aquí el mío, creo que aun tardo en hacerlos pero creo que no estaba bien familiarizado con prime numbers jojo esta demasiado interesante la historia de esos numeritos, me gustaron la verdad 😊

<code> 
export function solution(num) {
  let count = 2
  const  primeNum = []
  if (num != 1){
    while (count <= num) {
      if (count == 2 || count == 3 || count == 5) {
        primeNum.push(count)
        count++
      } else if (count % 2 == 0 || count % 3 == 0 || count % 5 == 0) {
        count++
      } else {
        primeNum.push(count)
        count++
      }
    }
  }
  return primeNum
}

hola yo lo hice con Python que es donde mejor me va, pero aun así me costo bastante hacerlo y entenderlo

def encontrar_primos(n):
    primos = []
    for num in range(2, n+1):
        es_primo = True
        print('-----',num)
        for i in range(2,num):
          print ('<<<', i)
          print(num)
          if (num % i) == 0:
                es_primo = False
                print('.....' ,num)
                break
        if es_primo:
            primos.append(num)
    return primos

print(encontrar_primos(21))

export function solution(num) {
  
  let numPrimos = [];

  function esPrimo(numero) {

    if (numero === 0 || numero === 1 || numero === 4)
      return (false);
    for (let x = 2; x < numero / 2; x++) {
      if (numero % x === 0)
        return (false);
    }
    return (true);
  }

  for (let x = 0; x <= num; x++){

    let dato = esPrimo(x);

    if (dato === true)
      numPrimos.push(x);
  
  }

  return (numPrimos);

}

Mi solución

export function solution(num) {
  let primeNumbers = [];
  for (let i = 1; i <= num; i++) {
    let divisorCounter = 0;
    for (let j = 1; j <= i; j++) {
      if (i % j === 0) {
        divisorCounter++;
      }
    }
    if (divisorCounter === 2) {
      primeNumbers.push(i);
    }
  }
  return primeNumbers;
}

Así me quedó mi código:
_____________________________________-

Encontre otra solucion, pero con ternarios:

 let primos = [];
  for (let i = 2; i <= num; i++) {
    let contador = 0;
    for (let j = 1; j <= i; j++) {
      i % j === 0 ? contador++ : null;
    }
    contador === 2 ? primos.push(i) : null;
  }
  return primos;

export function solution(num) {
  // Tu código aquí 👈
  let primos = [];
  for (let i = 2; i <= num; i++) {
    let contador = 0;
    for (let j = 1; j <= i; j++) {
      if (i % j === 0) {
        contador++;
      }
    }
    if (contador === 2) {
      primos.push(i);
    }
  }
  return primos;
}

Other solution:

export function solution(num) {
  function isPrime(n) {
    if (n <= 1) {
      return false;
    }
    for (let i = 2; i < n; i++) {
      if (n % i === 0) {
        return false;
      }
    }
    return true;
  }

  const nums = [];
  for (let i = 1; i <= num; i++) {
    if (isPrime(i)) {
      nums.push(i);
    }
  }
  return nums;
}

Mi solución en Python

# Imprimir una lista de números primos menores o iguale a un número dado

def solution(maxNumber):
  
  if maxNumber >= 2: # El 2 es el unico número par primo que tiene excepción
    
    primos = [2]
    divisores = []
    modules = []

    #Obtenemos una lista de números divisores para despues obtener el módulo
    for divisor in range(2, maxNumber):
      divisores.append(divisor)
    #print("Divisores: ", divisores)
    #print(" ")

    #Hacemos un ciclo para evaluar número por número del 3 al límite
    for numToEvaluate in range(3,maxNumber+1):
      #print("-"*30)
      #print("Número a evaluar:", numToEvaluate)
      #print("-"*30)

      for divisor in divisores:
        #print("Divisor a probar: ", divisor)
        if numToEvaluate > divisor:
          modules.append(numToEvaluate % divisor)
          #print(numToEvaluate, "%", divisor, "=", modules[-1])
          #print("Modules:", modules)
          #print("-"*30)

      if not 0 in modules:
       # print(numToEvaluate, "Es un número primo")
        primos.append(numToEvaluate)
      
      modules.clear()
     
  return primos


print("***** BUSCADOR DE NÚMEROS PRIMOS *****")
limit = input("Ingrese un número > 1 que defina el final de rango ->   ")

if not limit.isdigit() or int(limit) <= 1:
  print("Invalid Option, Try again!")
else:
  print(" ")
  print("Los números primos dentro del rango son: ", solution(int(limit)))