34, 84, 104, 112, 134

Bench/026-remove_duplicates.py

@@ -43,7 +43,7 @@ def remove__duplicates(a : List[int]) -> List[int]:
 def exists_check(a : List[int], x : int) -> bool:
     Requires(Acc(list_pred(a), 1/2))
     return Exists(int, lambda d_0_i_:
-        (Implies(((0) <= (d_0_i_)) and ((d_0_i_) < (len((a)))), ((a)[d_0_i_]) == (x))))
+        ((((0) <= (d_0_i_)) and ((d_0_i_) < (len((a)))) and ((a)[d_0_i_]) == (x))))
 
 @Pure 
 def count_check(a : List[int], x : int) -> bool:

WIP/034-unique.py → Bench/034-unique.py

@@ -1,6 +1,14 @@
 from typing import cast, List, Dict, Set, Optional, Union
 from nagini_contracts.contracts import *
 
+@Pure
+def InArray(a : List[int], x : int) -> bool:
+    Requires(Acc(list_pred(a), 1/2))
+    return Exists(int, lambda d_0_i_:
+        ((((0) <= (d_0_i_)) and ((d_0_i_) < (len((a)))) and ((a)[d_0_i_]) == (x))))
+
+
+
 def uniqueSorted(s : List[int]) -> List[int]:
     Requires(Acc(list_pred(s)))
     Requires(Forall(int, lambda d_0_i_:
@@ -9,13 +17,13 @@ def uniqueSorted(s : List[int]) -> List[int]:
                 ((s)[d_0_i_]) <= ((s)[d_1_j_])))))
     Ensures(Acc(list_pred(s)))
     Ensures(Acc(list_pred(Result())))
-    # Ensures(Forall(int, lambda d_2_i_:
-    #     Forall(int, lambda d_3_j_:
-    #         not ((((0) <= (d_2_i_)) and ((d_2_i_) < (d_3_j_))) and ((d_3_j_) < (len(Result())))) or (((Result())[d_2_i_]) < ((Result())[d_3_j_])))))
-    # Ensures(Forall(int, lambda d_4_x_:
-    #     not ((d_4_x_) in (Result())) or ((d_4_x_) in (s))))
-    # Ensures(Forall(int, lambda d_5_x_:
-    #     not ((d_5_x_) in (s)) or ((d_5_x_) in (Result()))))
+    Ensures(Forall(int, lambda d_9_k_:
+        (Implies(((0) <= (d_9_k_)) and ((d_9_k_) < (len(Result()))), InArray(s, Result()[d_9_k_])))))
+    Ensures(Forall(int, lambda d_2_i_:
+        Forall(int, lambda d_3_j_:
+            not ((((0) <= (d_2_i_)) and ((d_2_i_) < (d_3_j_))) and ((d_3_j_) < (len(Result())))) or (((Result())[d_2_i_]) < ((Result())[d_3_j_])))))
+    Ensures(Forall(int, lambda d_11_j_:
+        (Implies(((0) <= (d_11_j_)) and ((d_11_j_) < (len(s))), InArray(Result(), s[d_11_j_])))))
     result = list([int(0)] * 0) # type : List[int]
     result = list([])
     d_6_i_ = int(0) # type : int
@@ -28,44 +36,24 @@ def uniqueSorted(s : List[int]) -> List[int]:
                 Implies((((0) <= (d_0_i_)) and ((d_0_i_) < (d_1_j_))) and ((d_1_j_) < (len(s))), 
                     ((s)[d_0_i_]) <= ((s)[d_1_j_])))))
         Invariant(((0) <= (d_6_i_)) and ((d_6_i_) <= (len(s))))
