Pequenas correcoes nas docstrings (rust)

Author: kelvins

src/rust/bogo_sort.rs

@@ -1,12 +1,12 @@
-/* 
+/*
     Contribuidores
         - Dromedario de Chapéu
-  
-    O Bogo Sort é um algoritmo feito apenas como uma piada, feito 
-    o pior e mais demorado algoritmo de ordenação. Tudo que ele faz
+
+    O Bogo Sort é um algoritmo feito apenas como uma piada, sendo
+    o pior e mais demorado algoritmo de ordenação. Tudo o que ele faz
     é pegar uma lista, randomizar os seus itens, e verificar se todos
-    os itens estão ordenados. Logo se tor 100% aleatório, o que pode
-    fazer com que demore mais de 1 milhão de tentativas ate ser ordenado,
+    os itens estão ordenados. Logo, ele é 100% aleatório, o que pode
+    fazer com que demore mais de 1 milhão de tentativas até ser ordenado,
     ou que simplesmente na primeira tentativa ele seja ordenado.
 
 */
@@ -24,25 +24,25 @@ fn verifica_ordem(lista: Vec<u8>) -> bool {
     return true;
 }
 
-// Vec<u8> significa que o parâmetro "lista" é uma lista de 
+// Vec<u8> significa que o parâmetro "lista" é uma lista de
 // inteiros sem sinal de 8 bits. E o retorno u64 se refere
 // ao total de ciclos necessários para realizar a ordenação
 fn bogo_sort(mut lista: Vec<u8>) -> (Vec<u8>, u64) {
     let mut rng = thread_rng();
-    // Foi escolhido um limite tão grande justamente pelo bogo sort 
-    // poder ser tanto o algoritmo mais rápido quanto o mais lento, 
+    // Foi escolhido um limite tão grande justamente pelo bogo sort
+    // poder ser tanto o algoritmo mais rápido quanto o mais lento,
     // então para não crashar o programa é bom um range grande
     let mut ciclos: u64 = 0;
     loop {
         ciclos +=1;
         lista.shuffle(&mut rng);
         if verifica_ordem(lista.clone()) {
             return (lista, ciclos);
-        } 
+        }
     }
 }
 
-// O valor de u8 para os itens da lista é apenas para 
+// O valor de u8 para os itens da lista é apenas para
 // gerar números muito grandes e dificultar na visualização
 fn gera_lista(len: u8) -> Vec<u8> {
     let mut rng = thread_rng();
@@ -86,4 +86,4 @@ mod test {
         let (ordenada, _) = bogo_sort(desordenada);
         assert_eq!(ordenada, vec![1, 2, 3, 4, 5, 6]);
     }
-}
+}

src/rust/busca_binaria.rs

@@ -1,46 +1,46 @@
-/* 
+/*
     Contribuidores
         - Dromedario de Chapéu
-   
+
         O que é busca Binaria -
-    "A busca binária é um eficiente algoritmo para encontrar um item em uma lista 
-    ordenada de itens. Ela funciona dividindo repetidamente pela metade a porção da 
-    lista que deve conter o item, até reduzir as localizações possíveis a apenas uma. 
+    "A busca binária é um eficiente algoritmo para encontrar um item em uma lista
+    ordenada de itens. Ela funciona dividindo repetidamente pela metade a porção da
+    lista que deve conter o item, até reduzir as localizações possíveis a apenas uma.
     Nós usamos a busca binária em um jogo de adivinhação no tutorial introdutório."
         - Khan Academy : https://pt.khanacademy.org/computing/computer-science/algorithms/binary-search/a/binary-search
 */
 
 // O <T> em Rust indica que não se espera tipo especifico e sim qualquer tipo
 // no caso o T é usado para indicar o tipo dos valores da lista e o valor a ser
 // procurado.
-fn busca_binaria<T>(lista: &[T], valor: T) -> (bool, usize) 
+fn busca_binaria<T>(lista: &[T], valor: T) -> (bool, usize)
 where
     // É preciso especificar que T implementa as Traits PartialEq e PartialOrd para
     // indicar que T pode ser comparado T e que possui uma ordem de maior e menor
