Tiempo estimado para la presentacin: 15 minutos

Plan de intervencin:
Prez Soria Valtiare Alondra: Presentacin del equipo de trabajo, presentacin
del trabajo a exponer (tema y subtema), objetivo a lograr, introduccin y
explicacin de las reglas del juego. 4 minutos
Cruz Prez Daniela: Exposicin de breve resea histrica del problema,
planteamiento de una pregunta acerca del problema en un caso general y tanto
como su posible solucin y analoga. 3 minutos
Jimnez Garca Alexis: Proceso algortmico para la resolucin del juego
(algoritmo simple), explicacin del proceso algortmico en trminos de
programacin, su complejidad as como el cdigo; y la implementacin en un
ejercicio simple (en el cdigo). 7 minutos
Cruz Prez Daniela: Conclusin y presentacin de referencias. 1 minuto
Medios tcnicos: Computadora, can, presentacin en Power Point, cartel,
IDE de programacin.

JUEGO DE LAS RANAS SALTARINAS

Subtema: Aplicacin de procesos algortmicos con manejo de sucesiones.
Objetivo: Tomado en cuenta la posibilidad de tener n ranas de cada color se
buscar una relacin en el incremento de la los movimientos que estas tendrn
para su intercambio de posiciones y de esa manera se calcular cualquier
trmino de la sucesin de dichos elementos, as como la implementacin de
dicho algoritmo en el campo de la programacin y la complejidad que tendr
este ltimo.
Introduccin:
El juego parte de una tira de papel dividida en siete casillas.
La posicin inicial es la indicada con tres ranas verdes y las tres marrn con un
espacio entre ellas colocadas como en la figura.
El objetivo del juego consiste en permutar las posiciones de las ranas verdes y
marrones. Es decir, las verdes han de pasar a ocupar las posiciones de las
ranas marrn y viceversa. Para ello son vlidos los siguientes movimientos:
1.- Una rana puede moverse a un lugar contiguo, si ste est vaco.
2.-Una rana junto a otra de distinto color puede saltar por encima de ella si el
salto (por encima de una sola rana) le lleva a una casilla vaca.
3.- las ranas de la izquierda solo se pueden mover a la derecha y las de la
derecha solo a la izquierda (no se puede retroceder)

Resea histrica:
No se conoce el origen de este juego. Aparece, con el nombre un juego de
peones, en el libro Rcrations mathmatiques vol.2 (Recreaciones
Matemticas vol. 2) del matemtico francs douard Lucas (1842-1891),
publicado en el ao 1883. En el mismo se estudian las soluciones para los
casos particulares de 2, 3 y 4 fichas de cada color. La verdad es que este
solitario ya aparece desde finales del siglo XIX con una multitud de muy
distintos nombres: frogs and toads -ranas y sapos- (o muchos otros nombres
que mencionan a las ranas, como jumping frogs -ranas saltarinas- o el salto
de la rana, nombre por el que es conocido en castellano), right and left
puzzle, sheeps and goats ovejas y cabras-, etc o no se le asigna nombre
y simplemente se hace uso de sencillas referencias como la de E. Lucas, un
juego de peones.
Problema:
Si tuvisemos n cantidad de ranas de cada color, cul es la mnima cantidad
de movimientos necesarios que se deben realizar para colocar las ranas verdes
en el lado de las ranas marrn y de manera anloga las marrn?
Solucin:
Mediante un algoritmo de fcil implementacin encontrar una frmula general
que nos permita resolver de forma directa la cantidad de movimientos
necesarios a realizar como forma de sucesin cuando tengamos n ranas de
cada color colocadas en el juego.
Analoga: Como lo expuesto en la resea histrica este juego y el algoritmo
prximo a exponer se pueden reflejar en varios juegos de intercambio todos del
tipo right and left puzzle.

