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: Imprime los n煤meros primos

25/29

Aportes 105

Preguntas 10

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

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馃挌

馃洝锔廙URO 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.

馃憗锔廝roblema 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)

馃帠锔廋onclusi贸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
}
no deja presentar examen porque?? no se se帽al o WiFi nada solo sale que eso se restaurar谩 y nada q se puede

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
Genial, genial, despues de mucho he logrado completar el algoritmo del problema con algunos detalles. Igual necesite de orientacion, pues me cuesta implementar o plasmar la logica del algoritmo en el codigo. Pero de a poco voy mejorando. Aca les dejo mi codigo ```js export function solution(num) { let numerosContenidos = [] let numerosPrimos = [] for (let i = 2; i <= num; i++) { numerosContenidos.push(i) } for (let i = 0; i < numerosContenidos.length; i++) { let num = numerosContenidos[i] let resultado = esPrimo(num) if (resultado) { numerosPrimos.push(num) } } return numerosPrimos function esPrimo(n) { if (n % 2 === 0 && n !== 2) { return false } if (n === 1) { return false } let divisores = [] for (let i = 1; i <= n; i++) { if (n % i === 0) { divisores.push(i) } } if (divisores.length > 2) { return false } return true } } ```Primero relleno el array `numerosContenidos` con todos los numero desde 2 hasta el numero `num` que ingrese en el imput. Desde 2 porque es el primer numero primo. Luego usando un ciclo `for()` recorro el array `numerosContenidos`, y cada uno de los elementos del array lo guardo en la variable `num` (es una variable local, no tiene nada que ver con el `num` de afuera). Cada uno de estos elementos los paso por la funcion `esPrimo` y se guardaran en la variable `resultado` , si el valor de `resultado` es `true`, es decir si el numero es primo, agregara al array `numerosPrimos`. Luego se retorna el valor de `numerosPrimos` en pantalla. :D

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
Muy buenos, lo que m谩s me gusta son los tipo de sucesiones 馃グ

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)
    }
  }
