New version with english comments

boolean_algebra/and_gate.py

@@ -1,8 +1,8 @@
 """
-An AND Gate is a logic gate in boolean algebra which results to 1 (True) if both the
-inputs are 1, and 0 (False) otherwise.
+An AND Gate is a logic gate in boolean algebra which results to 1 (True) if all the
+inputs are 1 (True), and 0 (False) otherwise.
 
-Following is the truth table of an AND Gate:
+Following is the truth table of a Two Input AND Gate:
     ------------------------------
     | Input 1 | Input 2 | Output |
     ------------------------------
@@ -12,7 +12,7 @@
     |    1    |    1    |    1   |
     ------------------------------
 
-Refer - https://www.geeksforgeeks.org/logic-gates-in-python/
+Refer - https://www.geeksforgeeks.org/logic-gates/
 """
 
 
@@ -32,6 +32,18 @@ def and_gate(input_1: int, input_2: int) -> int:
     return int(input_1 and input_2)
 
 
+def n_input_and_gate(inputs: list[int]) -> int:
+    """
+    Calculate AND of a list of input values
+
+    >>> n_input_and_gate([1, 0, 1, 1, 0])
+    0
+    >>> n_input_and_gate([1, 1, 1, 1, 1])
+    1
+    """
+    return int(all(inputs))
+
+
 if __name__ == "__main__":
     import doctest
 

other/time_algo_exec.py

@@ -0,0 +1,40 @@
+# Author : Bosolindo Edhiengene Roger
+# email  : [email protected]
+
+# This module contains codes about algorithms complexity as to estimate the time an algorithm
+# will take to be run. Why do we find it usable ? Because, knowing this kind of information tells
+# you if your code or solution is efficient or not ; it helps you not to fall trying to run such a code.
+
+
+def calc(operations: dict) -> float:
+    """
+    calc(operation: dict) -> float:
+    This function aims to calculate how long an algorithm take, knowing only primary operations
+    :param operations: A dictionary where the values are tuples, consisting of the number of times
+                       an operation is performed and its execution time, and the key should
+                       preferably be the name of the operation for better clarity and usability.
+    :return: the time needed for the execution of this algorithm(if format is okey for "operations") or 0
+    #>>> operations1 = {"addition":(2, 0.1), "subtraction":(1, 0.2)}
+    #>>> operations2 = {"addition":(2, 0.1), "subtraction":(1, 0.2, 1)}
+    #>>> calc(operations1)
+    #>>> 0.4
+    #>>> calc(operations2)
+    #>>> 0
+    """
+    temps = 0
+    for couple in operations.values():
+        if len(couple) != 2:
+            return 0
+        temps += couple[0] * couple[1]
+
+    return temps
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
+    operations1 = {"addition": (2, 0.1), "subtraction": (1, 0.2)}
+    operations2 = {"addition": (2, 0.1), "subtraction": (1, 0.2, 1)}
+    print(calc(operations1))
+    print(calc(operations2))