Totalmente de acuerdo engelx, pero también hay considerar a veces que no sólo el código fuente sea más breve, sino que realmente se ejecute más rápido.

Por ejemplo, usas tres veces el strlen(text) es decir una sobrecarga por llamadas a función. Sería mejor definir una constante y asignarle el valor N = strlen(text), luego usas N. Esto quizá lleve más líneas de código fuente pero se ejecutará más rápido.

María, llega un momento en que la complejidad de un programa crece hasta que termina enredándose uno mismo en su propio trabajo, jeje. Para evitar eso debes trabajar de manera modular, es decir, divide el programa en pequeñas partes funcionales que puedan integrarse entre sí.

Ahora hago unos comentarios. Es muy válida la recomendación de eferion, si estás en C++ usa endl en lugar de '\n'. Por otra parte perdón a los que puedan discrepar pero me parece más lógico que la matriz sea considerada de enteros y no de char, pues al fin y al cabo contendrá números (1 si hay bomba, 0 si no hay). Soy partidario de que una función auxiliar sea la encargada de decidir qué caracteres se van a mostrar en pantalla, en lugar de que dichos caracteres sean almacenados directamente en la matriz. Y como verás, este enfoque te evitar tener que hacer conversiones y operaciones complicadas como:

Matriz[fil][col]=cont[fil][col]+48;   (????????)


Tomando como base el código que presentaste, y depurándolo eliminé unas cuántas líneas redundantes por aquí y por allá, también como te dije sacar del main() rutinas que pueden definirse aparte, hasta quedar un procedimiento principal breve, limpio y sencillo (como debe ser):

int main(void) {
 
   int dim;
   int i, j;
 
   cout << "Introduzca la dimension de la matriz: ";
   cin >> dim;
 
   int **A = new int *[dim];
   for (i = 0; i < dim; i++)
      A[i] = new int [dim];
   for (i = 0; i < dim; i++)
      for (int j = 0; j < dim; j++)
         A[i][j] = 0;
 
   /* indicar donde van las minas, e imprimir */      
   colocar_minas( A, dim);
   imprimir( A, dim, 1);
 
   /* descubrir las casillas */
   descubrir_casillas( A, dim);
}

donde me tomé el atrevimiento de cambiar el nombre "Matriz" por simplemente "A".

Ahora, la función auxuliar de colocar las minas se encarga de rellenar la matriz (en lugar de hacerlo el main()). En lo particular me pareció un poco pesado e innecesario que el usuario tenga que decir de antemano cuántas bombas hay. En lugar de ello lo modifiqué para que él te vaya preguntando si quieres meter otra mina, y sigue hasta que respondas 'n'. El código:

void colocar_minas (int **A, int dim) {
 
   int i, fil, col;
   char op;
 
   cout << endl << "*** Colocando las minas ***" << endl << endl;
 
   op = 's';
   do {
      do {
         cout << "Introduzca fila: ";
         cin >> fil;
      } while (fil < 1 || fil > dim);
      fil = fil - 1;
 
      do {
         cout << "Introduzca columna: ";
         cin >> col;
      } while (col < 1 || col > dim);
      col = col - 1;
 
      A[fil][col] = 1;
 
      /* imprimimos, para que el usuario vea como va quedando */
      imprimir( A, dim, 0);
 
      do {
         cout << "Otro? s/n: ";
         cin >> op;
      } while ( op != 's' && op != 'S' && op != 'n' && op != 'N' );
 
   } while ( op == 's' || op == 'S' );
}

También me pareció más adecuado separar la utilidad de contar las minas que rodean una casilla en una función aparte int contar_minas( int **A, int dim, int i, int j ).

Ahora vamos a la parte delicada, y lo que creó el meollo: si en la matriz reemplazas el valor de cada casilla (1 si hay bomba y 0 si no hay) por la suma de las casillas adyacentes, entonces pierdes el valor original. ¿Cómo hacer? Una solución sería crear dos matrices, pero desperdicia espacio de memoria. Otra alternativa es modificar la función:

imprimir(int **A, int dim, int estilo)

que recibe una matriz A de 1's y 0's, pero donde el tercer argumento estilo permite definir tres modos posibles de funcionamiento:

• estilo = 0, hace que se imprima '*' donde hay bomba y '0' donde no hay
• estilo = 1, hace que se impriman las sumas de las casillas circundantes, en lugar de bomba/no-moba
• estilo = 2, es para cuando el usuario va descubriendo las casillas. Imprime la suma circundante si la casilla no ha sido destapada, '0' si ha sido destapada y no hay bomba, y '*' si se destapó y hay una bomba (el juego termina).

