Primalidad

#include <iostream>
using namespace std;
#include <sstream>
#include <cmath>

#define FOR(A,B) for(unsigned long long i=A;i<=B;i++)
#define repite(A) FOR(1,A)

string convertiratexto(unsigned long long a);

unsigned long long encontrarDiferenciaSiguientePrimo(unsigned long long numeroPrimoAnterior);

unsigned long long enesimoPrimo(unsigned long long n);

unsigned long long compuesto(unsigned long long n);

unsigned long long compuesto_par(unsigned long long n);

unsigned long long compuesto_impar(unsigned long long n);

unsigned long long nextPrimo(unsigned long long n);

unsigned long long funcionAuxFactorizacion(unsigned long long a, unsigned long long b);

string encuentraFactorizacion(unsigned long long n, unsigned long long primo, bool verificadorAux);

string factorizacion(unsigned long long n);

string if_encuentraFactorizacion(unsigned long long n, unsigned long long primo, bool verificadorAux);

string if_factorizacion(unsigned long long n);

float serie_inversa_de_primos(unsigned long long n);

int main() {
	unsigned long long numero_primo, numero_compuesto, numero_compuesto_par, numero_compuesto_impar, numero_next_primo, numero_factorizacion, numero_if_factorizacion, numero_serie_inversa_primos, numero_menores;
	
    cout << "Escribe un numero natural para encontrar el enesimo numero primo asociado al natural:" << endl;
	cin >> numero_primo;
	cin.ignore();
	cin.clear();
	cout << enesimoPrimo(numero_primo) << endl;
	
    cout << "Escribe un numero natural para encontrar el enesimo numero compuesto asociado al natural:" << endl;
	cin >> numero_compuesto;
	cin.ignore();
	cin.clear();
	cout << compuesto(numero_compuesto) << endl;
	
	cout << "Escribe un numero natural para encontrar el enesimo numero compuesto par asociado al natural:" << endl;
	cin >> numero_compuesto_par;
	cin.ignore();
	cin.clear();
	cout << compuesto_par(numero_compuesto_par) << endl;
	
	cout << "Escribe un numero natural para encontrar el enesimo numero compuesto impar asociado al natural:" << endl;
	cin >> numero_compuesto_impar;
	cin.ignore();
	cin.clear();
	cout << compuesto_impar(numero_compuesto_impar) << endl;
	
	cout << "Escribe un numero natural para encontrar el siguiente numero primo:" << endl;
	cin >> numero_next_primo;
	cin.ignore();
	cin.clear();
	cout << nextPrimo(numero_next_primo) << endl;
	
	cout << "Escribe un numero natural para encontrar la factorizacion" << endl;
	cin >> numero_factorizacion;
	cin.ignore();
	cin.clear();
	cout << factorizacion(numero_factorizacion) << endl;
	
	cout << "Escribe un numero natural para encontrar la factorizacion compuesto o verificar si es primo, (devuelve primo en caso de ser verdadero)" << endl;
	cin >> numero_if_factorizacion;
	cin.ignore();
	cin.clear();
	cout << if_factorizacion(numero_if_factorizacion) << endl;
	
	cout << "Escribe un numero natural para encontrar la serie inversa de numeros primos" << endl;
	cin >> numero_serie_inversa_primos;
	cin.ignore();
	cin.clear();
	cout << serie_inversa_de_primos(numero_serie_inversa_primos) << endl;
	
	cout << "Escribe un numero natural para encontrar los numeros primos menores al numero natural" << endl;
	cin >> numero_menores;
	cin.ignore();
	cin.clear();
	
	unsigned long long numero_primo_menores=2;
	while (numero_primo_menores<numero_menores) {
		cout << numero_primo_menores << endl;
		if (numero_primo_menores==2) {
			numero_primo_menores=3;
		} else
		{
			numero_primo_menores+=encontrarDiferenciaSiguientePrimo(numero_primo_menores);
		}
	}
	
	system("pause");
	
	return 0;
}

string convertiratexto(unsigned long long a) {
	stringstream b;
	b << a;
	return b.str();
}