```js export function solution(num) { let arr = []; let arrTemp = []; for (let i = 2; i <= num; i++) { for (let j = 1; j <= i; j++) { i % j == 0 ? arrTemp.push(j) : null; } if (arrTemp.length <= 2) { arr.push(i); arrTemp = []; } else arrTemp = []; } return (arr); } ```
ublic class Main{ public static void main (String\[] args){ int\[] Numerosprimos ={2,3,4,5,7,11}; for ( int numero : Numerosprimos){ switch(numero){ case 2: case 3: case 5: case 4: case 7: case 11: System.out.println(numero+ "si es un numero primo"); break; default: System.out.println(numero+ "no es un numero primo"); break; } } } } me costo dos dias pero logre encontrar un metodo si me fune la cabeza tambi茅n intento de dividir para dos los n煤meros pero quedaba un residuo y todos me daban primos ajjaaja en fin lets go
After many trials, around one month, finally I had to use ChatGPT and this was the most intuitive solution it gave to me. Thanks OpenAI ```js function solution(num) { let primes = []; // Check each number from 2 to num for (let i = 2; i <= num; i++) { let isPrime = true; // Check if i is divisible by any number from 2 to i-1 for (let j = 2; j < i; j++) { if (i % j === 0) { isPrime = false; break; // Exit the loop early if i is not prime } } // If i is prime, add it to the primes array if (isPrime) { primes.push(i); } } return primes; } ```
Hola linda comunidad de Platzi: Con el siguiente c贸digo, si lo aplican en js de manera directa, va ejecutarse de manera correcta. Yo he corrido todas las pruebas, y han salido satisfactorias. Si tienen alguna duda, no duden en consultarme estar茅 aqu铆 para poder apoyarles. Por ende tambi茅n podr谩n visualizar la cantidad de n煤meros primos hasta dicho punto. ```js let array1; function solution(num) { if(num === 0 || num ===1){ array1 = []; } else{ let array = []; array1 = []; let D = 1; let contador = {}; do{ D = D + 1; for(d = 1; d <=D; d++){ if( D%d === 0){ array.push(D); } } } while( D < num); array.forEach(function(elemento) { contador[elemento] = (contador[elemento] || 0) + 1; }); for(let elemento in contador) { if(contador[elemento] === 2) { array1.push(parseInt(elemento)); } } } } solution(1); console.log(array1); ```let array1; function solution(num) { if(num === 0 || num ===1){聽 聽 array1 = \[];}else{let array = \[];array1 = \[];let D = 1;let contador = {};聽do{聽 聽 D = D + 1;聽 聽 for(d = 1; d <=D; d++){聽 聽 聽 聽 if( D%d === 0){聽 聽 聽 聽 聽 聽 array.push(D);聽 聽 聽 聽 }聽 聽 }} while( D < num); array.forEach(function(elemento) {聽 聽 contador\[elemento] = (contador\[elemento] || 0) + 1;聽 });聽for(let elemento in contador) {聽 聽 if(contador\[elemento] === 2) {聽 聽 聽 聽 array1.push(parseInt(elemento));聽 聽 }} }}solution(1);console.log(array1);

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]
Soluci贸n simple```js export function solution(num) { const valores = (num > 1)?[2]:[]; for (let i = 2; i <= num; i++) ((i % 2) != 0) && valores.push(i); return valores } ```export function solution(num) { const valores = (num > 1)?\[2]:\[]; for (let i = 2; i <= num; i++) ((i % 2) != 0) && valores.push(i); return valores }
````js export function solution(num) { let valores = (num > 1) ? [2] : []; for (let i = 2; i <= num; i++) ((i % 2) != 0) ? valores.push(i) : ''; return valores } solution(5) ```export function solution(num) {聽 let valores = (num > 1) ? \[2] : \[];聽 for (let i = 2; i <= num; i++)聽 聽 ((i % 2) != 0) ? valores.push(i) : '';聽 return valores}solution(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
}
```js function esPrimo (num) { let suma = [] if (num === 1) { return suma } else if(num === 2) { return [2] } else if(num > 2) { suma.push(2) } for (let i = 3; i <= num; i++) { let conteo = 0 for (let j = 1; j <= i; j++){ if (i % j === 0){ conteo++ } } if (conteo === 2) { suma.push(i) } } return suma } let resultado = esPrimo(1) console.log(resultado); ```function esPrimo (num) {聽 let suma = \[]聽 if (num === 1) {聽 聽 return suma聽 } else if(num === 2) {聽 聽 return \[2]聽 } else if(num > 2) {聽 聽 suma.push(2)聽 }聽 for (let i = 3; i <= num; i++) {聽 聽 let conteo = 0聽 聽 for (let j = 1; j <= i; j++){聽 聽 聽 if (i % j === 0){ 聽 聽 聽 聽 conteo++聽 聽 聽 }聽 聽 }聽 聽 聽 if (conteo === 2) {聽 聽 聽 聽 suma.push(i)聽 聽 聽 }聽 聽 }聽 聽 return suma聽 } let resultado = esPrimo(1)console.log(resultado);
Mi soluci贸n: ```js export function solution(num) { let x = []; for (let i = 2; i <= num; i++) { let enc = true; for (let j = 2; j * j <= i; j++) { if (i % j == 0) { enc = false; break; } } if (enc) x.push(i); } return x; } ``` Sabemos que un n煤mero primo es aquel que solo tiene dos divisores: 1 y el n煤mero mismo (N). Para verificar si un n煤mero es primo, basta con buscar divisores que sean mayores que 1 y menores que N. Si encontramos alguno, entonces el n煤mero no es primo. Adem谩s, para hacer el proceso m谩s eficiente, solo necesitamos buscar divisores hasta la ra铆z cuadrada de N. Esto se debe a que cualquier factor de N mayor que su ra铆z cuadrada ya habr铆a sido detectado como un factor menor en una etapa anterior. Por lo tanto, si no encontramos ning煤n divisor hasta la ra铆z cuadrada de N el numero sera primo Espero haberme explicado : D

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;
}
```js export function solution(num) { function esPrimo(n) { for (let i = 2; i <= Math.sqrt(n); i++) { if (n % i === 0) { return false; } } return n > 1; } const primos = []; for (let i = 2; i <= num; i++) { if (esPrimo(i)) { primos.push(i); } } return primos; } ```

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)
}
Comparto mi humilde c贸digo :) ```js export function solution(num) { // Tu c贸digo aqu铆 馃憟 let resul = [] let pos = 0 let ja = 0 for (let i = num; i > 1; i--){ if ((i%2) == 1 || (i==2)) { resul[pos] = i; pos++; } } return resul } ```export function solution(num) {聽 // Tu c贸digo aqu铆 馃憟聽 let resul = \[]聽 let pos = 0聽 let ja = 0聽 for (let i = num; i > 1; i--){聽 聽 if ((i%2) == 1 || (i==2)) {聽 聽 聽 resul\[pos] = i;聽 聽 聽 pos++;聽 聽 }聽 }聽 return resul}
Mi soluci贸n: ```js export function solution(num) { let array = []; let isPrimo = 2; while (num >= isPrimo) { let contador = 0; for (let i = 1; i <= isPrimo; i++) { if (isPrimo % i === 0) { contador++; } } if (contador === 2) { array.push(isPrimo); } isPrimo++; } return array; } ```
```js function solution(num) { let res = 0; let ar = []; for (let i = 2; i <= num; i++) { for (let t = 1; t <= i; t++) { if (i % t == 0) { res++; } } if (res == 2) { ar.push(i); } res = 0; } return ar } ```

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

![](https://drive.google.com/file/d/1NWQmWDctk7bXWXou4TJeFUh537iQC8v7/view?usp=drive_link)VACILATELA MI LLAVE 馃

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 馃憤

Mi soluci贸n fue esta ... ![](https://static.platzi.com/media/user_upload/image-c1dc3a3d-7f9b-4a6a-b353-9d21e89e0773.jpg)
C++ `#include <iostream>` `int primos[]{ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31 };` `void f(int n) {` `int t{};` `int i{};` `bool bandera{ true };` `for (i; i < 11 && bandera; i++) {` `if (n > primos[i]) {}` `else if (n == primos[i]) {` `t = i;` `bandera = false;` `for (t; t >= 0; t--) {` `std::cout << primos[t];` `if (t != 0) std::cout << ", ";` `}` `}` `else {` `t = i;` `bandera = false;` `for (t; t >= 0; t--) {` `if (t == i) {` `std::cout << n << ", ";` `}` `else {` `std::cout << primos[t];` `if (t != 0) std::cout << ", ";` `}` `}` `}` `}` `}` `int main() {` `f(25);` `}` `>`
```js export function solution(num) { // Tu c贸digo aqu铆 馃憟 let result = []; function isPrimo(valor) { let primo = true; if (valor == 1) { primo = false; } else if ((valor == 2) || (valor == 3)) { primo = true; } else { let dividendo = Math.round(Math.sqrt(valor)) while (dividendo > 1) { if (valor % dividendo == 0) { primo = false; } dividendo -= 1; } } return primo; } for (let i = 1; i <= num; i++){ if (isPrimo(i)) { result.push(i); } } return result; } ```

Bueno esta es la soluci贸n que encontr茅. El bucle ciclo while se repite mientras 鈥渘um鈥 sea mayor a 1 (entonces recorre cada valor y 鈥渃orta鈥 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 鈥渘um鈥撯 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)))

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

undefined