#Ruby 1.9.2p-180
###########################################################################
def generar_primos(final)
p = [2, 3]
n = [ ]
until true == false
t = [p, n].flatten.compact
s = t.size
break if (p[p.size - 1] + 2) >= final
s.times { | x | ; s.times { | y |
next if (n.include?(t[x]) and n.include?(t[y]))
a = t[x] * t[y]
if (a % 2) != 0 and not n.include?(a) and a < (final + 1)
n.insert(-1, a)
end
} }
q = siguiente_primo(p, n)
if q <= final then
p.insert(-1, q)
else
break
end
end
return p
end
def siguiente_primo(primos, no_primos)
u = primos[primos.size - 1]
until true == false
u += 2
break if no_primos.include?(u) == false
end
return u
end
print generar_primos(120)
###########################################################################
Hola bienvenidos a mi nuevo Post.
Para no hacer un post tan grande y otras cosas que considero innecesarias, he decidido hacerlo en esta forma, pequeño y entendible.
Explicacion:
Los numeros primos son aquello numeros que por su naturaleza son indivisibles por cualquier otro numero, excepto por 1 y por si mismo.
Ejemplos de numeros primos: 2, 3, 5, 7, 11, 13, 17, 19...
En la actualidad forman un papel muy importante en muchas ciencias, la mas relevante; la informatica.
Hoy en dia los principales, y tal vez unicos, programas de criptografia de clave publica se basan en los numeros primos, siendo estos la base fuerte de los algoritmos.
Entre ellos se encuentran RSA y ElGamal.
Ahora explicare un poco lo que hace el algoritmo escrito en la parte superior de este post.
Al llamar la funcion "generar_primos", lo hacemos pasando como argumento un numero integro. Este numero es el limite para buscar los siguientes numeros primos.
Lo que hace esta funcion es multiplicar los numeros primos entre si, los cuales estan localizados en la variable "p". Todos los resultados de dicha multiplicacion pasaran a agregarse a la variable "n", puesto que en esta variable se agregaran unicamente los numeros compuestos.
Una vez terminado de multiplicar todos los numeros primos entre si, llamamos a la funcion "siguiente_primo". A esta funcion la llamaremos pasando dos argumentos, la variable "p" (que incluye los numeros primos) y la variable "n" (que incluye los numeros compuestos).
Esta funcion toma el ultimo numero primo de la matriz "primos" y comienza a sumar de 2 en 2.
¿Por que se suma de 2 en 2?
Una de las reglas de bien conocidas de los numeros primos, es que todo numero primos es impar a excepcion del numero 2.
Por lo tanto para buscar el siguiente numero primo se agrega esta cantidad cuanto se necesario.
Despues de sumar 2, se comprueba que el nuevo producto o numero, no se encuentre dentro de la matriz "no_primos", si se encuentra en la matriz anterior entonces se asumira que es un numero compuesto, de lo contrario es un numero primo.
¿Asi de sencillo?
No, de hecho no es solo porque yo diga que despues de ver que no se encuentra en la lista no primos, ya es un numero primo.
Para esto yo me base en algunas reglas de los numeros primos:
Todo numero primos es impar, excepto el 2.
Un numero compuesto es producto de numeros primos menores a este.
Basandome en esos dos principios desarrolle este codigo. No muestra una eficiencia computacional exagerada, pero es un aporte para esta comunidad.
Lo importante es contribuir a la inteligencia colectiva.
Saludos
###########################################################################
def generar_primos(final)
p = [2, 3]
n = [ ]
until true == false
t = [p, n].flatten.compact
s = t.size
break if (p[p.size - 1] + 2) >= final
s.times { | x | ; s.times { | y |
next if (n.include?(t[x]) and n.include?(t[y]))
a = t[x] * t[y]
if (a % 2) != 0 and not n.include?(a) and a < (final + 1)
n.insert(-1, a)
end
} }
q = siguiente_primo(p, n)
if q <= final then
p.insert(-1, q)
else
break
end
end
return p
end
def siguiente_primo(primos, no_primos)
u = primos[primos.size - 1]
until true == false
u += 2
break if no_primos.include?(u) == false
end
return u
end
print generar_primos(120)
###########################################################################
Hola bienvenidos a mi nuevo Post.
Para no hacer un post tan grande y otras cosas que considero innecesarias, he decidido hacerlo en esta forma, pequeño y entendible.
Explicacion:
Los numeros primos son aquello numeros que por su naturaleza son indivisibles por cualquier otro numero, excepto por 1 y por si mismo.
Ejemplos de numeros primos: 2, 3, 5, 7, 11, 13, 17, 19...
En la actualidad forman un papel muy importante en muchas ciencias, la mas relevante; la informatica.
Hoy en dia los principales, y tal vez unicos, programas de criptografia de clave publica se basan en los numeros primos, siendo estos la base fuerte de los algoritmos.
Entre ellos se encuentran RSA y ElGamal.
Ahora explicare un poco lo que hace el algoritmo escrito en la parte superior de este post.
Al llamar la funcion "generar_primos", lo hacemos pasando como argumento un numero integro. Este numero es el limite para buscar los siguientes numeros primos.
Lo que hace esta funcion es multiplicar los numeros primos entre si, los cuales estan localizados en la variable "p". Todos los resultados de dicha multiplicacion pasaran a agregarse a la variable "n", puesto que en esta variable se agregaran unicamente los numeros compuestos.
Una vez terminado de multiplicar todos los numeros primos entre si, llamamos a la funcion "siguiente_primo". A esta funcion la llamaremos pasando dos argumentos, la variable "p" (que incluye los numeros primos) y la variable "n" (que incluye los numeros compuestos).
Esta funcion toma el ultimo numero primo de la matriz "primos" y comienza a sumar de 2 en 2.
¿Por que se suma de 2 en 2?
Una de las reglas de bien conocidas de los numeros primos, es que todo numero primos es impar a excepcion del numero 2.
Por lo tanto para buscar el siguiente numero primo se agrega esta cantidad cuanto se necesario.
Despues de sumar 2, se comprueba que el nuevo producto o numero, no se encuentre dentro de la matriz "no_primos", si se encuentra en la matriz anterior entonces se asumira que es un numero compuesto, de lo contrario es un numero primo.
¿Asi de sencillo?
No, de hecho no es solo porque yo diga que despues de ver que no se encuentra en la lista no primos, ya es un numero primo.
Para esto yo me base en algunas reglas de los numeros primos:
Todo numero primos es impar, excepto el 2.
Un numero compuesto es producto de numeros primos menores a este.
Basandome en esos dos principios desarrolle este codigo. No muestra una eficiencia computacional exagerada, pero es un aporte para esta comunidad.
Lo importante es contribuir a la inteligencia colectiva.
Saludos