No tienes acceso a esta clase

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

Curso Básico de Python

Curso Básico de Python

Facundo García Martoni

Facundo García Martoni

Proyecto: prueba de primalidad

26/32
Recursos

En este ejemplo, aprenderemos cómo detectar si un número es primo en Python. Esto se conoce como prueba de primalidad. Un número primo es todo número que puede dividirse únicamente por sí mismo y por 1. Todos los números primos, excepto el 2, son impares.

En la matemática aplicada, los números primos son utilizados para generar códigos criptográficos seguros. Esto se logra empleando los números primos de Mersenne (números muy grandes).

Ejemplo: cómo averiguar si un número es primo en Python

def es_primo(numero):
    if numero == 1:
        return False
    else:
        contador = 0
    for i in range(1 , numero+1):
        if i == 1 or i == numero:
            continue
        if numero % i == 0:
            contador += 1
    if contador == 0:
        return True
    else:
        return False


def run():
    numero = int(input("Escribe un número: "))
    if es_primo(numero):
        print(str(numero) + " es primo")
    else:
        print(str(numero) +  " NO es primo")


if __name__ == "__main__":
    run()

Aporte creado por: Rusbel Bermúdez, César Dávila

Aportes 1610

Preguntas 106

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

El número 1, no es primo, por que debe ser dos veces divisible. y uno es solo divisible una vez.

Encontre un metodo matematico con factorial para saber si un numero es primo:

Sí, el teorema de Wilson:
Un número n es primo si y solo si (n-1)! + 1 es múltiplo de n
Ejemplo:
¿Es 7 primo?
7 es primo si (7-1)! + 1 es múltiplo de 7
(7-1)! + 1 = 6! + 1 = (6·5·4·3·2·1)+1 = 721
¿721 es múltiplo de 7?
721 : 7 = 103 (división exacta)
721 sí es múltiplo de 7 por tanto 7 es un número primo.

def factorial(n):
    fact = 1
    if n < 0:
        return 0
    elif n == 0:
        return 1
    while (n > 1):
        fact *= n
        n -= 1
    return fact


def main():
    numero = int(input("Escoge un numero: "))
    wilson = factorial(numero - 1) + 1
    #print(wilson)
    if wilson % numero == 0:
        print("El numero es primo")
    else:
        print("No es primo")


if __name__ == '__main__':
    main()

Colocando un break al detectar cualquier división exacta con otro número debería ser suficiente para optimizar el código y evitar que se siga ejecutando el for. Esto hace que el programa tenga menos iteraciones y sea más eficiente:

def es_primo(numero): 
    contador = 0

    if numero <= 1:
        return False

    for i in range(1, numero + 1):
        if i == 1 or i == numero:
            continue
        if numero % i == 0:
            contador += 1
            break
    if contador == 0:
        return True
    else:
        return False


def run():
    numero = int(input('Escribe un número: '))

Por el teorema de Wilson

def es_primo(numero):
    factorial = 1
    for i in range(1,numero):
        factorial=factorial*i
    if  ( factorial + 1 ) % numero == 0:
        return "Es primo"
    else:
        return "No es primo"
    

def run():
    numero = int(input("Escriba el numero >>:"))
    respuesta = es_primo(numero)
    print(respuesta)


if __name__ == "__main__":
    run()

Hice un pequeño resumen de los métodos que encontré para probar la primalidad de un número.

  • La Criba de Eratóstenes (200 AC), pero el cual es ineficaz para el análisis de números grandes.
  • “Pequeño Teorema de Fermat”, con el cual se determina una característica que cumplen todos los números primos. Hay que recalcar que esta prueba no es concluyente, debido a que existen los números de Carmichael. Los números de Carmichael cumplen con la condición de Fermat y nos entrega un falso primo positivo.
  • Las pruebas de primalidad de Wilson la cual si es determinística, es decir, con esta prueba se puede decidir de manera efectiva si un número es primo. (con esta implemente el código 😉 )
  • Algoritmo AKS, en el año 2002 Agrawal, Kayal y Saxena presentaron un algoritmo con tiempo de ejecución polinomial, el cual determina si un número natural es primo o no. Esta prueba también es determinística 😃
  • El test de Miller Rabin es un algoritmo probabilístico para determinar si un número dado es primo.
  • El test de Solovay - Strassen el cual también es un algoritmo probabilístico de utilidad en la determinación de la primalidad de un número.

A continuación mi código usando el teorema de Wilson:

vi muchas veces esta clase que a veces me asusta que mucha gente diga que programar es fácil. Para mi algunas veces es algo complejo.

Creo que para los que están sufriendo por entender esto (como yo), les serviría una explicación más simple.

Lo que se hace con esto, según comprendí es que en el momento que los valores del rango i sean iguales a 1 o al valor en la variable número, estos sean omitidos del ciclo.

 if i == 1 or i == numero:
	continue

Siendo así, si tienes un número, digamos 7, solo estarías corriendo el ciclo para 2, 3, 4, 5, 6 con la condicional de abajo: “Si alguno de esos residuales es == 0, el contador aumentará 1”

if numero % i == 0:
            contador = contador + 1

Entonces los residuales serían:

7 % 2 == 1
7 % 3 == 1
7 % 4 == 3
7 % 5 == 2
7 % 6 == 1

Al no existir ningún residual == 0, el contador no se aumenta y permanece igual retornando True.
En caso de haber otro residual == 0 sabríamos que dicho número no es primo porque tendría más de dos divisores haciéndolo compuesto.

Los números omitidos por el continue son los únicos dos divisores que debe tener.

Siendo así 7 es primo.

if contador == 0: 
        return True
    else:
        return False

Así lo comprendí, espero les sirva a los despistados como yo.

'''para saber si un número es primo, se divide este entre los primeros números primos hasta su raiz cuadrada;
si el resultado de alguna de estas divisiones es exacto entonces el número no es primo'''

def es_primo(numero):
    
    validacion = True
    for i in range(1, int(round(numero**(1/2.0),0))):
        if i==1 or i==numero:
            continue
        if numero % i ==0:
            validacion=False
            break
    return validacion


def run():
    numero = int(input("Ingresa un número entero  "))
    if es_primo(numero):
        print("El número {} es primo".format(numero))
    else:
        print("El número {} no es primo".format(numero))        


if __name__ == "__main__":
    run()

Hola espero le guste como hice el desafío. Para ello utilice el Teorema de Wilson

Nota: Seria muy chevere si logran simplificarlo aun más y compartirlo por acá.

def es_primo(numero):
"""
Teorema de Wilson:
Un número n es primo si y solo si (n-1)! + 1 es múltiplo de n
"""
    modulo = (factorial(numero - 1) + 1) % numero

    if modulo == 0:
        return True
    else:
        return False

def factorial(n):
"""
Operador ternario que calcula el factorial de un numero
"""
    return 1 if (n==1 or n==0) else n * factorial(n - 1)

def run():
    numero = int(input('Escribe un número: '))
    if es_primo(numero):
        print('Es primo')
    else:
        print('No es primo')


if __name__ == '__main__':
    run()

Primer caso, versión ineficiente ya que tiene que recorrer todo el rango de números para determinar si es primo. esto es conocido comi un algoritmo de Orden lineal (O n)

def is_primo(item: int):
    temp = 0
    for x in range(1, item+1):
        if item % x == 0:
            temp = temp + 1
        elif temp > 2:
            return False
    
    if temp ==2:
        return True
    else:
        return False


def run():
    number = int(input('Ingresar número: '))  
    print(f'el número {number} es primo? -> {is_primo(number)}')


if __name__ == '__main__':
    run()

Podemos verificar si un número es primo dividiéndolo por números primos hasta la parte entera de su raíz cuadrada como se ilustra:

Codificación:

