Hola a todos. Creo que al programilla le falta la parte donde decide quién ganó (o quizá yo no la vi, sorry). Como un switch() anidado con las nueve posibilidades sería muy tedioso es más cómodo definir una matriz de 3x3, donde la opción 1 representa tijera, 2 la piedra, 3 el papel. En la posición (i,j) de la matriz se pone:

• 1, si i le gana a j
• -1, si i pierde ante j
• 0, si son iguales y hay empate

Así por ejemplo, para el caso de la tijera, como empata consigo misma, pierde ante piedra y gana ante papel, la primera fila de la matriz debe ser {0, -1, 1}. El programa inspecciona el elemento de la matriz, y ahí sabe si usted ganó, perdió o empató.

En la primera parte del programa el usuario elige tijera, piedra o papel pulsando '1', '2' ó '3' (más cómodo que escribir el nombre completo), y este valor entero se deposita en la variable human_op. Luego, elige la máquina al azar usando rand() y srand(), y su valor se deposita en machine_op. Como ya se explicó, el valor de A[human_op - 1][machine_op - 1] dará la respuesta.

Al final, te pregunta si quieres jugar de nuevo y así sucesivamente. Confieso que yo mismo me puse a jugar contra la máquina y casi me envicio, jajaja  .

Un detalle, la función clear_screen() está codificada para Windows y para Linux. En Windows debes dejar la línea system("cls") y comentariar  system("clear"), mientras en Linux se hace al revés. La versión que pongo aquí está para Windows:

#include <cstdlib>
#include <iostream>
#include <time.h>
 
void clear_screen( void );
 
using namespace std;
 
int main () {
 
    string human, machine;
    int human_op = 0;        /* 1: tijera, 2: piedra, 3: papel */
    int machine_op = 0;
    char next;                /* next == 's' indica que se quiere seguir jugando */
 
    /* Declarar matriz de casos:
     * 
     * 1: tijera, 2: piedra, 3: papel
     *
     * El elemento (i,j) vale: 
     *   1 si "i le gana a j"
     *  -1 si "i pierde ante j"
     *   0 si hay empate
     */
    int A[3][3] = {{0, -1, 1}, {1, 0, -1}, {-1, 1, 0}};
 
    /* inicializar semilla */
    srand( time(NULL) );
 
    do {
 
        /* El humano elige */
        do {
            clear_screen( );        /* borrar pantalla */
            cout << "Juego piedra, papel o tijera ..." << endl << endl
                << "1: tijera" << endl
                << "2: piedra" << endl
                << "3: papel" << endl << endl 
                << "elige: ";
            cin >> human_op;
        } while ( human_op < 1 || human_op > 3 );
        switch ( human_op ) {
            case 1:
                human = "tijera";
                break;
            case 2:
                human = "piedra";
                break;
            case 3:
                human = "papel";
                break;
        }
 
        /* La maquina elige */
        machine_op = rand( ) % 3 + 1;
        switch ( machine_op ) {
            case 1:
                machine = "tijera";
                break;
            case 2:
                machine = "piedra";
                break;
            case 3:
                machine = "papel";
                break;
        }
 
        /* Ahora se decide quien gana */
        cout << endl << "Usted elige: " << human << endl 
            << "La maquina elige: " << machine << endl << endl
            << "... ";
        switch ( A[human_op - 1][machine_op - 1] ) {
            case 1:
                cout << "Usted gana !!!" << endl;
                break;
            case -1:
                cout << "Ups, usted pierde" << endl;
                break;
            case 0:
                cout << "Empate" << endl;
                break;
        }
 
        /* Seguir jugando ? */
        cout << "Seguir jugando s/n? ";
        cin >> next;
    } while ( next == 's' );
}
 
/* Borra la pantalla */
void clear_screen( void ) {
 
    /* para Windows */
    system( "cls" );
    /* para Linux */
    //system( "clear" );
}

Totalmente de acuerdo, y con respecto a " lagunas de memoria, accesos a memoria no reservada o desbordamientos de buffer", te cuento que sí que tuve muchos dolores de cabeza con eso, pues me ocurría en las primeras versiones del código.

La verdad, este fue un ejercicio más que todo para aprender, pues como dices en una aplicación real lo más lógico es usar STL pues se vuelve más fácil de comprender y mantener.

Hacía tiempo quise ponerme a "inventar", y emular clases con C pero me encontré algunos problemas. Por ejemplo, tengamos la clase circle (círculo) con sus miembros x, y, radious, cuyos significados son obvios. Ahora queremos definir el método setX para cambiar el valor del miembro x. Claro, no son clases verdaderas, sino la emulación de éstas en C.

