Foro de elhacker.net

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:


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

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.

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:

Y de ahi pasarlo a esto:
Siguiendo las normas del juego, seria bueno que imprimiera los pasos que se realizan para ello.

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:

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