def run():
    num = int(input("Ingrese el número: "))
    if num >1:
        if prime_test(num):
            print(num, "es primo")
        else:
            print(num, "No es primo")
    else:
        print("El número debe ser mayor que 1")


def prime_test(num):
    sqrt_num = int(num**(1/2))
    for j in range(2,sqrt_num+1):
        if is_prime(j) and num%j == 0:
            return False
    return True


def is_prime(num):
    cont = 0
    for i in range(1,num+1):
        if num % i == 0:
            cont+=1
        if cont > 2:
            return False
    if cont == 2:
        return True
    else:
        return False


if __name__ == '__main__':
    run()

Ejecución:

No sé si sea trampa, pero generé un array de primos elementales y entonces si el número ingresado es divisible entre los primos elementales, no es primo. No importa cuan grande sea el número ingresado, la eficiencia siempre será la misma, pues el número de iteraciones siempre será igual o menor a 4

def es_primo(numero):
    primos_elementales = [2, 3, 5, 7]
    if numero == 1:
        return False
    elif primos_elementales.__contains__(numero):
        return True
    else:
        for i in primos_elementales:
            if numero % i == 0:
                return False
        return True


def run():
    numero = int(input("Ingresa un número: "))
    if es_primo(numero):
        print(f"El número {numero} es primo")
    else:
        print(f"El número {numero} no es primo")


if __name__ == '__main__':
    while(True):
        run()

👾 Comprueba si un número es primo o no.

def primo(numero):
    contador = 0

    for i in range(1, numero + 1):
        if i == 1 or i == numero:
            continue
        if numero % i == 0:
            contador = contador + 1
    if contador == 0:
        return True
    else:
        return False


def run():
    print("COMPRUEBA SI UN NUMERO ES PRIMO\n")
    numero = int(input('Ingrese un número: '))
    if primo(numero):
        print('Es primo')
    else:
        print('No es primo')


if __name__ == '__main__':
    run()

Implementacion del siguiente video de youtube link al video

PASOS:

  1. extraer la raiz cuadrada del numero
  2. obtener los numeros primos menores al resultado de la raiz cuadrada
  3. dividir el numero que nos dieron entre los primos menores
  4. Si al menos un resultado tiene residuo entonces el numero no es primo

PROBLEMA
Si bien debemos hacer menos calculos al sacarle la raiz cuadrada debemos de encontrar los numeros primos menor a este resultado, encontrar los numeros primos menores al resultado es otro calculo que debemos hacer una y otra vez.

IDEA
Seria ideal tener como una memoria que recuerde los numeros primos ya encontrados para asi poder calcular numeros primos aun mas grandes


def primos_menores(prod_raiz):
    contador = 0
    numeros = list(range(1, prod_raiz + 1))
    arr_primos_menores = []

    for i in numeros:
        for j in range(1, i+1):
            if i % j == 0:
                contador += 1
        if contador == 2:
            arr_primos_menores.append(i)
        contador = 0
    return arr_primos_menores


def es_primo(numero):

    contador = 0
    prod_raiz = numero ** 0.5
    prod_raiz = int(prod_raiz)

    arr = primos_menores(prod_raiz)

    for i in arr:
        if(numero % i == 0):
            contador += 1
            break

    if contador != 0 or numero == 1:
        return False
    else:
        return True


def run():
    numero = int(input('Escribe un numero: '))
    if es_primo(numero):
        print('Es primo!')
    else:
        print('No es primo')


if __name__ == '__main__':
    run()

La otra forma que encontré para identificar un número primo fue con los primos inferiores a la raíz cuadrada, y lo extrapolé eso a los números inferiores a la raíz cuadrada, eso reduce la cantidad de iteraciones a realizar por el programa, creo que lo hace más rápido. hice la prueba con primos y no primos inferiores a 100 y con el primo 237532343.

Como los divisores de un numero vienen en pares tal que numero=d1*d2, no es necesario probar con todos los números entre 1 y el numero input, es suficiente con probar hasta la parte entera de su raíz cuadrada. Ese fue mi único cambio en el código, sin embargo por el teorema fundamental de la aritmetica todo entero positivo excepto el 1 se puede escribir como un producto de primos con cierta multiplicidad
Ej: 84=(2^2)37
por lo tanto no es necesario probar con todos los enteros entre 1 y la parte entera de su raiz cuadrada, sino que con los primos de entre estos. Por más que intenté no pude implementar esto en un código por mi cuenta, lo dejaré para futuro. De momento solo esto:

def prime(number):
    counter = 0

    if number == 1:
        return False
    else:
        for i in range(1, int(number ** 0.5)+1):
            if i==1:
                continue
            if number % i == 0:
                counter += 1
        if counter == 0:
            return True
        else:
            return False


def run():
    number = int(input("Input a positive integer: "))
    if number <= 0:
        run()
    else: 
        if prime(number) == True :
            print("It's prime")
        else:
            print("It's not prime")


if __name__=='__main__':
    run()

Parti de esto:
’’'Factorizando
36 = 1 x 36
= 2 x 18
= 3 x 12
= 4 x 9

= 6 x 6

= 9 x 4
= 12 x 3
= 18 x 2
= 36 x 1

nota : se puede observar que los factores de arriba y los de abajo son los mismos pero invertidos

18 = 1 x 18
= 2 x 9
= 3 x 6

= sqrt(18) * sqrt(18)

= 6 x 3
= 9 x 2
= 18 x 1

n = 1 x n
= a x b
= …

=sqrt(n) x sqrt(n)

=…
= b x a
= n x 1
’’’

ningún los número que termine en 0, 2, 4, 5, 6 ó 8 a excepción del 2 y el 5 es primo pues sería múltiplo de 2 y/o 5, entonces con lo que vimos de cadenas de texto podemos decir que no es primo teniendo en cuenta esto sin tener que evaluarlo en estos casos, entonces al evaluar en el for vamos a evaluar que divida solo los impares pues los pares ya habrán sido todos excluidos, por eso en el for lo ponemos que evalué de 2 en 2 empezando en un impar. y lo mas importante es que cuando encuentre un divisor o su ultimo digito haga que no sea primo retornamos de una vez así evitamos que siga buscando mas y de la respuesta más rápido, otro dato importante es que si no tiene divisores menores o iguales a la raiz cuadrada no tendrá divisores mayores tampoco por lo que solo habría que evaluar hasta ahí

def es_primo(NUMERO): # evalua si un número es primo
    if NUMERO == 1:
        return False
    if NUMERO == 2 or NUMERO == 5:
        return True
    prueba_ultimo_digito = str(NUMERO)
    ultimo_digito = prueba_ultimo_digito[len(prueba_ultimo_digito) - 1]
    if ultimo_digito == "2" or ultimo_digito == "4" or ultimo_digito == "6" or ultimo_digito == "8" or ultimo_digito == "0" or ultimo_digito == "5":
        print("cómo el último dígito es " + ultimo_digito)
        return False
    for i in range(3, int(NUMERO ** 0.5 + 1 ), 2): # si no tiene divisores menores a su raíz cuadrada no tendrá mas divisores
        if NUMERO % i == 0:
            print("cómo " + str(i) + " es un divisor")
            return False
    return True

def run():# se acostumbra tener una función run que es donde estarán anidadas las demas funciones
    NUMERO = int(input("ingrese un numero: "))
    if es_primo(NUMERO):
        print(str(NUMERO) + " es un numero primo")
    else:
        print(str(NUMERO) + " no es un numero primo")


