diff --git a/.github/workflows/docker-image.yml b/.github/workflows/docker-image.yml index 2ae02e6a..5021cc75 100644 --- a/.github/workflows/docker-image.yml +++ b/.github/workflows/docker-image.yml @@ -179,7 +179,7 @@ jobs: docker image ls -a - name: Run Trivy vulnerability scanner (cli report) - uses: aquasecurity/trivy-action@0.29.0 + uses: aquasecurity/trivy-action@0.30.0 with: image-ref: ${{ env.IMAGE_NAME }}:${{ github.sha }} format: 'table' @@ -187,7 +187,7 @@ jobs: TRIVY_DB_REPOSITORY: ${{ vars.TRIVY_DB_REPOSITORY }} - name: Run Trivy vulnerability scanner (sarif report) - uses: aquasecurity/trivy-action@0.29.0 + uses: aquasecurity/trivy-action@0.30.0 with: image-ref: ${{ env.IMAGE_NAME }}:${{ github.sha }} format: 'sarif' diff --git a/.github/workflows/python-coverage.yml b/.github/workflows/python-coverage.yml index d21f99f0..34f81970 100644 --- a/.github/workflows/python-coverage.yml +++ b/.github/workflows/python-coverage.yml @@ -61,8 +61,8 @@ jobs: run: | python3 -m coverage xml - - name: SonarCloud Scan - uses: SonarSource/sonarcloud-github-action@master + - name: Analyze with SonarQube / SonarCloud + uses: SonarSource/sonarqube-scan-action@master env: SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }} # Needed to get PR information, if any diff --git a/.gitignore b/.gitignore index 60648631..c3a52581 100644 --- a/.gitignore +++ b/.gitignore @@ -181,3 +181,6 @@ cython_debug/ # Sarif *.sarif + +# SonarQube sonar-scanner (cli) +.scannerwork diff --git a/.pylintrc b/.pylintrc index 992951cf..49d2fc9c 100644 --- a/.pylintrc +++ b/.pylintrc @@ -552,7 +552,7 @@ const-naming-style=UPPER_CASE docstring-min-length=-1 # Naming style matching correct function names. -function-naming-style=snake_case +function-naming-style=camelCase # Regular expression matching correct function names. Overrides function- # naming-style. If left empty, function names will be checked with the set diff --git a/Dockerfile b/Dockerfile index 3c1ef2c3..c6401e5a 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,5 +1,7 @@ +ARG BASE_IMAGE=python:3.13.3-alpine3.20 + ############################################################################### -FROM python:3.13.1-alpine3.20 AS init +FROM ${BASE_IMAGE} AS init ENV WORKDIR=/app WORKDIR ${WORKDIR} diff --git a/Makefile b/Makefile index a7f573af..ab3720ec 100644 --- a/Makefile +++ b/Makefile @@ -118,15 +118,15 @@ upgrade: ${PACKAGE_TOOL} list --outdated | cut -f1 -d' ' | tr " " "\n" | awk '{if(NR>=3)print}' | cut -d' ' -f1 | xargs -n1 pip3 install -U clean: - ${PACKAGE_TOOL} freeze > unins ; pip3 uninstall -y -r unins ; rm unins + ${PACKAGE_TOOL} freeze > unins ; ${PACKAGE_TOOL} uninstall -y -r unins ; rm unins rm -f .coverage rm -fr .pytest_cache rm -fr htmlcov rm -fr coverage rm -fr build - find . -path "*/*.pyc" -delete -print - find . -path "*/*.pyo" -delete -print - find . -path "*/__pycache__" -type d -print -exec rm -fr {} ';' + find . -path "*/*.pyc" -delete -print || true + find . -path "*/*.pyo" -delete -print || true + find . -path "*/__pycache__" -type d -print -exec rm -fr {} ';' || true compose/build: env ${DOCKER_COMPOSE} --profile lint build diff --git a/docs/hackerrank/interview_preparation_kit/linked_lists/insert-a-node-into-a-sorted-doubly-linked-list.md b/docs/hackerrank/interview_preparation_kit/linked_lists/insert-a-node-into-a-sorted-doubly-linked-list.md index 48996bfb..11a4f454 100644 --- a/docs/hackerrank/interview_preparation_kit/linked_lists/insert-a-node-into-a-sorted-doubly-linked-list.md +++ b/docs/hackerrank/interview_preparation_kit/linked_lists/insert-a-node-into-a-sorted-doubly-linked-list.md @@ -1,4 +1,4 @@ -# [Linked Lists: Insert a node at a specific position in a linked list](https://www.hackerrank.com/challenges/insert-a-node-at-a-specific-position-in-a-linked-list) +# [Linked Lists: Insert a node at a specific position in a linked list](https://www.hackerrank.com/challenges/insert-a-node-into-a-sorted-doubly-linked-list) Create a node with a given value and insert it into a sorted doubly-linked list diff --git a/requirements.txt b/requirements.txt index 5d4f69e8..ea28d63b 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,26 +1,26 @@ -astroid==3.3.8 -attrs==24.3.0 +astroid==3.3.10 +attrs==25.3.0 autopep8==2.3.2 -coverage==7.6.10 -dill==0.3.9 -exceptiongroup==1.2.2 -flake8==7.1.1 -iniconfig==2.0.0 -isort==5.13.2 -lazy-object-proxy==1.10.0 +coverage==7.8.0 +dill==0.4.0 +exceptiongroup==1.3.0 +flake8==7.2.0 +iniconfig==2.1.0 +isort==6.0.1 +lazy-object-proxy==1.11.0 mccabe==0.7.0 nodeenv==1.9.1 -packaging==24.2 -platformdirs==4.3.6 +packaging==25.0 +platformdirs==4.3.8 pluggy==1.5.0 -pycodestyle==2.12.1 -pyflakes==3.2.0 -pylint==3.3.3 -pyright==1.1.392.post0 -pytest==8.3.4 -pytest-cov==6.0.0 +pycodestyle==2.13.0 +pyflakes==3.3.2 +pylint==3.3.7 +pyright==1.1.400 +pytest==8.3.5 +pytest-cov==6.1.1 tomli==2.2.1 tomlkit==0.13.2 -typing_extensions==4.12.2 +typing_extensions==4.13.2 wrapt==1.17.2 zipp>=3.19.1 # not directly required, pinned by Snyk to avoid a vulnerability diff --git a/sonar-project.properties b/sonar-project.properties index 63d81bf5..10a5ac0a 100644 --- a/sonar-project.properties +++ b/sonar-project.properties @@ -24,3 +24,4 @@ sonar.issue.ignore.multicriteria=e1 # python:S6792 Use the "type" parameter syntax to declare this generic class. sonar.issue.ignore.multicriteria.e1.ruleKey=python:S6792 sonar.issue.ignore.multicriteria.e1.resourceKey=**/*.py +sonar.python.naming.function=^[a-z][a-zA-Z0-9]*$ diff --git a/src/hackerrank/certification/num_cells.py b/src/hackerrank/certification/num_cells.py index 27533255..a8168e89 100644 --- a/src/hackerrank/certification/num_cells.py +++ b/src/hackerrank/certification/num_cells.py @@ -7,16 +7,16 @@ LOGGER = logging.getLogger(__name__) -def valid_coordinate(grid: List[List[int]], i: int, j: int, k: int, m: int) -> bool: +def validCoordinate(grid: List[List[int]], i: int, j: int, k: int, m: int) -> bool: return 0 <= k < len(grid) and \ 0 <= m < len(grid[k]) and \ (k, m) != (i, j) -def all_neighbors_are_minor(grid: List[List[int]], i: int, j: int) -> bool: +def allNeighborsAreMinor(grid: List[List[int]], i: int, j: int) -> bool: for k in range(i - 1, i + 2): for m in range(j - 1, j + 2): - if valid_coordinate(grid, i, j, k, m) and \ + if validCoordinate(grid, i, j, k, m) and \ grid[k][m] >= grid[i][j]: LOGGER.debug( 'Found some major neighbor: i = %i, j = %i, grid[i][j] = %i', @@ -29,7 +29,7 @@ def all_neighbors_are_minor(grid: List[List[int]], i: int, j: int) -> bool: return False -def num_cells(grid: List[List[int]]) -> int: +def numCells(grid: List[List[int]]) -> int: dominant_counter = 0 @@ -37,7 +37,7 @@ def num_cells(grid: List[List[int]]) -> int: for j in range(0, len(grid[i])): LOGGER.debug('Checking: i = %i, j = %i, grid[i][j] = %i', i, j, grid[i][j]) - if all_neighbors_are_minor(grid, i, j) is False: + if allNeighborsAreMinor(grid, i, j) is False: LOGGER.debug('grid[%i][%i] is dominant', i, j) dominant_counter += 1 diff --git a/src/hackerrank/certification/num_cells_test.py b/src/hackerrank/certification/num_cells_test.py index 65809d19..642c9bed 100644 --- a/src/hackerrank/certification/num_cells_test.py +++ b/src/hackerrank/certification/num_cells_test.py @@ -1,5 +1,5 @@ import unittest -from .num_cells import num_cells +from .num_cells import numCells class TestNumCells(unittest.TestCase): @@ -14,6 +14,6 @@ def test_num_cells_case_0(self): solution_found = 2 self.assertEqual( - num_cells(grid), solution_found, + numCells(grid), solution_found, f"num_cells({grid}) must be " f"=> {solution_found}") diff --git a/src/hackerrank/implementation/between_two_sets.py b/src/hackerrank/implementation/between_two_sets.py index 4dda56c4..0e74859c 100644 --- a/src/hackerrank/implementation/between_two_sets.py +++ b/src/hackerrank/implementation/between_two_sets.py @@ -5,7 +5,7 @@ LOGGER = logging.getLogger(__name__) -def is_factor(_n: int, group: list[int]) -> bool: +def isFactor(_n: int, group: list[int]) -> bool: result: bool = True i: int = 0 @@ -21,7 +21,7 @@ def is_factor(_n: int, group: list[int]) -> bool: return result -def factor_of(_n: int, group: list[int]): +def factorOf(_n: int, group: list[int]): result: bool = True i: int = 0 @@ -37,7 +37,7 @@ def factor_of(_n: int, group: list[int]): return result -def get_total_x(_a: list[int], _b: list[int]) -> int: +def getTotalX(_a: list[int], _b: list[int]) -> int: _max_ = 0 for _, j in enumerate(_b): _max_ = max(_max_, j) @@ -45,7 +45,7 @@ def get_total_x(_a: list[int], _b: list[int]) -> int: result: list[int] = [] for i in range(2, _max_): - if is_factor(i, _a) and factor_of(i, _b): + if isFactor(i, _a) and factorOf(i, _b): result.append(i) output = len(result) diff --git a/src/hackerrank/implementation/between_two_sets_test.py b/src/hackerrank/implementation/between_two_sets_test.py index 72586f0d..37f8655f 100755 --- a/src/hackerrank/implementation/between_two_sets_test.py +++ b/src/hackerrank/implementation/between_two_sets_test.py @@ -1,5 +1,5 @@ import unittest -from .between_two_sets import get_total_x, is_factor, factor_of +from .between_two_sets import getTotalX, isFactor, factorOf class TestProblemBetweenTwoSets(unittest.TestCase): @@ -9,39 +9,39 @@ def test_get_total_x(self): tinput: list[int] = [16, 32, 96] solution_found: int = 0 - calculated_a = get_total_x([], tinput) + calculated_a = getTotalX([], tinput) self.assertEqual( calculated_a, solution_found, - f"get_total_x([], tinput) must be " + f"getTotalX([], tinput) must be " f"=> {solution_found}") - calculated_b = get_total_x(tinput, []) + calculated_b = getTotalX(tinput, []) self.assertEqual( calculated_b, solution_found, - f"get_total_x({tinput}, {[]}) must be " + f"getTotalX({tinput}, {[]}) must be " f"=> {solution_found}") - calculated_c = get_total_x([], []) + calculated_c = getTotalX([], []) self.assertEqual( calculated_c, solution_found, - f"get_total_x({[]}, {[]}) must be " + f"getTotalX({[]}, {[]}) must be " f"=> {solution_found}") - calculated_d = is_factor(1, []) + calculated_d = isFactor(1, []) self.assertEqual( calculated_d, solution_found, - f"is_factor({1}, {[]}) must be " + f"isFactor({1}, {[]}) must be " f"=> {False}") - calculated_e = factor_of(1, []) + calculated_e = factorOf(1, []) self.assertEqual( calculated_e, solution_found, - f"factor_of({1}, {[]}) must be " + f"factorOf({1}, {[]}) must be " f"=> {False}") def test_get_total_x_case_0(self): @@ -53,11 +53,11 @@ def test_get_total_x_case_0(self): solution_found = 3 self.assertEqual( - get_total_x(_a_, _b_), solution_found, - f"get_total_x({_a_}, {_b_}) must be " + getTotalX(_a_, _b_), solution_found, + f"getTotalX({_a_}, {_b_}) must be " f"=> {solution_found}") self.assertEqual( - get_total_x(_a_, _b_reverse_), solution_found, - f"get_total_x({_a_}, {_b_reverse_}) must be " + getTotalX(_a_, _b_reverse_), solution_found, + f"getTotalX({_a_}, {_b_reverse_}) must be " f"=> {solution_found}") diff --git a/src/hackerrank/interview_preparation_kit/arrays/cruch_bruteforce.py b/src/hackerrank/interview_preparation_kit/arrays/cruch_bruteforce.py index c9bb5dc4..da613a15 100644 --- a/src/hackerrank/interview_preparation_kit/arrays/cruch_bruteforce.py +++ b/src/hackerrank/interview_preparation_kit/arrays/cruch_bruteforce.py @@ -6,7 +6,7 @@ LOGGER = logging.getLogger(__name__) -def array_manipulation(n_operations: int, queries: list[list[int]]) -> int: +def arrayManipulation(n_operations: int, queries: list[list[int]]) -> int: result = [0] * (n_operations + 1) maximum = 0 diff --git a/src/hackerrank/interview_preparation_kit/arrays/cruch_bruteforce_test.py b/src/hackerrank/interview_preparation_kit/arrays/cruch_bruteforce_test.py index fb31c10a..dd669411 100644 --- a/src/hackerrank/interview_preparation_kit/arrays/cruch_bruteforce_test.py +++ b/src/hackerrank/interview_preparation_kit/arrays/cruch_bruteforce_test.py @@ -1,12 +1,12 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .cruch_bruteforce import array_manipulation +from ....lib.loader import loadTestCases +from .cruch_bruteforce import arrayManipulation FILE_PATH = str(Path(__file__).resolve().parent) -CRUCH_SMALL_TEST_CASES = load_test_cases( +CRUCH_SMALL_TEST_CASES = loadTestCases( FILE_PATH + '/cruch.testcases.json') @@ -17,6 +17,6 @@ def test_array_manipulation(self): for _, _tt in enumerate(CRUCH_SMALL_TEST_CASES): self.assertEqual( - array_manipulation(_tt['n'], _tt['queries']), _tt['expected'], - f"{_} | array_manipulation({_tt['n']}, {_tt['queries']}) must be " + arrayManipulation(_tt['n'], _tt['queries']), _tt['expected'], + f"{_} | arrayManipulation({_tt['n']}, {_tt['queries']}) must be " f"=> {_tt['expected']}") diff --git a/src/hackerrank/interview_preparation_kit/arrays/cruch_optimized.py b/src/hackerrank/interview_preparation_kit/arrays/cruch_optimized.py index 487a82e6..7e612f23 100644 --- a/src/hackerrank/interview_preparation_kit/arrays/cruch_optimized.py +++ b/src/hackerrank/interview_preparation_kit/arrays/cruch_optimized.py @@ -9,7 +9,7 @@ LOGGER = logging.getLogger(__name__) -def array_manipulation_optimized(n_operations: int, queries: list[list[int]]) -> int: +def arrayManipulation(n_operations: int, queries: list[list[int]]) -> int: # why adding 2? # first slot to adjust 1-based index and # last slot for storing accum_sum result diff --git a/src/hackerrank/interview_preparation_kit/arrays/cruch_optimized_test.py b/src/hackerrank/interview_preparation_kit/arrays/cruch_optimized_test.py index 2380a778..d8deaaf8 100644 --- a/src/hackerrank/interview_preparation_kit/arrays/cruch_optimized_test.py +++ b/src/hackerrank/interview_preparation_kit/arrays/cruch_optimized_test.py @@ -1,12 +1,12 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .cruch_optimized import array_manipulation_optimized +from ....lib.loader import loadTestCases +from .cruch_optimized import arrayManipulation FILE_PATH = str(Path(__file__).resolve().parent) -CRUCH_SMALL_TEST_CASES = load_test_cases( +CRUCH_SMALL_TEST_CASES = loadTestCases( FILE_PATH + '/cruch.testcases.json') @@ -17,6 +17,6 @@ def test_array_manipulation_optimized(self): for _, _tt in enumerate(CRUCH_SMALL_TEST_CASES): self.assertEqual( - array_manipulation_optimized(_tt['n'], _tt['queries']), _tt['expected'], + arrayManipulation(_tt['n'], _tt['queries']), _tt['expected'], f"{_} | array_manipulation_optimized({_tt['n']}, {_tt['queries']}) " f"must be => {_tt['expected']}") diff --git a/src/hackerrank/interview_preparation_kit/arrays/ctci_array_left_rotation.py b/src/hackerrank/interview_preparation_kit/arrays/ctci_array_left_rotation.py index b515e6c8..2b4bb5bb 100644 --- a/src/hackerrank/interview_preparation_kit/arrays/ctci_array_left_rotation.py +++ b/src/hackerrank/interview_preparation_kit/arrays/ctci_array_left_rotation.py @@ -7,7 +7,7 @@ FIRST_POSITION: int = 0 -def rot_left_one(group: list[int]) -> list[int]: +def rotLeftOne(group: list[int]) -> list[int]: first = group.pop(FIRST_POSITION) group.append(first) @@ -15,12 +15,12 @@ def rot_left_one(group: list[int]) -> list[int]: return group -def rot_left(group: list[int], d_rotations: int) -> list[int]: +def rotLeft(group: list[int], d_rotations: int) -> list[int]: output = group.copy() i = 1 while i <= d_rotations: - output = rot_left_one(output) + output = rotLeftOne(output) i += 1 return output diff --git a/src/hackerrank/interview_preparation_kit/arrays/ctci_array_left_rotation.testcases.json b/src/hackerrank/interview_preparation_kit/arrays/ctci_array_left_rotation.testcases.json index 1750d965..d78f6838 100644 --- a/src/hackerrank/interview_preparation_kit/arrays/ctci_array_left_rotation.testcases.json +++ b/src/hackerrank/interview_preparation_kit/arrays/ctci_array_left_rotation.testcases.json @@ -1,7 +1,10 @@ [ - {"input": [1, 2, 3, 4, 5], "expected": [2, 3, 4, 5, 1]}, - {"input": [2, 3, 4, 5, 1], "expected": [3, 4, 5, 1, 2]}, - {"input": [3, 4, 5, 1, 2], "expected": [4, 5, 1, 2, 3]}, - {"input": [4, 5, 1, 2, 3], "expected": [5, 1, 2, 3, 4]}, - {"input": [5, 1, 2, 3, 4], "expected": [1, 2, 3, 4, 5]} + {"title": "Own 0", "input": [1, 2, 3, 4, 5], "d_rotations": 1, "expected": [2, 3, 4, 5, 1]}, + {"title": "Own 1", "input": [2, 3, 4, 5, 1], "d_rotations": 1, "expected": [3, 4, 5, 1, 2]}, + {"title": "Own 2", "input": [3, 4, 5, 1, 2], "d_rotations": 1, "expected": [4, 5, 1, 2, 3]}, + {"title": "Own 3", "input": [4, 5, 1, 2, 3], "d_rotations": 1, "expected": [5, 1, 2, 3, 4]}, + {"title": "Own 4", "input": [5, 1, 2, 3, 4], "d_rotations": 1, "expected": [1, 2, 3, 4, 5]}, + {"title": "Sample Test case 0", "input": [1, 2, 3, 4, 5], "d_rotations": 4, "expected": [5, 1, 2, 3, 4]}, + {"title": "Sample Test case 1", "input": [41, 73, 89, 7, 10, 1, 59, 58, 84, 77, 77, 97, 58, 1, 86, 58, 26, 10, 86, 51], "d_rotations": 10, "expected": [77, 97, 58, 1, 86, 58, 26, 10, 86, 51, 41, 73, 89, 7, 10, 1, 59, 58, 84, 77]}, + {"title": "Sample Test case 2", "input": [33, 47, 70, 37, 8, 53, 13, 93, 71, 72, 51, 100, 60, 87, 97], "d_rotations": 13, "expected": [87, 97, 33, 47, 70, 37, 8, 53, 13, 93, 71, 72, 51, 100, 60]} ] diff --git a/src/hackerrank/interview_preparation_kit/arrays/ctci_array_left_rotation_test.py b/src/hackerrank/interview_preparation_kit/arrays/ctci_array_left_rotation_test.py index 77f3c3b6..4b7d6d16 100644 --- a/src/hackerrank/interview_preparation_kit/arrays/ctci_array_left_rotation_test.py +++ b/src/hackerrank/interview_preparation_kit/arrays/ctci_array_left_rotation_test.py @@ -1,34 +1,22 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .ctci_array_left_rotation import rot_left, rot_left_one +from ....lib.loader import loadTestCases +from .ctci_array_left_rotation import rotLeft FILE_PATH = str(Path(__file__).resolve().parent) -TEST_CASES = load_test_cases( +TEST_CASES = loadTestCases( FILE_PATH + '/ctci_array_left_rotation.testcases.json') class TestArrayLeftRotation(unittest.TestCase): - def test_rot_left_one(self): - for _, _tt in enumerate(TEST_CASES): - - self.assertEqual( - rot_left_one(_tt['input']), _tt['expected'], - f"{_} | rot_left({_tt['input']}) must be " - f"=> {_tt['expected']}") - def test_rot_left(self): - tests = [ - {'input': [1, 2, 3, 4, 5], 'd': 4, 'expected': [5, 1, 2, 3, 4]}, - ] - - for _, _tt in enumerate(tests): + for _, _tt in enumerate(TEST_CASES): self.assertEqual( - rot_left(_tt['input'], _tt['d']), _tt['expected'], - f"{_} | rot_left({_tt['input']}) must be " + rotLeft(_tt['input'], _tt['d_rotations']), _tt['expected'], + f"{_} | rotLeft({_tt['input'], _tt['d_rotations']}) must be " f"=> {_tt['expected']}") diff --git a/src/hackerrank/interview_preparation_kit/arrays/minimum_swaps_2.py b/src/hackerrank/interview_preparation_kit/arrays/minimum_swaps_2.py index 1cafff11..c58d6244 100644 --- a/src/hackerrank/interview_preparation_kit/arrays/minimum_swaps_2.py +++ b/src/hackerrank/interview_preparation_kit/arrays/minimum_swaps_2.py @@ -6,7 +6,7 @@ LOGGER = logging.getLogger(__name__) -def minimum_swaps(group: list[int]) -> int: +def minimumSwaps(group: list[int]) -> int: indexed_group = [i - 1 for i in group] swaps = 0 diff --git a/src/hackerrank/interview_preparation_kit/arrays/minimum_swaps_2_test.py b/src/hackerrank/interview_preparation_kit/arrays/minimum_swaps_2_test.py index 1b87a88d..67364e7f 100644 --- a/src/hackerrank/interview_preparation_kit/arrays/minimum_swaps_2_test.py +++ b/src/hackerrank/interview_preparation_kit/arrays/minimum_swaps_2_test.py @@ -1,12 +1,12 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .minimum_swaps_2 import minimum_swaps +from ....lib.loader import loadTestCases +from .minimum_swaps_2 import minimumSwaps FILE_PATH = str(Path(__file__).resolve().parent) -TEST_CASES = load_test_cases( +TEST_CASES = loadTestCases( FILE_PATH + '/minimum_swaps_2.testcases.json') @@ -17,6 +17,6 @@ def test_minimum_swaps(self): for _, _tt in enumerate(TEST_CASES): self.assertEqual( - minimum_swaps(_tt['input']), _tt['expected'], - f"{_} | minimum_swaps({_tt['input']}) must be " + minimumSwaps(_tt['input']), _tt['expected'], + f"{_} | minimumSwaps({_tt['input']}) must be " f"=> {_tt['expected']}") diff --git a/src/hackerrank/interview_preparation_kit/arrays/new_year_chaos.py b/src/hackerrank/interview_preparation_kit/arrays/new_year_chaos.py index b9d5fecd..2ebcb884 100644 --- a/src/hackerrank/interview_preparation_kit/arrays/new_year_chaos.py +++ b/src/hackerrank/interview_preparation_kit/arrays/new_year_chaos.py @@ -4,11 +4,10 @@ import logging LOGGER = logging.getLogger(__name__) - TOO_CHAOTIC_ERROR = 'Too chaotic' -def minimum_bribes(queue: list[int]) -> 'int | None': +def minimumBribesCompute(queue: list[int]) -> 'int | None': bribes = 0 for i, value in enumerate(queue): @@ -24,10 +23,14 @@ def minimum_bribes(queue: list[int]) -> 'int | None': return bribes -def minimum_bribes_transform(queue: list[int]) -> 'int | str': +def minimumBribesText(queue: list[int]) -> 'int | str': - result = minimum_bribes(queue) + result = minimumBribesCompute(queue) if result is None: return TOO_CHAOTIC_ERROR return result + + +def minimumBribes(queue: list[int]): + print(minimumBribesText(queue)) diff --git a/src/hackerrank/interview_preparation_kit/arrays/new_year_chaos_test.py b/src/hackerrank/interview_preparation_kit/arrays/new_year_chaos_test.py index 87c9c007..14488074 100644 --- a/src/hackerrank/interview_preparation_kit/arrays/new_year_chaos_test.py +++ b/src/hackerrank/interview_preparation_kit/arrays/new_year_chaos_test.py @@ -1,12 +1,12 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .new_year_chaos import minimum_bribes_transform +from ....lib.loader import loadTestCases +from .new_year_chaos import minimumBribes, minimumBribesText FILE_PATH = str(Path(__file__).resolve().parent) -TEST_CASES = load_test_cases( +TEST_CASES = loadTestCases( FILE_PATH + '/new_year_chaos.testcases.json') @@ -17,6 +17,8 @@ def test_minimum_bribes(self): for _, _tt in enumerate(TEST_CASES): self.assertEqual( - minimum_bribes_transform(_tt['input']), _tt['expected'], - f"{_} | minimum_bribes_transform({_tt['input']}) must be " + minimumBribesText(_tt['input']), _tt['expected'], + f"{_} | minimumBribesText({_tt['input']}) must be " f"=> {_tt['expected']}") + + minimumBribes(_tt['input']) # Print the result (for coverage) diff --git a/src/hackerrank/interview_preparation_kit/arrays/two_d_array.py b/src/hackerrank/interview_preparation_kit/arrays/two_d_array.py index 86922c87..e33f6900 100644 --- a/src/hackerrank/interview_preparation_kit/arrays/two_d_array.py +++ b/src/hackerrank/interview_preparation_kit/arrays/two_d_array.py @@ -25,7 +25,7 @@ def gethourglass(arr: list[list[int]], position_x: int, position_y: int) -> list return result -def hourglass_sum(arr: list[list[int]]) -> int | None: +def hourglassSum(arr: list[list[int]]) -> int | None: matrix_size: int = len(arr) matrix_start_index: int = 1 diff --git a/src/hackerrank/interview_preparation_kit/arrays/two_d_array_test.py b/src/hackerrank/interview_preparation_kit/arrays/two_d_array_test.py index 6761855a..ea9ef52c 100644 --- a/src/hackerrank/interview_preparation_kit/arrays/two_d_array_test.py +++ b/src/hackerrank/interview_preparation_kit/arrays/two_d_array_test.py @@ -1,12 +1,12 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .two_d_array import hourglass_sum +from ....lib.loader import loadTestCases +from .two_d_array import hourglassSum FILE_PATH = str(Path(__file__).resolve().parent) -TEST_CASES = load_test_cases( +TEST_CASES = loadTestCases( FILE_PATH + '/two_d_array.testcases.json') @@ -16,6 +16,6 @@ def test_hourglass_sum(self): for _, _tt in enumerate(TEST_CASES): self.assertEqual( - hourglass_sum(_tt['input']), _tt['expected'], - f"{_} | hourglass_sum({_tt['input']}) must be " + hourglassSum(_tt['input']), _tt['expected'], + f"{_} | hourglassSum({_tt['input']}) must be " f"=> {_tt['expected']}") diff --git a/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/count_triplets_1.py b/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/count_triplets_1.py index 1d9010ce..0935f313 100644 --- a/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/count_triplets_1.py +++ b/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/count_triplets_1.py @@ -4,7 +4,7 @@ from collections import Counter -def count_triplets_brute_force(arr: list[int], ratio: int) -> int: +def countTripletsBruteForce(arr: list[int], ratio: int) -> int: size = len(arr) counter = 0 @@ -20,7 +20,7 @@ def count_triplets_brute_force(arr: list[int], ratio: int) -> int: return counter -def count_triplets(arr: list[int], ratio: int) -> int: +def countTriplets(arr: list[int], ratio: int) -> int: a_counter = Counter(arr) b_counter = Counter() triplets = 0 diff --git a/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/count_triplets_1_test.py b/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/count_triplets_1_test.py index ff059612..efd8e97b 100644 --- a/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/count_triplets_1_test.py +++ b/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/count_triplets_1_test.py @@ -1,15 +1,15 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .count_triplets_1 import count_triplets, count_triplets_brute_force +from ....lib.loader import loadTestCases +from .count_triplets_1 import countTriplets, countTripletsBruteForce FILE_PATH = str(Path(__file__).resolve().parent) -SMALL_TEST_CASES = load_test_cases( +SMALL_TEST_CASES = loadTestCases( FILE_PATH + '/count_triplets_1.small.testcases.json') -TEST_CASES_BIG = load_test_cases( +TEST_CASES_BIG = loadTestCases( FILE_PATH + '/count_triplets_1.big.testcases.json') @@ -19,7 +19,7 @@ def test_count_triplets_brute_force(self): for _, _tt in enumerate(SMALL_TEST_CASES): self.assertEqual( - count_triplets_brute_force(_tt['input'], _tt['r']), _tt['expected'], + countTripletsBruteForce(_tt['input'], _tt['r']), _tt['expected'], f"{_} | count_triplets_brute_force({_tt['input']}, {_tt['r']}) must be " f"=> {_tt['expected']}") @@ -28,7 +28,7 @@ def test_count_triplets(self): for _, _tt in enumerate(SMALL_TEST_CASES): self.assertEqual( - count_triplets(_tt['input'], _tt['r']), _tt['expected'], + countTriplets(_tt['input'], _tt['r']), _tt['expected'], f"{_} | count_triplets({_tt['input']}, {_tt['r']}) must be " f"=> {_tt['expected']} in {_tt['title']}") @@ -37,6 +37,6 @@ def test_count_triplets_big_cases(self): for _, _tt in enumerate(TEST_CASES_BIG): self.assertEqual( - count_triplets(_tt['input'], _tt['r']), _tt['expected'], + countTriplets(_tt['input'], _tt['r']), _tt['expected'], f"{_} | count_triplets({_tt['input']}, {_tt['r']}) must be " f"=> {_tt['expected']} in {_tt['title']}") diff --git a/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/ctci_ransom_note.py b/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/ctci_ransom_note.py index 4b91a2e7..8cd382b9 100644 --- a/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/ctci_ransom_note.py +++ b/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/ctci_ransom_note.py @@ -7,7 +7,7 @@ __NO__ = 'No' -def check_magazine_compute(magazine: List[str], note: List[str]) -> bool: +def checkMagazineCompute(magazine: List[str], note: List[str]) -> bool: dictionary: Dict[str, int] = {} word: str @@ -29,5 +29,9 @@ def check_magazine_compute(magazine: List[str], note: List[str]) -> bool: return True -def check_magazine(magazine: List[str], note: List[str]) -> str: - return __YES__ if check_magazine_compute(magazine, note) else __NO__ +def checkMagazineText(magazine: List[str], note: List[str]) -> str: + return __YES__ if checkMagazineCompute(magazine, note) else __NO__ + + +def checkMagazine(magazine: List[str], note: List[str]): + print(checkMagazineText(magazine, note)) diff --git a/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/ctci_ransom_note_test.py b/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/ctci_ransom_note_test.py index d3703536..35e65cf0 100644 --- a/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/ctci_ransom_note_test.py +++ b/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/ctci_ransom_note_test.py @@ -1,12 +1,12 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .ctci_ransom_note import check_magazine +from ....lib.loader import loadTestCases +from .ctci_ransom_note import checkMagazine, checkMagazineText FILE_PATH = str(Path(__file__).resolve().parent) -TEST_CASES = load_test_cases( +TEST_CASES = loadTestCases( FILE_PATH + '/ctci_ransom_note.testcases.json') @@ -17,6 +17,9 @@ def test_check_magazine(self): for _, _tt in enumerate(TEST_CASES): self.assertEqual( - check_magazine(_tt['magazine'], _tt['note']), _tt['expected'], - f"{_} | check_magazine({_tt['magazine']}, {_tt['note']}) must be " + checkMagazineText(_tt['magazine'], _tt['note']), _tt['expected'], + f"{_} | checkMagazineText({_tt['magazine']}, {_tt['note']}) must be " f"=> {_tt['expected']}") + + # Print the result (for coverage) + checkMagazine(_tt['magazine'], _tt['note']) diff --git a/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/frequency_queries.py b/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/frequency_queries.py index 0d524335..55bf961c 100644 --- a/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/frequency_queries.py +++ b/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/frequency_queries.py @@ -13,7 +13,7 @@ __FOUND__ = 1 -def freq_query(queries): +def freqQuery(queries): result = [] data_map: Dict[int, int] = {} diff --git a/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/frequency_queries_test.py b/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/frequency_queries_test.py index a54e042d..e93e2255 100644 --- a/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/frequency_queries_test.py +++ b/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/frequency_queries_test.py @@ -1,12 +1,12 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .frequency_queries import freq_query +from ....lib.loader import loadTestCases +from .frequency_queries import freqQuery FILE_PATH = str(Path(__file__).resolve().parent) -TEST_CASES = load_test_cases( +TEST_CASES = loadTestCases( FILE_PATH + '/frequency_queries.testcases.json') @@ -17,12 +17,12 @@ def test_freq_query(self): for _, _tt in enumerate(TEST_CASES): self.assertEqual( - freq_query(_tt['input']), _tt['expected'], - f"{_} | freq_query({_tt['input']}) must be " + freqQuery(_tt['input']), _tt['expected'], + f"{_} | freqQuery({_tt['input']}) must be " f"=> {_tt['expected']}") def test_freq_query_edge_case(self): self.assertRaisesRegex(ValueError, 'Invalid operation', - freq_query, [[4, 1]]) + freqQuery, [[4, 1]]) diff --git a/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/sherlock_and_anagrams.py b/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/sherlock_and_anagrams.py index 82de42d7..0b712308 100644 --- a/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/sherlock_and_anagrams.py +++ b/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/sherlock_and_anagrams.py @@ -9,7 +9,7 @@ LOGGER = logging.getLogger(__name__) -def sherlock_and_anagrams(s_word: str) -> int: +def sherlockAndAnagrams(s_word: str) -> int: candidates: Dict[str, List[str]] = {} size: int = len(s_word) diff --git a/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/sherlock_and_anagrams.json b/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/sherlock_and_anagrams.testcases.json similarity index 100% rename from src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/sherlock_and_anagrams.json rename to src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/sherlock_and_anagrams.testcases.json diff --git a/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/sherlock_and_anagrams_test.py b/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/sherlock_and_anagrams_test.py index 5f7fecf6..2e8798b8 100644 --- a/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/sherlock_and_anagrams_test.py +++ b/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/sherlock_and_anagrams_test.py @@ -1,13 +1,13 @@ import unittest -import json from pathlib import Path -from .sherlock_and_anagrams import sherlock_and_anagrams +from ....lib.loader import loadTestCases +from .sherlock_and_anagrams import sherlockAndAnagrams FILE_PATH = str(Path(__file__).resolve().parent) -JSON_DATA_FILE = FILE_PATH + '/sherlock_and_anagrams.json' -with open(JSON_DATA_FILE, encoding="utf-8") as file: - TEST_CASES = json.load(file) + +TEST_CASES = loadTestCases( + FILE_PATH + '/sherlock_and_anagrams.testcases.json') class TestSherlockAndAnagrams(unittest.TestCase): @@ -19,6 +19,6 @@ def test_sherlock_and_anagrams(self): for _, _tt in enumerate(testset['tests']): self.assertEqual( - sherlock_and_anagrams(_tt['input']), _tt['expected'], + sherlockAndAnagrams(_tt['input']), _tt['expected'], f"{_} | sherlock_and_anagrams({_tt['input']}) must be " f"=> {_tt['expected']}") diff --git a/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/two_strings.py b/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/two_strings.py index 3c894530..067bebc7 100644 --- a/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/two_strings.py +++ b/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/two_strings.py @@ -5,7 +5,7 @@ __NO__ = 'No' -def two_strings_compute(s1_word: str, s2_word: str) -> bool: +def twoStringsCompute(s1_word: str, s2_word: str) -> bool: for letter in s1_word: if letter in s2_word: return True @@ -13,5 +13,5 @@ def two_strings_compute(s1_word: str, s2_word: str) -> bool: return False -def two_strings(s1_word: str, s2_word: str) -> str: - return __YES__ if two_strings_compute(s1_word, s2_word) else __NO__ +def twoStrings(s1_word: str, s2_word: str) -> str: + return __YES__ if twoStringsCompute(s1_word, s2_word) else __NO__ diff --git a/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/two_strings_test.py b/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/two_strings_test.py index bd8bbe36..9c2382b9 100644 --- a/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/two_strings_test.py +++ b/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/two_strings_test.py @@ -1,12 +1,12 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .two_strings import two_strings +from ....lib.loader import loadTestCases +from .two_strings import twoStrings FILE_PATH = str(Path(__file__).resolve().parent) -TEST_CASES = load_test_cases( +TEST_CASES = loadTestCases( FILE_PATH + '/two_strings.testcases.json') @@ -17,6 +17,6 @@ def test_two_strings(self): for _, _tt in enumerate(TEST_CASES): self.assertEqual( - two_strings(_tt['s1'], _tt['s2']), _tt['expected'], - f"{_} | two_strings({_tt['s1']}, {_tt['s2']}) must be " + twoStrings(_tt['s1'], _tt['s2']), _tt['expected'], + f"{_} | twoStrings({_tt['s1']}, {_tt['s2']}) must be " f"=> {_tt['expected']} in {_tt['title']}") diff --git a/src/hackerrank/interview_preparation_kit/dynamic_programming/max_array_sum.py b/src/hackerrank/interview_preparation_kit/dynamic_programming/max_array_sum.py index 73e947db..6dbd2786 100644 --- a/src/hackerrank/interview_preparation_kit/dynamic_programming/max_array_sum.py +++ b/src/hackerrank/interview_preparation_kit/dynamic_programming/max_array_sum.py @@ -1,7 +1,7 @@ # @link Problem definition # [[docs/hackerrank/interview_preparation_kit/dynamic_programming/max_array_sum.md]] -def max_array_sum(arr_input: list[int]): +def maxSubsetSum(arr_input: list[int]): arr = arr_input[:] # Edge case diff --git a/src/hackerrank/interview_preparation_kit/dynamic_programming/max_array_sum_test.py b/src/hackerrank/interview_preparation_kit/dynamic_programming/max_array_sum_test.py index f7535f15..0f87221d 100644 --- a/src/hackerrank/interview_preparation_kit/dynamic_programming/max_array_sum_test.py +++ b/src/hackerrank/interview_preparation_kit/dynamic_programming/max_array_sum_test.py @@ -1,12 +1,12 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .max_array_sum import max_array_sum +from ....lib.loader import loadTestCases +from .max_array_sum import maxSubsetSum FILE_PATH = str(Path(__file__).resolve().parent) -TEST_CASES = load_test_cases( +TEST_CASES = loadTestCases( FILE_PATH + '/max_array_sum.testcases.json') @@ -17,8 +17,8 @@ def test_max_array_sum(self): for _, _tt in enumerate(TEST_CASES): self.assertEqual( - max_array_sum(_tt['input']), _tt['expected'], - f"{_} | max_array_sum({_tt['input']}) must be " + maxSubsetSum(_tt['input']), _tt['expected'], + f"{_} | maxSubsetSum({_tt['input']}) must be " f"=> {_tt['expected']}") def test_max_array_sum_edge_case_zero(self): @@ -27,8 +27,8 @@ def test_max_array_sum_edge_case_zero(self): _expected = 0 self.assertEqual( - max_array_sum(_input), _expected, - f"max_array_sum({_input}) must be " + maxSubsetSum(_input), _expected, + f"maxSubsetSum({_input}) must be " f"=> {_expected}") def test_max_array_sum_edge_case_one(self): @@ -37,6 +37,6 @@ def test_max_array_sum_edge_case_one(self): _expected = 1 self.assertEqual( - max_array_sum(_input), _expected, - f"max_array_sum({_input}) must be " + maxSubsetSum(_input), _expected, + f"maxSubsetSum({_input}) must be " f"=> {_expected}") diff --git a/src/hackerrank/interview_preparation_kit/graphs/roads_and_libraries.py b/src/hackerrank/interview_preparation_kit/graphs/roads_and_libraries.py index ac9f38fe..e254ec9d 100644 --- a/src/hackerrank/interview_preparation_kit/graphs/roads_and_libraries.py +++ b/src/hackerrank/interview_preparation_kit/graphs/roads_and_libraries.py @@ -36,7 +36,7 @@ def get_unions(self) -> int: return self._unions -def roads_and_libraries( +def roadsAndLibraries( q_paths: int, c_lib: int, c_road: int, diff --git a/src/hackerrank/interview_preparation_kit/graphs/roads_and_libraries_test.py b/src/hackerrank/interview_preparation_kit/graphs/roads_and_libraries_test.py index f41d5687..9bc2a515 100644 --- a/src/hackerrank/interview_preparation_kit/graphs/roads_and_libraries_test.py +++ b/src/hackerrank/interview_preparation_kit/graphs/roads_and_libraries_test.py @@ -1,12 +1,12 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .roads_and_libraries import roads_and_libraries +from ....lib.loader import loadTestCases +from .roads_and_libraries import roadsAndLibraries FILE_PATH = str(Path(__file__).resolve().parent) -TEST_CASES = load_test_cases( +TEST_CASES = loadTestCases( FILE_PATH + '/roads_and_libraries.testcases.json') @@ -17,7 +17,7 @@ def test_roads_and_libraries(self): for _, _tt in enumerate(TEST_CASES): self.assertEqual( - roads_and_libraries( + roadsAndLibraries( _tt['n'], _tt['c_lib'], _tt['c_road'], diff --git a/src/hackerrank/interview_preparation_kit/greedy_algorithms/angry_children.py b/src/hackerrank/interview_preparation_kit/greedy_algorithms/angry_children.py index 132d8a2c..e9e4a3ca 100644 --- a/src/hackerrank/interview_preparation_kit/greedy_algorithms/angry_children.py +++ b/src/hackerrank/interview_preparation_kit/greedy_algorithms/angry_children.py @@ -2,7 +2,7 @@ # @link Problem definition [[docs/hackerrank/interview_preparation_kit/greedy_algorithms/angry-children.md]] # noqa # pylint: enable=line-too-long -def max_min(k: int, arr: list[int]): +def maxMin(k: int, arr: list[int]): sortedlist = sorted(arr[:]) result = sortedlist[len(arr) - 1] - sortedlist[0] diff --git a/src/hackerrank/interview_preparation_kit/greedy_algorithms/angry_children_test.py b/src/hackerrank/interview_preparation_kit/greedy_algorithms/angry_children_test.py index 35bee1da..c9f36f77 100644 --- a/src/hackerrank/interview_preparation_kit/greedy_algorithms/angry_children_test.py +++ b/src/hackerrank/interview_preparation_kit/greedy_algorithms/angry_children_test.py @@ -1,12 +1,12 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .angry_children import max_min +from ....lib.loader import loadTestCases +from .angry_children import maxMin FILE_PATH = str(Path(__file__).resolve().parent) -TEST_CASES = load_test_cases( +TEST_CASES = loadTestCases( FILE_PATH + '/angry_children.testcases.json') @@ -17,6 +17,6 @@ def test_max_min(self): for _, _tt in enumerate(TEST_CASES): self.assertEqual( - max_min(_tt['k'], _tt['arr']), _tt['expected'], - f"{_} | max_min({_tt['k']}, {_tt['arr']}) must be " + maxMin(_tt['k'], _tt['arr']), _tt['expected'], + f"{_} | maxMin({_tt['k']}, {_tt['arr']}) must be " f"=> {_tt['expected']} in {_tt['title']}") diff --git a/src/hackerrank/interview_preparation_kit/greedy_algorithms/greedy_florist.py b/src/hackerrank/interview_preparation_kit/greedy_algorithms/greedy_florist.py index bb1fb682..bb64f015 100644 --- a/src/hackerrank/interview_preparation_kit/greedy_algorithms/greedy_florist.py +++ b/src/hackerrank/interview_preparation_kit/greedy_algorithms/greedy_florist.py @@ -3,7 +3,7 @@ # pylint: enable=line-too-long -def get_minimum_cost(k_customers: int, c_costs: list[int]): +def getMinimumCost(k_customers: int, c_costs: list[int]): flowers = sorted(c_costs[:], reverse=True) total: int = 0 diff --git a/src/hackerrank/interview_preparation_kit/greedy_algorithms/greedy_florist_test.py b/src/hackerrank/interview_preparation_kit/greedy_algorithms/greedy_florist_test.py index d76f4807..aac125cf 100644 --- a/src/hackerrank/interview_preparation_kit/greedy_algorithms/greedy_florist_test.py +++ b/src/hackerrank/interview_preparation_kit/greedy_algorithms/greedy_florist_test.py @@ -1,12 +1,12 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .greedy_florist import get_minimum_cost +from ....lib.loader import loadTestCases +from .greedy_florist import getMinimumCost FILE_PATH = str(Path(__file__).resolve().parent) -TEST_CASES = load_test_cases( +TEST_CASES = loadTestCases( FILE_PATH + '/greedy_florist.testcases.json') @@ -17,6 +17,6 @@ def test_get_minimum_cost(self): for _, _tt in enumerate(TEST_CASES): self.assertEqual( - get_minimum_cost(_tt['k'], _tt['contests']), _tt['expected'], - f"{_} | get_minimum_cost({_tt['k']}, {_tt['contests']}) must be " + getMinimumCost(_tt['k'], _tt['contests']), _tt['expected'], + f"{_} | getMinimumCost({_tt['k']}, {_tt['contests']}) must be " f"=> {_tt['expected']} in {_tt['title']}") diff --git a/src/hackerrank/interview_preparation_kit/greedy_algorithms/luck_balance.py b/src/hackerrank/interview_preparation_kit/greedy_algorithms/luck_balance.py index 0683b825..852a05b6 100644 --- a/src/hackerrank/interview_preparation_kit/greedy_algorithms/luck_balance.py +++ b/src/hackerrank/interview_preparation_kit/greedy_algorithms/luck_balance.py @@ -15,7 +15,7 @@ def __getitem__(self, item): return self.__dict__[item] -def luck_balance(k, contests: list) -> int: +def luckBalance(k, contests: list) -> int: important_contests: list[Contest] = [] nonimportant_contests: list[Contest] = [] diff --git a/src/hackerrank/interview_preparation_kit/greedy_algorithms/luck_balance_test.py b/src/hackerrank/interview_preparation_kit/greedy_algorithms/luck_balance_test.py index 7605d622..feb25242 100644 --- a/src/hackerrank/interview_preparation_kit/greedy_algorithms/luck_balance_test.py +++ b/src/hackerrank/interview_preparation_kit/greedy_algorithms/luck_balance_test.py @@ -1,12 +1,12 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .luck_balance import luck_balance +from ....lib.loader import loadTestCases +from .luck_balance import luckBalance FILE_PATH = str(Path(__file__).resolve().parent) -TEST_CASES = load_test_cases( +TEST_CASES = loadTestCases( FILE_PATH + '/luck_balance.testcases.json') @@ -17,6 +17,6 @@ def test_luck_balance(self): for _, _tt in enumerate(TEST_CASES): self.assertEqual( - luck_balance(_tt['k'], _tt['contests']), _tt['expected'], - f"{_} | luck_balance({_tt['k']}, {_tt['contests']}) must be " + luckBalance(_tt['k'], _tt['contests']), _tt['expected'], + f"{_} | luckBalance({_tt['k']}, {_tt['contests']}) must be " f"=> {_tt['expected']} in {_tt['title']}") diff --git a/src/hackerrank/interview_preparation_kit/greedy_algorithms/minimum_absolute_difference_in_an_array.py b/src/hackerrank/interview_preparation_kit/greedy_algorithms/minimum_absolute_difference_in_an_array.py index 1c9f925c..85d7ff91 100644 --- a/src/hackerrank/interview_preparation_kit/greedy_algorithms/minimum_absolute_difference_in_an_array.py +++ b/src/hackerrank/interview_preparation_kit/greedy_algorithms/minimum_absolute_difference_in_an_array.py @@ -8,7 +8,7 @@ LOGGER = logging.getLogger(__name__) -def minimum_absolute_difference(arr: list[int]) -> int | None: +def minimumAbsoluteDifference(arr: list[int]) -> int | None: sorted_nums = sorted(arr) result = None diff --git a/src/hackerrank/interview_preparation_kit/greedy_algorithms/minimum_absolute_difference_in_an_array_test.py b/src/hackerrank/interview_preparation_kit/greedy_algorithms/minimum_absolute_difference_in_an_array_test.py index 28fc654e..704cf4f7 100644 --- a/src/hackerrank/interview_preparation_kit/greedy_algorithms/minimum_absolute_difference_in_an_array_test.py +++ b/src/hackerrank/interview_preparation_kit/greedy_algorithms/minimum_absolute_difference_in_an_array_test.py @@ -1,12 +1,12 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .minimum_absolute_difference_in_an_array import minimum_absolute_difference +from ....lib.loader import loadTestCases +from .minimum_absolute_difference_in_an_array import minimumAbsoluteDifference FILE_PATH = str(Path(__file__).resolve().parent) -TEST_CASES = load_test_cases( +TEST_CASES = loadTestCases( FILE_PATH + '/minimum_absolute_difference_in_an_array.testcases.json') @@ -17,6 +17,6 @@ def test_minimum_absolute_difference(self): for _, _tt in enumerate(TEST_CASES): self.assertEqual( - minimum_absolute_difference(_tt['input']), _tt['expected'], - f"{_} | minimum_absolute_difference({_tt['input']}) must be " + minimumAbsoluteDifference(_tt['input']), _tt['expected'], + f"{_} | minimumAbsoluteDifference({_tt['input']}) must be " f"=> {_tt['expected']}") diff --git a/src/hackerrank/interview_preparation_kit/linked_lists/ctci_linked_list_cycle.py b/src/hackerrank/interview_preparation_kit/linked_lists/ctci_linked_list_cycle.py index 13745b49..c6533c47 100644 --- a/src/hackerrank/interview_preparation_kit/linked_lists/ctci_linked_list_cycle.py +++ b/src/hackerrank/interview_preparation_kit/linked_lists/ctci_linked_list_cycle.py @@ -1,3 +1,4 @@ +# pylint: disable=invalid-name # pylint: disable=line-too-long # @link Problem definition [[docs/hackerrank/interview_preparation_kit/linked_lists/ctci_linked_list_cycle.md]] # noqa: E501 # pylint: enable=line-too-long @@ -5,7 +6,7 @@ from .lib.singly_linked_list import SinglyLinkedListNode -def has_cycle(head: SinglyLinkedListNode) -> bool: +def has_cycle(head: SinglyLinkedListNode) -> bool: # NOSONAR llindex: list[SinglyLinkedListNode] = [] node: SinglyLinkedListNode | None = head diff --git a/src/hackerrank/interview_preparation_kit/linked_lists/find_the_merge_point_of_two_joined_linked_lists.py b/src/hackerrank/interview_preparation_kit/linked_lists/find_the_merge_point_of_two_joined_linked_lists.py index 8282261e..cd3b430f 100644 --- a/src/hackerrank/interview_preparation_kit/linked_lists/find_the_merge_point_of_two_joined_linked_lists.py +++ b/src/hackerrank/interview_preparation_kit/linked_lists/find_the_merge_point_of_two_joined_linked_lists.py @@ -5,7 +5,7 @@ from .lib.singly_linked_list import SinglyLinkedListNode -def find_merge_node( +def findMergeNode( head1: SinglyLinkedListNode, head2: SinglyLinkedListNode) -> int | None: llindex: list[SinglyLinkedListNode] = [] diff --git a/src/hackerrank/interview_preparation_kit/linked_lists/find_the_merge_point_of_two_joined_linked_lists_test.py b/src/hackerrank/interview_preparation_kit/linked_lists/find_the_merge_point_of_two_joined_linked_lists_test.py index c2d823a9..41914b89 100644 --- a/src/hackerrank/interview_preparation_kit/linked_lists/find_the_merge_point_of_two_joined_linked_lists_test.py +++ b/src/hackerrank/interview_preparation_kit/linked_lists/find_the_merge_point_of_two_joined_linked_lists_test.py @@ -1,7 +1,7 @@ import unittest from .lib.singly_linked_list import SinglyLinkedListNode -from .find_the_merge_point_of_two_joined_linked_lists import find_merge_node +from .find_the_merge_point_of_two_joined_linked_lists import findMergeNode # Test Case 0 # @@ -60,8 +60,8 @@ def test_find_merge_node(self): for _, _tt in enumerate(TEST_CASES): self.assertEqual( - find_merge_node(_tt['llist1'], _tt['llist2']), + findMergeNode(_tt['llist1'], _tt['llist2']), _tt['answer'], - f"{_} | find_merge_node(" + f"{_} | findMergeNode(" f"{_tt['llist1']}, {_tt['llist2']})" f") must be => {_tt['answer']}") diff --git a/src/hackerrank/interview_preparation_kit/linked_lists/insert_a_node_at_a_specific_position_in_a_linked_list.py b/src/hackerrank/interview_preparation_kit/linked_lists/insert_a_node_at_a_specific_position_in_a_linked_list.py index 35a80fab..a3a56feb 100644 --- a/src/hackerrank/interview_preparation_kit/linked_lists/insert_a_node_at_a_specific_position_in_a_linked_list.py +++ b/src/hackerrank/interview_preparation_kit/linked_lists/insert_a_node_at_a_specific_position_in_a_linked_list.py @@ -5,7 +5,7 @@ from .lib.singly_linked_list import SinglyLinkedListNode -def insert_node_at_position(llist: SinglyLinkedListNode | None, data: int, position: int): +def insertNodeAtPosition(llist: SinglyLinkedListNode | None, data: int, position: int): new_node = SinglyLinkedListNode(data) diff --git a/src/hackerrank/interview_preparation_kit/linked_lists/insert_a_node_at_a_specific_position_in_a_linked_list_test.py b/src/hackerrank/interview_preparation_kit/linked_lists/insert_a_node_at_a_specific_position_in_a_linked_list_test.py index 76a5ecfa..283c43c7 100644 --- a/src/hackerrank/interview_preparation_kit/linked_lists/insert_a_node_at_a_specific_position_in_a_linked_list_test.py +++ b/src/hackerrank/interview_preparation_kit/linked_lists/insert_a_node_at_a_specific_position_in_a_linked_list_test.py @@ -1,7 +1,7 @@ import unittest -from .lib.singly_linked_list import SinglyLinkedList, singly_linked_list_to_text -from .insert_a_node_at_a_specific_position_in_a_linked_list import insert_node_at_position +from .lib.singly_linked_list import SinglyLinkedList, singlyLinkedListToText +from .insert_a_node_at_a_specific_position_in_a_linked_list import insertNodeAtPosition TEST_CASES = [ @@ -24,17 +24,17 @@ def test_insert_node_at_position(self): for _, _tt in enumerate(TEST_CASES): - insert_node_at_position( + insertNodeAtPosition( _tt['llist'].head, _tt['data'], _tt['position']) - result = singly_linked_list_to_text(_tt['llist'].head, ' ') + result = singlyLinkedListToText(_tt['llist'].head, ' ') self.assertEqual( result, _tt['answer'], - f"{_} | insert_node_at_position(" + f"{_} | insertNodeAtPosition(" f"{_tt['llist'].head}," f"{_tt['data']}," f"{_tt['position']}," @@ -46,19 +46,19 @@ def test_insert_node_at_position_edge_case(self): data = 2 position = 0 - head = insert_node_at_position( + head = insertNodeAtPosition( llist.head, data, position) - result = singly_linked_list_to_text(head, ' ') + result = singlyLinkedListToText(head, ' ') answer = '2 1' self.assertEqual( result, answer, - f"insert_node_at_position(" + f"insertNodeAtPosition(" f"{llist}," f"{data}," f"{position}," diff --git a/src/hackerrank/interview_preparation_kit/linked_lists/insert_a_node_into_a_sorted_doubly_linked_list.py b/src/hackerrank/interview_preparation_kit/linked_lists/insert_a_node_into_a_sorted_doubly_linked_list.py index baf0d22a..96d3334b 100644 --- a/src/hackerrank/interview_preparation_kit/linked_lists/insert_a_node_into_a_sorted_doubly_linked_list.py +++ b/src/hackerrank/interview_preparation_kit/linked_lists/insert_a_node_into_a_sorted_doubly_linked_list.py @@ -1,5 +1,5 @@ # pylint: disable=line-too-long -# @link Problem definition [[docs/hackerrank/interview_preparation_kit/linked_lists/insert-a-current-into-a-sorted-doubly-linked-list.md]] # noqa: E501 +# @link Problem definition [[docs/hackerrank/interview_preparation_kit/linked_lists/insert-a-node-into-a-sorted-doubly-linked-list.md]] # noqa: E501 # pylint: enable=line-too-long import logging @@ -8,7 +8,7 @@ LOGGER = logging.getLogger(__name__) -def sorted_insert( +def sortedInsert( llist: DoublyLinkedListNode | None, data: int) -> DoublyLinkedListNode | None: diff --git a/src/hackerrank/interview_preparation_kit/linked_lists/insert_a_node_into_a_sorted_doubly_linked_list_test.py b/src/hackerrank/interview_preparation_kit/linked_lists/insert_a_node_into_a_sorted_doubly_linked_list_test.py index 43c06bc6..85935374 100644 --- a/src/hackerrank/interview_preparation_kit/linked_lists/insert_a_node_into_a_sorted_doubly_linked_list_test.py +++ b/src/hackerrank/interview_preparation_kit/linked_lists/insert_a_node_into_a_sorted_doubly_linked_list_test.py @@ -1,7 +1,7 @@ import unittest -from .lib.doubly_linked_list import DoublyLinkedList, double_linked_list_to_text -from .insert_a_node_into_a_sorted_doubly_linked_list import sorted_insert +from .lib.doubly_linked_list import DoublyLinkedList, doubleLinkedListToText +from .insert_a_node_into_a_sorted_doubly_linked_list import sortedInsert TEST_CASES = [ @@ -41,16 +41,16 @@ def test_sorted_insert(self): for _, _tt in enumerate(TEST_CASES): - llist = sorted_insert( + llist = sortedInsert( _tt['llist'].head, _tt['data']) - result = double_linked_list_to_text(llist, ' ') + result = doubleLinkedListToText(llist, ' ') self.assertEqual( result, _tt['answer'], - f"{_} | sorted_insert(" + f"{_} | sortedInsert(" f"{_tt['llist'].head}," f"{_tt['data']}," f") must be => {_tt['answer']}") @@ -60,18 +60,18 @@ def test_sorted_insert_edge_case(self): llist = DoublyLinkedList() data = 1 - head = sorted_insert( + head = sortedInsert( llist.head, data) - result = double_linked_list_to_text(head, ' ') + result = doubleLinkedListToText(head, ' ') answer = '1' self.assertEqual( result, answer, - f"sorted_insert(" + f"sortedInsert(" f"{llist}," f"{data}" f") must be => {answer}") diff --git a/src/hackerrank/interview_preparation_kit/linked_lists/lib/doubly_linked_list.py b/src/hackerrank/interview_preparation_kit/linked_lists/lib/doubly_linked_list.py index 16612523..de99925e 100644 --- a/src/hackerrank/interview_preparation_kit/linked_lists/lib/doubly_linked_list.py +++ b/src/hackerrank/interview_preparation_kit/linked_lists/lib/doubly_linked_list.py @@ -32,7 +32,7 @@ def insert_node(self, node_data): return self -def double_linked_list_to_text(node, sep): +def doubleLinkedListToText(node, sep): output: str = '' while node: diff --git a/src/hackerrank/interview_preparation_kit/linked_lists/lib/singly_linked_list.py b/src/hackerrank/interview_preparation_kit/linked_lists/lib/singly_linked_list.py index 44962eb9..72cdde99 100644 --- a/src/hackerrank/interview_preparation_kit/linked_lists/lib/singly_linked_list.py +++ b/src/hackerrank/interview_preparation_kit/linked_lists/lib/singly_linked_list.py @@ -32,7 +32,7 @@ def insert_node(self, node_data) -> SinglyLinkedList: # modified from original, this return a string instead of print -def singly_linked_list_to_text(node, sep) -> str: +def singlyLinkedListToText(node, sep) -> str: output: str = '' while node: diff --git a/src/hackerrank/interview_preparation_kit/linked_lists/reverse_a_doubly_linked_list_test.py b/src/hackerrank/interview_preparation_kit/linked_lists/reverse_a_doubly_linked_list_test.py index dadad7f2..ce958394 100644 --- a/src/hackerrank/interview_preparation_kit/linked_lists/reverse_a_doubly_linked_list_test.py +++ b/src/hackerrank/interview_preparation_kit/linked_lists/reverse_a_doubly_linked_list_test.py @@ -1,6 +1,6 @@ import unittest -from .lib.doubly_linked_list import DoublyLinkedList, double_linked_list_to_text +from .lib.doubly_linked_list import DoublyLinkedList, doubleLinkedListToText from .reverse_a_doubly_linked_list import reverse @@ -43,7 +43,7 @@ def test_reverse(self): llist = reverse(_tt['llist'].head) - result = double_linked_list_to_text(llist, ' ') + result = doubleLinkedListToText(llist, ' ') self.assertEqual( result, diff --git a/src/hackerrank/interview_preparation_kit/miscellaneous/flipping_bits.py b/src/hackerrank/interview_preparation_kit/miscellaneous/flipping_bits.py index bdfcca5c..6029aa0f 100644 --- a/src/hackerrank/interview_preparation_kit/miscellaneous/flipping_bits.py +++ b/src/hackerrank/interview_preparation_kit/miscellaneous/flipping_bits.py @@ -2,7 +2,7 @@ # @link Problem definition [[docs/hackerrank/interview_preparation_kit/miscellaneous/flipping-bits.md]] # noqa # pylint: enable=line-too-long -def flipping_bits(number: int) -> int: +def flippingBits(number: int) -> int: # print(n) n_bin = bin(number) diff --git a/src/hackerrank/interview_preparation_kit/miscellaneous/flipping_bits_test.py b/src/hackerrank/interview_preparation_kit/miscellaneous/flipping_bits_test.py index cdaab99d..084eb06b 100644 --- a/src/hackerrank/interview_preparation_kit/miscellaneous/flipping_bits_test.py +++ b/src/hackerrank/interview_preparation_kit/miscellaneous/flipping_bits_test.py @@ -1,12 +1,12 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .flipping_bits import flipping_bits +from ....lib.loader import loadTestCases +from .flipping_bits import flippingBits FILE_PATH = str(Path(__file__).resolve().parent) -TEST_CASES = load_test_cases( +TEST_CASES = loadTestCases( FILE_PATH + '/flipping_bits.testcases.json') @@ -19,6 +19,6 @@ def test_flipping_bits(self): for _, _tt in enumerate(testset['tests']): self.assertEqual( - flipping_bits(_tt['input']), _tt['answer'], - f"{_} | flipping_bits({_tt['input']}) must be " + flippingBits(_tt['input']), _tt['answer'], + f"{_} | flippingBits({_tt['input']}) must be " f"=> {_tt['answer']}") diff --git a/src/hackerrank/interview_preparation_kit/miscellaneous/friend_circle_queries.py b/src/hackerrank/interview_preparation_kit/miscellaneous/friend_circle_queries.py index ea6d6bd8..6928c6c0 100644 --- a/src/hackerrank/interview_preparation_kit/miscellaneous/friend_circle_queries.py +++ b/src/hackerrank/interview_preparation_kit/miscellaneous/friend_circle_queries.py @@ -47,7 +47,7 @@ def count_groups(self) -> int: return self._large_friendship -def max_circle(queries) -> list[int]: +def maxCircle(queries) -> list[int]: result: list[int] = [] friends = GroupingFriends() diff --git a/src/hackerrank/interview_preparation_kit/miscellaneous/friend_circle_queries_test.py b/src/hackerrank/interview_preparation_kit/miscellaneous/friend_circle_queries_test.py index 8c841870..7efff9df 100644 --- a/src/hackerrank/interview_preparation_kit/miscellaneous/friend_circle_queries_test.py +++ b/src/hackerrank/interview_preparation_kit/miscellaneous/friend_circle_queries_test.py @@ -1,13 +1,13 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .friend_circle_queries import max_circle +from ....lib.loader import loadTestCases +from .friend_circle_queries import maxCircle FILE_PATH = str(Path(__file__).resolve().parent) -TEST_CASES = load_test_cases( +TEST_CASES = loadTestCases( FILE_PATH + '/friend_circle_queries.testcases.json') @@ -18,6 +18,6 @@ def test_max_circle(self): for _, _tt in enumerate(TEST_CASES): self.assertEqual( - max_circle(_tt['arr']), _tt['answer'], - f"{_} | max_circle({_tt['arr']}) must be " + maxCircle(_tt['arr']), _tt['answer'], + f"{_} | maxCircle({_tt['arr']}) must be " f"=> {_tt['answer']} in {_tt['title']}") diff --git a/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/ctci_fibonacci_numbers.testcases.json b/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/ctci_fibonacci_numbers.testcases.json new file mode 100644 index 00000000..dfa753cf --- /dev/null +++ b/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/ctci_fibonacci_numbers.testcases.json @@ -0,0 +1,17 @@ +[ + { + "title": "Sample Test case 0", + "input": 5, + "expected": 5 + }, + { + "title": "Sample Test case 1", + "input": 12, + "expected": 144 + }, + { + "title": "Sample Test case 2", + "input": 17, + "expected": 1597 + } +] diff --git a/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/ctci_fibonacci_numbers_test.py b/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/ctci_fibonacci_numbers_test.py index 6c110ae7..2922743b 100644 --- a/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/ctci_fibonacci_numbers_test.py +++ b/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/ctci_fibonacci_numbers_test.py @@ -1,23 +1,13 @@ import unittest +from pathlib import Path + +from ....lib.loader import loadTestCases from .ctci_fibonacci_numbers import fibonacci -TEST_CASES = [ - { - 'title': 'Sample Test case 0', - 'input': 5, - 'answer': 5 - }, - { - 'title': 'Sample Test case 1', - 'input': 12, - 'answer': 144, - }, - { - 'title': 'Sample Test case 2', - 'input': 17, - 'answer': 1597 - } -] +FILE_PATH = str(Path(__file__).resolve().parent) + +TEST_CASES = loadTestCases( + FILE_PATH + '/ctci_fibonacci_numbers.testcases.json') class TestRecursionFibonacciNumbers(unittest.TestCase): @@ -27,6 +17,6 @@ def test_fibonacci(self): for _, _tt in enumerate(TEST_CASES): self.assertEqual( - fibonacci(_tt['input']), _tt['answer'], + fibonacci(_tt['input']), _tt['expected'], f"{_} | fibonacci({_tt['input']}) must be " - f"=> {_tt['answer']} in {_tt['title']}") + f"=> {_tt['expected']} in {_tt['title']}") diff --git a/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/ctci_recursive_staircase.py b/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/ctci_recursive_staircase.py index 5cb55d63..0291778f 100644 --- a/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/ctci_recursive_staircase.py +++ b/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/ctci_recursive_staircase.py @@ -9,7 +9,7 @@ STEPS_LIMIT = 3 -def step_perms_comput_with_cache( +def stepPermsComputWithCache( n_steps: int, cache: Dict[int, int], steps_limit: int) -> int: @@ -23,7 +23,7 @@ def step_perms_comput_with_cache( search_key: int = n_steps - i if search_key not in cache: - cache[search_key] = step_perms_comput_with_cache( + cache[search_key] = stepPermsComputWithCache( search_key, cache, steps_limit @@ -34,6 +34,6 @@ def step_perms_comput_with_cache( return (result + 1) if n_steps <= steps_limit else result -def step_perms(n_steps: int) -> int: +def stepPerms(n_steps: int) -> int: initial_cache: Dict[int, int] = {} - return step_perms_comput_with_cache(n_steps, initial_cache, STEPS_LIMIT) % TOP_LIMIT + return stepPermsComputWithCache(n_steps, initial_cache, STEPS_LIMIT) % TOP_LIMIT diff --git a/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/ctci_recursive_staircase_alternative.py b/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/ctci_recursive_staircase_alternative.py index ad6194ac..97ae5449 100644 --- a/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/ctci_recursive_staircase_alternative.py +++ b/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/ctci_recursive_staircase_alternative.py @@ -8,7 +8,7 @@ @cache -def step_perms(n_steps: int) -> int: +def stepPerms(n_steps: int) -> int: # Base cases if n_steps == 3: return 4 @@ -18,6 +18,6 @@ def step_perms(n_steps: int) -> int: # Recursion result = 0 for i in range(1, 4): - result += step_perms(n_steps - i) + result += stepPerms(n_steps - i) return result diff --git a/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/ctci_recursive_staircase_test.py b/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/ctci_recursive_staircase_test.py index 43f06777..ee5e38c7 100644 --- a/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/ctci_recursive_staircase_test.py +++ b/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/ctci_recursive_staircase_test.py @@ -1,24 +1,18 @@ import unittest -import json from pathlib import Path from typing import Dict -from .ctci_recursive_staircase import step_perms, step_perms_comput_with_cache -from .ctci_recursive_staircase_alternative import step_perms as step_perms_alt +from ....lib.loader import loadTestCases +from .ctci_recursive_staircase import stepPerms, stepPermsComputWithCache +from .ctci_recursive_staircase_alternative import stepPerms as stepPermsAlt FILE_PATH = str(Path(__file__).resolve().parent) -with open( - FILE_PATH + '/ctci_recursive_staircase.testcases.json', - encoding="utf-8" -) as file1: - TEST_CASES = json.load(file1) +TEST_CASES = loadTestCases( + FILE_PATH + '/ctci_recursive_staircase.testcases.json') -with open( - FILE_PATH + '/ctci_recursive_staircase_generalized.testcases.json', - encoding="utf-8" -) as file2: - TEST_CASES_GENERALIZED = json.load(file2) +TEST_CASES_GENERALIZED = loadTestCases( + FILE_PATH + '/ctci_recursive_staircase_generalized.testcases.json') class TestStaircase(unittest.TestCase): @@ -30,8 +24,8 @@ def test_step_perms_alt_edge_case(self): title: str = 'Edge Case 0' self.assertEqual( - step_perms(n_input), answer, - f"step_perms_alt({input}) must be " + stepPermsAlt(n_input), answer, + f"stepPermsAlt({input}) must be " f"=> {answer} in {title}") def test_step_perms(self): @@ -41,8 +35,8 @@ def test_step_perms(self): for _, _tt in enumerate(testset['tests']): self.assertEqual( - step_perms(_tt['input']), _tt['expected'], - f"{_} | step_perms({_tt['input']}) must be " + stepPerms(_tt['input']), _tt['expected'], + f"{_} | stepPerms({_tt['input']}) must be " f"=> {_tt['expected']} in {testset['title']}") def test_step_perms_comput_with_cache(self): @@ -54,11 +48,11 @@ def test_step_perms_comput_with_cache(self): initial_cache: Dict[int, int] = {} self.assertEqual( - step_perms_comput_with_cache( + stepPermsComputWithCache( _tt['input'], initial_cache, _tt['limit']), _tt['expected'], - f"{_} | step_perms_comput_with_cache(" + f"{_} | stepPermsComputWithCache(" f"{_tt['input']}, {initial_cache}, {_tt['limit']}) must be " f"=> {_tt['expected']} in {testset['title']}") @@ -69,6 +63,6 @@ def test_step_perms_alt(self): for _, _tt in enumerate(testset['tests']): self.assertEqual( - step_perms_alt(_tt['input']), _tt['expected'], - f"{_} | step_perms_alt({_tt['input']}) must be " + stepPermsAlt(_tt['input']), _tt['expected'], + f"{_} | stepPermsAlt({_tt['input']}) must be " f"=> {_tt['expected']} in {testset['title']}") diff --git a/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/recursive_digit_sum.py b/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/recursive_digit_sum.py index 533a0608..8acd6578 100644 --- a/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/recursive_digit_sum.py +++ b/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/recursive_digit_sum.py @@ -6,7 +6,7 @@ sys.set_int_max_str_digits(0) -def super_digit_compute(p_number: int): +def superDigitCompute(p_number: int): word = str(p_number) if len(word) == 1: @@ -16,8 +16,8 @@ def super_digit_compute(p_number: int): for digit in word: partial += int(digit) - return super_digit_compute(partial) + return superDigitCompute(partial) -def super_digit(n_number: int | str, k_times: int): - return super_digit_compute(int(n_number) * k_times) +def superDigit(n_number: int | str, k_times: int): + return superDigitCompute(int(n_number) * k_times) diff --git a/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/recursive_digit_sum.testcases.json b/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/recursive_digit_sum.testcases.json new file mode 100644 index 00000000..3c15cb4e --- /dev/null +++ b/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/recursive_digit_sum.testcases.json @@ -0,0 +1,33 @@ +[ + { + "title": "Sample Test case 0", + "n": "148", + "k": 3, + "expected": 3 + }, + { + "title": "Sample Test case 7", + "n": + "2365978831649490136475575038877779575813226775851820912370812124502641538947920808397703549713678494683928497712437176140282589350277653479225520602813456433277417366680426198633681891184348757007292907409160353745221125354212095528784124728447770959861439390350308313917365021363541712618686942946773324003146008424205688630371656757561012224744901800726911246423272186301595490993253791386102270201965996662707215300748516732223935858816466886068592299708740453558018878677753623653080545592459765998008028026982510689469213738241205802446029154833458048894002646934119082621498341445221491190955459548371083839625590505228681017724678315572531551988758568150699821635779156685637531274097856486075649357610713833072735231599919848220063026429718137766286716343385059699133211699189933339174843625266398503099203416124466032711453854413933737536836406105991857744766344461162222670876732729171585512468615558499979720269427922798431312270483732004392503905160233457811525428432787732543799783309593536386190295516419339222642886780012683583264436427241020490358960438948951090123073035203797984302163150042110707217274102457735317367100133807782064391421012191958312396649052833396257876824943425814834615313474161638240747120342368147351931074481983318414461554116111216672594256301273113776892080967125790153125125885441941114178586071406149630777323200516190208241341822285244325578953416388462284725673478766919050744786263188733438572307443267700831425575113213359873223948072988922668251652320316884761627830570057061821492039968369341602081382603302965910382997241199808824091331180464950187035576778206683245316006405529597170652549163351875206280564448346510252775085876212617353369513619186390565654064068546863018765466029315754619416429621887091818939474391383675337791979997519954871635692656223852981330368145996344325688247632566665645262588764650823901065646663460851602833982853795901687202035893967893724362979886948663369428689585509715442019662325024294581705265808022570365351645495802686891955348084550615538750809287498241260408673517746608582833123696027380353038348218786331710334697053069152326732702246704177127367642287975998486114018970510842276024855162228267767755948030029723573646908844109049374244456580474922058250964260437721278380069311972455077102266167098465788845261016395772392904280411167763443571285141388567074805986331207454652671618663858701085276806486000014124900483188940484497173286284987124699515039831183902383877120136788492339903316093693938833730548247174799553092402671083313285813003903363625219370039413610850308966558948057932583576771492037811460439359542902624599661588624295232252616245186844975995180218889230403968087888108494214819234992007182241562844376961711438491105585390645332161544542326095869642445733823661806228697208277656426326128938546125761166960351482948539114133280810916317873360419836067625116114001377672929333638768292095236809153349426894896869446197395671771932928211109385884940274160388152027885130001908095515987519207099973668415699818805100890690896126345099249836616348702742776559368591004254298734292430313132506862931339852599450961120591169865484036943294045257801193102728400887526383477970523720630900867795111210451854194391002244150921934506879640791680297603712618076174694948300699937409787596860516266369711284028834238022724596540529491965656156574337073988564171171562036245389632730259264953520190321920347601255396137920500496074443380910841069973360586715775083998842187392360751892748665579312212647821816086677544702037289983388842777905728540745718314922321086695691823249801139552886748181144717500999021690749662561227798159566905725946118195067702032931332172088385727012140744362147720922176656204772910422189621466379287662792372374145383317294646977085291873933547226857758530880168793511465268400187943977613894365634645591604177130794105552582447385631392788652188052953414781129655671439788151513996304231024358843023105354157338564270003904673736178109502550650713167258319522545824056524791781105181639237127875356417268878249642171688744070159985867211941494396566216365392991627962886902198712613982017603237174682825814797983967054038269833008728407345912699623004623467287738296110774212005294050799218227654983820235796069236099706911525806244933683548619651925300435846989868138976944006822652462513903624200398184640627878400159480147462063679751851193719499676402496701528971830054482832320057097082360875809145428036636600549270698504540758319126452884313155162288201445118708935758033035083555929081756050975974040793712887964439001525986626643925845343840647344753344394209812309532147589135665638895095150172324875219965305745649692175878476631167339609984047545458299489650202318886162798841051758853022389219423402386031324398337411422060786064174337895040820526914615325075313448800789763344707190242881920892579588963376086146960633381215378914452523108903834607764477580583821712879080194987840450703336371649758616364805184545636558639909806705757141231728890945705281578891764357530862478284617890886615612608017861029342475376559517893073874528735689724989147963227442563141916115837740823088920018306622898786665697436694114134566032298418513134640110497915781256013658157626876007303865007938799121914067544773285391447059337068967640221461662745594510968605338966108977317081902507941847885331172633986644666002196037962414608353479436996966565895587993028389782659415971152403029518493019029205611785920255633270560095438637318885230551138363908343081523545591224134467205438637992783829259919217744713264231649621461535887435410548366408012977973203459983761967831442350892580662433295719596302715165438994052920660204857279403439598616231631708579334309451829396365207336409446940374623441420435439989058506571776629533788131454314121504595268258657172190365178279637763408587826711292793610001999656837923788319438384372260168303662843086203813103771712423574817520332644704407707584630263836497460974781867543909787940278207946350316762434685271126547340568379697114143432270663747926423410939366867323227307888313764100323948708488249291932762190879422500980573314510481474989813161818046596342997489244092851481456635241462079248335760582513488928151459281907438730238065382341691833250917737617330046824951709287812847967496061820848573006896422220098029186444659696393722864425443174804115295661452095886127784785656396807536597522937517010395385281668735072368362229248386090765688300603292905737705424037244946746445640174635429078019229973366378415273692915764515173009646632256826278792193749314522687455317800604524740119271772480341422364037622841158408693597798800732407214231715176216414119458470398433698630492023148912788371335047944731850924533486580463894436416946298869397354691924065211837844914014837056117850937923852135361875895012428779496342389871713463333419295329258828037504468306416370691252321110783303933730724981220411655523128107813025668960480700236419568269112404054054013255954297124592253625509027169128346186086879842249233969016492009074059375814396213470661585889025858173286307393463166771278528359358679107663618852904436981159408575155381452852538538161326799566605463071606829507721627760695695298663348037499346965080571845983286426728562771057921340809114888275207834276278723670038713251819678117637307797126524335451875674322135660001938501046206646725087020563845482789165114015140237476770960542212541262365674096922377749965211055083880951870947588439313087505990968967904452943561444336754539161497904651842954423690339860136920316455021978105823558793189756025331264642326253916951167641064028719315782248353333706214902160610987866723541787809188383034860801960339654982067421224921066723519523759569071993168783868197116308035921525346492767986090665094574147296651701824963729081365854249511700896706324052098265362182297874817162325372836249682033460453106454759294279011517085352648052686287835826956331856000530656816094258663224239727567999798475939204052755892731997428948369450364798425229576414764799300949556003266863462364785971588403993047829919672884685002127952124093077144535644623315342420032186819555104280110883937594970132297831017511120535205810256141119655336117669459771376005411248881994640753601606805393583940281645304757423903447751752383876356426048210439751541893763188890403792485964646286690953432929961087972625329578244854544295899075470411907779181886987220577672224785177419791954783277253421243333498197370278143247403594312138218592254174197047846302000164735966226394070001204323764164912690541799927573761616438820835021411743898829210130296149250887986491553547221899402096605456148489590866922112294624680546281250567297009605663936998939340731539740128008013832941045470722922727419033890751091173021386847464099733717633316304536930447077599861319788266450790785072377536483225439587367122393671167950836029510856465462738804587713268436992128892171509071641161165880608224322539890931445909082786991260734902410993863449929626354001121991398640542747424891140797115509495342486678389565402504229791244504867508301342798992744796454984189142033193018659744179186808244403688375727771580862592404226696538971232713170205127941869698531179001250635892043048835137445218382957976989721755706861701366347894376710532041643279157597459032202591566808167568419301491754821992741943996185368155017334681412500723160011387595363158410560488203993638466615700276165502049790282263414502568166837301414930688269694553727263733690839349714652132206285243796184219815308355634318194592022805870387606542297381666905458451054204419608774066516116961329031388338821535694456637910702328420582124442440139995352494707284230907975581024232726130673375360163257154562557607055131368534412734263401317160921075802949888891100336188281116884460133424076740001934250575466042922149519629860344218277351996828116545149383178424384811799946144322536711027462093434842033767504492071349955677051700618860129870409856113128392373584622061075886499407885141951318807519645386474", + "k": 100000, + "expected": 7 + }, + { + "title": "Sample Test case 10", + "n": "9875", + "k": 4, + "expected": 8 + }, + { + "title": "Sample Test case 11", + "n": "123", + "k": 3, + "expected": 9 + }, + { + "title": "Sample Test case 10", + "n": "9875", + "k": 4, + "expected": 8 + } +] diff --git a/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/recursive_digit_sum_test.py b/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/recursive_digit_sum_test.py index cc19c6fb..95194ef2 100644 --- a/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/recursive_digit_sum_test.py +++ b/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/recursive_digit_sum_test.py @@ -1,163 +1,13 @@ import unittest -from .recursive_digit_sum import super_digit +from pathlib import Path -TEST_CASES = [ - { - 'title': 'Sample Test case 0', - 'n': 123, - 'k': 3, - 'answer': 9 - }, - { - 'title': 'Sample Test case 7', - 'n': - '2365978831649490136475575038877779575813226775851820912370812124502641' - '5389479208083977035497136784946839284977124371761402825893502776534792' - '2552060281345643327741736668042619863368189118434875700729290740916035' - '3745221125354212095528784124728447770959861439390350308313917365021363' - '5417126186869429467733240031460084242056886303716567575610122247449018' - '0072691124642327218630159549099325379138610227020196599666270721530074' - '8516732223935858816466886068592299708740453558018878677753623653080545' - '5924597659980080280269825106894692137382412058024460291548334580488940' - '0264693411908262149834144522149119095545954837108383962559050522868101' - '7724678315572531551988758568150699821635779156685637531274097856486075' - '6493576107138330727352315999198482200630264297181377662867163433850596' - '9913321169918993333917484362526639850309920341612446603271145385441393' - '3737536836406105991857744766344461162222670876732729171585512468615558' - '4999797202694279227984313122704837320043925039051602334578115254284327' - '8773254379978330959353638619029551641933922264288678001268358326443642' - '7241020490358960438948951090123073035203797984302163150042110707217274' - '1024577353173671001338077820643914210121919583123966490528333962578768' - '2494342581483461531347416163824074712034236814735193107448198331841446' - '1554116111216672594256301273113776892080967125790153125125885441941114' - '1785860714061496307773232005161902082413418222852443255789534163884622' - '8472567347876691905074478626318873343857230744326770083142557511321335' - '9873223948072988922668251652320316884761627830570057061821492039968369' - '3416020813826033029659103829972411998088240913311804649501870355767782' - '0668324531600640552959717065254916335187520628056444834651025277508587' - '6212617353369513619186390565654064068546863018765466029315754619416429' - '6218870918189394743913836753377919799975199548716356926562238529813303' - '6814599634432568824763256666564526258876465082390106564666346085160283' - '3982853795901687202035893967893724362979886948663369428689585509715442' - '0196623250242945817052658080225703653516454958026868919553480845506155' - '3875080928749824126040867351774660858283312369602738035303834821878633' - '1710334697053069152326732702246704177127367642287975998486114018970510' - '8422760248551622282677677559480300297235736469088441090493742444565804' - '7492205825096426043772127838006931197245507710226616709846578884526101' - '6395772392904280411167763443571285141388567074805986331207454652671618' - '6638587010852768064860000141249004831889404844971732862849871246995150' - '3983118390238387712013678849233990331609369393883373054824717479955309' - '2402671083313285813003903363625219370039413610850308966558948057932583' - '5767714920378114604393595429026245996615886242952322526162451868449759' - '9518021888923040396808788810849421481923499200718224156284437696171143' - '8491105585390645332161544542326095869642445733823661806228697208277656' - '4263261289385461257611669603514829485391141332808109163178733604198360' - '6762511611400137767292933363876829209523680915334942689489686944619739' - '5671771932928211109385884940274160388152027885130001908095515987519207' - '0999736684156998188051008906908961263450992498366163487027427765593685' - '9100425429873429243031313250686293133985259945096112059116986548403694' - '3294045257801193102728400887526383477970523720630900867795111210451854' - '1943910022441509219345068796407916802976037126180761746949483006999374' - '0978759686051626636971128402883423802272459654052949196565615657433707' - '3988564171171562036245389632730259264953520190321920347601255396137920' - '5004960744433809108410699733605867157750839988421873923607518927486655' - '7931221264782181608667754470203728998338884277790572854074571831492232' - '1086695691823249801139552886748181144717500999021690749662561227798159' - '5669057259461181950677020329313321720883857270121407443621477209221766' - '5620477291042218962146637928766279237237414538331729464697708529187393' - '3547226857758530880168793511465268400187943977613894365634645591604177' - '1307941055525824473856313927886521880529534147811296556714397881515139' - '9630423102435884302310535415733856427000390467373617810950255065071316' - '7258319522545824056524791781105181639237127875356417268878249642171688' - '7440701599858672119414943965662163653929916279628869021987126139820176' - '0323717468282581479798396705403826983300872840734591269962300462346728' - '7738296110774212005294050799218227654983820235796069236099706911525806' - '2449336835486196519253004358469898681389769440068226524625139036242003' - '9818464062787840015948014746206367975185119371949967640249670152897183' - '0054482832320057097082360875809145428036636600549270698504540758319126' - '4528843131551622882014451187089357580330350835559290817560509759740407' - '9371288796443900152598662664392584534384064734475334439420981230953214' - '7589135665638895095150172324875219965305745649692175878476631167339609' - '9840475454582994896502023188861627988410517588530223892194234023860313' - '2439833741142206078606417433789504082052691461532507531344880078976334' - '4707190242881920892579588963376086146960633381215378914452523108903834' - '6077644775805838217128790801949878404507033363716497586163648051845456' - '3655863990980670575714123172889094570528157889176435753086247828461789' - '0886615612608017861029342475376559517893073874528735689724989147963227' - '4425631419161158377408230889200183066228987866656974366941141345660322' - '9841851313464011049791578125601365815762687600730386500793879912191406' - '7544773285391447059337068967640221461662745594510968605338966108977317' - '0819025079418478853311726339866446660021960379624146083534794369969665' - '6589558799302838978265941597115240302951849301902920561178592025563327' - '0560095438637318885230551138363908343081523545591224134467205438637992' - '7838292599192177447132642316496214615358874354105483664080129779732034' - '5998376196783144235089258066243329571959630271516543899405292066020485' - '7279403439598616231631708579334309451829396365207336409446940374623441' - '4204354399890585065717766295337881314543141215045952682586571721903651' - '7827963776340858782671129279361000199965683792378831943838437226016830' - '3662843086203813103771712423574817520332644704407707584630263836497460' - '9747818675439097879402782079463503167624346852711265473405683796971141' - '4343227066374792642341093936686732322730788831376410032394870848824929' - '1932762190879422500980573314510481474989813161818046596342997489244092' - '8514814566352414620792483357605825134889281514592819074387302380653823' - '4169183325091773761733004682495170928781284796749606182084857300689642' - '2220098029186444659696393722864425443174804115295661452095886127784785' - '6563968075365975229375170103953852816687350723683622292483860907656883' - '0060329290573770542403724494674644564017463542907801922997336637841527' - '3692915764515173009646632256826278792193749314522687455317800604524740' - '1192717724803414223640376228411584086935977988007324072142317151762164' - '1411945847039843369863049202314891278837133504794473185092453348658046' - '3894436416946298869397354691924065211837844914014837056117850937923852' - '1353618758950124287794963423898717134633334192953292588280375044683064' - '1637069125232111078330393373072498122041165552312810781302566896048070' - '0236419568269112404054054013255954297124592253625509027169128346186086' - '8798422492339690164920090740593758143962134706615858890258581732863073' - '9346316677127852835935867910766361885290443698115940857515538145285253' - '8538161326799566605463071606829507721627760695695298663348037499346965' - '0805718459832864267285627710579213408091148882752078342762787236700387' - '1325181967811763730779712652433545187567432213566000193850104620664672' - '5087020563845482789165114015140237476770960542212541262365674096922377' - '7499652110550838809518709475884393130875059909689679044529435614443367' - '5453916149790465184295442369033986013692031645502197810582355879318975' - '6025331264642326253916951167641064028719315782248353333706214902160610' - '9878667235417878091883830348608019603396549820674212249210667235195237' - '5956907199316878386819711630803592152534649276798609066509457414729665' - '1701824963729081365854249511700896706324052098265362182297874817162325' - '3728362496820334604531064547592942790115170853526480526862878358269563' - '3185600053065681609425866322423972756799979847593920405275589273199742' - '8948369450364798425229576414764799300949556003266863462364785971588403' - '9930478299196728846850021279521240930771445356446233153424200321868195' - '5510428011088393759497013229783101751112053520581025614111965533611766' - '9459771376005411248881994640753601606805393583940281645304757423903447' - '7517523838763564260482104397515418937631888904037924859646462866909534' - '3292996108797262532957824485454429589907547041190777918188698722057767' - '2224785177419791954783277253421243333498197370278143247403594312138218' - '5922541741970478463020001647359662263940700012043237641649126905417999' - '2757376161643882083502141174389882921013029614925088798649155354722189' - '9402096605456148489590866922112294624680546281250567297009605663936998' - '9393407315397401280080138329410454707229227274190338907510911730213868' - '4746409973371763331630453693044707759986131978826645079078507237753648' - '3225439587367122393671167950836029510856465462738804587713268436992128' - '8921715090716411611658806082243225398909314459090827869912607349024109' - '9386344992962635400112199139864054274742489114079711550949534248667838' - '9565402504229791244504867508301342798992744796454984189142033193018659' - '7441791868082444036883757277715808625924042266965389712327131702051279' - '4186969853117900125063589204304883513744521838295797698972175570686170' - '1366347894376710532041643279157597459032202591566808167568419301491754' - '8219927419439961853681550173346814125007231600113875953631584105604882' - '0399363846661570027616550204979028226341450256816683730141493068826969' - '4553727263733690839349714652132206285243796184219815308355634318194592' - '0228058703876065422973816669054584510542044196087740665161169613290313' - '8833882153569445663791070232842058212444244013999535249470728423090797' - '5581024232726130673375360163257154562557607055131368534412734263401317' - '1609210758029498888911003361882811168844601334240767400019342505754660' - '4292214951962986034421827735199682811654514938317842438481179994614432' - '2536711027462093434842033767504492071349955677051700618860129870409856' - '113128392373584622061075886499407885141951318807519645386474', - 'k': 100000, - 'answer': 7 - } -] +from ....lib.loader import loadTestCases +from .recursive_digit_sum import superDigit + +FILE_PATH = str(Path(__file__).resolve().parent) + +TEST_CASES = loadTestCases( + FILE_PATH + '/recursive_digit_sum.testcases.json') class TestRecursiveDigitSum(unittest.TestCase): @@ -167,6 +17,6 @@ def test_super_digit(self): for _, _tt in enumerate(TEST_CASES): self.assertEqual( - super_digit(_tt['n'], _tt['k']), _tt['answer'], - f"{_} | super_digit({_tt['n']}, {_tt['k']}) must be " - f"=> {_tt['answer']} in {_tt['title']}") + superDigit(_tt['n'], _tt['k']), _tt['expected'], + f"{_} | superDigit({_tt['n']}, {_tt['k']}) must be " + f"=> {_tt['expected']} in {_tt['title']}") diff --git a/src/hackerrank/interview_preparation_kit/search/ctci_ice_cream_parlor.py b/src/hackerrank/interview_preparation_kit/search/ctci_ice_cream_parlor.py index 914dc645..17340276 100644 --- a/src/hackerrank/interview_preparation_kit/search/ctci_ice_cream_parlor.py +++ b/src/hackerrank/interview_preparation_kit/search/ctci_ice_cream_parlor.py @@ -2,7 +2,8 @@ # @link Problem definition [[docs/hackerrank/interview_preparation_kit/search/ctci-ice-cream-parlor.md]] # noqa # pylint: enable=line-too-long -def what_flavors(cost: list[int], money: int) -> list[int] | None: + +def whatFlavors(cost: list[int], money: int) -> list[int] | None: cache = {} diff --git a/src/hackerrank/interview_preparation_kit/search/ctci_ice_cream_parlor_bruteforce.py b/src/hackerrank/interview_preparation_kit/search/ctci_ice_cream_parlor_bruteforce.py index 852e6fed..e7a1d5fa 100644 --- a/src/hackerrank/interview_preparation_kit/search/ctci_ice_cream_parlor_bruteforce.py +++ b/src/hackerrank/interview_preparation_kit/search/ctci_ice_cream_parlor_bruteforce.py @@ -1,4 +1,4 @@ -def what_flavors_brute_force(cost: list[int], money: int) -> list[int] | None: +def whatFlavors(cost: list[int], money: int) -> list[int] | None: for i, price in enumerate(cost): diff --git a/src/hackerrank/interview_preparation_kit/search/ctci_ice_cream_parlor_bruteforce_test.py b/src/hackerrank/interview_preparation_kit/search/ctci_ice_cream_parlor_bruteforce_test.py index 9f3fd1fc..38736bb4 100644 --- a/src/hackerrank/interview_preparation_kit/search/ctci_ice_cream_parlor_bruteforce_test.py +++ b/src/hackerrank/interview_preparation_kit/search/ctci_ice_cream_parlor_bruteforce_test.py @@ -2,41 +2,41 @@ import os from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .ctci_ice_cream_parlor_bruteforce import what_flavors_brute_force +from ....lib.loader import loadTestCases +from .ctci_ice_cream_parlor_bruteforce import whatFlavors BRUTEFORCE = os.getenv('BRUTEFORCE') BRUTEFORCE = BRUTEFORCE.upper() == "TRUE" if BRUTEFORCE is not None else False FILE_PATH = str(Path(__file__).resolve().parent) -TEST_CASES_SMALL_CASES = load_test_cases( +TEST_CASES_SMALL_CASES = loadTestCases( FILE_PATH + '/ctci_ice_cream_parlor.testcases.json') -TEST_CASES_BORDER_CASES = load_test_cases( +TEST_CASES_BORDER_CASES = loadTestCases( FILE_PATH + '/ctci_ice_cream_parlor.border_testcases.json') class TestIceCreamParlorBruteForce(unittest.TestCase): # @unittest.skipIf(not BRUTEFORCE, "skipping due a is a large BRUTEFORCE test") - def test_what_flavors_brute_force(self): + def test_what_flavors(self): for _, testset in enumerate(TEST_CASES_SMALL_CASES): for _, _tt in enumerate(testset['tests']): self.assertEqual( - what_flavors_brute_force(_tt['costs'], _tt['money']), _tt['expected'], - f"{_} | what_flavors_brute_force({_tt['costs']}, {_tt['money']}) " + whatFlavors(_tt['costs'], _tt['money']), _tt['expected'], + f"{_} | whatFlavors({_tt['costs']}, {_tt['money']}) " f"=> must be {_tt['expected']}") - def test_what_flavors_brute_force_border_case(self): + def test_what_flavors_border_case(self): for _, testset in enumerate(TEST_CASES_BORDER_CASES): for _, _tt in enumerate(testset['tests']): self.assertEqual( - what_flavors_brute_force(_tt['costs'], _tt['money']), _tt['expected'], + whatFlavors(_tt['costs'], _tt['money']), _tt['expected'], f"{_} | what_flavors({_tt['costs']}, {_tt['money']}) must be " f"=> {_tt['expected']}") diff --git a/src/hackerrank/interview_preparation_kit/search/ctci_ice_cream_parlor_test.py b/src/hackerrank/interview_preparation_kit/search/ctci_ice_cream_parlor_test.py index 259696dc..226447bf 100644 --- a/src/hackerrank/interview_preparation_kit/search/ctci_ice_cream_parlor_test.py +++ b/src/hackerrank/interview_preparation_kit/search/ctci_ice_cream_parlor_test.py @@ -1,14 +1,14 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .ctci_ice_cream_parlor import what_flavors +from ....lib.loader import loadTestCases +from .ctci_ice_cream_parlor import whatFlavors FILE_PATH = str(Path(__file__).resolve().parent) -TEST_CASES = load_test_cases(FILE_PATH + '/ctci_ice_cream_parlor.testcases.json') -TEST_CASES_BORDER_CASES = load_test_cases( +TEST_CASES = loadTestCases(FILE_PATH + '/ctci_ice_cream_parlor.testcases.json') +TEST_CASES_BORDER_CASES = loadTestCases( FILE_PATH + '/ctci_ice_cream_parlor.border_testcases.json') @@ -21,8 +21,8 @@ def test_what_flavors(self): for _, _tt in enumerate(testset['tests']): self.assertEqual( - what_flavors(_tt['costs'], _tt['money']), _tt['expected'], - f"{_} | what_flavors({_tt['costs']}, {_tt['money']}) must be " + whatFlavors(_tt['costs'], _tt['money']), _tt['expected'], + f"{_} | whatFlavors({_tt['costs']}, {_tt['money']}) must be " f"=> {_tt['expected']}") def test_what_flavors_border_case(self): @@ -32,6 +32,6 @@ def test_what_flavors_border_case(self): for _, _tt in enumerate(testset['tests']): self.assertEqual( - what_flavors(_tt['costs'], _tt['money']), _tt['expected'], - f"{_} | what_flavors({_tt['costs']}, {_tt['money']}) must be " + whatFlavors(_tt['costs'], _tt['money']), _tt['expected'], + f"{_} | whatFlavors({_tt['costs']}, {_tt['money']}) must be " f"=> {_tt['expected']}") diff --git a/src/hackerrank/interview_preparation_kit/search/swap_nodes_algo.py b/src/hackerrank/interview_preparation_kit/search/swap_nodes_algo.py index 272c2c91..f341a968 100644 --- a/src/hackerrank/interview_preparation_kit/search/swap_nodes_algo.py +++ b/src/hackerrank/interview_preparation_kit/search/swap_nodes_algo.py @@ -22,7 +22,7 @@ sys.setrecursionlimit(__HIGH_RECURSION_LIMIT__) -def callback_collect_nodes( +def callbackCollectNodes( root: Node, collect: Dict[int, list[Node]], level: int @@ -33,7 +33,7 @@ def callback_collect_nodes( collect[level].append(root) -def callback_collect_plain( +def callbackCollectPlain( root: Node, collect: Dict[int, list[Node]], level: int @@ -47,7 +47,7 @@ def callback_collect_plain( collect[_level].append(root) -def traverse_in_order_collector( +def traverseInOrderCollector( root: Node, collect: Dict[int, list[Node]], level: int, @@ -55,17 +55,17 @@ def traverse_in_order_collector( ) -> Dict[int, list[Node]]: if root.left is not None: - traverse_in_order_collector(root.left, collect, level + 1, callback) + traverseInOrderCollector(root.left, collect, level + 1, callback) callback(root, collect, level) if root.right is not None: - traverse_in_order_collector(root.right, collect, level + 1, callback) + traverseInOrderCollector(root.right, collect, level + 1, callback) return collect -def build_tree(indexes: List[List[int]]) -> Node: +def buildTree(indexes: List[List[int]]) -> Node: indexes_copy = indexes[:] root: Node = Node(__ROOT_VALUE__) @@ -73,11 +73,11 @@ def build_tree(indexes: List[List[int]]) -> Node: while len(indexes_copy) > 0: node_collector = {} - traverse_in_order_collector( + traverseInOrderCollector( root, node_collector, __INITIAL_LEVEL__, - callback_collect_nodes) + callbackCollectNodes) last_level: int = sorted(list(node_collector))[-1] @@ -93,14 +93,14 @@ def build_tree(indexes: List[List[int]]) -> Node: return root -def flatten_tree(root: Node) -> List[int]: +def flattenTree(root: Node) -> List[int]: node_collector: Dict[int, list[Node]] = {} - node_collector = traverse_in_order_collector( + node_collector = traverseInOrderCollector( root, node_collector, __INITIAL_LEVEL__, - callback_collect_plain + callbackCollectPlain ) output: List[int] = [] @@ -113,7 +113,7 @@ def flatten_tree(root: Node) -> List[int]: return output -def swap_branch(root: Node | None) -> Node | None: +def swapBranch(root: Node | None) -> Node | None: if root is not None: temp: Node | None = root.left root.left = root.right @@ -122,23 +122,23 @@ def swap_branch(root: Node | None) -> Node | None: return root -def swap_nodes(indexes: List[List[int]], queries: List[int]) -> List[List[int]]: - tree: Node = build_tree(indexes) +def swapNodes(indexes: List[List[int]], queries: List[int]) -> List[List[int]]: + tree: Node = buildTree(indexes) plain: List[int] output: List[List[int]] = [] node_collector: Dict[int, list[Node]] = {} - traverse_in_order_collector( + traverseInOrderCollector( tree, node_collector, __INITIAL_LEVEL__, - callback_collect_nodes) + callbackCollectNodes) node_collector = dict(sorted(node_collector.items())) - plain = flatten_tree(tree) # original + plain = flattenTree(tree) # original LOGGER.debug('Plain tree: %s', plain) @@ -146,9 +146,9 @@ def swap_nodes(indexes: List[List[int]], queries: List[int]) -> List[List[int]]: for level, node_list in node_collector.items(): if level % query == 0: for node in node_list: - swap_branch(node) + swapBranch(node) - plain = flatten_tree(tree) + plain = flattenTree(tree) output.append(plain) return output diff --git a/src/hackerrank/interview_preparation_kit/search/swap_nodes_algo_big_test.py b/src/hackerrank/interview_preparation_kit/search/swap_nodes_algo_big_test.py index 184ac6f3..6eb14297 100644 --- a/src/hackerrank/interview_preparation_kit/search/swap_nodes_algo_big_test.py +++ b/src/hackerrank/interview_preparation_kit/search/swap_nodes_algo_big_test.py @@ -1,28 +1,28 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .swap_nodes_algo import swap_nodes, build_tree, flatten_tree +from ....lib.loader import loadTestCases +from .swap_nodes_algo import swapNodes, buildTree, flattenTree FILE_PATH = str(Path(__file__).resolve().parent) -BIG_TEST_CASES = load_test_cases(FILE_PATH + '/swap_nodes_algo.big.testcases.json') +BIG_TEST_CASES = loadTestCases(FILE_PATH + '/swap_nodes_algo.big.testcases.json') class TestSwapNodesAlgoBig(unittest.TestCase): def test_build_tree_and_flatten_big(self): for _, _tt in enumerate(BIG_TEST_CASES): - t_result: list[int] = flatten_tree(build_tree(_tt['nodes'])) + t_result: list[int] = flattenTree(buildTree(_tt['nodes'])) self.assertEqual( t_result, _tt['flattened'], - f"{_} | flatten_tree({_tt['nodes']}) must be {_tt['expected']}") + f"{_} | flattenTree({_tt['nodes']}) must be {_tt['expected']}") def test_swap_nodes_big(self): for _, _tt in enumerate(BIG_TEST_CASES): self.assertEqual( - swap_nodes(_tt['nodes'], _tt['queries']), _tt['expected'], - f"{_} | swap_nodes({_tt['nodes'], _tt['queries']}) must be " + swapNodes(_tt['nodes'], _tt['queries']), _tt['expected'], + f"{_} | swapNodes({_tt['nodes'], _tt['queries']}) must be " f"=> {_tt['expected']}") diff --git a/src/hackerrank/interview_preparation_kit/search/swap_nodes_algo_test.py b/src/hackerrank/interview_preparation_kit/search/swap_nodes_algo_test.py index f4544eee..d78f4b67 100644 --- a/src/hackerrank/interview_preparation_kit/search/swap_nodes_algo_test.py +++ b/src/hackerrank/interview_preparation_kit/search/swap_nodes_algo_test.py @@ -1,11 +1,11 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .swap_nodes_algo import swap_nodes, build_tree, flatten_tree, swap_branch +from ....lib.loader import loadTestCases +from .swap_nodes_algo import swapNodes, swapBranch, buildTree, flattenTree FILE_PATH = str(Path(__file__).resolve().parent) -TEST_CASES = load_test_cases(FILE_PATH + '/swap_nodes_algo.testcases.json') +TEST_CASES = loadTestCases(FILE_PATH + '/swap_nodes_algo.testcases.json') class TestSwapNodesAlgo(unittest.TestCase): @@ -14,20 +14,20 @@ def test_swap_nodes(self): for _, _tt in enumerate(TEST_CASES): self.assertEqual( - swap_nodes(_tt['nodes'], _tt['queries']), _tt['expected'], - f"{_} | swap_nodes({_tt['nodes'], _tt['queries']}) must be " + swapNodes(_tt['nodes'], _tt['queries']), _tt['expected'], + f"{_} | swapNodes({_tt['nodes'], _tt['queries']}) must be " f"=> {_tt['expected']}") def test_swap_branch(self): t_input = None - t_result = swap_branch(t_input) + t_result = swapBranch(t_input) expected = None self.assertEqual( t_result, expected, - f"swap_branch({t_input}) must be " + f"swapBranch({t_input}) must be " f"=> {expected}" ) @@ -35,22 +35,22 @@ def test_build_tree_and_plain(self): for _, _tt in enumerate(TEST_CASES): - t_result: list[int] = flatten_tree(build_tree(_tt['nodes'])) + t_result: list[int] = flattenTree(buildTree(_tt['nodes'])) self.assertEqual( t_result, _tt['flattened'], - f"{_} | flatten_tree({_tt['nodes']}) must be {_tt['expected']}") + f"{_} | flattenTree({_tt['nodes']}) must be {_tt['expected']}") def test_build_tree_empty(self): t_input = [] - t_to_test = build_tree(t_input) - t_result = flatten_tree(t_to_test) + t_to_test = buildTree(t_input) + t_result = flattenTree(t_to_test) expected = [1] self.assertEqual( t_result, expected, - f"build_tree({t_input}) must be " + f"buildTree({t_input}) must be " f"=> {expected}" ) diff --git a/src/hackerrank/interview_preparation_kit/sorting/ctci_bubble_sort.py b/src/hackerrank/interview_preparation_kit/sorting/ctci_bubble_sort.py index d012a362..77d1d2bf 100644 --- a/src/hackerrank/interview_preparation_kit/sorting/ctci_bubble_sort.py +++ b/src/hackerrank/interview_preparation_kit/sorting/ctci_bubble_sort.py @@ -42,7 +42,7 @@ def bubble_sort(self) -> SortableGroup: return self -def count_swaps(group: list[int]) -> str: +def countSwaps(group: list[int]) -> str: sortable_group = SortableGroup(group) sortable_group.bubble_sort() diff --git a/src/hackerrank/interview_preparation_kit/sorting/ctci_bubble_sort_test.py b/src/hackerrank/interview_preparation_kit/sorting/ctci_bubble_sort_test.py index baf05de6..0ef5d972 100644 --- a/src/hackerrank/interview_preparation_kit/sorting/ctci_bubble_sort_test.py +++ b/src/hackerrank/interview_preparation_kit/sorting/ctci_bubble_sort_test.py @@ -1,12 +1,12 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .ctci_bubble_sort import SortableGroup, count_swaps +from ....lib.loader import loadTestCases +from .ctci_bubble_sort import SortableGroup, countSwaps FILE_PATH = str(Path(__file__).resolve().parent) -TEST_CASES = load_test_cases(FILE_PATH + '/ctci_bubble_sort.testcases.json') +TEST_CASES = loadTestCases(FILE_PATH + '/ctci_bubble_sort.testcases.json') class TestBubleSort(unittest.TestCase): @@ -29,6 +29,6 @@ def test_counts(self): expected: str = _tt['expected'].replace('\n', "\n") self.assertEqual( - count_swaps(_tt['input']), expected, - f"{_} | count_swaps({_tt['input']}) must be " + countSwaps(_tt['input']), expected, + f"{_} | countSwaps({_tt['input']}) must be " f"=> {expected}") diff --git a/src/hackerrank/interview_preparation_kit/sorting/ctci_comparator_sorting.py b/src/hackerrank/interview_preparation_kit/sorting/ctci_comparator_sorting.py index 4e6a25bc..de0a6978 100644 --- a/src/hackerrank/interview_preparation_kit/sorting/ctci_comparator_sorting.py +++ b/src/hackerrank/interview_preparation_kit/sorting/ctci_comparator_sorting.py @@ -51,7 +51,7 @@ def comparator(self: Player, b_player: Player) -> int: return 0 -def comparator_sorting(players: List[SortablePlayer]) -> str: +def comparatorSorting(players: List[SortablePlayer]) -> str: players = sorted(players, key=cmp_to_key(SortablePlayer.comparator)) diff --git a/src/hackerrank/interview_preparation_kit/sorting/ctci_comparator_sorting_test.py b/src/hackerrank/interview_preparation_kit/sorting/ctci_comparator_sorting_test.py index 7c596f1c..813afda0 100644 --- a/src/hackerrank/interview_preparation_kit/sorting/ctci_comparator_sorting_test.py +++ b/src/hackerrank/interview_preparation_kit/sorting/ctci_comparator_sorting_test.py @@ -1,12 +1,12 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .ctci_comparator_sorting import Player, SortablePlayer, comparator_sorting +from ....lib.loader import loadTestCases +from .ctci_comparator_sorting import Player, SortablePlayer, comparatorSorting FILE_PATH = str(Path(__file__).resolve().parent) -TEST_CASES = load_test_cases(FILE_PATH + '/ctci_comparator_sorting.testcases.json') +TEST_CASES = loadTestCases(FILE_PATH + '/ctci_comparator_sorting.testcases.json') class TestComparatorSorting(unittest.TestCase): @@ -32,6 +32,6 @@ def test_comparator_sorting(self): players.append(SortablePlayer(player['name'], player['score'])) self.assertEqual( - comparator_sorting(players), _tt['expected'], - f"{_} | comparator_sorting({_tt['input']}) must be " + comparatorSorting(players), _tt['expected'], + f"{_} | comparatorSorting({_tt['input']}) must be " f"=> {_tt['expected']}") diff --git a/src/hackerrank/interview_preparation_kit/sorting/mark_and_toys.py b/src/hackerrank/interview_preparation_kit/sorting/mark_and_toys.py index a5a851fc..ee952b35 100644 --- a/src/hackerrank/interview_preparation_kit/sorting/mark_and_toys.py +++ b/src/hackerrank/interview_preparation_kit/sorting/mark_and_toys.py @@ -1,7 +1,7 @@ # @link Problem definition # [[docs/hackerrank/interview_preparation_kit/sort/mark-and-toys.md]] -def maximum_toys(prices: list[int], k: int): +def maximumToys(prices: list[int], k: int): group = prices[:] group.sort() diff --git a/src/hackerrank/interview_preparation_kit/sorting/mark_and_toys_test.py b/src/hackerrank/interview_preparation_kit/sorting/mark_and_toys_test.py index 2acf7d33..db581665 100644 --- a/src/hackerrank/interview_preparation_kit/sorting/mark_and_toys_test.py +++ b/src/hackerrank/interview_preparation_kit/sorting/mark_and_toys_test.py @@ -1,12 +1,12 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .mark_and_toys import maximum_toys +from ....lib.loader import loadTestCases +from .mark_and_toys import maximumToys FILE_PATH = str(Path(__file__).resolve().parent) -TEST_CASES = load_test_cases(FILE_PATH + '/mark_and_toys.testcases.json') +TEST_CASES = loadTestCases(FILE_PATH + '/mark_and_toys.testcases.json') class TestMarkAndToys(unittest.TestCase): @@ -15,6 +15,6 @@ def test_maximum_toys(self): for _, _tt in enumerate(TEST_CASES): self.assertEqual( - maximum_toys(_tt['prices'], _tt['budget']), _tt['expected'], - f"{_} | maximum_toys({_tt['prices'], _tt['budget']}) must be " + maximumToys(_tt['prices'], _tt['budget']), _tt['expected'], + f"{_} | maximumToys({_tt['prices'], _tt['budget']}) must be " f"=> {_tt['expected']}") diff --git a/src/hackerrank/interview_preparation_kit/stacks_and_queues/balanced_brackets.py b/src/hackerrank/interview_preparation_kit/stacks_and_queues/balanced_brackets.py index fe19dcc6..2608688c 100644 --- a/src/hackerrank/interview_preparation_kit/stacks_and_queues/balanced_brackets.py +++ b/src/hackerrank/interview_preparation_kit/stacks_and_queues/balanced_brackets.py @@ -7,7 +7,7 @@ LOGGER = logging.getLogger(__name__) -def is_balanced(text: str) -> bool: +def isBalanced(text: str) -> bool: pairs = {'{': '}', '(': ')', '[': ']'} brackets = [] diff --git a/src/hackerrank/interview_preparation_kit/stacks_and_queues/balanced_brackets_test.py b/src/hackerrank/interview_preparation_kit/stacks_and_queues/balanced_brackets_test.py index eaec8db6..9e8a568a 100644 --- a/src/hackerrank/interview_preparation_kit/stacks_and_queues/balanced_brackets_test.py +++ b/src/hackerrank/interview_preparation_kit/stacks_and_queues/balanced_brackets_test.py @@ -1,12 +1,12 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .balanced_brackets import is_balanced +from ....lib.loader import loadTestCases +from .balanced_brackets import isBalanced FILE_PATH = str(Path(__file__).resolve().parent) -TEST_CASES = load_test_cases(FILE_PATH + '/balanced_brackets.testcases.json') +TEST_CASES = loadTestCases(FILE_PATH + '/balanced_brackets.testcases.json') class TestBalancedBrackets(unittest.TestCase): @@ -18,6 +18,6 @@ def test_is_balanced(self): for _, _tt in enumerate(testset['tests']): self.assertEqual( - is_balanced(_tt['input']), _tt['answer'], - f"{_} | is_balanced({_tt['input']}) must be " + isBalanced(_tt['input']), _tt['answer'], + f"{_} | isBalanced({_tt['input']}) must be " f"=> {_tt['answer']}") diff --git a/src/hackerrank/interview_preparation_kit/string_manipulation/alternating_characters.py b/src/hackerrank/interview_preparation_kit/string_manipulation/alternating_characters.py index 2a05b799..b9176589 100644 --- a/src/hackerrank/interview_preparation_kit/string_manipulation/alternating_characters.py +++ b/src/hackerrank/interview_preparation_kit/string_manipulation/alternating_characters.py @@ -2,7 +2,7 @@ # @link Problem definition [[docs/hackerrank/interview_preparation_kit/string_manipulation/alternating-characters.md]] # noqa # pylint: enable=line-too-long -def alternating_characters(word: str) -> int: +def alternatingCharacters(word: str) -> int: last: str = '' new_string: str = '' diff --git a/src/hackerrank/interview_preparation_kit/string_manipulation/alternating_characters_test.py b/src/hackerrank/interview_preparation_kit/string_manipulation/alternating_characters_test.py index 5e58fe50..d4a8cbb3 100644 --- a/src/hackerrank/interview_preparation_kit/string_manipulation/alternating_characters_test.py +++ b/src/hackerrank/interview_preparation_kit/string_manipulation/alternating_characters_test.py @@ -1,12 +1,12 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .alternating_characters import alternating_characters +from ....lib.loader import loadTestCases +from .alternating_characters import alternatingCharacters FILE_PATH = str(Path(__file__).resolve().parent) -TEST_CASES = load_test_cases(FILE_PATH + '/alternating_characters.testcases.json') +TEST_CASES = loadTestCases(FILE_PATH + '/alternating_characters.testcases.json') class TestAlternatingCharacters(unittest.TestCase): @@ -18,6 +18,6 @@ def test_alternating_characters(self): for _, _tt in enumerate(testset['tests']): self.assertEqual( - alternating_characters(_tt['input']), _tt['expected'], - f"{_} | alternating_characters({_tt['input']}) must be " + alternatingCharacters(_tt['input']), _tt['expected'], + f"{_} | alternatingCharacters({_tt['input']}) must be " f"=> {_tt['expected']}") diff --git a/src/hackerrank/interview_preparation_kit/string_manipulation/ctci_making_anagrams.py b/src/hackerrank/interview_preparation_kit/string_manipulation/ctci_making_anagrams.py index 14954a84..cda4b8b6 100644 --- a/src/hackerrank/interview_preparation_kit/string_manipulation/ctci_making_anagrams.py +++ b/src/hackerrank/interview_preparation_kit/string_manipulation/ctci_making_anagrams.py @@ -7,16 +7,16 @@ LOGGER = logging.getLogger(__name__) -def char_to_dict(word: str) -> dict: +def charToDict(word: str) -> dict: word_map = {char: (word.count(char)) for char in ''.join(sorted(word[:]))} return word_map -def make_anagram(word_a: str, word_b: str) -> int: +def makeAnagram(word_a: str, word_b: str) -> int: - a_map = char_to_dict(word_a) - b_map = char_to_dict(word_b) + a_map = charToDict(word_a) + b_map = charToDict(word_b) diff = 0 for key in a_map: diff --git a/src/hackerrank/interview_preparation_kit/string_manipulation/ctci_making_anagrams_test.py b/src/hackerrank/interview_preparation_kit/string_manipulation/ctci_making_anagrams_test.py index d81eeccd..b9cba35b 100644 --- a/src/hackerrank/interview_preparation_kit/string_manipulation/ctci_making_anagrams_test.py +++ b/src/hackerrank/interview_preparation_kit/string_manipulation/ctci_making_anagrams_test.py @@ -1,12 +1,12 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .ctci_making_anagrams import make_anagram +from ....lib.loader import loadTestCases +from .ctci_making_anagrams import makeAnagram FILE_PATH = str(Path(__file__).resolve().parent) -TEST_CASES = load_test_cases(FILE_PATH + '/ctci_making_anagrams.testcases.json') +TEST_CASES = loadTestCases(FILE_PATH + '/ctci_making_anagrams.testcases.json') class TestMakeAnagram(unittest.TestCase): @@ -16,6 +16,6 @@ def test_make_anagram(self): for _, _tt in enumerate(TEST_CASES): self.assertEqual( - make_anagram(_tt['a'], _tt['b']), _tt['expected'], - f"{_} | make_anagram({_tt['a']}, {_tt['b']}) must be " + makeAnagram(_tt['a'], _tt['b']), _tt['expected'], + f"{_} | makeAnagram({_tt['a']}, {_tt['b']}) must be " f"=> {_tt['expected']}") diff --git a/src/hackerrank/interview_preparation_kit/string_manipulation/sherlock_and_valid_string.py b/src/hackerrank/interview_preparation_kit/string_manipulation/sherlock_and_valid_string.py index 5187b3f8..4776d484 100644 --- a/src/hackerrank/interview_preparation_kit/string_manipulation/sherlock_and_valid_string.py +++ b/src/hackerrank/interview_preparation_kit/string_manipulation/sherlock_and_valid_string.py @@ -5,7 +5,7 @@ from collections import Counter -def is_valid(word: str) -> bool: +def isValid(word: str) -> bool: if len(word) <= 1: return True diff --git a/src/hackerrank/interview_preparation_kit/string_manipulation/sherlock_and_valid_string_test.py b/src/hackerrank/interview_preparation_kit/string_manipulation/sherlock_and_valid_string_test.py index 3afd0888..144c9525 100644 --- a/src/hackerrank/interview_preparation_kit/string_manipulation/sherlock_and_valid_string_test.py +++ b/src/hackerrank/interview_preparation_kit/string_manipulation/sherlock_and_valid_string_test.py @@ -1,12 +1,12 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases -from .sherlock_and_valid_string import is_valid +from ....lib.loader import loadTestCases +from .sherlock_and_valid_string import isValid FILE_PATH = str(Path(__file__).resolve().parent) -TEST_CASES = load_test_cases(FILE_PATH + '/sherlock_and_valid_string.testcases.json') +TEST_CASES = loadTestCases(FILE_PATH + '/sherlock_and_valid_string.testcases.json') class TestSherklockAndValidString(unittest.TestCase): @@ -16,6 +16,6 @@ def test_is_valid(self): for _, _tt in enumerate(TEST_CASES): self.assertEqual( - is_valid(_tt['input']), _tt['expected'], - f"{_} | is_valid({_tt['input']}) must be " + isValid(_tt['input']), _tt['expected'], + f"{_} | isValid({_tt['input']}) must be " f"=> {_tt['expected']}") diff --git a/src/hackerrank/interview_preparation_kit/trees/binary_search_tree_lowest_common_ancestor_test.py b/src/hackerrank/interview_preparation_kit/trees/binary_search_tree_lowest_common_ancestor_test.py index 5cade71e..2113055a 100644 --- a/src/hackerrank/interview_preparation_kit/trees/binary_search_tree_lowest_common_ancestor_test.py +++ b/src/hackerrank/interview_preparation_kit/trees/binary_search_tree_lowest_common_ancestor_test.py @@ -1,13 +1,13 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases +from ....lib.loader import loadTestCases from ...lib.tree import BinarySearchTree from .binary_search_tree_lowest_common_ancestor import lca, find FILE_PATH = str(Path(__file__).resolve().parent) -TEST_CASES = load_test_cases( +TEST_CASES = loadTestCases( FILE_PATH + '/binary_search_tree_lowest_common_ancestor.testcases.json') diff --git a/src/hackerrank/interview_preparation_kit/trees/ctci_is_binary_search_tree.py b/src/hackerrank/interview_preparation_kit/trees/ctci_is_binary_search_tree.py index ffb709bc..9a8f9a28 100644 --- a/src/hackerrank/interview_preparation_kit/trees/ctci_is_binary_search_tree.py +++ b/src/hackerrank/interview_preparation_kit/trees/ctci_is_binary_search_tree.py @@ -5,18 +5,18 @@ from ...lib.node import Node -def traverse_bst(root: Node | None, collect: list[int]) -> list[int] | None: +def traverseBST(root: Node | None, collect: list[int]) -> list[int] | None: if root is not None: - traverse_bst(root.left, collect) + traverseBST(root.left, collect) collect.append(root.data) - traverse_bst(root.right, collect) + traverseBST(root.right, collect) -def check_bst(root: Node | None) -> bool: +def checkBST(root: Node | None) -> bool: plaint_tree = [] - traverse_bst(root, plaint_tree) + traverseBST(root, plaint_tree) print(plaint_tree) result = True diff --git a/src/hackerrank/interview_preparation_kit/trees/ctci_is_binary_search_tree_test.py b/src/hackerrank/interview_preparation_kit/trees/ctci_is_binary_search_tree_test.py index b5d11dd2..a81c0acb 100644 --- a/src/hackerrank/interview_preparation_kit/trees/ctci_is_binary_search_tree_test.py +++ b/src/hackerrank/interview_preparation_kit/trees/ctci_is_binary_search_tree_test.py @@ -1,6 +1,6 @@ import unittest from ...lib.node import Node -from .ctci_is_binary_search_tree import check_bst +from .ctci_is_binary_search_tree import checkBST class TestIsBinarySearchTree(unittest.TestCase): @@ -11,8 +11,8 @@ def test_check_bst_edge_case(self): answer = True self.assertTrue( - check_bst(root), - f"check_bst({root}) must be " + checkBST(root), + f"checkBST({root}) must be " f"=> {answer}" ) @@ -35,8 +35,8 @@ def test_check_bst_test_example(self): answer = False self.assertFalse( - check_bst(root), - f"check_bst({root}) must be " + checkBST(root), + f"checkBST({root}) must be " f"=> {answer}" ) @@ -60,8 +60,8 @@ def test_check_bst_test_case_0(self): answer = True self.assertTrue( - check_bst(root), - f"check_bst({root}) must be " + checkBST(root), + f"checkBST({root}) must be " f"=> {answer}" ) @@ -85,8 +85,8 @@ def test_check_bst_test_case_1(self): answer = False self.assertFalse( - check_bst(root), - f"check_bst({root}) must be " + checkBST(root), + f"checkBST({root}) must be " f"=> {answer}" ) @@ -110,7 +110,7 @@ def test_check_bst_test_case_2(self): answer = True self.assertTrue( - check_bst(root), - f"check_bst({root}) must be " + checkBST(root), + f"checkBST({root}) must be " f"=> {answer}" ) diff --git a/src/hackerrank/interview_preparation_kit/trees/tree_height_of_a_binary_tree_test.py b/src/hackerrank/interview_preparation_kit/trees/tree_height_of_a_binary_tree_test.py index 36f56184..eaf5de56 100644 --- a/src/hackerrank/interview_preparation_kit/trees/tree_height_of_a_binary_tree_test.py +++ b/src/hackerrank/interview_preparation_kit/trees/tree_height_of_a_binary_tree_test.py @@ -1,13 +1,13 @@ import unittest from pathlib import Path -from ....hackerrank.lib.loader import load_test_cases +from ....lib.loader import loadTestCases from ...lib.tree import BinarySearchTree from .tree_height_of_a_binary_tree import height FILE_PATH = str(Path(__file__).resolve().parent) -TEST_CASES = load_test_cases( +TEST_CASES = loadTestCases( FILE_PATH + '/tree_height_of_a_binary_tree.testcases.json') diff --git a/src/hackerrank/projecteuler/euler001.py b/src/hackerrank/projecteuler/euler001.py index 8520a570..89ae3188 100644 --- a/src/hackerrank/projecteuler/euler001.py +++ b/src/hackerrank/projecteuler/euler001.py @@ -5,7 +5,7 @@ # Function to find sum of Arithmetic Progression series -def sum_of_arithmetic_progression(n: int, d: int) -> int: +def sumOfArithmeticProgression(n: int, d: int) -> int: # Number of terms n = n // d @@ -20,6 +20,6 @@ def euler001(a: int, b: int, n: int) -> int: n = n - 1 lcm = (a * b) // math.gcd(a, b) - return sum_of_arithmetic_progression(n, a) + \ - sum_of_arithmetic_progression(n, b) - \ - sum_of_arithmetic_progression(n, lcm) + return sumOfArithmeticProgression(n, a) + \ + sumOfArithmeticProgression(n, b) - \ + sumOfArithmeticProgression(n, lcm) diff --git a/src/hackerrank/projecteuler/euler002.py b/src/hackerrank/projecteuler/euler002.py index 16ccfc51..4fbb9833 100644 --- a/src/hackerrank/projecteuler/euler002.py +++ b/src/hackerrank/projecteuler/euler002.py @@ -1,7 +1,7 @@ # @link Problem definition [[docs/hackerrank/projecteuler/euler002.md]] # pylint: disable=C0103:invalid-name -def fibo_even_sum(n: int) -> int: +def fiboEvenSum(n: int) -> int: total = 0 fibo = 0 fibo1 = 1 @@ -20,4 +20,4 @@ def fibo_even_sum(n: int) -> int: def euler002(n: int) -> int: - return fibo_even_sum(n) + return fiboEvenSum(n) diff --git a/src/hackerrank/projecteuler/euler003.py b/src/hackerrank/projecteuler/euler003.py index 8f231c67..37435646 100644 --- a/src/hackerrank/projecteuler/euler003.py +++ b/src/hackerrank/projecteuler/euler003.py @@ -6,7 +6,7 @@ import math -def prime_factor(n: int) -> 'int | None': +def primeFactor(n: int) -> 'int | None': if n < 2: return None @@ -30,4 +30,4 @@ def prime_factor(n: int) -> 'int | None': def euler003(n: int) -> 'int | None': - return prime_factor(n) + return primeFactor(n) diff --git a/src/hackerrank/warmup/a_very_big_sum.py b/src/hackerrank/warmup/a_very_big_sum.py index 43860a18..c27726c9 100644 --- a/src/hackerrank/warmup/a_very_big_sum.py +++ b/src/hackerrank/warmup/a_very_big_sum.py @@ -5,7 +5,7 @@ LOGGER = logging.getLogger(__name__) -def a_very_big_sum(_input: list[int]) -> int: +def aVeryBigSum(_input: list[int]) -> int: result: int = 0 for i in _input: diff --git a/src/hackerrank/warmup/a_very_big_sum_test.py b/src/hackerrank/warmup/a_very_big_sum_test.py index c61f925a..613a52e9 100755 --- a/src/hackerrank/warmup/a_very_big_sum_test.py +++ b/src/hackerrank/warmup/a_very_big_sum_test.py @@ -1,5 +1,5 @@ import unittest -from .a_very_big_sum import a_very_big_sum +from .a_very_big_sum import aVeryBigSum class TestaVeryBigSum(unittest.TestCase): @@ -16,6 +16,6 @@ def test_a_very_big_sum(self): for _, _tt in enumerate(tests): self.assertEqual( - a_very_big_sum(_tt['input']), _tt['answer'], - f"{_} | a_very_big_sum({_tt['input']}) must be " + aVeryBigSum(_tt['input']), _tt['answer'], + f"{_} | aVeryBigSum({_tt['input']}) must be " f"=> {_tt['answer']}") diff --git a/src/hackerrank/warmup/birthday_cake_candles.py b/src/hackerrank/warmup/birthday_cake_candles.py index 8753a3da..a2392be8 100644 --- a/src/hackerrank/warmup/birthday_cake_candles.py +++ b/src/hackerrank/warmup/birthday_cake_candles.py @@ -5,7 +5,7 @@ LOGGER = logging.getLogger(__name__) -def birthday_cake_candles(_ar: list[int]) -> int: +def birthdayCakeCandles(_ar: list[int]) -> int: if len(_ar) == 0: raise ValueError('Empty input') diff --git a/src/hackerrank/warmup/birthday_cake_candles_test.py b/src/hackerrank/warmup/birthday_cake_candles_test.py index 20c984b6..90284918 100755 --- a/src/hackerrank/warmup/birthday_cake_candles_test.py +++ b/src/hackerrank/warmup/birthday_cake_candles_test.py @@ -1,6 +1,6 @@ import unittest import pytest -from .birthday_cake_candles import birthday_cake_candles +from .birthday_cake_candles import birthdayCakeCandles class TestBirthdayCakeCandles(unittest.TestCase): @@ -15,11 +15,11 @@ def test_birthday_cake_candles(self): for _, _tt in enumerate(tests): self.assertEqual( - birthday_cake_candles(_tt['input']), _tt['answer'], - f"{_} | birthday_cake_candles({_tt['input']}) must be " + birthdayCakeCandles(_tt['input']), _tt['answer'], + f"{_} | birthdayCakeCandles({_tt['input']}) must be " f"=> {_tt['answer']}") def test_birthday_cake_candles_wrong_input(self): with pytest.raises(Exception): - birthday_cake_candles([]) + birthdayCakeCandles([]) diff --git a/src/hackerrank/warmup/compare_triplets.py b/src/hackerrank/warmup/compare_triplets.py index e7cbaba6..694ff5a1 100644 --- a/src/hackerrank/warmup/compare_triplets.py +++ b/src/hackerrank/warmup/compare_triplets.py @@ -5,7 +5,7 @@ LOGGER = logging.getLogger(__name__) -def compare_triplets(_a: list[int], _b: list[int]) -> list[int]: +def compareTriplets(_a: list[int], _b: list[int]) -> list[int]: if len(_a) == 0 or len(_b) == 0 or len(_a) != len(_b): raise ValueError('Empty input') diff --git a/src/hackerrank/warmup/compare_triplets_test.py b/src/hackerrank/warmup/compare_triplets_test.py index 827a5776..f95f915c 100755 --- a/src/hackerrank/warmup/compare_triplets_test.py +++ b/src/hackerrank/warmup/compare_triplets_test.py @@ -1,6 +1,6 @@ import unittest import pytest -from .compare_triplets import compare_triplets +from .compare_triplets import compareTriplets class TestCompareTriplets(unittest.TestCase): @@ -11,13 +11,13 @@ def test_compare_triplets_wrong_data(self): _b = [2, 3] with pytest.raises(Exception): - compare_triplets(_a, _b) + compareTriplets(_a, _b) with pytest.raises(Exception): - compare_triplets([], _b) + compareTriplets([], _b) with pytest.raises(Exception): - compare_triplets(_a, []) + compareTriplets(_a, []) def test_compare_triplets_test_case0(self): @@ -28,6 +28,6 @@ def test_compare_triplets_test_case0(self): for _, _tt in enumerate(tests): self.assertEqual( - compare_triplets(_tt['a'], _tt['b']), _tt['answer'], - f"{_} | birthday_cake_candles({_tt['a']}, {_tt['b']}) must be " + compareTriplets(_tt['a'], _tt['b']), _tt['answer'], + f"{_} | compareTriplets({_tt['a']}, {_tt['b']}) must be " f"=> {_tt['answer']}") diff --git a/src/hackerrank/warmup/diagonal_difference.py b/src/hackerrank/warmup/diagonal_difference.py index d908e975..049b910c 100644 --- a/src/hackerrank/warmup/diagonal_difference.py +++ b/src/hackerrank/warmup/diagonal_difference.py @@ -5,7 +5,7 @@ LOGGER = logging.getLogger(__name__) -def diagonal_difference(arr: list[list[int]]) -> int: +def diagonalDifference(arr: list[list[int]]) -> int: diag1 = 0 diag2 = 0 last = len(arr) - 1 diff --git a/src/hackerrank/warmup/diagonal_difference_test.py b/src/hackerrank/warmup/diagonal_difference_test.py index a767af51..b18ff43c 100755 --- a/src/hackerrank/warmup/diagonal_difference_test.py +++ b/src/hackerrank/warmup/diagonal_difference_test.py @@ -1,5 +1,5 @@ import unittest -from .diagonal_difference import diagonal_difference +from .diagonal_difference import diagonalDifference class TestdiagonalDifference(unittest.TestCase): @@ -15,6 +15,6 @@ def test_diagonal_difference(self): answer = 15 self.assertEqual( - diagonal_difference(matrix), answer, + diagonalDifference(matrix), answer, f"diagonalDifference({matrix}) must be " f"=> {answer}") diff --git a/src/hackerrank/warmup/mini_max_sum.py b/src/hackerrank/warmup/mini_max_sum.py index 7299cc6b..c38d8954 100644 --- a/src/hackerrank/warmup/mini_max_sum.py +++ b/src/hackerrank/warmup/mini_max_sum.py @@ -5,7 +5,7 @@ LOGGER = logging.getLogger(__name__) -def mini_max_sum(arr: list[int]) -> str: +def miniMaxSum(arr: list[int]) -> str: if len(arr) == 0: raise ValueError('Empty input') diff --git a/src/hackerrank/warmup/mini_max_sum_test.py b/src/hackerrank/warmup/mini_max_sum_test.py index 54251d16..aa151a14 100755 --- a/src/hackerrank/warmup/mini_max_sum_test.py +++ b/src/hackerrank/warmup/mini_max_sum_test.py @@ -1,6 +1,6 @@ import unittest import pytest -from .mini_max_sum import mini_max_sum +from .mini_max_sum import miniMaxSum class TestMiniMaxSum(unittest.TestCase): @@ -8,7 +8,7 @@ class TestMiniMaxSum(unittest.TestCase): def test_mini_max_sum_wrong_data(self): with pytest.raises(Exception): - mini_max_sum([]) + miniMaxSum([]) def test_mini_max_sum(self): @@ -20,6 +20,6 @@ def test_mini_max_sum(self): for _, _tt in enumerate(tests): self.assertEqual( - mini_max_sum(_tt['input']), _tt['answer'], + miniMaxSum(_tt['input']), _tt['answer'], f"{_} | miniMaxSum({_tt['input']}) must be " f"=> {_tt['answer']}") diff --git a/src/hackerrank/warmup/plus_minus.py b/src/hackerrank/warmup/plus_minus.py index ae85227d..e38df445 100644 --- a/src/hackerrank/warmup/plus_minus.py +++ b/src/hackerrank/warmup/plus_minus.py @@ -5,7 +5,7 @@ LOGGER = logging.getLogger(__name__) -def plus_minus(arr: list[int]) -> str: +def plusMinus(arr: list[int]) -> str: positives: int = 0 negatives: int = 0 zeros: int = 0 @@ -26,5 +26,5 @@ def plus_minus(arr: list[int]) -> str: output: str = '\n'.join(result) - LOGGER.info('Problem 0000 result: %s', output) + LOGGER.info('plusMinus result: %s', output) return output diff --git a/src/hackerrank/warmup/plus_minus_test.py b/src/hackerrank/warmup/plus_minus_test.py index 5c30fd76..ba5f935e 100755 --- a/src/hackerrank/warmup/plus_minus_test.py +++ b/src/hackerrank/warmup/plus_minus_test.py @@ -1,5 +1,5 @@ import unittest -from .plus_minus import plus_minus +from .plus_minus import plusMinus class TestPlusMinus(unittest.TestCase): @@ -16,6 +16,6 @@ def test_plus_minus(self): for _, _tt in enumerate(tests): self.assertEqual( - plus_minus(_tt['input']), _tt['answer'], - f"{_} | plus_minus({_tt['input']}) must be " + plusMinus(_tt['input']), _tt['answer'], + f"{_} | plusMinus({_tt['input']}) must be " f"=> {_tt['answer']}") diff --git a/src/hackerrank/warmup/simple_array_sum.py b/src/hackerrank/warmup/simple_array_sum.py index ebe6722d..0aa12cbe 100644 --- a/src/hackerrank/warmup/simple_array_sum.py +++ b/src/hackerrank/warmup/simple_array_sum.py @@ -5,7 +5,7 @@ LOGGER = logging.getLogger(__name__) -def simple_array_sum(arr: list[int]) -> int: +def simpleArraySum(arr: list[int]) -> int: acum = 0 for _, value in enumerate(arr): diff --git a/src/hackerrank/warmup/simple_array_sum_test.py b/src/hackerrank/warmup/simple_array_sum_test.py index 01493fa0..1d7a934c 100755 --- a/src/hackerrank/warmup/simple_array_sum_test.py +++ b/src/hackerrank/warmup/simple_array_sum_test.py @@ -1,5 +1,5 @@ import unittest -from .simple_array_sum import simple_array_sum +from .simple_array_sum import simpleArraySum class TestSimpleArraySum(unittest.TestCase): @@ -13,6 +13,6 @@ def test_simple_array_sum(self): for _, _tt in enumerate(tests): self.assertEqual( - simple_array_sum(_tt['input']), _tt['answer'], - f"{_} | simple_array_sum({_tt['input']}) must be " + simpleArraySum(_tt['input']), _tt['answer'], + f"{_} | simpleArraySum({_tt['input']}) must be " f"=> {_tt['answer']}") diff --git a/src/hackerrank/warmup/solve_me_first.py b/src/hackerrank/warmup/solve_me_first.py index e2303ec8..82e92f5a 100644 --- a/src/hackerrank/warmup/solve_me_first.py +++ b/src/hackerrank/warmup/solve_me_first.py @@ -5,7 +5,7 @@ LOGGER = logging.getLogger(__name__) -def solve_me_first(_a: int, _b: int) -> int: +def solveMeFirst(_a: int, _b: int) -> int: result = _a + _b LOGGER.info('Solve Me First result: %i', result) diff --git a/src/hackerrank/warmup/solve_me_first_test.py b/src/hackerrank/warmup/solve_me_first_test.py index e35467b1..b033d909 100644 --- a/src/hackerrank/warmup/solve_me_first_test.py +++ b/src/hackerrank/warmup/solve_me_first_test.py @@ -1,5 +1,5 @@ import unittest -from .solve_me_first import solve_me_first +from .solve_me_first import solveMeFirst class TestSolveMeFirst(unittest.TestCase): @@ -13,6 +13,6 @@ def test_solve_me_first(self): for _, _tt in enumerate(tests): self.assertEqual( - solve_me_first(_tt['a'], _tt['b']), _tt['answer'], - f"{_} | solve_me_first({_tt['a'], _tt['b']}) must be " + solveMeFirst(_tt['a'], _tt['b']), _tt['answer'], + f"{_} | solveMeFirst({_tt['a'], _tt['b']}) must be " f"=> {_tt['answer']}") diff --git a/src/hackerrank/warmup/time_conversion.py b/src/hackerrank/warmup/time_conversion.py index 3d006847..46c4f40c 100644 --- a/src/hackerrank/warmup/time_conversion.py +++ b/src/hackerrank/warmup/time_conversion.py @@ -5,7 +5,7 @@ LOGGER = logging.getLogger(__name__) -def time_conversion(_s: str) -> str: +def timeConversion(_s: str) -> str: meridian = _s[-2:] meridian = meridian.lower() diff --git a/src/hackerrank/warmup/time_conversion_test.py b/src/hackerrank/warmup/time_conversion_test.py index 654fa819..5d93f1cf 100755 --- a/src/hackerrank/warmup/time_conversion_test.py +++ b/src/hackerrank/warmup/time_conversion_test.py @@ -1,5 +1,5 @@ import unittest -from .time_conversion import time_conversion +from .time_conversion import timeConversion class TestTimeConversion(unittest.TestCase): @@ -14,8 +14,8 @@ def test_time_conversion_example(self): for _, _tt in enumerate(tests): self.assertEqual( - time_conversion(_tt['input']), _tt['answer'], - f"{_} | time_conversion_({input}) must be " + timeConversion(_tt['input']), _tt['answer'], + f"{_} | timeConversion({input}) must be " f"=> {_tt['answer']}") def test_time_conversion_case_0(self): @@ -24,6 +24,6 @@ def test_time_conversion_case_0(self): solution_found = '19:05:45' self.assertEqual( - time_conversion(tinput), solution_found, - f"problem0000({input}) must be " + timeConversion(tinput), solution_found, + f"timeConversion({input}) must be " f"=> {solution_found}") diff --git a/src/hackerrank/lib/loader.py b/src/lib/loader.py similarity index 75% rename from src/hackerrank/lib/loader.py rename to src/lib/loader.py index ac5943e4..f5356ccc 100644 --- a/src/hackerrank/lib/loader.py +++ b/src/lib/loader.py @@ -1,7 +1,7 @@ import json -def load_test_cases(filename: str): +def loadTestCases(filename: str): with open(filename, encoding="utf-8" ) as file: return json.load(file) diff --git a/src/projecteuler/helpers/number_to_word.py b/src/projecteuler/helpers/number_to_word.py index 915dbce8..e639dbcb 100644 --- a/src/projecteuler/helpers/number_to_word.py +++ b/src/projecteuler/helpers/number_to_word.py @@ -37,7 +37,7 @@ } -def number_to_word(value: int) -> str: +def numberToWord(value: int) -> str: big_value = str(value) # 1 to 19 @@ -61,7 +61,7 @@ def number_to_word(value: int) -> str: if rest == 0: return f'{dictionary[big_value[0]]} {_CENTS_}' - return f'{dictionary[big_value[0]]} {_CENTS_} and {number_to_word(rest)}' + return f'{dictionary[big_value[0]]} {_CENTS_} and {numberToWord(rest)}' # up to 1000 if value == 1000: diff --git a/src/projecteuler/helpers/number_to_word_test.py b/src/projecteuler/helpers/number_to_word_test.py index cd6c0126..c31b7134 100644 --- a/src/projecteuler/helpers/number_to_word_test.py +++ b/src/projecteuler/helpers/number_to_word_test.py @@ -1,27 +1,27 @@ import unittest -from .number_to_word import number_to_word +from .number_to_word import numberToWord class TestNumberToWord(unittest.TestCase): def test_number_to_word_up_to_two_digits(self): - self.assertEqual(number_to_word(1), 'one') - self.assertEqual(number_to_word(16), 'sixteen') - self.assertEqual(number_to_word(20), 'twenty') - self.assertEqual(number_to_word(30), 'thirty') - self.assertEqual(number_to_word(64), 'sixty-four') + self.assertEqual(numberToWord(1), 'one') + self.assertEqual(numberToWord(16), 'sixteen') + self.assertEqual(numberToWord(20), 'twenty') + self.assertEqual(numberToWord(30), 'thirty') + self.assertEqual(numberToWord(64), 'sixty-four') def test_number_to_word_up_to_three_digit(self): - self.assertEqual(number_to_word(301), 'three hundred and one') - self.assertEqual(number_to_word(348), 'three hundred and forty-eight') - self.assertEqual(number_to_word(500), 'five hundred') + self.assertEqual(numberToWord(301), 'three hundred and one') + self.assertEqual(numberToWord(348), 'three hundred and forty-eight') + self.assertEqual(numberToWord(500), 'five hundred') def test_number_to_word_border_cases(self): - self.assertEqual(number_to_word(1000), 'one thousand') + self.assertEqual(numberToWord(1000), 'one thousand') self.assertRaisesRegex(AttributeError, 'Invalid value', - number_to_word, 9999) + numberToWord, 9999) diff --git a/src/projecteuler/helpers/palindrome.py b/src/projecteuler/helpers/palindrome.py index b72dc59a..789ec9c7 100644 --- a/src/projecteuler/helpers/palindrome.py +++ b/src/projecteuler/helpers/palindrome.py @@ -1,5 +1,5 @@ -def is_palindrome(num): +def isPalindrome(num): digits = str(num) reversed_num = "".join(reversed(digits)) diff --git a/src/projecteuler/helpers/palindrome_test.py b/src/projecteuler/helpers/palindrome_test.py index 0bdf599e..c17f7426 100644 --- a/src/projecteuler/helpers/palindrome_test.py +++ b/src/projecteuler/helpers/palindrome_test.py @@ -1,19 +1,19 @@ import unittest -from .palindrome import is_palindrome +from .palindrome import isPalindrome class TestPalindromes(unittest.TestCase): def test_is_palindrome(self): - self.assertTrue(is_palindrome(0)) - self.assertTrue(is_palindrome(7)) - self.assertTrue(is_palindrome(101)) - self.assertTrue(is_palindrome(9889)) + self.assertTrue(isPalindrome(0)) + self.assertTrue(isPalindrome(7)) + self.assertTrue(isPalindrome(101)) + self.assertTrue(isPalindrome(9889)) def test_is_not_palindrome(self): - self.assertFalse(is_palindrome(13), False) - self.assertFalse(is_palindrome(29), False) - self.assertFalse(is_palindrome(123), False) - self.assertFalse(is_palindrome(534), False) + self.assertFalse(isPalindrome(13), False) + self.assertFalse(isPalindrome(29), False) + self.assertFalse(isPalindrome(123), False) + self.assertFalse(isPalindrome(534), False) diff --git a/src/projecteuler/helpers/prime.py b/src/projecteuler/helpers/prime.py index fb3df201..be1bc8f5 100644 --- a/src/projecteuler/helpers/prime.py +++ b/src/projecteuler/helpers/prime.py @@ -1,4 +1,4 @@ -def is_prime(num): +def isPrime(num): if num in (0, 1): return False diff --git a/src/projecteuler/helpers/prime_test.py b/src/projecteuler/helpers/prime_test.py index f4b71a7f..fe2c290b 100644 --- a/src/projecteuler/helpers/prime_test.py +++ b/src/projecteuler/helpers/prime_test.py @@ -1,19 +1,19 @@ import unittest -from .prime import is_prime +from .prime import isPrime class TestPrimes(unittest.TestCase): def test_(self): - self.assertFalse(is_prime(1)) - self.assertTrue(is_prime(2)) - self.assertTrue(is_prime(7)) - self.assertTrue(is_prime(13)) + self.assertFalse(isPrime(1)) + self.assertTrue(isPrime(2)) + self.assertTrue(isPrime(7)) + self.assertTrue(isPrime(13)) def test_not_prime(self): - self.assertFalse(is_prime(4)) - self.assertFalse(is_prime(10)) - self.assertFalse(is_prime(100)) - self.assertFalse(is_prime(3000)) + self.assertFalse(isPrime(4)) + self.assertFalse(isPrime(10)) + self.assertFalse(isPrime(100)) + self.assertFalse(isPrime(3000)) diff --git a/src/projecteuler/helpers/word_score.py b/src/projecteuler/helpers/word_score.py index 38ca3622..b8b5aece 100644 --- a/src/projecteuler/helpers/word_score.py +++ b/src/projecteuler/helpers/word_score.py @@ -28,7 +28,7 @@ } -def word_score(word: str) -> int: +def wordScore(word: str) -> int: result = 0 for letter in list(word): diff --git a/src/projecteuler/helpers/word_score_test.py b/src/projecteuler/helpers/word_score_test.py index bada4927..12b7dd25 100644 --- a/src/projecteuler/helpers/word_score_test.py +++ b/src/projecteuler/helpers/word_score_test.py @@ -1,6 +1,6 @@ import unittest -from .word_score import word_score +from .word_score import wordScore class TestWordScore(unittest.TestCase): @@ -14,11 +14,11 @@ def test_wordscore(self): ] for _, _tt in enumerate(tests): - to_test = word_score(_tt['input']) + to_test = wordScore(_tt['input']) self.assertEqual( to_test, _tt['answer'], - f"{_} | word_score({_tt['input']}) must be " + f"{_} | wordScore({_tt['input']}) must be " f"=> {_tt['answer']}") def test_wordscore_with_scoreless_characters(self): @@ -29,9 +29,9 @@ def test_wordscore_with_scoreless_characters(self): ] for _, _tt in enumerate(tests): - to_test = word_score(_tt['input']) + to_test = wordScore(_tt['input']) self.assertEqual( to_test, _tt['answer'], - f"{_} | word_score({_tt['input']}) must be " + f"{_} | wordScore({_tt['input']}) must be " f"=> {_tt['answer']}") diff --git a/src/projecteuler/problem0004.py b/src/projecteuler/problem0004.py index 48af0e93..79b7afee 100644 --- a/src/projecteuler/problem0004.py +++ b/src/projecteuler/problem0004.py @@ -1,7 +1,7 @@ # @link Problem definition [[docs/projecteuler/problem0004.md]] import logging -from .helpers.palindrome import is_palindrome +from .helpers.palindrome import isPalindrome LOGGER = logging.getLogger(__name__) @@ -23,7 +23,7 @@ def problem0004(_bottom: int, _top: int) -> 'None | int': cycles += 1 - if is_palindrome(i * j): + if isPalindrome(i * j): found_palindrome = i * j LOGGER.debug("FOUND %d x %d = %d is Palindrome", diff --git a/src/projecteuler/problem0005_alt.py b/src/projecteuler/problem0005_alt.py index 53329655..26bc2c2f 100644 --- a/src/projecteuler/problem0005_alt.py +++ b/src/projecteuler/problem0005_alt.py @@ -7,7 +7,7 @@ LOGGER = logging.getLogger(__name__) -def _increase(element: int, group: dict[int, int]) -> dict[int, int]: +def increase(element: int, group: dict[int, int]) -> dict[int, int]: elem = group.get(element, None) if elem is None: group.update({element: 1}) @@ -17,7 +17,7 @@ def _increase(element: int, group: dict[int, int]) -> dict[int, int]: return group -def _replace_maximum(element: int, count: int, group: dict[int, int]) -> dict[int, int]: +def replaceMaximum(element: int, count: int, group: dict[int, int]) -> dict[int, int]: elem = group.get(element, None) if elem is None: group.update({element: count}) @@ -27,16 +27,16 @@ def _replace_maximum(element: int, count: int, group: dict[int, int]) -> dict[in return group -def prime_factors_collection(factors: list[int]) -> dict[int, int]: +def primeFactorsCollection(factors: list[int]) -> dict[int, int]: collection = {} for factor in factors: - collection = _increase(factor, collection) + collection = increase(factor, collection) return collection -def problem0005_alt(_bottom: int, _top: int) -> 'None | float': +def problem0005(_bottom: int, _top: int) -> 'None | float': minimum_prime_factors = {} result: None | float = None @@ -49,7 +49,7 @@ def problem0005_alt(_bottom: int, _top: int) -> 'None | float': primes = number.prime_factors() cycles += number.get_prime_factors_cycles() - factors = prime_factors_collection(primes) + factors = primeFactorsCollection(primes) cycles += len(primes) LOGGER.debug('Prime Factors of %d list => %s', i, str(primes)) @@ -57,7 +57,7 @@ def problem0005_alt(_bottom: int, _top: int) -> 'None | float': for factor, quantity in factors.items(): cycles += 1 - _replace_maximum(factor, quantity, minimum_prime_factors) + replaceMaximum(factor, quantity, minimum_prime_factors) LOGGER.debug('Prime Factors of %d grouped => %s', i, str(minimum_prime_factors)) diff --git a/src/projecteuler/problem0005_test.py b/src/projecteuler/problem0005_test.py index 2d64d261..3ac6f3e8 100755 --- a/src/projecteuler/problem0005_test.py +++ b/src/projecteuler/problem0005_test.py @@ -1,6 +1,6 @@ import unittest from .problem0005 import problem0005 -from .problem0005_alt import problem0005_alt +from .problem0005_alt import problem0005 as problem0005_alt class TestProblem0005(unittest.TestCase): diff --git a/src/projecteuler/problem0007.py b/src/projecteuler/problem0007.py index 451a3317..e45b16cb 100644 --- a/src/projecteuler/problem0007.py +++ b/src/projecteuler/problem0007.py @@ -1,7 +1,7 @@ # @link Problem definition [[docs/projecteuler/problem0007.md]] import logging -from .helpers.prime import is_prime +from .helpers.prime import isPrime LOGGER = logging.getLogger(__name__) @@ -15,7 +15,7 @@ def problem0007(_top: int) -> int: while len(primes) < _top: i += 1 - if is_prime(j): + if isPrime(j): primes.append(j) LOGGER.debug("Prime found %d put in position: %d", j, len(primes)) diff --git a/src/projecteuler/problem0017.py b/src/projecteuler/problem0017.py index 77c538f7..0d6ad579 100644 --- a/src/projecteuler/problem0017.py +++ b/src/projecteuler/problem0017.py @@ -2,7 +2,7 @@ import re import logging -from .helpers.number_to_word import number_to_word +from .helpers.number_to_word import numberToWord LOGGER = logging.getLogger(__name__) @@ -12,7 +12,7 @@ def problem0017(_init: int, _last: int) -> int: acum = 0 for i in range(_init, _last + 1): - word = number_to_word(i) + word = numberToWord(i) replaced = re.sub(r'[^a-zA-Z]', '', word) acum += len(replaced) diff --git a/src/projecteuler/problem0022.py b/src/projecteuler/problem0022.py index d59df681..c31c700e 100644 --- a/src/projecteuler/problem0022.py +++ b/src/projecteuler/problem0022.py @@ -3,7 +3,7 @@ import logging from typing import List -from .helpers.word_score import word_score +from .helpers.word_score import wordScore LOGGER = logging.getLogger(__name__) @@ -18,7 +18,7 @@ def problem0022(list_of_names: List[str]) -> int: for name in names: counter += 1 - result += counter * word_score(name) + result += counter * wordScore(name) LOGGER.info('Problem 0022 result: %i', result) return result diff --git a/src/projecteuler/problem0022_test.py b/src/projecteuler/problem0022_test.py index 0ef00166..a96065c0 100755 --- a/src/projecteuler/problem0022_test.py +++ b/src/projecteuler/problem0022_test.py @@ -1,22 +1,23 @@ import unittest -import json -import os +from pathlib import Path + +from ..lib.loader import loadTestCases from .problem0022 import problem0022 +FILE_PATH = str(Path(__file__).resolve().parent) + +NAMES = loadTestCases( + FILE_PATH + '/data/p022_names.json') + + class TestProblem0022(unittest.TestCase): def test_problem0022(self): - file_abs_path = os.path.abspath(os.path.dirname(__file__)) - - with open( - os.path.join(file_abs_path, 'data', 'p022_names.json'), - encoding="utf-8") as read_content: - names = json.load(read_content) - solution_found = 871198282 + solution_found = 871198282 - self.assertEqual( - problem0022(names), solution_found, - f"problem0022({names}) must be " - f"=> {solution_found}") + self.assertEqual( + problem0022(NAMES), solution_found, + f"problem0022({NAMES}) must be " + f"=> {solution_found}")