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  )

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  
http://blog.tayuyo.com/2007/09/13/sapos-y-ranas/

Un saludo!
Dedicado a MR.FROG  

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

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

#!/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í?

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.

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

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