-        # Invariant(Forall(int, lambda d_7_k_:
-        #     Forall(int, lambda d_8_l_:
-        #         not ((((0) <= (d_7_k_)) and ((d_7_k_) < (d_8_l_))) and ((d_8_l_) < (len(result)))) or (((result)[d_7_k_]) < ((result)[d_8_l_])))))
         Invariant(Forall(int, lambda d_9_k_:
-            (Implies(((0) <= (d_9_k_)) and ((d_9_k_) < (len(result))), Exists(int, lambda d_10_m_:
-                (((0) <= (d_10_m_)) and ((d_10_m_) < (d_6_i_))) and (((result)[d_9_k_]) == ((s)[d_10_m_])))), [[(result)[d_9_k_]]])))
-        # Invariant(Forall(int, lambda d_11_k_:
-        #     (Forall(int, lambda d_12_l_:
-        #         (Implies(0 <= d_11_k_ and d_11_k_ < len(result), 
-        #             Implies(d_6_i_ <= d_12_l_ and d_12_l_ < len(s), result[d_11_k_] <= s[d_12_l_])), 
-        #             [[s[d_12_l_]]])), [[result[d_11_k_]]])))
-        # Invariant(Forall(int, lambda d_11_j_:
-        #     not (((0) <= (d_11_j_)) and ((d_11_j_) < (d_6_i_))) or (((s)[d_11_j_]) in (result))))
+            (Implies(((0) <= (d_9_k_)) and ((d_9_k_) < (len(result))), InArray(s, result[d_9_k_])), [[InArray(s, result[d_9_k_])]])))
+        Invariant(Implies(d_6_i_ < len(s), 
+            Forall(int, lambda d_2_i_:
+                (Implies(((0) <= (d_2_i_)) and ((d_2_i_) < (len(result))), result[d_2_i_] <= s[d_6_i_]), [[result[d_2_i_]]]))))
+        Invariant(Forall(int, lambda d_7_k_:
+            (Forall(int, lambda d_8_l_:
+                (not ((((0) <= (d_7_k_)) and ((d_7_k_) < (d_8_l_))) and ((d_8_l_) < (len(result)))) or (((result)[d_7_k_]) < ((result)[d_8_l_])), 
+                    [[(result)[d_8_l_]]])), 
+                [[(result)[d_7_k_]]])))
+        Invariant(Forall(int, lambda d_11_j_:
+            (Implies(((0) <= (d_11_j_)) and ((d_11_j_) < (d_6_i_)), InArray(result, s[d_11_j_])), [[]])))
         if ((len(result)) == (0)) or (((result)[(len(result)) - (1)]) != ((s)[d_6_i_])):
-            # Assert(((len(result)) == (0)) or (((result)[(len(result)) - (1)]) < ((s)[d_6_i_])))
-            # old_res = list(result)
-            # Assert(Forall(int, lambda d_9_k_:
-            #     (Implies(((0) <= (d_9_k_)) and ((d_9_k_) < (len(result))), Exists(int, lambda d_10_m_:
-            #         (((0) <= (d_10_m_)) and ((d_10_m_) < (d_6_i_))) and (((result)[d_9_k_]) == ((s)[d_10_m_])))), [[(result)[d_9_k_]]])))
-            # Assert(Forall(int, lambda d_9_k_: Implies(0 <= d_9_k_ and d_9_k_ < len(result), result[d_9_k_] == old_res[d_9_k_])))
-            # Assert(Forall(int, lambda d_9_k_:
-            #     (Implies(((0) <= (d_9_k_)) and ((d_9_k_) < (len(old_res))), Exists(int, lambda d_10_m_:
-            #         (((0) <= (d_10_m_)) and ((d_10_m_) < (d_6_i_))) and (((old_res)[d_9_k_]) == ((s)[d_10_m_])))), [[(old_res)[d_9_k_]]])))    
+            Assert(Implies(len(result) > 0, result[len(result) - 1] < s[d_6_i_]))
+            Assert(Implies(len(result) > 0, 
+                Forall(int, lambda d_11_j_:
+                    Implies(0 <= d_11_j_ and d_11_j_ < len(result), result[d_11_j_] < s[d_6_i_]))))
             result = (result) + [(s)[d_6_i_]]