unsigned long long encontrarDiferenciaSiguientePrimo(unsigned long long numeroPrimoAnterior) {
    // numeroParaDividirPrimo empieza en 2, porque el número 2 es el primer número primo
    // después, se le suma una diferencia para hallar el siguiente primo, para que
    // numeroParaDividir sea siempre un número primo.
    unsigned long long numeroParaDividir = 2;
    // empieza la diferencia en 2, hasta hallar la diferencia.
    unsigned long long diferencia = 2;

    while (true) {
        if (ceil(sqrt(numeroPrimoAnterior + diferencia)) <= numeroParaDividir && (numeroPrimoAnterior + diferencia) % numeroParaDividir != 0) {
            return diferencia;
        } else {
            if ((numeroPrimoAnterior + diferencia) % numeroParaDividir != 0) {
                if (numeroParaDividir == 2) {
                    numeroParaDividir = 3;
                } else {
                    numeroParaDividir += encontrarDiferenciaSiguientePrimo(numeroParaDividir);
                }
            } else {
                numeroParaDividir = 2;
                diferencia += 2;
            }
        }
    }
}

unsigned long long enesimoPrimo(unsigned long long n) {
    if (n == 0) {
        // Caso especial para n = 0 (podría considerarse un error)
        return 0;
    }
	if (n == 1) {
        return 2;
    }
	if (n == 2) {
        return 3;
    }
	unsigned long long numeroLimit = n - 2;
	unsigned long long sucesion = 3;

	for (unsigned long long i = 1; i <= numeroLimit; i++) {
		sucesion += encontrarDiferenciaSiguientePrimo(sucesion);
	}

	return sucesion;
}

unsigned long long compuesto(unsigned long long n) {
	if (n == 0) {
        // Caso especial para n = 0 (podría considerarse un error)
        return 0;
    }
    unsigned long long primo=2;
	unsigned long long solucion=2;
	repite(n) {
		if (i>1) {solucion++;}
		
		while (solucion>=primo) {
			while (solucion>primo) {
				if (primo==2) {
					primo=3;
				} else {
					primo+=encontrarDiferenciaSiguientePrimo(primo);
				}
			}
			
			while (solucion==primo) {
				if (primo==2) {
					primo=3;
				} else {
					primo+=encontrarDiferenciaSiguientePrimo(primo);
				}
				solucion++;
			}
		}
	}
	
	return solucion;
}

unsigned long long compuesto_par(unsigned long long n) {
	if (n == 0) {
        // Caso especial para n = 0 (podría considerarse un error)
        return 0;
    }
    return 2*n+2;
}

unsigned long long compuesto_impar(unsigned long long n) {
	if (n == 0) {
        // Caso especial para n = 0 (podría considerarse un error)
        return 0;
    }
    unsigned long long primo=2;
	unsigned long long solucion=3;
	repite(n) {
		if (i>1) {solucion+=2;}
		
		while (solucion>=primo) {
			while (solucion>primo) {
				if (primo==2) {
					primo=3;
				} else {
					primo+=encontrarDiferenciaSiguientePrimo(primo);
				}
			}
			
			while (solucion==primo) {
				if (primo==2) {
					primo=3;
				} else {
					primo+=encontrarDiferenciaSiguientePrimo(primo);
				}
				solucion+=2;
			}
		}
	}
	
	return solucion;
}

unsigned long long nextPrimo(unsigned long long n) {
	if (n==0 || n==1) {
		return 2;
	} else
	if (n%2==0) {
		return (n-1)+encontrarDiferenciaSiguientePrimo(n-1);
	} else
	{
		return n+encontrarDiferenciaSiguientePrimo(n);
	}
}

//

