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
}

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

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

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

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

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

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

Mi solución:

function numerosPrimosHastaEl(num) {
    let resultado = num >= 2 ? [2] : []
    for (let i = 3; i <= num; i += 2) {
        let esPrimo = true
        for (let j = 3; j <= i - 1; j += 2) {
            if (i % j == 0) {
                esPrimo = false
                break
            }
        }
        if (esPrimo) resultado.push(i)
    }
    console.log(resultado)
    return (resultado)
}

numerosPrimosHastaEl(1)     /* Imprime: [] */
numerosPrimosHastaEl(2)     /* Imprime: [ 2 ] */
numerosPrimosHastaEl(3)     /* Imprime: [ 2, 3 ] */
numerosPrimosHastaEl(5)     /* Imprime: [ 2, 3, 5 ] */
numerosPrimosHastaEl(11)    /* Imprime: [ 2, 3, 5, 7, 11 ] */
numerosPrimosHastaEl(13)    /* Imprime: [ 2, 3, 5, 7, 11, 13 ] */
numerosPrimosHastaEl(20)    /* Imprime: [ 2, 3, 5, 7, 11, 13, 17, 19 ] */

Les comparto mi solucion, basica pero explicita

export function solution(num) {
  let array1 = [];
  let i = 2;

  while (i <= num) {
    if (esPrimo(i) == true) {
      array1.push(i);
    }

    i++;
  }

  return array1;
}

function esPrimo(numero) {

  for (let i = numero - 1; i > 1; i--) {
    if (numero % i == 0) {
      return false;
    }
  }

  return true;
}

Logrado!!

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

Mi respuesta al ejercicio

export function solution(num) {
  let arr = []
  let i = 2
  while (i <= num) {
    if (i == 2 || i == 3 || i == 5 || i == 7) {
      arr.push(i);
    } else if (i % 2 != 0 && i % 3 != 0 && i % 5 != 0 && i % 7 != 0) {
      arr.push(num);
    }
    i++;
  }
  return arr;
}

Mi solución del Playgroud:

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

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

Mi solución en Replit:

let num = 5;

console.log("Has pasado el numero: " + num);

function primo(num) {
  if (num < 2) {
    console.log(num + " NO es un numero primo");
  }
  for (var i = 2; i <= Math.sqrt(num); i++) {
    if (num % i === 0) {
      return false;
    }
  }

  return true;
}

let primoNum = [];
for (let i = 2; i <= num; i++) {
  if (primo(i)) {
    primoNum.push(i);
  }
}
console.log(primoNum.join(' | '));

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

function isPrime(num) {
if (num <= 1)
return false;
if (num <= 3)
return true;

if (num % 2 == 0 || num % 3 == 0)
  return false;

for (let i = 5; i * i <= num; i = i + 6)
  if (num % i == 0 || num % (i + 2) == 0)
    return false;

return true;

}
}

Necesito descargar el diploma!!!

Quisiera constancia del curso!!!

C:\Users\USUARIO\OneDrive\Imágenes\Capturas de pantalla\2023-01-16 (2).png

mi aporte

Mi solucion es la siguiente:

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

  for (let i = 1; i <= num; i++){
    let divisibles = 0
    for (let y = 1; y <= i; y++){
      if (i % y == 0) {
        divisibles++
        //este condicional sirva para que si tiene mas de 2 divisibles, no hay necesidad de seguir buscando mas divisores y sale del for
        if (divisibles > 2) {
          break
        }
      }
    }
    if (divisibles == 2) {
      solucion.push(i)
    }
  }
  return solucion
}