-            # Assert(Exists(int, lambda d_10_m_:
-            #     (((0) <= (d_10_m_)) and ((d_10_m_) <= (d_6_i_))) and (((result)[len(result) - 1]) == ((s)[d_10_m_]))))
-            # Assert(Forall(int, lambda d_9_k_:
-            #     (Implies(((0) <= (d_9_k_)) and ((d_9_k_) < (len(old_res))), Exists(int, lambda d_10_m_:
-            #         (((0) <= (d_10_m_)) and ((d_10_m_) < (d_6_i_))) and (((old_res)[d_9_k_]) == ((s)[d_10_m_])))), [[(old_res)[d_9_k_]]])))    
-            # Assert(Forall(int, lambda d_9_k_:
-            #     (Implies(((0) <= (d_9_k_)) and ((d_9_k_) < (len(old_res))), Exists(int, lambda d_10_m_:
-            #         (((0) <= (d_10_m_)) and ((d_10_m_) <= (d_6_i_))) and (((old_res)[d_9_k_]) == ((s)[d_10_m_])))), [[(old_res)[d_9_k_]]])))    
-            # Assert(Forall(int, lambda d_9_k_:
-            #     (Implies(((0) <= (d_9_k_)) and ((d_9_k_) + 1 < (len(result))), Exists(int, lambda d_10_m_:
-            #         (((0) <= (d_10_m_)) and ((d_10_m_) <= (d_6_i_))) and (((result)[d_9_k_]) == ((s)[d_10_m_])))), [[(result)[d_9_k_]]])))    
-            # Assert(Forall(int, lambda d_9_k_:
-            #     (Implies(((0) <= (d_9_k_)) and ((d_9_k_) < (len(result))), Exists(int, lambda d_10_m_:
-            #         (((0) <= (d_10_m_)) and ((d_10_m_) <= (d_6_i_))) and (((result)[d_9_k_]) == ((s)[d_10_m_])))), [[(result)[d_9_k_]]])))    
         d_6_i_ = (d_6_i_) + (1)
     return result
 

Bench/084-solve.py

