#include <stdio.h>
#include <stdlib.h>
 
void matriz_a_inicial (int a [][3]);
int main (){
    int a[3][3];
    matriz_a_inicial (a);
    return 0;
}
 
void matriz_a_inicial (int  a [][3]){
    a [3][3]={{1,2,3},{4,5,6},{7,8,9}};
}
 

He tenido que crear un tema nuevo porque el autor del tema original, tan simpático él, le cambio el nombre al tema que se encuentra ahora en

http://foro.elhacker.net/programacion_cc/portafolium_set_my_name_for_the_example_yes_i_from_colombia-t390785.0.html

La verdad es que el reto era curioso, lamentablemente estaba algo indefinido, como ya comenté en otro post anterior.

Así que decidí poner yo las condiciones que faltaban:

* Rellenamos una matriz de 10x10 de manera aleatoria con números entre 1 y 1000.

* Se comienza, lo que acabará siendo un juego en modo consola, por situarnos en la casilla del número el mínimo de la matriz.

* A partir de ahí nos movemos hacia la casilla que le rodee y que contenga al mayor número, poniendo un cero en la casilla que se abandona.

* Si está rodeado de ceros el movimiento será  al máximo de los números que queden en la matriz y siempre dejando un cero en la casilla que se deja.

* Así se continúa hasta que todos los elementos sean cero.

Por ahora el movimiento lo realiza el ordenador, aunque espera un Enter para que el usuario pueda localizar la casilla. En cambio, en la próxima "entrega" el juego será más interactivo, ya que el usuario tendrá que entrar las coordenadas de la casilla a la que tiene que moverse, y en función de los intentos fallidos y el tiempo empleado se le puntuará. Y será aún con más color. Todo es cuestión de encontrar tiempo para su desarrollo. Y aún quedará el reto de controlar el ratón para mediante él seleccionar la casilla, aunque esto lleva más conocimientos de Api y/o ensamblador de los que tengo en estos momentos. Pero todo se andará.   y si alguien esta "curtido" en el control del ratón con las API agradecería me pasará información al respecto.

El reto en sí es hacerlo todo mediante un código simple y, lo más importante, sin usar librerías gráficas, todo en C puro y duro.

Por ahora dejo lo explicado anteriormente y para a quienes le queden dudas de cómo funciona el futuro juego, por cierto bautizado como "Matrisan", les dejo un enlace donde se ve en acción:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
 
/***************  FUNCIONES  ***********/
 
int color (int n);
int mover (int i_mov, int j_mov, int matriz[10][10], int pendiente);
void rellenar_matriz (int i_mov, int j_mov, int matriz[10][10]);
void calculo_maximo (int matriz [10][10], int* i_max,int* j_max);
 
/***************  MAIN  ***********/
 
int main()
{
    //system("color 70");
    srand(time(NULL));
	int n,matriz[10][10]={0}, i=rand()%10+1, j=0,pendiente=0, x, y,minimo=10001,i_min=0,j_min=0;
 
/***************  CALCULO  DEL MINIMO  ***********/
 
	do{
 
		x=rand()%10;
		y=rand()%10;
		if(matriz[x][y]==0 ){
            matriz[x][y]=i;
            if (i<minimo)
            {
                minimo=i;
                i_min=x;
                j_min=y;
            }
        i+=rand()%18+1;
        j++;
        }
	}while (j<100);
 
/***************  IMPRESION CON COLOR  ***********/
 
    for(i=0;i<10;i++)
	{
        putchar('\n');
		for(j=0;j<10;j++)
        {
            if (i==i_min && j==j_min)
                n=228;
            else
                n=113;
            color (n);
            printf(" %d", matriz[i][j]);
            color (7);
            printf("\t");
        }
	}
    color (96);
    printf("\n\nminimo = %d en la posicion ",minimo);
    color (228);
    printf(" (%d,%d) \n",i_min+1,j_min+1);
    color (7);
    matriz[i_min][j_min] = 0;
    mover (i_min, j_min, matriz,  pendiente);
    return 0;
}
int color (int n)
{
        SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
}
 
/***************  FUNCION COLOR  ***********/
 