ALGORITMO (SIMPLE)
1.- Se identifica en nmero de ranas de cada color
2.-Eleguir que color se mueve primero (verdes o marrones)
3.-El color de rana que comenzara el juego realizara solo un movimiento
4.-Cuando se haga un cambio de color los movimientos de las ranas de cada
color irn aumentando gradualmente (es decir se empieza por ejemplo con un
solo salto de las ranas verdes, despus saltaran 2 ranas marrones, despus 3
ranas verdes y as sucesivamente; siempre que el nmero de las ranas lo
permita).
5.- Si la cantidad de ranas de cada color coincide con la cantidad de
movimientos que debe de realizar en ese instante, se repetir esa cantidad de
movimientos 2 veces ms sin olvidar la intercalacin entre los colores.
6.-Si no, continuar con paso 4.
7.-Si se cumple el paso 5 empezara un decremento de la cantidad de
movimientos que realizaran las ranas de cada color hasta llegar al nmero de
movimientos inicial
Ejemplificacin del algoritmo:
Ranas verdes=V
Ranas marrones=M
Espacio sin rana=0
0.V V V 0 M M M
1.V V V M 0 M M Comienza con un solo movimiento de las ranas marrn
2.V V 0 M V M M Comienza el aumento gradual de movimientos
3.V 0 V M V M M
4.V M V 0 V M M
5.V M V M V 0 M
6.V M V M V M 0 Aqu se cumple la validacin del paso 5
7.V M V M 0 M V Comienzo de la repeticin de la cantidad de movimientos
8.V M 0 M V M V
9.0 M V M V M V
10.M 0 V M V M V
11.M M V 0 V M V
12.M M V M V 0 V Termino paso 5
13.M M V M 0 V V Empieza paso 7
14.M M 0 M V V V
15.M M M 0 V V V Fin del algoritmo

ALGORITMO (PROGRAMACION DEL CODIGO DEL PROBLEMA)

Si bien el algoritmo anterior es una manera simple de ver un intercambio de
posicione o un reordenamiento de objetos; en trminos de programacin este
problema se ve reflejado con una complejidad similar a los llamados problemas
NP completos (Se debe de entender a NP como un grado de complejidad
elevado de problemas en programacin).
Dado a que el algoritmo anteriormente expuesto tiende a poder verse como un
problema en el cual se puede ir resolviendo por medio de una bsqueda de
ramificaciones o mejor dicho uno de un rbol binario; as como la
implementacin de una bsqueda profunda de la solucin.
En el siguiente cdigo se han programado funciones las cuales limitan los
movimientos de los objetos as como la bsqueda de la solucin y permutacin
de los objetos de tal manera que queden en el mismo orden siendo
transpuestos en el lado contrario a su posicin original.
Como se puede observar el ejemplo expuesto es una cadena de 5 nmeros en
el cual nuestro pivote que funge como representante del espacio vaco o
espacio para el intercambio en este caso en nmero cero; se realiza el
intercambio de los dos nmeros de la derecha a la izquierda y los de la
izquierda a la derecha.
As mismo nos da los pasos a realizar; por la estructura del cdigo nos da los
pasos de manera inversa comenzando por la solucin y que pasos hay detrs
de ella.
CODIGO EN C
#include <stdio.h>

#define TRUE 1
#define FALSE 0

int encontrar_solucion(int arreglo[], int size);

void obtener_conjunto_solucion(int arreglo[], int size);
int solo_izquierda(int valor);
int solo_derecha(int valor);
void imprimir_arreglo(int arreglo[], int size);

int conjunto_soluciones[5][5];
int soluciones_parciales;

int main()
{
int arreglo[] = {3, 4, 0, 1, 2};
encontrar_solucion(arreglo, 5);
return 0;
}

int encontrar_solucion(int arreglo[], int size)

{
if (arreglo[0] == 1 &&
arreglo[1] == 2 &&
arreglo[2] == 0 &&
arreglo[3] == 3 &&
arreglo[4] == 4)
{
return TRUE;
}
obtener_conjunto_solucion(arreglo, size);
int total = soluciones_parciales;
int arreglo_soluciones[5][5];
for (int i = 0; i < 5; ++i)
{
for (int j = 0; j < size; ++j)
{
arreglo_soluciones[i][j] = conjunto_soluciones[i][j];
}
}

if (total == 0)
return FALSE;
for (int i = 0; i < total; ++i)
{
//printf("Probando opcion %d: ", i);
//imprimir_arreglo(conjunto_soluciones[i], size);
if (encontrar_solucion(arreglo_soluciones[i], size) == TRUE)
{
printf("Solucion: ");
imprimir_arreglo(arreglo_soluciones[i], size);
return TRUE;
}
//printf("No es encontro solucion, regresando\n");
}
return FALSE;
}

void obtener_conjunto_solucion(int arreglo[], int size)