La idea es usar el estilo 0 cuando estás rellenando la matriz, el 1 cuando terminaste de llenar, y el 2 cuando vas destapando las casillas. Pero resumes los tres en una sola función, de un modo sintético y elegante.

Sin embargo surge un problema delicado. Si una casilla no tiene bomba y no ha sido destapada se representa por la suma circundante. Pero si no tiene bomba y ha sido destapada, se representa por un '0'. ¿Cómo distinguir un caso de otro? Como dije antes una solución (ineficiente) es crear una segunda matriz que se vaya actualizando según las casillas que el usuario vaya descubriendo.
Mejor es apelar a un "truco" que usamos los programadores. Si miras bien, hasta ahora hemos usado 2 valores posibles para cada celda de la matriz A, esto es, 0 y 1. Quedan otros valores disponibles, con los que podemos representar otros significados. Podríamos asignar el valor -1 para la casilla que tenga una bomba que ha sido descubierta (boom!!, termina el juego), y el 2 para la casilla que ha sido destapada y no tiene bomba. Así quedaría:

• A[ i][j] = -1, si hay una bomba y fue destapada (termina el juego)
• A[ i][j] = 0, si no hay bomba, y no ha sido destapada
• A[ i][j]) = 1, si hay bomba, pero no ha sido destapada
• A[ i][j] = 2, si no hay bomba, y fue destapada

La función de imprimir, con las tres posibilidades quedaría:

void imprimir( int **A, int dim, int estilo) {
 
   int i, j;
 
   for (i = 0; i < dim; i++) {
   cout << "\t\t" ;
      for (j = 0; j < dim; j++) {
         /* aqui decidimos como queremos imprimir */
         switch (estilo) {
            /* solo mina / no-mina */
            case 0:
               if ( A[i][j] == 1 )
                  cout << " * ";
               else
                  cout << " 0 ";
               break;
            /* contar las minas que rodean */
            case 1:
               cout << ' ' << contar_minas( A, dim, i, j ) << ' ';
               break;
            /* a medida se van descubriendo las minas */
            case 2:
               if ( A[i][j] == -1 )
                  cout << " * ";      /* boom, jeje */
               else if ( A[i][j] == 0 || A[i][j] == 1 )   
                  cout << ' ' << contar_minas( A, dim, i, j ) << ' ';
               else if ( A[i][j] == 2 )
                  cout << " 0 ";
            break;
         }
      }
      cout << endl << endl;
   }
   cout << endl << endl;
}

Ahora, hay que tener cuidado cuando codificamos la función de sumar los adyacentes. Recuerda que se debe sumar cualquier bomba (destapada o no) o sea, el valor 1 ó -1 en la matriz. Por lo tanto:

/* Cuenta la cantidad de minas que rodean a una posicion dada de la matriz,
 * incluyendo al elemento propio */
int contar_minas( int **A, int dim, int i, int j ) {
 
   int k, l, contador;
 
   contador = 0;
   for ( k = -1; k < 2; k++) {
      for ( l = -1; l < 2; l++) {
         if (i+k >= 0 && j+l >= 0 && i+k < dim && j+l < dim) 
            if ( A[i+k][j+l] == 1 || A[i+k][j+l] == -1)
               contador ++;
      }
   }
 
   return contador;
}

Ya lo que quedaría sería definir la función que permite al usuario ir destapando las casillas a su gusto. Si destapa una bomba, pierde. De lo contrario, el juego continúa hasta que destapa todas las que no tienen bomba en cuyo caso gana. Este código te lo muestro al final, junto con el programa completo.

El código a continuación ya es funcional, está listo para copiar, compilar y ejecutar.

NOTA. Téngase en cuenta que en el juego buscaminas real hay características que nuestro programa aún no posee.

#include <iostream>
 
using namespace std;
 
void imprimir (int **A, int dim, int estilo);
void colocar_minas (int **A, int dim);
int contar_minas (int **A, int dim, int i, int j);
void descubrir_casillas (int **A, int dim);
 
