HERRAMIENTAS INFORMÁTICAS PARA LAS

MATEMÁTICAS
David Martín Bermúdez
22 de enero de 2018

Índice
1. Primera parte sobre generación de contraseñas 2
1.1. Solución ejercicio 2.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.1. Ejemplo 2.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2. Solución ejercicio 2.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.1. Capacidades de la solución planteada . . . . . . . . . . . . . . . . 5
1.2.2. Ejemplo 2.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2. Segunda parte sobre la resolución de pasatiempos 8

2.1. Solucion ejercicio 2.3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2. Solucion ejercicio 2.4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3. Solucion ejercicio 2.5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

1
 1. Primera parte sobre generación de contraseñas
El siguiente código en Scilab, disponible en el archivo “genera_contrasegna_tres_caracteres_T2.sce”,
se ha programado con el objetivo de generar una contraseña de tres caracteres a partir de una
palabra clave que tiene el mismo número de caracteres que la contraseña. Observe que la
contraseña se elige aleatoriamente (por sorteo) entre todas las posibles contraseñas, y se ha
probado con la palabra clave dia, Observe también que el código trata a todos los caracteres
de la palabra clave como si fueran diferentes, luego puede dar lugar a una contraseña con
caracteres repetidos, basta que la palabra clave ya los tuviera.

1 / / D e f i n e l a f u n c i ó n que g e n e r a t o d a s l a s p o s i b l e s d i s p o s i c i o n e s de t r e s
2 / / e l e m e n t o s a l f a n u m é r i c o s en t r e s p o s i c i o n e s s i n r e p e t i r n i n g u n o .
3 function disposiciones=disposiciones_3e_3c ( disposicion_inicial )
4 n =0;
5 f o r c1 = 1 : 1 : 3
6 f o r c2 = 1 : 1 : 3
7 i f c2 <> c1
8 f o r c3 = 1 : 1 : 3
9 i f c3 <> c1 & c3 <> c2
10 n=n + 1 ;
11 d i s p o s i c i o n e s ( n , 1 ) = p a r t ( d i s p o s i c i o n _ i n i c i a l , c1 ) + p a r t (
d i s p o s i c i o n _ i n i c i a l , c2 ) + p a r t ( d i s p o s i c i o n _ i n i c i a l , c3 ) ;
12 end
13 end
14 end
15 end
16 end
17 e n d f u n c t i o n
18
19 / / A s i g n a l a p a l a b r a c l a v e de t r e s c a r a c t e r e s
20 p a l a b r a = ’ d i a ’ ; / / E j e m p l o con d i a
21 / / G e n e r a t o d a s l a s p o s i b l e s c o n t r a s e ñ a s a p a r t i r de e s a p a l a b r a c l a v e
22 p o s i b l e s _ c o n t r a s e g n a s = d i s p o s i c i o n e s _ 3 e _ 3 c ( p a l a b r a ) ;
23
24 / / G e n e r a a l e a t o r i a m e n t e l a p o s i c i ó n p a r a l o c a l i z a r l a c o n t r a s e ñ a en e l
c o n j u n t o de c o n t r a s e ñ a s g e n e r a d a s
25 r a n d ( " u n i f o r m " )
26 n= f a c t o r i a l ( 3 ) ;
27 p o s i c i o n _ a l e a t o r i a =1+ r o u n d ( ( n −1)∗ r a n d ( ) ) ;
28
29 / / S e l e c c i o n a y p r e s e n t a l a p o s i b l e c o n t r a s e ñ a
30 c o n t r a s e g n a = p o s i b l e s _ c o n t r a s e g n a s ( p o s i c i o n _ a l e a t o r i a ) ;
31 d i s p ( ’ La p o s i b l e c o n t r a s e ñ a e s : ’ )
32 d i s p ( c o n t r a s e g n a )

2.1) Comprobar que el código en Scilab cumple el objetivo propuesto y proponer de for-
ma razonada un código similar en Maxima para esa funcionalidad. También se recomienda
documentar en extenso algún ejemplo que justifique dicha funcionalidad. (Nota: Tenga en
cuenta que, mientras en Scilab se ha podido trabajar con cadenas de caracteres en Maxima
quizás tenga que trabajar con listas y/o matrices de caracteres).

