ds3 tp/td + e1

.zed/debug.json

@@ -21,4 +21,15 @@
     "request": "launch",
     "adapter": "CodeLLDB",
   },
+  {
+    "label": "Debug tp7 exo7",
+    "build": {
+      "command": "gcc",
+      "args": ["-o", "./exe", "-lm", "-g", "tp7/exo7.c"],
+      "cwd": "$ZED_WORKTREE_ROOT",
+    },
+    "program": "$ZED_WORKTREE_ROOT/exe",
+    "request": "launch",
+    "adapter": "CodeLLDB",
+  },
 ]

ds3/ds3.typ

@@ -0,0 +1,161 @@
+#show enum.item: it => {
+  let (number, body, ..fields) = it.fields()
+  if body.func() == block { return it }
+
+  body = block(breakable: false, body)
+  enum.item(number, body, ..fields)
+}
+
+= DS n°3
+
+== TD et TP
+
+#set enum(numbering: "T1.")
+\
++ ```ocaml
+let points main = Array.fold_left
+  (fun acc carte -> acc + (points_carte carte))
+  0
+  main
+;;
+```
+
++ ```ocaml
+let creer_fileb capacite init = {
+  taille = 0;
+  tete = 0;
+  queue = 0;
+  donnees = Array.make capacite init
+};;
+
+let enfiler_fileb f x =
+  let capacite = Array.length f.donnees in
+  if f.taille = capacite then
+    failwith "File pleine"
+  else
+    f.donnees.(f.queue) <- x;
+    f.queue <- (f.queue + 1) mod capacite;
+    f.taille <- f.taille + 1
+;;
+
+let defiler_fileb f =
+  let capacite = Array.length f.donnees in
+  if f.taille = 0 then
+    failwith "File vide"
+  else
+    let x = f.donnees.(f.tete) in
+    f.tete <- (f.tete + 1) mod capacite;
+    f.taille <- f.taille - 1;
+    x
+;;
+
+let est_vide_fileb f = f.taille = 0;;
+```
+
++ ```ocaml
+let rec map func l = match l with
+  | [] -> []
+  | x::q -> (func x)::map func q
+;;
+```
+
++ ```c
+void tri_denombrement(int t[], int taille, int k) {
+    int *counts = malloc((k+1)*sizeof(int));
+    for (int i=0; i<k+1; i+=1) {
+        counts[i] = 0;
+    }
+    for (int i=0; i<taille; i+=1) {
+        counts[t[i]] += 1;
+    }
+    int i = 0;
+    for (int j=0; j<k+1 && i < taille; j+=1) {
+        while (counts[j] > 0) {
+            t[i] = j;
+            i += 1;
+            counts[j] -= 1;
+        }
+    }
+}
+```
+
+== Exercices
+
+=== Exercice 1
+\
+Première fonction :
+```ocaml
+let rec somme l = match l with
+  | [] | _::[] -> l
+  | (x,a)::(y,b)::q ->
+    if x = y then
+      (x,a+.b)::somme q
+    else
+      (x,a)::somme ((y,b)::q)
+;;
+let func1 l = somme (List.fast_sort compare l);;
+```
+\
+Deuxième fonction :
+```ocaml
+(* On suppose que l est une liste de Hashtbl *)
+let rec func2 l = match l with
+  | [] -> Hashtbl.create 0
+  | ht::q ->
+    let ht2 = func2 q in
+    Hashtbl.iter
+      (fun cle x ->
+        Hashtbl.replace ht2 cle (
+          match Hashtbl.find_opt ht2 cle with
+            | None -> x
+            | Some x2 -> x+.x2
+        )
+      )
+      ht;
+    ht2
+;;
+```
+#pagebreak()
+Troisième fonction :
+```c
+struct couple {
+    int cle;
+    double val;
+};
+typedef struct couple cpl;
+void sort(cpl t[], int taille) {
+    if (taille <= 1) {
+        return;
+    }
+    int pivot = t[taille-1].cle;
+    int i = 0;
+    int j = taille-2;
+    while (i<j) {
+        while (t[i].cle<=pivot && i<j) i+=1;
+        while (t[j].cle>=pivot && i<j) j-=1;
+        cpl temp = t[i];
+        t[i] = t[j];
+        t[j] = temp;
+    }
+    cpl temp = t[taille-1];
+    t[taille-1] = t[i];
+    t[i] = temp;
+    sort(t, i);
+    sort(t+i+1, taille-i-1);
+}
+// Renvoie la nouvelle taille du tableau
+int func3(cpl t[], int taille) {
+    sort(t, taille);
+    int i=0;
+    for (int j=1; j<taille; j+=1) {
+        if (t[j-1].cle == t[j].cle) {
+            t[i].val += t[j].val;
+        } else {
+            i+=1;
+            t[i] = t[j];
+        }
+    }
+    i += 1;
+    return i;
+}
+```