@@ -0,0 +1,27 @@
+from typing import cast, List, Dict, Set, Optional, Union, Tuple
+from nagini_contracts.contracts import *
+
+def solve(n : int) -> int:
+    Requires((n) >= (0))
+    Ensures(Result() >= 0)
+    Ensures((Result()) == (popcount(n)))
+    r = int(0) # type : int
+    d_0_m_ = int(0) # type : int
+    d_0_m_ = n
+    r = 0
+    while (d_0_m_) > (0):
+        Invariant(((0) <= (d_0_m_)) and ((d_0_m_) <= (n)))
+        Invariant(r >= 0)
+        Invariant(((r) + (popcount(d_0_m_))) == (popcount(n)))
+        r = (r) + ((d_0_m_ % 2))
+        d_0_m_ = (d_0_m_ // 2)
+    return r
+
+@Pure
+def popcount(n : int) -> int :
+    Requires(n >= 0)
+    if n == 0:
+        return 0
+    else:
+        return (n % 2) + popcount(n // 2)
+

Bench/104-unique_digits.py

@@ -0,0 +1,145 @@
+from typing import cast, List, Dict, Set, Optional, Union
+from nagini_contracts.contracts import *
+
+
+@Pure
+def InArray(a : List[int], x : int) -> bool:
+    Requires(Acc(list_pred(a), 1/2))
+    return Exists(int, lambda d_0_i_:
+        ((((0) <= (d_0_i_)) and ((d_0_i_) < (len((a)))) and ((a)[d_0_i_]) == (x))))
+
+@Pure
+def HasNoEvenDigit(n : int) -> bool :
+    Requires(((0) <= (n)))
+    return (n == 0 or (((((n % 10) % 2)) != (0)) and (HasNoEvenDigit((n // 10)))))
+
+def UniqueDigits(x : List[int]) -> List[int]:
+    Requires(Acc(list_pred(x), 1/2))
+    Requires(Forall(int, lambda d_0_i_: Implies(d_0_i_ >= 0 and d_0_i_ < len(x), (x[d_0_i_] >= 0))))
+    Ensures(Acc(list_pred(x), 1/2))
+    Ensures(Acc(list_pred(Result())))
+    Ensures(len(Result()) <= len(x))
+    Ensures(Forall(int, lambda d_0_i_: Implies(d_0_i_ >= 0 and d_0_i_ < len(x), (x[d_0_i_] >= 0))))
+    Ensures(Forall(int, lambda d_0_i_: Implies(d_0_i_ >= 0 and d_0_i_ < len(Result()), (Result()[d_0_i_] >= 0))))
+    Ensures(Forall(int, lambda d_0_i_:
+        not (((0) <= (d_0_i_)) and ((d_0_i_) < (len(Result())))) or (HasNoEvenDigit((Result())[d_0_i_]))))
+    Ensures(Forall(int, lambda d_8_e_:
+        not (((d_8_e_) >= 0 and d_8_e_ < len(x)) and (HasNoEvenDigit(x[d_8_e_]))) or 
+            (Exists(int, lambda d_9_j_: 
+                (d_9_j_ >= 0 and d_9_j_ < len(Result())) and Result()[d_9_j_] == x[d_8_e_]))))
+    Ensures(Forall(int, lambda d_7_e_:
+        not ((d_7_e_) >= 0 and d_7_e_ < len(Result())) or (InArray(x, Result()[d_7_e_]))))
+    Ensures(Forall(int, lambda d_1_i_:
+        Forall(int, lambda d_2_j_:
+            not ((((0) <= (d_1_i_)) and ((d_1_i_) < (d_2_j_))) and ((d_2_j_) < (len(Result())))) or (((Result())[d_1_i_]) <= ((Result())[d_2_j_])))))
+    result = list([int(0)] * 0) # type : List[int]
+    result = list([])
+    d_5_i_ = 0
+
+    while d_5_i_ < len(x):
+        Invariant(Acc(list_pred(result)))
+        Invariant(Acc(list_pred(x), 1/2))
+        Invariant(0 <= d_5_i_ and d_5_i_ <= len(x))
+        Invariant(len(result) <= d_5_i_)
+        Invariant(Forall(int, lambda d_0_i_: Implies(d_0_i_ >= 0 and d_0_i_ < len(x), (x[d_0_i_] >= 0))))
+        Invariant(Forall(int, lambda d_0_i_: Implies(d_0_i_ >= 0 and d_0_i_ < len(result), (result[d_0_i_] >= 0))))
+        Invariant(Forall(int, lambda d_6_j_:
+            (Implies(((0) <= (d_6_j_)) and ((d_6_j_) < (len(result))), HasNoEvenDigit((result)[d_6_j_])), [[HasNoEvenDigit((result)[d_6_j_])]])))
+        Invariant(Forall(int, lambda d_8_e_:
+            (Implies(((d_8_e_) >= 0 and d_8_e_ < d_5_i_) and (HasNoEvenDigit(x[d_8_e_])), 
+                Exists(int, lambda d_9_j_: 
+                    (d_9_j_ >= 0 and d_9_j_ < len(result)) and result[d_9_j_] == x[d_8_e_])), 
+                [[(HasNoEvenDigit(x[d_8_e_]))]])))
+        Invariant(Forall(int, lambda d_7_e_:
+            (Implies((d_7_e_) >= 0 and d_7_e_ < len(result), 
+                InArray(x, result[d_7_e_])), 
+                [[InArray(x, result[d_7_e_])]])))
+        if HasNoEvenDigit((x)[d_5_i_]):
+            result = (result) + [(x)[d_5_i_]]
+        d_5_i_ = (d_5_i_) + (1)
+    d_9_i_ = int(0) # type : int
+    d_9_i_ = 0
+    while (d_9_i_) < (len(result)):
+        Invariant(Acc(list_pred(result)))
+        Invariant(Acc(list_pred(x), 1/2))
+        Invariant(len(result) <= len(x))
+        Invariant(((0) <= (d_9_i_)) and ((d_9_i_) <= (len(result))))
+        Invariant(Forall(int, lambda d_0_i_: 
+            (Implies(d_0_i_ >= 0 and d_0_i_ < len(x), (x[d_0_i_] >= 0)), [[x[d_0_i_]]])))
+        Invariant(Forall(int, lambda d_0_i_: 
+            (Implies(d_0_i_ >= 0 and d_0_i_ < len(result), (result[d_0_i_] >= 0)), [[result[d_0_i_]]])))
+        Invariant(Forall(int, lambda d_6_j_:
+            (Implies(((0) <= (d_6_j_)) and ((d_6_j_) < (len(result))), HasNoEvenDigit((result)[d_6_j_])), [[HasNoEvenDigit((result)[d_6_j_])]])))
+        Invariant(Forall(int, lambda d_8_e_:
+            (Implies(((d_8_e_) >= 0 and d_8_e_ < len(x)) and (HasNoEvenDigit(x[d_8_e_])), 
+                Exists(int, lambda d_9_j_: 
+                    (d_9_j_ >= 0 and d_9_j_ < len(result)) and result[d_9_j_] == x[d_8_e_])), 
+                [[(HasNoEvenDigit(x[d_8_e_]))]])))
+        Invariant(Forall(int, lambda d_7_e_:
+            (Implies((d_7_e_) >= 0 and d_7_e_ < len(result), 
+                InArray(x, result[d_7_e_])), 
+                [[InArray(x, result[d_7_e_])]])))
+        Invariant(Forall(int, lambda d_10_j_:
+            (Forall(int, lambda d_11_k_:
+                (not ((((0) <= (d_10_j_)) and ((d_10_j_) < (d_11_k_))) and ((d_11_k_) < (d_9_i_))) or (((result)[d_10_j_]) <= ((result)[d_11_k_])), 
+                 [[(result)[d_11_k_]]])), 
+                [[(result)[d_10_j_]]])))
+        Invariant(Forall(int, lambda d_12_j_:
+            (not ((((0) <= (d_12_j_)) and ((d_12_j_) < (d_9_i_)))) or 
+                (Forall(int, lambda d_13_k_:
+                    (not ((((d_9_i_) <= (d_13_k_)) and ((d_13_k_) < (len(result))))) or 
+                        (((result)[d_12_j_]) <= ((result)[d_13_k_])), 
+                    [[result[d_13_k_]]]))), 
+                [[(result)[d_12_j_]]])))
+        d_17_minIndex_ = int(0) # type : int
+        d_17_minIndex_ = d_9_i_
+        d_18_j_ = int(0) # type : int
+        d_18_j_ = (d_9_i_) + (1)
+        while (d_18_j_) < (len(result)):
+            Invariant(Acc(list_pred(result)))
+            Invariant(Acc(list_pred(x), 1/2))    
+            Invariant(len(result) <= len(x))
+            Invariant(((0) <= (d_9_i_)) and ((d_9_i_) < (len(result))))
+            Invariant(Forall(int, lambda d_0_i_: 
+                (Implies(d_0_i_ >= 0 and d_0_i_ < len(x), (x[d_0_i_] >= 0)), [[x[d_0_i_]]])))
+            Invariant(Forall(int, lambda d_0_i_: 
+                (Implies(d_0_i_ >= 0 and d_0_i_ < len(result), (result[d_0_i_] >= 0)), [[result[d_0_i_]]])))
+            Invariant((((d_9_i_) <= (d_17_minIndex_)) and ((d_17_minIndex_) < (d_18_j_))) and ((d_18_j_) <= (len(result))))
+            Invariant(Forall(int, lambda d_6_j_:
+                (Implies(((0) <= (d_6_j_)) and ((d_6_j_) < (len(result))), HasNoEvenDigit((result)[d_6_j_])), [[HasNoEvenDigit((result)[d_6_j_])]])))
+            Invariant(HasNoEvenDigit((result)[d_17_minIndex_]))
+            Invariant(Forall(int, lambda d_8_e_:
+                (Implies(((d_8_e_) >= 0 and d_8_e_ < len(x)) and (HasNoEvenDigit(x[d_8_e_])), 
+                    Exists(int, lambda d_9_j_: 
+                        (d_9_j_ >= 0 and d_9_j_ < len(result)) and result[d_9_j_] == x[d_8_e_])), 
+                    [[(HasNoEvenDigit(x[d_8_e_]))]])))
+            Invariant(Forall(int, lambda d_7_e_:
+                (Implies((d_7_e_) >= 0 and d_7_e_ < len(result), 
+                    InArray(x, result[d_7_e_])), 
+                    [[InArray(x, result[d_7_e_])]])))
+            Invariant(Forall(int, lambda d_10_j_:
+                (Forall(int, lambda d_11_k_:
+                    (not ((((0) <= (d_10_j_)) and ((d_10_j_) < (d_11_k_))) and ((d_11_k_) < (d_9_i_))) or (((result)[d_10_j_]) <= ((result)[d_11_k_])), 
+                    [[(result)[d_11_k_]]])), 
+                [[(result)[d_10_j_]]])))
+            Invariant(Forall(int, lambda d_19_k_:
+                (not (((d_9_i_) <= (d_19_k_)) and ((d_19_k_) < (d_18_j_))) or (((result)[d_17_minIndex_]) <= ((result)[d_19_k_])), [[((result)[d_19_k_])]])))
+            Invariant(Forall(int, lambda d_12_j_:
+                (not ((((0) <= (d_12_j_)) and ((d_12_j_) < (d_9_i_)))) or 
+                    (Forall(int, lambda d_13_k_:
+                        (not ((((d_9_i_) <= (d_13_k_)) and ((d_13_k_) < (len(result))))) or 
+                            (((result)[d_12_j_]) <= ((result)[d_13_k_])), 
+                        [[result[d_13_k_]]]))), 
+                    [[(result)[d_12_j_]]])))
+            if ((result)[d_18_j_]) < ((result)[d_17_minIndex_]):
+                d_17_minIndex_ = d_18_j_
+            d_18_j_ = (d_18_j_) + (1)
+        if (d_17_minIndex_) != (d_9_i_):
+            d_20_temp_ = int(0) # type : int
+            d_20_temp_ = (result)[d_9_i_]
+            Assert(HasNoEvenDigit((result)[d_17_minIndex_]))
+            result[d_9_i_] = (result)[d_17_minIndex_]
+            Assert(HasNoEvenDigit(d_20_temp_))
+            result[d_17_minIndex_] = d_20_temp_
+        d_9_i_ = (d_9_i_) + (1)
+    return result

Bench/112-reverse_delete.py

@@ -5,7 +5,7 @@
 def InArray(a : List[int], x : int) -> bool :
     Requires(Acc(list_pred(a)))
     return Exists(int, lambda d_0_i_:
-        (Implies(((0) <= (d_0_i_)) and ((d_0_i_) < (len((a)))), ((a)[d_0_i_]) == (x))))
+        ((((0) <= (d_0_i_)) and ((d_0_i_) < (len((a)))) and ((a)[d_0_i_]) == (x))))
 
 @Pure 
 def NotInArray(a : List[int], x : int) -> bool :
@@ -46,13 +46,11 @@ def reverse__delete(s : List[int], chars : List[int]) -> Tuple[List[int], bool]:
         Invariant(Forall(int, lambda d_5_i_:
             (not (((0) <= (d_5_i_)) and ((d_5_i_) < (len(res)))) or (InArray(s, res[d_5_i_])), [[InArray(s, res[d_5_i_])]])))
         Invariant(Forall(int, lambda d_6_j_:
-            (not ((((0) <= (d_6_j_)) and ((d_6_j_) < (d_3_i_)))) or (implArrays(chars, res, (s)[d_6_j_])), [[implArrays(chars, res, (s)[d_6_j_])]])))
+            (not ((((0) <= (d_6_j_)) and ((d_6_j_) < (d_3_i_)))) or (implArrays(chars, res, (s)[d_6_j_])), [[InArray(res, (s)[d_6_j_])]])))
         if NotInArray(chars, (s)[d_3_i_]):
             res = (res) + [(s)[d_3_i_]]
         d_3_i_ = (d_3_i_) + (1)
     is__palindrome = is__palindrome__fun(res)
-    Assert(Forall(int, lambda d_4_i_:
-        (not (((0) <= (d_4_i_)) and ((d_4_i_) < (len(res)))) or (NotInArray(chars, (res)[d_4_i_])), [[NotInArray(chars, (res)[d_4_i_])]])))
     return (res, is__palindrome)
 
 def is__palindrome__fun(text : List[int]) -> bool:

Bench/134-check_if_last_char_is_a_letter.py

@@ -0,0 +1,14 @@
+from typing import cast, List, Dict, Set, Optional, Union
+from nagini_contracts.contracts import *
+
+def check__if__last__char__is__a__letter(s : List[int]) -> bool:
+    Requires(Acc(list_pred(s)))
+    Ensures(Acc(list_pred(s)))
+    Ensures((Result()) == ((((len(s)) > (0)) and (is__alpha((s)[(len(s)) - (1)]))) and (((len(s)) == (1)) or (((s)[(len(s)) - (2)]) == (32)))))
+    b = False # type : bool
+    b = (((len(s)) > (0)) and (is__alpha((s)[(len(s)) - (1)]))) and (((len(s)) == (1)) or (((s)[(len(s)) - (2)]) == (32)))
+    return b
+
+@Pure
+def is__alpha(c : int) -> bool :
+    return (((97) <= (c)) and ((c) <= (122))) or (((65) <= (c)) and ((c) <= (90)))

README.md

@@ -37,7 +37,7 @@ Current status:
 - [x] 31. is_prime
 - [ ] 32. poly
 - [x] 33. sort_third
-- [ ] 34. unique
+- [x] 34. unique
 - [x] 35. max_element
 - [ ] 36. fizz_buzz
 - [x] 37. sort_even
@@ -87,7 +87,7 @@ Current status:
 - [ ] 81. numerical_letter_grade
 - [x] 82. prime_length
 - [x] 83. starts_one_ends
-- [ ] 84. solve
+- [x] 84. solve
 - [x] 85. add
 - [ ] 86. anti_shuffle
 - [ ] 87. get_row
@@ -107,7 +107,7 @@ Current status:
 - [ ] 101. words_string
 - [x] 102. choose_num
 - [ ] 103. rounded_avg
-- [ ] 104. unique_digits
+- [x] 104. unique_digits
 - [x] 105. by_length
 - [x] 106. f
 - [ ] 107. even_odd_palindrome
@@ -137,7 +137,7 @@ Current status:
 - [ ] 131. digits
 - [ ] 132. is_nested
 - [x] 133. sum_squares
-- [ ] 134. check_if_last_char_is_a_letter
+- [x] 134. check_if_last_char_is_a_letter
 - [x] 135. can_arrange
 - [x] 136. largest_smallest_integers
 - [ ] 137. compare_one