2
1.1. Solución ejercicio 2.1
Comprobamos que el código funciona perfectamente, para ello cargamos el archivo “ge-
nera_contrasegna_tres_caracteres_T2.sce” y dada la palabra clave “dia” obtenemos en cada
ejecución una contraseña y solo muestra caracteres repetidos si se introduce una palabra que
los tenga.

Figura 1: Demostración del funcionamiento del código en Scilab

Para introducir esta funcionalidad en Maxima, debemos previamente analizar el código

y verificar si el algoritmo es optimizable, sin embargo esto se hará en el ejercicio posterior,
así que procedemos a convertir el código solventando los cambios de estructura de datos.
Ejecutar Ejercicio 2.1 del archivo Trabajo2.wxm:
( % i2) load(basic)$ /*definimos la funcion*/ disposiciones_3e_3c(disposicion_inicial):=block( dis-
posiciones:matrix(), for c1 thru 3 do for c2 thru 3 do if c2#c1 then for c3 thru 3 do
if (c3 # c1 and c3#c2) then block( /*Este bloque nos permite ejecutar estas sentencias
dentro del if*/ disposiciones:addrow(/* Disponemos las letras en una matrix*/ disposicio-
nes,[charat(disposicion_inicial,c1),charat(disposicion_inicial,c2),charat(disposicion_inicial,
c3)] ) ), /*Generamos un número aleatorio*/ num:random(length(disposiciones))+1, r:,
L:disposiciones[num], /*Generamos la palabra*/ for k thru length(disposiciones[num]) do
r:concat(r,pop(L)) ,disp(r) )$;
Nótese que ahora no se usa la variable n pues nos valemos de la función addrow() para relle-
nar la matriz y cargamos la librería basic para hacer uso de la función pop al tratar las filas
de la matrix como listas. También se ha encapsulado la segunda parte del código dentro de
la función para poder manejar el generador de mejor manera.

3
1.1.1. Ejemplo 2.1
Ahora pasamos a probar el código introducido cargando Ejemplo 2.1 del archivo Traba-
jo1.wxm:
( % i3) for i thru 10 do disposiciones_3e_3c(.ola");
loa
ola
loa
alo
aol
oal
alo
alo
ola
oal

done ( % o3)
Como se puede ver, se hace uso del código mediante una llamada reiterada a la función
para obtener distintas salidas y ver que la generación es correcta. Si probamos el código
con palabras más grandes de tres caracteres se generarán contraseñas unicamente con los
tres primeros caracteres. Una simple modificación del código nos permite usar palabras más
grandes y seguir generando contraseñas de tres caracteres, solo hay que añadir el tamaño de
la cadena a cada for, generando una lista de n! posibles contraseñas.
( % i6) load(basic)$ /*definimos la funcion*/ disposiciones_3e_3c_b(disposicion_inicial):=block(
disposiciones:matrix(), for c1 thru slength(disposicion_inicial) do for c2 thru
slength(disposicion_inicial)
do if c2#c1 then for c3 thru slength(disposicion_inicial) do if (c3 # c1 and
c3#c2) then block( /*Este bloque nos permite ejecutar estas sentencias dentro
del if*/ disposiciones:addrow(/* Disponemos las letras en una matrix*/ disposicio-
nes,[charat(disposicion_inicial,c1),charat(disposicion_inicial,c2),charat(disposicion_inicial,
c3)] ) ), /*Generamos un número aleatorio*/ num:random(length(disposiciones))+1, r:,
L:disposiciones[num], /*Generamos la palabra*/ for k thru length(disposiciones[num]) do
r:concat(r,pop(L)) ,disp(r) )$
for i thru 10 do disposiciones_3e_3c_b("dias");
sda
dsa
adi
sdi
sai
dia
ais
dsi
dis
isd

done ( % o6)