if __name__ == "__main__": # aquí es donde siempre inicia el programa
    run()```

Mi forma de resolverlo fue así:

def is_prime(number):
    primes = []
    for i in range(2,number+1):
        imPrime = True
        if len(primes) > 0:
            for prime in primes:
                if i%prime == 0:
                    imPrime = False
                    break
            if imPrime:
                primes.append(i)
        else:
            primes.append(i)
    return primes[-1]==number

number=15
print(is_prime(number))

Imprimi una lista en un rango de 1 a 101 donde me muestra los numeros primos

Hola grupo
Con el teorema de Fermat se comprueba matemáticamente que el numero 1 no es un numero primo, pueden leer mas sobre el en:
https://elpais.com/elpais/2017/08/24/el_aleph/1503587455_519490.html
Mi solución, fue esta:

<code>
    def es_primo(numero):
    fermat = numero - 1
    potencia =2**fermat
    if potencia % numero == 1:
        return True 
    else:
        return False


def run():
    

    numero = int(input("Escribe el numero al que comprobar su primalidad "))
    if es_primo(numero):
        print("Es primo")
    else: 
        print("No es primo")
        
        
if __name__ == "__main__":
    run()
</code>

Este es el método que utilicé para hallar si un número es primo o no.

Y se obtienen estas respuestas:

después de 3 horas logre terminar el reto 😃😃😃, utilice el método de la raíz cuadrada de esta pagina:
https://www.wikiprimes.com/como-saber-si-un-numero-es-primo/
además de usar lo que ya vimos en clase, me decante a usar list() para poder guardar los números primos, hay va el código:

def is_prime(numero):
    valo = int(numero**(1/2))
    v=list()
    v.append(2)
    v.append(3)
    cont = 0
    for i in range(1,valo):
        if i == 1 or i == valo:
            continue
        for k in range(len(v)):
            if v[k]>i:
                break
            if i%v[k]==0:
                cont+=1
        if cont ==0:
            v.append(i)
        cont=0
    for i in range(len(v)):
        if v[i]==0:
            continue
        if numero%v[i]==0:
            cont+=1
        if cont == 0:
            return True
        else:
            return False

def run():
    numero = int(input('escribe un numero: '))
    if numero == 1:
        print('no es primo')
    elif numero%2==0 and numero!=2:
        print('no es primo')
    elif is_prime(numero) or numero== 2:
        print('es primo')
    else:
        print('no es primo')


if __name__ == '__main__':
    run()

Hola!
Investigando encontré que para saber si un número “es primo” basta con probar si el número no es divisible por ningún numero hasta su raíz cuadrada:


def es_primo(numero):
    limite = int(round(numero ** 0.5,0))
    es_primo = True
    i = 2
    while es_primo and i <= limite:
        if numero % i == 0:
            es_primo = False
            break
        i += 1
    return es_primo


def run():
    numero = int(input("Escribe un número: "))
    if es_primo(numero):
        print("Es primo")
    else:
        print("No es primo")


if __name__ == "__main__":
    run()

🟢Programa de validación de números primos tomando como base el Teorema de Korselt. (Pongo los comentarios de manera didáctica)

Un abrazo de gol! 🦾

Código del screenshot:

import math
def is_prime(number):

    if number < 2:
        return False

    root = int(math.sqrt(number)) + 1
    print(f'The rounded number of the square root of {number} is {root}')

    for i in range(2, root):
        if number % i == 0:
            return False
    return True


def run():
    number = int(input('Write a number: '))
    if is_prime(number):
        print(f'It is a prime number')
    else:
        print(f'It is not a prime number')

if __name__ == "__main__":
    run()

uso la raíz del numero primo como limite , ya que según encontré para saber que un numero es primo o no , no es necesario dividirlo entre todos los números anteriores al mismo numero , si no solo hasta los numero primos anteriores a su raíz cuadrada ( en todo caso lo divido entre todos los anteriores de su raíz cuadra que vendría a ser parecido a la afirmación anterior )

import math

def es_primo(numero):
    contador = 0
    raiz = math.sqrt(numero)
    raiz = math.ceil(raiz)
    for i in range(1, raiz):
        if i == 1:
            continue
        if numero % i == 0:
            contador += 1
    
    if contador == 0:
        return True
    else:
        return False


def run():
    numero = int(input("introduce un numero: "))
    if es_primo(numero) == True:
        print("Es primo")
    else:
        print("No es primo")


if __name__ == "__main__":
    run()

Hice la siguiente solución en el siguiente curso de Python, porque tomé primero el segundo 😒

Pero este curso está excelente, me hubiera ayudado mucho haber tomado este curso antes.

Lo hice antes de ver la clase:

def run():
    print("¿Es ")
    numero = int(input())
    print(" un número primo?")
    if numero > 1:
        for i in range(1, numero, 1):
            if numero % i == 0 and i != 1:
                break
        if i == numero - 1:
            print("Sí")
        else:
            print("No")
    else:
        print("No")


if __name__ == '__main__':
    run()

En la matemática aplicada los números primos son utilizados para generar códigos criptográficos seguros. Esto se logra utilizando los números primos de Mersenne (números muy grandes). Por ejemplo las llaves públicas son el resultado de multiplicar 2 números primos muy grandes digamos A y B. mientras que las llaves privadas contienen los dos números primos A y B que son los únicos factores de la clave pública

Aquí mi código de acuerdo a lo aprendido

def primalidad():
    num = int(input("Ingresa un número a verificar: "))
    if num > 1:
        for i in range(2,num): # a partir de 2 porque se sabe que los numero primos son mayores a 1
            if (num % i) == 0:
                print(str(num) + " No es un numero primo")
                break
        else:
            print(str(num) + " SI ES UN NUMERO PRIMO")
    else:
        print(str(num) + " No es un numero primo")


if __name__ == '__main__':
    primalidad()

Les dejo mi solución al reto usando el Teorema de Wilson que es el siguiente:

Un número natural n es un número primo si y sólo si (n - 1)! ≡ 1 mód n

factorial = 1
if numero == 0:
    return False
for i in range(1, numero):
    factorial = factorial*i
factorial += 1
if factorial % numero == 0 and numero > 1:
    return True
else:
    return False

Una forma de optimizar la cantidad de ciclos que debe hacer el programa para determinar si un número es primo, es solo evaluar la división de dicho numero, hasta la raíz cuadrada del mismo mas 1 y al encontrar un numero por el cual sea divisible, interrumpir con un break el ciclo for. Así, el número 997, solo requiere 32 divisiones para darnos cuenta que es primo y no 997.

def es_primo(numero):
    bandera = True
    if numero == 1:
        bandera = False
    elif numero == 2:
        bandera = True
    else:
        raiz_cuadrada = numero**0.5
        limite = int(round(raiz_cuadrada + 0.5,0))
        print ('Raiz-> ' + str(round(raiz_cuadrada,3)) + ' - Solo se evalua hasta-> ' + str(limite))
        for i in range(2,limite+1):
            #print('i->' + str(i) + '. num->' + str(numero))
            if numero % i == 0:
                bandera = False
                break

    return bandera


def run():
    numero = int(input('Escribe un número: '))
    if es_primo(numero):
        print('Es primo')
    else:
        print('No es primo')

if __name__ == '__main__':
    run()

Ya que el objetivo primario es hacer eficiente el código en cuánto a procesamiento, ví que hay otro método para no ejecutar el conteo de números desde 1 hasta n, basta con ejecutar la serie de números hasta la parte entera del resultado de la raíz del número que estamos evaluando, por ejemplo si queremos evaluar el 1000, basta con probar hasta la raíz de 1000 y no hasta el número 1000, aún se podría eficiente más probando en esa cadena solo los números primos y/o desde el principio descartar los pares excluyendo el 2. Pero ya no lo hice con la reducción por raíz considero suficiente para este caso. anexo mi código.

def ev_primo(numero):
contador = 0
raiz = int(round( numero** (1.0/2.0) , 0 )+1)
for i in range (1,raiz):
if ( i1 or i numero ):
continue
if numero % i == 0:
contador = contador + 1
if contador == 0:
return True
else:
return False

def run():
numero = int(input('Intoduce un número entero para evaluar SI es o No un número Primo: '))
numero = round(numero,0)
if ev_primo(numero) == True:
print(‘El numero : ’ + str(numero) + ’ SI es un número Primo’)
else:
print(‘El numero : ’ + str(numero) + ’ NO es un número Primo’)

if name == “main”:
run()

Prueba de primalidad usando raíz cuadrada

def numero_primo(numero):
raiz = int(numero**0.5)
contador = 2
for i in range(2, raiz + 1):
if numero % contador != 0:
contador + 1
if numero % contador == 0:
return False
else:
return True

def run():
numero = int(input('Escribe un número: '))
if numero_primo(numero) == True:
print(‘Es primo’)
else:
print(‘No es primo’)

if name == ‘main’:
run()

Para averiguar si un numero es primo no es necesario hacer la prueba de las divisiones hasta el numero, es suficiente con realizar las pruebas hasta el entero de la raíz cuadrada del numero mas uno, ejemplo si quiero saber si 101 es primo obtengo el entero de la raíz cuadrada de 101 que es 10 mas uno once, entonces aplico las divisiones hasta el numero once.

Imaginemos si el numero es 1000001 basta hacer que el algoritmo haga la prueba hasta 1001.

def run():
    numero=int(input("Ingresa un número por favor: "))
    if numero==2:
        print(str(numero)+" es un número primo.") 
    else: 
        a=2
        while a<numero or numero==1:
            if numero==1:
                print(str(numero)+" no es un número primo.")
                break
            elif numero%(a) ==0:
                print(str(numero)+" no es un número primo.")
                break
            else:
                if a==numero-1:
                    print(str(numero)+" es un número primo.")
                    break
                a=a+1
                continue

   
if __name__== '__main__':
    run() 

El modo más rápido que encontré para verificar la primalidad de un número es el teorema de Wilson donde n es primo si y solo si:
"(n - 1)! + 1" es múltiplo de n, esto es ( (n - 1)! + 1) % n == 0

Además agregué un bucle que emula al ciclo do while que no es nativo de python, que permite repetir el programa para evaluar varios números sin la necesidad de tener que volver a abrir el programa en la terminal, así como también un comando para terminar el programa y un mensaje de error pues la primalidad, por definición, no se puede aplicar a numeros negativos

def factorial(numero):
    contador = 1
    for i in range(1, numero + 1):
        contador *= i
    return contador

def esPrimo(numero):
    if (factorial(numero - 1) + 1) % numero == 0:
        return True
    else:
        return False

def main():
    while True:
        numero = int(input('Escribe un número: '))
        if numero == 0:
            print('0 no es primo, programa finalizado') #para terminar el programa solo hay que ingresar 0
            break
        if numero < 0:
            print('Error, debe ingresar un numero natural') #el concepto de primalidad solo se aplica a numeros enteros positivos
            continue
        if esPrimo(numero):
            print('Es primo!')
        else:
            print('No es primo!')

if __name__ == '__main__':
    main()

Una solución más eficiente usando memoization. Esto lo implementé en el cuarto curso de Python, solo se agrega un diccionario que va guardando los resultados previos y así no se tiene que recalcular un número que se haya preguntado antes:

Hola les comparto mi resolución al desafío.
Primero investigue que basta checar que no sea divisible con números menores o iguales la raíz cuadrada de ese número. Según yo esto lo implemente en el código que viene más abajo.
Pero creo que es importante saber la razón matemática, y es que si un número x no es primo, tiene divisores a y b tales que n = a*b, ahora _**a **_y b no pueden ser ambos mayores a sqrt(x) (hagan la multiplicación). Así en cualquier factorización al menos uno de los divisores debe ser <= sqrt(x). (Si alguien quiere sugerir o comentar algo de este razonamiento me ayudaría mucho).
Bueno y me canse de ir checando solo para un numero así que cheque del 1 al 100, y hasta ahí verifique, espero y no este mal para números mayoes. Saludos a todos 😃

from math import sqrt

def es_primo(numero):
    if numero==1:
        return False
    contador = 0
    for i in range(2, int(round(sqrt(numero)))+1):
        if numero % i == 0:
            contador += 1
    if contador == 0:
        return True
    else:
        return False

def run():
    for i in range(1,100):
        if es_primo(i):
            print("el numero " + str(i) + " es primo.")

if __name__=="__main__":
    run()```

