FASE - 6 1

PASO 6 – CONSTRUCCIÓN COLABORATIVA

PRESENTADO POR:

OSCAR JAVIER PARDO GALLEGO. CODIGO: 79858975

KAREN LIZETH VILLAMIL. CODIGO: 1233695732

LAURA VALENTINA ALVARADO. CODIGO: 1049655470

LIBARDO PAIPA HUERTAS. CODIGO: 1002710158

PRESENTADO A: JUAN MONROY

GRUPO: 203036_97

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA

PROGRAMA DE ELECTRONICA ANALOGA

NOVIEMBRE - 2019
FASE - 6 2

CONTENIDO
INTRODUCCIÓN......................................................................................................................3

OBJETIVOS...............................................................................................................................4

General:...................................................................................................................................4

Específicos:.............................................................................................................................4

PROBLEMA...............................................................................................................................5

ACTIVIDAD COLABORATIVA A DESARROLLAR............................................................6

ALGORITO DEL JUEGO..........................................................................................................6

PANTALLAZOS DE LA EJECUCIÓN DEL CÓDIGO EN SCILAB....................................17

CONCLUSIONES....................................................................................................................26

BIBLIOGRAFIA......................................................................................................................27
FASE - 6 3

INTRODUCCIÓN

En este trabajo colaborativo elegiremos un algoritmo de los presentados para desarrollar el paso

6.

En este caso elegimos el algoritmo de nuestro compañero Oscar el cual se caracteriza por tener

bucles, arreglos, funciones, definición de matices, etc.

Lo que nos permite hacer un código más desarrollado y que llegue a la solución del problema

planteado.

Para el desarrollo del código utilizamos Scilab o Matlab ya que sus funciones nos permiten

operar matrices, números aleatorios, vectores y esto es lo que necesitamos para el desarrollo del

juego propuesto en la guía de actividades.

Este programa, maneja varias funciones que aplicaremos el código como bucles, funciones y

además que permita cumplir con todas las condiciones necesarias para el desarrollo del

problema.

En conclusión, este trabajo está diseñado para dar solución al problema planteado y así

desarrollar el código que de la solución correcta.

FASE - 6 4

OBJETIVOS

General:

Escoger el algoritmo más acertado para desarrollar el código en scilab o Matlab.

Específicos:

 Describir las características de la solución diseñada

 Realizar un algoritmo (diagrama de flujo ó pseudocódigo) de la solución del problema

planteado

 Emplear el código fuente de la solución del problema

 Anexar las capturas de pantalla del funcionamiento del aplicativo

FASE - 6 5

PROBLEMA

Una empresa de juegos didácticos virtuales, quieren implementar un juego de rompecabezas

numérico, junto con sus respectivas reglas de puntuación, para ello es necesario diseñar un

aplicativo que genere una matriz de números aleatorio de 3x3 donde se almacenen 8 números

entero consecutivos y le dé la posibilidad al usuario de:

 Establecer el primer número de los ocho posibles a almacenar, (los demás serán
consecutivos).
 El usuario debe poder determinar cómo mover la casilla vacía, indicando si el
movimiento lo hace hacia arriba ó abajo, derecha ó izquierda.
 Tener la opción de no continuar con el armado del rompecabezas.
 Decidir si el armado lo dese hacer horizontal o vertical.
 Leer las reglas de la puntuación con la que se valorará su desarrollo.

Una vez el usuario termine de ordenar el rompecabezas o haya decidido no continuar con el

armado, el aplicativo debe:

 Indicar la cantidad de movimientos realizados

 Puntuación obtenida
El aplicativo, en su funcionamiento debe cumplir con las siguientes características:

 Permitir el movimiento de una celda a la vez.

 En los bordes de la matriz restringir los movimientos, es decir que de la última columna
no es posible desplazarse a la primera o viceversa, igual con las filas, de la primera fila
no es posible llegar a la última y viceversa.
 Mostar solo una matriz en pantalla, ir actualizándola a medida que se van realizando los
movimientos, para dar la sensación de desplazamiento de los números.
 Cuando logre ordenar el rompecabezas informarle al usuario que lo terminó.

ACTIVIDAD COLABORATIVA A DESARROLLAR

 Leer el problema a resolver

 Retomar los algoritmos propuestos en el paso anterior y seleccionar el que van a emplear
para la codificación.
FASE - 6 6

 Con base en el algoritmo seleccionado, desarrollar el código fuente en Matlab o Scilab,