int mover (int i_mov, int j_mov, int matriz[10][10], int pendiente)
{
    color (7);
    int n=0,i=0,j=0,maximo=0,maximo2=0,i_max=0,j_max=0,x,y;
 
    if (pendiente==100)
    {
        color (228);
        printf("\n\t\t\t\t\tACABO\t\t\t\t\t\n");
        color (7);
        return 1;
    }
 
    else
    {
        for ( i=i_mov-1; i<=i_mov+1; i++)
        {
            for ( j=j_mov-1; j<=j_mov+1; j++)
                {
                    if ( i < 0 || j < 0 || i > 9 || j > 9)
                        continue;
                    else
                    {
                        if (matriz[i][j] > maximo )
                        {
                            maximo = matriz[i][j];
                            i_max = i;
                            j_max = j;
                        }
                    }
                }
        }
   if (maximo==0)
        {
            for (x=0;x<10;x++)
                for (y=0;y<10;y++)
                {
                    if (matriz[x][y]>maximo)
                    {
                        maximo = matriz[x][y];
                        i_max = x;
                        j_max = y;
                    }
                }
        }
    }
    color (96);
    printf("\nMaximo = %d en la posicion ",maximo);
    color (228);
    printf(" (%d,%d) \n",i_max+1,j_max+1);
    color (7);
    //puts ("color");
 
    pendiente++;
    //rellenar_matriz ( i_mov,  j_mov,  matriz[10][10]);
 
    /***************  IMPRESION CON COLOR  ***********/
 
     for(i=0;i<10;i++)
	{
        putchar('\n');
		for(j=0;j<10;j++)
        {
            if (i==i_max && j==j_max)
                n=228;
            if (i==i_mov && j==j_mov)
                n=86;
            else if (matriz[i][j]==0)
                n=125;
            else
                n=113;
            color (n);
            printf(" %d ", matriz[i][j]);
            color (7);
            printf("\t");
        }
	}
    //color (113);
    matriz[i_max][j_max] = 0;
    system("pause");
    system("cls");
    mover (i_max, j_max, matriz,  pendiente);
}
 
/***************  X  ***********/
 
 

No salen los 256 porque no cabían en la pantalla.   Y el código con el cual he generado la tabla anterior:

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
 
int color (int n);
 
int main()
{
    int n=0,matriz[10][30]={0}, i, j;
    for(i=0;i<9;i++)
	{
        for(j=0;j<30 && n<256 ;j++,n++)
        {
           if (j%10==0  )
                printf ("\n");
            matriz[i][j]=n;
            color (n);
            printf("  %d  ", matriz[i][j]);
            color (7);
            printf("\t");
        }
	}
    system("pause");
    return 0;
}
 
int color (int n)
{
        SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
}
 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
struct lista_elementos
{
char elem[40];
struct lista_elementos *sig;
struct lista_elementos *ant;
};
 
typedef struct lista_elementos nodo;
 
void crear(nodo *registro,nodo *fin,nodo *anterior);
void mostrar_abajo(nodo *pt);
void mostrar_arriba(nodo *pt);
 
int main()
{
    nodo *prin,*fin;
    prin=(nodo*)malloc(sizeof(nodo));
    fin=(nodo*)malloc(sizeof(nodo));
    crear(prin,fin,NULL);
    puts("\n");
    mostrar_abajo(prin);
    puts("\n");
    mostrar_arriba(fin);
}
 
void crear(nodo *registro,nodo *fin,nodo *anterior)
{
    printf("Dato (Escribir LEOSANSAN para terminar): ");
    scanf(" %s",registro->elem);
 
    if (strcmp(registro->elem,"LEOSANSAN")==0)
            {
            registro->sig=NULL;
            registro->ant=anterior;
            fin=registro;
        }
    else
        {
            registro->sig=(nodo*)malloc(sizeof(nodo));
            registro->ant=anterior;
            crear(registro->sig,fin,registro);
        }
}
 
void mostrar_abajo(nodo *pt)
{
    if (pt->sig!=NULL)
        {
            printf("%s  ",pt->elem);
            mostrar_abajo(pt->sig);
        }
}
void mostrar_arriba(nodo *pt)
{
   if (pt->ant==NULL)
    printf("%s",pt->elem);
    else
        {
            printf("%s  ",pt->elem);
            mostrar_arriba(pt->ant);
        }
}