int main(void) {
 
   int dim;
   int i, j;
 
   cout << "Introduzca la dimension de la matriz: ";
   cin >> dim;
 
   int **A = new int *[dim];
   for (i = 0; i < dim; i++)
      A[i] = new int [dim];
   for (i = 0; i < dim; i++)
      for (int j = 0; j < dim; j++)
         A[i][j] = 0;
 
   /* indicar donde van las minas, e imprimir */      
   colocar_minas( A, dim);
   imprimir( A, dim, 1);
 
   /* descubrir las casillas */
   descubrir_casillas( A, dim);
}
 
/* Permite al usuario ir colocando las minas. Para seguir colocando, 
 * responder 's' al final, de lo contrario termina. */
void colocar_minas (int **A, int dim){
 
   int i, fil, col;
   char op;
 
   cout << endl << "*** Colocando las minas ***" << endl << endl;
 
   op = 's';
   do {
      do {
         cout << "Introduzca fila: ";
         cin >> fil;
      } while (fil < 1 || fil > dim);
      fil = fil - 1;
 
      do {
         cout << "Introduzca columna: ";
         cin >> col;
      } while (col < 1 || col > dim);
      col = col - 1;
 
      A[fil][col] = 1;
 
      /* imprimimos, para que el usuario vea como va quedando */
      imprimir( A, dim, 0);
 
      do {
         cout << "Otro? s/n: ";
         cin >> op;
      } while ( op != 's' && op != 'S' && op != 'n' && op != 'N' );
 
   } while ( op == 's' || op == 'S' );
}
 
/* Imprime la matriz en varios estilos:
 *
 *  0: Indican simplemente donde hay minas y donde no.
 *  1: Indica cuantas minas rodean a cada casilla (incluyendo a si misma)
 *  2: Como se muestra a medida que se descubren las casillas.
 *     El valor -1 imprime una bomba, para los valores entre 0 y 9 imprimen
 *     la suma circundante, y el 10 se imprime como 0.
 */
void imprimir( int **A, int dim, int estilo) {
 
   int i, j;
 
   for (i = 0; i < dim; i++) {
   cout << "\t\t" ;
      for (j = 0; j < dim; j++) {
         /* aqui decidimos como queremos imprimir */
         switch (estilo) {
            /* solo mina / no-mina */
            case 0:
               if ( A[i][j] == 1 )
                  cout << " * ";
               else
                  cout << " 0 ";
               break;
            /* contar las minas que rodean */
            case 1:
               cout << ' ' << contar_minas( A, dim, i, j ) << ' ';
               break;
            /* a medida se van descubriendo las minas */
            case 2:
               if ( A[i][j] == -1 )
                  cout << " * ";      /* boom, jeje */
               else if ( A[i][j] == 0 || A[i][j] == 1 )   
                  cout << ' ' << contar_minas( A, dim, i, j ) << ' ';
               else if ( A[i][j] == 2 )
                  cout << " 0 ";
            break;
         }
      }
      cout << endl << endl;
   }
   cout << endl << endl;
}
 
/* Cuenta la cantidad de minas que rodean a una posicion dada de la matriz,
 * incluyendo al elemento propio */
int contar_minas( int **A, int dim, int i, int j ) {
 
   int k, l, contador;
 
   contador = 0;
   for ( k = -1; k < 2; k++) {
      for ( l = -1; l < 2; l++) {
         if (i+k >= 0 && j+l >= 0 && i+k < dim && j+l < dim) 
            if ( A[i+k][j+l] == 1 || A[i+k][j+l] == -1)
               contador ++;
      }
   }
 
   return contador;
}
 
/* Permite al usuario ir descubriendo casillas del tablero, y si se 
 * encuentra una mina, pierde !!! */
void descubrir_casillas( int **A, int dim ) {
 
   int i, j;
   char terminar;
 
   cout << endl << "*** Ahora descubriendo las casillas ***" << endl << endl;
 
   imprimir( A, dim, 2);
 
   terminar = 'n';
   do {
      do {
         cout << "Introduzca fila: ";
         cin >> i;
      } while (i < 1 || i > dim);
      i = i - 1;
 
      do {
         cout << "Introduzca columna: ";
         cin >> j;
      } while (j < 1 || j > dim);
      j = j - 1;
 
      if ( A[i][j] == 1) {
         /* encuentra mina: pierde !!! */
         A[i][j] = -1;
         imprimir( A, dim, 2 );
         cout << endl << "Boom!!!, ha perdido" << endl;
         terminar = 's';
      }
      else {
         /* sigue jugando */
         A[i][j] = 2;
         imprimir( A, dim, 2 );
      }
 
      /* Nota: 0 significa casilla sin bomba y sin descubrir.
       *       2 significa casilla sin bomba y ya descubierta.
      /* El programa termina si no quedan por descubrir casillas 
       * sin bombas (casillas con el valor 0) */
      if ( terminar == 'n' ) {
         terminar = 's';
         for (i = 0; terminar == 's' && i < dim; i++)
            for (j = 0; terminar == 's' && j < dim; j++)
               if ( A[i][j] == 0 ) terminar = 'n';
 
         if ( terminar == 's' ) {
            cout << endl << "Felicitaciones, ha ganado !!!" << endl;
            imprimir( A, dim, 0);
         }
      }
 
   } while ( terminar == 'n' );
}