4
 2.2) El código facilitado en esta primera parte es útil pero resultaría poco eficiente si se
quisiera generalizar a un número mayor de caracteres. El principal inconveniente es que,
aunque solo se presente una contraseña, se generan todas las posibles; seis (3!) en este caso.
Un algoritmo más efectivo, que seguiría tratando todos los caracteres de la palabra clave
como si fueran diferentes, podría incluir los siguientes pasos:

Paso 1: Sortea la primera posición de la contraseña, a la que son candidatos los tres
caracteres de la palabra clave.

Paso 2: Sortea la segunda posición a la que son candidatos los dos caracteres que no
han sido afortunados en el sorteo de la primera posición.

Paso 3: Adjudica la tercera posición al caracter que no ha sido afortunado en los dos
sorteos anteriores.

Programar una función en Scilab capaz de generar una posible contraseña de n caracteres
alfanuméricos a partir de una palabra clave con m caracteres, siendo m ≥ n mayor o igual.
La función estará dotada de cierta aleatoriedad, de manera que la contraseña generada
sea diferente cada vez que se llame a la función. Como caso particular de prueba, debería
documentar al menos la generación de diez contraseñas diferentes de seis caracteres a partir
de la palabra clave “Morilla_Garcia” mediante sucesivas llamadas a la función. (Nota:
Tenga en cuenta que, si la función trata a todos los caracteres de la palabra clave como si
fueran diferentes, quizás tenga que hacer más de diez llamadas para completar la prueba
solicitada).

1.2. Solución ejercicio 2.2

El algoritmo planteado es eficaz pero necesita ser escalado para poder ser utilizado por
palabras más grandes y hay que decidir de qué forma se sortean las posiciones, generalizando
transformamos los pasos dados en

Se genera un vector con el número de posiciones igual a la longitud de la cadena de

entrada, se sortea la primera y se elimina de la lista

Se siguen sorteando y eliminando de la lista las siguientes posiciones hasta que se

llegue al número objetivo m − n de elementos restantes en la lista, deberá entonces
repetirse el proceso n veces y almacenarse en un vector.

Por último se obtienen los caracteres en las posiciones dadas y se devuelve la contra-
seña generada comor resultado.

1.2.1. Capacidades de la solución planteada

Nótese que el algoritmo es el mismo que el planteado para el caso m = n = 3, el bucle
solo se ejecuta unicamente el número de veces que se necesitan para generar una contraseña
de la longitud introducida, en el peor de los casos se ejecutará un número de veces igual
al tamaño de la cadena y el mísmo número de veces para reconstruir la cadena resultante
siendo complejidad del algoritmo de O(n + n) = O(2n) = O(n), es decir, complejidad lineal.
Como podemos introducir como máximo una cadena de 4054 caracteres de longitud, en el
peor de los casos se ejecutará 8108, que se acerca a 7!, es decir, generar una contraseña de
4054 caracteres sería equivalente computacionalmente a generar una de 7 caracteres con la

5
 solución planteada inicialmente.

Ejecutar archivo 2-2.sce:

1 function contrasegna = genera_contrasegna_nc ( disposicion_inicial , n)
2 m = length ( disposicion_inicial ) ;
3 / / n o s a s e g u r a m o s de que e l n i n t r o d u c i d o t e n g a
4 / / a l menos e l mismo tamaño que l a c a d e n a
5 i f n > m then
6 n = m;
7 end
8 l = [ 1 : 1 :m ] ;
9 i = 1;
10 w h i l e l e n g t h ( l ) > (m−n ) do
11 / / sorteamos
12 j = 1+ r o u n d ( ( l e n g t h ( l ) −1)∗ r a n d ( ) ) ;
13 / / Guardamos l a p o s i c i ó n
14 c( i ) = l ( j ) ;
15 / / eliminamos
16 l ( j ) = [];
17 i = i +1;
18 end
19 r =" " ;
20 f o r i = 1 : 1 : n do
21 r = r + part ( disposicion_inicial , c( i ) ) ;
22 end
23 contrasegna=r ;
24 endfunction
25 for i = 1:1:20
26 disp ( genera_contrasegna_nc ( " Morilla_Garcia " ,6) ) ;
27 end