unsigned long long funcionAuxFactorizacion(unsigned long long a, unsigned long long b) {
	if (a==b) {
		return 1;
	}
	if (a<b) {
		return 0;
	}
	{
		unsigned long long solucion=1, digit=9, Aux=1, potencia=pow(b,solucion);
		while (a%potencia>=pow(10,Aux)*digit) {
			cout << "ii: " << solucion << endl;
			solucion+=pow(10,Aux)*digit;
			if(digit>1) {
				digit--;
			}
			if(digit==1) {
				Aux++;
				digit=9;
			}
			potencia=pow(b,solucion);
		}
		while (a%potencia==0) {
			solucion++;
			potencia=pow(b,solucion);
		}
		solucion--;
		return solucion;
	}
}

string encuentraFactorizacion(unsigned long long n, unsigned long long primo, bool verificadorAux) {
	string solucion="";
	while(n>0) {
		if (verificadorAux==primo) {
			if (verificadorAux==true) {
				solucion = convertiratexto(n)+" es primo";
			} else
			{
				solucion = solucion+convertiratexto(n);
			}
			n=0;
		} else
		{
			if (primo>ceil(sqrt(n))) {
				if (verificadorAux==true) {
					solucion = convertiratexto(n)+" es primo";
				} else
				{
					solucion = solucion+convertiratexto(n);
				}
				n=0;
			} else
			{
				if (n%primo==0) {
					
					if (funcionAuxFactorizacion(n,primo)>1) {
						
						if (primo==2) {
							if (encuentraFactorizacion(n/(pow(primo,funcionAuxFactorizacion(n,primo))),3, false)=="1") {
								solucion = solucion+convertiratexto(primo)+"^"+convertiratexto(funcionAuxFactorizacion(n,primo));
								n=0;
								verificadorAux=false;
							} else
							{
								solucion = solucion+convertiratexto(primo)+"^"+convertiratexto(funcionAuxFactorizacion(n,primo))+"*";
								n/=(pow(primo,funcionAuxFactorizacion(n,primo)));
								primo=3;
								verificadorAux=false;
							}
						} else {
							if (encuentraFactorizacion(n/(pow(primo,funcionAuxFactorizacion(n,primo))),primo+encontrarDiferenciaSiguientePrimo(primo), false)=="1") {
								solucion = solucion+convertiratexto(primo)+"^"+convertiratexto(funcionAuxFactorizacion(n,primo));
								n=0;
								verificadorAux=false;
							} else
							{
								solucion = solucion+convertiratexto(primo)+"^"+convertiratexto(funcionAuxFactorizacion(n,primo))+"*";
								n/=(pow(primo,funcionAuxFactorizacion(n,primo)));
								primo+=encontrarDiferenciaSiguientePrimo(primo);
								verificadorAux=false;
							}
						}
						
					} else {
						
						if (primo==2) {
							if (encuentraFactorizacion(n/(pow(primo,funcionAuxFactorizacion(n,primo))),3, false)=="1") {
								solucion = solucion+convertiratexto(primo);
								verificadorAux=0;
								verificadorAux=false;
							} else
							{
								solucion = solucion+convertiratexto(primo)+"*";
								n/=(pow(primo,funcionAuxFactorizacion(n,primo)));
								primo=3;
								verificadorAux=false;
							}
						} else {
							if (encuentraFactorizacion(n/(pow(primo,funcionAuxFactorizacion(n,primo))),primo+encontrarDiferenciaSiguientePrimo(primo), false)=="1") {
								solucion = solucion+convertiratexto(primo);
								n=0;
								verificadorAux=false;
							} else
							{
								solucion = solucion+convertiratexto(primo)+"*";
								n/=(pow(primo,funcionAuxFactorizacion(n,primo)));
								primo+=encontrarDiferenciaSiguientePrimo(primo);
								verificadorAux=false;
							}
						}
						
					}
				} else {
					
					if (n>primo && n%primo!=0) {
						if (primo==2) {
							primo=3;
						} else {
							primo+=encontrarDiferenciaSiguientePrimo(primo);
						}
					} else {
						solucion = "1^1";
						n=0;
					}
				}
			}
		}
	}
	
	return solucion;
}

string factorizacion(unsigned long long n) {
	if (n == 0) {
        // Caso especial para n = 0 (podría considerarse un error)
        return "0";
    }
	if (n==1) {
		return "1";
	}
	if (n==2) {
		return "2 es primo";
	}
	return encuentraFactorizacion(n, 2, true);
}