Uy, engelx se me adelantó, justo con la idea de interrupir el ciclo cuando ya se sepa que no es palíndromo. Lo que faltaría es recorrer sólo la primera mitad de la palabra, yeah!!

Hola, comparto un programilla que puede ser útil en este mismo foro. Encuentro que al subir código con la etiqueta code, los tabuladores son reemplazados por una cantidad de espacios que a mi entender son demasiados (son como 8). El código entonces toma una aparienci anti-estética  . Se me ocurrió hacer un programa llamado "tab" que reemplace todos los TAB en el fichero .c original por una cantidad de espacios determinada, y vuelque su salida a un fichero auxiliar, cuyo contenido copiaré dentro de la etiqueta code.

La sintaxis (UNIX)

./tab fichero_entrada fichero_salida N_spaces

y en DOS quitar el "./" que antecede a tab. Por ejemplo, "tab code.c code2.c 3". Si no se indica N_spaces se toman 3, y si no se indica fichero de salida toma la salida estándar.

#include <stdlib.h>
#include <stdio.h>
 
/* Este programa reemplaza los caracteres TAB del fichero de texto
 * pasado como primer argumento por una cantidad determinada de espacios,
 * y escribe su salida en el fichero pasado como segundo argumento.
 * El tercer argumento (opcional) especifica cuántos caracteres ' ' 
 * reemplazarán el TAB, y si no se indica, se tomará una cantidad de tres.
 */
 
int main( int argc, char *argv[]) {
 
   int i, N_spaces;
   char c;
   char * in_fname, * out_fname;
   FILE * in_fptr = NULL, * out_fptr = NULL;
 
   if ( argc < 2 ) {
      printf("Use:\n tab in_file out_file\n tab in_file out_file N_spaces\n");
      goto failure;
   }
 
   in_fname = argv[1];
 
   if ( argc > 3 ) {
      N_spaces = atoi( argv[3] );
      if ( N_spaces < 1 )
         N_spaces = 3;
      }
   else
      N_spaces = 3;
 
   if ( ( in_fptr = fopen( in_fname, "r" ) ) == NULL ) {
      printf( "No existe o no se pudo abrir '%s'\n", in_fname );
      goto failure;
   }
 
   /* toma stdout si falta fichero de salida */
   if ( argc < 3 ) 
      out_fptr = stdout;
   else   {
      out_fname = argv[2];
      if ( ( out_fptr = fopen( out_fname, "w" ) ) == NULL ) {
         printf( "Imposible crear, abrir o escribir en '%s'\n", out_fname );
         goto failure;
      }
   }
 
   /* reemplazando TAB por N_spaces caracteres ' ' */
   while ( ( c = fgetc( in_fptr ) ) != EOF ) {
      if ( c != '\t' ) 
         fputc( c, out_fptr );
      else
         for ( i = 0; i < N_spaces; i++ )
            fputc( ' ', out_fptr );
   }
 
   if ( in_fptr != NULL ) fclose( in_fptr);
   if ( out_fptr != NULL ) fclose( out_fptr);
   return 0;
 
failure:
   if ( in_fptr != NULL ) fclose( in_fptr);
   if ( out_fptr != NULL ) fclose( out_fptr);
   return -1;
}

NOTA. Una alternativa es la utilería "sed" (UNIX), pero no se si tiene alternativa Windows.

Exactamente como dice leosasan, faltaba la parte donde realmente inviertes la palabra (?!). Y aparte yo recomendaría optimizar la parte donde haces la comparación, sin necesidad de usar la variable intermedia j (entre menos variables uses, el código será más ligero):

if( strcmp(text2, text) != 0 )
    printf("\n Es un palindromo ");
else
    printf("\n No es un palindromo ");
}

