ruff 설정 변경 및 코드 포매팅

Author: flynnpark

dfs.py

@@ -1,4 +1,4 @@
-graph = {
+graph: dict[int, list[int]] = {
     1: [2, 3, 4],
     2: [5],
     3: [5],
@@ -9,7 +9,9 @@
 }
 
 
-def recursive_dfs(v: int, discovered: list[int] = []) -> list[int]:
+def recursive_dfs(v: int, discovered: list[int] | None = None) -> list[int]:
+    if discovered is None:
+        discovered = []
     discovered.append(v)
     for w in graph[v]:
         if w not in discovered:

pyproject.toml

@@ -47,12 +47,18 @@ ignore = [
     "E501",    # line too long, handled by black
     "E711",    # Comparison to None should be cond is None
     "E712",    # Comparison to True should be cond is True or if cond:
+    "E741",    # ambiguous variable name
     "B008",    # do not perform function calls in argument defaults
     "C901",    # too complex
     "PLR0913", # too many arguments to function call
     "B028",    # no-explicit-stacklevel
 ]
 
+[tool.ruff.lint.per-file-ignores]
+"**/test_solution.py" = [
+    "PLR2004", # Magic value used in comparision
+]
+
 [tool.ruff.format]
 quote-style = "single"
 indent-style = "space"

solutions/solution_0002/__init__.py

@@ -19,9 +19,9 @@ def __eq__(self, other):
 class Solution:
     def addTwoNumbers(
         self,
-        l1: Optional[ListNode],
-        l2: Optional[ListNode],
-    ) -> Optional[ListNode]:
+        l1: ListNode | None,
+        l2: ListNode | None,
+    ) -> ListNode | None:
         result = ListNode(0)
         current = result
         carry = 0

solutions/solution_0002/test_solution.py

@@ -1,9 +1,7 @@
-from typing import List
-
 from . import ListNode, Solution
 
 
-def arrayToListNode(numbers: List[int]) -> ListNode | None:
+def arrayToListNode(numbers: list[int]) -> ListNode | None:
     result = ListNode()
     current = result
     for number in numbers:

solutions/solution_0003/test_solution.py

@@ -2,25 +2,28 @@
 
 from . import Solution
 
-CaseDict = TypedDict("CaseDict", {"input": str, "expected": int})
+
+class CaseDict(TypedDict):
+    input: str
+    expected: int
 
 
 test_cases: list[CaseDict] = [
     {
-        "input": 'abcabcbb',
-        "expected": 3,
+        'input': 'abcabcbb',
+        'expected': 3,
     },
     {
-        "input": 'bbbbb',
-        "expected": 1,
+        'input': 'bbbbb',
+        'expected': 1,
     },
     {
-        "input": 'pwwkew',
-        "expected": 3,
+        'input': 'pwwkew',
+        'expected': 3,
     },
 ]
 
 
 def test_solution():
     for test_case in test_cases:
-        assert Solution().lengthOfLongestSubstring(test_case["input"]) == test_case["expected"]
+        assert Solution().lengthOfLongestSubstring(test_case['input']) == test_case['expected']

solutions/solution_0005/test_solution.py

@@ -1,19 +1,22 @@
-from typing import List, TypedDict
+from typing import TypedDict
 
 from . import Solution
 
-CaseDict = TypedDict('CaseDict', {'input': str, 'expected': List[str]})
 
+class CaseDict(TypedDict):
+    input: str
+    expected: list[str]
 