En C++ las clases mantienen su espacio privado de nombres de métodos, por lo que debemos usar el operador :: para acceder a ellos. No sucede lo mismo en C, donde hay que usar funciones "sueltas". Una idea sería prefijar los nombres de los métodos con el nombre de la clase, algo como:

CIRCLE_setX( double new_x, circle * this)

aunque aún es un poco burdo. No se si es lo mejor que se puede hacer a costa de mantenerse puro dentro de C, o se puede mejorar un poquito.
¿Acaso podemos ser creativos e inventar algo con #define para volverlo más amigable?

A ver, ¿cómo hacían los programadores antiguos, cuando no había aparecido C++?

Mmmm, entonces la implementación es diferente que en Windows. En Windows el tiempo sí transcurre a pesar de getchar(). Curioso (?!)

Probé este otro, que imprime "1 ... " y espera 3 segundos antes de imprimir "2". Éste sí funciona en Linux de la manera esperada:

#include <stdio.h>
#include <time.h>
 
int main( ) {
 
	clock_t t1, t2;
	int i, j, k;
 
	t1 = clock();
	printf( "1 ... " );
        fflush( stdout );
	do {
		t2 = clock();
	} while ( (double)(t2 - t1)/CLOCKS_PER_SEC < 3 );
	printf( "2" );
}

Igualmente un gran abrazo hermano, aprecio tu solidaridad !!!!!!!!!  

Ah, el pastebin es porque como es un código largo, para no embasurar el foro, pero también se puede poner aquí ...

Mira, pero me pusiste la bandera "izquierdista", con 8 estrellas y el caballo andando a la izquierda, jaja. Tienes que poner ésta  

Hola María. Compatriota!!!, entiendo tu situación pues también soy de Vzla y es triste la situación que vivimos. Los poderosos explotando a los débiles  , no importa el lado político en que se midan.

Ok, vamos por partes. Una primera recomendación sería declarar las variables contador i, j al principio del main(), y no dentro de cada ciclo. Así:

int i, j;

y de este modo ya puedes escribir

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

sin tener que poner "int" dentro del for. Me tomé el atrevimiento de cambiar el nombre "matriz" por "dim" porque me pareció más acorde con el significado o intención de esa variable, que es representar la dimensión de la matriz.

En esta primera parte del programa pides al usuario el tamaño o dimensión del tablero, y luego creas la matriz dinámicamente. Al principio la matriz se rellena toda con ceros, luego el programa te va pidiendo que le indiques dónde van las minas. Le indicas un '1' para decir que hay una mina en la posición indicada, o un '0' para decir que no hay mina.

Ahora creo que señalaste el problema de que es muy fastidioso preguntar por todas las casilla si sólo van 2 ó 3 bombas. Primero recuerda que el programa te tiene que pedir todas las coordenadas, ya que las minas podrían en cualquier parte. Sin embargo, si terminaste de declarar las minas antes de recorrer toda la matriz, introduce un 'x' ó un 'q' para terminar el ciclo. Eso se hace con la parte:

else if ( c == 'q' || c == 'Q' || c == 'x' || c == 'Q' )
   listo = 1;

La otra forma de trabajar sería que el programa no te pregunte por todas y cada de una de las casillas sino que te pida coordenada i, coordenada j, y valor. Ahora, yo creo que esta segunda opción sería incluso más fastidiosa (!?).

Otra manera más sería que el programa rellenara las minas aleatoriamente, también podemos hacerlo así, depende de los requerimientos de diseño, de cómo lo quieres hacer y si profesor ha puesto alguna clase de límites o condiciones.

La siguiente parte del código es donde se imprime la matriz, indicando con '*' donde hay bomba, y '0' donde no hay.

Ahora, por otra parte el programa de leosansan está muy completo, aunque no se si lo has leído, si quieres basarte en él, o si lo pudiste entender.

Unas preguntas o comentarios:

• ¿Trabajas en Windows o Linux?
• ¿Te permiten usar getch()?
• Si es en Windows, ¿te permiten usar la biblioteca conio?
• ¿Se puede usar simplemente C en lugar de C++? Me parece que la complejidad del programa no exige C++ (no lleva clases)
• Finalmente quiero comentar que para mí la matriz puede ser de char, o de int, indistintamente. Al fin y al cabo almacena números (ceros o unos).

