feat(algorithms, matrix): transpose matrix

Author: BrianLusina

algorithms/matrix/transpose/README.md

@@ -0,0 +1,156 @@
+# Transpose
+
+Take input text and output it transposed.
+
+Given an input text output it transposed.
+
+Roughly explained, the transpose of a matrix:
+
+```
+ABC
+DEF
+```
+
+is given by:
+
+```
+AD
+BE
+CF
+```
+
+Rows become columns and columns become rows. See <https://en.wikipedia.org/wiki/Transpose>.
+
+If the input has rows of different lengths, this is to be solved as follows:
+
+- Pad to the left with spaces.
+- Don't pad to the right.
+
+Therefore, transposing this matrix:
+
+```
+ABC
+DE
+```
+
+results in:
+
+```
+AD
+BE
+C
+```
+
+And transposing:
+
+```
+AB
+DEF
+```
+
+results in:
+
+```
+AD
+BE
+ F
+```
+
+In general, all characters from the input should also be present in the transposed output. That means that if a column
+in the input text contains only spaces on its bottom-most row(s), the corresponding output row should contain the spaces
+in its right-most column(s).
+
+## Source
+
+Reddit r/dailyprogrammer challenge #270 [Easy]
+. [https://www.reddit.com/r/dailyprogrammer/comments/4msu2x/challenge_270_easy_transpose_the_input_text](https://www.reddit.com/r/dailyprogrammer/comments/4msu2x/challenge_270_easy_transpose_the_input_text)
+
+
+--
+
+# Transpose Matrix
+
+You're given a 2D array of integers <span>matrix</span>. Write a function that returns the transpose of the matrix.
+
+The transpose of a matrix is a flipped version of the original matrix across its main diagonal (which runs from top-left
+to bottom-right); it switches the row and column indices of the original matrix.
+
+You can assume the input matrix always has at least 1 value; however its width and height are not necessarily the same.
+
+## Examples
+
+Example 1:
+
+```text
+Input:
+matrix = [
+    [1, 2],
+]
+
+Output:
+[
+    [1],
+    [2]
+]
+```
+
+Example 2:
+
+```text
+Input:
+matrix = [
+    [1, 2],
+    [3, 4],
+    [5, 6],
+]
+
+Output:
+[
+    [1, 3, 5],
+    [2, 4, 6],
+]
+```
+
+Example 3:
+
+```text
+Input:
+matrix = [
+    [1, 2, 3],
+    [4, 5, 6],
+    [7, 8, 9],
+]
+
+Output:
+[
+    [1, 4, 7],
+    [2, 5, 8],
+    [3, 6, 9],
+]
+```
+
+## Hints
+
+- The row and column indices of each entry in the matrix should be flipped. For example, the value at `matrix[1][2]` will
+  be at `matrix[2][1]` in the transpose of the matrix.
+- Each column in the matrix should be become a row in the transpose of the matrix. Each row in the matrix should become 
+  a column in the transpose of the matrix.
+- Try iterating one column at a time, and with each column, create a row of the values to add to the transpose of the
+  matrix.
+
+## Solution
+
+The transpose of a matrix `A` with dimensions `R x C` is a matrix `ans` with dimensions C x R for which `ans[c][r]` = `A[r][c]`.
+
+Let's initialize a new matrix ans representing the answer. Then, we'll copy each entry of the matrix as appropriate.
+
+### Complexity Analysis
+
+#### Time Complexity: O(R*C)
+
+Where `R` and `C` are the number of rows and columns in the given matrix `A`.
+
+#### Space Complexity: O(R*C)
+
+The space used by the answer.
+

algorithms/matrix/transpose/__init__.py

@@ -0,0 +1,38 @@
+from typing import List
+
+
+def transpose(input_lines: str) -> str:
+    """
+    transposes letters in input lines like a matrix, where the columns become rows and rows
+    become columns
+    :param input_lines: lines to transpose
+    :return: String with the characters transposed
+    """
+    lines = input_lines.split("\n")
+    zipped = map(list, [line.ljust(len(max(lines, key=len))) for line in lines])
+
+    return "\n".join("".join(line) for line in zip(*zipped)).strip()
+
+
+def transpose_matrix(matrix: List[List[int]]) -> List[List[int]]:
+    """
+    transposes a matrix by making the columns the rows and the rows the columns
+    Args:
+        matrix: matrix to transpose
+    Returns:
+        Transposed matrix
+    """
+    if not matrix:
+        return []
+
+    n_rows = len(matrix)
+    n_cols = len(matrix[0])
+
+    transposed_matrix = [[0] * n_rows for _ in range(n_cols)]
+
+    for row in range(n_rows):
+        for col in range(n_cols):
+            value = matrix[row][col]
+            transposed_matrix[col][row] = value
+
+    return transposed_matrix

tests/algorithms/test_transpose.py …ithms/matrix/transpose/test_transpose.pytests/algorithms/test_transpose.py renamed to algorithms/matrix/transpose/test_transpose.py tests/algorithms/test_transpose.py renamed to algorithms/matrix/transpose/test_transpose.py

@@ -1,8 +1,6 @@
 import unittest
 
-from algorithms.transpose import transpose
-
-# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+from algorithms.matrix.transpose import transpose
 
 
 class TransposeTests(unittest.TestCase):

algorithms/matrix/transpose/test_transpose_matrix.py

@@ -0,0 +1,47 @@
+import unittest
+from typing import List
+from parameterized import parameterized
+from algorithms.matrix.transpose import transpose_matrix
+
+TRANSPOSE_MATRIX_TEST_CASES = [
+    (
+        [
+            [1, 2],
+        ],
+        [[1], [2]],
+    ),
+    (
+        [
+            [1, 2],
+            [3, 4],
+            [5, 6],
+        ],
+        [
+            [1, 3, 5],
+            [2, 4, 6],
+        ],
+    ),
+    (
+        [
+            [1, 2, 3],
+            [4, 5, 6],
+            [7, 8, 9],
+        ],
+        [
+            [1, 4, 7],
+            [2, 5, 8],
+            [3, 6, 9],
+        ],
+    ),
+]
+
+
+class TransposeMatrixTestCase(unittest.TestCase):
+    @parameterized.expand(TRANSPOSE_MATRIX_TEST_CASES)
+    def test_transpose_matrix(self, matrix: List[List[int]], expected: List[List[int]]):
+        actual = transpose_matrix(matrix)
+        self.assertEqual(actual, expected)
+
+
+if __name__ == "__main__":
+    unittest.main()

algorithms/transpose/README.md

@@ -27,10 +27,10 @@ def integer_addition(a: int, b: int):
 
 def integer_addition_2(a: int, b: int) -> int:
     mask = 0xFFFFFFFF
-    max_int = 2 ** 31 - 1
+    max_int = 2**31 - 1
     while b != 0:
         sum_ = (a ^ b) & mask
         carry = (a & b) & mask
         a = sum_
         b = carry << 1
-    return a if a <= max_int else ~(a ^ mask)
+    return a if a <= max_int else ~(a ^ mask)

algorithms/transpose/__init__.py

@@ -13,6 +13,7 @@
     (2147483647, 1, -2147483648),
 ]
 
+
 class SumOfTwoIntegersTestCase(unittest.TestCase):
     @parameterized.expand(SUM_OF_TWO_INTEGERS_TEST_CASES)
     def test_integer_addition(self, a: int, b: int, expected: int):
@@ -25,5 +26,5 @@ def test_integer_addition_2(self, a: int, b: int, expected: int):
         self.assertEqual(result, expected)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()