Brick wall challenge (#21)

"Brick wall" is a basic-level challenge for working with data structures.
The original challenge: https://leetcode.com/problems/brick-wall/

There is a rectangular brick wall in front of you with n rows of
bricks. The ith row has some number of bricks each of the same height
(i.e., one unit) but they can be of different widths. The total width
of each row is the same.

Draw a vertical line from the top to the bottom and cross the least
bricks. If your line goes through the edge of a brick, then the brick
is not considered as crossed. You cannot draw a line just along one of
the two vertical edges of the wall, in which case the line will
obviously cross no bricks.

Given the 2D array wall that contains the information about the wall,
return the minimum number of crossed bricks after drawing such
a vertical line.

Author: shorodilov

poetry.lock

@@ -35,11 +35,12 @@ packages = [
     { include = "bisearch", from = "src" },
     { include = "calc", from = "src" },
     { include = "conv_store", from = "src" },
+    { include = "datasets", from = "src" },
     { include = "dynamic", from = "src" },
     { include = "sequences", from = "src" },
     { include = "sorting", from = "src" },
     { include = "primes", from = "src" },
-    { include = "wrw_game", from = "src" }
+    { include = "wrw_game", from = "src" },
 ]
 
 [tool.poetry.dependencies]

pyproject.toml

@@ -0,0 +1,15 @@
+"""
+Dataset challenges
+==================
+
+"""
+
+__all__ = [
+    "get_bricks_count",
+    "get_position_frequency",
+    "get_least_bricks_position",
+    "get_least_bricks_count",
+]
+
+from datasets.func import (get_bricks_count, get_least_bricks_count,
+                           get_least_bricks_position, get_position_frequency)

src/datasets/__init__.py

@@ -0,0 +1,108 @@
+"""
+Datasets functions implementation
+
+"""
+
+from typing import Dict, List
+
+
+# brick wall challenge
+def get_bricks_count(structure: List[List[int]]) -> int:
+    """Return number of bricks in the wall structure
+
+    :param structure: represents wall structure as sequences of integers
+    :type structure: list[list[int]]
+
+    :return: total number of bricks in the entire wall structure
+    :rtype: int
+
+    Usage:
+
+    >>> get_bricks_count([[1], [1], [1]]) == 3
+    >>> get_bricks_count([[1, 1, 1], [1, 1, 1]]) == 6
+    >>> get_bricks_count([[2, 1, 2], [1, 1, 1, 1, 1]]) == 8
+
+    """
+
+    return sum(len(row) for row in structure)
+
+
+def get_position_frequency(structure: List[List[int]]) -> Dict[int, int]:
+    """Return a matrix of position-bricks pairs for a structure
+
+    :param structure: represents wall structure as sequences of integers
+    :type structure: list[list[int]]
+
+    :return: the position - frequency matrix
+    :rtype: dict[int, int]
+
+    Usage:
+
+    >>> assert get_position_frequency([[1], [1], [1]]) == {}
+    >>> assert get_position_frequency([[1, 2], [2, 1], [3]]) = {1: 1, 2: 1}
+    >>> assert get_position_frequency([[1, 1, 1], [1, 1, 1]]) = {1: 2, 2: 2}
+
+    """
+
+    structure_matrix = {}
+
+    for row in structure:
+        row_length = 0
+        for brick_length in row[:-1]:
+            row_length += brick_length
+            if row_length not in structure_matrix:
+                structure_matrix[row_length] = 0
+            structure_matrix[row_length] += 1
+
+    return structure_matrix
+
+
+def get_least_bricks_position(structure: List[List[int]]) -> int:
+    """Return a pointer to the weakest line in the structure
+
+    :param structure: represents wall structure as sequences of integers
+    :type structure: list[list[int]]
+
+    :return: the distance from the left edge to the weakest line location
+    :rtype: int
+
+    This function uses helper function ``get_structure_matrix`` to build
+    the matrix of distances from the left edge of the "wall".
+
+    Usage:
+
+    >>> assert get_least_bricks_position([[1], [1], [1]]) == 0
+    >>> assert get_least_bricks_position([[1, 1, 1], [1, 1, 1]]) == 1
+
+    """
+
+    matrix = get_position_frequency(structure)
+    if not matrix:
+        return 0
+
+    return max(matrix, key=matrix.get)  # type: ignore
+
+
+def get_least_bricks_count(structure: List[List[int]]) -> int:
+    """Return the least number of bricks in a vertical line
+
+    :param structure: represents wall structure as sequences of integers
+    :type structure: list[list[int]]
+
+    :return: minimum number of bricks in a line
+    :rtype: int
+
+    Usage:
+
+    >>> assert get_least_bricks_count([[1], [1], [1]]) == 3
+    >>> assert get_least_bricks_count([[1, 2], [2, 1], [3], [1, 1, 1]]) == 2
+    >>> assert get_least_bricks_count([[1, 1, 1], [1, 1, 1]]) == 0
+
+    """
+
+    max_value: int = 0
+    matrix = get_position_frequency(structure)
+    for count in matrix.values():
+        max_value = max(max_value, count)
+
+    return len(structure) - max_value

src/datasets/func.py

@@ -0,0 +1,38 @@
+import pytest
+
+
+@pytest.fixture
+def small_bricks_wall():
+    return [[1], [1], [1]]
+
+
+@pytest.fixture
+def bricks_wall():
+    return [
+        [5, 5, 3, 4, 1],
+        [3, 2, 1, 4, 2, 1, 5],
+        [2, 3, 1, 5, 5, 2],
+        [3, 4, 3, 4, 3, 1],
+        [5, 5, 3, 2, 3],
+    ]
+
+
+@pytest.fixture
+def matrix():
+    return {5: 4, 10: 4, 13: 3, 17: 2, 3: 2, 6: 2, 12: 1, 2: 1, 11: 1, 16: 1,
+            7: 1, 14: 1, 15: 1}
+
+
+@pytest.fixture
+def position():
+    return 5
+
+
+@pytest.fixture
+def bricks_count():
+    return 29
+
+
+@pytest.fixture
+def least_bricks():
+    return 1

src/datasets/py.typed

@@ -0,0 +1,24 @@
+import datasets
+
+
+def test_brick_counter(bricks_wall, bricks_count):
+    assert datasets.get_bricks_count(bricks_wall) == bricks_count
+
+
+def test_matrix_builder(bricks_wall, position):
+    assert datasets.get_least_bricks_position(bricks_wall) == position
+
+
+def test_least_bricks(bricks_wall, small_bricks_wall):
+    assert datasets.get_least_bricks_count(bricks_wall) == 1
+    assert datasets.get_least_bricks_count(small_bricks_wall) == 3
+
+
+def test_original_case():
+    wall = [[1, 2, 2, 1],
+            [3, 1, 2],
+            [1, 3, 2],
+            [2, 4],
+            [3, 1, 2],
+            [1, 3, 1, 1]]
+    assert datasets.get_least_bricks_count(wall) == 2