Programación en Python

Técnica acusatoria

Supongamos que tenemos que hacer un programa para determinar si entre 20 números
ingresados por el usuario viene algún múltiplo de 10.

Acá hay un par de cosas a tener en cuenta:

 Cada vez que ingrese un número tengo toda la información necesaria para saber si es
múltiplo de 10 o no, no preciso nada más.
 En cuanto ingrese el primer múltiplo de 10 ya sé que hay al menos uno. Para
determinar que no vino ninguno, sin embargo, necesito leer todos…

Ahora…

Leo un número y averiguo si es múltiplo, y luego voy a la vuelta o el número siguiente.

Cuando mi bucle finaliza, la verdad es que no sé qué sucedió en cada vuelta!!!

Necesito dejar pistas o marcar algún suceso relevante para que al final de todo pueda
saber si pasó o no.

Una forma sencilla es con el uso de banderas. Una bandera es una variable que toma sólo
dos estados o valores posibles (normalmente se implementan con variables enteras o
booleanas). La bandera parte al inicio del ciclo con un valor y se cambia (se prende) ante un
hecho determinado (que es el que queremos señalar). Una vez que se prendió una bandera
nunca más se apaga hasta el final del ciclo o instancia donde vamos a preguntar su valor
para averiguar qué pasó. Lo que si puede suceder es que ya fue prendida y se vuelve a
prender, pero eso no tiene ninguna consecuencia. Se las llama bandera porque actúan
como una bandera de llegada en una carrera. En una carrera de auto la bandera está alta y
cuando llega el primer vehículo baja. Luego llegan al resto y la bandera se mantiene baja,
pero ya no importa.
Veamos cómo plantear el ejercicio con una bandera ban.
ban=0
print('Ingrese 20 números enteros positivos')
cant=1
while cant<=20
num=int(input())
if num%10==0:
ban=1
cant+=1
if ban==1:
print('En la lista ingresada hubo al menos un múltiplo de 10')
else:
print('En la lista ingresada no hubo múltiplos de 10')
exit()

Ahora pensemos en la verificación de primo…

Un número es primo si es divisible sólo por 1 y por si mismo. Para averiguar si un número
es primo usamos una técnica de sospecha o acusatoria, intentaremos por todos los medios
encontrarle algún divisor para descalificarlo. O sea que si le encontramos un divisor ya
sabemos que no es primo. Pero para reconocerlo como primo debemos asegurarnos de
probar con todos los candidatos y fallar antes. Si lo piensan, es similar al primer caso que
planteamos…

Bueno, y dónde buscamos los divisores? Seguramente los divisores de cualquier número n
estarán entre 1 y n (un divisor siempre es menor o igual que el dividendo). Entonces
tenemos que empezar a probar con todos los candidatos (entre 2 y n-1) y si encontramos
un divisor lo marcamos para que a la salida sepamos que estuvo, ya que hasta que no
termine de probar no puedo garantizar que sea primo.

Vamos de vuelta (fijarse qué similar con el primer caso)

ban=0
num=int(input('Ingrese un número entero positivo '))
divisor=2
while divisor<num:
if num%divisor==0:
ban=1 # si encuentro un divisor ya marco que num no es primo con ban
divisor+=1 # con esto voy probando los candidatos
if ban==1:
print(num, 'No es primo')
else:
print(num, 'Es primo')
exit()
 Programación en Python

Tips para exigentes:

Si encontré un divisor en la primera vuelta estoy forzado a seguir probando aunque ya sepa
la respuesta (mmmm…). Para averiguar si 11 es primo no es grave, pero para saber si 101, o
12345!!!

A ver, a ver…
ban=0
num=int(input('Ingrese un número entero positivo '))
divisor=2
while (ban==0) and(divisor<num): # esta condición hace saltar del ciclo en
#cuanto aparezca un divisor
if num%divisor==0:
ban=1
divisor+=1
if ban==1:
print(num, 'No es primo')
else:
print(num, 'Es primo')
exit()

¿Mejor no???

Ahora un poco de matemática para volvernos más eficientes…

Recordar: nada más ineficiente que hacer bien lo que no es necesario.

Los divisores de 30 son: Los divisores de 50 son:

1 da 30 1 da 50

2 da 15 2 da 25

3 da 10 5 da 5

15 da 2 25 da 2

30 da 1 50 da 1
Si prestamos atención después del cociente = 2 sigue el cociente =1 (este último se obtiene
dividiendo un número por si mismo) y para obtener el cociente anterior, 2, debe dividirse
un número por su mitad. Es decir…
No hay ninguna posibilidad de encontrar un divisor de n entre n-1 y n//2+1

Haciendo revisión de nuestro algoritmo:

ban=0
num=int(input('Ingrese un número entero positivo '))
divisor=2
while (ban==0) and(divisor<=num//2):
if num%divisor==0:
ban=1
divisor+=1
if ban==1:
print(num, 'No es primo')
else:
print(num, 'Es primo')
exit()

Vamos por mas…

Si un número no es divisible por 2 (impar) no tiene sentido que probemos si es divisible por
otro par. ¿No es cierto?
Así que después de 3 podemos intentar sólo con impares:

num=int(input('Ingrese un número entero positivo '))

ban=0
divisor=2
while ban==0 and divisor<=num//2:
if num%divisor==0:
ban=1
if divisor==2:
divisor+=1
else:
divisor+=2
if ban==1:
print(num,'No es primo')
else:

print(num,'Es primo')
 Programación en Python

Si se entendió, sugiero que generalices este algoritmo para más de un número. Puedes leer
15 números y determinar para cada uno si es primo.
Buena suerte!!