2º [EI/ETIX] Programación Declarativa (PD)

[Fer]

Una pregunta sencilla os hago :

Es factible realizar el ejercicio 2 a) de este examen:

http://quegrande.org/apuntes/ETIX/2/PD/ ... e_2006.pdf


Sólo si es factible, pregunto, una solución ya sería más de lo que merezco. Yo no gasto ya más neuronas en el puto ejercicio

Claro, y bastante fácil, creo yo. Con dos funciones auxiliares, lo haría: una que itere en la lista de listas, y otra que itere dentro de cada lista-elemento de la lista de listas. Y fijo que hay alguna manera fácil de hacerlo con una función recursiva nada más.


PD: Suerte a los que vayáis mañana a PD.

[M2Z]

Una pregunta sencilla os hago :
Es factible realizar el ejercicio 2 a) de este examen:
http://quegrande.org/apuntes/ETIX/2/PD/ ... e_2006.pdf

Sólo si es factible, pregunto, una solución ya sería más de lo que merezco. Yo no gasto ya más neuronas en el puto ejercicio

Una solución sencilla, aunque no especialmente eficiente:

Código: Seleccionar todo

let rec sublistas = function
        []      -> [[]]
|       h::t   ->  let r = sublistas t in
                       r @ (List.map (function x -> h::x) r)
;;


[Zhek]

¿Alguien sabe si las prácticas cuentan algo? Es que como no ha dicho (creo) nada...

[Fer]

¿Alguien sabe si las prácticas cuentan algo? Es que como no ha dicho (creo) nada...

Se dice que sí, pero vamos... Más bien es para poder ir al examen. Lo que sí contará, supongo, son las opcionales, que para algo lo son.

[omikinho]

Código: Seleccionar todo

          PROGRAMACION DECLARATIVA
            4 DE FEBREIRO DE 2009
(*1. (5 puntos) Escriba o resultado da compilación e execución das seguintes frases, con tipos e valores, como faría o compilador interactivo de ocaml:*)

let l = [1,2;3,4;5,6];;

(*val l : (int * int) list = [(1, 2); (3, 4); (5, 6)]*)

(function (_,x)::_ -> x);;

(*Warning P: this pattern-matching is not exhaustive.
Here is an example of a value that is not matched:
[]
- : ('a * 'b) list -> 'b = <fun>*)

(function (_,x)::_ -> x) (List.tl l);;

(*Warning P: this pattern-matching is not exhaustive.
Here is an example of a value that is not matched:
[]
- : int = 4*)

let rec apl = function
        [] -> []
     | (x,y)::t -> x y::apl t;;

(*val apl : (('a -> 'b) * 'a) list -> 'b list = <fun>*)

let f = apl [(-),0];;

(*val f : (int -> int) list = [<fun>]*)

let l = List.tl l in List.hd l;;

(*- : int * int = (3, 4)*)

let x,y = List.hd l;;

(*val x : int = 1
val y : int = 2*)

let x,y = x+y,y-x in x+y,y-x;;

(*- : int * int = (4, -2)*)

let x,y = let x,y = x+y,x-y in x+y,y-x;;

(*val x : int = 2
val y : int = -4*)

(let x = x*x in 2*x) + x + y;;

(*- : int = 6*)

let rec mcomp l x = match l with
        [] -> x
    | (n,f)::t -> if n > 0 then f (mcomp((n-1,f)::t) x) else mcomp t x;;

(*val mcomp : (int * ('a -> 'a)) list -> 'a -> 'a = <fun>*)

mcomp [(2,function x -> x*x);(3,(+) 1);(0,abs);(3,(-)0)] 1;;

(*- : int = 16*)


(*2. (1 punto) Realice unha nova definición para a función mcomp do exercicio anterior, de xeito que só se empregue recursividade terminal.*)

let mcomp l x =
   let rec aux l i = match l with
              [] -> i
      | (n,f)::t -> if n > 0 then aux((n-1,f)::t) (f i)     
                            else aux t i
   in aux (List.rev l) x;;

(*3. (2 puntos) Considere a seguinte definición en ocaml para o tipo de dato inttree (que serve para representar árbores binarias con valores enteiros nos nodos):

type inttree = Empty | Node of int * inttree * inttree;;

Chamaremos "peso" dunha árbore á suma dos valores de todos os seus nodos.
Diremos que unha árbore "está equilibrada" se as dúas ramas que "colgan" de cada nodo teñen o mesmo peso. Defina unha función equilibrada: inttree -> bool, que indique se unha árbore está equilibrada ou non.*)

type inttree = Empty | Node of int * inttree * inttree;;

let rec equilibrada = function
         Empty -> true
 | Node(_,i,d) -> let rec peso = function
                             Empty -> 0
                     | Node(x,i,d) -> x + peso i + peso d
                  in (peso i = peso d) && (equilibrada i) && (equilibrada d);;

(*4. (2 puntos) Diremos que unha lista s_i é un segmento inicial doutra lista l se existe outra lista s_f tal que l = s_i @ s_f.

Así, por exemplo, son segmentos iniciais da lista [2;3;7] as listas [],[2],[2;3] e [2;3;7].

Defina unha función inisegs: 'a list -> 'a list list que, para cada lista, nos dea todos os seus segmentos iniciais.*)


let inisegs l =
   let rec aux l2 ll n = match l2 with
              [] -> ll@[[]]
         |  h::t -> if n = List.length l then ll
                                         else aux t (ll@[h::t]) (n+1)
   in List.map List.rev (aux (List.rev l) [] 0);;



¡Quén me dera ter así o examen! Aínda que bueno, penso que aprobar, aprobo. A ver cómo é...
Se vedes cousas que estén mal dicídemo.

[Peibol]

Antes de que el hilo se vaya a la segunda página, mando un mensaje a ver si lo lee molineli y se deja de ir de cañas, porque los examenes están apunto de oxidarse.

[darkjohn]

Alguien sabe cuanto suelen tardar en salir las notas de PD, pq ya hace un mes que hicimos el examen

[dzr]

Pues cuando le salga del **** a molinelli, asique a saber cuando será eso...

[xyzzys]

As notas xa están publicadas no tablón.

[Morpheo]

¿Se sabe algo de las notas de septiembre?