Presentación

Hola me llamo IRWIN ALBERTO VITERI RAMBAY, soy de Guayaquil – Ecuador, tengo 19 años y estudio en la ESPOL actualmente estoy  cursando el 4 semestre en la carrera de Electrónica y Telecomunicaciones.

Y LES INVITO A QUE VISITEN MI BLOG…


Este blog es dedicado para poder prácticar programar en lenguaje C, para a fines de FUNDAMENTOS DE PROGRAMACIÓN, materia que se ve en la ESPOL…

FUNDAMENTOS DE PROGRAMACIÓN

Fundamentos de Programación

Si desea ver un libro que nos ayude a entender  busque entre los enlaces.

▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼

¿Qué es un compilador?
Un traductor es cualquier programa que toma como entrada un texto escrito en un lenguaje, llamado fuente y da como salida otro texto en un lenguaje, denominado objeto.

En el caso de que el lenguaje fuente sea un lenguaje de programación de alto nivel y el objeto sea un lenguaje de bajo nivel (ensamblador o código de máquina), a dicho traductor se le denomina compilador. Un ensamblador es un compilador cuyo lenguaje fuente es el lenguaje ensamblador. Un intérprete no genera un programa equivalente, sino que toma una sentencia del programa fuente en un lenguaje de alto nivel y la traduce al código equivalente y al mismo tiempo lo ejecuta. Históricamente, con la escasez de memoria de los primeros ordenadores, se puso de moda el uso de intérpretes frente a los compiladores, pues el programa fuente sin traducir y el intérprete juntos daban una ocupación de memoria menor que la resultante de los compiladores. Por ello los primeros ordenadores personales iban siempre acompañados de un intérprete de BASIC (Spectrum, Commodore VIC-20, PC XT de IBM, etc.). La mejor información sobre los errores por parte del compilador así como una mayor velocidad de ejecución del código resultante hizo que poco a poco se impusieran los compiladores. Hoy en día, y con el problema de la memoria prácticamente resuelto, se puede hablar de un gran predominio de los compiladores frente a los intérpretes, aunque intérpretes como los incluidos en los navegadores de Internet para interpretar el código JVM de Java son la gran excepción.
Ventajas de compilar frente a interpretar:

  • Se compila una vez, se ejecuta n veces.
  • En bucles, la compilación genera código equivalente al bucle, pero interpretándolo se traduce tantas veces una línea como veces se repite el bucle.
  • El compilador tiene una visión global del programa, por lo que la información de mensajes de error es mas detallada.
  • Ventajas del intérprete frente al compilador:
  • Un intérprete necesita menos memoria que un compilador. En principio eran más abundantes dado que los ordenadores tenían poca memoria.
  • Permiten una mayor interactividad con el código en tiempo de desarrollo.

Un compilador no es un programa que funciona de manera aislada, sino que necesita de otros programas para conseguir su objetivo: obtener un programa ejecutable a partir de un programa fuente en un lenguaje de alto nivel. Algunos de esos programas son el preprocesador, el linker, el depurador y el ensamblador. El preprocesador se ocupa (dependiendo del lenguaje) de incluir ficheros, expandir macros, eliminar comentarios, y otras tareas similares. El linker se encarga de construir el fichero ejecutable añadiendo al fichero objeto generado por el compilador las cabeceras necesarias y las funciones de librería utilizadas por el programa fuente. El depurador permite, si el compilador ha generado adecuadamente el programa objeto, seguir paso a paso la ejecución de un programa. Finalmente, muchos compiladores, en vez de generar código objeto, generan un programa en lenguaje ensamblador que debe después convertirse en un ejecutable mediante un programa ensamblador.

►►►►PARA PODER TRABAJAR ES NECESARIO EL COPILADOR◄◄◄◄

↑↑↑↑  BUSCA ENTRE LOS ENLACES EL VISUAL STUDIO 2010 ↑↑↑↑

Ejercicios en C

/*

* Archivo: antifactorial.c

* DESCRIPCIÓN: El programa debe perdirle al usuario que ingrese

* un número, y se debe mostrar de ser posible, su antifactorial.

* Ejemplo: 120 –> antifactorial: 5

*/

#include <stdio.h>

void main(void)

{

int num,fac=1,cont=0;

do{

printf(«Ingrese un n%cmero: «,163);

scanf(«%d», &num);

}while(num<0);//Ingrese un numero positvo

while(fac<num)

{

cont++;

fac=fac*cont;

}

if(fac==num)

{

if(fac==1)

printf(«EL antifactorial de 1 puede ser 1 o 0»);

else

printf(«El antifactorial de %d es: %d»,num,cont);

}

else

printf(«No existe el antifactorial de %d»,num);

getch();

}

___________________________________________________________

——————————————————————————————————————

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©

/*

* Archivo: busqueda_de_digitos.c

* Descripción:  Programa que pide un numero positivo por teclado, y

* luego pide un digito a buscar en el numero…

* Finalmente imprime el numero de veces que el digito se repite en el numero

*/

#include<stdio.h>

void main()

