¿Cómo programar un juego de blackjack en lenguaje C?
#define N 20
#define COL 100
#define FILA 40
# incluir "stdio.h"
#include "time.h"/*Función de hora del sistema*/
#include "graphics.h"/*Función de gráficos**
#include "alloc.h"/* Función de asignación dinámica de direcciones***
#include "stdlib.h"/*Función de biblioteca**
#include " string.h"/* Función de cadena*/
#include "ctype.h"/*Función de operación de caracteres*/
char p[4][13]={< / p>
{'A', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'J', 'Q', 'K'}, /*Cartas de póquer, 10 está representado por 0*/
{'A', 2', '3', '4', '5', ' 6 ','7','8','9','0','J','Q','K'},
{'A','2','3 ' , '4', '5', '6', '7', '8', '9', '0', 'J', 'Q', 'K'}
{ ' A', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'J', 'Q', 'K' }};
typedef struct node
{
int data;
struct node * link;
}STACK1;/*stack1**/
typedef struct node2
{
datos char;
struct node2 *link <; /p>
}STACK2; /*stack2**/
void init(void); /* Controlador de gráficos*/
void close(void); close*/
void play(void);/* El proceso específico de repartir cartas*/
void rand1(int j);/* Función de reparto aleatorio*/
void change(char *e, char *a); /* Función de infijo a sufijo*/
int computer(char *s); >
STACK1 *initstack1(STACK1 *top); /* Inicialización de pila*/
STACK1 *push(STACK1 *top, int x/* Operación de entrada de pila*/<); p>STACK1 *pop(STACK1 *top); /* pila elimina el elemento superior de la pila*/
int topx(STACK1 *top); /*stack1 lee el elemento superior de la pila*/
STACK1 *ptop(STACK1 *top, int *x); /*Stack1 lee el valor del elemento superior de la pila y elimina el elemento superior*/
int vacío(STACK1 * top); /*Función para determinar si la pila 1 está vacía*/
STACK2 *initsta
ck2(STACK2 *top); /* Inicializar pila 2*/
STACK2 *push2(STACK2 *top, char x); /*Operación de entrada de pila 2*/
STACK2 * pop2(STACK2 *top); /*La pila 2 elimina el elemento superior de la pila*/
char topx2(STACK2 *top); /*La pila 2 lee el elemento superior de la pila*/
STACK2 *ptop2(STACK2 *top, char *x); /*Stack2 lee el valor del elemento superior de la pila y elimina el elemento superior de la pila*/
int vacío2 (STACK2 *top); /* Determinar la pila 2 si es una función vacía*
int text1(char *s); /p>
{
char s[N], s1[N], ch;
int i, resultado
int gdriver, gmode; ;
clrscr(); / *Borrar la pantalla*/
init() /*Función de inicialización*/
while(1)
{
setbkcolor( NEGRO); /*Establecer color de fondo*/
cleardevice(); /*Borrar pantalla*/
play( ); /*distribuidor**
gotoxy(1,15); /* mover cursor**/
printf("------------) --------------Nota----- ---------------\n");
printf(" Ingrese expreso de acuerdo con los cuatro números anteriores\n"); /*Solicitar mensaje**/
printf(" Formato como sigue: 2.*(5. 7.)\n"); / * Solicitar formato de cadena de entrada**/
printf(" -- -------------------------- --- ---------------\n");
scanf("sc", s1, amp; ch); /* Ingrese la cadena y presione Enter*/
change(s1, s); /* Llama a la función de cambio a La expresión intermedia s1 se convierte en la expresión postfix s */
result=computer(s); Calcula el valor de la expresión postfix y devuelve el resultado*/
if(result= =24) /*Si el resultado es igual a 24 */
text1("muy bueno "); /*Llame a la función text1 para mostrar la cadena "muy bien"*/
else
text1("¡incorrecto! !!!") ;/* De lo contrario, la función text1 mostrará la cadena "¡¡¡incorrecto!!!" */
else
text1("incorrecto!*/
printf("Continuar (s/n)?\n"); /* Mensaje indicador, si se debe continuar*/
scanf("c", amp; ch); / * Introduce un carácter */
p>
if(ch=='n'||ch=='N') /* Si el carácter es igual a n o N */
break /* Saltar del; bucle y finalizar el programa*/
}
close()
return /*return**
}
void rand1 (int j)/*aleatorizar la función de licencia*/
{
int kind, num
char str[ 3; ], n;
randomize();
while(1)/* bucle hasta que se reparta una carta**
{
kind=random(4) ; /* número aleatorio de trajes**
num=random(13); /* número aleatorio de tallas**
if( p[kind] ][num]!=- 1) /*Este número no se ha tomado antes
}
int computer(char *s) /* Función de cálculo*/
{
PILA1 *top=NULL;
int i, k, num1, num2, resultado
i=0;
while(s[i ]! = '\0') /* Realice las siguientes operaciones cuando la cadena no esté terminada*
{
if(isdigit(s[ i]))/* Determinar si el carácter es un número*
{
k=0; /* k se establece inicialmente en 0*
do {
k=10* k s[i]-'0'; /* Concatenar caracteres en números decimales*/
i /* Agregar i a 1*/
} while(s[i]! ='.'); /* Repetir el bucle cuando el carácter no sea '.', cuando el carácter no sea '.'*/
arriba =push(top,k); /*Pon el número generado en la pila*/
}
if(s[i]==' ') /*Si es el ' ' número*/
{
top=ptop(top, amp; num2 /*Elimina el elemento superior de la pila y colócalo en num2*/
top=ptop(top, amp; num1); /*Elimina el elemento superior de la pila y colócalo en num1*/
result=num2 num1;/* Agrega num1 y num2 y ponerlo en resultado*/
top=push(top, amp; num2) /* Poner el resultado en resultado*/
top=push(top, amp; num2); ; /* Poner el resultado en resultado*
top=push(result);/ *Pon el resultado en resultado resultado /*Pon el resultado en la pila*/
}
if(s[i]=='-') /*Si el símbolo es '-' */
{
top=ptop( top, amp; num2); /*Saque el elemento superior de la pila y colóquelo en num2*/
top= ptop(top, amp; num1);
elemento superior y ponerlo en num1*/
result=num1-num2; /*Restar num1 de num2 y poner el resultado en result*/
top=push(top , result ); /* Empujar el resultado en la pila * result=num1/num2; /* Almacenar el resultado de dividir num1 por num2 en resultado*
top=push(top, result); el resultado se coloca en la pila*/
}
i; /*i plus 1*/
}
top =ptop (top , amp; resultado); /*El valor del último elemento en la parte superior de la pila es el resultado del cálculo*/
devolver resultado/*Devolver resultado*/
STACK1 *initstack1(STACK1 *top) /*Inicialización*/
{
top=NULL /*El puntero superior de la pila es establecido en null*/
return top;/* Devuelve el puntero superior de la pila*/
}
STACK1 *push(STACK1 *top, int x) /*función initstack*/
{
STACK1 *p; /* Tipo de puntero temporal STACK1**
p=(STACK1 *)malloc(sizeof( STACK1)); /* Solicitar espacio de tamaño STACK1* **
if(p==NULL) /* Si p está vacío***
{
printf("la memoria está desbordada\n. !!!") /* Mostrar desbordamiento de memoria*/
exit(0); }
p-gt ;data=x; /* Guarda el valor x en el nuevo espacio*/
p-gt; por el puntero superior de la pila actual***
top=p; /* El nuevo puntero superior de la pila es el nodo recién insertado*/
return top /* Devuelve el puntero superior de la pila*/
}
STACK1 *pop(STACK1 *top) /* Salir de la pila*/
{
STACK1 *q; /* Definir variables temporales*/
q =top;/* Guardar el puntero superior de la pila actual*/
top=top-gt; * Retroceder el puntero superior de la pila*/
free(q); /* Liberar q */
return top /* Devolver el puntero superior de la pila */
}
int topx(STACK1 *top) /* Leer la parte superior de los elementos de la pila*/
{
if(top==NULL ) /* Si la pila está vacía*/
{
printf( "La pila es nula\n" /* Mostrar información sobre la pila vacía */
return 0; /* Devuelve el número entero 0 */
}
Devuelve datos top-gt /* Devuelve el elemento superior de la pila */
}
STACK1 *ptop(STACK1 *top, int *x) /* Toma el elemento superior de la pila y elimínalo.
Elemento superior de la pila*/
{
*x=topx(top); /* Leer el elemento superior de la pila*/
top= pop(top) ;/* Eliminar el elemento superior de la pila*/
return top; /* Devuelve el puntero superior de la pila*/
}
int vacío(STACK1 *top) / * Determinar si la pila está vacía*/
{
if(top==NULL) /* Si está vacía*/
devuelve 1; /* Devuelve 1*/
else
devuelve 0 /* En caso contrario, devuelve 0*/
}
STACK2 *initstack2(STACK2 *top ) /* Inicialización*/
{
top=NULL /* Establece el puntero superior de la pila en nulo*/
Volver al principio; /* Volver al principio de la pila Puntero*/
}
STACK2 *push2(STACK2 *top, char x) / *Función de pila de inicialización*/
{
STACK2 *p /* Tipo de puntero temporal STACK2 */
p=(STACK2 *)malloc(sizeof( STACK2)); /* Solicitar espacio de tamaño STACK2 */
if(p==NULL) /* si p está vacío*/
{
printf("la memoria está desbordada\n. !!!!") ; /* mostrar La memoria se ha desbordado*/
exit(0) /* Salir**/p>
p-gt; data=x; /* Guardar valor x en un nuevo espacio*/
p-gt; el puntero superior de la pila actual**/p>
top=p /* El nuevo puntero superior de la pila es el nodo recién insertado*/
return top /* Return top; el puntero superior de la pila*/
}
STACK2 *pop2 (STACK2 *top) /* pop */
{
STACK2 *q; /*definir variable temporal */
q=top; /* almacena el puntero de la pila superior actual*/
top=top-gt; el puntero superior de la pila*/
free(q); /*libera q*/
return top /* Devuelve el puntero superior de la pila*/
}
char topx2(STACK2 *top) /* Leer el elemento superior de la pila*/
{
if(top==NULL) /* Si la pila está vacía*/
{
printf("La pila es nula\ n"); /* Muestra el mensaje de que la pila está vacía*/
return ''; /* Devuelve el carácter nulo*/
}
return top-gt /* Devuelve el elemento superior del; pila*/
}
PILA2 *ptop2(PILA2 *
top, char *x) /* Obtener el elemento superior de la pila y eliminar el elemento superior de la pila*/
{
*x=topx2(top);/* Leer el elemento superior de la pila* /
top=pop2(top); /* Eliminar el elemento superior de la pila*/
return top /* Devuelve el puntero en la parte superior de la pila*/
}
int vacío2(STACK2 *top) /* Determinar si la pila está vacía*/
{
if( top==NULL) /* Si está vacío */
devuelve 1 /* devuelve 1 */
else
devolver 0; /* en caso contrario devolver 0 */
}
int text1(char *s)
{
setbkcolor(AZUL) ); /* Establece el color de fondo en azul*/
cleardevice(); /* Limpia la pantalla*/
setcolor(12); red*/
settextstyle(1, 0, 8); /* Fuente de tres trazos. Ampliar 8 veces*//p>
outtextxy(120, 120, s); /*Cadena de salida s*/
setusercharsize(2, 1, 4, 1); * Ampliar 2 veces horizontalmente y 4 veces verticalmente*//p>
setcolor(15); /*Establece el color del texto en *blanco*/
settextstyle(3, 0, 5); /*Trazos sans serif, ampliados 5 veces*/
outtextxy(220, 220, s); /*Cadena de salida s*/
getch( ); Cualquier carácter en el teclado*/
return; /*Valor de retorno*/
}.