(* Probleme cu liste de liste: de la parțial și altele *)

(* Pornim de la o listă simplă: numerele de la 1 la n *)

let upto =         (* lista de la 1 la n *)
  let rec addlst acc n = if n <= 0 then acc else addlst (n::acc) (n-1)
  in addlst []

let test_up = upto 10  (* [1; 2; 3; 4; 5; 6; 7; 8; 9; 10] *)

let ndown n =        (* lista de la n la 1 *)
  let rec addlst acc k = if k > n then acc else addlst (k::acc) (k+1)
  in addlst [] 1

let test_down = ndown 7 (* [7; 6; 5; 4; 3; 2; 1] *)

(* creează lista [f 1; f 2; ... f n] cu funcția f dată parametru *)
(* Simplu: înlocuim n :: ... cu f n :: ... în funcțiile de mai sus *)

let mapup f =         (* lista de la f 1 la f n *)
  let rec addlst acc n = if n <= 0 then acc else addlst (f n::acc) (n-1)
  in addlst []

(* Am fi putut crea întâi lista [1; 2; ...; n], apoi  aplicăm List.map *)
let mapup2 f n = upto n |> List.map f
               
let mapdown f n =        (* lista de la n la 1 *)
  let rec addlst acc k = if k > n then acc else addlst (f k::acc) (k+1)
  in addlst [] 1

(* Acum putem face simplu tot felul de liste *)
(* chiar listele de numere sunt cazuri particulare pentru functia identitate *)
let test_up = mapup (fun x -> x) 7
let test_down = mapdown (fun x -> x) 9
              
let evens = mapup (fun x -> 2*x) 5  (* [2; 4; 6; 8; 10] *)

let ntimes v = mapup (fun _ -> v)        (* funcție constantă: repetă v *)
             
let test_s = ntimes "ana" 3                (* ["ana"; "ana"; "ana" ] *)

(* Scrieți funcția f(n) care dă [[n;n-1;...;1];[n-1;...;1];...;[2;1];[1]] *)

(* lista interioară [k;...;2;1] e chiar ndown k deci: *)
let f1 = mapdown ndown (* sau, deoarece ndown = mapdown (fun k -> k) *)
let f1 = mapdown (fun k -> k) |> mapdown

let test1 = f1 5  (* [[5; 4; 3; 2; 1]; [4; 3; 2; 1]; [3; 2; 1]; [2; 1]; [1]] *)

(* Scrieți funcția f(n) care returnează [[n];[n-1;n-1];...;[1;1;(*n ori*);1]] *)

(* în interior, avem valoarea k de (n+1-k) ori, deci odată n...-> de n ori 1 *)
let f2 n = mapdown (fun k -> ntimes k (n+1-k)) n

let test2 = f2 4  (*  [[4]; [3; 3]; [2; 2; 2]; [1; 1; 1; 1]] *)

(* lista de liste [ [1;2...;n]; [2;4;...2*n]; ...; [n; 2*n; ... n*n ]] *)
(* ca și for j ... for k -> j * k *)
let f3 n = mapup (fun j -> mapup (fun k -> j*k) n) n 

let test3 = f3 3  (*  [[1; 2; 3]; [2; 4; 6]; [3; 6; 9]] *)
          
(* lista de liste [ [1;2...;n]; [n+1;n+2;...2*n]; ...; [n*n-n+1; ... n*n ]] *)

let f4 n = mapup (fun j -> mapup (fun k -> j*n-n+k) n) n
         
let test4 = f4 3 (* [[1; 2; 3]; [4; 5; 6]; [7; 8; 9]] *)

This document was generated using caml2html