que dé solución al problema planteado en el curso, para realizarlo retome: La propuesta
metodológica planteada por ustedes en los pasos anteriores y la información recopilada

ALGORITO DEL JUEGO

//Primero mostraremos una pantalla con las reglas del juego, y puntuación

Inicio()

function inicio(){

Printf “¿QUIERES JUGAR ROMPECOCOS? \n”

$ir =0

While $ir =0

Printf(‘Selecciona una opción\n:

1. Jugar\n
2. Instrucciones del juego\n’)
$opc = INPUT (‘’)

switch $opc

case 1

jugar()

$ir =1

case 2

Instrucciones()

$ir =1

default

$ir=0

}
FASE - 6 7

function Instrucciones(){

Printf(‘

1. Objetivo del juego: Armar los números del rompecabezas en orden

consecutivo en la menor cantidad de jugadas posible.
2. El jugador escoge el número inicial y decide armar el rompecabezas ya sea de
forma vertical u horizontal.
3. La casilla vacía se puede mover hacia arriba digitando “8”, abajo con el 2 ,
izquierda con el 4 o derecha con el 6 para organizar los números.
4. El jugador comenzará el juego con 10.000 puntos cada vez que haga una
movida perderá 200 puntos. Si hace más de 50 movidas perderá el juego.
5. Al armar el rompecabezas recibirá el puntaje obtenido y la cantidad de
movimientos realizados
’)

$ir=0

While $ir =0

$jugar=INPUT(‘Jugar? Ingrese 1 \n Salir? Ingrese 2’)

SWITCH

case 1

jugar()

$ir =1

case 2

Inicio()

$ir =1

default

$ir=0

end

}
FASE - 6 8