Aquí el código de la primera parte, que es simplemente la correción de unos pequeños detalles del que hiciste:

#include <iostream>
#include <string>
 
using namespace std;
 
int main()
{
   int dim, bomba='*', valor;
   int i, j;      /* <-- declara aqui, no dentro del ciclo */
   char c;
   char listo;
 
   cout << time(NULL);
   return 0;
 
   cout << "Tamano de la matriz: ";
   cin >> dim;
   cout << endl;
 
   /* creamos la matriz, y rellenamos con ceros */
   char **M = new char *[dim];
   for (i = 0; i != dim; i++)
      M[i] = new char [dim];
 
   for (i = 0; i < dim; i++) 
      for (j = 0; j < dim; j++)
         M[i][j] = '0';
 
   /* poniendo posiciones de las minas */
   listo = 0;
   for (i = 0; i < dim && listo == 0; i++) {
      for (j = 0; j < dim && listo == 0; j++) {
         cout << endl << "Posicion [ " << i << " ] [ " << j << " ]: ";
         cin >> c;
         if ( c == '1' )
            M[i][j] = '1';
         else if ( c == 'q' || c == 'Q' || c == 'x' || c == 'Q' )
            listo = 1;
      }
   }
 
   // mostrar matriz
   cout << endl << "La matriz es:" << endl;
   for (i = 0; i != dim; i++) {
      for (j = 0; j != dim; j++)
         if ( M[i][j] == '1') 
            cout << "*\t";
         else
            cout << "0\t";
      cout << endl;
   }
 
   // destruye la matriz
   for (i = 0; i != dim; i++)
     delete[] M[i];
   delete[] M;
 
   return 0;
}

Una recomendación a ivance96. Para que el código sea más portable, recordemos que los tipos enteros no tienen una longitud rígidamente definida, por ejemplo en algunas máquinas (antiguas) los enteros son de 16bits, y en otras de 32bits. Si mal no recuerdo, la norma indica que la longitud de int debe estar entre la longitud de short y la de long, pero la elección entre ambos depende de la implementación. Debiendo ser la longitud de short de al menos 16 bits, y la de long de al menos 32 bits. Así que por ejemplo una implementación en particular (quizá en el futuro, para una máquina potente) pudiera tener short de 32 bits, int de 64 bits y long de 64 bits.

La biblioteca <limits.h> define los máximos posibles para los distintos tipos aritméticos según la puesta en práctica. Por ejemplo, CHAR_MAX, SHRT_MAX, UINT_MAX define los máximos de char, short int y unsigned int respectivamente, y son valores que dependen de la implementación de C en tu máquina particular. Así que el programa podría quedar algo así como:

/** INT && UINT **/
if(s[0]=='-')
	sign=true;
	if ( allNumeric(s.substr(sign, s.size()))) {
	if(sign) {
   		if ( atoi(s.substr(1, s.size())) <= INT_MAX  )
		type+=type_int;
	}else{
	if ( atoi(s.substr(0, s.size())) <= INT_MAX )
		type+=type_int;
	if ( atoi(s.substr(0, s.size())) <= UINT_MAX)
		type+=type_uint;
	}
}

el cual es transportable sin problemas de una máquina a otra.

Hola, preciso ayuda de los Linuxeros. Este sencillo código (que mide el tiempo transcurrido entre el inicio del programa y la pulsación de ENTER) no funciona como debe en Linux. En Windows lo probé y está Ok.

El problema es que clock() devuelve siempre cero (0), tanto para t1 como para t2, y por eso no mide el tiempo. ¿Qué es lo que le falta "ajustar" para que funcione en plataformas Linux y/ similares?

#include <stdio.h>
#include <time.h>
 
int main( ) {
 
	clock_t t1, t2;
 
	t1 = clock();
	getchar();
	t2 = clock();
	printf("Han transcurrido %.2lf s\n", (double)(t2 - t1)/CLOCKS_PER_SEC );
 
}

Ok, el triángulo de Pascal, pero exactamente qué se te ocurre hacer?? Acepto el reto, jeje (claro, en un nuevo post) ...

Ah, leosansan pero es mi intención fue precisamente recibir una cadena de 3 o menos dígitos. O sea, si aceptamos en forma estricta la longitud y el número fuera 12 tendrías que escribir 012, que es un fastidio, puff

Una solución sería definir un búfer más grande (por ello la constante N), digamos de 10 o 20 caracteres, así el usuario dispone de todos esos espacios para escribir su número (grande o pequeño). Ahora si él se equivoca tecleado el número, es culpa de él, jajajajajajaja

