int m[3][3] = {0, 2, 0, 0, 0, 0, 0, 0, 3};

Eso es una matriz unidimensional (aunque los arrays n-dimensionales se almacenen por filas) y no entiendo bien tu pregunta...

Simplemente sigue la aritmética de punteros como haces con los arrays unidimensionales.

Y en tu ejemplo recorres la matriz y cuando encuentras esos valores, asignas sus direcciones a los punteros.

Para recorrer una matriz bidimensional con un puntero...

int main () {
	int m[3][3] = { {0, 2, 0},
                        {0, 0, 0},
                        {0, 0, 3}};
	int *p;
	int i, j;
 
	for(i=0; i<3; i++) {
	    p = m[i];
		for(j=0; j<3; j++){
			printf("%d", p[j]);
		}
		printf("\n");
	}
 
	return 0;
 
}

Pero el 3 esta en la ultima posicion de la matriz, cual seria el movimiento que queres hacer?? despues de encontrar el 3 que posicion seria la siguiente para el recorrido??

Saludos

Hola a todos:

Muchas gracias  los que lo habéis intentado, he estado toda la tarde y he podido resolver parte del código, os dejo lo dejo puesto para que lo veáis.

Ahora mi problema surge en otro punto, una vez que el robot llega al "2" no se lo come, si no que se pone a saltarlo de un lado a otro.

Cualquier ayuda sera bienvenida. Gracias a todos.

#include <stdio.h>
#include <stdlib.h>
 
void mostrar(int m[3][3]) {
	int i, j;
 
	for(i=0; i<3; i++){
		for(j=0; j<3; j++){
			printf("%d ", m[i][j]);
		}
		printf("\n");
	}
	printf("\n");
}
void buscar(int m[3][3], int *Xc, int *Yc, int *X1, int *Y1, int *X2, int *Y2, int *X3, int *Y3, int *X4, int *Y4){
	int i,j;
 
	for(i=0; i<3; i++){
		for(j=0; j<3; j++){
			if (m[i][j]==2){
				*Xc = i;
				*Yc = j;
			}
			if (m[i][j]==3){	
				*X1 = i+1;
				*Y1 = j;
				*X2 = i-1;
				*Y2 = j;
				*X3 = i;
				*Y3 = j+1;
				*X4 = i;
				*Y4 = j-1;
			}
		}
	}
 
}
int calcularPasos(int Xc, int Yc, int X, int Y){
	int XT, YT, steps;
 
	if (Xc>=X){
		XT = Xc-X;
	}else if(X>=Xc){
		XT = X-Xc;
	}
	if (Yc>=Y){
		YT = Yc-Y;
	}else if(Y>=Yc){
		YT = Y-Yc;
	}
	steps = XT+YT;
 
	return steps;
}
 
void movimientoTorre(int steps1, int steps2, int steps3, int steps4, int m[3][3]){
	int aux;
	int i, j;
	int *pCaux, *pRaux, *p1aux, *p2aux, *p3aux, *p4aux;
 
	for(i=0; i<3; i++){
		for(j=0; j<3; j++){
			if (m[i][j]==2){
				pCaux = &m[i][j];
			}
			if (m[i][j]==3){
				pRaux = &m[i][j];
				p1aux = &m[i+1][j];	
				p2aux = &m[i-1][j];
				p3aux = &m[i][j+1];
				p4aux = &m[i][j-1];
			}
		}
	}
 
	if(steps1<=steps2 && steps1<=steps3 && steps1<=steps4){
		aux = *p1aux;
		*p1aux = *pRaux;
		*pRaux = aux;
	} else if(steps2<=steps1 && steps2<=steps3 && steps2<=steps4){
		aux = *p2aux;
		*p2aux = *pRaux;
		*pRaux = aux;
	} else if(steps3<=steps2 && steps3<=steps1 && steps3<=steps4){
		aux = *p3aux;
		*p3aux = *pRaux;
		*pRaux = aux;
	} else if(steps4<=steps2 && steps4<=steps3 && steps4<=steps1){
		aux = *p4aux;
		*p4aux = *pRaux;
		*pRaux = aux;
	}
 
 
}
 
int main () {
	int m[3][3] = { {0, 2, 0},
					{0, 0, 0},
					{0, 0, 3}};
	int Xc, Yc, X1, Y1, X2, Y2, X3, Y3, X4, Y4;
	int steps1, steps2, steps3, steps4;
 
	//INICIALIZACION
	mostrar(m);
 
	//BUSCAR
	buscar(m, &Xc, &Yc, &X1, &Y1, &X2, &Y2, &X3, &Y3, &X4, &Y4);
 
	//CALCULAR PASOS
	steps1 = calcularPasos(Xc, Yc, X1, Y1);
	steps2 = calcularPasos(Xc, Yc, X2, Y2);
	steps3 = calcularPasos(Xc, Yc, X3, Y3);
	steps4 = calcularPasos(Xc, Yc, X4, Y4);
 
	//REALIZAR MOVIMIENTO
	movimientoTorre(steps1, steps2, steps3, steps4, m);
 
	//MOSTRAR RESULTADO
	mostrar(m);
 
}

PD: edito el titulo del post para que no haya confusiones.

jack09, perdón por no leer el código pero estoy vago xD. Por otra parte la función buscar es una locura.

Ten en cuenta la siguiente frase: "Si algo es difícil es que está mal". Aunque parezca una tontería a mí me ayuda bastante xD.

Lo necesario para este ejercicio es conocer las coordenadas de 2 y 3. Luego podemos tener:

typedef struct {
	x,y:unsigned int; // matriz
} Punto;
 

Y tener p2 y p3 de tipo Punto. Buscar significa recorrer la matriz y si encontramos a 2, guardar las coordenadas en p2 y, por el contrario, si encontramos a 3, guardamos las coordenadas en p3:

// No es necesario pasar el tamaño de la segunda dimensión porque se infiere por el tipo int y la longitud de la dimensión 1.

void buscar (int m[3][], Punto *p2, *p3) {
 
	int i,j;
 
	for (i = 0; i < 3; i++)
		for (j = 0; j < 3; j++)
			if (m[i][j] == 2) {
				p2->x = i;
				p2->y = j;
			} else if (m[i][j] == 3) {
				p3->x = i;
				p3->y = j;
			}
}
 

Luego, para llegar de 3 a 2 simplemente hay que desplazar p3 hasta p2 teniendo en cuenta las filas y las columnas y que nos acercamos a p2 hasta encontrarnos con él. La primera componente de la matriz identifica a las filas de las mismas y la segunda a las columnas.

No he leído el código de leosansan pero creo que está bien.

¡Suerte!