6
1.2.2. Ejemplo 2.2

Figura 2: El resultado que obtenemos es el siguiente, ninguna contraseña se ha repetido de

las que han sido generadas y el tiempo de ejecución ha sido instantáneo.

7
 2. Segunda parte sobre la resolución de pasatiempos
La exploración exhaustiva de todas las posibles situaciones, no recomendable para resolver el
problema de generar una contraseña, sí puede resultar aconsejable cuando se aborda el diseño
o la resolución de un pasatiempo numérico con una o varias soluciones, en el
que todas las cifras son diferentes. Por ejemplo, el siguiente código en Scilab,
disponible en el archivo “triángulos_tres_cifras_T2.sce”, permite generar las
seis (3!) posibles disposiciones de cifras 1, 2, 3 en el hipotético triángulo con
tres celdas (C1, C2 y C3) de la figura. Que también valdría para cualquier otra
disposición con tres celdas.

1 mtriangulos = zeros (1 ,3) ;

2 n =0;
3 f o r c1 = 1 : 1 : 3
4 f o r c2 = 1 : 1 : 3
5 i f c2 <> c1
6 f o r c3 = 1 : 1 : 3
7 i f c3 <> c1 & c3 <> c2
8 n=n + 1 ;
9 m t r i a n g u l o s ( n , 1 : 3 ) = [ c1 c2 c3 ] ;
10 end
11 end
12 end
13 end
14 end
15 d i s p ( ’ P o s i b l e s t r i á n g u l o s de 3 c i f r a s ’ )
16 disp ( mtriangulos )

La generación de estos triángulos puede ser el primer paso para resolver el siguiente pasa-
tiempo numérico: “Disponga las cifras 1, 2 y 3 en formación triángular de manera que la
suma de las cifras situadas en las posiciones inferiores sea igual a la cifra situada en la posi-
ción superior”. Este pasatiempo tiene dos soluciones; las disposiciones 312 y 321. Pues son
las únicas que cumplen la condición C1 = C2 +C3 , impuesta por el pasatiempo. La búsqueda
de soluciones se podría hacer a posteriori, después de generar todas las disposiciones, o al
mismo tiempo que se hace la generación, almacenando únicamente aquellas disposiciones
que cumplen la condición. En este último caso, el código modificado sería el siguiente:

Adjunto en “triangulos_tres_cifras_reutilizado.sce”
1 / / Programa p a r a e n c o n t r a r l a s s o l u c i o n e s a l s i g u i e n t e pas at iem po numérico :
2 / / " d i s p o n g a l a s c i f r a s 1 , 2 y 3 en f o r m a c i ó n t r i a n g u l a r de manera que l a suma
3 / / de l a s c i f r a s s i t u a d a s en l a s p o s i c i o n e s i n f e r i o r e s s e a i g u a l a l a c i f r a
4 / / s i t u a d a en l a p o s i c i ó n s u p e r i o r " .
5 soluciones = zeros (1 ,3) ;
6 n =0;
7 f o r c1 = 1 : 1 : 3
8 f o r c2 = 1 : 1 : 3
9 i f c2 <> c1
10 f o r c3 = 1 : 1 : 3
11 i f c3 <> c1 & c3 <> c2 &c1 == c2 + c3
12 n=n + 1 ;
13 s o l u c i o n e s ( n , 1 : 3 ) = [ c1 c2 c3 ] ;
14 end
15 end
16 end
17 end
18 end
19 d i s p ( ’ P o s i b l e s t r i á n g u l o s de 3 c i f r a s ’ )
20 disp ( soluciones )

8
2.3) Reutilice el código facilitado en el archivo “triangulos_tres_cifras_T2.sce” para pro-
bar este útimo código en Scilab cumple su objetivo.

2.1. Solucion ejercicio 2.3

