Práctica 3, ejercicio 3

Espero que sirva. En algunos definí otras funciones auxiliares para que quede más claro.

Ejercicio 1
aux capicúa(s : [T] ) : Bool =
todos( [ indice(s,i) == indice(s,|s|-(i+1)) | i ← [0..|s|) ] );

Ejercicio 2
aux longitudDeLaMasCorta(s,t : [T]) : Int =
beta(|s|>=|t|)|t| + beta(|s|<|t|)*|s|
*
aux esPrefijo(s,t : [T]) : Bool =
todos([indice(s,i)==indice(t,i) | i ← [0..longitudDeLaMasCorta(s,t)-1])

Ejercicio 3
aux estáOrdenada(s : [Float]) : Bool =
todos( [indice(s,i)<=indice(s,i+1) | i ← [0..|s|-2]] )

Ejercicio 4
*aux primo(x : Int) : Bool = long( [ i | i ← (1..x], x mod i == 0] ) == 1
*
aux todosPrimos(s : [Int]) : Bool = todos ( [primo(x) | x ← a] )

Ejercicio 5
aux todosIguales (s : [T]) : Bool =
todos( [ indice(s,i)==indice(s,j) | i ← [0--|s|), j ← [0..|s|) ]

Ejercicio 6
Este está mal... vean al fondo del topic que está corregido!

aux hayUnParQueDivideAlResto (s:[Int]) : Bool =
algun( [todos( x mod y == 0) | x ← s] | y ← s), y mod 2 == 0 ] )

Ejercicio 7
aux hayUnoEnPosiciónParQueDivideAlResto (s:[Int]) : Bool =
algun( [todos( x mod indice(s,i) == 0) | x ← s] | i ← [0..|s|), i mod 2 == 0 ] )

Ejercicio 8
aux sinRepetidos(s : [T]) : Bool =
todos ( [cuenta(x,s)==1 | x ← s])

Ejercicio 9
aux sinMasDeNApariciones(s : [T], n : Int) : Bool =
todos ( [cuenta(x,s)<=n | x ← s] )

Ejercicio 10
aux otroMayorADerecha(s : [Float]) : Bool =
todos( [algun( [indice(s,i)<indice(s,j) | j ← [0..|s|), i<j]) | i ← [0..|s|-1))

Ejercicio 11
aux todoEsMúltiplo(s : [Int]) : Bool =
todos( [algun( [x mod y == 0 | y ← s] ) | x ← s] )

Ejercicio 12
*aux estánSóloLosTres(s : [Float]) : Bool =
cuenta(s,0)>0 && cuenta(s,1)>0 && cuenta(s,2)>0 && todos( [cuenta(s,x)=0 | x ← s, x!= 0, x!=1, x!=2])

aux indicesOrdenados(s : [Float]) : Bool =
todos( [len(sub(s,0,i)<len(sub(s,0,j) | i,j ← [0..|s|-1], indice(s,i)<indice(s,j)] )
*
aux enTresPartes (s : [Float]) : Bool =
estánSóloLostres(s) && indicesOrdenados(s)

Observacion: para la modificación que pide después sólo hay que modificar estánSóloLosTres para que en las primeras 3 condiciones acepte mayor o igual a 0.

Editado 2 veces.

Lindas las resoluciones, no se me habia ocurrido eso de aux longitudDeLaMasLarga. ¿La funcion cuenta q es? (si, ya se q cuentan cosas xD , pero de donde salio? )

¿La funcion cuenta q es? (si, ya se q cuentan cosas xD , pero de donde salio? )

Perdón, pensé que la habían definido en clase. Sería algo así:

aux cuenta(secuencia: [T], elemento : T) : Int = longitud( [x | x <-- secuencia , x==elemento] )

Igual ahora que lo veo tendría que ser longitudDeLaMasCorta.... lo edito.

en el 6) me parece q hay un parentesis de mas .....lo digo por q si esta bien escrito, entonces esto cada vez me confunde mas!!!!
algun( [todos( x mod y == 0) | x ← s] | y ← s ==&gt😉<== , y mod 2 == 0 ] ) ...

mm mirá ahora que lo veo creo que ni siquiera sacándole ese paréntesis tiene sentido lo que puse 😄

lo reescribí y creo que ahora funciona:

aux hayUnParQueDivideAlResto(s: [Int]) : Bool =
alguno( [ todos([x%y==0 | x<--s]) | y <-- s, y mod 2==0] );

Es medio rebuscado, queda más claro cuando lo escribís con existe y para todo, pero como lo hice en el editor de texto (sin latex) opté por la versión "alternativa".

El alguno toma una lista de booleanos y da verdadero si hay alguno que sea verdadero.

La secuencia que quedó adentro son todos términos que dicen que todos los elementos (cada uno de los x) son divisibles por un y, que en cada elemento de esta secuencia por comprensión se reemplaza por un elemento par de la secuencia que se pasó como parámetro.

Así, si hay un par que divide a todos, entonces uno de los booleanos todos([...]) va a dar True, y luego el alguno que los englobe da True.

Muchas gracias por avisar y espero que te sirva!

hay siiii es como lo habia hecho yo....gracias again!

jaja hablando de ejercicios a las 2 de la mañana, somos un desastre.

fijate en el 4, a mi entender quisiste poner x<--s porq sino esa "a" mágica no c de donde sale 😄

y...en el 6.... es x mod y==0 creo...

en el 7 creo q con lo q pusiste estas diciendo que la posicion de i(que es par) divide a x ,con x tomando los valores de la lista s, y lo que en realidad queremos es que x mod i ==0| x<--s, indice(s,i) mod 2==0 o algo por el estilo...no?

yo lo puse asi,no c si estará bien:

algún([todos([x mod i==0|x<--s,i<--[0..|s|)])|índice(s,i) mod 2 == 0])