Added Implementation of NAND, OR ,XNOR and NOT gates in python (#7596)

* Added Implementation for XNOR gate

* Added Implementation for OR gate

* Added implementation of NAND gate

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Added Implementation of NAND gate

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Updated nand_gate.py

* updated xnor_gate.py after some changes

* Delete due to duplicate file

* Updated xnor_gate.py

* Added Implementation of NOT gate in python

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* fixed a typo error

* Updated to a new logic

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Updated nand_gate.py file

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

boolean_algebra/nand_gate.py

@@ -0,0 +1,47 @@
+"""
+A NAND Gate is a logic gate in boolean algebra which results to 0 (False) if both
+the inputs are 1, and 1 (True) otherwise. It's similar to adding
+a NOT gate along with an AND gate.
+Following is the truth table of a NAND Gate:
+    ------------------------------
+    | Input 1 | Input 2 | Output |
+    ------------------------------
+    |    0    |    0    |    1   |
+    |    0    |    1    |    1   |
+    |    1    |    0    |    1   |
+    |    1    |    1    |    0   |
+    ------------------------------
+Refer - https://www.geeksforgeeks.org/logic-gates-in-python/
+"""
+
+
+def nand_gate(input_1: int, input_2: int) -> int:
+    """
+    Calculate NAND of the input values
+    >>> nand_gate(0, 0)
+    1
+    >>> nand_gate(0, 1)
+    1
+    >>> nand_gate(1, 0)
+    1
+    >>> nand_gate(1, 1)
+    0
+    """
+    return int((input_1, input_2).count(0) != 0)
+
+
+def test_nand_gate() -> None:
+    """
+    Tests the nand_gate function
+    """
+    assert nand_gate(0, 0) == 1
+    assert nand_gate(0, 1) == 1
+    assert nand_gate(1, 0) == 1
+    assert nand_gate(1, 1) == 0
+
+
+if __name__ == "__main__":
+    print(nand_gate(0, 0))
+    print(nand_gate(0, 1))
+    print(nand_gate(1, 0))
+    print(nand_gate(1, 1))

boolean_algebra/not_gate.py

@@ -0,0 +1,37 @@
+"""
+A NOT Gate is a logic gate in boolean algebra which results to 0 (False) if the
+input is high, and 1 (True) if the input is low.
+Following is the truth table of a XOR Gate:
+    ------------------------------
+    | Input   |  Output |
+    ------------------------------
+    |    0    |    1    |
+    |    1    |    0    |
+    ------------------------------
+Refer - https://www.geeksforgeeks.org/logic-gates-in-python/
+"""
+
+
+def not_gate(input_1: int) -> int:
+    """
+    Calculate NOT of the input values
+    >>> not_gate(0)
+    1
+    >>> not_gate(1)
+    0
+    """
+
+    return 1 if input_1 == 0 else 0
+
+
+def test_not_gate() -> None:
+    """
+    Tests the not_gate function
+    """
+    assert not_gate(0) == 1
+    assert not_gate(1) == 0
+
+
+if __name__ == "__main__":
+    print(not_gate(0))
+    print(not_gate(1))

boolean_algebra/or_gate.py

@@ -0,0 +1,46 @@
+"""
+An OR Gate is a logic gate in boolean algebra which results to 0 (False) if both the
+inputs are 0, and 1 (True) otherwise.
+Following is the truth table of an AND Gate:
+    ------------------------------
+    | Input 1 | Input 2 | Output |
+    ------------------------------
+    |    0    |    0    |    0   |
+    |    0    |    1    |    1   |
+    |    1    |    0    |    1   |
+    |    1    |    1    |    1   |
+    ------------------------------
+Refer - https://www.geeksforgeeks.org/logic-gates-in-python/
+"""
+
+
+def or_gate(input_1: int, input_2: int) -> int:
+    """
+    Calculate OR of the input values
+    >>> or_gate(0, 0)
+    0
+    >>> or_gate(0, 1)
+    1
+    >>> or_gate(1, 0)
+    1
+    >>> or_gate(1, 1)
+    1
+    """
+    return int((input_1, input_2).count(1) != 0)
+
+
+def test_or_gate() -> None:
+    """
+    Tests the or_gate function
+    """
+    assert or_gate(0, 0) == 0
+    assert or_gate(0, 1) == 1
+    assert or_gate(1, 0) == 1
+    assert or_gate(1, 1) == 1
+
+
+if __name__ == "__main__":
+    print(or_gate(0, 1))
+    print(or_gate(1, 0))
+    print(or_gate(0, 0))
+    print(or_gate(1, 1))

boolean_algebra/xnor_gate.py

@@ -0,0 +1,48 @@
+"""
+A XNOR Gate is a logic gate in boolean algebra which results to 0 (False) if both the
+inputs are different, and 1 (True), if the inputs are same.
+It's similar to adding a NOT gate to an XOR gate
+
+Following is the truth table of a XNOR Gate:
+    ------------------------------
+    | Input 1 | Input 2 | Output |
+    ------------------------------
+    |    0    |    0    |    1   |
+    |    0    |    1    |    0   |
+    |    1    |    0    |    0   |
+    |    1    |    1    |    1   |
+    ------------------------------
+Refer - https://www.geeksforgeeks.org/logic-gates-in-python/
+"""
+
+
+def xnor_gate(input_1: int, input_2: int) -> int:
+    """
+    Calculate XOR of the input values
+    >>> xnor_gate(0, 0)
+    1
+    >>> xnor_gate(0, 1)
+    0
+    >>> xnor_gate(1, 0)
+    0
+    >>> xnor_gate(1, 1)
+    1
+    """
+    return 1 if input_1 == input_2 else 0
+
+
+def test_xnor_gate() -> None:
+    """
+    Tests the xnor_gate function
+    """
+    assert xnor_gate(0, 0) == 1
+    assert xnor_gate(0, 1) == 0
+    assert xnor_gate(1, 0) == 0
+    assert xnor_gate(1, 1) == 1
+
+
+if __name__ == "__main__":
+    print(xnor_gate(0, 0))
+    print(xnor_gate(0, 1))
+    print(xnor_gate(1, 0))
+    print(xnor_gate(1, 1))