{

int num,cont=0,dig,dig_num;//Declaracion de variables

do{

system(«cls»);//Limpia la pantalla

printf(«Ingrese un numero positivo por favor: «);

scanf(«%d»,&num);

}while(num<0);//El lazo continua mientras el numero ingresado sea negativo

do{

system(«cls»);

printf(«Ahora ingrese un digito a buscar en el numero %d: «,num);

scanf(«%d»,&dig);

}while(dig<0 || dig>9);//Validamos que sea un solo digito entre (0 y 9)

while(num>0)

{

dig_num=num%10;//Obtenemos el digito

if(dig_num==dig)//Condicion para ver si el digito del numero es igual al ingresado

cont++; //vamos a contar los digitos que coinciden

num=num/10;//Disminuimos el numero

}

printf(«\n\nEl digito %d se repite %d veces en el numero»,dig,cont);

getch();

}

___________________________________________________________

——————————————————————————————————————

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©

/*

* Archivo: cifras_dig.c

* Descripcion: Hacer un Programa que pida al usuario ingresar un numero, luego dividirlo

* dicho numero en sus cifras,presentar cada una de las cifras.

*/

#include <stdio.h>

void main()

{

int num,cifra;

printf(«Ingrese un Numero:»);

scanf(«%d»,&num);

while(num>0)//mientras el numero sea distinto de cero seguirá el ciclo.

{

cifra=num%10;//Obtenemos el modulo del numero que será la cifra

num=num/10;//Al dividir el numero para diez y igualarlo al mismo numero, tenemos ese numero sin la ultima cifra.

printf(«%d\n»,cifra);

}

getch();

}

___________________________________________________________

——————————————————————————————————————

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©

/*

* Archivo: Conjetura_Ullman

* Descripción: Escriba un programa en C, tal que dado un valor “n” entero positivo,calcule

y muestre la correspondiente conjetura de Ullman, que consiste en lo siguiente:

a) Empiece con cualquier entero positivo

b) Si es par, dividalo para 2

c) Si es impar, multipliquelo por  3 y agreguele 1

d) Obtenga enteros sucesivamente repitiendo el proceso.

Al final se debe obtener el numero 1, independientemente del entero inicial.

*/

#include <stdio.h>

#include <conio.h>

void main()

{

int numero;

printf(«Ingrese un numero entero positivo:\n»);scanf(«%d», &numero);

printf(«Su conjetura de Ullman es:\n»);

do

{

if((numero%2)==0)

{

numero=numero/2;

printf(«\t\t\t\t%d\n», numero);

}

else

{

numero=(numero*3)+1;

printf(«\t\t\t\t%d\n», numero);

}

}while(numero>1);

getch();

}

___________________________________________________________

——————————————————————————————————————

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©

/*

* Archivo: Guerra_barcos.c

* Descripcion:Programa en c que simula una Guerra de Barcos:

Supongamos que estamos en un barco lejano y tenemos 7 balas de mucho alcance

Significa  que tenemos 7 oportunidades  para  dispararle a 7 barcos enemigos

Estos van   a estar moviendose en  20 espacios que  tiene el mar, el usuario

decide a que  espacio (del 1-20) disparar y si yo  logro hundir a 4 de los 7

barcos, entonces  he ganado la Guerra  de Barcos, caso contrario, ha perdido

*/

#include<stdio.h>

#include<stdlib.h>

#include<time.h>

#define BARCO 7

#define MAX 20

void Arreglo_Inicializar(int A[],int tam);

void Colocar_Barcos(int A[],int tam,int n_barc);

void Mover_Barcos(int A[],int tam);

void main()

{

int i,balas=0,tiros_acertados=0;

int Mar[MAX];

srand(time(NULL));

printf(«Bienvenido a la consola Guerra de Barcos\n»);

Arreglo_Inicializar(Mar,MAX);

Colocar_Barcos(Mar,MAX,BARCO);

while(balas<7)

{

do{

printf(«Oportunidad %d de 7!!\nEspacio de Mar a disparar:»,balas+1);

scanf(«%d»,&i);

if(i<1 || i>MAX)

printf(«Espacio de mar incorrecto, debe escoger del 1-20\n»);

}while(i<1 || i>MAX);

if(Mar[i-1]==BARCO)

{

Mar[i-1]=0;

tiros_acertados++;

printf(«\nFelicidades!! Le has dado a %d\n»,tiros_acertados);

}

balas++;

Mover_Barcos(Mar,MAX);

}

if(tiros_acertados>3)

printf(«\nFelicidades, usted ha ganado la Guerra hundiendo %d Barcos!!»,tiros_acertados);

else

printf(«\nLastima, no ganaste la Guerra, %d Barcos hundidos,\nPero animate a jugar otra vez!!»,tiros_acertados);

getch();

}

void Arreglo_Inicializar(int A[],int tam)

{

int i;

for(i=0;i<tam;i++)

A[i]=0;

}

void Colocar_Barcos(int A[],int tam,int n_barc)

{

int i;

for(i=0;i<n_barc;i++)

A[rand()%tam]=BARCO;

}

void Mover_Barcos(int A[],int tam)

