Sunteți pe pagina 1din 50

//Codificado por: sAfOrAs

//Cdigo Fuente: Calcula cuantos nmeros pares hay entre dos ingresados
#include<iostream>
using namespace std;
int main()
{
int a=0,b=0,c=0;
cout<<"ingrese un numero: ";cin>>a;
cout<<"ingrese otro numero: ";cin>>b;
while(a<=b)
{
if(a%2!=0)
c=c+1; a=a+1;
}
cout<<c<<endl;
cin.ignore(); return 0;
}

METODO
Este programa calcula la inversa de una matriz por medio del metodo
del espejo, es decir se aplica la reduccion de Gauss-Jordan en
una matriz de nxn y se aplican las mismas operaciones de fila a una
matriz identidad de nxn
#include <stdio.h>
#include <conio.h>
#include <math.h>
/*********** VARIABLES GLOBALES **********************/
double matriz[50][50];
double identidad[50][50];
int N; //N contiene el tamao de la matriz cuadrada
/*********** PROTOTIPOS DE FUNCIONES *****************/
void
void
void
void
void
void
void
void

hallar_inversa(void);
escalonar_matriz(void);
permutar_filas(int fila1, int fila2);
multip_fila(int fila,double factor);
sumar_fila_multip(int fila1,int fila2, double factor);
ceros_abajo(int fila_pivote, int columna_pivote);
ceros_arriba(int fila_pivote, int columna_pivote);
generar_matriz_identidad(void);

/*****************************************************/

int main()
{
int fi, co;
clrscr();
do{
printf("Ingrese el tamao de la matriz cuadrada: ");
scanf("%i",&N);
if(N>50 || N<2) {clrscr(); printf("El numero debe estar entre 2 y 50n");}
}while(N>50 || N<2);
for(fi=0;fi<N;fi++)
{
for(co=0;co<N;co++)
{
printf("Ingrese el valor de matriz[%i][%i]",fi+1,co+1);
scanf("%lf",&matriz[fi][co]);
}
}
hallar_inversa();
return 0;
}
/*-------------------------------------------------------------------------*/
void hallar_inversa(void)
{
int cont,cont2, flag=0;
escalonar_matriz();
generar_matriz_identidad(); //rellena la matriz identidad
for(cont=0;cont<N;cont++) //recorre filas
{
for(cont2=0;cont2<N;cont2++) //recorre columnas
{
if(matriz[cont][cont2]!=0) //busca pivote (elemento ditinto de 0)
{
if(matriz[cont][cont2]!=1) //si pivote no es 1, se lo multiplica
{
multip_fila(cont,pow(matriz[cont][cont2],-1));
}
ceros_arriba(cont,cont2); // se hacen 0's por arriba
ceros_abajo(cont,cont2); // y por debajo del pivote
break;
}
}

}
/*--------------------------------------------------------------*/
/* Una vez terminada esta operacion, la matriz identidad estara */
/* transformada en la inversa */
/* */
/* Ahora se comprueba que la matriz original este transformada */
/* en la matriz identidad, de no ser asi la inversa obtenida */
/* no es valida y la matriz no tiena inversa */
/*--------------------------------------------------------------*/
for(cont=0;cont<N;cont++)
{
for(cont2=0;cont2<N;cont2++)
{
if(cont==cont2)
{
if(matriz[cont][cont2]!=1) flag=1;
}
else
{
if(matriz[cont][cont2]!=0) flag=1;
}
}
}

if(flag==1)
{
printf("nnLa matriz no tiene inversann");
}
else
{
printf("nnLa Matriz Inversa es :nn");
for(cont=0;cont<N;cont++)
{
for(cont2=0;cont2<N;cont2++)
{
printf("%+#0.3f ",identidad[cont][cont2]);
}
printf("n");
}
}
printf("nPresione una tecla para continuar...");
getch();
}
/*-----------------------------------------------------------------------*/

/* */
/* Ordena la matriz de forma que quede en su forma escalonada por */
/* renglones */
/* */
/*-----------------------------------------------------------------------*/
void escalonar_matriz(void)
{
int cont, col, ceros, vec[10];
int flag, aux;
for(cont=0;cont<N;cont++)
{
col=0,ceros=0;
if(matriz[cont][col]==0)
{
do{
ceros++;
col++;
}while(matriz[cont][col]==0);
}
vec[cont]=ceros;
}
do
{
flag=0;
for(cont=0;cont<N-1;cont++)
{
if(vec[cont]>vec[cont+1])
{
aux=vec[cont];
vec[cont]=vec[cont+1];
vec[cont+1]=aux;
permutar_filas(cont,cont+1);
flag=1;
}
}
}while(flag==1);
}
/*----------------------------------------------------------------------*/
/* SE DEFINEN LAS 3 OPERACIONES ELEMENTALES DE FILA */
/* */
/* Las operaciones que se le realizen a la matriz para reducirla */
/* tambien deberan realizarsele a la matriz identidad para obtener */
/* la matriz inversa */
/*----------------------------------------------------------------------*/

void permutar_filas(int fila1,int fila2)


{
float auxval;
int cont;
for(cont=0;cont<N;cont++)
{
auxval=matriz[fila1][cont];
matriz[fila1][cont]=matriz[fila2][cont];
matriz[fila2][cont]=auxval;
auxval=identidad[fila1][cont];
identidad[fila1][cont]=identidad[fila2][cont];
identidad[fila2][cont]=auxval;
}
}
/*----------------------------------------------------------------------*/
void multip_fila(int fila,double factor)
{
int cont;
for(cont=0;cont<N;cont++)
{
matriz[fila][cont]=(matriz[fila][cont])*factor;
identidad[fila][cont]=(identidad[fila][cont])*factor;
}
}
/*----------------------------------------------------------------------*/
void sumar_fila_multip(int fila1,int fila2, double factor)
{
int cont;
for(cont=0;cont<N;cont++)
{
matriz[fila1][cont]=(matriz[fila1][cont])+((matriz[fila2][cont])*factor);
identidad[fila1][cont]=(identidad[fila1][cont])+((identidad[fila2][cont])*factor);
}
}
void ceros_arriba(int fila_pivote, int columna_pivote)
{
int cont;
for(cont=0;cont<fila_pivote;cont++)
{
sumar_fila_multip(cont,fila_pivote,((matriz[cont][columna_pivote])*(-1)));
}
}
/*-------------------------------------------------------------------------*/

void ceros_abajo(int fila_pivote, int columna_pivote)