o más elegantemente, reemplazado strcmp(text2, text) != 0 por  !strcmp(text2, text) :

if( !strcmp(text2, text) )
    printf("\n Es un palindromo ");
else
    printf("\n No es un palindromo ");
}

=====================================================
(EDICIÓN)

Estaba pensando mejor el asunto, y no es necesario invertir toda la palabra para saber si es un palindromo. Es decir, basta que un carácter no coincida con su "complementario" en la otra mitad de la palabra. O sea si la palabra tiene una longitud N entonces basta que

text[i] != text[N - i - 1]

para saber que no es palíndromo, y en este punto el ciclo debería detenerse. Por la misma razón, es suficiente con escanear la primera mitad de la palabra, o sea desde i=0 y mientras i sea menor a N/2 caracteres (saca la cuenta, funciona con N par e impar).

Con todo esto, el código se puede depurar a:

#include <stdio.h>
#include <stdlib.h>
 
int palindromo (char text[]);
 
int main ()
{
 
   char text[100];
 
   printf("\n Introduce un texto: ");
   gets(text);
 
   if ( palindromo(text) )
     printf("\n Es un palindromo ");
   else
     printf("\n No es un palindromo ");
 
   printf("\n FIN DEL PROGRAMA \n ");
   getchar( );
 
   return 0;
}
 
int palindromo (char text[])
{
   int i, N;
 
   N = strlen(text);
   for (i = 0; i < (float)N/2; i++)
   {
      if ( text[i] != text[N - i - 1] )
         return 0;
   }
   return 1;
}

Claro, entre más sofisticado se vuelva el código puede que este se ejecute más rápido pero aumenta la complejidad de algunos detalles del mismo (espero no abrumarte). Observa que el tipo de retorno de la función auxiliar palindromo se cambió a int, precisamente para que devuelva un valor numérico indicando si la palabra es palindromo o no.

Si no lo es, observa que la ejecución del for/ se detiene en algún momento cuando la condición dentro del if sea verdadera, y retorna 0. De lo contrario, continúa hasta el final y retorna 1.

Por último un detalle sutil. Cuando la longitud N de la palabra sea impar, el cociente N/2 será decimal, pero los tipos de las variables i, N son enteros, por eso la comparación i < N/2 no será válida. Es necesario convertir N a float para que admita los decimales y por eso ponemos i < (float)N / 2.

Por ejemplo, si N=5 entonces el programa debe ejecutarse con las primeras 3 letras de la palabra, y siendo N/2 = 2.5 ocurrirá justo así, se ejecutará para i=0, i=1, i=2. Por eso, funciona bien cuando N es impar.

Leo, tu programa es ideal para el caso de una clave numérica con una cantidad exacta de dígitos, además obliga al usuario sobre meter exactamente esa cantidad.

Y respecto a los rombos, ....... tranquilo jaja que ya voy a aparecer con una idea que he estado pensando y espero sorprendente  (tanto como las de todos)

Ojo, leosansan, no había leído bien los mensajes previos tuyos y de eferion, sin embargo para que no haya confusión aclaro que en el juego que diseñé los asteriscos son MINAS.

Es más, voy a tener que usar unos #defines para especificar los distintos símbolos, así se pueden cambiar facílito de una versión a otra, jajaja

Yo no tengo en el mío casillas bloqueadas (inseleccionables), aunque esa funcionalidad se puede añadir.

En todo lo demás que has dicho sobre las características del juego buscaminas real, estoy de acuerdo!

Hola!!! Bueno, en C++ no conozco un método que no sea el propuesto por leosansan.

Pero hurgando en los papeles encontré una función de biblioteca de C llamada strtok() (requiere <string.h>) que me despertó curiosidad. Funciona precisamente en casos como éstos, su finalidad es "dividir una cadena en componentes léxicos". Sea la cadena s1, que se quiere dividir en componente léxicos, por medio de un token separador dado por la cadena (no carácter) s2. Entonces la llamada

strtok(s1, s2);

extrae de s1 el primer componente léxico, hasta llegar al token delimitador (o al final de s1 si no se encontró dicho delimitador). La función devuelve una cadena que corresponde al componente extraído. Las llamadas subsiguientes a strtok() deben hacerse con NULL como primer argumento, y de allí en adelante se siguen extrayendo los siguientes componentes de la cadena, devolviendo NULL cuando no existan más de ellos.