{

int tmp,i,r,o;

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

{

r=rand()%tam;

o=rand()%tam;

tmp=A[r];

A[r]=A[o];

A[o]=tmp;

}

}

___________________________________________________________

——————————————————————————————————————

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©

/* Archivo: carrera_caballos.c

* Descripcion :-  Escriba un programa que implemente el juego “Carrera de caballos”.

* El programa debe utilizar el procedimiento llenarPista, mostrar el caballo ganador

* y el número de turnos jugados

*/

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

#include <conio.h>

#define MAX 50

void llenar_pista(int pista[], int tam);

void main()

{

int avance,posicion1=0,caballo1=0,posicion2=0,caballo2=0;

int pista[MAX];

srand(time(NULL));

llenar_pista(pista,MAX);

do{

avance=1+rand()%5;

printf(«\nLa posicion inicial del caballo 1 es:%d\n», posicion1);

posicion1=posicion1+avance;

printf(«La posicion final del caballo 1 es:%d\n», posicion1);

if((pista[posicion1-1])==-1)

{

posicion1=posicion1-3;

printf(«Ha caido en un obstaculo retroceda 3 casillas\n»);

if(posicion1<0)

posicion1=0;

printf(«Su nueva posicion final es:%d\n», posicion1);

}

else

if(pista[posicion1-1]==1)

{

posicion1=posicion1+2;

printf(«Ha caido en un premio avance 2 casillas\n»);

printf(«Su nueva posicion final es:%d\n», posicion1);

}

caballo1=caballo1+1;

if(posicion1==posicion2&&caballo1>caballo2)

{

posicion1=posicion1-1;

printf(«El caballo 1 ocupa una celda ya ocupada\n»);

printf(«El caballo 1 retrocede una casilla\n»);

printf(«Su nueva posicion final es:%d\n», posicion1);

}

getch();

avance=rand()%5+1;

printf(«\nLa posicion inicial del caballo 2 es:%d\n», posicion2);

posicion2=posicion2+avance;

printf(«La posicion final del caballo 2 es:%d\n», posicion2);

if(pista[posicion2-1]==-1)

{

posicion2=posicion2-3;

printf(«Ha caido en un obstaculo retroceda 3 casillas\n»);

if(posicion2<0)

posicion2=0;

printf(«Su nueva posicion final es:%d\n», posicion2);

}

else

if(pista[posicion2-1]==1)

{

posicion2=posicion2+2;

printf(«Ha caido en un premio avance 2 casillas\n»);

printf(«Su nueva posicion final es:%d\n», posicion2);

}

caballo2=caballo2+1;

if(posicion1==posicion2&&caballo2==caballo1)

{

posicion2=posicion2-1;

printf(«El caballo 2 ocupa una celda ya ocupada\n»);

printf(«El caballo 2 retrocede una casilla\n»);

printf(«Su nueva posicion final es:%d\n», posicion2);

}

getch();

}while(posicion1<=50&&posicion2<=50);

if(posicion1>50&&posicion1>posicion2)

{

printf(«\nEl ganador es el caballo 1\n»);

printf(«Los turnos que se movio fueron:%d\n», caballo1);

}

else

{

printf(«\nEl ganador es el caballo 2\n»);

printf(«Los turnos que se movio fueron:%d\n», caballo2);

}

getch();

}

void llenar_pista(int pista[], int tam)

{

int i, a;

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

{

pista[i]=0;

}

for(i=0;i<2;i++)

{

do{

a=rand()%50;

}while(pista[a]!=0);

pista[a]=1;

}

for(i=0;i<2;i++)

{

do{

a=rand()%50;

}while(pista[a]!=0);

pista[a]=-1;

}

}

___________________________________________________________

——————————————————————————————————————

©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©

Proyecto 1.0

proyecto 1.0

Serpientes y Escaleras

øøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøø

Resolución de proyecto 1.0