Al cargar el código del archivo “triangulos_tres_cifras_reutilizado.sce” en el que hemos
añadido la condición de que c1 sea igual a c2+c3, obtenemos las soluciones correpondients
que son los disposiciones 312 y 321.
2.4) Proponer de forma razonada un código en Maxima capaz de encontrar las soluciones a
este otro pasatiempo: “Disponga las cifras 1,2 y 3 en formación triangular de manera que la
cifra 3 siempre esté situada en la posicion superior”. ¿Qué relación guarda este pasatiempo
con el del apartado 2.3?

2.2. Solucion ejercicio 2.4

De la misma manera que hemos tratado el ejercicio anterior podemos continuar modifi-
cando el código planteado anteriormente, pero unicamente con la condición de que se acepte
como solución si C1 = 3 y ningún elemento se repite. También se podría limitar el número
de iteraciones asignando directamente c1 = 3 pero no lo haremos dado que el objetivo es
explorar todas las posibilidades y extraer las soluciones.

Con respecto a la segunda cuestión sobre qué relación guarda con el pasatiempo anterior,
se trata de que ambos tienen las mismas soluciones, además los dos pasatiempos tienen el
mismo conjunto de posibilidades, también se trata de una disposición triangular, difiriendo
unicamente en la forma de solucionarlo. Cabe también mencionar que dado estas condi-
ciones, el código planteado en el ejercicio anterior también resuelve este pasatiempo, pero
utilizando un criterio diferente.
( % i14) block( soluciones:matrix(), for c1 thru 3 do for c2 thru 3 do if c2#c1 then for c3 th-
ru 3 do if (c3#c1 and c3#c2) and c1=3 then soluciones:addrow(soluciones,[c1,c2,c3]),
disp(soluciones) )$
 
3 1 2
3 2 1

2.5 En los apartados 2.3 y 2.4 ha podido comprobar que los pasatiempos numéricos que se
pueden plantear con tres cifras son muy símples. Pero la dificultad y la variedad de los pasa-

9
 tiempos crecen rápidamente al aumentar el número de cifras en juego. Programa un código
en Scilab o en Maxima capaz de encontrar todas las soluciones al siguiente pasatiempo:
“Disponga las cifras 1, 2, 3, 4, 5 y 6 en formación triangular (en el hipo-
tético triángulo de seis celdas de la figura) de manera que las tres sumas
laterales sean iguales a 10”. Las soluciones que debería generar su códi-
go son las siguientes: 146523, 164325, 326541, 362145, 524361, 542163.
Que como era de esperar no son más que disposiciones obtenidas por
giros y/o simetrías de la disposición inicial, la primera de las solucio-
nes.

2.3. Solucion ejercicio 2.5

Podemos implementar el código tanto en Maxima como en Scilab y realmente no hay
necesidad de elegir uno u otro, en este caso he elegido Scilab porque la codificación se pa-
rece un poco más a la tradicional, pero el algoritmo planteado se puede ejecutar igualmente
en maxima.

Al intentar escalar la solución anterior nos damos cuenta de que el número de condiciones
a implementar es cada vez mayor, así que he decidido repetir solo el número de veces que
sea necesario, evitando tales condiciones, para ello me sirvo del siguiente algoritmo:

1. Recorremos la lista que contiene las cifras

2. Asignamos a c1 el primer elemento de la lista

3. Eliminamos el elemento de la lista

4. Recorremos la lista resultante (implicando todos los pasos de este algoritmo, incluyen-
do este, y restaurar, hasta llegar a c6).

5. Restauramos la lista anterior

De esta manera evitamos tener que estar programando todas las condiciones necesarias para
no ejecutar los bucles en caso de cifras repetidas y nos podemos centrar en la resolución del
pasatiempo, que consta de unicamente de guardar en una matriz los elementos que corres-
pondan a la condición dada.

Ejecutar el archivo 2.5.sce

1 O = [1 ,2 ,3 ,4 ,5 ,6]; / / l i s t a original
2 L = O ; / / l i s t a de t r a b a j o
3 n = length (L) ;
4 c1 = 0 ; c2 = 0 ; c3 = 0 ; c4 = 0 ;
5 c5 = 0 ; c6 = 0 ;
6 sol = [ ] ;
7
8 for i = 1:1: n
9 c1 = L ( i ) ;
10 L( i ) = [ ] ;
11 m = length (L) ;
12 f o r j = 1 : 1 :m
13 tmp = L ;
14 c2 = L ( j ) ;
15 L( j ) = [ ] ;
16 p = length (L) ;
17 for k = 1:1: p

10
18 tmp2 = L ;
19 c3 = L ( k ) ;
20 L( k ) = [ ] ;
21 q = length (L) ;
22 for l = 1:1: q
23 tmp3 = L ;
24 c4 = L ( l ) ;
25 L( l ) = [ ] ;
26 r = length (L) ;
27 for x = 1:1: r
28 tmp4 = L ;
29 c5 = L ( x ) ;
30 L( x ) = [ ] ;
31 s = length (L) ;
32 for y = 1:1: s
33 c6 = L ( y ) ;
34 L( y ) = [ ] ;
35 i f c1 + c2 + c4 == 10 & c1 + c3 + c6 ==10 & c4 + c5 + c6 == 1 0 ;
36 s o l ( $ + 1 , : ) = [ c1 c2 c3 c4 c5 c6 ] ;
37 end
38 end
39 L = tmp4 ;
40 end
41 L = tmp3 ;
42 end
43 L = tmp2 ;
44 end
45 L = tmp ;
46 end
47 L = O
48 end
49 / / e l i m i n a m o s l a f i l a de c e r o s que s e c r e a a l u s a r
50 / / e l i d e n t i f i c a d o r $+1
51 sol (1 ,:) = [ ] ;
52 disp ( sol ) ;

De igual modo también se puede implementar el algoritmo en Maxima sin demasiados pro-
blemas, nos valemos nuevamente del paquete Basic b para manejar las listas, esta vez usamos
la función delete, que nos permite borrar un elemento de la lista que nos hará las veces de
la operación L(i) = [] que hacíamos en Scilab, el resto se plantea practicamente igual y la
solución se almacena en una matriz.
Ejecutar Ejercicio 2.5 del archivo Trabajo 2.wxm:
( % i7) load(basic)$ O: [1,2,3,4,5,6]$ L:O$ n: length(O)$ sol:matrix()$ for i thru n do block(
c1:L[i], L:delete(L[i],L), m:length(L), for j thru m do block( tmp:L, c2:L[j], L:delete(L[j],L),
p:length(L), for k thru p do block( tmp2:L, c3:L[k], L:delete(L[k],L), q:length(L), for l thru
q do block( tmp3:L, c4:L[l], L:delete(L[l],L), r:length(L), for x thru r do block( tmp4:L,
c5:L[x], L:delete(L[x],L), s:length(L), for y thru s do block( c6:L[y], L:delete(L[y],L),
if (c1 + c2 + c4) = 10 and c1 + c3 + c6 = 10 and c4 + c5 + c6 =10 then
sol:addrow(sol,[c1,c2,c3,c4,c5,c6]) ) ,L:tmp4) ,L:tmp3) ,L:tmp2) ,L:tmp) ,L:O); sol;
done ( % o6)

 
1 4 6 5 2 3
1 6 4 3 2 5
 
3 2 6 5 4 1

3
 ( % o7)
 6 2 1 4 5

5 2 4 3 6 1
5 4 2 1 6 3
2.6) Reutilice el código del apartado anterior para proponer al menos otros dos pasatiem-
pos numéricos con seis cifras y documentar sus soluciones. Así como para comprobar algún

