Lahenda crashcourse praktikumis

Author: sim642

src/crashcourse/basics.ml

@@ -4,12 +4,12 @@
 
 (** Suurendab täisarvu ühe võrra. *)
 let inc (x: int): int =
-  failwith "TODO"
+  x + 1
 
 (** Suurendab täisarvu ühe võrra.
     Kasutada "lambdafunktsiooni". *)
-let inc': int -> int = fun x ->
-  failwith "TODO"
+let inc': int -> int =
+  fun x -> x + 1
 
 
 (** Rekursiivsed funktsioonid. *)
@@ -18,15 +18,23 @@ let inc': int -> int = fun x ->
     Kasutada if-i.
     Vihje: võrdusoperaator on = (mitte ==) ja selle vastand on <> (mitte !=). *)
 let rec fact (n: int): int =
-  failwith "TODO"
+  (* if n < 0 then
+    invalid_arg "negatiivne"
+  else *)
+  if n = 0 then
+    1
+  else
+    n * fact (n - 1)
 
 (** OCaml-i if on avaldis, millel on väärtus, mitte lause: if a then b else c.
     Java-s jms. on selle analoog ternary operaator: a ? b : c. *)
 
 (** Arvutab faktoriaali.
     Kasutada match-i. *)
 let rec fact' (n: int): int =
-  failwith "TODO"
+  match n with
+  | 0 -> 1
+  | _ -> n * fact' (n - 1)
 
 
 (** Mitme argumendiga funktsioonid. *)
@@ -35,12 +43,17 @@ let rec fact' (n: int): int =
     Vt. https://en.wikipedia.org/wiki/Euclidean_algorithm#Implementations.
     Vihje: Jäägi operaator (mitte funktsioon) on mod. *)
 let rec gcd (x: int) (y: int): int =
-  failwith "TODO"
+  if y = 0 then
+    x
+  else
+    gcd y (x mod y)
 
 (** Arvutab implikatsiooni.
     Kasutada mitme argumendiga match-i. *)
 let implies (x: bool) (y: bool): bool =
-  failwith "TODO"
+  match x, y with
+  | true, false -> false
+  | _, _ -> true
 
 
 

src/crashcourse/collections.ml

@@ -7,19 +7,25 @@ open Types
 (** Teisendab puu elementide listiks (keskjärjestuses).
     Vihje: Listide konkateneerimise operaator on @. *)
 let rec list_of_tree (t: 'a tree): 'a list =
-  failwith "TODO"
+  match t with
+  | Leaf x -> [x]
+  | Branch (l, r) -> list_of_tree l @ list_of_tree r
 
 (** Suurendab täisarvude listi elemente ühe võrra. *)
 let list_inc (xs: int list): int list =
-  failwith "TODO"
+  (* List.map (fun x -> x + 1) xs *)
+  List.map Basics.inc xs
 
 (** Jätab täisarvude listist alles elemendid, mis on vähemalt 4. *)
 let list_big (xs: int list): int list =
-  failwith "TODO"
+  List.filter (fun x -> x >= 4) xs
 
 (** Liidab kokku täisarvude listi elemendid. *)
 let list_sum (xs: int list): int =
-  failwith "TODO"
+  (* List.fold_left (fun acc x ->
+      acc + x
+    ) 0 xs *)
+  List.fold_left (+) 0 xs
 
 (** Liidab kokku täisarvude listi elemendid.
     Imperatiivsem lahendus. *)

src/crashcourse/types.ml

@@ -9,7 +9,10 @@ type color =
     Teisendab värvi sõneks, vastavalt "R", "G" ja "B".
     Kasutada match-i. *)
 let show_color (c: color): string =
-  failwith "TODO"
+  match c with
+  | Red -> "R"
+  | Green -> "G"
+  | Blue -> "B"
 
 (** Ülesanne:
     Teisendab sõne värviks. show_color pöördfunktsioon.
@@ -22,6 +25,10 @@ let parse_color (s: string): color =
 
 (** Algebralised andmetüübid. *)
 
+(* type inttree =
+  | Leaf of int
+  | Branch of inttree * inttree *)
+
 (** Polümorfne kahendpuu, mille elemendid on tüüpi 'a. *)
 type 'a tree =
   | Leaf of 'a (** Leht sisaldab ühte väärtust. *)
@@ -37,32 +44,61 @@ type 'a tree =
       .   4
      / \
     2   3 *)
-let example_int_tree = Leaf 1
+let example_int_tree =
+  Branch (
+    Leaf 1,
+    Branch (
+      Branch (
+        Branch (
+          Leaf 2,
+          Leaf 3
+        ),
+        Leaf 4
+      ),
+      Leaf 5
+    )
+  )
 
 (** Ülesanne:
            .
          /   \
        .       .
       / \     / \
     'a' 'b' 'b' 'a' *)
-let example_char_tree = Leaf 'a'
+let example_char_tree =
+  Branch (
+    Branch (
+      Leaf 'a',
+      Leaf 'b'
+    ),
+    Branch (
+      Leaf 'b',
+      Leaf 'a'
+    )
+  )
 
 
 (** Näited. *)
 
 (** Arvutab puu kõrguse. Lehe kõrgus on 0.
     Vihje: Kasuta max funktsiooni. *)
 let rec height (t: 'a tree): int =
-  failwith "TODO"
+  match t with
+  | Leaf _ -> 0
+  | Branch (l, r) -> 1 + max (height l) (height r)
 
 (** Teisendab puu sõneks. Vt teste.
     Vihje: Sõnede konkateneerimise operaator on ^. *)
 let rec show_tree (show_leaf: 'a -> string) (t: 'a tree): string =
-  failwith "TODO"
+  match t with
+  | Leaf x -> show_leaf x
+  | Branch (l, r) -> "(" ^ show_tree show_leaf l ^ " " ^ show_tree show_leaf r ^ ")"
 
 (** Rakendab funktsooni puu lehtedele. *)
 let rec tree_map (f: 'a -> 'b) (t: 'a tree): 'b tree =
-  failwith "TODO"
+  match t with
+  | Leaf x -> Leaf (f x)
+  | Branch (l, r) -> Branch (tree_map f l, tree_map f r)
 
 
 (** Ülesanded. *)