{
int elemento_vacio = 0;
for (int i = 0; i < size; i++)
{
if (arreglo[i] == 0)
{
elemento_vacio = i;
break;
}
}

soluciones_parciales = 0;

if (elemento_vacio + 2 < size)

{
if (solo_izquierda(arreglo[elemento_vacio + 2]))
{
for (int i = 0; i < size; ++i)
{
conjunto_soluciones[soluciones_parciales][i] = arreglo[i];
}
int temp = conjunto_soluciones[soluciones_parciales]
[elemento_vacio];
conjunto_soluciones[soluciones_parciales][elemento_vacio] =
conjunto_soluciones[soluciones_parciales][
elemento_vacio + 2];
conjunto_soluciones[soluciones_parciales][elemento_vacio + 2] =
temp;
soluciones_parciales++;
}
}

if (elemento_vacio + 1 < size)

{
if (solo_izquierda(arreglo[elemento_vacio + 1]))
{
for (int i = 0; i < size; ++i)
{
conjunto_soluciones[soluciones_parciales][i] = arreglo[i];
}
int temp = conjunto_soluciones[soluciones_parciales]
[elemento_vacio];
conjunto_soluciones[soluciones_parciales][elemento_vacio] =
conjunto_soluciones[soluciones_parciales][
elemento_vacio + 1];

conjunto_soluciones[soluciones_parciales][elemento_vacio + 1] =
temp;
soluciones_parciales++;
}
}
if (elemento_vacio - 1 > 0)
{
if (solo_derecha(arreglo[elemento_vacio - 1]))
{
for (int i = 0; i < size; ++i)
{
conjunto_soluciones[soluciones_parciales][i] = arreglo[i];
}
int temp = conjunto_soluciones[soluciones_parciales]
[elemento_vacio];
conjunto_soluciones[soluciones_parciales][elemento_vacio] =
conjunto_soluciones[soluciones_parciales][
elemento_vacio - 1];
conjunto_soluciones[soluciones_parciales][elemento_vacio - 1] =
temp;
soluciones_parciales++;
}
}
if (elemento_vacio - 2 >= 0)
{
if (solo_derecha(arreglo[elemento_vacio - 2]))
{
for (int i = 0; i < size; ++i)
{
conjunto_soluciones[soluciones_parciales][i] = arreglo[i];
}

int temp = conjunto_soluciones[soluciones_parciales]

[elemento_vacio];
conjunto_soluciones[soluciones_parciales][elemento_vacio] =
conjunto_soluciones[soluciones_parciales][
elemento_vacio - 2];
conjunto_soluciones[soluciones_parciales][elemento_vacio - 2] =
temp;
soluciones_parciales++;
}
}
if (elemento_vacio - 1 >= 0 && elemento_vacio + 1 < size)
{
if (solo_derecha(arreglo[elemento_vacio - 1]) &&
solo_izquierda(arreglo[elemento_vacio + 1]))
{
for (int i = 0; i < size; ++i)
{
conjunto_soluciones[soluciones_parciales][i] = arreglo[i];
}
int temp = conjunto_soluciones[soluciones_parciales]
[elemento_vacio - 1];
conjunto_soluciones[soluciones_parciales][elemento_vacio - 1] =
conjunto_soluciones[soluciones_parciales][
elemento_vacio + 1];
conjunto_soluciones[soluciones_parciales][elemento_vacio + 1] =
temp;
soluciones_parciales++;
}
}
}

int solo_izquierda(int valor)

{

if (valor < 3)
return TRUE;
return FALSE;
}

int solo_derecha(int valor)

{
if (valor > 2)
return TRUE;
return FALSE;
}

void imprimir_arreglo(int arreglo[], int size)

{
for (int i = 0; i < size; i++)
{
printf("%d", arreglo[i]);
}
printf("\n");
}

Numero de ranas

Cantidad de
movimientos

Calculo

(2^2)-1=((1+1)^2)-1

(3^2)-1=((2+1)^2)-1

.
.
.
N

(n^2)-1

CONCLUSIN:
Viendo la relacin que existe entre el nmero de ranas y la cantidad de
movimientos que se deben de realizar para poder realizar el intercambio,
podemos encontrar una frmula general para calcular el ensimo trmino de la
sucesin de movimientos.
Al igual que podemos comprobar que el algoritmo desarrollado es
computacional ya que se puede programar, es cualitativo ya que permiten dar
solucin a casos cotidianos en donde no es necesario utilizar operaciones
matemticas para llegar a dicha solucin. y cuantitativo porque tambin se
puede recurrir a las matemticas para dar solucin al problema.

REFERENCIAS
https://prograyalgo2012.wikispaces.com/Diagrama+de+Flujo
https://revistasuma.es/IMG/pdf/14/050-059.pdf
http://culturacientifica.com/2014/01/15/el-salto-de-la-rana-y-familia/