string if_encuentraFactorizacion(unsigned long long n, unsigned long long primo, bool verificadorAux) {
	string solucion="";
	while(n>0) {
		if (verificadorAux==primo) {
			if (verificadorAux==true) {
				solucion = "primo";
			} else
			{
				solucion = solucion+convertiratexto(n);
			}
			n=0;
		} else
		{
			if (primo>ceil(sqrt(n))) {
				if (verificadorAux==true) {
					solucion = "primo";
				} else
				{
					solucion = solucion+convertiratexto(n);
				}
				n=0;
			} else
			{
				if (n%primo==0) {
					
					if (funcionAuxFactorizacion(n,primo)>1) {
						
						if (primo==2) {
							if (encuentraFactorizacion(n/(pow(primo,funcionAuxFactorizacion(n,primo))),3, false)=="1") {
								solucion = solucion+convertiratexto(primo)+"^"+convertiratexto(funcionAuxFactorizacion(n,primo));
								n=0;
								verificadorAux=false;
							} else
							{
								solucion = solucion+convertiratexto(primo)+"^"+convertiratexto(funcionAuxFactorizacion(n,primo))+"*";
								n/=(pow(primo,funcionAuxFactorizacion(n,primo)));
								primo=3;
								verificadorAux=false;
							}
						} else {
							if (encuentraFactorizacion(n/(pow(primo,funcionAuxFactorizacion(n,primo))),primo+encontrarDiferenciaSiguientePrimo(primo), false)=="1") {
								solucion = solucion+convertiratexto(primo)+"^"+convertiratexto(funcionAuxFactorizacion(n,primo));
								n=0;
								verificadorAux=false;
							} else
							{
								solucion = solucion+convertiratexto(primo)+"^"+convertiratexto(funcionAuxFactorizacion(n,primo))+"*";
								n/=(pow(primo,funcionAuxFactorizacion(n,primo)));
								primo+=encontrarDiferenciaSiguientePrimo(primo);
								verificadorAux=false;
							}
						}
						
					} else {
						
						if (primo==2) {
							if (encuentraFactorizacion(n/(pow(primo,funcionAuxFactorizacion(n,primo))),3, false)=="1") {
								solucion = solucion+convertiratexto(primo);
								verificadorAux=0;
								verificadorAux=false;
							} else
							{
								solucion = solucion+convertiratexto(primo)+"*";
								n/=(pow(primo,funcionAuxFactorizacion(n,primo)));
								primo=3;
								verificadorAux=false;
							}
						} else {
							if (encuentraFactorizacion(n/(pow(primo,funcionAuxFactorizacion(n,primo))),primo+encontrarDiferenciaSiguientePrimo(primo), false)=="1") {
								solucion = solucion+convertiratexto(primo);
								n=0;
								verificadorAux=false;
							} else
							{
								solucion = solucion+convertiratexto(primo)+"*";
								n/=(pow(primo,funcionAuxFactorizacion(n,primo)));
								primo+=encontrarDiferenciaSiguientePrimo(primo);
								verificadorAux=false;
							}
						}
						
					}
				} else {
					
					if (n>primo && n%primo!=0) {
						if (primo==2) {
							primo=3;
						} else {
							primo+=encontrarDiferenciaSiguientePrimo(primo);
						}
					} else {
						solucion = "1^1";
						n=0;
					}
				}
			}
		}
	}
	
	return solucion;
}

string if_factorizacion(unsigned long long n) {
	if (n == 0) {
        // Caso especial para n = 0 (podría considerarse un error)
        return "numero no permitido";
    }
	if (n==1) {
		return "1";
	}
	if (n==2) {
		return "primo";
	}
	return if_encuentraFactorizacion(n,2, true);
}

float serie_inversa_de_primos(unsigned long long n) {
	unsigned long long primo=2;
	float serie=0;
	FOR(1,n) {
		if (i!=1) {
			if (primo==2) {
				primo=3;
			} else
			{
				primo+=encontrarDiferenciaSiguientePrimo(primo);
			}
		}
		serie=serie+(1/(float)primo);
	}
	return serie;
}

 

