cargo: fmt

solutions/rust/src/bin/116A.rs

@@ -11,7 +11,10 @@ fn main() {
         let mut s = String::new();
         io::stdin().read_line(&mut s).unwrap();
 
-        let s: Vec<i64> = s.split_whitespace().map(|d| d.parse::<i64>().unwrap()).collect();
+        let s: Vec<i64> = s
+            .split_whitespace()
+            .map(|d| d.parse::<i64>().unwrap())
+            .collect();
 
         people += s[1] - s[0];
 

solutions/rust/src/bin/1327A.rs

@@ -9,7 +9,10 @@ fn main() {
         let mut s = String::new();
         io::stdin().read_line(&mut s).unwrap();
 
-        let a: Vec<u64> = s.split_whitespace().map(|d| d.parse::<u64>().unwrap()).collect();
+        let a: Vec<u64> = s
+            .split_whitespace()
+            .map(|d| d.parse::<u64>().unwrap())
+            .collect();
 
         if a[0] % 2 == a[1] % 2 {
             if a[1].pow(2) > a[0] {

solutions/rust/src/bin/149A.rs

@@ -9,7 +9,10 @@ fn main() {
     let mut s = String::new();
     io::stdin().read_line(&mut s).unwrap();
 
-    let mut a: Vec<u64> = s.split_whitespace().map(|d| d.parse::<u64>().unwrap()).collect();
+    let mut a: Vec<u64> = s
+        .split_whitespace()
+        .map(|d| d.parse::<u64>().unwrap())
+        .collect();
 
     a.sort();
     a.reverse();

solutions/rust/src/bin/200B.rs

@@ -9,7 +9,10 @@ fn main() {
     let mut p = String::new();
     io::stdin().read_line(&mut p).unwrap();
 
-    let drinks = p.split_whitespace().map(|c| c.parse::<u64>().unwrap()).collect::<Vec<u64>>();
+    let drinks = p
+        .split_whitespace()
+        .map(|c| c.parse::<u64>().unwrap())
+        .collect::<Vec<u64>>();
 
     let conc = drinks.iter().sum::<u64>() as f64 / n as f64;
 

solutions/rust/src/bin/2044B.rs

@@ -22,10 +22,10 @@ fn main() {
             match j {
                 'q' => {
                     new.push('p');
-                },
+                }
                 'p' => {
                     new.push('q');
-                },
+                }
                 _ => {
                     new.push('w');
                 }

solutions/rust/src/bin/236A.rs

@@ -1,5 +1,5 @@
-use std::io;
 use std::collections::HashSet;
+use std::io;
 
 fn main() {
     let mut s = String::new();

solutions/rust/src/bin/25A.rs

@@ -6,7 +6,10 @@ fn main() {
 
     let mut s = String::new();
     io::stdin().read_line(&mut s).unwrap();
-    let a: Vec<u64> = s.split_whitespace().map(|d| d.parse::<u64>().unwrap()).collect();
+    let a: Vec<u64> = s
+        .split_whitespace()
+        .map(|d| d.parse::<u64>().unwrap())
+        .collect();
 
     let mut evenness = vec![];
     for i in a {

solutions/rust/src/bin/313A.rs

@@ -17,7 +17,11 @@ fn main() {
         .chain(balance.chars().skip(balance.len() - 1))
         .collect();
 
-    let options_str: [&str; 3] = [&balance[0..balance.len()-1], &removed, &balance[0..balance.len()]];
+    let options_str: [&str; 3] = [
+        &balance[0..balance.len() - 1],
+        &removed,
+        &balance[0..balance.len()],
+    ];
     let options = options_str.map(|i| i.parse::<i64>().unwrap());
 
     println!("{}", options.iter().max().unwrap());

solutions/rust/src/bin/318A.rs

@@ -4,7 +4,10 @@ fn main() {
     let mut s = String::new();
     io::stdin().read_line(&mut s).unwrap();
 
-    let input = s.split_whitespace().map(|s| s.parse::<u64>().unwrap()).collect::<Vec<u64>>();
+    let input = s
+        .split_whitespace()
+        .map(|s| s.parse::<u64>().unwrap())
+        .collect::<Vec<u64>>();
     let n = input[0];
     let k = input[1];
 

solutions/rust/src/bin/337A.rs

@@ -4,14 +4,20 @@ fn main() {
     let mut s = String::new();
     io::stdin().read_line(&mut s).unwrap();
 
-    let a = s.split_whitespace().map(|s| s.parse::<u64>().unwrap()).collect::<Vec<u64>>();
+    let a = s
+        .split_whitespace()
+        .map(|s| s.parse::<u64>().unwrap())
+        .collect::<Vec<u64>>();
     let n: usize = a[0] as usize;
     let m: usize = a[1] as usize;
 
     let mut s = String::new();
     io::stdin().read_line(&mut s).unwrap();
 
-    let mut f = s.split_whitespace().map(|s| s.parse::<u64>().unwrap()).collect::<Vec<u64>>();
+    let mut f = s
+        .split_whitespace()
+        .map(|s| s.parse::<u64>().unwrap())
+        .collect::<Vec<u64>>();
 
     f.sort();
 
@@ -27,4 +33,3 @@ fn main() {
 
     println!("{}", minimum);
 }
-

solutions/rust/src/bin/339A.rs

@@ -4,7 +4,11 @@ fn main() {
     let mut s = String::new();
     io::stdin().read_line(&mut s).unwrap();
 
-    let mut nums = s.trim().split('+').map(String::from).collect::<Vec<String>>();
+    let mut nums = s
+        .trim()
+        .split('+')
+        .map(String::from)
+        .collect::<Vec<String>>();
 
     nums.sort();
 

solutions/rust/src/bin/34B.rs

@@ -4,13 +4,21 @@ fn main() {
     let mut s = String::new();
     io::stdin().read_line(&mut s).unwrap();
 
-    let a1 = s.trim().split_whitespace().map(|i| i.parse::<i64>().unwrap()).collect::<Vec<i64>>();
+    let a1 = s
+        .trim()
+        .split_whitespace()
+        .map(|i| i.parse::<i64>().unwrap())
+        .collect::<Vec<i64>>();
     let max = a1[1];
 
     let mut s = String::new();
     io::stdin().read_line(&mut s).unwrap();
 
-    let mut a2 = s.trim().split_whitespace().map(|i| i.parse::<i64>().unwrap()).collect::<Vec<i64>>();
+    let mut a2 = s
+        .trim()
+        .split_whitespace()
+        .map(|i| i.parse::<i64>().unwrap())
+        .collect::<Vec<i64>>();
 
     let mut cost = 0;
     let mut count = 0;

solutions/rust/src/bin/405A.rs

@@ -7,11 +7,17 @@ fn main() {
     let mut s = String::new();
     io::stdin().read_line(&mut s).unwrap();
 
-    let mut initial = s.split_whitespace().map(|s| s.parse::<u64>().unwrap()).collect::<Vec<u64>>();
+    let mut initial = s
+        .split_whitespace()
+        .map(|s| s.parse::<u64>().unwrap())
+        .collect::<Vec<u64>>();
 
     initial.sort();
 
-    let output = initial.iter().map(|d| d.to_string()).collect::<Vec<String>>();
+    let output = initial
+        .iter()
+        .map(|d| d.to_string())
+        .collect::<Vec<String>>();
 
     println!("{}", output.join(" "));
 }

solutions/rust/src/bin/451A.rs

@@ -4,7 +4,10 @@ fn main() {
     let mut s = String::new();
     io::stdin().read_line(&mut s).unwrap();
 
-    let a = s.split_whitespace().map(|i| i.parse::<i64>().unwrap()).collect::<Vec<i64>>();
+    let a = s
+        .split_whitespace()
+        .map(|i| i.parse::<i64>().unwrap())
+        .collect::<Vec<i64>>();
     let mut n = a[0];
     let mut m = a[1];
 

solutions/rust/src/bin/466A.rs

@@ -4,7 +4,11 @@ fn main() {
     let mut s = String::new();
     io::stdin().read_line(&mut s).unwrap();
 
-    let inp = s.trim().split_whitespace().map(|i| i.parse::<f64>().unwrap()).collect::<Vec<f64>>();
+    let inp = s
+        .trim()
+        .split_whitespace()
+        .map(|i| i.parse::<f64>().unwrap())
+        .collect::<Vec<f64>>();
 
     let n = inp[0];
     let m = inp[1];

solutions/rust/src/bin/580A.rs

@@ -8,7 +8,10 @@ fn main() {
     let mut s = String::new();
     io::stdin().read_line(&mut s).unwrap();
 
-    let a = s.split_whitespace().map(|n| n.parse::<u64>().unwrap()).collect::<Vec<u64>>();
+    let a = s
+        .split_whitespace()
+        .map(|n| n.parse::<u64>().unwrap())
+        .collect::<Vec<u64>>();
 
     let mut maximum = 1;
     let mut count = 1;

solutions/rust/src/bin/598A.rs

@@ -25,5 +25,4 @@ fn main() {
         println!("{}", total);
         total = 0;
     }
-
 }

solutions/rust/src/bin/791A.rs

@@ -4,7 +4,10 @@ fn main() {
     let mut s = String::new();
     io::stdin().read_line(&mut s).unwrap();
 
-    let a = s.split_whitespace().map(|s| s.parse::<u64>().unwrap()).collect::<Vec<u64>>();
+    let a = s
+        .split_whitespace()
+        .map(|s| s.parse::<u64>().unwrap())
+        .collect::<Vec<u64>>();
     let mut l = a[0];
     let mut b = a[1];