La otra opción de que sea una cantidad fija de dígitos, ni más ni menos, también puede ser deseable. Eso depende de cómo el diseñador quiera presentar la interfaz de su programa, y de la aplicación que involucre. Si por ejemplo vas a meter un cifra cuya cantidad de dígitos se conoce con exactitud (cédula de identidad, código de un producto en un almacén, o el carnet de un trabajador) vale el segundo enfoque. Pero si la longitud es variable y desconocida vale el primer enfoque con un búfer tan grande como la máxima longitud admisible.

Ya eso depende del caso que se quiera trabajar ..... Y saludos como siempre 

Jajaja, ¿MS-DOS?. De buena intención te digo que deberías aventurarte a conocer el Linux, cuando lo domines no querrás dejarlo. Te voy a poner un ejemplo, quieres inspeccionar en el directorio actual todos los ficheros cuyo nombre empieza con "abc" y hayan sido modificados hace menos de 10m. Con una simple orden bash (la consola de Linux):

find . -name "abc*" -mmin -10

¿y cómo lo harías así de rápido en Win?

Bueno pero volviendo al tema, al final quedé un poco frustrado porque no logré el comportamiento deseado. Me hubiera gustado que la bola siguiera un movimiento continuo en una dirección dada y al pulsar una tecla de flecha cambiara la dirección. Pero esto tiene un inconveniente, y es que la pulsación de dichas flechas sería asíncrona, es decir, no sabes cuándo va a suceder. Si haces algo como:

Sleep(500);
c = getch();

sería un error porque se quedaría "colgado" tras cada movimiento pidiendo tecla.

Lo ideal aquí sería un "servicio" o "demonio", es decir un programa que corre paralelo al principal, en segundo  plano, y su labor sería inspeccionar si hay caracteres no leídos en el búfer de teclado. En ese caso, los extrae e interpreta: si es un carácter de flecha, cambia la dirección de la bola. Si no hay caracteres disponibles no hacer nada.

Hasta lo que tengo entendido la función getch() no funciona de este modo porque es "bloqueante", es decir bloquea el programa llamador hasta que se reciba un carácter. En los sistemas conformes a POSIX este comportamiento se puede modificar para que espere un tiempo dado y de no recibir carácter en ese lapso, devuelva al programa principal. En Windows realmente no se cómo se pude imitar este comportamiento (aunque de seguro se puede), imagino que un manera sería crear un "servicio" que inspeccione continuamente el teclado y deposite los caracteres en un búfer virtual. De esta manera al no recibir tecla se bloquearía el programa servicio y no el programa principal.

Finalmente, y para curar en salud, elegí quitar la pausa y pedir tecla siempre  
O sea, la pelotita se mueve sólo un paso a la vez. Tienes que teclear y teclear para moverla por todo el tablero. Por otro lado, y como no recuerdo la codificación de la teclas de flecha en Windows, decidí hacerlo con las teclas del teclado numérico:

8:  arriba
2:  abajo
4:  izq
6:  der

Si sabes los códigos de las teclas de flecha en Win, modifica el programa en la parte de getch(). En Linux (como es conforme al estándar ECMA) estas teclas se codifican de manera diferente, como "secuencias de escape". De hecho, es bueno saber que supuestamente el único sistema que no acepta secuencias de escape es Windows (?!), o sea, Win es la excepción y no la regla (aunque esa "excepción" copa el 90% del mercado!)

Volviendo al tema, el juego termina cuando hayas alcanzado la fila inferior del tablero, o te hayas excedido del máximo posible de movimientos (le puse un límite de 100, jeje). Sería bueno modificar el tablero para hacer una especie de laberinto ...

El código es multiplataforma, se puede compilar en Linux y en Windows. Para el primer caso debes definir la macro _LINUX, y para el segundo define _WIN. Lo más cómodo es por supuesto en la orden de compilación:

Windows: gcc -o tablero tablero.c -D_WIN
Linux:   gcc -o tablero tablero.c -D_LINUX


Pruébalo y me comentas si le añadimos o quitamos algo (sólo modifiqué la opción 2 del programa, no toqué ni la 3 ni la 4).

NOTA. El parámetro blocked parece redundante (no hace nada) pero está porque en un principio quería hacer que al quedarse bloqueado pidiera tecla para cambiar la dirección, pero como comenté anteriormente no pude al menos en este primer intento.

Aquí el código fuente (pastebin): http://pastebin.com/fDweNAsf