/*
* Archivo: Serpientes y escaleras.c
* Autor: Viteri Rambay Irwin
* Fecha de creación: 2010-20-06
* Descripcion:
* Programa utilizado para simular un juego de azar de hasta dos jugadores
* mesa de 15 posiciones, quien llega primero a la posicion 15 gana
* se juega apartir de lanzamiento de dados.
* Modificaciones: 2010-23-06 seleccion de fichas
*/
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#define tamano 15
#define exit 4
/* variable universal, no es afectada por la retroalimentacion del sistema
* asi que no es receteada a menos que el usuario decida cambiar los valores
* con la opción 3 del menú principal*/
int x=1,y=3;
/* prototipos de funciones utilizadas en el programa*/
void nplayer();
int dado();
void tablero();
int verificar_regla1();
int verificar_regla2();
void juego();
void fichas();
void main ()
{
//Declaracion de variables
int player=0;
do
{
system(«cls»);
printf(«\t bienvenido al juego de serpientes y escaleras \n»);
printf(«\t escoja el numero de jugadores \n»);
printf(«\t\t 1.- un Jugador \n»);
printf(«\t\t 2.- dos Jugadores \n»);
printf(«\t\t 3.- fichas de juego \n»);
printf(«\t\t 4.- Salir del Juego \n\t\t»);
scanf(«%d»,&player);
switch (player)
{
case 1: nplayer(player);break;
case 2: nplayer(player);break;
case 3: fichas();break;
case 4: player=exit; break;
default: main();break;
}
}while(player!=exit);
}/*menú principal que nos permite entrar o salir del juego */
/*
* Función: nplayer
* Uso: nplayer(player);
* ———————————————————-
* Descripción: esta funcion realiza al azar que jugador lanzará primero o
* si la opcion es de un solo jugador, lo envia a jugar.
*/
void nplayer(int player)
{
//Declaracion de variables
int op=2, pl1=0, pl2=0;
switch(player)
{
case 1:{ pl1=1;
pl2=0;
do
{
system(«cls»);
printf(«\t\t\t\t UN JUGADOR \n»);
tablero();
printf(«\n\t\t1.- iniciar juego\n\n»);
printf(«\t\t2.- regresar al menu principal\n»);
scanf(«%d»,&op);
}while(op<1 || op>2);
if(op==2)
{
return 0;
}
juego(pl1,pl2);
} break;
case 2:{
do
{
system(«cls»);
printf(«\t\t\t\t DOS JUGADORES \n»);
tablero();
printf(«\n\t\t1.- iniciar juego\n\n»);
printf(«\t\t2.- regresar al menu principal\n»);
scanf(«%d»,&op);
}while(op<1 || op>2);
if(op==1)
{
printf(«antes de iniciar el juego decide con tu companero\n»);
printf(«que numero de jugador eres 1 o 2 \n»);
getch ();
printf(«sortear turno\n»);
do
{
pl1=dado();
pl2=dado();
}while(pl1==pl2);
if(pl1<pl2)
{
printf(«el jugador 2 lanza primero \n»);
pl1=2;
pl2=1;
}
else
{
printf(«el jugador 1 lanza primero \n»);
pl1=1;
pl2=2;
}
getch();
}
else
{
return 0;
}
juego(pl1,pl2);
}break;
}
}
/*
* Función: dado
* Uso: simulasion de lanzamiento de dado
* ———————————————————-
* Descripción: retorna un número al azar entre 1 – 6.
*/
int dado()
{
//Declaracion de variables
int w;
srand(time(NULL));
w=rand()%6+1;
return w;
}/*funcion que nos simula el lanzamiento de un dado*/
/*
* Función: tablero
* Uso: tablero(posicion1,posicion2,avance1,avance2);
* ———————————————————-
* Descripción: genera una imagen del tablero y mueve la ficha segun
* la posicion de esta.
*/
void tablero(int posicion1,int posicion2, int avance1, int avance2)
{
//Declaracion de variables
int i, j;
char A[tamano]={0},B[tamano]={0};
printf(«=============================================================================\n»);
printf(«||»);
//trabajando avance de ficha de juagador 1
for(i=1;i<=tamano;i++)
{
if(i==avance1+posicion1)
{
A[i-1]=x;
printf(«%c ||»,A[i-1]);
}
else
printf(» ||»);
}
printf(«\n||»);
//trabajando avance de ficha de juagador 2
for(j=1;j<=tamano;j++)
{
if(j==avance2+posicion2)
{
B[j-1]=y;
printf(«%c ||»,B[j-1]);
}
else
printf(» ||»);
}
printf(«\n»);
printf(«|| || || || || || || || || || || || || || || ||\n»);
printf(«|| || 0000Serpiente000 || || || || 0000Serpiente000 || || || ||\n»);
printf(«|| || || || || || || || || || || || || || || ||\n»);
printf(«||Str|| || ####escalera#### || || ##escalera# || || || || ||FIN||\n»);
printf(«=============================================================================\n»);
printf(«|| 1 || 2 || 3 || 4 || 5 || 6 || 7 || 8 || 9 || 10|| 11|| 12|| 13|| 14|| 15||\n»);
printf(«=============================================================================\n»);
}/*simula la mesa de juego sobre la cual se realizan las juegadas*/
/*
* Función: verificar regla1
* Uso: verificar_regla(posicion1,avance1);
* ———————————————————-
* Descripción: verifica si el jugador1 esta respetando las
* reglas del juego.
*/
int verificar_regla1(int posicion1, int avance1)
{
switch(posicion1+avance1)
{
case 3: printf(«usted ha caido en una escalera, avanza 3 espacios \n»); return 3; break;
case 5: printf(«usted ha caido en una serpiente, retrocede 3 espacios \n»);return (-3); break;
case 8: printf(«usted ha caido en una escalera, avanza 2 espacios \n»);return 2; break;
case 12: printf(«usted ha caido en una Serpiente, retrocede 3 espacios \n»);return (-3); break;
default: return 0; break;
}
}/*verifica que el jugador 1 respete las reglas de serpientes y escaleras*/
/*
* Función: verificar regla2
* Uso: verificar_regla(posicion2,avance2);
* ———————————————————-
* Descripción: verifica si el jugador2 esta respetando las
* reglas del juego.
*/
int verificar_regla2(int posicion2, int avance2)
{
switch(posicion2+avance2)
{
case 3: printf(«usted ha caido en una escalera, avanza 3 espacios \n»); return 3; break;
case 5: printf(«usted ha caido en una serpiente, retrocede 3 espacios \n»);return (-3); break;
case 8: printf(«usted ha caido en una escalera, avanza 2 espacios \n»);return 2; break;
case 12: printf(«usted ha caido en una Serpiente, retrocede 3 espacios \n»);return (-3); break;
default: return 0; break;
}
}/*verifica que el jugador 2 respete las reglas de serpientes y escaleras*/
/*
* Función: juego
* Uso: juego(pl1,pl2);
* ———————————————————-
* Descripción: realiza los cambio de avance de las fichas en
* el tablero.
*/
void juego(int pl1, int pl2)
{
//Declaracion de variables
int cont=1, avance1=0, avance2=0, posicion1=1,posicion2=1, p, v1=0, v2=0;
do
{
if(cont==pl1)
{
system(«cls»);
tablero(posicion1,posicion2,avance1,avance2);
printf(«lanzar dado jugador 1\n»);
getch ();
p=dado();
system(«cls»);
tablero(posicion1,posicion2,avance1,avance2);
printf(«avanza %d espacios»,p);
getch();
avance1=p;
system(«cls»);
tablero(posicion1,posicion2,avance1,avance2);
v1=verificar_regla1(posicion1,avance1);
getch();
if(v1!=0)
{
avance1=avance1+v1;
system(«cls»);
tablero(posicion1,posicion2,avance1,avance2);
getch();
}
posicion1=posicion1+avance1;
avance1=0;
pl1=pl1+2;
cont++;
}
if(cont==pl2 && posicion1<tamano)
{
system(«cls»);
tablero(posicion1,posicion2,avance1,avance2);
printf(«lanzar dado jugador 2\n»);
getch ();
p=dado();
system(«cls»);
tablero(posicion1,posicion2,avance1,avance2);
printf(«avanza %d espacios»,p);
getch();
avance2=p;
system(«cls»);
tablero(posicion1,posicion2,avance1,avance2);
v2=verificar_regla2(posicion2,avance2);
getch();
if(v2!=0)
{
avance2=avance2+v2;
system(«cls»);
tablero(posicion1,posicion2,avance1,avance2);
getch();
}
posicion2=posicion2+avance2;
avance2=0;
pl2=pl2+2;
cont++;
}
else
pl1=pl1-1;
}while(posicion1<tamano && posicion2<tamano);
if(posicion1>=tamano)
printf(«el jugador 1 es el ganador \n»);
if(posicion2>=tamano)
printf(«el jugador 2 es el ganador \n»);
getch();
}/*realiza todos los procesos «pasos» del juego respetando el turno establecido*/
/*
* Función: fichas
* Uso: fichas();
* ———————————————————-
* Descripción: esta funcion modifica la imagen de la ficha que
* aparece en el tablero.
*/
void fichas()
{
//Declaracion de variables
int op1, op2;
char a=1, b=2, c=3, d=4, e=5, f=6, g=11, h=12, i=14, j=15;
printf(«elija una ficha \n»);
printf(«\t1.- %c \t2.- %c \t3.- %c \t4.- %c \t5.- %c\n», a, b, c, d, e);
printf(«\t6.- %c \t7.- %c \t8.- %c \t9.- %c \t10.-%c\n», f, g, h, i, j);
printf(«jugador 1 \n»);
scanf(«%d»,&op1);
switch (op1)
{
case 1:x=1;break;
case 2:x=2;break;
case 3:x=3;break;
case 4:x=4;break;
case 5:x=5;break;
case 6:x=6;break;
case 7:x=11;break;
case 8:x=12;break;
case 9:x=14;break;
case 10:x=15;break;
default: printf(«opcion no valida, no habra cambio de ficha \n»);
}
printf(«jugador 2 \n»);
scanf(«%d»,&op2);
switch (op2)
{
case 1:y=1;break;
case 2:y=2;break;
case 3:y=3;break;
case 4:y=4;break;
case 5:y=5;break;
case 6:y=6;break;
case 7:y=11;break;
case 8:y=12;break;
case 9:y=14;break;
case 10:y=15;break;
default: printf(«opcion no valida, no habra cambio de ficha \n»);
}
getch();
}

Proyecto 2.0

Proyecto 2.0

Serpientes y Escaleras

☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼

Resolución al proyecto 2.0
/*
* Archivo:Proyectoo 2.0.c
* Autor: Viteri Rambay Irwin
* Fecha de creación: 2010-08-20
* Descripción:
* Juego mejorado de serpientes y escaleras
* mucho mejor que la versión 1.0
*/
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
typedef struct{
int avance;
int veces;
char nombre[11];
}JugadorT;
typedef struct{
int comodines[5][10];
char matriz[5][10];
}TableroT;
void colocarFicha(JugadorT gam[], int turno, TableroT *tab, int *fil, int *col);
void analizarCasilla(JugadorT gam[], int turno, TableroT *tab, int *fil, int *col);
void buscarConsecuente(TableroT tab, int num, int *fil, int *col);
void ImprimirMensaje(int num, JugadorT gam[], int turno);
void dibujar_tablero_juego();
int registrarGanador(JugadorT gam[]);
void ordenaTop(JugadorT temp[], int tam);
void guardarPartida(JugadorT gam[], int turno, TableroT tab, FILE *in);
int cargaPartida(JugadorT gam[], int *turno, int *njug);
void menuPrincipal();
void main(){
FILE *sav, *in;
int n=0, k, r, r1, r2, nd, fila=-1, columna=-1, temp, option, p1=0, aux;
char tecla, opt, cadena[30];
JugadorT gamer[2]={0,0};
TableroT table={{{0,0,0,7,0,4,0,11,0,0},
{0,8,2,0,9,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,12},
{1,0,0,0,0,0,0,0,0,0},
{0,0,6,0,10,5,0,3,0,0}}};
srand(time(NULL));
for(n=0;n<5;n++){
for(k=0;k<10;k++)
table.matriz[n][k]=’ ‘;
}
do{
menuPrincipal();
do{
scanf(«%d»,&option);
}while(option>6||option<1);
if(option==4){
printf(«Se procedera a reanudar la partid\n»);
aux=cargaPartida(gamer,&r,&n);
getch();
if(aux!=0){
option=3;
p1=2;
}else
option=6;
}
if(option==1&&p1==0){
printf(«Elija el numero de jugadores (1 o 2): «);
do{
scanf(«%d», &n);
}while(n!=2&&n!=1);
if(n==2){
for(k=0; k<n; k++){
printf(«Ingres el nombre de jugador %d: «, k+1);
fflush(stdin);
gets(gamer[k].nombre);
}
p1=1;
}else{
printf(«Ingres el nombre del jugador: «);
fflush(stdin);
gets(gamer[0].nombre);
r=0;
temp=r;
p1=2;
}
}
if(option==3&&p1==2){
do{
system(«cls»);
dibujar_tablero_juego();
printf(«Turno: %s\n», gamer[r].nombre);
printf(«Presione + para lanzar dado, barra espaciadora para salir o guardar la partida:»);
do{
tecla=getch();
}while(tecla!=’+’&&tecla!=’ ‘);
switch (tecla){
case ‘+’:
if(gamer[r].avance!=0)
printf(«\nEsta en la casilla %d»,gamer[r].avance);
nd=(rand()%6)+1;
gamer[r].avance+=nd;
if(gamer[r].avance>50)
gamer[r].avance=50;
printf(«\nDADO: %d», nd);
colocarFicha(gamer, r, &table, &fila, &columna);
analizarCasilla(gamer, r, &table, &fila, &columna);
getch();
if(n!=1){
temp=r;
r=(r+1)%2;
}
break;
case ‘ ‘:
printf(«Presiones < s > para salir o < g > para guardar: «);
do{
opt=getch();
}while(opt!=’s’&&opt!=’g’);
if(opt==’g’){
printf(«\nSu partida se procedera a guardar…..\n»);
guardarPartida(gamer, r, table, &sav);
printf(«Partida salvada\n»);
opt=’s’;
}else{
sav=fopen(«juegoSyE.ptd»,»w»);
fprintf(sav,»-1″);
fclose(sav);
}
break;
}
}while(gamer[temp].avance<50&&opt!=’s’);
if(opt!=’s’){
gamer[temp].veces=1;
printf(«FELICITACIONES!!!!! < %s > GANO\n»,gamer[temp].nombre);
k=registrarGanador(gamer, temp);
printf(«Se encuentra en el top %d\n», k);
}
option=6;
}
if(option==2&&p1==1){
if(n==2){
do{
printf(«\n< %s > presione + para lanzar dados», gamer[0].nombre);
while(getch()!=’+’);
r1=rand()%6+1;
printf(«\n< %s > presione + para lanzar dados», gamer[1].nombre);
while(getch()!=’+’);
r2=rand()%6+1;
printf(«\n< %s >: %d\n< %s >: %d», gamer[0].nombre, r1, gamer[1].nombre, r2);
if(r1==r2){
printf(«\nLos dados salieron iguales»);
r=-1;
}else{
if(r1>r2)
r=0;
else
r=1;
printf(«\n%s comienza primero», gamer[r].nombre);
}
getch();
}while(r==-1);
p1=2;
}
}
if(option==5){
in=fopen(«top.ptd»,»r»);
if(in==NULL){
printf(«No existe el archivo top 10!!!!!!\n»);
exit(1);
}else{
system(«cls»);
fscanf(in,»%s»,cadena);
printf(» %s\n», cadena);
for(k=0;k<10;k++){
fscanf(in,»%s»,cadena);
fscanf(in,»%d»,&temp);
printf(«%10s %2d\n», cadena, temp);
}
fclose(in);
}
option=6;
}
}while(option!=6);
getch();
}
void colocarFicha(JugadorT gam[], int turno, TableroT *tab, int *fil, int *col){
if(*fil!=-1&&*col!=-1)
tab->matriz[*fil][*col]=’ ‘;
if(gam[turno].avance%10!=0){
*col=(gam[turno].avance%10)-1;
*fil=gam[turno].avance/10;
}else{
*col=9;
*fil=(gam[turno].avance/10)-1;
}
tab->matriz[*fil][*col]=gam[turno].nombre[0];
return;
}
void analizarCasilla(JugadorT gam[], int turno, TableroT *tab, int *fil, int *col){
int aux;
char temp;
aux=tab->comodines[*fil][*col];
temp=tab->matriz[*fil][*col];
ImprimirMensaje(aux, gam, turno);
if((aux%2)!=0){
tab->matriz[*fil][*col]=’ ‘;
buscarConsecuente( *tab, aux, fil, col);
tab->matriz[*fil][*col]=temp;
}
return;
}
void buscarConsecuente(TableroT tab, int num, int *fil, int *col){
int i, j;
for(i=0;i<5;i++){
for(j=0;j<10;j++){
if(tab.comodines[i][j]==(num+1)){
*fil=i;
*col=j;
return;
}
}
}
}
void ImprimirMensaje(int num, JugadorT gam[], int turno){
switch (num){
case 1:
printf(«\nQue pena callo en una serpiente!!! retroceda a la casilla 13\n»);
gam[turno].avance=13;
break;
case 3:
printf(«\nQue pena callo en una serpiente!!! retroceda a la casilla 6\n»);
gam[turno].avance=6;
break;
case 5:
printf(«\nQue pena callo en una serpiente!!! retroceda a la casilla 43\n»);
gam[turno].avance=43;
break;
case 7:
printf(«\nQue suerte callo en una escalera!!! anvanza a la casilla 12\n»);
gam[turno].avance=12;
break;
case 9:
printf(«\nQue suerte callo en una escalera!!! anvanza a la casilla 45\n»);
gam[turno].avance=45;
break;
case 11:
printf(«\nQue suerte callo en una escalera!!! anvanza a la casilla 30\n»);
gam[turno].avance=30;
break;
default:
printf(«\nAnvanza a la casilla %d\n», gam[turno].avance);
break;
}
}
void dibujar_tablero_juego(){
printf(«\n ******Serpientes y Escaleras******\n»);
printf(«ÚÄÄÄÄÄÄÂÄÄÄÄÄÄÂÄÄÄÄÄÄÂÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄ¿\n»);
printf(«³1 ³2 ³3 ³4ÜÜ ³5 ³6 **³7 ³8 Ü ³9 ³10 ³\n»);
printf(«³ ³ ³ ÜÜÜÜÜ ³ ³ ** ³ ÜÜÜ ³ ³\n»);
printf(«ÃÄÄÄÄÄÄÅÄÄÄÄÄÄÜÜÜÜÄÄÄÅÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÅÄ*ÄÄÄÄÄÅÄÄÄÄÄÄÄÅÜÜÜÄÄÄÄÅÄÄÄÄÄÄÄ´\n»);
printf(«³11 ³12 ÜÜܳ13 ³14 ³15ÌÍ͹ ³16 ³17* ³18 ³19 ÜÜ ³20 ³\n»);
printf(«³ ³ ** ³ ³ ÌÍ͹ ³ ³ * ³ ³ ÜÜÜ ³\n»);
printf(«ÃÄÄÄÄÄÄÅÄÄÄÄ*ÄÅÄÄÄÄÄÄÅÄÄÄÄÄÄÄÅÄÄÌÍ͹ÄÅÄÄÄÄÄÄÄÅÄÄÄ*ÄÄÄÅÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÅÜÜÜÄÄÄÄ´\n»);
printf(«³21 ³22 * ³23 ³24 ³25ÌÍ͹ ³26 ³27 * ³28 ³29 ³30 ÜÜ ³\n»);
printf(«³ ³ * ³ ³ ³ ÌÍ͹ ³ ³ * ³ ³ ³ ³\n»);
printf(«ÃÄÄÄÄÄÄÅ**ÄÄÄÄÅÄÄÄÄÄÄÅÄÄÄÄÄÄÄÅÄÄÌÍ͹ÄÅÄÄÄÄÄÄÄÅÄÄÄÄÄ*ÄÅÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄ´\n»);
printf(«³31 ***32 ³33 ³34 ³35ÌÍ͹ ³36 ³37 *³38 ³39 ³40 ³\n»);
printf(«³ ³ ³ ³ ³ ÌÍ͹ ³ ³ * ³ ³ ³\n»);
printf(«ÃÄÄÄÄÄÄÅÄÄÄÄÄÄÅÄÄÄÄÄÄÅÄÄÄÄÄÄÄÅÄÄÌÍ͹ÄÅÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÅ***ÄÄÄÄÅÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄ´\n»);
printf(«³41 ³42 ³43 ³44 ³45ÌÍ͹ ³46 ³47 ³48 ** ³49 ³50 ³\n»);
printf(«³ ³ ³ *³ **** ³**** ³ ³ ³ ³ ³\n»);
printf(«ÀÄÄÄÄÄÄÁÄÄÄÄÄÄÁÄÄÄÄÄÄ*******ÄÁÄÄ******ÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÙ\n»);
}
int registrarGanador(JugadorT gam[], int turno){
JugadorT temp[200];
int k=0, i, flag=0;
char cadena[30];
FILE *top, *temptop;
temptop=fopen(«temptop.ptd»,»r»);
if(temptop==NULL){
temptop=fopen(«temptop.ptd»,»w»);
fprintf(temptop,»[TEMPTOP]\n%s %d», gam[turno].nombre, gam[turno].veces);
top=fopen(«top.ptd»,»w»);
fprintf(top,»[TOP10]\n%s %d», gam[turno].nombre, gam[turno].veces);
}else{
fscanf(temptop,»%s»,cadena);
while(!(feof(temptop))){
fscanf(temptop,»%s»,temp[k].nombre);
fscanf(temptop,»%d»,&temp[k].veces);
k++;
}
fclose(temptop);
for(i=0;i<k;i++){
if(strcmp(gam[turno].nombre,temp[i].nombre)==0){
flag=1;
temp[i].veces++;
i=k;
}
}
if(flag!=1){
strcpy(temp[k].nombre,gam[turno].nombre);
temp[k].veces=1;
}else
k–;
ordenaTop(temp,k+1);
temptop=fopen(«temptop.ptd»,»w»);
fprintf(temptop,»[TEMPTOP]»);
for(i=0;i<k+1;i++)
fprintf(temptop,»\n%s %d», temp[i].nombre, temp[i].veces);
top=fopen(«top.ptd»,»w»);
fprintf(top,»[TOP10]»);
if(k>9)
k=9;
for(i=k;i>=0;i–)
fprintf(top,»\n%s %d», temp[i].nombre, temp[i].veces);
}
fclose(temptop);
fclose(top);
return (k+1);
}
void ordenaTop(JugadorT temp[], int tam){
int i, j, aux;
char cadena[30];
for(i=0;i<tam;i++){
for(j=i+1;j<tam;j++){
if(temp[i].veces<temp[j].veces){
strcpy(cadena,temp[i].nombre);
aux=temp[i].veces;
temp[i].veces=temp[j].veces;
strcpy(temp[i].nombre,temp[j].nombre);
temp[j].veces=aux;
strcpy(temp[j].nombre,cadena);
}
}
}
}
void guardarPartida(JugadorT gam[], int turno, TableroT tab, FILE *in){
in=fopen(«juegoSyE.ptd»,»w»);
fprintf(in,»Turno: %d»,turno+1);
fprintf(in,»\n#datos del jugador %d», turno+1);
fprintf(in,»\n%s,%d», gam[turno].nombre, gam[turno].avance);
fprintf(in,»\n#datos del jugador %d», (turno+1)%2+1);
fprintf(in,»\n%s,%d», gam[(turno+1)%2].nombre, gam[(turno+1)%2].avance);
fclose(in);
}
int cargaPartida(JugadorT gam[], int *turno, int *njug){
int k, cont=0, aux;
char cadena[30];
FILE *launch;
launch=fopen(«juegoSyE.ptd»,»r»);
if(launch==NULL){
printf(«No tiene partidas guardadas…»);
return 0;
}else{
fscanf(launch,»%s»,cadena);
if((strcmp(cadena,»-1″))==0){
printf(«No tiene partidas guardadas…»);
return 0;
}else{
fscanf(launch,»%d»,&k);
*turno=k-1;
aux=*turno;
while(!feof(launch)){
for(k=0; k<4; k++)
fscanf(launch,»%s»,cadena);
fscanf(launch,»%[^,],%d»,gam[aux].nombre,&gam[aux].avance);
aux=(*turno+1)%2;
cont++;
}
*njug=cont;
return 1;
}
}
}
void menuPrincipal(){
system(«cls»);
system(«color 9b»);
printf(» ÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜ\n»);
printf(«Û Ü Ü\n»);
printf(«Û Û Û . SERPIENTES Y ESCALERAS V2.0 Û\n»);
printf(«Û Û Û ÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜ \n»);
printf(«Û ² Û\n»);
printf(«Û ² Û ÜÜÜ ÜÜ ÜÜÜ ÜÜÜ ÜÜÜ ÜÜ ÜÜÜ ÜÜ\n»);
printf(«Û ² Û Û Û ÛÜÛ Û Û Û Û Û Û ÛÜ ÛÜÜ\n»);
printf(«Û ² Û ÛÜÛ Û ÛÜÜ ÜÛÜ ÛÜÛ Û Û ÛÜÜ ÜÛ\n»);
printf(«Û ± Û\n»);
printf(«Û ± Û 1: Definir numero de jugadores\n»);
printf(«Û ± Û 2: Sortear turnos\n»);
printf(«Û ° Û 3: Iniciar juego\n»);
printf(«Û ° Û 4: reaunudar partida\n»);
printf(«Û ° Û 5: Top 10\n»);
printf(«Û ° Û 6: Salir\n»);
printf(«ÜÜÜÜÛ\n\n»);
}
Ir a la barra de herramientas