Cuando las almas cantan

Poesía de estilo libre creada por Jorge Chaves Román.

Título: Cuando las almas cantan, un héroe rescata a su compañera de las garras de la bestia

Cuando las almas cantan
bajo el brillo de las estrellas,
un héroe alza su espada para hacer la danza
para rescatar a su bella
compañera de las garras de la bestia
y su esperanza ha sido derrotada,
los recuerdos de su compañera Celestia
le da fuerzas bajo la helada
noche de su travesía
a su encuentro con el destino,
cuando el alba avisó que el día
iba ser obscuro, él vino
a recoger su arco, carcaj, flechas, armadura
y su espada para empezar el largo trayecto
de su destino con una armagura,
con el propósito de su proyecto
de rescatar a su compañera con una herida
emocional que nunca cicatrizará,
él hizo su propia ida
para rescatar al que él siempre amará.

Para lograr la felicidad

Poesía de estilo libre y que de igual modo puede ser cantada como canción. Es creada por Jorge Chaves Román.

Título: Para lograr la felicidad...

Versión 1.
Para lograr la felicidad...
Hay que pintarse la cara...
De color esperanza...
Para tentar al futuro...
Con el corazón...
Con toda la bondad...
Para así volar a un mundo de fantasía...
En el que no hay un patrón maléfico...
Sino un patrón de felicidad..
Con armonía, paz...
Una inimaginable esperanza y de un sinfín de amor...
Para así ver la realidad...
Para así percibir el bien...
Para así sentir el Cosmos...
Para así irse con la imaginación...
A un mundo de arco iris...
Tan igual como un paraíso...
En el que se viva...
En armonía...
Con todos los seres vivos...
Como si fuera una gran familia...
En el que la compañía de la gran familia...
No halla distancia entre sí...
Sino una gran fuerte conexión celestial...
Entre todos los individuos...
De la gran familia...
Para así convivir en la fantasía...
De un mundo de...
Belleza sin igual...
Con una inimaginable esperanza...
Y un sinfín de amor...
Pero en fin...
No hay que ilusionarse...
Con solo pensarlo...
Sino embarcarse hacia...
El largo camino hacia...
El gran despertar...
De la consciencia...
Plena y superior...
Para llegar a un estado...
Interdimensional...
Para alcanzar la frontera...
Del misterioso destino...
Para así averiguar...
Lo que realmente está bien...
En esta fase experimentar...
De nuestra existencia...
Para lograr alcanzar la bondad...
Para así obtener...
El deseado estado de la nirvana...
Para así encontrarte con tu verdadero yo...
Para así respetar los valores de la Existencia...

Versión 2.
Hay que pintarse la cara De color esperanza, Para tentar al futuro Con el corazón, Con toda la bondad.
Así volaremos a un mundo de fantasía, Donde no existe un patrón maléfico, Sino un patrón de felicidad, Con armonía y paz.
Una inimaginable esperanza y un sinfín de amor Nos guiarán en este viaje, Donde veremos la realidad, Percibiremos el bien, Y sentiremos el Cosmos.
Nuestra imaginación nos llevará A un mundo de arco iris, Similar a un paraíso, Donde viviremos en armonía Con todos los seres vivos.
Seremos una gran familia, Sin distancias entre nosotros, Solo una fuerte conexión celestial Entre cada individuo.
En este mundo de belleza sin igual, La esperanza nos acompañará, Y el amor será infinito.
Pero no basta con soñarlo, Debemos embarcarnos en el largo camino Hacia el gran despertar De la consciencia plena y superior.
Alcanzaremos un estado interdimensional, Rozando la frontera del misterioso destino, Para averiguar lo que realmente está bien En esta fase de nuestra existencia.
Buscaremos la bondad, El deseado estado de la nirvana, Y nos encontraremos con nuestro verdadero yo, Respetando los valores de la Existencia.
Así, en este viaje interior, Descubriremos la esencia de la felicidad.