Las soluciones para el ejercicio pueden postearlas en cualquier lenguaje, no se trata de ver quien acaba antes ni que codigo lo hace en menor tiempo, sino en que salga (solo hay una forma de hacerlo creo :laugh:)
El reto consiste en:
Tenemos un array de 7 elementos, siendo los 3 primeros 1's, el 4 un espacio, y los 3 ultimos 2's, es decir:
1,1,1,espacio,2,2,2
Lo que tenemos que conseguir, es que los 1's acaben en el lugar de los 2's, y viceversa.
Para ello, los 1's solo se pueden mover hacia la derecha, y los 2's a la izquierda.
Solo se puede mover a la casilla siguiente, en caso de que esta este vacía, y si estuviese ocupada por un contrario, a la siguiente de la siguiente, en caso de que este vacia.
Por si alguien no lo entiende bien, este juego es lo mismo, pero cambia los 1's por ranas y los 2's por sapos :xD
http://blog.tayuyo.com/2007/09/13/sapos-y-ranas/ (http://blog.tayuyo.com/2007/09/13/sapos-y-ranas/)
Un saludo!
Dedicado a MR.FROG >:D :laugh:
P.D: El espacio lo podeis representar como un 0, o como os venga en gana, la salida deberia de quedar
2,2,2,espacio,1,1,1
P.D2 : Los que lo resolvais primero por el juego, no hagais esos movimientos en el programa :¬¬ , intentad hacerlo generico (para mas tamaños)
Lo se, me explico como el culo
Con BFS sale... cada vertice es un estado del juego, los adyacentes son cada posible jugada valida... mas tarde veo si lo codeo... ahora no entiendo para que una entrada... si es fija...
Si, me hago un poco el lio explicando jajaja
La profesora de matematicas nos dijo que como mejor se resolvia era con grafos, pero como estamos en 2º de bachiller, no damos eso, dijo que haber quien lo resolvia con los menores pasos posibles jaja
Ya tengo los movimientos del juego voy a hacer a ver si se puede con 4 en cada lado
PD:Una vez que extraes los movimientos lo puedes hacer para X numeros a cada lado, solo que cada vez son mas movimientos con 4 son 25 (Incluyo el estado inicial de 1111 2222)
#!/usr/bin/env python
#Ranas y sapos
#Autor: pablomi
def mover(x):
if array[x]==1:
if array[x+1]==0:
array[x+1] = 1
elif array[x+2]==0:
array[x+2] = 1
elif array[x]==2:
if array[x-1]==0:
array[x-1] = 2
elif array[x-2]==0:
array[x-2] = 2
array[x] = 0
array = [1,1,1,0,2,2,2]
movimientos = "245310246531243"
print "Antes: %s" % array
for x in movimientos:
mover(int(x))
print "Despues: %s" % array
¿Vale así? :laugh:
Si que vale pero dice que no se haga para el ejemplo que pone sino mas generico.
Cita de: guru6 en 21 Diciembre 2010, 15:16 PM
Si, me hago un poco el lio explicando jajaja
La profesora de matematicas nos dijo que como mejor se resolvia era con grafos, pero como estamos en 2º de bachiller, no damos eso, dijo que haber quien lo resolvia con los menores pasos posibles jaja
Entonces mas bien es una tarea, no un reto como tal. :¬¬
Pero es interesante crear un algoritmo para resolverlo. Recuerdo que la primera vez lo resolví en 10 segundos, la segunda vez ya no recordaba como xD.
Ahora me has dado algo en que pasar el tiempo.
@pablomi
:xD tramposo
Segun creo entender, en el argumento de la funcion a realizar deberiamos incluir el numero (impar) de posiciones posibles, si fuera 9 seria:
1,1,1,1,0,2,2,2,2Y de ahi pasarlo a esto:
2,2,2,2,0,1,1,1,1Siguiendo las normas del juego, seria bueno que imprimiera los pasos que se realizan para ello.
Cita de: Darhius en 21 Diciembre 2010, 21:30 PM
Entonces mas bien es una tarea, no un reto como tal. :¬¬
No es para nada deberes ni nada parecido (lo digo porque va a mi mismo instituto)
DoEvents! :P
Esta sería la serie de movimientos para 4 elementos de cada tipo:
1111 2222 avance (1)
111 12222 salto (2)
11121 222 avance (2)
111212 22 salto (1)
1112 2122 salto (1)
11 212122 avance (1)
1 1212122 salto (2)
121 12122 salto (2)
12121 122 salto (2)
1212121 2 avance (2)
12121212 salto (1)
121212 21 salto (1)
1212 2121 salto (1)
12 212121 salto (1)
21212121 avance (2)
2 1212121 salto (2)
221 12121 salto (2)
22121 121 salto (2)
2212121 1 avance (1)
221212 11 salto (1)
2212 2111 salto (1)
22 212111 avance (2)
222 12111 salto (2)
22221 111 avance (1)
2222 1111
Basandonos en las regularidades que se presentan se puede hacer un par de algoritmos...
Para mañana les traigo uno implementado en C
Saludos ;D
¿Sería algo parecido a las torres de Hanoi?.
Por cierto, :xD
sList = [1,1,1,1,0,2,2,2,2]
print sList
sList.reverse()
print sList
Era joda...
ajam, hay cierto parecido. En ambos problemas se tienen que realizar movimientos con ciertas restricciones :)
Bueno como lo prometido es deuda aqui esta el código.
#include <stdio.h>
#define MAX_ELEM 1000
void permutar(char *a,char *b)
{
char temp=*a;
*a=*b;
*b=temp;
}
int main(void)
{
int i,diravance=1,dirsalto=1,csaltos=1,saltos=1,incsaltos=1,ne,te,uesp,des=-1;
char a[MAX_ELEM];
/* leer la cantidad de elementos de cada tipo */
scanf("%d",&ne);
/* establecer la posicion inicial de los 1's y 2's */
te=2*ne+1;
for(i=0;i<te;i++)
a[i]=(i<ne)?'1':'2';
a[ne]=' ';
a[te]='\0';
uesp=ne;
puts(a);
/* efectuar los cambios en el arreglo */
while(csaltos>=0)
{
permutar(&a[uesp],&a[uesp+des]);
uesp+=des;
puts(a);
/* determinar siguiente movimiento */
if(saltos)
{
des=dirsalto*2;
saltos--;
}
else
{
des=diravance;
saltos=(csaltos+=incsaltos);
dirsalto*=-1;
diravance*=-1;
}
/* hacer el ajuste necesario luego de la mitad del total de movimientos */
if(saltos>=ne||ne==1)
{
incsaltos=-1;
diravance=-diravance;
}
}
return 0;
}
Que tengan unas felices fiestas!
Saludos :)
EDIT: Para no hacer doble post