-test_cases: List[CaseDict] = [
-    {"input": "babad", "expected": ["bab", "aba"]},
-    {"input": "cbbd", "expected": ["bb"]},
-    {"input": "a", "expected": ["a"]},
-    {"input": "ac", "expected": ["a", "c"]},
+
+test_cases: list[CaseDict] = [
+    {'input': 'babad', 'expected': ['bab', 'aba']},
+    {'input': 'cbbd', 'expected': ['bb']},
+    {'input': 'a', 'expected': ['a']},
+    {'input': 'ac', 'expected': ['a', 'c']},
 ]
 
 
 def test_solution():
     for test_case in test_cases:
-        actual_result = Solution().longestPalindrome(test_case["input"])
-        assert actual_result in test_case["expected"]
+        actual_result = Solution().longestPalindrome(test_case['input'])
+        assert actual_result in test_case['expected']

solutions/solution_0007/test_solution.py

@@ -1,4 +1,4 @@
-from typing import List, TypedDict
+from typing import TypedDict
 
 from . import Solution
 
@@ -8,15 +8,15 @@ class CaseDict(TypedDict):
     expected: int
 
 
-test_cases: List[CaseDict] = [
-    {"input": 123, "expected": 321},
-    {"input": -123, "expected": -321},
-    {"input": 120, "expected": 21},
-    {"input": 0, "expected": 0},
+test_cases: list[CaseDict] = [
+    {'input': 123, 'expected': 321},
+    {'input': -123, 'expected': -321},
+    {'input': 120, 'expected': 21},
+    {'input': 0, 'expected': 0},
 ]
 
 
 def test_solution():
     for test_case in test_cases:
-        actual_result = Solution().reverse(test_case["input"])
-        assert actual_result == test_case["expected"]
+        actual_result = Solution().reverse(test_case['input'])
+        assert actual_result == test_case['expected']

solutions/solution_0009/test_solution.py

@@ -1,4 +1,4 @@
-from typing import List, TypedDict
+from typing import TypedDict
 
 from . import Solution
 
@@ -8,15 +8,15 @@ class CaseDict(TypedDict):
     expected: bool
 
 
-test_cases: List[CaseDict] = [
-    {"input": 121, "expected": True},
-    {"input": -121, "expected": False},
-    {"input": 10, "expected": False},
-    {"input": -101, "expected": False},
+test_cases: list[CaseDict] = [
+    {'input': 121, 'expected': True},
+    {'input': -121, 'expected': False},
+    {'input': 10, 'expected': False},
+    {'input': -101, 'expected': False},
 ]
 
 
 def test_solution():
     for test_case in test_cases:
-        actual_result = Solution().isPalindrome(test_case["input"])
-        assert actual_result == test_case["expected"]
+        actual_result = Solution().isPalindrome(test_case['input'])
+        assert actual_result == test_case['expected']

solutions/solution_0011/__init__.py

@@ -1,8 +1,5 @@
-from typing import List
-
-
 class Solution:
-    def maxArea(self, height: List[int]) -> int:
+    def maxArea(self, height: list[int]) -> int:
         left = 0
         right = len(height) - 1
         max_area = 0

solutions/solution_0011/test_solution.py

@@ -1,12 +1,12 @@
-from typing import List, TypedDict
+from typing import TypedDict
 
 import pytest
 
 from . import Solution
 
 
 class InputDict(TypedDict):
-    height: List[int]
+    height: list[int]
 
 
 class CaseDict(TypedDict):
@@ -16,16 +16,16 @@ class CaseDict(TypedDict):
 
 test_cases: list[CaseDict] = [
     {
-        "input": {
-            "height": [1, 8, 6, 2, 5, 4, 8, 3, 7],
+        'input': {
+            'height': [1, 8, 6, 2, 5, 4, 8, 3, 7],
         },
-        "expected": 49,
+        'expected': 49,
     },
     {
-        "input": {
-            "height": [1, 1],
+        'input': {
+            'height': [1, 1],
         },
-        "expected": 1,
+        'expected': 1,
     },
 ]
 
@@ -35,5 +35,5 @@ class CaseDict(TypedDict):
     test_cases,
 )
 def test_solution(test_case: CaseDict):
-    result = Solution().maxArea(**test_case["input"])
-    assert result == test_case["expected"]
+    result = Solution().maxArea(**test_case['input'])
+    assert result == test_case['expected']

solutions/solution_0013/test_solution.py

@@ -1,4 +1,4 @@
-from typing import List, TypedDict
+from typing import TypedDict
 
 from . import Solution
 
@@ -8,16 +8,16 @@ class CaseDict(TypedDict):
     expected: int
 
 
-test_cases: List[CaseDict] = [
-    {"input": "III", "expected": 3},
-    {"input": "IV", "expected": 4},
-    {"input": "IX", "expected": 9},
-    {"input": "LVIII", "expected": 58},
-    {"input": "MCMXCIV", "expected": 1994},
+test_cases: list[CaseDict] = [
+    {'input': 'III', 'expected': 3},
+    {'input': 'IV', 'expected': 4},
+    {'input': 'IX', 'expected': 9},
+    {'input': 'LVIII', 'expected': 58},
+    {'input': 'MCMXCIV', 'expected': 1994},
 ]
 
 
 def test_solution():
     for test_case in test_cases:
-        actual_result = Solution().romanToInt(test_case["input"])
-        assert actual_result == test_case["expected"]
+        actual_result = Solution().romanToInt(test_case['input'])
+        assert actual_result == test_case['expected']

solutions/solution_0014/__init__.py

@@ -1,13 +1,10 @@
-from typing import List
-
-
 class Solution:
-    def longestCommonPrefix(self, strs: List[str]) -> str:
+    def longestCommonPrefix(self, strs: list[str]) -> str:
         result = []
-        for pair in zip(*strs):
+        for pair in zip(*strs, strict=False):
             pair_set = set(pair)
             if len(pair_set) == 1:
                 result.append(pair_set.pop())
             else:
                 break
-        return "".join(result)
+        return ''.join(result)

solutions/solution_0014/test_solution.py

@@ -1,21 +1,21 @@
-from typing import List, TypedDict
+from typing import TypedDict
 
 from . import Solution
 
 
 class CaseDict(TypedDict):
-    input: List[str]
+    input: list[str]
     expected: str
 
 
-test_cases: List[CaseDict] = [
-    {"input": ["flower", "flow", "flight"], "expected": "fl"},
-    {"input": ["dog", "racecar", "car"], "expected": ""},
-    {"input": ["cir", "car"], "expected": "c"},
+test_cases: list[CaseDict] = [
+    {'input': ['flower', 'flow', 'flight'], 'expected': 'fl'},
+    {'input': ['dog', 'racecar', 'car'], 'expected': ''},
+    {'input': ['cir', 'car'], 'expected': 'c'},
 ]
 
 
 def test_solution():
     for test_case in test_cases:
-        actual_result = Solution().longestCommonPrefix(test_case["input"])
-        assert actual_result == test_case["expected"]
+        actual_result = Solution().longestCommonPrefix(test_case['input'])
+        assert actual_result == test_case['expected']

solutions/solution_0015/__init__.py

@@ -1,8 +1,5 @@
-from typing import List
-
-
 class Solution:
-    def threeSum(self, nums: List[int]) -> List[List[int]]:
+    def threeSum(self, nums: list[int]) -> list[list[int]]:
         results = []
         nums.sort()
 

solutions/solution_0015/test_solution.py

@@ -1,21 +1,21 @@
-from typing import List, TypedDict
+from typing import TypedDict
 
 from . import Solution
 
 
 class CaseDict(TypedDict):
-    input: List[int]
-    expected: List[List[int]]
+    input: list[int]
+    expected: list[list[int]]
 
 
-test_cases: List[CaseDict] = [
-    {"input": [-1, 0, 1, 2, -1, -4], "expected": [[-1, -1, 2], [-1, 0, 1]]},
-    {"input": [], "expected": []},
-    {"input": [0], "expected": []},
+test_cases: list[CaseDict] = [
+    {'input': [-1, 0, 1, 2, -1, -4], 'expected': [[-1, -1, 2], [-1, 0, 1]]},
+    {'input': [], 'expected': []},
+    {'input': [0], 'expected': []},
 ]
 
 
 def test_solution():
     for test_case in test_cases:
-        actual_result = Solution().threeSum(test_case["input"])
-        assert actual_result == test_case["expected"]
+        actual_result = Solution().threeSum(test_case['input'])
+        assert actual_result == test_case['expected']

solutions/solution_0020/test_solution.py

@@ -1,21 +1,24 @@
-from typing import List, TypedDict
+from typing import TypedDict
 
 from . import Solution
 
-CaseDict = TypedDict('CaseDict', {'input': str, 'expected': bool})
 
+class CaseDict(TypedDict):
+    input: str
+    expected: bool
 
-test_cases: List[CaseDict] = [
-    {"input": "()", "expected": True},
-    {"input": "()[]{}", "expected": True},
-    {"input": "(]", "expected": False},
-    {"input": "([)]", "expected": False},
-    {"input": "{[]}", "expected": True},
-    {"input": "(", "expected": False},
+
+test_cases: list[CaseDict] = [
+    {'input': '()', 'expected': True},
+    {'input': '()[]{}', 'expected': True},
+    {'input': '(]', 'expected': False},
+    {'input': '([)]', 'expected': False},
+    {'input': '{[]}', 'expected': True},
+    {'input': '(', 'expected': False},
 ]
 
 
 def test_solution():
     for test_case in test_cases:
-        actual_result = Solution().isValid(test_case["input"])
-        assert actual_result == test_case["expected"]
+        actual_result = Solution().isValid(test_case['input'])
+        assert actual_result == test_case['expected']