-    T: PartialEq,   
+    T: PartialEq,
     T: PartialOrd,
 {
     // Centro indica o centro a lista ou sublista
-    let mut centro = lista.len() / 2;   
-    
+    let mut centro = lista.len() / 2;
+
     // Limite_r representa o maior indice possível, referente ao extremo direito
-    // da lista atual, serve para dividir a lista original sem precisar ficar 
+    // da lista atual, serve para dividir a lista original sem precisar ficar
     // clonando ou literalmente dividindo. Seria o [-1] da sublista
-    let mut limite_r = lista.len() - 1; 
-    
-    // Limite_l representa o mesmo que Limite_r porem para o extremo esquerdo, 
-    // ou sejá, o [0] da sub lista.
+    let mut limite_r = lista.len() - 1;
+
+    // Limite_l representa o mesmo que Limite_r porem para o extremo esquerdo,
+    // ou seja, o [0] da sub lista.
     let mut limite_l = 0;
 
     loop {
-        // O valor esta sendo passado por referencia e depois acessado pelo seu 
-        // ponteiro pelo sistema de owenrship o Rust, isso pode feito com atribuição
+        // O valor esta sendo passado por referencia e depois acessado pelo seu
+        // ponteiro pelo sistema de ownership o Rust, isso pode feito com atribuição
         // simples como `valor_p = lista[centro]` em um Python por exemplo
-        let valor_p = &lista[centro]; 
+        let valor_p = &lista[centro];
 
         // O primeiro bloco de if se responsabiliza em verificar se o valor que estamos
         // buscado foi encontrado, caso não ele verifica da ultima operação para esta
-        // o centro não mudou de posição, ou sejá, não ha mais valores para verificar
+        // 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)
@@ -52,19 +52,19 @@ where
         // e o atual valor_p, caso seja valor_p seja maior, significa que o valor procurado
         // esta mais para trás, e o centro é movido para o centro da sub lista anterior.
         // Porem caso valor seja maior que o valor_p, significa que precisamos mover o centro
-        // para o centro da sub lista superiors 
+        // para o centro da sub lista superiors
         if *valor_p > valor {
-            limite_r = centro; 
+            limite_r = centro;
             centro = centro / 2;
         } else if *valor_p < valor {
             limite_l = centro;
             // O If esta verificando se o espaço entre limite_r e limite_l é igual a 1
-            // pois a operação de padrão usada daria o resultado de 0 nesse caso, pois 
+            // pois a operação de padrão usada daria o resultado de 0 nesse caso, pois
             // Rust arredonda os valores para baixo, logo 0.5 é jogado para 0
-            // Poderia ser feito em uma linha utilizado conversão de tipos e arredondamento  
+            // 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 } 
+
+            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);
@@ -82,13 +82,13 @@ fn main() {
 mod test {
     use super::*;
 
-    #[test] 
+    #[test]
     fn busca() {
-        let lista = vec![-3, -2, -1, 0, 1, 2, 3];        
+        let lista = vec![-3, -2, -1, 0, 1, 2, 3];
         assert_eq!(busca_binaria(&lista, -7), (false, 0));
         assert_eq!(busca_binaria(&lista, -2), (true, 1));
         assert_eq!(busca_binaria(&lista, 0), (true, 3));
         assert_eq!(busca_binaria(&lista, 2), (true, 5));
         assert_eq!(busca_binaria(&lista, 7), (false, 0));
     }
-}
+}

src/rust/busca_sequencial.rs

@@ -1,24 +1,24 @@
-/* 
+/*
     Contribuidores
         - Dromedario de Chapéu
-    
-    Busca Sequencial é o mais simples algoritmo de busca possessive, alem de 
-    ser um dos menos eficientes. Ele simplesmente itera por todos os itens 
-    de uma lista ate encontrar o valor desejado ou atingir o final da lista
+
+    Busca Sequencial é o mais simples algoritmo de busca possessive, alem de
+    ser um dos menos eficientes. Ele simplesmente itera por todos os itens
+    de uma lista até encontrar o valor desejado ou atingir o final da lista
     retornando que o elemento não esta presente na lista.
 
-    Esse algorítimo pode ser útil para listas pequenas de algumas poucas centenas
-    de valores de tipo simples, porem mais que isso ele sera um grande gargalo 
+    Esse algoritmo pode ser útil para listas pequenas de algumas poucas centenas
+    de valores de tipo simples, porem mais que isso ele sera um grande gargalo
     durante a execução do programa.
 
-    Uma possível vantagem deste algoritmo, é que ele independe da lista esta
-    ordenada para funcionar. Pois ele não se importa com a ordem dos elementos.
+    Uma possível vantagem deste algoritmo, é que ele independe da lista estar
+    ordenada para funcionar, pois ele não se importa com a ordem dos elementos.
 */
 fn busca_sequencial(lista: &[i32], valor: i32) -> (bool, usize) {
     for (i, c) in lista.iter().enumerate() {
         if *c == valor {
             return (true, i);
-        } 
+        }
     }
     return (false, 0);
 }
@@ -39,4 +39,4 @@ mod test {
         assert_eq!(busca_sequencial(&lista, 2), (true, 1));
         assert_eq!(busca_sequencial(&lista, 0), (false, 0));
     }
-}
+}

src/rust/busca_sequencial_recursiva.rs

@@ -1,16 +1,16 @@
-/* 
+/*
     Contribuidores
         - Dromedário de Chapéu
-   
+
     A Busca Sequencial Recursiva consiste do mesmo conceito da Busca Sequencial.
-    A diferente é que invés de iterar na lista utilizando um for por exemplo,
+    A diferença é que ao invés de iterar na lista utilizando um for por exemplo,
     é utilizado recursão que é resumidamente uma função que se chama N vezes com
     mudanças no seus parâmetros te atingir ou o resultado desejado, ou um estado
     onde não ha mais o que fazer.
 
     Essa implementação é ainda mais lenta e custosa que a forma utilizando for,
     pois recursão utiliza muito mais memoria e processamento para ser utilizada, para
-    poucos itens na pratica ele vai ser tão rápido quanto qualquer outro algoritmo. 
+    poucos itens na pratica ele vai ser tão rápido quanto qualquer outro algoritmo.
     Porem caso seja uma lista de milhares de itens este algoritmo sera um problema.
 */
 
@@ -24,8 +24,8 @@ fn busca_sequencial_recursiva(lista: &[i32], valor: i32, indice: usize) -> (bool
         return (false, 0)
     } else if lista[indice] == valor {
         return (true, indice)
-    }    
-    
+    }
+
     // Caso o item atual não seja o item desejado, nos chamamos a função com o índice
     // acrescentado, para que na próxima execução da função seja verificado o próximo
     // item da lista
@@ -48,4 +48,4 @@ mod test {
         assert_eq!(busca_sequencial_recursiva(&lista, 2, 0), (true, 1));
         assert_eq!(busca_sequencial_recursiva(&lista, 0, 0), (false, 0));
     }
-}
+}