Differences

This shows you the differences between two versions of the page.

--- aa:lab:sol:3 [2023/10/27 11:20]
ioana.dabelea created
+++ aa:lab:sol:3 [2025/10/19 21:59] (current)
andreidarlau04 [Algebraic Data Types]
@@ Line 1: / Line 1: @@
-.
+===== Exercitiul 1 =====
-  * $ f_{111}(M) = TRUE \iff  M[111] \rightarrow TRUE$
+==== Metoda Agregatelor ====
-O să încercăm să arătăm că $ f_{h} \le_m f_{111}$.
+=== ArrayList - inserare ===
-Trebuie să găsim o transformare t care primeşte inputul lui Halting Problem şi întoarce un input pentru $ f_{111}$:
+Raspuns: ĉ<sub>i</sub> = 3
-$ M, w \to t \to M^*$
-După ce am găsit asta,  mai ramane de demonstrat doar: $ f_{h}(M, w) = TRUE \iff f_{111}(M^*) = TRUE$
+Explicatie: Incepem cu un array cu capacitate 1 si 0 elemente (vom nota cost insert = c<sub>i</sub>, copiere n elemente = cpy<sub>n</sub>.
+  * insert1: c = c<sub>i</sub> = 1
+  * insert2: c = cpy<sub>1</sub> + c<sub>i</sub> = 2
+  * insert3: c = cpy<sub>2</sub> + c<sub>i</sub> = 3
+  * insert4: c = c<sub>i</sub> = 1
+  * insert5: c = cpy<sub>4</sub> + c<sub>i</sub> = 5
+  * insert6: c = c<sub>i</sub> = 1
+  * insert7: c = c<sub>i</sub> = 1
+  * insert8: c = c<sub>i</sub> = 1
+  * insert9: c = cpy<sub>8</sub> + c<sub>i</sub> = 9
-$ M^*(x):$
-<code>
-   run M[w]
-   return x == 111
-</code>
-Demonstraţii:
+Observam ca numarul de copieri este cpy<sub>1</sub> + cpy<sub>2</sub> + cpy<sub>4</sub> + cpy<sub>8</sub> + ... + cpy<sub>n</sub> = 2 * n (suma geometrica). (1)
-  - $ f_{h}(M, w) = TRUE \Rightarrow M[w] \text{se termină} \Rightarrow \text{vom returna x == 111} \Rightarrow \text{când x este 111}, M^* \text{va tranziţiona în Y} => M^*[111] \rightarrow TRUE \Rightarrow f_{111}(M^*) = TRUE$
-  - $ f_{111}(M^*) = TRUE \Rightarrow M^*[111] \rightarrow TRUE \Rightarrow \text{am ajuns la return} \Rightarrow \text{run M[w] din }M^* \text{nu a ciclat} \Rightarrow \text{M[w] s-a oprit} \Rightarrow f_{h}(M, w) = TRUE$
-Din cele 2 direcţii ale demonstraţiei $\Rightarrow f_{h} \le_m f_{111}$.
+De asemenea, au avut loc n insert-uri, care au c = n. (2)
+Din (1) si (2) => ĉ<sub>i</sub> = T(n) / n = (2 * n + n) / n = 3.
-  * $ f_{p}(M) = TRUE \iff \forall w, M \text{ decide dacă w e palindrom} $
+=== ArrayList - stergere ===
-O să încercăm să arătăm că $ f_{h} \le_m f_{p}$.
+Raspuns = ĉ<sub>i</sub> = 2.
-Trebuie să găsim o transformare t care primeşte inputul lui Halting Problem şi întoarce un input pentru $ f_{p}$:
+Presupunem cel mai rau caz: capacitate = 4 * n, nr. elemente = n + 1 (delete va cauza o copiere, deoarece la primul delete ajungem la 1/4 din capacitate)
-$ M, w \to t \to M^*$
-$ M^*(x):$
+  * delete1: cpy<sub>n/2</sub> + c<sub>delete</sub> = n/2 + 1 -> capacitatea devine 2 * n
-<code>
+  * delete2: c<sub>delete</sub> = 1
-   run M[w]
+  * delete3: c<sub>delete</sub> = 1
-   check if x is palindrome
+  * ...
-</code>
+  * delete(n/2): cpy<sub>n/4</sub> + c<sub>delete</sub> = n/4 + 1 -> capacitatea devine n
-Demonstraţii:
+Observam ca numarul de copieri este cpy<sub>n/2</sub> + cpy<sub>n/4</sub> + cpy<sub>n/8</sub> + ... = n. (1)
-  - $ f_{h}(M, w) = TRUE \Rightarrow M[w] \text{se termină} \Rightarrow \text{o sa verificăm dacă x este palindrom} \Rightarrow \text{când x este palindrom}, M^* \text{va tranziţiona în Y}  \Rightarrow f_{p}(M^*) = TRUE$
-  - $ f_{p}(M^*) = TRUE \Rightarrow M^*[x] \text{decide daca x este palindrom } \forall x \Rightarrow \text{am ajuns la return} \Rightarrow \text{run M[w] din }M^* \text{nu a ciclat} \Rightarrow \text{M[w] s-a oprit} \Rightarrow f_{h}(M, w) = TRUE$
-Din cele 2 direcţii ale demonstraţiei $\Rightarrow f_{h} \le_m f_{p}$.
+Numarul de stergeri efective este n. (2)
-  * $ f_{rev}(M) = TRUE \iff \forall w, M \text{ computează inversul lui w}$
+Din (1) si (2) => ĉ<sub>i</sub> = T(n) / n = (n + n) / n = 2.
-O să încercăm să arătăm că $ f_{h} \le_m f_{rev}$.
-Trebuie să găsim o transformare t care primeşte inputul lui Halting Problem şi întoarce un input pentru $ f_{rev}$:
+=== ArrayList - cazul generic ===
-$ M, w \to t \to M^*$
-$ M^*(x):$
+Fie capacitatea initiala = 1, c<sub>i</sub> = costul inserarii, c<sub>d</sub> = costul stergerii.
-<code>
-   run M[w]
-   return rev(x)
-</code>
-Demonstraţii:
+Stim ca:
-  - $ f_{h}(M, w) = TRUE \Rightarrow M[w] \text{se termină} \Rightarrow \text{o sa calculeze rev(x) deoarece ajunge la return} \Rightarrow f_{rev}(M^*) = TRUE$
+  * c<sub>i</sub> = 1 pentru cazul fara copiere
-  - $ f_{rev}(M^*) = TRUE \Rightarrow M^*[x] \text{calculeaza rev(x) } \forall x \forall x \Rightarrow \text{am ajuns la return} \Rightarrow \text{run M[w] din }M^* \text{nu a ciclat} \Rightarrow \text{M[w] s-a oprit} \Rightarrow f_{h}(M, w) = TRUE$
+  * c<sub>i</sub> + m cazul pentru copiere si inserare
+  * c<sub>d</sub> = 1 pentru cazul fara copiere
+  * c<sub>d</sub> + m pentru cazul stergerii si copierii
+  * n<sub>final</sub> = k - p numarul final de elemente (elemente inserare - elemente sterse)
+  * nr<sub>operatii</sub> = k + p
-Din cele 2 direcţii ale demonstraţiei $\Rightarrow f_{h} \le_m f_{rev}$.
+=> ĉ<sub>i</sub> = C<sub>total</sub> / (k + p) = (C<sub>ins</sub> + C<sub>del</sub>) / (k + p)
-  * $ f_{own}(M) = TRUE \iff M[enc(M)] \rightarrow TRUE$
+Am stabilit precedent ca:
+  * costul tuturor copierilor la inserare este de 2k
+  * costul tuturor inserarilor efective este k
+  * => C<sub>ins</sub> = 3k
-O să încercăm să arătăm că $ f_{h} \le_m f_{own}$.
+De asemenea:
+  * costul tuturor copierilor la stergere este de p
+  * costul tuturor stergerilor efective este tot p
+  * => C<sub>del</sub> = 2p
-Trebuie să găsim o transformare t care primeşte inputul lui Halting Problem şi întoarce un input pentru $ f_{own}$:
+=> ĉ<sub>i</sub> = (3k + 2p) / (k + p)
-$ M, w \to t \to M^*$
-$ M^*(x):$
+Interpretare:
-<code>
+  * pentru p = 0, avem ĉ<sub>i</sub> = 3 (adevarat, asta este costul doar inserarilor)
-   if x == enc(M*):
+  * pentru k = 0 (presupunem ca avem deja un array), ĉ<sub>i</sub> = 2 (adevarat, costul stergerii)
-     run M[w]
+  * pentru k = p, avem ĉ<sub>i</sub> = 2.5
-   else:
+  * => costul amortizat este mai apropiat de 3 pentru mai multe inserari, dar mai apropiat de 2 pentru mai multe stergeri.
-     nu se termină
-</code>
-Demonstraţii:
+==== Metoda bancherului ====
-  - $ f_{h}(M, w) = TRUE \Rightarrow M[w] \text{se termină} \Rightarrow M^*[enc(M^*)] \text{se termina} \Rightarrow f_{own}(M^*) = TRUE$
-  - $ f_{own}(M^*) = TRUE \Rightarrow M^*[enc(M^*)] \text{se termina} \Rightarrow \text{run M[w] din }M^* \text{nu a ciclat} \Rightarrow \text{M[w] s-a oprit} \Rightarrow f_{h}(M, w) = TRUE$
-Din cele 2 direcţii ale demonstraţiei $\Rightarrow f_{h} \le_m f_{own}$.
+(pentru insertion: 3 bani -> 1 inserare, 1 banut atribuit inseratiei curente, 1 banut atribuit altei inseratii din bucata copiata precedent)
-  * $ f_{finite}(M) = TRUE \iff M \text{ se oprește pentru un număr finit de cuvinte}$
+Idee de rezolvare: impartim array-ul in 2 bucati:
+  * bucata care se va copia = elementele care raman dupa stergeri
+  * bucata elementelor care se sterg.
-O să încercăm să arătăm că $ f_{h} \le_m f_{finite}$.
+Pentru fiecare operatie de stergere (cost 1), "plasam" un banut catre prima bucata a array-ului (cea care se va copia). In acest fel, la momentul copierii, fiecare element are deja banutul pregatit care ii acopera costul. Astfel, nu mai trebuit platit un cost suplimentar pentru copiere.
+==== Metoda potentialelor ====
-Trebuie să găsim o transformare t care primeşte inputul lui Halting Problem şi întoarce un input pentru $ f_{finite}$:
+ĉ<sub>i</sub> = c<sub>i</sub> + Φ(D<sub>i</sub>) - Φ(D<sub>i-1</sub>).
-$ M, w \to t \to M^*$
-$ M^*(x):$
+Definim n = elemente curente, m = capacitate:
-<code>
-   run M[w] pentru maxim |x| paşi
-    dacă M[w] s-a oprit:
-     nu se termina
-    else:
-     se termina
-</code>
-Demonstraţii:
+Fie
-  - $ f_{h}(M, w) = TRUE \Rightarrow M[w] \text{ se termină in n paşi} \Rightarrow M^*[w] \text{se opreşte } \forall x \text{, |x| < n}, \text{ciclează } \forall x \text{, |x| >= n} \Rightarrow f_{finite}(M^*) = TRUE$
+    Φ(n,m) = 2n - m,  daca n >= m/2
-  - $ f_{finite}(M^*) = TRUE \Rightarrow M^*[x] \text{ se opreşte după un număr finit de cuvinte }\Rightarrow \text{M[w] s-a oprit după un număr finit de paşi} \Rightarrow f_{h}(M, w) = TRUE$
+           = m/2 - n, altfel
-Din cele 2 direcţii ale demonstraţiei $\Rightarrow f_{h} \le_m f_{finite}$.
+. Cazul stergerii in cazul in care capacitatea nu se schimba:
+  * c<sub>i</sub> = 1
+  * ΔΦ = Φ(n - 1, m) - Φ(n, m):
+    * caz 1: n > m/2 => ΔΦ = (2(n - 1) - m) - (2n - m) = -2
+    * caz 2: n = m/2 => ΔΦ = (m/2 - (n - 1)) - (2n - m) = 1 + 3m/2 - 3n, dar n = 3m/2 => ΔΦ = 1 + 3m/2 - 3m/2 = 1
+    * caz 3: n < m/2 => ΔΦ = (m/2 - (n - 1)) - (m/2 - n) = 1
-  * $ f_{set}(A, M) = TRUE \iff \forall w \in A, M[w] \text{ halts}$
+Aflam ca pentru un load factor de peste 1/2 (suntem aproape de capacitatea maxima) avem cost amortizat -1, iar 2 daca ne apropiem de injumatatire.
-O să încercăm să arătăm că $ f_{h} \le_m f_{set}$.
+<note important>In operatiile de analiza amortizata, noi luam drept cost amortizat costul operatiilor mai "scumpe", neluand in calcul operatiile "ieftine", deci ĉ<sub>i</sub> = 2 in acest caz, nu -1. </note>
-Trebuie să găsim o transformare t care primeşte inputul lui Halting Problem şi întoarce un input pentru $ f_{set}$:
+. Cazul stergerii in care capacitatea se schimba:
-$ M, w \to t \to A, M^*$
+  * Perechea (n, m) este de fapt (n + 1, 4 * n) -> (n, 2 * n)
+  * ΔΦ = Φ(n, 2 * n) - Φ(n + 1, 4 * n) = (2 * n - 2 * n) - (4 * n / 2 - n - 1) = 1 - n
+  * c<sub>i</sub> = 1 + n (deletion + copiere)
+  * ĉ<sub>i</sub> = 1 + n + (1 - n) = 2
-A = {101}
+===== Algebraic Data Types =====
-$ M^*(x):$
-<code>
-   if x is in A:
-    run M[w]
-   else:
-    nu se termină
-</code>
-Demonstraţii:
+. <code>
-  - $ f_{h}(M, w) = TRUE \Rightarrow M[w] \text{se termină} \Rightarrow \text{cum } M^* \text{se poate opri doar pentru x = 101} \Rightarrow f_{set}(A, M^*) = TRUE$
+typedef struct list {
-  - $ f_{set}(M^*) = TRUE \Rightarrow M^*[x] \text{o să se oprească pentru orice x din A} \Rightarrow \text{M[w] s-a oprit} \Rightarrow f_{h}(M, w) = TRUE$
+    int e;
+    struct list *next;
+} *List;
-Din cele 2 direcţii ale demonstraţiei $\Rightarrow f_{h} \le_m f_{set}$.
+List Void() {
+    return NULL;
+}
-  * $ f_{x}(M) = TRUE \iff \exists w, M[w] \text{ scrie un x pe bandă la un moment dat}$
+List Cons(int e, List list) {
+    List newElem = (List)malloc(sizeof(struct list));
+    newElem->e = e;
+    newElem->next = list;
-O să încercăm să arătăm că $ f_{h} \le_m f_{x}$.
+    return newElem;
+}
-Trebuie să găsim o transformare t care primeşte inputul lui Halting Problem şi întoarce un input pentru $ f_{x}$:
+</code>
-$ M, w \to t \to M^*$
+.
+<code>
-$ M^*(x):$
+Size(Void) = 0
+Size(Cons(e, L)) = 1 + Size(L)
+</code>
 <code>
-   run M[w]
+Add(Void, x) = Cons(x, Void)
-   print x
+Add(Cons(y, L), x) = Cons(y, Add(L, x)
+</code>
+<code>
+Append(Void, L) = L
+Append(Cons(x, L1), L2) = Cons(x, Append(L1, L2))
+</code>
+<code>
+Reverse(Void) = Void
+Reverse(Cons(x, L)) = Append(Reverse(L), Cons(x, Void))
+</code>
+Helper:
+<code>
+isNull(Void) = True
+isNull(Cons(x, L)) = False
 </code>
-Demonstraţii:
+.
-  - $ f_{h}(M, w) = TRUE \Rightarrow M[w] \text{se termină} \Rightarrow \text{cum } M^* \text{printează x la final} \Rightarrow f_{x}(M^*) = TRUE$
+<code>
-  - $ f_{x}(M^*) = TRUE \Rightarrow M^*[x] \text{ajunge să printeze x pe bandă} \Rightarrow \text{M[w] s-a oprit} \Rightarrow f_{h}(M, w) = TRUE$
+bool isNull(List l) {
+    return l == NULL;
+}
-Din cele 2 direcţii ale demonstraţiei $\Rightarrow f_{h} \le_m f_{x}$.
+int size(List l) {
+    if (isNull(l))
+        return 0;
+    return 1 + size(l->next);
+}
-  * $ f_{eq}(M_1, M_2) = TRUE \iff  \forall w, M_1[w] \equiv M_2[w]$; i.e. mașinile au același comportament (fie acceptă, fie resping, fie computează aceeași valoare, fie nu se termină) pentru orice cuvânt.
+List add(List l, int x) {
+    if isNull(l))
+        return Cons(x, Void());
+    return Cons(l->e, add(l->next, x));
+}
-O să încercăm să arătăm că $ f_{h} \le_m f_{eq}$.
+List append(List l1, List l2) {
+    if (isNull(l1))
+        return l2;
+    return Cons(l1->e, append(l1->next, l2));
+}
-Trebuie să găsim o transformare t care primeşte inputul lui Halting Problem şi întoarce un input pentru $ f_{eq}$:
+List reverse(List l) {
-$ M, w \to t \to M_{1}, M_{2}$
+    if (isNull(l))
+        return Void();
-$ M_{1}[x]: $
+    return append(reverse(l->next), Cons(l->e, Void()));
-<code>
+}
- acceptă
 </code>
-$ M_{2}[x]: $
-<code>
-   run M[w]
-   acceptă
-</code>
-Demonstraţii:
-  - $ f_{h}(M, w) = TRUE \Rightarrow M[w] \text{se termină} \Rightarrow M_{2} \text{acceptă orice x, iar } M_{1}[x] \text{deja acceptă orice x din construcţie} \Rightarrow M_1[w] \equiv M_2[w] \Rightarrow f_{eq}(M_{1}, M_{2}) = TRUE$
-  - $ f_{eq}(M_{1}, M_{2}) = TRUE \Rightarrow M_1[w] \equiv M_2[w] \Rightarrow \text{stim din construcţie că} M_{1} \text{acceptă orice x} \Rightarrow M_{2} \text{acceptă orice x} \Rightarrow M[w] \text{se opreşte} \Rightarrow f_{h}(M, w) = TRUE$
-Din cele 2 direcţii ale demonstraţiei $\Rightarrow f_{h} \le_m f_{eq}$.