En el ejemplo a continuación el usuario introduce cualquier secuencia como "1,2,3,4", y el programa devuelve las distintas divisiones encontradas de la cadena, según el delimitador ","

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
int main() {
 
	char buf[101];
	char *s;
 
	scanf( "%s", buf );
 
	if ( ( s = strtok( buf, ",") ) != NULL )           /* primer componente */
		printf( "%s\n", s );
	while ( ( s = strtok( NULL, ",") ) != NULL )  /* restantes, hasta llegar al final */
		printf( "%s\n", s1 );
}

===========================================
(EDITO)

A propósito del tema, estaba revisando que la función strtok(char* s1, const char *s2) acepta en s2 una cadena donde cualquiera de sus caracteres puede funcionar como delimitador. Esto puede aumentar la potencia del programa, por ejemplo si s2=",." entonces cualquiera de los caracteres coma o punto será un delimitador. El programa con la entrada "1,2.3.4" separará en 1, 2, 3, 4

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
int main() {
 
   char buf[101];
   char *s1;
 
   scanf( "%s", buf );
 
   if ( ( s1 = strtok( buf, ",.") ) != NULL ) 
      printf( "%s\n", s1 );
   while ( ( s1 = strtok( NULL, ",.") ) != NULL ) 
      printf( "%s\n", s1 );
}

NOTA. No funciona el espacio como separador debido a scanf(). Si se reemplaza por fgets() sí lo podría aceptar.

Leo, ¿En serio se me olvidó el return de main()? Jaja, pero que burdo, sorry  !!!

Pero de veras que el programa está divertido, provoca fajarse a jugar contra la máquina, jaja.
Bueno, con las modificaciones que propones (contador de ganadas, perdidas y empatadas), quedaría:

#include <cstdlib>
#include <iostream>
#include <ctime>
 
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 */
   int ganadas, perdidas, empates;
 
   /* 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) );
   ganadas = perdidas = empates = 0;
 
   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 máquina 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;
            ganadas++;
            break;
         case -1:
            cout << "Ups, usted pierde" << endl;
            perdidas++;
            break;
         case 0:
            cout << "Empate" << endl;
            empates++;
            break;
      }
 
      /* Seguir jugando ? */
      cout << ganadas << " ganadas, " << perdidas << " perdidas, " 
         << empates << " empates" << endl << endl;
      cout << "Seguir jugando s/n? ";
      cin >> next;
   } while ( next == 's' );
 
   return 0;
}
 
/* Borra la pantalla */
void clear_screen( void ) {
 
   /* para Windows */
   //system( "cls" );
   /* para Linux */
   system( "clear" );
}

Leo, lo que quiero decir más específicamente es que el totalitarismo de derecha (Pinochet, Franco, Mussolini) y el de izquierda (Stalin, Fidel, Chávez) son lo mismo; al final sólo pisotear y explotar al pueblo. Robar a manos llenas, porque TODOS sin importar su lado político se hacen ricos y amasan enormes fortunas en el exterior, mientras el pueblo pasa trabajo. Aunque seas un profesional, igual no te alcanza para vivir. En Venezuela estamos mal, mal, mal .... la GN reprime y maltrata a la gente, a algunos los han lesionado, quemado, golpeado, secuestrado, perdido un ojo, y otros han perdido la vida. No hay comida. No se puede salir del país porque no hay Aerolíneas (el gobierno les debe una fortuna y suspendieron el servicio) y es un problema para otorgar los dólares o euros. Así que ni soñar con visitar un días las Canarias. Por cierto, ¿cómo es la situación allá? Espero que mejor que aquí, y si pensabas venir algún día a Vzla no lo hagas en este momento porque al saber que eres extranjero capaz y te acusan de agente de la CIA y te llevan preso.

Y agradezco la solidaridad de ustedes los Canarios, yo creo que la cultura Hispana, Canaria y Latinoamericana se parece mucho. Por cierto, ¿Canarios y Españoles peninsulares se llevan bien o mal entre sí?

Respecto al buscaminas pareces adivinar porque justamente tuve que buscar en google ya que se me había olvidado como se jugaba, jaja. Corrí tu programa y perfecto!!!, ahora sólo hace falta la parte dónde se desarrolla el juego en sí, o sea, se van descubriendo las minas. Por eso le pregunté a María si se puede usar getch() ya que en ese caso el juego sería más interactivo y nos podemos ir  desplazando por directamente por las casillas en lugar que estar preguntando coordenadas