function jugar(){

Printf(‘ROMPECOCOS’)

Printf (“Ingrese un número” )

INPUT $PRIMERO

Printf “ Cómo desea organizar el rompecabezas?:\n

1- HORIZONTAL -2- VERTICAL”

INPUT $orden

$FINAL = $PRIMERO+8

$puntaje= 10000

//creo un vector con 9 números aleatorios que NO SE REPITAN. El número 9 será el

espacio “X” que asignaremos más adelante

vec=grand(1,'prm',($PRIMERO:$FINAL)’)

//organizo estos números en una matriz de 3 x 3

matRompe=matrix(vec,3,3)

//si el orden es vertical, realizo una transpuesta de la matriz

If $orden==2

MatRompe=( MatRompe’)

/*Convertir los elementos de la matriz en texto para poder reemplazar el último número
por una X*/
MatRompe = string(MatRompe)

//ordenar el vector inicial en orden para verificar que la matriz esté ordenada cuando

avance el juego

ordenado=gsort(vec,g,i)
FASE - 6 9

/*Busco la posición en la matriz que coincida con el último número de la serie y

reemplazo por “X”,

así tendremos la matriz para iniciar el juego*/

$blanca=ordenado(9)

For i=1:3

For j=1:3

If matRompe(i,j)==$FINAL then

matRompe(i,j)=$blanca

end

end

//convierto en texto los elementos del vector ordenado y reemplazo por una X el valor

del último elemento

ordenado=string(ordenado)

ordenado(9)= $blanca

//crear una matriz ordenada de acuerdo a la dirección que determinó el usuario

matOrdenada=(ordenado,3,3)

//Mostrar en pantalla matriz inicial del juego (matRompe)

Disp(matRompe)

//Iniciar contador de jugadas

$CONTADOR=0
FASE - 6 10

// Encontrar la posición de X en la matriz

For i=1:3

For j=1:3

If matRompe(i,j)==’X’ then

posXi=i

posXj=j

end

end

//Función mostrar los comandos en pantalla

$COMANDOS (matRompe ,posXi, posXj, matOrdenada)

FUNCION $COMANDOS (matriz, posXi, posXj, matOr)

matOrden= matOr

matRom=matriz;

der=0; izq=0 ; aba=0; arr=0

switch posXi

case 1

aba=1

case 2

aba=1

arr=1

case 3

arr=1
FASE - 6 11

switch posXj

case 1

der=1

case 2

izq=1

der=1

case 3

izq=1

Print “Ingrese un número para mover X: \n IZQ (1) DER (2) ARRIBA (3) ABAJO

(4) SALIR (5) \n”

OPC=INPUT(‘’)

//Mientras el movimiento no sea válido o el número ingresado este mal

$orden=0

while $orden==0

switch OPC

case 1

If izq==1

MoverIZQ(matRom , posXi, posXj, matOrden)

$orden=1

Else

$error= “No puedes mover hacia la izquierda”

printf(‘$error’)
FASE - 6 12

case 2

If der==1

MoverDER(matRom ,posXi, posXj, matOrden)

$orden=1

Else

$error= “No puedes mover hacia la derecha”

printf(‘$error’)

case 3

If arr==1

MoverARR(matRom ,posXi, posXj, matOrden)

$orden=1

Else

$error= “No puedes mover hacia arriba”

printf(‘$error’)

case 4

If aba==1

MoverABA(matRom ,posXi, posXj, matOrden)

$orden=1

Else

$error= “No puedes mover hacia abajo”

printf(‘$error’)
FASE - 6 13

case 5

salir()

default

$error= “Ingrese un numero válido”

printf(‘$error’)

Function moverARR(matriz , posXi, posXj, matOr)

matRompe=matriz

matOrdenada=matOr

i = posXi

j= posXj

$blanco= matRompe(i,j)

$nvaPosicion= matRompe(i-1,j)

//borrar pantalla

clc;

matRompe(i,j)= $nvaPosicion

matRompe(i-1,j)= $blanco

disp(matRompe)

$CONTADOR++

$puntaje = $puntaje - 200

verificar(matRompe,i-1,j, matOrdenada, $puntaje)

FASE - 6 14

Function moverABA(matriz ,posXi, posXj,matOr)

matOrdenada=matOr

matRompe=matriz

i = posXi

j= posXj

$blanco= matRompe(i,j)

$nvaPosicion= matRompe(i+1,j)

//borrar pantalla

clc;

matRompe(i,j)= $nvaPosicion

matRompe(i+1,j)= $blanco

disp(matRompe)

$CONTADOR++

$puntaje = $puntaje - 200

verificar(matRompe,i+1,j, matOrdenada, $puntaje)

Function moverIZQ(matriz,posXi, posXj, matOr)

matRompe=matriz

matOrdenada=matOr

i = posXi

j= posXj

$blanco= matRompe(i,j)

$nvaPosicion= matRompe(i,j-1)
FASE - 6 15

//borrar pantalla

clc;

matRompe(i,j)= $nvaPosicion

matRompe(i,j-1)= $blanco

disp(matRompe)

$CONTADOR++

$puntaje = $puntaje - 200

verificar(matRompe,i,j-1, matOrdenada, $puntaje)

Function moverDER(matriz,posXi, posXj, matOr)

matRompe=matriz

matOrdenada=matOr

i = posXi

j= posXj

$blanco= matRompe(i,j)

$nvaPosicion= matRompe(i,j+1)

//borrar pantalla

clc;

matRompe(i,j)= $nvaPosicion

matRompe(i,j+1)= $blanco

disp(matRompe)

$CONTADOR++

$puntaje = $puntaje - 200

FASE - 6 16

verificar(matRompe,i+1,j, matOrdenad, $puntaje)

Function Verificar(matriz,i,j,matrO){

IF $puntaje<= 0

Printf ‘(Tu puntaje quedó en 0. Game over’)

IF [matriz == matrO] then

Felicidades, has terminado el juego

Printf(‘Tu puntaje: d%‘,$puntaje)

OPC =INPUT(‘Ingresa 1 para Volver a jugar,2 para salir del juego’ )

IF OPC==1 then

Inicio()

IF opc==2

SALIR()

Función SALIR

Printf (“Game Over”)

Inicio()
FASE - 6 17

PANTALLAZOS DE LA EJECUCIÓN DEL CÓDIGO EN SCILAB

FASE - 6 18
FASE - 6 19
FASE - 6 20
FASE - 6 21
FASE - 6 22
FASE - 6 23
FASE - 6 24
FASE - 6 25
FASE - 6 26
FASE - 6 27
FASE - 6 28
FASE - 6 29
FASE - 6 30
FASE - 6 31

CONCLUSIONES

 Se escogió el algoritmo más acertado para desarrollar el código en scilab.

 Se describieron las características de la solución diseñada.

 Se realizó un algoritmo para la solución del problema planteado.

 Se empleó un código fuente para la solución del problema.

 Se anexaron las capturas de pantalla del funcionamiento del aplicativo.

FASE - 6 32

BIBLIOGRAFIA

 Scott Hudson (2014).  Scilab Lectures. Pág. 9-16. Recuperado

de http://users.tricity.wsu.edu/~hudson/Teaching/EE221/Text/03%20Programming
%20structures.pdf

 Hahn, B. D., & Valentine, D. T. (2013). Essential MATLAB for Engineers and Scientists
(Vol. Fifth edition). Waltham, MA: Academic Press. Capítulo 5. Pág. 111-129.
Recuperado de http://bibliotecavirtual.unad.edu.co/login?
url=http://search.ebscohost.com/login.aspx?
direct=true&db=nlebk&AN=485981&lang=es&site=eds-live

 Gil, R. M. (2003). Introducción rápida a Matlab y Simulink para ciencia e ingeniería.

Madrid, ES: Ediciones Díaz de Santos. Capítulo 3. pág. 38-40. Recuperado
de http://bibliotecavirtual.unad.edu.co:2077/lib/unadsp/reader.action?
ppg=1&docID=11059428&tm=1479848795401

Otros recursos:

 Manual Scilab
 Comando help + función que queremos utilizar

OVA

 Matrices ing. Stephen Guseph Pinto Morato para el manejo de matrices en Scilab
https://www.youtube.com/watch?v=ma6ia3iaenc

 Random Numbers in Matlab https://www.youtube.com/watch?v=2qP8OWy426U

clc;
clear
contador=0
puntaje=12000

function jugar()
printf('\n****** ROMPECOCOS ****** \n\n')
contador=0
puntaje=12000
primero = input ('Ingresa un número: ')
printf (' ¿Cómo deseas organizar el rompecabezas?:\n 1- HORIZONTAL \n 2- VERTICAL\n' )

orden=input('')
FASE - 6 33

final= primero+8

//creo un vector con 9 números aleatorios que NO SE REPITAN. El número 9 será el espacio “X” que asignaremos más
adelante
vec=grand(1,'prm',(primero:final))
//ordenar el vector inicial en orden para verificar que la matriz esté ordenada cuando avance el juego
ordenado=gsort(vec,'g','i')

//crear una matriz ordenada de acuerdo a la dirección que determinó el usuario

matOrdenada=matrix(ordenado,3,3)
matOrdenada=string(matOrdenada)
matOrdenada(3,3)='☻'
if orden==2
disp('orden es vertical')
matOrdenada=(matOrdenada)'
disp('revertical')
end
disp(matOrdenada')

//Busco la posición en el vector que coincida con el último número de la// serie y reemplazo por un carácter especial,
//así tendremos la matriz para iniciar el juego

casilla=string(final)
//disp(casilla)
vec = string(vec)
for i=1:9

if vec(i)==casilla then

vec(i)='☻';
end

end

//organizo estos números en una matriz de 3 x 3

matRompe=matrix(vec,3,3)
clc;
disp(matRompe)

/*Mostrar en pantalla matriz inicial del juego (matRompe)

Disp(matRompe)*/
//Iniciar contador de jugadas
contador=0
// Encontrar la posición de X en la matriz
for i=1:3
for j=1:3
if matRompe(i,j)=='☻'
posXi=i
posXj=j
end
end
end
comandos (matRompe ,posXi, posXj, matOrdenada)
FASE - 6 34

endfunction

function comandos(matriz, posXi, posXj, matOr)

matOrden= matOr
matRom=matriz;
der=0; izq=0 ; aba=0; arr=0
switch posXi
case 1
aba=1
case 2
aba=1
arr=1
case 3
arr=1
end

switch posXj
case 1
der=1
case 2
izq=1
der=1
case 3
izq=1
end
orden=0
while orden==0

printf ('Ingresa un número para mover ☻: \n IZQ (1) DER (2) ARRIBA (3) ABAJO (4) SALIR (5) \n')
opc=input('')
//Mientras el movimiento no sea válido o el número ingresado este mal

switch opc
case 1
if izq==1 then
MoverIZQ(matRom , posXi, posXj, matOrden)
orden=1

else
error1= 'No puedes mover hacia la izquierda'
printf(error1)
orden=0
end

case 2
if der==1 then
MoverDER(matRom ,posXi, posXj, matOrden)
orden=1
else
error2= 'No puedes mover hacia la derecha'
printf(error2)
orden=0
end
case 3
if arr==1 then
MoverARR(matRom ,posXi, posXj, matOrden)
orden=1
FASE - 6 35

else
error3= 'No puedes mover hacia arriba'
printf(error3)
orden=0
end

case 4
if aba==1 then
MoverABA(matRom ,posXi, posXj, matOrden)
orden=1
else
error4= 'No puedes mover hacia abajo'
printf(error4)
orden=0
end
case 5
salir()
otherwise
error5= 'Ingresa un numero válido'
printf(error5)
orden=0
end
end

endfunction

function MoverIZQ(matriz, posXi, posXj, matOr)

printf('Mover Izquierda')
matRompe=matriz
matOrdenada=matOr
i = posXi
j= posXj
blanco= '☻'
nvaPosicion= matRompe(i,j-1)
//borrar pantalla
clc;
matRompe(i,j)= nvaPosicion
matRompe(i,j-1)= blanco
disp(matRompe);
contador =contador+1
puntaje = puntaje - 200
verificar(matRompe,i,j-1, matOrdenada, puntaje)

endfunction

function MoverARR(matriz, posXi, posXj, matOr)

matRompe=matriz
matOrdenada=matOr
i = posXi
j= posXj
blanco= '☻'
nvaPosicion= matRompe(i-1,j)
//borrar pantalla
clc;
matRompe(i,j)= nvaPosicion
matRompe(i-1,j)= blanco
disp(matRompe);
contador =contador+1
puntaje = puntaje - 200
FASE - 6 36

verificar(matRompe,i-1,j, matOrdenada, puntaje)

endfunction

function MoverDER(matriz, posXi, posXj, matOr)

printf('Mover Derecha')
matRompe=matriz
matOrdenada=matOr
i = posXi
j= posXj
blanco= '☻'
nvaPosicion= matRompe(i,j+1)
//borrar pantalla
clc;
matRompe(i,j)= nvaPosicion
matRompe(i,j+1)= blanco
disp(matRompe);
contador =contador+1
puntaje = puntaje - 200
verificar(matRompe,i,j+1, matOrdenada, puntaje)

endfunction

function MoverABA(matriz, posXi, posXj, matOr)

printf('Mover Abajo')

matRompe=matriz
matOrdenada=matOr
i = posXi
j= posXj
blanco= '☻'
nvaPosicion= matRompe(i+1,j)
//borrar pantalla
clc;
matRompe(i,j)= nvaPosicion
matRompe(i+1,j)= blanco
disp(matRompe);
contador =contador+1
puntaje = puntaje - 200

verificar(matRompe,i+1,j, matOrdenada, puntaje)

endfunction

function verificar(matriz, i, j, matrO, punt)

printf('te quedan %d puntos',punt)
// disp('la matriz ordenada:')
// disp (matrO)
if [matriz == matrO]
printf ('Felicidades, has terminado el juego')
printf('Tu puntaje: %d',puntaje)
preguntar()
else
if puntaje<= 0
disp ('Tu puntaje quedó en 0. Game over')
input('')
preguntar()
end
FASE - 6 37

end

comandos (matriz, i, j, matrO)

endfunction
function preguntar()
opc =input('Ingresa 1 para volver a jugar,2 para salir del juego' )
if opc==1
inicio()
end
if opc==2
salir()
end
endfunction

function instrucciones()
clc;
printf('INSTRUCCIONES DEL JUEGO:\n')

printf('1. Objetivo del juego: Armar los números del rompecabezas en orden consecutivo en la menor cantidad de
jugadas posible.\n 2. El jugador escoge el número inicial y decide armar el rompecabezas ya sea de forma vertical u
horizontal.\n 3. La casilla vacía se puede mover hacia arriba digitando “8”, abajo con el 2 , izquierda con el 4 o derecha
con el 6 para organizar los números.\n 4. El jugador comenzará el juego con 10.000 puntos cada vez que haga una
movida perderá 200 puntos. Si hace más de 50 movidas perderá el juego. \n 5. Al armar el rompecabezas recibirá el
puntaje obtenido y la cantidad de movimientos realizados')
ir=0
while ir ==0 then
jugar=input('Para jugar Ingrese 1 \n Para salir ingrese 2')
switch jugar
case 1
jugar()
ir =1
case 2
inicio()
ir =1
otherwise
ir=0
end
end

endfunction
function salir()
printf('Juego Terminado')
inicio()
endfunction

function inicio()
clc;
ir =0
while ir ==0 then
printf('************************')
printf('****** ROMPECOCOS ******\n\4n')
printf('Selecciona una opción:\n1. Jugar\n 2.Instrucciones del juego\')
opc = input('')
switch opc
case 1
FASE - 6 38

jugar()
ir =1
case 2
instrucciones()
ir =1
otherwise
ir=0
end
end
endfunction
inicio()