11
pasatiempo sin solución.

Después de adaptar el algoritmo para que sea utilizado más facilmente vamos a comprobar
la solución de los siguientes pasatiempos:

1. Que el producto de los pares y la suma de los impares sea igual al mismo número.

2. Que la suma de las posiciones opuestas sea igual (los opuestos en el triángulo son c1
y c5, c3 y c4, y c2 y c3). curiosamente esto solo se da cuando la suma de los opuestos
es igual a 7.

12
3. Comprobamos que la suma de cada cifra con su opuesta nunca es igual a la suma del
resto de cifras.

13
 Por último, también podemos hacer uso de las disposiciones propuestas para cambiar el enfo-
que y los objetivos del juego, por ejemplo usando la disposición. rectangular
veamos que las soluciones posibles qeu hay para la suma de c3 y c4 sea igual a
la suma de las aristas, c1 + c5 y c2 + c6, son también 48.
Ejecutar el archivo 2.6.sce
1 c1 = 0 ; c2 = 0 ; c3 = 0 ; c4 = 0 ; c5 = 0 ; c6 = 0 ;
2 f u n c t i o n sol = t r i a n g u l o _ s e i s _ c i f r a s ( expr )
3 O = [1:1:6];
4 L = [1:1:6];
5 for i = 1:1: n
6 c1 = L ( i ) ;
7 L( i ) = [ ] ;
8 m = length (L) ;
9 f o r j = 1 : 1 :m
10 tmp = L ;
11 c2 = L ( j ) ;
12 L( j ) = [ ] ;
13 p = length (L) ;
14 for k = 1:1: p
15 tmp2 = L ;
16 c3 = L ( k ) ;
17 L( k ) = [ ] ;
18 q = length (L) ;
19 for l = 1:1: q
20 tmp3 = L ;
21 c4 = L ( l ) ;
22 L( l ) = [ ] ;
23 r = length (L) ;
24 for x = 1:1: r
25 tmp4 = L ;
26 c5 = L ( x ) ;
27 L( x ) = [ ] ;
28 s = length (L) ;
29 / / e l u t l i m o v a l o r no n e c e s i t a b u c l e
30 c6 = L ( y ) ;
31 L( y ) = [ ] ;
32 i f eval ( expr ) ;
33 s o l ( $ + 1 , : ) = [ c1 c2 c3 c4 c5 c6 ] ;
34 end
35 L = tmp4 ;
36 end
37 L = tmp3 ;
38 end