Este es mi aporte, te muestra todos los números primos entre el 1 hasta el valor que le des, con una pequeña optimización de recursos

def run():
    rango = int(input("¿Hasta que numero desea comprobar primos?: "))
    contador = 0
    for n in range(1, rango):
        if n % n == 0 and n % 1 == 0:
            for a in range(1, n+1):
                if contador <= 2:
                    if n%a == 0 and n%a < n:
                        contador += 1
                else:
                    continue
            if contador == 2:
                print(n)
        contador = 0


if __name__ == '__main__':
    run()

La prueba de Wilson es la mas efectiva para este problema, solo debemos agregar una funcion para realizar numeros factoriales.

Aqui les dejo mi solucion:

Al igual que muchos compañeros, lo resolví empleando el teorema de Wilson.

def factorial(num):
  if num < 0: return 0
  if num == 0: return 1
  return num * factorial(num - 1)

def run():
  number = int(input("Ingrese el número a evaluar: "))
  is_prime = factorial(number - 1) % number == -1 % number
  print("Es primo" if is_prime else "No es primo")
  
if __name__ == "__main__":
  run()

Le puse un break y ya xD

def es_primo(numero):
    contador = 0

    for i in range(1, numero + 1):
        if i == 1 or i == numero:
            continue
        if numero % i == 0:
            contador += 1
            break
    if contador == 0: 
        return True
    else:
        return False

def run():
    numero = int(input("Escribe un número: "))
    if es_primo(numero):
        print("Es primo")
    else:
        print("No es primo")


if __name__ == "__main__":
    run()

Encontré esta solución al desafío de primalidad, decidí usar el ciclo while en lugar del for para encontrar el factorial.
La fórmula que encontré es la siguiente:
n es primo si (n-1)! + 1 es múltiplo de n

  • En la función factorial hago el cálculo de (n-1)! + 1.

  • En la función es_primo compruebo que el factorial sea múltiplo de n .

  • Y en la función run compruebo si n es primo o no.

Cualquier consejo u observación será bien recibido.

def factorial(numero):
    LIMITE    = numero
    contador  = 2
    fact      = 1
    while contador <= LIMITE - 1:
        fact = fact * contador
        contador += 1
    fact = fact + 1
    return fact


def es_primo(numero):
    if factorial(numero) % numero == 0:
        return True
    else:
        return False


def run():
    numero = int(input('Escribe un número: '))
    if numero == 1:
        print('No es primo')
    elif numero > 1:
        if es_primo(numero):
            print('Es primo.')
        else:
            print('No es primo.')


if __name__ == '__main__':
    run()

Escribí un pequeño código que dice si es primo o compuesto, además de decirte los divisores del número

n= int(input("Escribe un número: "))
v=1
list=[1]

for k in range(2,n+1):
	if k==1 or k==n :
		list.append(k)
	else:
		if n % k == 0 :
			list.append(k)
			v*=0

if n==1:
	print("1 no es primo ni compuesto")
else:
	if v!=0:
		print("primo")
	else:
		print("compuesto")

print("Sus divisores son: ")
print(list)

numeros primos con while

def numeros_primo(numero_ingresar,contador):
    a = 1
    while a < numero_ingresar :
        a += 1
        if numero_ingresar % a == 0 :
          contador += 1  
    
    if contador == 1:
        return True
    else: 
        return False
    
