JProcDocText

https://drive.google.com/file/d/15VoctynxC_0V6QqJ6bTyzlZIlOhXFX1-/view?usp=sharing
Enlace de descarga

Es un procesador de texto creado por Jorge Chaves Román.
Aunque está incompleto, tiene nuevas características que no tienen otros procesadores de texto, como por ejemplo 5 tipos diferentes de índices en lugar de los 2 tipos comunes y tradicional de superíndice y subíndice.
Aunque está incompleto y por eso no puede dar formato en negrita o tachado o incluso subrayado pero si que tiene cursiva.
Relaciones/Relacionado con: JLeng.
[...]

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