{
int cont;
for(cont=columna_pivote+1;cont<N;cont++)
{
sumar_fila_multip(cont,fila_pivote,((matriz[cont][columna_pivote])*(-1)));
}
}
/*-------------------------------------------------------------------------*/
void generar_matriz_identidad(void)
{
int i,j;
for(i=0;i<50;i++)
{
for(j=0;j<50;j++)
{
if(i==j) identidad[i][j]=1;
else identidad[i][j]=0;
}
}
}
FOBONAZI
Solo es una funcion que muestra el numero fibonachi n
// codiog probado en Dev-C++
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
// primera idea de funcino fibonachi
long long Fibonachi1(int n)
{
if (n<2) return 1;
else return (Fibonachi1(n-1)+Fibonachi1(n-2));
}
//fibonachi Mejorada
long long Fibonachi1(int n)
{
long long vector[n];
for (int i=0; i<n; i++)
{
if (i<2) vector[i]= i;
else vector[i] = (vector[i-1]+vector[i-2]);
return vector[n-1];
}

main()

int a;
cout << "ingrese el numero a calcular: ";
cin >> a;
cout << endl << endl;
cout << "el resultado es : " << Fibonachi2(a);
getchar();
return 0;

consiste en un tablero de 4x4 casillas con nmeros ordenados del 1 al 15, no contiene
el 16 por simular el espacio, que trata principalmente en mostrar al usuario un tablero
desordenado para que ste lo ordene en la menor cantidad de movimientos posibles
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<conio.h>
#define FLECHA 224 // Codigo Ascii comn a flecha (esto es copia de otro posteo XD)
#define IZQUIERDA 75 // Codigo Ascii flecha izquierda
#define DERECHA 77 // Codigo Ascii flecha derecha
#define ARRIBA 72 // Codigo Ascii flecha arriba
#define ABAJO 80 // Codigo Ascii flecha abajo
#define N 4
void imprime(int puzzle[N][N]){
int i,j;
printf("\nnttt *-----------------------*n");
for(i=0;i<N;i++){
printf("ttt |");
for(j=0;j<N;j++){
if(puzzle[i][j]==0)
printf(" |");
else
printf("%3d |",puzzle[i][j]);
}
printf("n");
if(i<3)
printf("ttt ------+-----+-----+------n");
}
printf("ttt *-----------------------*nnn");
}
char tecla (unsigned char pulsacion){
if (pulsacion==224) //se hace esta condicin por si no se llegase a ingresar flechas par
a mover
pulsacion=getch();
return pulsacion;
}
void mover(int puzzle[N][N],int mov){// Realiza movimientos el usuario
int i,j,k,l,aux;
for(k=0;k<N;k++)//encontramos el lugar donde no hay nada para tener los indices de
posicion
for(l=0;l<N;l++)
if(puzzle[k][l]==0){
i=k;

j=l;
}
while((mov==80 && i==0)||(mov==75 && j==3)||(mov==77 && j==0)||(mov==72 &
& i==3)||(mov!=80 && mov!=75 && mov!=77 && mov!=72)){
system("cls");
imprime(puzzle);
printf("nnt Presione las flechas para realizar movimientos (%c%c%c%c)",27,24,25,26);
mov=tecla(getch());
}
if(mov==80){ // movimiento abajo
aux=puzzle[i][j];
puzzle[i][j]=puzzle[i-1][j];
puzzle[i-1][j]=aux;
i=i-1;
}
else if(mov==75){ // movimiento izquirda
aux=puzzle[i][j];
puzzle[i][j]=puzzle[i][j+1];
puzzle[i][j+1]=aux;
j=j+1;
}
else if(mov==77){ // movimiento derecha
aux=puzzle[i][j];
puzzle[i][j]=puzzle[i][j-1];
puzzle[i][j-1]=aux;
j=j-1;
}
else{ // movimiento arriba
aux=puzzle[i][j];
puzzle[i][j]=puzzle[i+1][j];
puzzle[i+1][j]=aux;
i=i+1;
}
}
void desordena(int puzzle[N][N],int dific){
int i,j,k,alea;
int aux;
i=3;
j=3;
for(k=0;k<dific;k++){
do{
alea=rand()%4; //Genero aleatorio para posicion de arreglo movimiento
}while((alea==0 && i==0)||(alea==1 && j==3)||(alea==2 && j==0)||(alea==3 && i=
=3));
switch(alea){
case 0: // movimiento abajo
aux=puzzle[i][j];
puzzle[i][j]=puzzle[i-1][j];
puzzle[i-1][j]=aux;
i=i-1;
break;
case 1: // movimiento izquirda
aux=puzzle[i][j];
puzzle[i][j]=puzzle[i][j+1];

puzzle[i][j+1]=aux;
j=j+1;
break;
case 2: // movimiento derecha
aux=puzzle[i][j];
puzzle[i][j]=puzzle[i][j-1];
puzzle[i][j-1]=aux;
j=j-1;
break;
case 3: // movimiento arriba
aux=puzzle[i][j];
puzzle[i][j]=puzzle[i+1][j];
puzzle[i+1][j]=aux;
i=i+1;
break;
}
}
}
void genera_puzzle(int puzzle[N][N]){
int i,j,num;
num=1;
for(i=0;i<N;i++){
for(j=0;j<N;j++){
puzzle[i][j]=num;
num++;
if(i==3 && j==3)
puzzle[i][j]=0;
}
}
}
int correcto(int puzzle[N][N]){//ve si el puzzle esta resuelto
int i,j,num,flag;
num=1;
flag=1;
for(i=0;i<N;i++)
for(j=0;j<N;j++){
if(i==3 && j==3)
num=0;
if(puzzle[i][j]!=num)
flag++;
num++;
}
return(flag);
}
main()
{
// Declaraciones
int n,i,dific,cont;
int puzzle[N][N]; //Arreglo con puzzle
int continuar;
unsigned char mov;//se declara como unsigned char porque el cdigo ascii no imprimib
le de las flechas
//es 224 y un simple char solo soporta ascii entre 0 y 127 y con la
//declaracion de insigned char soporta codigo ascii entre 0 y 225
time_t t;

time(&t);
srand(t);
// Algoritmo
genera_puzzle(puzzle);
do{
printf("[1] Faciln");
printf("[2] Intermedion");
printf("[3] Dificiln");
printf("Ingrese dificultad: ");
dific=getch();
system("cls");
}while(dific!=49 && dific!=50 && dific!=51);
if(dific==49)
dific=200;
else if(dific==50)
dific=500;
else
dific=900;
do{ // para corroborar que realmente se ha desordenado
desordena(puzzle,dific);
continuar=correcto(puzzle);
}while(continuar==1);
cont=0;// contador de jugadas
system("color 70");
do{
do{
system("cls");
imprime(puzzle);
printf("nnt Presione las flechas para realizar movimientos (%c%c%c%c)",27,24,25,26);
mov=tecla(getch());
printf("n");
}while(mov!=ABAJO && mov!=IZQUIERDA && mov!=DERECHA && mov!=ARRIBA);
mover(puzzle,mov);
continuar=correcto(puzzle);
cont++;
}while(continuar!=1);
system("cls");
imprime(puzzle);
system("color 07");
sleep(400);
printf(" %c%c%c%c%c %c%c%c%c %c %c %c%c%c%c%c %c %c%c%c %c %c%c%c %
c%c%c%c %c%c%c%c
%cn",1,1,1,1,1,2,2,2,2,1,2,1,1,1,1,1,2,1,1,1,2,1,1,1,2,2,2,2,1,1,1,1,1);
system("color 70");
sleep(400);
printf(" %c %c %c %c %c %c %c %c %c %c %c %cn",1,2,1,1,1,1,2,2,1,1,2);
system("color 07");
sleep(400);
printf(" %c%c %c%c %c %c %c %c %c %c %c%c%c%c%c %c %c %c%c %c%c%c%c
%cn",1,1,2,2,1,2,1,2,1,1,2,2,2,2,2,1,1,2,2,1,1,1,1,1);
system("color 70");
sleep(400);

printf(" %c %c %c %c %c %c %c %c %c %c %c %c %c %cn",1,2,1,2,1,2,1,1,2,2,1,1,2,1)
;
system("color 07");
sleep(400);
printf(" %c %c%c%c%c%c %c%c%c%c%c %c %c%c%c%c%c %c %c%c%c %c %c %c
%c%c %c%c%c%c%c %c%c%c%c
%cn",1,2,2,2,2,2,1,1,1,1,1,2,1,1,1,1,1,2,1,1,1,2,2,1,1,1,2,2,2,2,2,1,1,1,1,1);
system("color 70");
sleep(400);
printf("nttt Total movimientos: %dnntt ",cont);
system("color 07");
sleep(400);
system("pause");
}
/*
Se declara a la variable mov como unsigned char debido a que un simple char
solo acepta cdigo ascii entre 0 y 127, lo cual no nos sirve, debido a que
los caracteres no imprimibles estn comprendidos entre 0 y 225, siendo el
cdigo ascii comn de las flechas el nmero 224, pero el especfico de cada
flecha seran los siguientes:
Abajo : 80
Izquierda : 75
Derecha : 77
Arriba : 72
*/

DIAS TRANSCURRIDOS
//DETERMINAR LA CANTIDAD DE DIAS QUE PASARON
HASTA LA FECHA.
#include<iostream>

03
0
4

using namespace
std;

0
5

int main()

0
6

0
7

int m,a;

0
8

cout<<"Ingrese mes y
a"<<char(164)<<"o"<<endl;

0
9

cin>>m>>a;

1
0

1
1

if((a%4)==0) cout<<"365
dias"<<endl;
else

1
2
1
3

cout<<"364
dias"<<endl;

1
4
1
5
1
6

cin.ignore();
return 0;
}

AGENDA TELEFONICA
Pede dar de alta, baja , modificar registros; ordenar por nombre, apellidos , edad.
Guarda los contenidos en un archivos binario y los puede leer tambien puede exportar
en csv. corre perfecto en linux, pero para que funcione en windows hay que quitar la
funcion sleep.
/*
Creado Por Vicente Mendoza
*/
# include <stdio.h>
# include <string.h>
# define FICHERO "datos"
# define MAX 25
# define ESCAPE ((char)27)
FILE *fichero;

struct agenda{

//*************************

int clave;

//

Esctructura con *

char nom[20];

//

la forma de

char ApPat[15];

//

los datos registro*

char ApMat[15];

//*************************

int edad;
long int tel;
long int cel;
char calle[15];
char col[15];
char mun[15];
char estado[15];
int sw;
char mail[25];
}r[MAX];

int menu (void);


void agregar(void);
void mostrar(struct agenda);
void buscarnom(char[]);
void buscaredad(int);

//********************

void apertura(void);

//Prototipos de las

void m_todo(void);

//

void borrar(int);
void borrartodo(void);
void ordena(void);
void SaveToDisk(struct agenda);
struct agenda ReadToDisk(int);
int ReadAllToDisk(void);
void OrdenaOnMemory(int,int);
void clavesdisponibles(void);
void actualizar(struct agenda,int);

Funciones

//********************

void exportar(void);

int main (){


int op,opc=0,opcls=0,clave=0,edades=0,i;
int numreg=0;
char expresion[20];
struct agenda reg;
printf("Creado por Vicente Mendoza");
apertura();
menu:
op = menu();
switch (op){
case 1:
agregar();
//*********
//AGREGAR

goto menu;

break;
//*********
case 2:
printf("Dame la clave a borrar: ");
//*********

scanf ("%d",&clave);
borrar(clave);

//BORRAR
//*********

printf("tRegistro Borrado: %d",clave);


goto menu;

break;
case 3:
printf ("t Como prefiere hacer la busqueda ?");

printf ("n");
printf ("tt1. Por Nombre, Apellido Paterno y Materno");
printf ("n");
//***********
printf ("tt2. Por Edad");
//BUSQUEDA
printf("ntOpcion: ");
//***********
scanf("%d",&opc);
if(opc==1){
printf ("Escribe el Nombre o Apellidos a buscar: ");
scanf ("%s",expresion);
buscarnom(expresion);
}else if(opc=2){
printf ("Escribe la edad para buscar ");
scanf ("%d",&edades);
buscaredad(edades);
}
goto menu;
break;
case 4:
m_todo();

//*************

goto menu;

//MOSTRAR_TODO

break;

//*************

case 5:
ordena();
goto menu;
break;
case 6:

printf("n 1)Nombret2)Ap. Paternot3)Ap. Maternot4)Edadt5)C

alle");

printf("nOpcion: ");
scanf("%d",&opcls);
numreg=ReadAllToDisk();
//******************
OrdenaOnMemory(numreg,opcls);

//LISTAR

for(i=0;i<numreg;i++)
//******************
mostrar(r[i]);
goto menu;
break;
case 7:
printf("nQue registro va actualizar (clave): ");
//***************

scanf("%d",&clave);
reg=ReadToDisk(clave);

//ACTUALIZAR
//***************

mostrar(reg);
printf("nQue dato desea actualizar");

printf("n 1)Nombret2)Ap. Paternot3)Ap. Maternot4)Edadt5)C


allet6)Telefonot7)Celulart8)Email ");
printf("n Opcion: ");
scanf("%d",&opcls);
actualizar(reg,opcls);
printf("nRegistro Actualizado");
goto menu;
break;
case 8:
exportar();

//****************

goto menu;
break;

//EXPORTAR EN CSV
//****************

case 9:
printf("n Ha terminado el programa..n");
break;
}
fclose(fichero);
return 1;
}
///////////////////////////////////////////////////////////////////////
void ordena(void){
int i,c;
c=ReadAllToDisk();
OrdenaOnMemory(c,1);
//*******************************
Archivo

borrartodo();
for(i=0;i<c;i++){
r[i].clave=i+1;
//*******************************
SaveToDisk(r[i]);
}
printf("nArchivo Ordenadon");

}
///////////////////////////////////////////////////////////////////////
void OrdenaOnMemory(int c,int tipo){
int pas,i;
struct agenda aux={0};
for(pas=1;pas<c;pas++)

//Funcion que Ordena el


//Por Nombre

for(i=0;i<c-1;i++){
if(strcmp(r[i].nom,r[i+1].nom)>0 && tipo==1){
aux=r[i];
r[i]=r[i+1];
//*******************
//esta funcion

r[i+1]=aux;

}else if(strcmp(r[i].ApPat,r[i+1].ApPat)>0 && tipo==2){


//ordena en memoria
//recibe el numero de

aux=r[i];
r[i]=r[i+1];

//registros c
//Y tipo que sirve

r[i+1]=aux;

}else if(strcmp(r[i].ApMat,r[i+1].ApMat)>0 && tipo==3){


//para saber sobre
//que campo ordenar

aux=r[i];

r[i]=r[i+1];
//*******************
r[i+1]=aux;
}else if(r[i].edad >= r[i+1].edad && tipo==4){
aux=r[i];
r[i]=r[i+1];
r[i+1]=aux;
}else if(strcmp(r[i].calle,r[i+1].calle)>0 && tipo==5){
aux=r[i];
r[i]=r[i+1];
r[i+1]=aux;
}
}

}
///////////////////////////////////////////////////////////////////////
void apertura(void){
//*********************************
if((fichero=fopen(FICHERO,"r+"))==NULL)
abrir el archivo

//Metodo para

fichero=fopen(FICHERO,"w");
ror crea el archivo

//En caso de er

}
********************

//*************

///////////////////////////////////////////////////////////////////////
int menu(void){
int opmenu=0;
printf("%c[1;34m",ESCAPE);
//*********************************
printf ("ntM E N U");
uestra el Menu

//Fucion que m

printf("n");
tero con el valor

//retorna un en

elegida

printf("%c[2;36m",ESCAPE);
printf ("1)Agregar");
//*********************************
printf (" 2)Borrar");
printf (" 3)Buscar");
printf (" 4)M.Todo");
printf (" 5)OrdenarArchivo");
printf (" 6)Listar");
printf (" 7)Modificar Registro");
printf (" 8)Exportar");
printf (" 9)Salir");
printf ("n");

//de la opcion

printf ("Opcion: ");


scanf("%d",&opmenu);
printf("%c[0m",ESCAPE);
return opmenu;
}
///////////////////////////////////////////////////////////////////////
void SaveToDisk(struct agenda registro){
//****************************************
fseek(fichero,(registro.clave-1)*sizeof(registro),SEEK_SET);
Salvar 1 registro en disco

//Funcion para

fwrite(istro,sizeof(registro),1,fichero);
stro y lo guarda dependiendo de su

//recibe el regi

}
e en el archivo

//clav

////////////////////////////////////////////////////////////////////// //**************************************
********
void agregar(void){
int clave;
struct agenda registro,aux;
printf("%c[31m",ESCAPE);
clavesdisponibles();
printf("%c[0m",ESCAPE);
do{
printf (" Dame tu clave: ");
//******************************
scanf ("%d",&clave);
//Codigo para validar la clave
if(clave>MAX) {
//debe de ser menor que MAX
printf("%c[31m",ESCAPE);
sar una con datos

//Y no puede u

//asociados

printf("Tu clave debe ser menor que %dn",MAX);

printf("%c[0m",ESCAPE);
//******************************
}
aux=ReadToDisk(clave);
if(aux.sw==1){
printf("%c[31m",ESCAPE);
printf("La clave ya esta en uso n");
printf("%c[0m",ESCAPE);
}
}while(clave>MAX || aux.sw==1);
registro.clave=clave;
printf (" Cual es tu nombre ? ");
//******************************
scanf ("%s",registro.nom);
Pedir datos

//Metodo para

printf (" Cual es tu Apellido Paterno ? ");


regarlos a disco

//y despues ag

scanf ("%s",registro.ApPat);
//******************************
printf (" Cual es tu Apellido Materno ? ");
scanf ("%s",registro.ApMat);
printf (" Cual es tu edad ? ");
scanf ("%d",istro.edad);
printf (" Cual es tu telefono ? ");
scanf ("%ld",istro.tel);
printf (" Cual es tu telefono celular? ");
scanf ("%ld",istro.cel);
printf (" Cual es tu calle ? ");
scanf ("%s",registro.calle);

printf (" Cual es tu colonia ? ");


scanf ("%s",registro.col);
printf (" Cual es tu Municipio ? ");
scanf ("%s",registro.mun);
printf (" En que Estado vives ? ");
scanf ("%s",registro.estado);
printf (" Cual es tu e-mail ? ");
scanf ("%s",registro.mail);
registro.sw=1;
SaveToDisk(registro);
printf ("Se ha agregado otro elemento a la agenda");
}
///////////////////////////////////////////////////////////////////////
void buscarnom(char expresion[20]){
//************************************
int i=2;
buscar una expresion (NOMBRE)

//Funcion que sirve para

struct agenda registro;

//en todos los r

egistros.
registro = ReadToDisk(1);
//************************************
do{
if((strcmp(registro.nom,expresion))==0 || (strcmp(registro.ApPat,exp
resion))==0 || (strcmp(registro.ApMat,expresion))==0)
mostrar(registro);
registro=ReadToDisk(i);
i++;
}while(!feof(fichero));
}
///////////////////////////////////////////////////////////////////////

void buscaredad(int edades){


int i=2;
struct agenda registro;
//*********************************
registro=ReadToDisk(1);
//Funcion que sirve para buscar
do{
edad en todos los registros

//una

if(registro.edad == edades)
//*********************************
mostrar(registro);
registro=ReadToDisk(i);
i++;
}while(!feof(fichero));
}
///////////////////////////////////////////////////////////////////////
int ReadAllToDisk(void){
struct agenda registro;
int i=2,c=0;
registro=ReadToDisk(1);
do{
if(registro.sw==1){
//*************************************
ee todos los registros

r[c]=registro;

//Funcion que l

c++;

//del archivo

}
************************
registro=ReadToDisk(i);
i++;
}while(!feof(fichero));

//*************

return c;
}
///////////////////////////////////////////////////////////////////////
struct agenda ReadToDisk(int clave){
struct agenda registro;
//*********************************************
fseek(fichero,(clave-1)*sizeof(registro),SEEK_SET);
a clave ,se diige a ella

//funcion que recibe un

fread(istro,sizeof(registro),1,fichero);
etorna la estructura

//en el archivo la lee y r

return registro;
//*********************************************
}
///////////////////////////////////////////////////////////////////////
void m_todo(void){
int i=2;
struct agenda registro;
registro=ReadToDisk(1);
//**************************
odos

do{

//Metodo para mostrar t


if(registro.sw==1)

//los registros del archiv

o
mostrar(registro);
registro=ReadToDisk(i);
i++;
}while(!feof(fichero));
}
///////////////////////////////////////////////////////////////////////
void mostrar(struct agenda registro){
printf ("n");

//***************************

printf (" Clave: tt %d ",registro.clave);


printf ("n");
printf (" Nombre: tt %s",registro.nom);
printf ("n");
printf (" Apellido Paterno: t %s",registro.ApPat);
printf ("n");
printf (" Apellido Materno: t %s",registro.ApMat);
//*******************************
printf ("n");
ecibe un registro
printf (" Edad: ttt %d",registro.edad);
printf ("n");
//*******************************
printf (" Telefono: tt %ld",registro.tel);
printf ("n");
printf (" Telefono Celular:t %ld",registro.cel);
printf ("n");
printf (" Calle: tt %s",registro.calle);
printf ("n");
printf (" Colonia: tt %s",registro.col);
printf ("n");
printf (" Municipio: tt %s",registro.mun);
printf ("n");
printf (" Estado: tt %s",registro.estado);
printf ("n");
printf (" Mail: ttt %s",registro.mail);
printf ("n");
sleep(1);
}

//Funcion que r
//y muestra sus campos

///////////////////////////////////////////////////////////////////////
void borrar(int clave){
struct agenda aux={0,"","","",0,0,0,"","","","",0,""};
//******************************
fseek (fichero,(clave-1)*sizeof(aux),SEEK_SET);
//Funcion que guarda un registro
fwrite(&aux,sizeof(aux),1,fichero);
rrar el anterior

//vacio para bo

}
**************************

//****

///////////////////////////////////////////////////////////////////////
void borrartodo(void){
int i;

//*****************************

for (i=1;i<=MAX;i++)

//Metodo que deja el Archivo

borrar(i);

//en blanco (borra todo)

//*****************************

///////////////////////////////////////////////////////////////////////
void clavesdisponibles(void){
struct agenda registro;
int i=2;
registro=ReadToDisk(1);
printf("Las claves disponibles son: ");
//***********************
isualiza

do{

//Metodo que v
if(registro.sw!=1)
printf("%d ",i-1);

registro=ReadToDisk(i);
//***********************
i++;
}while(!feof(fichero));

//todas las claves


//disponibles

for(;i<=MAX+1;i++)
printf("%d ",i-1);
printf("n");
}
///////////////////////////////////////////////////////////////////////
void actualizar(struct agenda registro,int opcion){
switch(opcion){
case 1:
printf (" Nombre ? ");
scanf ("%s",registro.nom);
break;
case 2:
printf (" Apellido Paterno ? ");
scanf ("%s",registro.ApPat);
break;
//**********************************
ecibe un registro

case 3:

//Funcion que r
printf (" Apellido Materno ? ");

//y modifica segun "opci

on"
scanf ("%s",registro.ApMat);

respondiente

break;
//**********************************
case 4:
printf (" Edad ? ");
scanf ("%d",istro.edad);
break;
case 5:
printf (" Calle ? ");

//el campo cor

scanf ("%s",registro.calle);
break;
case 6:
printf (" Telefono ? ");
scanf ("%ld",istro.tel);
break;
case 7:
printf (" Telefono celular? ");
scanf ("%ld",istro.cel);
break;
case 8:
printf (" Cual es tu e-mail ? ");
scanf ("%s",registro.mail);
break;
}
SaveToDisk(registro);
}
///////////////////////////////////////////////////////////////////////
void exportar(void){
FILE *archivo;
char nombre[20];

//********************************

int c,i;

//Metodo que sirve para

c=ReadAllToDisk();

//crear un archivo de te

xto
OrdenaOnMemory(c,1);
por comas
printf("Nombre del Archivo: ");
//********************************
scanf("%s",nombre);

//con valores separados

if((archivo=fopen(nombre,"w"))==NULL)
archivo=fopen(nombre,"w");
for(i=0;i<c;i++)
fprintf(archivo,"%d,%s,%s,%s,%d,%d,%d,%s,%s,%s,%s,
%s,n",r[i].clave,r[i].nom,r[i].ApPat,r[i].ApMat,r[i].edad,r[i].tel,r[i].cel,r[i].calle,r[i].col,r[i].
mun,r[i].estado,r[i].mail);
fclose(archivo);
}
///////////////////////////////////////////////////////////////////////
NUMERO PRIMO
/*INVESTIGACION DE UN NUMERO RESPECTO A SI ES NUMERO PRIMO*/
#include<stdio.h>
int main()
{
long Num,divisor=2;
printf("t Introducir el Numero = ");
scanf("%ld",&Num);
while(divisor<Num)
{ while( Num % divisor != 0)
divisor=divisor+1;
if(Num== divisor)
printf("t %ld es PRIMO n",Num);
else
printf("t%ld NO es PRIMO ,pues ES multiplo de %ld n",Num,divisor);
break;
}
return 0;
}

CALCULADORA
Una calculadora simple que ilustra el funcionamiento de algunas funciones de _math.h_
/* Este fichero ha sido descargado desde:
http://www.elrincondelc.com
*
*
*
*
*
*
*
*
*
*
*

calc.c: Lame-brain Calculator For simplicity in parsing, this program


reads lines of the form:
value operation
where the value is optional in some cases.
For example, the following script computes
the integer part of sqrt(1 + 3.4*3.4):

*
*
*
*
*
*/

3.4 =
3.4 *
1+
sqrt
floor

#include
#include
#include
#include
#include
#include

<stdio.h>
<stdlib.h>
<math.h>
<string.h>
<ctype.h>
<errno.h>

#define LINSIZ 40
char *getline(char *);
main()
{
double reg = 0.0;
char line[LINSIZ];
while (getline(line) != NULL)
{
char *op;
double val;
/* Parse command string */
val = strtod(line,&op);
while (isspace(*op))
++op;
strupr(op);
/* Perform operation */
errno = 0;
if (*op == '+')
reg += val;
else if (*op == '-')
reg -= val;
else if (*op == '*')
reg *= val;
else if (*op == '/')
{
if (val != 0)
reg /= val;
else
{
puts("ERROR>>> invalid divisor");
continue;
}
}
else if (*op == '=')
reg = val;

else if (*op == '^')


{
if (val == 0.0)
reg = 1.0;
else if (val == 0.5)
reg = sqrt(reg);
else
reg = pow(reg,val);
}
else if (strncmp(op,"NEGATE",1) == 0)
reg = -reg;
else if (strncmp(op,"MOD",1) == 0)
{
if (val == 0.0)
{
puts("ERROR>>> invalid modulus");
continue;
}
else
reg = fmod(reg,val);
}
else if (strncmp(op,"CEIL",1) == 0)
reg = ceil(reg);
else if (strncmp(op,"FLOOR",1) == 0)
reg = floor(reg);
else if (strncmp(op,"ROUND",1) == 0)
reg = (reg < 0.0) ? ceil(reg - 0.5)
: floor(reg + 0.5);
else if (strncmp(op,"SQRT",1) == 0)
reg = sqrt(reg);
else if (strncmp(op,"QUIT",1) == 0)
exit(0);
else if (*op != '\0')
{
puts("ERROR>>> invalid operation");
continue;
}
if (errno)
perror("ERROR>>>");
else
printf("\t%s => %g\n",line,reg);
}
return 0;
}
char *getline(char *buf)
{
fputs("Calc> ",stdout);
fflush(stdout);
return gets(buf);
}
/* Output:
Calc> 3.4 =

3.4 = => 3.4


Calc> 3.4 *
3.4 * => 11.56
Calc> 1 +
1 + => 12.56
Calc> sqrt
SQRT => 3.54401
Calc> round
FLOOR => 3
Calc> q
*/
ANALIZADOR LEXICO
Este programa es un analizador lexico que te sube las palabras analizadas de un
archivo a memoria dinamica utilizando arboles
los archivos tendran el codigo fuente
ejemplo
inicio
escribir(Daniel)
fin
este programa esta hecho con pase de parametros espero que te sirva
#include"stdio.h" /*Las palabras que puedes utilizar en este progra ma son las iguient
es*/
#include"conio.h" /*inicio, escribe, lee, si, fin, mientras*/
#include"alloc.h"
/*inicio es la cabesa del programa*/
#define FALSO 0 /*fin son los pies delprograma*/
#define CIERTO 1 /*escribe,lee,si,mientras son isntrucciones dadas por*/
/*la gramatica ya antes establecida*/
char palabra[30],palabr[30];
struct programa{struct inicio *inicio1; struct sentencias *sen1; struct fin *fin1;};
struct inicio{struct programa *anterior1;};
struct sentencias{struct sentencias *siguiente1; struct instrucciones *ins_sig; struct se
ntencias *anterior2; struct programa *raiz;};
struct instrucciones{struct escribe *esc; struct lee *lee; struct mientras *min; struct si *
si; struct sentencias *sent;};
struct escribe{struct instrucciones *anterior3;};
struct lee{struct instrucciones *anterior4;};
struct mientras{struct instrucciones *anterior5;};
struct si{struct instrucciones *anterior6;};
struct fin{struct programa *anterior7;};
struct
struct
struct
struct
struct
struct
struct
struct
struct

programa *nodo_raiz=NULL;
inicio *i=NULL;
sentencias *sent=NULL;
instrucciones *inst=NULL;
escribe *escb=NULL;
lee *le=NULL;
mientras *mi=NULL;
si *s=NULL;
fin *f=NULL;

int ins_sen(char palabra[50])

void
void

void

void

void

void

{if((strcmp(palabra,"escribe"))==0) return 1;
else if((strcmp(palabra,"lee"))==0) return 2;
else if((strcmp(palabra,"mientras"))==0) return 3;
else if((strcmp(palabra,"si"))==0) return 4;
else if((strcmp(palabra,"inicio"))==0) return 5;
else if((strcmp(palabra,"fin"))==0) return 6;
}
mensage(){printf("NO HAY MEMORIA DISPONIBLE"); getch(); exit(1);};
ins_lee()
{if((le=malloc(sizeof(le)))==NULL){mensage();}
le->anterior4=inst;
inst->lee=le;}
ins_mientras()
{if((mi=malloc(sizeof(mi)))==NULL){mensage();}
mi->anterior5=inst;
inst->min=mi;
}
ins_escribe()
{ if((escb=malloc(sizeof(escb)))==NULL){mensage();}
escb->anterior3=inst;
inst->esc=escb;}
ins_si()
{ struct instrucciones *tem=inst;
if((inst=malloc(sizeof(inst)))==NULL){mensage();}
inst->esc=NULL; inst->lee=NULL;
inst->min=NULL; inst->si=NULL;
inst->sent=NULL;
if(!tem)
{ inst->esc=NULL;
inst->min=NULL;
inst->lee=NULL;
inst->si=NULL;
inst->sent=sent;}
else
{ inst->esc=NULL;
inst->min=NULL;
inst->lee=NULL;
inst->si=NULL;
inst->sent=tem; }
}
ins_sentencias()
{ struct sentencias *tmp=sent ;
if((sent=malloc(sizeof(sent)))==NULL){mensage();}
if(!tmp){sent->siguiente1=NULL;
sent->ins_sig=NULL;
sent->anterior2=NULL;
nodo_raiz->sen1=sent;
sent->raiz=nodo_raiz;
}
else
{
sent->ins_sig=NULL;
sent->anterior2=tmp;
sent->siguiente1=NULL;
sent->raiz=NULL;

void
void
void

void

void

}
}
ins_fin()
{ if((f=malloc(sizeof(f)))==NULL){mensage();}
f->anterior7=nodo_raiz; nodo_raiz->fin1=f; }
ins_inicio()
{ if((i=malloc(sizeof(i)))==NULL){mensage();}
nodo_raiz->inicio1=i; i->anterior1=nodo_raiz; }
ins_programa()
{ if((nodo_raiz=malloc(sizeof(nodo_raiz)))==NULL){mensage();}
nodo_raiz->inicio1=NULL; nodo_raiz->sen1=NULL; nodo_raiz->fin1=NULL;
}
memoria(int que)
{ if(que==1){ins_escribe();}
else if(que==2){ins_lee();}
else if(que==3){ins_mientras();}
else if(que==4){ins_si();}
else if(que==5){ins_inicio();}
else if(que==6){ins_fin();}
}
inicialisa(void) { int x; for(x=0;x<=29;x++){ palabra[x]='

TRADUCTOR INGLES
Este pequeo programa es un traductor de ingles a espaol frases completas solo
tienes que recordar que deveras colorarlas sin comas y puntos porque no reconosera la
frace cualquier duda mandar un email a guitarristaloco_gm@hotmail.com espero que
te sirva
#include"stdio.h"
#include"conio.h"
#include"ctype.h"
#include"string.h"
void load(void);
void enter(void);
void marco(int col1,int fil1,int col2,int fil2);
void clear(int col1,int fil1,int col2,int fil2,int color);
char buscado(char palabra[20],int e);
void registro(void);
void menu(void);
void limpiar(void);
struct registro
{
char ingles[20];
char espanol[20];
}traducida;
int x=0,y=0;
main()

{
char texto[','];
char palabra[20];
char caracter;

char TECLA;
int posi=0,pos=0,x=9,s=0,o=0;
textbackground(0);
clrscr();
load();
enter();
clrscr();
menu();
do
{
textcolor(15);
textbackground(0);
gotoxy(40,8);cprintf("MENU");
gotoxy(32,10);cprintf(" REGISTRAR PALABRAS ");
gotoxy(32,11);cprintf(" BAJA DE PALABRA ");
gotoxy(32,12);cprintf(" TRADUCIR TEXTOS ");
if(x==10)
{
textcolor(14);
textbackground(4);
gotoxy(32,10);cprintf(" registrar palabras ");
}
if(x==11)
{
textcolor(14);
textbackground(4);
gotoxy(32,11);cprintf(" baja de palabra ");
}
if(x==12)
{
textcolor(14);
textbackground(4);
gotoxy(32,12);cprintf(" traducir textos ");
}
gotoxy(32,x);
TECLA=getch();
if(TECLA=='H')
{
if(x>10)
x--;
else
x=12;
}
if(TECLA=='P')
{
if(x<12)
x++;
else
x=10;
}
if(x==10)
{
textbackground(1);

gotoxy(32,10);cprintf(" REGISTRAR PALABRAS ");


}
if(TECLA==13 && x==12)
{
posi=0;
clear(2,2,78,23,0);
marco(2,2,78,11);
marco(2,13,78,23);
marco(3,4,77,10);
marco(3,15,77,22);
gotoxy(39,3);printf("INGLES");
gotoxy(39,14);printf("ESPAOL");
gotoxy(5,5);
gets(texto);
strupr(texto);
o=strlen(texto);
while(posi<=o)
{
caracter=texto[posi];
if(caracter==NULL || caracter==' ')
{
buscado(palabra,pos);
for(s=0;s<=20;s++){palabra[s]='';}
pos=0;
}
else
{
palabra[pos]=caracter;
pos++;
}
posi++;
}
getch();
caracter='a';
clear(2,2,78,23,0);
menu();
pos=0;
y=0;
}
if(TECLA==13 && x==10)
{
clear(2,2,78,23,0);
marco(2,2,78,4);
marco(2,6,78,23);
gotoxy(32,3);cprintf("REGISTRO DE PLALABRAS");
marco(5,10,24,12);
marco(25,10,54,12);
marco(5,13,24,15);
marco(25,13,54,15);
gotoxy(6,11);cprintf("PALABRA EN INGLES");
gotoxy(6,14);cprintf("PALABRA EN ESPAOL");
limpiar();
gotoxy(26,11);gets(traducida.ingles);
gotoxy(26,14);gets(traducida.espanol);
strupr(traducida.ingles);

strupr(traducida.espanol);
registro();
getch();
clear(2,2,78,23,0);
menu();
}
}while(TECLA!=27);

}
void limpiar(void){int x; for(x=0;x<=19;x++){traducida.ingles[x]=''; traducida.espanol
[x]='';}}
void menu(void)
{
textbackground(0);
textmode(3);
marco(1,1,80,24);
marco(2,2,78,22);
marco(31,9,52,13);
marco(30,7,53,14);
}
void registro(void)
{
FILE *archivo;
if((archivo=fopen("C:Diccionario.txt","a+"))==NULL)
{
clear(1,1,80,24,0);
gotoxy(26,12);printf("ERROR EL ARCHIVO NO EXISTE");
getch();
exit(0);
}
fwrite(&traducida,sizeof(traducida),1,archivo);
fclose(archivo);
}
char buscado(char palabra[20],int e)
{
FILE *archivo;
int trad=0,m=0,dimencion=0;
if((archivo=fopen("C:Diccionario.txt","r"))==NULL)
{
clear(1,1,80,24,0);
gotoxy(26,12);printf("ERROR EL ARCHIVO NO EXISTE");
getch();
exit(0);
}
rewind(archivo);
while(!(feof(archivo)))
{
fread(&traducida,sizeof(traducida),1,archivo);
m=strlen(traducida.ingles);
if(e<=3)
{
if(palabra[0]==traducida.ingles[0] && palabra[1]==traducida.ingle
s[1] &&
palabra[2]==traducida.ingles[2])
{
trad=1;

break;
}
}
else
if(stricmp(palabra,traducida.ingles)==0)
{
trad=1;
break;
}

}
fclose(archivo);
if(trad==0)
{
for(m=0;m<e;m++)
{
gotoxy(5+m+y,16);
printf("%c",palabra[m]);
}
}
else
{
dimencion=strlen(traducida.espanol);
gotoxy(5+y,16);printf("%s ",traducida.espanol);
y+=dimencion-4;
}
y=y+e+2+dimencion;
fclose(archivo);
}
void clear(int col1,int fil1,int col2,int fil2,int color)
{
int x,y;
textbackground(color);
for(x=col1;x<=col2;x++)
for(y=fil1;y<=fil2;y++)
{
gotoxy(x,y);
cprintf(" ");
}
}
void marco(int col1,int fil1,int col2,int fil2)
{
int x;
textbackground(0);
textcolor(15);
for(x=col1;x<col2;x++){gotoxy(x,fil1);cprintf("%c",205);
gotoxy(x,fil2);cprintf("%c",205);}
for(x=fil1;x<=fil2;x++){gotoxy(col1,x);cprintf("%c",179);
gotoxy(col2,x);cprintf("%c",179);}
gotoxy(col1,fil1);cprintf("%c",213);gotoxy(col2,fil1);cprintf("%c",184);
gotoxy(col1,fil2);cprintf("%c",212);gotoxy(col2,fil2);cprintf("%c",190);
}
void enter(void)
{
int x=1;

clrscr();
while(!kbhit())
{
textmode(0);
textcolor(x);
gotoxy(3,24);
cprintf("PRESIONA CUALQUIER TECLA PARA INICIAR");
delay(2500);
if(x<=15)
{
x++;
}
else
{
x=1;
}
}
}
void load(void)
{
int x,por;
textcolor(15);
gotoxy(37,11);
cprintf("CARGANDO");
marco(24,10,57,15);
for(x=1;x<=30;x++)
{
textcolor(1);
gotoxy(25+x,12);
cprintf("%c",178,178);
}
for(x=1;x<=30;x++)
{
textcolor(15);
gotoxy(25+x,12);
cprintf("%c",178,178);
por=(x/3)*10;
gotoxy(39,13);textcolor(15);cprintf("%d%",por);
delay(100000);
}
}

//Codigo fuente: Signos


del zodiaco
03

#include <iostream>

0
4

using namespace
std;

0
5

int main()

6
0
7

int mes,
dia;
cout<<"\t\t\tSIGNO ZODIACAL"<<endl;

0
8
0
9

cout<<"(1)Enero \t(2)Febrero \t(3)Marzo


\t(4)Abril"<<endl;
cout<<"(5)Mayo \t(6)Junio

1
0

\t(7)Julio \t(8)Agosto"<<endl;

1
1

cout<<"(9)Septiembre \t(10)Octubre \t(11)Noviembre


\t(12)Diciembre"<<endl<<endl;

1
2

cout<<"Ingrese la fecha de su
cumplea"<<char(164)<<"o (dia y mes)"<<endl;
cin>>dia>>mes;

1
3
1
4
1
5

switch(mes
)
{

1
6

/*enero*/
case 1:if(dia<21)
cout<<"Capricornio"<<endl;

1
7

else
cout<<"Acuario"<<endl;break;

1
8
1
9

/*febrero*/
case 2:if(dia<21)
cout<<"Acuario"<<endl;

2
0

else
cout<<"Piscis"<<endl;break;

2
1
2
2

/*marzo*/
case 3:if(dia<21)
cout<<"Piscis"<<endl;

2
3

else
cout<<"Aries"<<endl;break;

2
4
2
5

/*abril*/
case 4:if(dia<21)
cout<<"Aries"<<endl;

2
6

else
cout<<"Tauro"<<endl;break;

2
7
2
8

/*mayo*/
case 5:if(dia<22)
cout<<"Tauro"<<endl;

2
9

else
cout<<"Geminis"<<endl;break;

3
0
3
1

/*junio*/
case 6:if(dia<22)
cout<<"Geminis"<<endl;

3
2

else
cout<<"Cancer"<<endl;break;

3
3
3
4

/*julio*/
case 7:if(dia<23)
cout<<"Cancer"<<endl;

3
5

else
cout<<"Leo"<<endl;break;

3
6
3
7

/*agosto*/
case 8:if(dia<23)
cout<<"Leo"<<endl;

3
8

else
cout<<"Virgo"<<endl;break;

3
9
4
0

/*septiembre*/ case 9:if(dia<24)


cout<<"Virgo"<<endl;

4
1

else
cout<<"Libra"<<endl;break;

4
2
4
3

/*octubre*/
case
10:if(dia<25)cout<<"Libra"<<endl;

4
4

else
cout<<"Escorpio"<<endl;break;

4
5
4
6

/*noviembre*/ case
11:if(dia<23)cout<<"Escorpio"<<endl;

4
7

else
cout<<"Sagitario"<<endl;break;

4
8
4
9

/*diciembre*/ case
12:if(dia<22)cout<<"Sagitario"<<endl;

5
0

else
cout<<"Capricornio"<<endl;break;

5
1
5
2

default:cout<<"INGRESE UNA FECHA


VALIDA"<<endl;
}

5
3
5
4

cin.ignore();return
0;

5
5

CONVERSOR DE UNIDADES
Convierte un nmero de una base a otra, por ejemplo de binario (base 2) a decimal
(base 10). Permite cualquier combinacin.
/*
** BASCNVRT.C - Convert between number bases
**
** public domain demo by Bob Stout
*/
#define TEST
#include <stdlib.h>

#ifdef TEST
#include <stdio.h>
#endif
/*
** Calling parameters: 1 - Number string to be converted
**
2 - Buffer for the converted output
**
3 - Radix (base) of the input
**
4 - Radix of the output
**
** Returns: Pointer to converted output
*/
char *base_convert(const char *in, char *out, int rin, int rout)
{
long n;
char *dummy;
n = strtol(in, &dummy, rin);
return itoa(n, out, rout);
}
#ifdef TEST
int main(int argc, char *argv[])
{
int rin, rout;
char buf[40];
if (4 > argc)
{
puts("Usage: BASCNVRT <number> <base_in> <base_out>");
return(-1);
}
rin = atoi(argv[2]);
rout = atoi(argv[3]);
printf("%s (base %d) = %s (base %d)n", argv[1], rin,
base_convert((const char *)argv[1], buf, rin, rout), rout);
return 0;

#endif
//Cdigo Fuente: Calcula el salario de
un trabajador.
03

#include<iostream>

0
4

#include<string>

0
5

using namespace
std;

0
6

int main()

0
7

{
string apno;

0
8
0
9

float
hrtr,tahr,subt,boni,tota;

1
0

cout<<"Calculos de
pagos\n\n";

1
1

cout<<"Nombres:\t";cin>
>apno;

1
2

cout<<endl<<endl<<"Horas
Trabajadas:\t";cin>>hrtr;
if (hrtr<=0)

1
3
1
4

cout<<"No trabajo
nada"<<endl;else

1
5

{cout<<"Tarifa por
hora:\t";cin>>tahr;

1
6

subt=hrtr*ta
hr;
if(hrtr>192)

1
7
1
8

05;

boni=subt*0.

else

1
9

boni=subt*0.

2
0

03;

2
1

2
2

cout<<"El sub total


es:\t"<<subt<<endl;

2
3

cout<<"La bonifiacion
es:\t"<<boni<<endl;

tota=subt+boni

2
4

cout<<"El total a pagar


es:\t"<<tota<<endl<<endl;

2
5

}cin.ignore(); return 0;

2
6

SEMAFORO
este programa sirve para simular un semaforo de dos carriles
#include <stdio.h>
#include <time.h>
//funcion
int cambiarColor( int );
main( )
{

int tiempoSimulacion, tiempo;

int semaforo1 = 0, semaforo2 = 1;


bool entraPrimerVez = true;
time_t comienzo, actual;
//Se introduce el tiempo durante el cual se va a ejecutar la simulacion
//Y tambien el tiempo en el que queremos que cambie el color del semaforo
printf( "Introduzca el tiempo en segundos en el que se va a realizar la simulaci
onn" );
scanf( "%d", &tiempoSimulacion );
printf( "Introduzca el tiempo en segundos del cambio del color de los semafor
osn" );
scanf( "%d", &tiempo );
comienzo = time( NULL );
do
{
actual = time( NULL );
//Entra al cuerpo del if cada que haya transcurrido el tiempo de cambio ingresadopor el
usuario
if( int( difftime(actual, comienzo) ) % tiempo == 0 && entraPrimerVe
z)
{
entraPrimerVez = false;
semaforo1 = cambiarColor( semaforo1 );
semaforo2 = cambiarColor( semaforo2 );
if( semaforo1 == 1 )
{
printf( "El semaforo 1 esta en Verde y el semaforo
2 en Rojonn" );

}
else
{

printf( "El semaforo 1 esta en Rojo y el semaforo 2

en Verdenn" );

}
}
if( int( difftime(actual, comienzo) ) % tiempo > 0 )
{
entraPrimerVez = true;
}
}
while( int( difftime(actual, comienzo) ) < tiempoSimulacion );
return 0;
}
int cambiarColor( int semaforo )
{
//Si el valor del semaforo_1 es 1 es porque este semaforo este en verde, lo qu
e indica que este pasa a rojo
//y el semaforo_2 pasaria a verde, de lo contrario se invertiria el color segun lo
explicado anteriormente
if( semaforo == 1 )
{
semaforo = 0;
}
else
{
semaforo = 1;
}
return semaforo;
}
ECUACIONES DE SEGUNDO GRADO
/*Este programa resuelve ecuaciones de segundo grado usando
una funcin denominada ecuacionator*/
#include <stdio.h>
#include <math.h>
float discrim; /*El discriminante es el nmero que queda dentro de la raz*/
/*La funcin ecuacionator devuelve 0 si la ecuacin no tiene solucin*/
float ecuacionator(float a, float b, float c)
{
discrim=((b*b)-(4*a*c));
if (discrim<=0) return 0;
else return discrim;
}
int main ()
{
float a=0, b=0, c=0;
printf("Vamos a resolver una ecuacin del tipo ax+bx+c=0n");
printf("nIntroduce el valor de a: ");
scanf("%f", &a);
printf("nIntroduce el valor de b: ");

scanf("%f", &b);
printf("nIntroduce el valor de c: ");
scanf("%f", &c);
if (ecuacionator(a, b, c)==0)
printf("La ecuacin no tiene solucin");
if (ecuacionator(a, b, c)!=0)
{
float num1, num2;
float den;
float solucion1, solucion2;

/*Los dos numeradores*/


/*El denominador*/
/*Las 2 soluciones*/

num1= (-b + sqrt(discrim));


num2= (-b - sqrt(discrim));
den=2*a;
solucion1=num1/den;
solucion2=num2/den;
printf("nLa primera solucin es %f", solucion1);
printf("nLa segunda solucion es %f", solucion2);
printf("n");
}
return 0;
}
//CONVIERTE DECIMALES EN NUMEROS ROMANOS
#include<iostream>
using namespace std;
int main()
{
int x;
cout<<"ingrese un numero"<<endl;
cin>>x;
if((x<1)||(x>999))
cout<<"Ingrese un numero entre 0-999"<<endl;
else
{
if(x>=900)

{cout<<"CM"

;x=x-900; }

if(x>=500)

{cout<<"D"

;x=x-500; }

if(x>=400)

{cout<<"CD"

;x=x-400; }

if(x>=300)

{cout<<"C"

;x=x-100; }

if(x>=200)

{cout<<"C"

;x=x-100; }

if(x>=100)

{cout<<"C"

;x=x-100; }

if(x>=90)

{cout<<"XC"

;x=x-90; }

if(x>=50)

{cout<<"L"

;x=x-50; }

if(x>=40)

{cout<<"XL"

;x=x-40; }

if(x>=30)

{cout<<"X"

;x=x-10; }

if(x>=20)

{cout<<"X"

;x=x-10; }

if(x>=10)

{cout<<"X"

;x=x-10; }

if(x>=9) {cout<<"IX"

;x=x-9;

if(x>=5) {cout<<"V"

;x=x-5;

if(x>=4) {cout<<"IV"

;x=x-4;

if(x>=3) {cout<<"III";x=x-3;

if(x>=2) {cout<<"II"

;x=x-2;

if(x>=1) {cout<<"I"

;x=x-1;

}
cout<<endl;
cin.ignore();return 0;
}

COMO REALIZAR UN MENU


//Codigo fuente: Mostrar un men
con 6 opciones.
#include<iostream>

03
0
4

using namespace
std;

0
5

int main()

0
6

0
7

int m;

0
8

cout<<"\t\t\tElija una opcion\n\n";

0
9

//con '\t\t\t' llevo un poco al centro el mensaje, y con '\n\n' salto


2 lineas hacia abajo.

1
0

cout<<"1
Ingresos\n";

cout<<"2

Modificacion\n";

1
2

cout<<"3
Consultas\n";

1
3

cout<<"4
Reportes\n";

1
4

cout<<"5
Utilidades\n";

1
5

cout<<"6
Salir\n\n";
cin>>m;

1
6
1
7
1
8

switch(m)

1
9

2
0

case 1:cout<<"Ud tiene S/.


2500"<<endl;break;

2
1

case 2:cout<<"Que desea


modificar?"<<endl;break;

2
2

case 3:cout<<"Escriba su consulta aqui:


"<<endl;break;

2
3

case 4:cout<<"Ud. no presenta


reportes"<<endl;break;

2
4

case 5:cout<<"Este servicio esta bloqueado por el


momento"<<endl;break;

2
5

case 6:cout<<"Ya esta fuera"<<endl;break;

2
6

default: cout<<"El valor ingresado no esta en el


menu"<<endl;

2
7

2
8

cin.ignore();
return 0;

2
9