def run():   
    numero_ingresar = int(input('Ingrese un numero: '))   
    contador = 0
    numeros_primo(numero_ingresar,contador)
    if numeros_primo(numero_ingresar,contador):
        print('es primo')
    else:
        print('no es primo') 
    
if __name__ == '__main__' :
    run()

Este es mi código, le agregue varias cosas que investigue para que se limpiara la consola, además de que pregunta si quiere saber si otro número es primo, y te pide un número positivo en caso de escribir una letra.

import math
import os

if os.name == "posix":
    os.system("clear")

def es_primo(numero):
    
    raiz = int(math.sqrt(numero))    
    contador = 0

    for i in range(1, raiz + 1):
        
        if i == 1 or i == numero:
            continue
        if numero % i == 0:
            contador += 1
    if numero == 1:
        return False
    if contador == 0:
        return True
    else:
        return False
    

def run():
    while True:
        try:
            numero = int(input("Escribe un número para saber si es primo: "))
            break 
        except ValueError:
            print("Escribe un número positivo")
            
    if es_primo(numero):
        print('Es primo')
    else:
        print('No es primo'
    
    while input("¿Quieres saber si otro número es primo? (S/N): ").upper() == "S":

        if os.name == "posix":
            os.system("clear")

        while True:
            try:
                numero = int(input("Escribe un número para saber si es primo: "))
                break 
            except ValueError:
                print("Escribe un número positivo")
        if es_primo(numero):
            print('Es primo')
        else:
            print('No es primo')
    print("¡Hasta la próxima!")

    
if __name__ == '__main__':
    run()

Así lo hice yo. Utilicé otras cosas que investigué para evitar ingresar un valor que de error (letras, negativos). 😉

< import math

print('Programa para determinar si un numero ingresado por el usuario es primo - RDAN')


def prime(number):

    factorial_prime = math.factorial(number - 1) + 1 # Teorema de Wilson: Un número n es primo si y solo si (n-1)! + 1 es múltiplo de n
        
    if factorial_prime % number == 0 and number != 1:
        return True
    else:
        return False 


def main():

    cond = True
    
    while cond:
        try:
            input_number = int(input('Ingrese el numero que desea saber si es primo o no: '))
            if input_number > 0:
                cond = False
            else:
                print('Ingrese un numero positivo!')
        except ValueError:
            print('Ingrese un numero válido!')

    if prime(input_number):    
        print('El numero {} es primo'.format(input_number))
    else:    
        print('El numero {} No es primo'.format(input_number))


if __name__ == '__main__':
    
    main()> 

Así debería ser más rapido

def es_primo(numero):

    for i in range(1, numero + 1):
        if i == 1 or i == numero:
            continue 
        if numero % i == 0:
            return False

    return True```

Codigo para sacar numeros primos segun el teorema de wilson. Tuve que aplicar recursividad para encontrar el factorial. El teorema de wilson: Un número n es primo si y solo si (n-1)! + 1 es múltiplo de n. (Por lo que investigue no es muy eficiente, pero te saca casi cualquier numero primo)

def factorial(number):
    if number == 0 or number == 1:
        resultado = 1
    elif number > 1:
        resultado = number * factorial(number - 1)
    return resultado


def verifying(total, number):
    if total % number == 0:
        print('Es numero primo')
    else:
        print('No es primo compa')


def run():
    user_number = int(input('Ingresa un numero para conocer si es primo o no: '))
    number_for_method = user_number - 1
    prime_method = factorial(number = number_for_method) + 1
    verifying(total = prime_method, number = user_number)


if __name__ == '__main__':
    run()```

te indica que números primos hay hasta el numero que ingreses, me costo mas de lo que pense xd

def run():
    numero = int(input("que numeros primos hay hasta el numero ?: "))

    for i in range(1, numero):
        contador = 0
        if i == 1 or i == numero:
            continue
        for j in range(1, i):
            if j == 1 or j == i:
                continue
            if (i % j) == 0:
                contador += 1
        if contador == 0:
            print(f'{i} SI es primo')


if __name__ == "__main__":
    run()

Para los que quieren evitar que considere al 1 como número primo, ya que para ser primo debe tener 2 divisores ( el 1 y el mismo número)

Hola a Todos! esta es mi propuesta de solución con validación de lementos en listas. Saludos.

<def es_primo(num):
    divisibles = [] 
    for i in range(2,num + 1):
        if num % i != 0:
            continue
        divisibles.append(i)
    if divisibles[0] == num:
        print('Primo')
    else:
        print('No Primo')
    
            
if __name__ == '__main__':
    es_primo(int(input('Digite el numero: ')))    
 > 
def es_primo(numero):
    for i in range(2, numero):
        if numero % i == 0:
            return False
    return True


def run():
    numero = int(input("Ingrese un numero: "))
    if es_primo(numero):
        print("El numero es primo")
    else:
        print("El numero no es primo")


if __name__ == '__main__': 
    run()

Aquí dejo mi aporte, usé ciclo for y break. Coloqué para que especificara que el número debe ser mayor a uno, y en caso de ser igual 1 la entrada del usuarion, devolver una oración con el por qué no es válido. Además en caso de ser menor que uno, se pide ingresar un número válido.

def run():
numero = int(input(“Ingresa un número:”))
if numero > 1:
for i in range(2,numero):
if (numero % i) == 0:
print(numero, “no es primo”)
print(i,“por”, numero // i, “es”, numero)
break
else:
print(numero, “es un número primo”)
print(“Porque solo es divisible entre sí mismo y la unidad”)
elif numero == 1:
print(“El número 1 sólo tiene un divisor”)
else:
print(“Ingresa un número mayor a 1”)

if name == ‘main’:
run()

Les dejo mi aporte, el algoritmo tiene un pequeño cambio el cual corrige el detalle que 1 no es primo y por otro lado, si encuentra que el número “no es primo”, el algoritmo se detiene, lo que ahorra el número de iteraciones.

def es_primo(numero):
    if numero == 1:
        return False
    else:
        for i in range(2, numero):
            modulo = numero % i
            if modulo == 0:
                return False
                break
        return True```

Todos los números primos, excepto el 2, son impares. Los únicos dos números primos.

def calculoprimo(num):
noprimo = num % 2

if noprimo == 0:
    print("No es un numero primo")
elif noprimo==2:
    print("Es un numero primo apesar de ser un numero par")
else:
    print("ES un numero primo")

def run():
num = int(input("Digite un numero: ") )
calculoprimo(num)

if name== ‘main’:
run()

def es_primo(numero):
contador = 0

for i in range(1, numero + 1):
    if i == 1 or i == numero:
        continue
    if numero % i == 0:
        contador += 1
if contador == 0:
    return True
else:
    return False

def run():
numero = int(input('Escribe un numero: '))
if es_primo(numero):
print(‘Es primo’)
else:
print(‘No es primo’)

if name == ‘main’:
run()

def es_primo(numero):
factorial = 1
for i in range(1,numero):
factorial=factorial*i
if ( factorial + 1 ) % numero == 0:
return "Es primo"
else:
return “No es primo”

def run():
numero = int(input(“Digite el numero >>”))
respuesta = es_primo(numero)
print(respuesta)

if name == “main”:
run()

Les comparto mi código con el que hallo y cuento los primos menores o iguales al número ingresado. Nótese que si quitamos el print del elif de la función run() este código solo sería un contador de números primos.

def es_primo(numero):
    contador = 0

    for i in range(1, int(numero**0.5)+1):
        if i == 1 or i == numero:
            continue
        if numero % i == 0:
            contador += 1
            break
    if contador == 0:
        return True
    else:
        return False


def run():
    numero = int(input('Ingrese un número: '))
    n = 0
    for i in range(1, numero +1): 
        if i == 1:
            i +=1
        elif es_primo(i):
            print(str(i) + ' es primo')
            i +=1
            n +=1 
        else:
            i +=1

    
    print('''
        Hay ''' + str(n) + ' números primos menores o iguales al número ingresado')

if __name__ == '__main__':
    run()

Otra forma de averiguar si un número es primo, es la siguiente:

paso 1 : averiguar la raíz cuadrada de ese número

paso 2: dividir al número ingresado por los números primos inferiores a esa raíz

paso 3: comprobar que al hacerlo ninguna división de cero como resto

Por ejemplo:
si ingreso el 9, la raíz cuadrada es 3; por lo tanto sólo compruebo dividiendo mi numero ingresado ( 9) por 2 y 3 ; si nunca obtengo cero, es primo (no es el caso)

En base a este método escribí mi código, con la salvedad que divido a mi número ingresado por todos los números inferiores a su raíz (no sólo los primos) , porque no supe cómo resolver esa cuestión, pero me funcionó!

def es_primo(numero):
    contador = 0
    import math
    raiz_numero =int(math.sqrt(numero))
    for i in range (2, raiz_numero + 1):
        if numero % i == 0: 
            contador +=1                

    if contador == 0:
            return True
    else:
            return False



       
    
def run():
    numero = int(input('ingrese un número: '))
    if es_primo(numero):
        print('es primo ')
    else:
        print('no es primo ')   



if __name__ == '__main__':
    run()

Este código es una alternativa sin ciclos usando los condicionales, tengamos en cuenta que los número primos principales son 2, 3, 5 y 7, lo demas dentro del rango 1 hasta 9 no son primos por definición, si tomamos un número cualquiera y si su modulo(%) con 2, 3, 5 y 7 es diferente de 0, ese número es primo siempre. Por ejemplo: 17%2=1, 17%3=2, 17%5=2, 17%7=3, sus resultado dieron distintos a 0, por lo cual 17 es un número primo, pero entonces busquemos otro ejemplo con un número que no es primo 91, 91%2=1, 91%3=1, 91%5=1, 91%7=0, como 91%7 no es diferente de 0, entonces 91 no es un número primo.

def main():
    numero = int(input("Escribe un numero: "))
    if numero==2 or numero==3 or numero==5 or numero==7:
        print("Es primo")
    elif numero%2!=0 and numero%3!=0 and numero%5!=0 and numero%7!=0:
        print("Es primo")
    else:
        print("No es primo")
main()

Dejo mi rebuscada solución:

import math

def es_primo(numero):
    # se asume que 2, 3 y 5 son primos
    if numero in ['2', '3', '5']:
        return True

    # se asume que 1 no es primo
    # se descartan todos los numeros pares
    # se descartan todos los numeros que terminan en 5 ya que son divisibles entre 5
    if numero == '1' or es_par(numero) or numero[-1] == '5':
        return False

    numero = int(numero)

    # se descartan todos los numeros divisibles entre 3
    if numero % 3 == 0:
        return False

    medio_superior = math.ceil(int(numero) / 2)
    # No es necesario verificar numeros superiores a la mitad del numero
    # se inicia la verificacion desde el 7 ya que es primo y se descartaron con anterioridad los primos inferiores
    # se usa el range de 2 en 2 para evitar los numeros pares
    for i in range(7, medio_superior + 1, 2):
        if numero % i == 0:
            return False
            
    return True

def es_par(numero):
    numero = int(numero)
    if numero % 2 == 0:
        return True


def run():
    numero = input("Escribe un número: ")

    if es_primo(numero):
        print(str(numero) + " es primo")
    else:
        print(str(numero) + " no es primo")


if __name__ == "__main__":
    run()

Teorema de Wilson

import math


def es_primo(numero):
    #Teorema de Wilson
    p = (math.factorial(numero-1)) +1
    if p % numero == 0:
        return True
    else:
        return False


def run():
    numero=int(input('Inseratar un numero:'))
    
    if es_primo(numero):
        print(f'el {numero} es primo')
    else:
        print(f'el {numero} no es primo')
    

if __name__ == "__main__":
    run()

No encontré un método matemático distinto, pero acorté un poco la función del booleano:

def es_primo(numero):
    if numero == 1:
        return False

    for i in range(2, numero):
        if numero % i == 0:
            return False
        else:
            continue
    return True


def run():
    numero = int(input('Escribe un número: '))
    if es_primo(numero):
        print('Es primo.')
    else:
        print('No es primo.')


if __name__=='__main__':
    run()

Hola amigos, estuve casi dos horas leyendo explicaciones del teorema de wilson para poder llevar eso a programación y logré hacerlo de esta forma, espero les sirva:

from math import factorial

def main():
    numero = int(input("Escribe un número: "))

    # Por teorema de Wilson

    # El teorena establece que un número n es primo si y solo si el factorial
    # de dicho número menos uno (n-1)!, es igual a -1 modulo de p

    if numero > 1:
        numero_oper = numero - 1
        resultado_fact = factorial(numero_oper)

        div_modulo = (resultado_fact % numero) - numero

        if div_modulo == -1:
            print("{} es un número primo.".format(numero))
        else:
            print("{} no es un número primo.".format(numero))


if __name__ == '__main__':
    main()

Mi aporte 😃

def run():
    numero = int(input('Ingrese el número: '))
    if primo(numero):
        print('El número ' +str(numero) + ' ES primo')
    else:
        print('El número ' +str(numero) + ' NO es primo')


def primo(numero):
    if numero < 2:
        return False
    else:
        for i in range(2, numero):
            if numero % i == 0:
                return False
            else:
                continue
    return True


if __name__ == '__main__':
    run()```

RETO: Buscar una forma diferente más eficiente de saber si un número es primo o no

En este caso usaremos el teorema de Wilson = Un número n es primo si y solo si (n-1)! + 1 es múltiplo de n.

import math

def es_primo(numero):
  if ((math.factorial(numero - 1 ) + 1) % numero == 0):
    return True
  else:
    return False


def run():
    numero = int(input("Ingres el número: "))
    if es_primo(numero):
      print("El número " + str(numero) + " es primo")
    else:
      print("El número " + str(numero) + " no es primo")


if __name__ == '__main__':
  run()

Para saber si un número es primo, se divide este entre los primeros números primos hasta su raíz cuadrada;
si el resultado de alguna de estas divisiones es exacto entonces el número no es primo:
Videos explicativo: https://www.youtube.com/watch?v=SnHusNzNjQQ

Entonces en este caso el numero no se va a dividir desde 1 hasta el mismo numero, sino que se va a dividir desde el 1 hasta resultado de la raíz del numero que ingreso el usuario
En la función es_primo agregue primero un calculo matemático para saber la raíz del numero que se ingresa y ese resultado lo incorporo en el ciclo for :

def es_primo(numero):
    import math

    resultado = int(math.sqrt(numero))
        
    contador = 0

    if numero <= 1:
        return False

    for i in range(1, resultado + 1):
        if i == 1 or i == numero:
            continue
        if numero % i == 0:
            contador += 1
    if contador == 0:
        return True
    else:
        return False            


def run():
    numero = int(input("Escribe un número: "))
    if es_primo(numero):
        print("Es primo") 
    else:
        print("No es primo")
        

if __name__ == "__main__":
    run()

Hola compañeros. Hice un programa que te dice si el número ingresado es primo o no. Lo hice antes de que lo desarrollara el profesor. Seguro veré la clase y mejoraré mi código.

def run():
    numero=int(input('Ingrese numero: '))
    numeros=range(1,(numero+1))
    numeros=numeros[::-1]
    for i in numeros:
        num_anterior=i-1
        residuo=numero%(num_anterior)
        if residuo==0:
            break
    if num_anterior > 1:
        print('No es numero primo.')
    else:
        print('Es numero primo')


if __name__=='__main__':
    run()

Hay un teorema que dice que podemos solo probar hasta la raíz cuadrada del número entonces mi código quedo así. 😄

def es_primo(numero):
    if numero < 2:
        return False
    contador = 0
    for i in range(1, int((numero**0.5)) + 1):
        if i == 1 or i == numero:
            continue
        if numero % i == 0:
            contador += 1
    if contador > 0:
        return False
    else:
        return True


def run():
    numero = int(input("Escribe un numero: "))
    if es_primo(numero):
        print("Es primo")
    else:
        print("No es primo")


if __name__ == "__main__":
    run()

Utilice el teorema de Wilson para determinar si un número es primo: Utilizando la expresión P = (Numero-1)! + 1 dicho resultado se divide entre el numero a determinar si es primo si es divisible se considera que es un numero primo.

numero = int(input'escribe un número:  ')
factorial = 1
p = numero - 1
if p !=0:
    for i in range(1, p+1):
          factorial = factorial * i
    resultado = factorial + 1
if resultado % numero == 0:
    print('Es primo')
else:
    print('No es primo')   
     

Intenté simplificar un poco el código, me quedó de esta manera.

def es_primo(numero):
    if numero == 1:
        return False
    
    for i in range(1,numero+1):
        if i == numero:
            continue
        if i % 2 == 0:
           return False
    
    return True


def run():
    numero = int(input("Ingrese un número: "))
    if es_primo(numero):
        print(str(numero) + " es un número primo")
    else:
        print(str(numero) + " no es un número primo")


if __name__ == '__main__':
    run()

Muy bueno el curso!

Esto fue lo que se me ocurrió para la función es_primo antes de ver el video. Se aprende mucho tratando de resolver los problemas antes de ver cómo lo hace el profe

Saludos!

def es_primo(numero):
    for i in range(2,numero):
        if numero % i == 0:
            return False
        else:
            continue
    return True 

Hola a todos

El reto lo resolvi usando el teorema de Wilson, donde:

Un número n es primo si y solo si (n-1)! + 1 es múltiplo de n
COmparot el link donde encontre la informacion, y el codigo que utilice para desarrollarlo

https://www.masscience.com/2019/10/27/es-posible-encontrar-una-formula-que-permita-comprobar-si-un-numero-es-primo/

from math import factorial

def TeoremaWilson(Numero):
    if (factorial(Numero - 1)+1) % Numero == 0:
        return True
    

def run():
    Numero= int(input('Que numero desea validar?: '))
    if TeoremaWilson(Numero):
        print('Es primo')
    else:
        print ('No es primo')

    
if __name__ == '__main__':
    run()


Espero les guste! 😄

En la función es_primo, en el ciclo for, en lugar de poner range(1,número +1), coloco range(2, (número/2)+1). Asi evito hacer la mitad de divisiones que son sin sentido ya que al dividir cualquier número por otro que sea mayor a la mitad del primero todos los resultados van a ser 1 coma algo, hasta llegar al número y ahí recién dará la división 1

<code> 
def is_it_prime_number(number):
    counter = 0
    for i in range(1, (number // 2) + 1):
        if i == 1:
            continue
        if number % i == 0:
            counter = 1
            break
    return counter == 0

def run():
    number = int(input('Escribe un número: '))
    if is_it_prime_number(number):
        print('Es primo')
    else:
        print('No es primo')

if __name__ == '__main__':
    run()

Esta es mi funcion para saber si el numero es primo o no

def es_primo(numero):
  cantidad_divisores = 0
  if numero == 1:
    return False
  
  for i in range(1,numero+1):
    if numero % i == 0:
      cantidad_divisores += 1
  
  if cantidad_divisores > 2:
    return False
  else:
    return True

Al ver la clase me surgió la duda de qué sucedería sí se ingresara el número 27.

ÉSTO RESUELVE EL PROBLEMA DE INGRESAR 1 Y 27…

Agradecido de antemano a cualquier corrección!!! ❤️

.
.
.

def primo(a):
mitad = float(a / 2)
mitad = round (mitad, 0)
if a <= 1:
return True
for i in range (2, a+1):
division = a % i
if division != 0:
continue
if a % i == 0 and i < mitad:
print("Es divisible por: " + str(i) + “…”)
return (True)
else:
return(False)
.
.
.

def run():
numero = int(input("Ingresa un numero: "))
es_primo = primo(numero)
if es_primo == False:
print(“Es primo”)
else:
print(“No es primo”)

Reto:
Utlilce la fórmula de John Wilson (1741 – 1793) que dice:

Un número n es primo si y solo si (n-1)! + 1 es múltiplo de n

Entonce el código me quedó así:

# Teorema de John Wilson para saber si un número es primo
def es_primo(numero):
    valor_n = numero - 1
    for i in range (1, valor_n):
        valor_n = valor_n * i
    
    valor_multiplo = valor_n + 1
    
    if valor_multiplo % numero == 0:
        return True
    else:
        return False


def run():
    numero = int(input('Escribe un número: '))
    if es_primo(numero):
        print('Es primo')
    else:
        print('No es primo')


if __name__ == "__main__":
    run()

Hola a todos, lo hice de esta forma

def run():
    numero = int(input("Ingrese Número para establecer si es primo: "))
    contador = 0
    for i in range(1,numero+1):
        if numero%i==0:
            contador += 1
    if contador == 2:
        print(f"El número {numero} es primo")
    elif numero == 1:
        print(f"El Número {numero} es primo")
    else:
        print(f"El numero {numero} NO es primo")


if __name__ == '__main__':
    run()

Sé que este aporte es largo, pero créeme que vale la pena leer. Aquí te muestro el poder de la optimización.

  • Primero: ningún número que termine en 0, 2, 4, 6, 8 es primo, ya que se puede dividir entre 2. Con esto podemos reducir a la mitad la cantidad de números que nuestro programa tiene que comprobar.

  • Segundo: Después de que “contador” es mayor que “numero/2”, podemos dar por hecho que los siguientes números no se podrán dividir entre ningún otro número.

  • Tercero: Tomando en cuenta los dos puntos anteriores, podemos dar por hecho que si “contador” es mayor a “numero/3”, entonces ningún número después de “numero/3” será dividible, ya que si “contador” es mayor que “numero/3”, el último número por el que se puede dividir es 2, y tomando en cuenta que eliminamos todos los números que en el primer punto quitamos todos los números divisibles entre 2, podemos dar por hecho que ningún número mayor a “numero/3” podrá dividir a “numero”.

  • Cuarto: Dados los puntos anteriores, podemos decir que si hacemos “numero%9 != 0” (nos saltamos los números que terminan en 0,2,4,6,8 por lo explicado en el primer punto) y el resultado es False, entonces todos los números desde “numero/9” hacia delante son indivisibles por cualquier número que sea menor a 9 (véase: 7,5,3).

  • Quinto: Dados los puntos anteriores, podemos asegurar que llegado el punto en el que “contador” sea mayor que “numero”, todos los números por comprobar son falsos (no pueden dividir a numero), por lo cual podemos implementar esto en nuestro algoritmo para hacer que se detenga en esta parte y hacerlo MUCHÍSIMO más eficiente.

  • Por ejemplo, si antes para comprobar que el número “1000000000” (diez millones) es primo ocupábamos hacer DIEZ MILLONES de operaciones, ahora:

  • Aplicando el primer punto: tardaríamos CINCO MILLONES de operaciones;

  • Aplicando el segundo punto: tardaríamos DOS Y MEDIO MILLONES de operaciones;

  • Aplicando el tercer punto: tardaríamos UNO MILLON 333K operaciones.

  • Y aplicando el quinto punto, tardaríamos SÓLO 1,581 operaciones.

  • Es decir, aplicando estos puntos hicimos que nuestro programa que antes le tomaría DIEZ MILLONES de operaciones, ahora le tomara poco más de 1,500.

  • Les invito a que prueben mi código y lo comprueben por ustedes mismos. Incluso con números más rápidos sigue siendo eficiente. AUNQUE no creo que sea lo más eficiente posible. Si alguien encuentra una forma de aumentar su eficiencia estaré gustoso de leer!

from ast import If
from pickle import FALSE


def dividir_primos(numero):
    inicial = 3
    dividio = False
    #mitad = int(numero/2)+1
    #tercio = int(numero/3)+1
 
    while dividio == False and inicial <= numero/inicial:
        resultado = numero % inicial
        if resultado == 0:
            dividio = True
        else:
            inicial += 2


    if dividio == False:
        print(f"#{numero} es PRIMO     Coincidencia en {inicial}      Divisiones totales: {int((inicial - 1) / 2)}")


def run(): 
    inicial = 10000000
    final = 10000100

    print("V4")
    for i in range (inicial, final):
        if i % 2 != 0:
            dividir_primos(i)


if __name__ == "__main__":
    run()

Yo lo hice de la siguiente forma:

def run():
    numero = int(input("Escribe un numero: "))
    n1 = (numero + 1)
    n2 = (numero - (1/2))
    n3 = n1 * n2

    if n3 % 3 == int:
        print ("es primo")
    else:
        print ("no es primo")

if __name__ == '__main__':
   run()

Se puede validar si un numero es primo revisando si es divible entre los enteros hasta su raiz cuadrada, este es el codigo que desarrolle:

def es_primo(numero):
    raiz = int(numero**(1/2))
    primo = True
    for i in range(1, raiz + 1):
        if i == 1:
            continue
        if numero % i == 0:
            primo = False
            break
    return primo


def run():
    numero = int(input('Escribe un número: '))
    if es_primo(numero):
        print('Es primo')
    else:
        print('No es primo')


if __name__ == '__main__':
    run()

Para saber si un numero es primo encontré el teorema de Wilson

def es_primo(num):
    for n in range(2,num):
        if num % n  == 0:
            return False
    return True


def run():
    numero = int(input("Por favor escribe un número para descubrir si es un número primo: "))
    numero = abs(numero)
    if es_primo(numero):
        print("El número " + str(numero) + ' es primo')
    else:
        print("El número " + str(numero) + ' no es primo')


if __name__ ==  '__main__':
    run()

Solución utilizando el Teorema de Wilson y la librería math:

from math import factorial


def run():
    n = int(input("Write n until= "))
    for i in range(0, n + 1):
        if i <= 0 or i == 1:
            print(f"{i}  Isn't prime")
        elif (i - 1) * (factorial(i - 1) + 1) % i == 0:
            print(f"{i} It's prime")
        else:
            print(f"{i} Isn't prime")


if __name__ == '__main__':
    run()

Así fue como yo “optimice” el código hecho por Facundo

def isPrime(number):
  if number == 1:
    return False
  else:
    for i in range(2, number):
      if number % i == 0:
        return False

    return True

Aquí como opción el teorema de Wilson para números primos

# El teorema de wilson dice que n es primo si ((n - 1)! + 1)/n es una división exacta
 
def es_primo(entrada):
    n = 1
    lim = entrada - 1
    for i in range(lim,0,-1):
        n = n * i
    n = n + 1

    if n % entrada == 0 and entrada != 1:
        return True
    else:
        return False
def run():
    print("******************************************************************************")
    print("* Bienvenido                                                                 *")
    print("* Este programa te dira si un numero es primo                                *")
    print("******************************************************************************")
    entrada = int(input("Indica el numero a analizar: "))
    if es_primo(entrada):
        print("El numero " + str(entrada) + " es un número primo")
    else:
        print("El numero " + str(entrada) + " NO es un número primo")


if __name__ == '__main__':  # es una buen practica de Python 
    run()
def es_primo(numero):
    factorial = 1
    if numero > 0 and numero != 1:
        for i in range(1,numero):
            factorial = factorial * i
    if (factorial + 1) % numero == 0:
        return True
    else:
        return False


def run():
    numero = int(input("Ingrese un número: "))
    if es_primo(numero):
        print("es primo")
    else:
        print("No es primo")


if __name__ == "__main__":
    run()

Prueba de primalidad con ciclo While

def primo(numero):
    contador = 0
    i = 1
    while i <= numero:
        if i == 1 or i == numero:
            continue
        if numero % i == 0:
            contador += 1
        i++
    if contador == 0:
        return True
    else:
        return False  


def run():
    numero = int(input('Escribe un numero: '))
    if primo(numero):
        print('Es primo')
    else:
        print('No es primo')

if __name__ == '__main__':
    run()

Este es mi aporte, traté de usar la menor cantidad de líneas de código.

Como no se necesita dividir entre el número 1 y el mismo que estamos trabajando, NO los incluyo dentro del rango. En caso de que el número sea 1 NO entra en el ciclo for y se declara de inmediato que no es primo. En caso de que se encuentre un sólo módulo igual a cero salimos del ciclo inmediatamente, ya que no es necesario seguir buscando.

def prime_number(number):
    for i in range(2,number):
        if number % i == 0:
            return False
        return True
    return False

def run():
    n = int(input('Escribe un número entero positivo'))
    if prime_number(n):
        print("Es primo")
    else:
        print("No es primo")

if __name__ == '__main__':
    run()
el rango podria no ser desde 1 hasta numero sino basta que sea hasta la raiz cuadrada de numero. pues la matematica sugiere que no se necesita evaluar en todos los numeros sino hasta el numero que sea la raiz cuadrada del numero que queremos verificar si es primo, de esa forma es mucho mas rapido y funciona para numeros muy grandes.

Les comparto mi solución con el teorema de wilson y descartando antes de aplicar el teorema los numeros que sean multiplos de 2, 3 y 5.

Esto porque es menos costoso computacionalmente dividir entre 2 para obtener el modulo, que aplicar el teorema de wilson. Entonces al agregar el caso de multiplos de 2 se evita calcular el factorial para la mitad de los numeros que existen (pares). Con la misma logica descarto los multiplos de 3 y de 5.

import math


def es_primo(numero):
    if numero == 1:
        return False
    elif numero == 2 or numero == 3 or numero == 5:
        return True
    elif numero % 2 == 0 or numero % 3 == 0 or numero % 5 == 0:
        return False
    else:
        if (math.factorial(numero-1) + 1) % numero == 0:
            return True


def run():
    numero = int(input('Escribe un numero entero: '))
    if es_primo(numero):
        print('Es primo')
    else:
        print('No es primo')


if __name__ == '__main__':
    run()

Aquí mi ejemplo,
lo forma de resolverlo fue encontrar los números compuestos (los que no son primos)
Considero que se resuelve de manera más eficiente ¿qué opinan?

Aquí el programa.

def es_primo(numero):
    if (numero == 2 or numero == 5):
        return True
    if (numero == 1):
        return False
    elif numero % 2 == 0 or numero % 4 == 0 or numero % 5 == 0 or numero % 6 == 0 or numero % 8 == 0:
        return False
    else:
        Sdigitos, ExtraerN = 0,0
        while numero != 0:
             ExtraerN = numero % 10.
             numero //= 10.
             Sdigitos+= ExtraerN
             if(Sdigitos%3==0):
                return False
             else:
                return True        


def run():
    numero = int(input('introduce tu numero para saber si es primo: '))
    if es_primo(numero):
        print('Es primo')
    else:
        print('No es primo')
    
    
if __name__ == '__main__':
    run()

💚💚 Primalidad 💚💚

  • Los números primos: son aquellos que sólo son divisibles por uno y por sí mismos.