diff --git a/bit_manipulation/find_unique_number.py b/bit_manipulation/find_unique_number.py
new file mode 100644
index 000000000000..77970b4865d1
--- /dev/null
+++ b/bit_manipulation/find_unique_number.py
@@ -0,0 +1,37 @@
+def find_unique_number(arr: list[int]) -> int:
+    """
+    Given a list of integers where every element appears twice except for one,
+    this function returns the element that appears only once using bitwise XOR.
+
+    >>> find_unique_number([1, 1, 2, 2, 3])
+    3
+    >>> find_unique_number([4, 5, 4, 6, 6])
+    5
+    >>> find_unique_number([7])
+    7
+    >>> find_unique_number([10, 20, 10])
+    20
+    >>> find_unique_number([])
+    Traceback (most recent call last):
+        ...
+    ValueError: input list must not be empty
+    >>> find_unique_number([1, 'a', 1])
+    Traceback (most recent call last):
+        ...
+    TypeError: all elements must be integers
+    """
+    if not arr:
+        raise ValueError("input list must not be empty")
+    if not all(isinstance(x, int) for x in arr):
+        raise TypeError("all elements must be integers")
+
+    result = 0
+    for num in arr:
+        result ^= num
+    return result
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
diff --git a/linear_algebra/matrix_inversion.py b/linear_algebra/matrix_inversion.py
new file mode 100644
index 000000000000..50dae1c2e825
--- /dev/null
+++ b/linear_algebra/matrix_inversion.py
@@ -0,0 +1,36 @@
+import numpy as np
+
+
+def invert_matrix(matrix: list[list[float]]) -> list[list[float]]:
+    """
+    Returns the inverse of a square matrix using NumPy.
+
+    Parameters:
+    matrix (list[list[float]]): A square matrix.
+
+    Returns:
+    list[list[float]]: Inverted matrix if invertible, else raises error.
+
+    >>> invert_matrix([[4.0, 7.0], [2.0, 6.0]])
+    [[0.6000000000000001, -0.7000000000000001], [-0.2, 0.4]]
+    >>> invert_matrix([[1.0, 2.0], [0.0, 0.0]])
+    Traceback (most recent call last):
+        ...
+    ValueError: Matrix is not invertible
+    """
+    np_matrix = np.array(matrix)
+
+    try:
+        inv_matrix = np.linalg.inv(np_matrix)
+    except np.linalg.LinAlgError:
+        raise ValueError("Matrix is not invertible")
+
+    return inv_matrix.tolist()
+
+
+if __name__ == "__main__":
+    mat = [[4.0, 7.0], [2.0, 6.0]]
+    print("Original Matrix:")
+    print(mat)
+    print("Inverted Matrix:")
+    print(invert_matrix(mat))
diff --git a/project_euler/problem_122/__init__.py b/project_euler/problem_122/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_122/sol1.py b/project_euler/problem_122/sol1.py
new file mode 100644
index 000000000000..cd8b1e67708c
--- /dev/null
+++ b/project_euler/problem_122/sol1.py
@@ -0,0 +1,89 @@
+"""
+Project Euler Problem 122: https://projecteuler.net/problem=122
+
+Efficient Exponentiation
+
+The most naive way of computing n^15 requires fourteen multiplications:
+
+                                               n x n x ... x n = n^15.
+
+But using a "binary" method you can compute it in six multiplications:
+
+                                                         n x n = n^2
+                                                     n^2 x n^2 = n^4
+                                                     n^4 x n^4 = n^8
+                                                     n^8 x n^4 = n^12
+                                                    n^12 x n^2 = n^14
+                                                      n^14 x n = n^15
+
+However it is yet possible to compute it in only five multiplications:
+
+                                                                n x n = n^2
+                                                              n^2 x n = n^3
+                                                            n^3 x n^3 = n^6
+                                                            n^6 x n^6 = n^12
+                                                           n^12 x n^3 = n^15
+
+We shall define m(k) to be the minimum number of multiplications to compute n^k;
+for example m(15) = 5.
+
+Find sum_{k = 1}^200 m(k).
+
+It uses the fact that for rather small n, applicable for this problem, the solution
+for each number can be formed by increasing the largest element.
+
+References:
+- https://en.wikipedia.org/wiki/Addition_chain
+"""
+
+
+def solve(nums: list[int], goal: int, depth: int) -> bool:
+    """
+    Checks if nums can have a sum equal to goal, given that length of nums does
+    not exceed depth.
+
+    >>> solve([1], 2, 2)
+    True
+    >>> solve([1], 2, 0)
+    False
+    """
+    if len(nums) > depth:
+        return False
+    for el in nums:
+        if el + nums[-1] == goal:
+            return True
+        nums.append(el + nums[-1])
+        if solve(nums=nums, goal=goal, depth=depth):
+            return True
+        del nums[-1]
+    return False
+
+
+def solution(n: int = 200) -> int:
+    """
+    Calculates sum of smallest number of multiplactions for each number up to
+    and including n.
+
+    >>> solution(1)
+    0
+    >>> solution(2)
+    1
+    >>> solution(14)
+    45
+    >>> solution(15)
+    50
+    """
+    total = 0
+    for i in range(2, n + 1):
+        max_length = 0
+        while True:
+            nums = [1]
+            max_length += 1
+            if solve(nums=nums, goal=i, depth=max_length):
+                break
+        total += max_length
+    return total
+
+
+if __name__ == "__main__":
+    print(f"{solution() = }")