1

Factorial---------------------------10 !!!=280-------------------------------------------------------------------
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class factorial {

public static void main(String[] args) {
try {
BufferedReader br = new BufferedReader(new FileReader("factorials.in"));
String linea;
while((linea=br.readLine())!=null){
String dato[]=linea.split(" ");
int a=Integer.parseInt(dato[0]);
String b=dato[1];
int c=b.length();
int total=1;
int r=1;
//if(a%c==0){
while((a-(r*c))>0){
total*=(a-(r*c));
r++;
}
total=total*a;
System.out.println(total);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

Electrical outlets
3 7
3234 31
10 4 4 4 4 4 4 4 4 37
44
4 10 10 10 10

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class ejemplo1 {

public static void main(String[] args) {
try {
BufferedReader br=new BufferedReader(new FileReader("outlets.in"));
String linea;
int a=Integer.parseInt(br.readLine());
int b=0;
2

while(b<=a){
while((linea=br.readLine())!=null){
int total=0;
String datos[]=linea.split(" ");
int d=Integer.parseInt(datos[0]);
for(int i=1;i<=d;i++){
total+=Integer.parseInt(datos[i]);

}
total=(total-d)+1;
System.out.println(total);
}}

} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}
}
Hellokitty
Love 1 Love
Kitty 2 oveL
. veLo
eLov
KittyKitty
ittyKittyK
ttyKittyKi
tyKittyKit
yKittyKity

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class HelloKitti {

public static void main(String[] args) {
try{
BufferedReader br=new BufferedReader(new
FileReader("hkitty.in"));
String linea;
while((linea=br.readLine())!=null){
String datos[]=linea.split(" ");
int a=Integer.parseInt(datos[1]);
String palabra=datos[0];
int q=palabra.length();
for(int i=1;i!=a;i++){
palabra+=datos[0];
3

}
System.out.println(palabra);
for(int i=1;i!=q;i++){
String Palabra2="";
for(int j=1;j!=palabra.length();j++){
Palabra2+=palabra.charAt(j);
}
Palabra2+=palabra.charAt(0);
System.out.println(Palabra2);
palabra=Palabra2;
}
}
}catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

MAKING BOOK (cantidad de nmeros ejm 012349 entre

digamos 10 al 11 hay 0=1,1=7.)

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Numeros {

public static void main(String[] args) {
try{
BufferedReader br=new BufferedReader(new FileReader("book.in"));
String linea;
int a=0;
while((linea=br.readLine())!=null){
a++;
String datos[]=linea.split(" ");
int numero[]=new int[10];
String palabra="";
for(int i =Integer.parseInt(datos[0]);i<=Integer.parseInt(datos[1]);i++){

String m=String.valueOf(i);
for(int y=0;y<m.length();y++){
if(m.charAt(y)=='0'){
numero[0]+=1;
}
if(m.charAt(y)=='1'){
numero[1]+=1;
}
if(m.charAt(y)=='2'){
4

numero[2]+=1;
}
if(m.charAt(y)=='3'){
numero[3]+=1;
}
if(m.charAt(y)=='4'){
numero[4]+=1;
}
if(m.charAt(y)=='5'){
numero[5]+=1;
}
if(m.charAt(y)=='6'){
numero[6]+=1;
}
if(m.charAt(y)=='7'){
numero[7]+=1;
}
if(m.charAt(y)=='8'){
numero[8]+=1;
}
if(m.charAt(y)=='9'){
numero[9]+=1;
}
}
}
System.out.println("Case "+a+": "+"0:"+numero[0]+" 1:"+numero[1]+" 2:"+numero[2]+
3:"+numero[3]+" 4:"+numero[4]+" 5:"+numero[5]+" 6:"+numero[6]+
" 7:"+numero[7]+" 8:"+numero[8]+" 9:"+numero[9]);
}
}catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

3N+1
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;

public class tresnmasuno {

public static void main(String[] args) throws IOException {
try {
BufferedReader br= new BufferedReader(new FileReader("three.in"));
String linea;
5

while((linea=br.readLine())!=null){
String datos[]=linea.split(" ");
int num[]= new int[2];
num[0]=Integer.valueOf(datos[0]);
num[1]=Integer.valueOf(datos[1]);
int ciclomax=0;
for(int i=num[0];i<=num[1];i++){
int ciclos=0;
int valor=i;
while(valor!=1){
if(valor%2==0){
valor/=2;
}else{
valor=(valor*3)+1;
}
ciclos++;
}
ciclos++;
if(ciclos>ciclomax){
ciclomax=ciclos;
}
}
System.out.println(num[0]+" "+num[1]+" "+ciclomax);
}
} catch (FileNotFoundException ex) {
Logger.getLogger(tresnmasuno.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
PARES E IMPARES
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;

public class ParesEImpares {

public static void main(String[] args) {
try {
BufferedReader br=new BufferedReader(new FileReader("pares.txt"));
String lineas;
while(!((lineas=br.readLine()).equals("0"))){
int pares=0;
int impares=0;
int caso=Integer.parseInt(lineas);
for(int i=0;i<caso;i++){
lineas=br.readLine();
int numero=Integer.parseInt(lineas);
if(numero%2==0){
pares++;
}else{
impares++;
}
}
if(pares==impares){
System.out.println("CASO "+(caso)+":"+"\nIgual cantidad de numeros pares e impares\n");
}else if(pares<impares){
System.out.println("CASO "+caso+":"+"\nHay mayor cantidad de numeros impares\n");
}else if(pares>impares){
System.out.println("CASO "+caso+":"+"\nHay mayor cantidad de numeros pares\n");
 6

}
}
} catch (FileNotFoundException ex) {
Logger.getLogger(ParesEImpares.class.getName()).log(Level.SEVERE, null, ex);
} catch (IOException ex) {
Logger.getLogger(ParesEImpares.class.getName()).log(Level.SEVERE, null, ex);
}
}
}

WORM GUSANO QUE SUBE Y BAJA

1. import java.io.BufferedReader;
2. import java.io.FileNotFoundException;
3. import java.io.FileReader;
4. import java.io.IOException;
5. import java.math.BigInteger;
6. import java.util.Date;
7. import java.util.Scanner;
8. import java.util.logging.Level;
9. import java.util.logging.Logger;
10.
11. public class worm {
12.
13. public static void main (String []args){
14. try {
15. BufferedReader br = null;
16. br = new BufferedReader(new FileReader("worm.in"));
17. String linea;
18. while(!((linea=br.readLine()).equals("0 0 0"))){
19. String datos[] = linea.split(" ");
20. int n = Integer.parseInt(datos[0]);
21. int u = Integer.parseInt(datos[1]);
22. int d = Integer.parseInt(datos[2]);
23. int aux=u;
24. int min=1;
25. while(u<n){
26. min+=2;
27. u-=d;
28. u+=aux;
29. }
30. System.out.println(min);
31. }
32. br.close();
33. } catch (IOException ex) {
34.
35. }
36. }
37. }
NUMERO EN PIRAMIDE
public class uj {
public static void main (String []args){
long time1=System.currentTimeMillis();
BufferedReader br=null;
try {
br=new BufferedReader(new FileReader("uj.in"));
} catch (FileNotFoundException ex) {
7

Logger.getLogger(uj.class.getName()).log(Level.SEVERE, null,
ex);
}
String linea;
try {
while(!(linea=br.readLine()).equals("0 0")){
String datos[]=linea.split(" ");
int m=Integer.parseInt(datos[1]);

BigInteger bigInteger=new BigInteger(datos[0]);

bigInteger=bigInteger.pow(m);

System.out.println(bigInteger.toString());

} } catch (IOException ex) {

Logger.getLogger(uj.class.getName()).log(Level.SEVERE, null,
ex);
}

QUICKSUM
public class NewClass {
public static void main (String []args) {
BufferedReader br = null;
try {
br = new BufferedReader(new FileReader("quicksum.in"));
String linea;
while(!(linea=br.readLine()).equals("#")){
int total=0;
for(int i=0;i<linea.length();i++)
{
if(linea.charAt(i)!=' '){
int valorchar=linea.charAt(i)-64;
total +=valorchar*(i+1);
}

}
System.out.println(total);
}
} catch (IOException ex) {
Logger.getLogger(NewClass.class.getName()).log(Level.SEVERE,
null, ex);
}
}}
8

QUALITY

FACTORIAL RECURSIVO

#include <iostream>//se incluyen las librerias que se van a utilizar respectivamente

#include <conio.h>//se incluyen las librerias que se van a utilizar respectivamente
using namespace std;
class relativo//se declara a relativo como un class
{
private://bloque privado
int x,y;//se declaran las variables de tipo entero
int *a;
public: //bloque publico
relativo();
~relativo();

long int factorial(int x);//funcion factorial

void mostrar();//funcion mostrar
};
relativo::relativo()//funcion contructor
{ int x = 0; //Declaracion e inicializacion en 0 para eliminar datos basura
cout << "Ingrese el numero" << endl;//se le pide al usuario que ingrese un numero
cin >> x;//se captura el valor ingresado en la variable
cout << "El resultado es, "<< factorial(x) << endl; //se imprime el resultado invocando a una funcion
a= new int [x];//asignacion de memoria dinamica
if(a==NULL)//condicion en caso de que exista un error en la asignacion de memoria dinamica
cout<<"Error";//se imprime en pantalla que existe un error
}
relativo::~relativo()//funcion destructora
{
cout<<"\nDestruyendo";//se imprime en pantalla para comprobar que es la ultima en ejecutarse
delete a;//liberacion
}

long int relativo::factorial (int y) //funcion para sacar el factorial de un numero en forma recursiva
{
switch(y)//se utiliza la instruccion switch para darle tratamiento al numero dependiendo de factores
{
case 0://caso donde el numero sea 0 se retorna un uno
return 1;
break;
case 1://en caso de que sea el numero 1 tambien se retorna un uno
return 1;
break;
9

default://en otro caso...

return (factorial(y-1)*y); //Llamada recursiva, la funcion se llama asi misma
break;
}
}

int main()//funcion principal

{
relativo num;//se declara a num como objeto de tip relativo

num;long int factorial(int x);//invocacion de la funcion

getch();
}

Potencia de un numero
#include"iostream"//se incluyen respectivamente las librerias que utilizare
#include<conio.h>
using namespace std;

class potencia//se declara a potencia como un class

{
private://bloque privado
int x,y;//declaracion de variables de tipo entero
float resultado1, resultado2;//declaracion de variables de tipo float
int f, i,g,m;//declaracion de variables de tipo entero
int *a,*b;//se declaran las variables como apuntador de tipo entero
public: //datos del bloque publico donde estan las funciones
potencia();// funcion constructora
~potencia();//funcion destructor
void proceso (void);//funcion no recibe no retorna proceso
void salida (void); //funcion no recibe no retorna salida
};
potencia::potencia (void)//funcion constructor
{
cout<<"Programa para elevar un numero a una potencia"<<endl;
cout<<"Ingrese por favor el primer numero, seguido del segundo "<<endl;//le pide al usuario que ingrese los dos numeros a
elevar
cin>>x>>y;//captura los valores en las respectivas variables
a=new int[x];//asignacion dinamica de memoria
if(a==NULL)//condicion if por si existen errores en la asignacion de memoria dinamica
cout<<"Error";//imprime en pantalla el error
b=new int[y];//asignacion dinamica de memoria
if(b==NULL)//condicion if por si existen errores en la asignacion de memoria dinamica
cout<<"Error 2";//imprime en pantalla el error
}
potencia::~potencia()//funcion destructura la ultima que se ejecuta
{
cout<<"Destruyendo "<<endl;//se imprime para verificar que es la ultima en ejecutarse
delete a;//liberacion
delete b;//liberacion
}

void potencia::proceso (void)//funcion no recibe no retorna proceso

{
f=1;//asignacion de valor a la variable
i=1;//asignacion de valor a la variable
g=1;//asignacion de valor a la variable
m=1;//asignacion de valor a la variable
while(i<=y)//ciclo while mientras que i sea menor o igual que y se realice
{
f=f*x;//se realiza una multiplicacion entre el mismo valor
i++; //se suma uno mientras termina el proceso
}
while(m<=x)//ciclo while mientras que m sea menor o igual que x se realice
{
g=g*y;//se realiza una multiplicacion entre el mismo valor
m++; //se suma uno cada vez que termina el proceso
10

}
}
void potencia::salida(void)//funcion encargada de imprimir los datos
{
cout<<"el numero "<<x<<" elevado al numero "<<y<<" es igual a "<<f<<endl;//se imprimen los resultados
cout<<"el numero "<<y<<" elevado al numero "<<x<<" es igual a "<<g<<endl;//se imprimen los resultados
}

int main()//funcion principal

{
potencia programa;//se declara a programa como un objeto de tipo potencia
programa.proceso();//invocacion de la funcion proceso
programa.salida(); //invocacion de la funcion salida
getch();//pausa para observar los resultados
}
NUMERO PERFECTO
# include <iostream>//se incluyen respectivamente las librerias a utilizar
using namespace std;
class perfecto//se declara a perfecto de tipo class
{
private://bloque privado
int num, acum;//se declaran variables tipo entero
int *a;//se declaran las variables como apuntador de tipo entero
public://bloque publico donde se encuentran declaradas las funciones
perfecto();//funcion constructora
~perfecto();//funcion destructora
void contador();//funcion no recibe no retorna contador
void resultado();//funcion no recibe no retorna resultado
};

perfecto::perfecto()//funcion constructora
{
cout << "Digite un numero por favor: ";//se le pide al usuario que ingrese un numero
cin >> num;//se captura el resultado en la variable num
a= new int [num];//asignacion dinamica de memoria
if(a==NULL)//condicion if por si existen errores en la asignacion de memoria dinamica
cout<<"Error"<<endl;//imprime en pantalla que existe un error
}

perfecto::~perfecto()//funcion destructora
{
cout<<"\n...Destruyendo"<<endl;//para confirmar que es la ultima en ejecutarse
delete a;//liberacion
}

void perfecto::contador()//funcion no recibe no retorna contador

{
acum=0;//se le asigna el valor de 0 a la variable para evitar datos basura
for (int i=1 ; i<num ; i++)//for que va desde el 1 hasta el num y avanza 1
{
if (num%i==0)//condicion si el modulo del numero entre i da cero
{
acum=acum+i;//se me vayan acumulado en la variable los resultados
}
}
}

void perfecto::resultado()//funcion no recibe no retorna resultado

{
if (acum==num)//condicion que me dicew que si el acumulado es igual al valor del numero
{
cout << "El numero " << num << " es perfecto" << endl;//me imprime que el numero es perfecto
}
else
{
cout << "El numero " << num << " no es perfecto" << endl;//o el numero no es perfecto en caso de que no se cumpla la
condicion
}
11

}
int main()//funcion principal
{
perfecto n;//se declara a n como un objeto de tipo perfecto
n.contador();//invocacion de la funcion contador
n.resultado();//invocacion de la funcion resultado
}

DE MAYUSCULAS A MINUSCULAS
#include <iostream>
#include <string.h>
using namespace std;

class convertir
{
private:
char arreglo[30];
int n;

public:
void leer(void);
void operar(void);
void mostrar(void);
};

void convertir::leer(void)
{

cout<<"Teclee la frase : ";

gets(arreglo);
}
void convertir::operar(void)
{
n=strlen(arreglo);
for (int i=0;i<strlen(arreglo);i++){
if(arreglo[i]>= 'a' && arreglo[i]<='z') {
arreglo[i]-=32;

}
else if(arreglo[i] >= 'A' && arreglo[i]<='Z'){
arreglo[i]+=32;
}
}
}

void convertir::mostrar(void)
{
cout<<"la palabra ha cambiado a:"<<endl;
for(int x=0;x<strlen(arreglo);x++)
cout<<arreglo[x]<<endl;
}
int main () {

convertir letras;
letras.leer();
letras.operar();
letras.mostrar();
}

FACTORIAL DE M HASTA N

#include <iostream>
using namespace std;
class factoriales
{
int i,j,k,n,m,fact,aux1,aux2;
int arreglo[50];
public:
12

factoriales();
~factoriales();
void ingresar (void);
void procesar (void);
void mostrar (void);
};

factoriales::factoriales()
{
cout<<"construyendo..."<<endl;
aux1=aux2=0;
fact=1;
}

factoriales::~factoriales()
{
cout<<"destruyendo..."<<endl;
}
void factoriales::ingresar(void){
cout<<"ingrese el valor desde donde se comenzara a hallar el factorial:"<<endl;
cin>>n;
cout<<"ingrese el valor donde terminaremos de hallar el factorial:"<<endl;
cin>>m;
}

void factoriales::procesar(void)
{
for (i=n;i<=m;i++)
{
for(j=1;j<i+1;j++){
fact=fact*j;
}
arreglo[aux1]=fact;//aux1 servira para recorrer y guardar en el arreglo el factorial en orden.
fact=1;//se devuelve factorial a 1 luego de ser guardado en el arreglo para seguir calculando los factoriales
siguientes
aux1++;
}
}

void factoriales::mostrar(void)
{
for(k=n;k<=m;k++)//la variable k servira para mostrar los numeros desde n hasta m.
{
cout<<"el factorial del numero "<<k<<" es: "<<arreglo[aux2];////aux2 servira para recorrer el arreglo el factorial en
orden para luego mostrarlo.
aux2++;
cout<<endl;
}
}
int main () {
factoriales respuesta;
respuesta.ingresar();
respuesta.procesar();
respuesta.mostrar();
}

CANTIDAD DE DIVISORES DE UN NUMERO

# include <iostream>//incluyo las librerias correspondientes
using namespace std;
class dos//declaro a dos como tipo class
{
private://datos del bloque privado
int num1, num2, acum1, acum2,i,j,n; //declaracion de variables de tipo entero
int *a,*b;//se declaran las variables como apuntador de tipo entero
public://datos del bloque publico donde estan las funciones
dos();// funcion constructora
~dos();//funcion destructor
13

void leer();//funcion no recibe no retorna leer

void contador();//funcion no recibe no retorna contador
void mostrar();//funcion no recibe no retorna mostrar
};

dos::dos()//funcion constructora
{
cout<<"Construyendo \n"<<endl;//verificar que es el primero que se ejecuta
cout << "Ingrese el numero 1" << endl;//imprime en pantalla que el usuario debe ingresar el primer numero
cin >> num1;//le asigno el valor a la variable
cout << "Ingrese el numero 2" << endl;//impre en pantalla que el usuario debe ingresar un segundo numero
cin >> num2;//captura el valor en la variable
a=new int[num1];//asignacion dinamica de memoria
if(a==NULL)//condicion if por si existen errores en la asignacion de memoria dinamica
cout<<"Error";//imprime en pantalla el error
b=new int[num2];//asignacion dinamica de memoria
if(b==NULL)//condicion if por si existen errores en la asignacion de memoria dinamica
cout<<"Error 2";//imprime en pantalla el error
}
dos::~dos()//funcion destructura la ultima que se ejecuta
{
cout<<"Destruyendo "<<endl;//se imprime para verificar que es la ultima en ejecutarse
delete a;//liberacion
delete b;//liberacion
}

void dos::leer(void)//funcion no recibe no retorna leer

{
cout<<"\n"<<endl;//salto de linea para un mejor aspecto
acum1=0;//se le da un valor a la variable para eliminar datos basura
acum2=0;//se le da un valor a la variable para eliminar datos basura
}

void dos::contador(void)//funcion no recibe no retorna contador

{
cout << "Los divisores de " << num1 << " son: ";//imprime en pantalla que se diran cuales son los dvisores del primer numero
for (int i=1 ; i<=num1 ; i++)//cuenta desde el 1 gasta el primer numero introducido
{
if (num1%i==0)//condicion para sacar los divisores del numero
{
acum1++;//variable acumuladora para saber cuantos divisores tiene
cout << i << " ";//para mostrar los divisores del numero
}
}
cout << endl << "Los divisores de " << num2 << " son: ";//imprime en pantalla que se diran cuales son los dvisores del
segundo numero
for (int j=1 ; j<=num2 ; j++)//cuenta desde el 1 gasta el segundo numero introducido
{
if (num2%j==0)//condicion para sacar los divisores del numero
{
acum2++;//variable acumuladora para saber cuantos divisores tiene
cout << j << " ";//para imprimir los divisores del numero
}
}
}

void dos::mostrar(void)//funcion no recibe no retorna mostrar

{
if (acum1>acum2)//condicion para saber cual de los dos numeros tiene mas divisores
{
cout << endl << "El numero " << num1 << " tiene mas divisores\n";//me imprime en pantalla cual de los dos numeros tiene
mas divisores
}
else //en caso de que acum1 no sea mayor que acum2
{
cout << endl << "El numero " << num2 << " tiene mas divisores\n";//se imprime en pantalla que tiene mas divisores
14

}
}

int main()//funcion principal

{
dos d;// se declara d como objeto de tipo
d.leer();//invocacion de funcion leer
d.contador();//invocacion de la funcion contador
d.mostrar();//invocacion de la funcion mostrar
}
PARES O IMPARES Y MUESTRA LA SUMA

#include <iostream>
#include <conio.h>
using namespace std;
int n, suma=0,s,num[100], par[100],impar[100],cp=0,cip=0;
int main()
{
cout<<"Cuantos numeros desea introducir?"<<endl;
cin>>n;
for (int i=1;i<=n;i++)
{
cout<<"Ingrese el numero por favor "<<endl;
cin>>s;
num[i]=s;
suma=suma+s;
if (s%2==0)
{
cp=cp++;
cout<<"el numero es par
"<<endl;

else{
cip=cip++;
cout<<"el numero es
impar "<<endl;
}

}
for (int i=1;i<=n;i++)
{
if (s%2==0)
{
par[i]=s;
}
else
impar[i]=s;
}
cout<<"La suma de los "<<n<<" numeros es "<<suma<<endl;
cout<<"los numeros son "<<endl<<endl;

for (int i=1;i<=n;i++)

{
cout<<" "<<num[i];
}
cout<<"hay "<<cp<<" numeros pares"<<endl;
cout<<"hay "<<cip<<" numeros impares"<<endl;
getch();
}

PRIMOS RELATIVOS

class dos//declaro a dos como tipo class

15

{
private://datos del bloque privado
int num1, num2, acum,i,j,n;//declaracion de variables de tipo entero
int *a,*b;//se declaran las variables como apuntador de tipo entero
public://datos del bloque publico donde estan las funciones
dos();// funcion constructora
~dos();//funcion destructor
void hacer(void);//funcion no recibe no retorna hacer
void ver(void);//funcion no recibe no retorna ver
};

dos::dos()//funcion constructora
{
cout<<"Construyendo "<<endl;//verificar que es el primero que se ejecuta
cout << " Ingrese el numero 1" << endl;//imprime en pantalla que el usuario debe ingresar el primer numero
cin >> num1;//captura el dato en la variable
cout << " Ingrese el numero 2" << endl;//imprime en pantalla que el usuario debe ingresar el segundo numero
cin >> num2;//captura el dato en la variable
a=new int[num1];//asignacion dinamica de memoria
if(a==NULL)//condicion if por si existen errores en la asignacion de memoria dinamica
cout<<"Error";//imprime en pantalla el error
b=new int[num2];//condicion if por si existen errores en la asignacion de memoria dinamica
if(b==NULL)//condicion if por si existen errores en la asignacion de memoria dinamica
cout<<"Error 2";//imprime en pantalla el error
}

dos::~dos()//funcion destructura
{
cout<<"Destruyendo "<<endl;//se imprime para verificar que es la ultima en ejecutarse
delete a;//liberacion
delete b;//liberacion
}

void dos::hacer(void)//funcion no recibe no retorna hacer

{
acum=0;//se le asigna el valor de 0 a la variable para eliminar datos basura
for (int i=1 ; i<=num1 ; i++)//for que cuenta desde 1 hasta el primer numero
{
if (num1%i==0)//condicion si el modulo de num1 en i si es 0
{
for (int j=1 ; j<=num2 ; j++)//for que cuenta desde 1 hasta el segundo numero
{
if (num2%j==0)//condicion si el modulo de num1 en i si es 0
{
if (i==j)
{
acum= acum+1;
}
}

}
}
}
}

void dos::ver(void)//funcion no recibe no retorna ver

{
if (acum==1)
{
cout << "los numeros " << num1 << " " << num2 << " son primos relativos" << endl;//me imprime en pantalla los resultados
}
else
{
cout << "los numeros " << num1 << " " << num2 << " no son primos relativos" << endl;//me imprime en pantalla los
resultados
}
16

int main()//funcion principal

{
dos d;//se declara a d como objeto de tipo dos
d.hacer();//invocacion de la funcion hacer
d.ver();//invocacion de la funcion ver
getch();
}

INVERTIR UN NUMERO
class relativo//declaro a relativo como tipo class
{
int nu;//declaracion de variables de tipo entero
int *a;//se declaran las variables como apuntador de tipo entero
public: //datos del bloque publico donde estan las funciones
relativo();// funcion constructora
~relativo();//funcion destructor
void comparar();//funcion no recibe no retorna comparar
void mostrar();//funcion no recibe no retorna mostrar
};

relativo::relativo()// funcion constructora

{
cout<<"Construyendo \n"<<endl;//verificar que es el primero que se ejecuta
cout<<"Ingrese por favor un numero para invertirlo ";
cin>>nu;
a=new int[nu];//asignacion dinamica de memoria
if(a==NULL)//condicion if por si existen errores en la asignacion de memoria dinamica
cout<<"Error";//imprime en pantalla el error
}
relativo::~relativo()//funcion destructura la ultima que se ejecuta
{
cout<<"Destruyendo "<<endl;//se imprime para verificar que es la ultima en ejecutarse
delete a;//liberacion
}

void relativo::comparar()//funcion no recibe no retorna comparar

{
while(nu>10) //cuando nu sea mayor que 10
{
cout<<(nu%10); //se le saque el module a nu de 10
nu=nu/10; //nu=a nu dividido entre 10
}
}

void relativo::mostrar()//funcion no recibe no retorna mostrar

{
cout<<nu; //imprime el numero invertido
getch(); //pausa para ver los resultados
}

int main()//funcion principal

{
relativo num;//se declara a num como objeto de tipo relativo
num.comparar();//invocaciond e la funcion comparar
num.mostrar();//invocacion de la funcion mostrar
}
FIBONACCI

class dos//se declara a dos de tipo class

{
private://bloque privado
17

int d,e,c,l,i;//se declaran variables tipo entero

int *a;//se declaran las variables como apuntador de tipo entero
public://bloque publico donde se encuentran declaradas las funciones
dos();//funcion constructora
~dos();//funcion destructora
void leer(void);//funcion leer
void hacer(void);//funcion no recibe no retorna hacer
void ver(void);//funcion no recibe no retorna ver
};

dos::dos()//funcion constructora
{
cout<<"Construyendo "<<endl;//para confirmar que es la primera en ejecutarse
d=0;//se le asigna el valor de 0 a la variable para evitar datos basura
e=1;//se le asigna el valor de 1 para evitar datos basura
c=1;//se le asigna este valor
cout<<"Ingresar numero limite\n"<<endl;//se le pide al usuario que ingre el numero de limite a obetener en la serie
cin>>l;//se captura el resultado en la variable l
a=new int[l];//asignacion dinamica de memoria
if(a==NULL)//condicion if por si existen errores en la asignacion de memoria dinamica
cout<<"Error";//imprime en pantalla que existe un error
for(i=0;i<=l;i++)//for que realizar las veces de repetir hasta n veces
a[i]=0;//el primer valor de el vector a[i] es 0
}

dos::~dos()//funcion destructora
{
cout<<"Destruyendo "<<endl;//para confirmar que es la ultima en ejecutarse
delete a;//liberacion

void dos::leer(void)//funcion leer

{
if(l == 0)//esta condicion significa q si l es igual a cero q me imprima un 0 en la pantalla
cout<<d<<" "<<endl;//impresion del 0
}

void dos::hacer(void)//funcion no recibe no retorna hacer

{

if(l == 1)//esta condicion dice q si l es igual a 1 me imprima en pantalla los valores que tienen las variables
cout<<d<<" "<<e<<" "<<c<<" ";//impresion del valor que tiene las variable y espacios para separarlas
}

void dos::ver(void)//funcion no recibe no retorna ver

{
if(l > 1) {//esta condicion me dice q si le es mayor q 1 imprima los valores de las siguientes variables
cout<<d<<" "<<e<<" "<<c;////impresion del valor que tiene las variable y espacios para separarlas
while(c < l) {//ciclo que dice que si c es menor que 1 realice los pasos siguientes

d=e;//dice que copie el valor que tiene e a d

e=c;//dice que copue el valor que tiene c a e
c=d+e;//dice que c es igual a la suma de d+e
cout<<" "<<c;//me imprime un espacio y el valor que tiene c

}
}
getch(); //pausa para observar los resultados en pantalla
}

int main()//funcion principal

{
dos d;//se declara como objeto d de tipo dos
d.leer();//invocacion de la funcion leer
18

d.hacer();//invocacion de la funcion hacer

d.ver();//invocacion de la funcion ver
}
FACTORIAL SENCILLO
R ES EL NUMERO INGRESADO
r=f;//se le asigna a r el mismo valor que tiene f
for(int i=f-1;i>=1;i--)//for que que va disminuyendo el numero ingresado una vez cada ciclo para poder multiplicarlo entre si mismos
{
r*=i; //Multiplicar y operador de asignacin, se multiplica operando de la derecha con el operando de la izquierda y asigna el
resultado a la izquierda del operando
}
ORDENAR NOMBRES ALFAVETICAMENTE
using namespace std;
int main()
{
int n;
cout<<"Ingrese cantidad de nombres a ingresar: \n";
cin>>n;
char s[n-1][100],aux[100];
int i,j;
float comp;
for(i=0;i<n;i++)
{
printf("Ingrese un nombre: \n");
scanf("%s",s[i]);
}
system("cls");
for(i=0;i<n;i++)
{
for(j=0;j<n-i;j++)
{
comp = strcmp( s[j], s[j+1] );
if(comp > 0)
{
strcpy(aux,s[j]);
strcpy(s[j],s[j+1]);
strcpy(s[j+1],aux);
}
}
}
printf("Los nombres ordenados alfabeticamente son: \n");
for(i=0;i<n;i++)
{
printf("%d.- %s \n",i+1,s[i]);
}
system("PAUSE");
}

1. public static boolean esPrimo(int numero){

2. int contador = 2;
3. boolean primo=true;
4. while ((primo) && (contador!=numero)){
5. if (numero % contador == 0)
6. primo = false;
7. contador++;
8. }
9. return primo;
10. }