Apply rustfmt

Author: kelvins

src/rust/bogo_sort.rs

@@ -34,7 +34,7 @@ fn bogo_sort(mut lista: Vec<u8>) -> (Vec<u8>, u64) {
     // então para não crashar o programa é bom um range grande
     let mut ciclos: u64 = 0;
     loop {
-        ciclos +=1;
+        ciclos += 1;
         lista.shuffle(&mut rng);
         if verifica_ordem(lista.clone()) {
             return (lista, ciclos);

src/rust/bubble_sort.rs

@@ -1,13 +1,16 @@
 fn bubble_sort(mut slice: Vec<i32>) -> Vec<i32> {
-  for i in 0..slice.len() {
-    for j in 0..slice.len() - 1 - i {
-      if slice[j] > slice[j + 1] {
-        slice.swap(j, j + 1);
-      }
+    for i in 0..slice.len() {
+        for j in 0..slice.len() - 1 - i {
+            if slice[j] > slice[j + 1] {
+                slice.swap(j, j + 1);
+            }
+        }
     }
-  }
-  slice
+    slice
 }
-fn main(){
-  println!("{:?}", bubble_sort(vec![4, 65, 2, -31, 0, 99, 2, 83, 782, 1]));
+fn main() {
+    println!(
+        "{:?}",
+        bubble_sort(vec![4, 65, 2, -31, 0, 99, 2, 83, 782, 1])
+    );
 }

src/rust/busca_binaria.rs

@@ -43,9 +43,9 @@ where
         // o centro não mudou de posição, ou seja, não ha mais valores para verificar
         // e o item não existe
         if *valor_p == valor {
-            return (true, centro)
+            return (true, centro);
         } else if centro == limite_l && centro == limite_r {
-            return (false, 0)
+            return (false, 0);
         }
 
         // O segundo bloco se responsabiliza em verificar a distancia entre o valor recebido
@@ -64,8 +64,11 @@ where
             // Poderia ser feito em uma linha utilizado conversão de tipos e arredondamento
             // porem eu pessoalmente acredito que a performance ganha não vale compensa
 
-            centro = if (limite_r - limite_l) == 1 { centro + 1 }
-                     else { centro + (limite_r - limite_l) / 2 };
+            centro = if (limite_r - limite_l) == 1 {
+                centro + 1
+            } else {
+                centro + (limite_r - limite_l) / 2
+            };
             // Forma em uma linha -
             //     centro = centro + (((limite_r - limite_l) as f32 / 2.0).ceil() as usize);
         }

src/rust/busca_sequencial_recursiva.rs

@@ -21,9 +21,9 @@ fn busca_sequencial_recursiva(lista: &[i32], valor: i32, indice: usize) -> (bool
     // para que o índice chega ao final da lista + 1, logo todos os itens da lista
     // foram percorridos
     if indice == lista.len() {
-        return (false, 0)
+        return (false, 0);
     } else if lista[indice] == valor {
-        return (true, indice)
+        return (true, indice);
     }
 
     // Caso o item atual não seja o item desejado, nos chamamos a função com o índice

src/rust/calculate_pi.rs

@@ -1,21 +1,21 @@
-fn main(){
-  println!("{:?}", calculate_pi(vec![10, 1000, 100000, 10000000]));
+fn main() {
+    println!("{:?}", calculate_pi(vec![10, 1000, 100000, 10000000]));
 }
 fn calculate_pi(terms: Vec<i32>) -> Vec<f64> {
-  let mut denominator: f64;
-  let mut operation: f64;
-  let mut pi: Vec<f64> = Vec::<f64>::new();
+    let mut denominator: f64;
+    let mut operation: f64;
+    let mut pi: Vec<f64> = Vec::<f64>::new();
 
-  for i in 0..terms.len() {
-    denominator = 1.0;
-    operation = 1.0;
-    pi.push(0.0);
-    for _ in 0..terms[i] {
-      let i: usize = i as usize;
-      pi[i] += operation * (4.0 / denominator);
-      denominator += 2.0;
-      operation *= -1.0;
+    for i in 0..terms.len() {
+        denominator = 1.0;
+        operation = 1.0;
+        pi.push(0.0);
+        for _ in 0..terms[i] {
+            let i: usize = i as usize;
+            pi[i] += operation * (4.0 / denominator);
+            denominator += 2.0;
+            operation *= -1.0;
+        }
     }
-  }
-  pi
-}
+    pi
+}

src/rust/deque.rs

@@ -1,58 +1,62 @@
 #[derive(Debug)]
 struct Deque<T> {
-  deque: Vec<T>
+    deque: Vec<T>,
 }
 
 impl<T> Deque<T> {
-  fn new() -> Self {
-    Deque { deque: Vec::new() }
-  }
+    fn new() -> Self {
+        Deque { deque: Vec::new() }
+    }
 
-  fn add_last(&mut self, item: T) {
-    self.deque.push(item)
-  }
+    fn add_last(&mut self, item: T) {
+        self.deque.push(item)
+    }
 
-  fn remove_last(&mut self) -> Option<T> {
-    self.deque.pop()
-  }
+    fn remove_last(&mut self) -> Option<T> {
+        self.deque.pop()
+    }
 
-  fn add_first(&mut self, item: T) {
-    self.deque.insert(0 , item)
-  }
+    fn add_first(&mut self, item: T) {
+        self.deque.insert(0, item)
+    }
 
-  fn remove_first(&mut self) -> T {
-    self.deque.remove(0)
-  }
+    fn remove_first(&mut self) -> T {
+        self.deque.remove(0)
+    }
 
-  fn length(&self) -> usize {
-    self.deque.len()
-  }
+    fn length(&self) -> usize {
+        self.deque.len()
+    }
 
-  fn is_empty(&self) -> bool {
-    self.deque.is_empty()
-  }
+    fn is_empty(&self) -> bool {
+        self.deque.is_empty()
+    }
 
-  fn peek(&self) -> Option<&T> {
-    self.deque.first()
-  }
+    fn peek(&self) -> Option<&T> {
+        self.deque.first()
+    }
 
-  fn peek_last(&self) -> Option<&T> {
-    self.deque.last()
-  } 
+    fn peek_last(&self) -> Option<&T> {
+        self.deque.last()
+    }
 }
 
-fn main(){
-  let mut deque: Deque<i32> = Deque::<i32>::new();
-  deque.add_first(1);
-  deque.add_last(2);
-  deque.add_first(3);
-  println!("{:?}", deque);
-  deque.remove_last();
-  deque.remove_first();
-  println!("{:?}", deque);
-  println!("length: {:?}, is empty? {:?}", deque.length(), deque.is_empty());
-  deque.add_first(1);
-  deque.add_last(2);
-  deque.add_first(3);
-  println!("{:?}, {:?}", deque.peek(), deque.peek_last());
-}
+fn main() {
+    let mut deque: Deque<i32> = Deque::<i32>::new();
+    deque.add_first(1);
+    deque.add_last(2);
+    deque.add_first(3);
+    println!("{:?}", deque);
+    deque.remove_last();
+    deque.remove_first();
+    println!("{:?}", deque);
+    println!(
+        "length: {:?}, is empty? {:?}",
+        deque.length(),
+        deque.is_empty()
+    );
+    deque.add_first(1);
+    deque.add_last(2);
+    deque.add_first(3);
+    println!("{:?}, {:?}", deque.peek(), deque.peek_last());
+}

src/rust/exponentiation_recursive.rs

@@ -1,13 +1,13 @@
-fn main(){
-  println!{"3^3 = {:?}", exponentiation_recursive(3,3)}
-  println!{"3^4 = {:?}", exponentiation_recursive(3,4)}
-  println!{"2^3 = {:?}", exponentiation_recursive(2,3)}
-  println!{"5^2 = {:?}", exponentiation_recursive(5,2)}
+fn main() {
+    println! {"3^3 = {:?}", exponentiation_recursive(3,3)}
+    println! {"3^4 = {:?}", exponentiation_recursive(3,4)}
+    println! {"2^3 = {:?}", exponentiation_recursive(2,3)}
+    println! {"5^2 = {:?}", exponentiation_recursive(5,2)}
 }
 
-fn exponentiation_recursive(base: i32, exponent: i32) -> i32{
-  if exponent <= 1 {
-    return base;
-  }
-  base * exponentiation_recursive(base, exponent - 1)
-}
+fn exponentiation_recursive(base: i32, exponent: i32) -> i32 {
+    if exponent <= 1 {
+        return base;
+    }
+    base * exponentiation_recursive(base, exponent - 1)
+}

src/rust/fatorial.rs

@@ -3,20 +3,20 @@
         - Dromedario de Chapéu
 
     Fatorial é uma função matematica que consistem em realizar
-	a multiplicação de todos os antecessores de um numero.
+    a multiplicação de todos os antecessores de um numero.
 
-	Ex: 5! = 5 * 4 * 3 * 2 * 1 = 120 
+    Ex: 5! = 5 * 4 * 3 * 2 * 1 = 120
 */
 
-// A diferença desta implementação para a com recursão é 
+// A diferença desta implementação para a com recursão é
 // que nesta versão o retorno, é feito utilizado interadores.
 fn fatorial(valor: u128) -> u128 {
     let total = match valor {
-        0  => 1,
+        0 => 1,
         // Product faz a multiplicação de todos os valores em um array
-        1.. => (1..valor+1).product(),
-    };    
-    return total
+        1.. => (1..valor + 1).product(),
+    };
+    return total;
 }
 
 fn main() {
@@ -32,4 +32,4 @@ mod test {
         assert_eq!(fatorial(1), 1);
         assert_eq!(fatorial(10), 3628800);
     }
-}
+}

src/rust/fatorial_recursiva.rs

@@ -1,21 +1,21 @@
 /*
     Contribuidores
-        - Heitor582 
+        - Heitor582
         - Dromedario de Chapéu
 
     Fatorial é uma função matematica que consistem em realizar
-	a multiplicação de todos os antecessores de um numero.
+    a multiplicação de todos os antecessores de um numero.
 
-	Ex: 5! = 5 * 4 * 3 * 2 * 1 = 120 
+    Ex: 5! = 5 * 4 * 3 * 2 * 1 = 120
 */
 
 // Para realizar uma fatoração com recursão basta fazer o retorno
-// de uma função ser valor * a propia função recebendo valor - 1 
+// de uma função ser valor * a propia função recebendo valor - 1
 fn fatorial(valor: u128) -> u128 {
-    // Para que não chege a multiplicar por 0 quando chegamos a 1 ou 0 é 
+    // Para que não chege a multiplicar por 0 quando chegamos a 1 ou 0 é
     // retornado 1 para que o utlimo valor não sejá zerado ao multiplicar por zero
     match valor {
-        0 | 1  => 1,
+        0 | 1 => 1,
         2.. => valor * (fatorial(valor - 1)),
     }
 }

src/rust/fibonacci.rs

@@ -1,12 +1,12 @@
-fn fibonacci(number: i32) -> i32{
+fn fibonacci(number: i32) -> i32 {
     if number < 2 {
-      return number;
-    }else{
-      return fibonacci(number - 1) + fibonacci(number - 2);
+        return number;
+    } else {
+        return fibonacci(number - 1) + fibonacci(number - 2);
     }
-  }
+}
 fn main() {
-  println!("{:?}", fibonacci(3));        
-  println!("{:?}", fibonacci(15));   
-  println!("{:?}", fibonacci(30)); 
+    println!("{:?}", fibonacci(3));
+    println!("{:?}", fibonacci(15));
+    println!("{:?}", fibonacci(30));
 }