14
39 L = tmp2 ;
40 end
41 L = tmp ;
42 end
43 L = O
44 end
45 / / e l i m i n a m o s l a p r i m e r a f i l a de c e r o s
46 sol (1 ,:) = [ ] ;
47 disp ( sol ) ;
48 d i s p ( s i z e ( s o l ) ) ; / / a y u d a a v e r l a c a n t i d a d de s o l u c i o n e s
49 endfunction
50
51 d i s p ( ’ p r o d u c t o de p a r e s suma de i m p a r e s ’ ) ;
52 t r i a n g u l o _ s e i s _ c i f r a s ( ’ ( c2 ∗ c4 ∗ c6 ) == ( c1 + c2 + c3 ) ’ ) ;
53 d i s p ( ’ que l a suma de l o s o p u e s t o s s e a i g u a l ’ ) ;
54 t r i a n g u l o _ s e i s _ c i f r a s ( ’ ( c1 + c5 == c4 + c3 ) & ( c1 + c5 == c2 + c6 ) & ( c2 + c6 ==
c4 + c3 ) ’ ) ;
55
56 d i s p ( ’ suma de l o s o p u e s t o s i g u a l al resto ’ ) ;
57 t r i a n g u l o _ s e i s _ c i f r a s ( ’ c6 + c2 == ( c1 + c3 + c4 + c5 ) ’ ) ;
58 t r i a n g u l o _ s e i s _ c i f r a s ( ’ c5 + c1 == ( c2 + c3 + c4 + c6 ) ’ ) ;
59 t r i a n g u l o _ s e i s _ c i f r a s ( ’ c4 + c3 == ( c1 + c2 + c5 + c6 ) ’ ) ;
60
61 d i s p ( ’ que l a suma d e l c e n t r o s e a i g u a l a l a suma de l a s a r i s t a s ’ )
62 t r i a n g u l o _ s e i s _ c i f r a s ( ’ c4 + c3 == ( c1 + c5 ) & c4 + c3 == c2 + c6 ’ ) ;

15