Mi solución tratando de hacer el menos trabajo posible 😅`

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

  if (num <= 1) {
    return primeNumbers;
  }

  primeNumbers.push(2);

  for (let i = 3; i <= num; i++) {
    let n = primeNumbers.length;
    let existDivisors = false;

    for (let j = 0; j < n; j++) {
      if (i % primeNumbers[j] == 0) {
        existDivisors = true;
        break;
      }
    }

    if (!existDivisors) {
      primeNumbers.push(i);
    }
  }

  return primeNumbers;

}

Con la ayuda de ChatGPT

export function solution(n) {
  console.log("Inicio de función");
  // Crear un arreglo vacío para almacenar los números primos encontrados
  let primes = [];
  console.log("Entero a operar: " + n);
  
  // Iterar desde 2 hasta el número de entrada
  for (let i = 2; i <= n; i++) {
    console.log("Entrando a primer ciclo for");
    console.log("Valor indice i: " + i);
    let isPrime = true;
    console.log("Valor de isPrime: " + isPrime);
    
    // Iterar desde 2 hasta la mitad del número actual
    for (let j = 2; j <= i / 2; j++) {
      console.log("Entrando a segundo ciclo for");
      console.log("Valor indice j: " + j);
      console.log("Número de iteraciones i/2: " + (i/2));
      let k = i % j;
      console.log("i módulo j: " + k);
      // Si el número actual es divisible por algún número en el rango, entonces no es primo
      if (k === 0) {
        console.log("Entrando a primer condicional if");
        isPrime = false;
        console.log("i % j === 0; entonces, isPrime = " + isPrime);
        console.log("Saliendo de primer condicional if");
        break;
      }
      console.log("Saliendo de segundo ciclo for");
    }
    console.log("Saliendo de primer ciclo for");
    // Si el número es primo, agrégalo al arreglo de números primos
    if (isPrime) {
      console.log("Entrando a segunda condicional if");
      primes.push(i);
      console.log(`isPrime = ${isPrime}; entonces: `);
      console.log("Primo agregado a primes: " + i);
    }
    console.log("Saliendo de segunda condicional if");
  }

  // Regresar el arreglo de números primos ordenado
  // return primes.sort((a, b) => a - b);
  console.log(`Los números primos menores o iguales a ${n} son: ${primes}`);
  console.log("Fin de la función");
  return primes;
}

Bueno les comparto este codigo

export function solution(num) {
  let lista = []
  let numeroVariable
  /* ciclo de 1 hasta el numero proporcionado */
  for (let i = 1; i <= num; i++) {
    /* inicializamos el nuemro en 2 por acada iteraccion */
    numeroVariable = 2
    /* mientras el numero sea menor que i */
    while (numeroVariable < i) {
      /* si i / 2 retorna un residuo de cero entonces no es primo */
      if (i % numeroVariable == 0) {
        /* numero obtiene el valor i + 1  */
        numeroVariable = i + 1
      }
      /* incremento numero */
      numeroVariable++
    }
    /* si numero es igual a i es primo */
    if (numeroVariable == i) {
      /* inserto al final de la lista el numero primo */
      lista.push(i)
    }
  }
  /* retorno la lista o array */
  return lista
}

XD estuvo dificil la verdad,pero mi solucion xd es rara ni siquiera se como funciono

export function solution(num) {
  // Tu código aquí 👈
  var primos = [2]
  var yes_no = true
  var new_num = 2
  if (num != 1) {
    for (let i = 0; i < num - 2; i++) {
      new_num += 1
      if ((new_num % 2) == 1) {
        console.log(new_num)
        for (let i = 2; i < new_num; i++) {
          console.log(new_num / i)
          if ((Number.isInteger(new_num / i))) {
            yes_no = false
            break;
          } else {
            yes_no = true
          }
        }
        if (yes_no) {
          primos.push(new_num)
        }
      }
    }
  } else {
    return primos = []
  }
  return primos
}

export function solution(num) {
  // Tu código aquí 👈
  function isPrime(num) {
    if (num < 2) {
      return false;
    }
    for (let i = 2; i <= Math.sqrt(num); i++) {
      if (num % i === 0) {
        return false;
      }
    }
    return true;
  }

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

Mi solucion, este ejercicio me gusto mucho mas ya que tenia bien claro y definido lo que habia que lograr, tambien era facil poder dar ejemplos de inputs y outputs para poder saber lo que debia devolver el codigo.

a
export function solution(num) {
// Tu código aquí 👈
var arrSolucion = [];
var cont;

for (var i = 2; i <= num; i ++){

cont = 0;

for (var j = 2; j <= i; j++){
  if (i % j == 0)
    cont++;  
}

if (cont == 1)
  arrSolucion.push(i);

}

return arrSolucion;
}

Mi solución:

export function solution(num) {
  var p = [], p2 = [], i1 = 2, i2 = 1
  while (i1 <= num) {
    while (i2 <= i1) {
      if (i1 % i2 == 0) {
        p2.push(i2)
      }
      i2++
    }
    if (p2.length == 2) {
      p.push(i1)
    }
    i2 = 1, i1++, p2 = []
  }
  return p
}

Mi pequeño aporte.

export function solution(num) {
  // Tu código aquí 👈
  let resp = [2]
  if(num===2){return [2]}
  if(num<2){return []}
  for(let i = 3; i <= num ; i++) {
    let div = 1
    let cont = 0
    while(div <= i){
      if(i % div === 0){
        cont++
      }
      div++
    }
    cont === 2 && resp.push(i)
  }
  return resp
}

Con tabla de busqueda, se puede mejorar agregando elementos a la tabla segun sean computados

export function solution(num) {
  var medio = num / 2 + 1;
  var response = [];
  var lookup = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97];

  if (num > 100) {
    response = lookup;

    for (var i = 101; i <= num; i += 2) {
      for (var p = 3; true; p += 2) {
        if (i % p == 0) { break; }
        if (p > medio) { response.push(i); break; }
      }
    }
  } else {
    for (var i = 0; lookup[i] <= num; ++i) {
      response.push(lookup[i]);
    }
  }
  return response;
}

Solucion con programacion dinamica:

export function solution(num) {
    //se llenara a medida que se descubra primos
    const memo = []

    function isPrimo(quantity) {
      // se tiene que agregar el 2 y 3 a la lista de memo
      if (quantity === 2) return true
      if (quantity === 3) return true
      //para poder inicializar
      let idx = 0
      // utilizaremos para verificar, solamente con lo primos descubiertos
      let min = memo[idx]

      while (min <= Math.sqrt(num)) {
        if (quantity % min === 0) {
          return false
        }
        idx++
        min = memo[idx]
      }
      return true
    }
    for (let i = 2; i <= num; i++) {
      if (isPrimo(i)) {
        memo.push(i)
      }
    }
    return memo

}