[pre-commit.ci] pre-commit autoupdate (#11322)

* [pre-commit.ci] pre-commit autoupdate

updates:
- [github.com/astral-sh/ruff-pre-commit: v0.2.2 → v0.3.2](https://github.com/astral-sh/ruff-pre-commit/compare/v0.2.2...v0.3.2)
- [github.com/pre-commit/mirrors-mypy: v1.8.0 → v1.9.0](https://github.com/pre-commit/mirrors-mypy/compare/v1.8.0...v1.9.0)

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

backtracking/all_combinations.py

@@ -1,9 +1,10 @@
 """
-        In this problem, we want to determine all possible combinations of k
-        numbers out of 1 ... n. We use backtracking to solve this problem.
+In this problem, we want to determine all possible combinations of k
+numbers out of 1 ... n. We use backtracking to solve this problem.
 
-        Time complexity: O(C(n,k)) which is O(n choose k) = O((n!/(k! * (n - k)!))),
+Time complexity: O(C(n,k)) which is O(n choose k) = O((n!/(k! * (n - k)!))),
 """
+
 from __future__ import annotations
 
 from itertools import combinations

backtracking/all_permutations.py

@@ -1,10 +1,11 @@
 """
-        In this problem, we want to determine all possible permutations
-        of the given sequence. We use backtracking to solve this problem.
+In this problem, we want to determine all possible permutations
+of the given sequence. We use backtracking to solve this problem.
 
-        Time complexity: O(n! * n),
-        where n denotes the length of the given sequence.
+Time complexity: O(n! * n),
+where n denotes the length of the given sequence.
 """
+
 from __future__ import annotations
 
 

backtracking/all_subsequences.py

@@ -5,6 +5,7 @@ of the given sequence. We use backtracking to solve this problem.
 Time complexity: O(2^n),
 where n denotes the length of the given sequence.
 """
+
 from __future__ import annotations
 
 from typing import Any

backtracking/coloring.py

@@ -1,9 +1,9 @@
 """
-    Graph Coloring also called "m coloring problem"
-    consists of coloring a given graph with at most m colors
-    such that no adjacent vertices are assigned the same color
+Graph Coloring also called "m coloring problem"
+consists of coloring a given graph with at most m colors
+such that no adjacent vertices are assigned the same color
 
-    Wikipedia: https://en.wikipedia.org/wiki/Graph_coloring
+Wikipedia: https://en.wikipedia.org/wiki/Graph_coloring
 """
 
 

backtracking/hamiltonian_cycle.py

@@ -1,10 +1,10 @@
 """
-    A Hamiltonian cycle (Hamiltonian circuit) is a graph cycle
-    through a graph that visits each node exactly once.
-    Determining whether such paths and cycles exist in graphs
-    is the 'Hamiltonian path problem', which is NP-complete.
+A Hamiltonian cycle (Hamiltonian circuit) is a graph cycle
+through a graph that visits each node exactly once.
+Determining whether such paths and cycles exist in graphs
+is the 'Hamiltonian path problem', which is NP-complete.
 
-    Wikipedia: https://en.wikipedia.org/wiki/Hamiltonian_path
+Wikipedia: https://en.wikipedia.org/wiki/Hamiltonian_path
 """
 
 

backtracking/minimax.py

@@ -7,6 +7,7 @@ if move is of maximizer return true else false
 leaves of game tree is stored in scores[]
 height is maximum height of Game tree
 """
+
 from __future__ import annotations
 
 import math

backtracking/n_queens.py

@@ -1,12 +1,13 @@
 """
 
- The nqueens problem is of placing N queens on a N * N
- chess board such that no queen can attack any other queens placed
- on that chess board.
- This means that one queen cannot have any other queen on its horizontal, vertical and
- diagonal lines.
+The nqueens problem is of placing N queens on a N * N
+chess board such that no queen can attack any other queens placed
+on that chess board.
+This means that one queen cannot have any other queen on its horizontal, vertical and
+diagonal lines.
 
 """
+
 from __future__ import annotations
 
 solution = []

backtracking/n_queens_math.py

@@ -75,6 +75,7 @@ Applying these two formulas we can check if a queen in some position is being at
 for another one or vice versa.
 
 """
+
 from __future__ import annotations
 
 

backtracking/sudoku.py

@@ -9,6 +9,7 @@ function on the next column to see if it returns True. if yes, we
 have solved the puzzle. else, we backtrack and place another number
 in that cell and repeat this process.
 """
+
 from __future__ import annotations
 
 Matrix = list[list[int]]

backtracking/sum_of_subsets.py

@@ -1,11 +1,12 @@
 """
-        The sum-of-subsetsproblem states that a set of non-negative integers, and a
-        value M, determine all possible subsets of the given set whose summation sum
-        equal to given M.
+The sum-of-subsetsproblem states that a set of non-negative integers, and a
+value M, determine all possible subsets of the given set whose summation sum
+equal to given M.
 
-        Summation of the chosen numbers must be equal to given number M and one number
-        can be used only once.
+Summation of the chosen numbers must be equal to given number M and one number
+can be used only once.
 """
+
 from __future__ import annotations