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

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

Author: pre-commit-ci[bot]

.prettierignore

@@ -7,4 +7,4 @@ CODE_OF_CONDUCT.md
 coverage
 src/gatsby/xdm.js
 PULL_REQUEST_TEMPLATE.md
-*.mdx
+*.mdx

content/3_Silver/Intro_Tree.mdx

@@ -183,7 +183,7 @@ public class Subordinates {
 
 In the Python solution, we need to set recursion limit to $2\times10^5$.
 
-```python
+```py
 import sys
 
 sys.setrecursionlimit(200006)  # set recursion limit

content/3_Silver/Prefix_Sums.mdx

@@ -272,7 +272,7 @@ public class Main {
 
 <PySection>
 
-```python
+```py
 def psum(a):
 	psum = [0]
 	for i in a:

content/5_Plat/Matrix_Expo.mdx

@@ -132,7 +132,7 @@ int main() {
 </CPPSection>
 
 <PySection>
-```python
+```py
 from typing import List
 
 MOD = 10**9 + 7

py/format_code.py

@@ -24,6 +24,7 @@
 	"{" + ", ".join(filter(lambda x: x != "", CLANG_FORMAT_STYLE.split("\n"))) + "}"
 )
 
+
 def lead_white(line):
 	return len(line) - len(line.lstrip())
 
@@ -75,15 +76,17 @@ def format_path(path: str):
 	nlines = []
 	prog = []
 	for line in lines:
-		if line.strip().startswith("```") and len(line.strip()) > 3: # start of lang block
+		if (
+			line.strip().startswith("```") and len(line.strip()) > 3
+		):  # start of lang block
 			lang = line.strip()[3:].strip()
-			if lang == 'python':
-				lang = 'py'
-			if lang not in ['cpp', 'py', 'java']:
+			if lang == "python":
+				lang = "py"
+			if lang not in ["cpp", "py", "java"]:
 				raise ValueError(f"Unrecognized formatting lang: {line.strip()[3:]}")
 			nlines.append(f"```{lang}\n")
 		elif line.strip() == "```":
-			if lang is not None: # end of lang block
+			if lang is not None:  # end of lang block
 				if not contains_banned_terms(prog):
 					prog = [match_indentation(line, prog_line) for prog_line in prog]
 					prog = format_prog(lang, prog)
@@ -94,9 +97,9 @@ def format_path(path: str):
 				prog = []
 				lang = None
 			nlines.append(line)
-		elif lang is not None: # program block
+		elif lang is not None:  # program block
 			prog.append(line)
-		else: # outside of program block
+		else:  # outside of program block
 			nlines.append(line)
 	with open(path, "w") as f:
 		f.write("".join(nlines))

solutions/bronze/usaco-1109.mdx

@@ -35,7 +35,7 @@ shoelace formula is proved.
 
 ## Implementation
 
-```python
+```py
 def cross_product(p1, p2):
 	return p1[0] * p2[1] - p2[0] * p1[1]
 

solutions/silver/ac-GCDOnBlackboard.mdx

@@ -9,10 +9,10 @@ author: Andrew Cheng, Mohammad Nour Massri, David Zhang
 The problem asks us to find the maximum possible GCD of the remaining $N-1$ numbers
 after taking any one of them away. Naively trying every single combination will result in a
 complexity of $\mathcal{O}(N^2 + N \log(\max a_i))$ as there are $N$ different ways to take away a number and calculating
-the GCD will take $\mathcal{O}(N+\log(\max a_i))$ time per case. 
+the GCD will take $\mathcal{O}(N+\log(\max a_i))$ time per case.
 
 To speed this process up, we can calculate the GCDs of every prefix and suffix. Let $l[i] = \gcd_{j=1}^{i} a[j]$ and $r[i] = \gcd_{j=i}^{N} a[j]$.
-Then the answer is the maximum of $\gcd(l[i-1],r[i+1]),$ $i \in [1,N]$. 
+Then the answer is the maximum of $\gcd(l[i-1],r[i+1]),$ $i \in [1,N]$.
 
 **Time Complexity:**
 $\mathcal{O}(N+\log(\max a_i))$
@@ -107,7 +107,7 @@ print(ans)
 ```
 </PySection>
 <JavaSection>
-	
+
 ```java
 import java.util.*;
 import java.io.*;

solutions/silver/ac-MultipleOf2019.mdx

@@ -18,30 +18,30 @@ $$[1234, 234, 34, 4, 0]$$
 
 **Keep in mind, that an empty suffix with is also considered.**
 
-This is useful because we can access any substring in $\mathcal{O}(1)$ time through a range query. So if $${S_0} = 1234 $$ and $${S_3=4}$$, this means $${S_0}-{S_3} = 123 * {10^1}$$ or $$1230$$. 
+This is useful because we can access any substring in $\mathcal{O}(1)$ time through a range query. So if $${S_0} = 1234 $$ and $${S_3=4}$$, this means $${S_0}-{S_3} = 123 * {10^1}$$ or $$1230$$.
 
-It also means that if both $${S_0}(mod$$ $$M)=$$ $${S_3}(mod$$ $$M)$$ (both suffixes have the same remainders), subtracting would lead to $${S_0}(mod$$ $$M)-$$ $${S_3}(mod$$ $$M)=0$$, meaning a substring that is divisible by $$2019$$. 
+It also means that if both $${S_0}(mod$$ $$M)=$$ $${S_3}(mod$$ $$M)$$ (both suffixes have the same remainders), subtracting would lead to $${S_0}(mod$$ $$M)-$$ $${S_3}(mod$$ $$M)=0$$, meaning a substring that is divisible by $$2019$$.
 
-So with $$1234$$, $${S_0-{S_3}=1234(mod}$$ $$3)-4(mod$$ $$3)=1-1=0$$. Because they substract to zero, it means the substring from index $$0$$ to $$2$$ leads to a number divisible by the modulus. (The substring is $$123$$ which is divisble by 3). 
+So with $$1234$$, $${S_0-{S_3}=1234(mod}$$ $$3)-4(mod$$ $$3)=1-1=0$$. Because they substract to zero, it means the substring from index $$0$$ to $$2$$ leads to a number divisible by the modulus. (The substring is $$123$$ which is divisble by 3).
 
 However, we would still need to go through every pair of possible suffixes $(i, j)$ which would be $\mathcal{O}(N^2)$.
 
-Instead, **we do not need to know which suffix has a certain remainder, but rather how many suffixes have that certain remainder.** 
+Instead, **we do not need to know which suffix has a certain remainder, but rather how many suffixes have that certain remainder.**
 
-To elaborate, we can take $${N \choose K}$$, and choose 2 numbers that are divisible by the same remainder of 2019, where $$N=$$ the amount of times a certain remainder occurs, and $$K=$$ 2 (because we are picking 2 indicies $$i$$ and $$j$$). 
+To elaborate, we can take $${N \choose K}$$, and choose 2 numbers that are divisible by the same remainder of 2019, where $$N=$$ the amount of times a certain remainder occurs, and $$K=$$ 2 (because we are picking 2 indicies $$i$$ and $$j$$).
 
-Therefore, our answer is the counts of all the remainders in an array from $$0...2018$$ and $${N \choose 2}$$. 
+Therefore, our answer is the counts of all the remainders in an array from $$0...2018$$ and $${N \choose 2}$$.
 
 So in our example with $$1234$$, our new array would look like this:
 
 $$[2, 3, 0]$$
 
-Where each index represents the count of a certain remainder. 
+Where each index represents the count of a certain remainder.
 * There are $$2$$ suffixes with a remainder of $$0$$ when dividing by $$3$$, $$[234, 0]$$
 * There are $$3$$ suffixes with a remainder of $$1$$ when dividing by $$3$$, $$[1234, 34, 4]$$
 * And there are no suffixes with a remainder of $$2$$
 
-So, the sum of all of these numbers would be $${2 \choose 2} + {3 \choose 2}=1+3=4$$ 
+So, the sum of all of these numbers would be $${2 \choose 2} + {3 \choose 2}=1+3=4$$
 
 If $$N<K$$, it should be $$0$$, since there aren't enough suffixes that can make a pair.
 
@@ -88,9 +88,9 @@ int main() {
 ```
 
 </CPPSection>
-	
+
 <JavaSection>
-	
+
 ```java
 import java.io.*;
 import java.util.*;
@@ -123,7 +123,7 @@ public class MultipleOf2019 {
 	//CodeSnip{Kattio}
 }
 ```
-					 
+
 </JavaSection>
 <PySection>
 

solutions/silver/apio-11-TableColoring.mdx

@@ -61,14 +61,14 @@ it simply isn't possible to color the table, the answer is $0$.
 
 ### Checking Whether the Answer is $0$
 
-This problem then becomes checking whether there is an cycle with odd weight 
+This problem then becomes checking whether there is an cycle with odd weight
 in the resulting graph, which we can answer efficiently using DSU or DFS.
 
-One way to implement this is as follows. Since each already-colored cell 
-$(x, y)$ determines whether the colors of the cells $(x, 0)$ and $(0, y)$ are 
-the same, we can instead split each node in our graph into 2 nodes (one for 
+One way to implement this is as follows. Since each already-colored cell
+$(x, y)$ determines whether the colors of the cells $(x, 0)$ and $(0, y)$ are
+the same, we can instead split each node in our graph into 2 nodes (one for
 each color) and create edges between nodes with consistent colors.
-The answer is $0$ if two new nodes corresponding to the same original node 
+The answer is $0$ if two new nodes corresponding to the same original node
 are in the same connected component.
 
 ## Implementation

solutions/silver/cc-AMONGUS2.mdx

@@ -6,7 +6,7 @@ author: Ryan Chou
 ---
 
 ## Explanation
-If we only have two players $x$ and $y$, then we have 4 cases possible cases. 
+If we only have two players $x$ and $y$, then we have 4 cases possible cases.
 
 * If $x$ vouches for $y$ and $x$ is an imposter, then $y$ must also be an imposter.
 

solutions/silver/ccc-Firehose.mdx

@@ -87,4 +87,4 @@ int main() {
 ```
 </CPPSection>
 
-</LanguageSection>
+</LanguageSection>

solutions/silver/ceoi-12-JobScheduling.mdx

@@ -9,9 +9,9 @@ author: Chuyang Wang
 
 ## Explanation
 
-To find the minimum possible solution, we can use binary search on the number of machines needed for finishing the jobs within the given deadline. With $M$ requests, the number of needed machines must lie in the range $[1, M]$ as in the worst case where all the requests are given on the last day, we still have $D + 1$ days to process these requests. 
+To find the minimum possible solution, we can use binary search on the number of machines needed for finishing the jobs within the given deadline. With $M$ requests, the number of needed machines must lie in the range $[1, M]$ as in the worst case where all the requests are given on the last day, we still have $D + 1$ days to process these requests.
 
-For each number of machines being tested, we can check its feasibility in linear time if the given job requests are already sorted in ascending order with respect to the request date. We iterate through each day $i$ from $1$ to $N$ and add requests to the schedule in the sorted order. If there is no available machine left on a certain day $i$ while there are still requests not processed, we move to next day $i+1$ and process these requests. If the day $i$ exceeds the delay limit for the current job being processed, i.e. the request date of the job added with the permitted delay is strictly less than the current day $i$, we can stop iterating as it is not possible to use the giving number of machines to process all the jobs within the deadline. Otherwise, if we have processed all job requests, the number of machines being tested is feasible, and we also found a schedule for these jobs. 
+For each number of machines being tested, we can check its feasibility in linear time if the given job requests are already sorted in ascending order with respect to the request date. We iterate through each day $i$ from $1$ to $N$ and add requests to the schedule in the sorted order. If there is no available machine left on a certain day $i$ while there are still requests not processed, we move to next day $i+1$ and process these requests. If the day $i$ exceeds the delay limit for the current job being processed, i.e. the request date of the job added with the permitted delay is strictly less than the current day $i$, we can stop iterating as it is not possible to use the giving number of machines to process all the jobs within the deadline. Otherwise, if we have processed all job requests, the number of machines being tested is feasible, and we also found a schedule for these jobs.
 
 ## Implementation
 

solutions/silver/cf-1158A.mdx

@@ -92,9 +92,9 @@ int main() {
 ```
 
 </CPPSection>
-	
+
 <JavaSection>
-	
+
 ```java
 import java.io.*;
 import java.util.*;
@@ -144,9 +144,9 @@ public class ThePartyAndSweets {
 		io.close();
 	}
 	//CodeSnip{Kattio}
-}	
+}
 ```
-	
+
 </JavaSection>
 
 </LanguageSection>

solutions/silver/cf-1223C.mdx

@@ -9,7 +9,7 @@ author: Jesse Choe, Kevin Sheng
 
 ## Explanation
 
-Binary search on the answer for the minimum number of tickets, $t$, to sell to make the total ecological contribution to at least $k$. 
+Binary search on the answer for the minimum number of tickets, $t$, to sell to make the total ecological contribution to at least $k$.
 
 Let's try to determine the maximum contribution attainable with $t$ tickets.
 
@@ -89,7 +89,7 @@ int main() {
 </CPPSection>
 
 <JavaSection>
-    
+
 ### Java Implementation
 
 ```java
@@ -163,7 +163,7 @@ public final class SaveNature {
 </JavaSection>
 
 <PySection>
-    
+
 ### Python Implementation
 
 ```py
@@ -211,7 +211,7 @@ for _ in range(int(input())):
 			lo = mid + 1
 	print(valid)
 ```
-    
+
 </PySection>
 
 </LanguageSection>

solutions/silver/cf-1359C.mdx

@@ -12,7 +12,7 @@ author: Jesse Choe
 
 Consider the following observations:
 
-- Case 1: The number of cups of hot water poured is equal to the number of cups of cold water poured. Pouring an equal number of cups of hot and cold water is equivalent to pouring one cup of each. 
+- Case 1: The number of cups of hot water poured is equal to the number of cups of cold water poured. Pouring an equal number of cups of hot and cold water is equivalent to pouring one cup of each.
 - Case 2: Otherwise, there must be exactly one more cup of hot water poured than cold water poured. Thus, there will be $c_i + 1$ cups of hot water and $c_i$ cups of cold water for some $c_i \geq 0$.
 - It can be proven, using induction, that the average barrel temperatures when $c_i$ is odd is a monotonically decreasing function. Thus, we can binary search on the maximum number of odd cups $c_i$ which gives a temperature of at least $t$ by checking the odd integers around it.
 

solutions/silver/cf-1398C.mdx

@@ -68,21 +68,21 @@ import java.util.*;
 public class GoodSubarrays {
 	static long solve(int arrLen, String strArr) {
 		int[] prefArr = new int[arrLen + 1];
-		for (int i = 1; i <= arrLen; i++) {  
+		for (int i = 1; i <= arrLen; i++) {
 			prefArr[i] = strArr.charAt(i - 1) - '0';
 		}
-		for (int i = 1; i <= arrLen; i++) { 
+		for (int i = 1; i <= arrLen; i++) {
 			prefArr[i] += prefArr[i - 1];
 		}
-		
+
 		Map<Integer, Long> sumDist = new HashMap<>();
 		for (int i = 0; i <= arrLen; i++) {
 			int val = prefArr[i] - i;
 			sumDist.put(val, sumDist.getOrDefault(val, 0L) + 1);
 		}
 
 		long goodArrays = 0;
-		for (long f : sumDist.values()) {  
+		for (long f : sumDist.values()) {
 			// calculate # of possible unordered pairs with f values of i
 			goodArrays += f * (f - 1) / 2;
 		}
@@ -92,7 +92,7 @@ public class GoodSubarrays {
 	public static void main (String[] args) {
 		Kattio io = new Kattio();
 		int t = io.nextInt();
-		for (int i = 0; i < t; i++) { 
+		for (int i = 0; i < t; i++) {
 			int arrLen = io.nextInt();
 			String array = io.next();
 			io.println(solve(arrLen, array));

solutions/silver/cf-1468D.mdx

@@ -8,7 +8,7 @@ author: Jesse Choe
 [Official Editorial](https://codeforces.com/blog/entry/85951)
 
 We can initially attempt this problem by figuring out which firecrackers should explode. Obviously, we should attempt to explode the firecrackers with a minimal
-detonation time to increase the number of firecrackers exploded before eventually being caught. Also, observe that the firecrackers with a longer detonation 
+detonation time to increase the number of firecrackers exploded before eventually being caught. Also, observe that the firecrackers with a longer detonation
 time should be dropped first.
 
 To find the maximum number of firecrackers before the hooligan gets caught by the guard, sort the detonation times in increasing order and figure out the

solutions/silver/cf-1474C.mdx

@@ -7,7 +7,7 @@ author: Kevin Sheng, Jesse Choe
 
 [Official Editorial](https://codeforces.com/blog/entry/86933)
 
-# Solution 
+# Solution
 
 **Time Complexity:** $\mathcal{O}(N^2\log N)$
 

solutions/silver/cf-321B.mdx

@@ -4,7 +4,7 @@ source: CF
 title: Ciel and Duel
 author: Ryan Chou
 ---
- 
+
 [Official Analysis (C++)](https://codeforces.com/blog/entry/8192)
 
 ## Explanation

solutions/silver/cf-847B.mdx

@@ -61,7 +61,7 @@ int main() {
 ```
 </CPPSection>
 <PySection>
-	
+
 ```py
 n = int(input().strip())
 numbers = [int(x) for x in input().strip().split()]