Skip to content

Commit ccfdab2

Browse files
kelvinskelvins
committedApr 22, 2023
Apply rustfmt
1 parent 2c75534 commit ccfdab2

20 files changed

+461
-444
lines changed
 

‎src/rust/bogo_sort.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -34,7 +34,7 @@ fn bogo_sort(mut lista: Vec<u8>) -> (Vec<u8>, u64) {
3434
// então para não crashar o programa é bom um range grande
3535
let mut ciclos: u64 = 0;
3636
loop {
37-
ciclos +=1;
37+
ciclos += 1;
3838
lista.shuffle(&mut rng);
3939
if verifica_ordem(lista.clone()) {
4040
return (lista, ciclos);

‎src/rust/bubble_sort.rs

+12-9
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,16 @@
11
fn bubble_sort(mut slice: Vec<i32>) -> Vec<i32> {
2-
for i in 0..slice.len() {
3-
for j in 0..slice.len() - 1 - i {
4-
if slice[j] > slice[j + 1] {
5-
slice.swap(j, j + 1);
6-
}
2+
for i in 0..slice.len() {
3+
for j in 0..slice.len() - 1 - i {
4+
if slice[j] > slice[j + 1] {
5+
slice.swap(j, j + 1);
6+
}
7+
}
78
}
8-
}
9-
slice
9+
slice
1010
}
11-
fn main(){
12-
println!("{:?}", bubble_sort(vec![4, 65, 2, -31, 0, 99, 2, 83, 782, 1]));
11+
fn main() {
12+
println!(
13+
"{:?}",
14+
bubble_sort(vec![4, 65, 2, -31, 0, 99, 2, 83, 782, 1])
15+
);
1316
}

‎src/rust/busca_binaria.rs

+7-4
Original file line numberDiff line numberDiff line change
@@ -43,9 +43,9 @@ where
4343
// o centro não mudou de posição, ou seja, não ha mais valores para verificar
4444
// e o item não existe
4545
if *valor_p == valor {
46-
return (true, centro)
46+
return (true, centro);
4747
} else if centro == limite_l && centro == limite_r {
48-
return (false, 0)
48+
return (false, 0);
4949
}
5050

5151
// O segundo bloco se responsabiliza em verificar a distancia entre o valor recebido
@@ -64,8 +64,11 @@ where
6464
// Poderia ser feito em uma linha utilizado conversão de tipos e arredondamento
6565
// porem eu pessoalmente acredito que a performance ganha não vale compensa
6666

67-
centro = if (limite_r - limite_l) == 1 { centro + 1 }
68-
else { centro + (limite_r - limite_l) / 2 };
67+
centro = if (limite_r - limite_l) == 1 {
68+
centro + 1
69+
} else {
70+
centro + (limite_r - limite_l) / 2
71+
};
6972
// Forma em uma linha -
7073
// centro = centro + (((limite_r - limite_l) as f32 / 2.0).ceil() as usize);
7174
}

‎src/rust/busca_sequencial_recursiva.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -21,9 +21,9 @@ fn busca_sequencial_recursiva(lista: &[i32], valor: i32, indice: usize) -> (bool
2121
// para que o índice chega ao final da lista + 1, logo todos os itens da lista
2222
// foram percorridos
2323
if indice == lista.len() {
24-
return (false, 0)
24+
return (false, 0);
2525
} else if lista[indice] == valor {
26-
return (true, indice)
26+
return (true, indice);
2727
}
2828

2929
// Caso o item atual não seja o item desejado, nos chamamos a função com o índice

‎src/rust/calculate_pi.rs

+17-17
Original file line numberDiff line numberDiff line change
@@ -1,21 +1,21 @@
1-
fn main(){
2-
println!("{:?}", calculate_pi(vec![10, 1000, 100000, 10000000]));
1+
fn main() {
2+
println!("{:?}", calculate_pi(vec![10, 1000, 100000, 10000000]));
33
}
44
fn calculate_pi(terms: Vec<i32>) -> Vec<f64> {
5-
let mut denominator: f64;
6-
let mut operation: f64;
7-
let mut pi: Vec<f64> = Vec::<f64>::new();
5+
let mut denominator: f64;
6+
let mut operation: f64;
7+
let mut pi: Vec<f64> = Vec::<f64>::new();
88

9-
for i in 0..terms.len() {
10-
denominator = 1.0;
11-
operation = 1.0;
12-
pi.push(0.0);
13-
for _ in 0..terms[i] {
14-
let i: usize = i as usize;
15-
pi[i] += operation * (4.0 / denominator);
16-
denominator += 2.0;
17-
operation *= -1.0;
9+
for i in 0..terms.len() {
10+
denominator = 1.0;
11+
operation = 1.0;
12+
pi.push(0.0);
13+
for _ in 0..terms[i] {
14+
let i: usize = i as usize;
15+
pi[i] += operation * (4.0 / denominator);
16+
denominator += 2.0;
17+
operation *= -1.0;
18+
}
1819
}
19-
}
20-
pi
21-
}
20+
pi
21+
}

‎src/rust/deque.rs

+47-43
Original file line numberDiff line numberDiff line change
@@ -1,58 +1,62 @@
11
#[derive(Debug)]
22
struct Deque<T> {
3-
deque: Vec<T>
3+
deque: Vec<T>,
44
}
55

66
impl<T> Deque<T> {
7-
fn new() -> Self {
8-
Deque { deque: Vec::new() }
9-
}
7+
fn new() -> Self {
8+
Deque { deque: Vec::new() }
9+
}
1010

11-
fn add_last(&mut self, item: T) {
12-
self.deque.push(item)
13-
}
11+
fn add_last(&mut self, item: T) {
12+
self.deque.push(item)
13+
}
1414

15-
fn remove_last(&mut self) -> Option<T> {
16-
self.deque.pop()
17-
}
15+
fn remove_last(&mut self) -> Option<T> {
16+
self.deque.pop()
17+
}
1818

19-
fn add_first(&mut self, item: T) {
20-
self.deque.insert(0 , item)
21-
}
19+
fn add_first(&mut self, item: T) {
20+
self.deque.insert(0, item)
21+
}
2222

23-
fn remove_first(&mut self) -> T {
24-
self.deque.remove(0)
25-
}
23+
fn remove_first(&mut self) -> T {
24+
self.deque.remove(0)
25+
}
2626

27-
fn length(&self) -> usize {
28-
self.deque.len()
29-
}
27+
fn length(&self) -> usize {
28+
self.deque.len()
29+
}
3030

31-
fn is_empty(&self) -> bool {
32-
self.deque.is_empty()
33-
}
31+
fn is_empty(&self) -> bool {
32+
self.deque.is_empty()
33+
}
3434

35-
fn peek(&self) -> Option<&T> {
36-
self.deque.first()
37-
}
35+
fn peek(&self) -> Option<&T> {
36+
self.deque.first()
37+
}
3838

39-
fn peek_last(&self) -> Option<&T> {
40-
self.deque.last()
41-
}
39+
fn peek_last(&self) -> Option<&T> {
40+
self.deque.last()
41+
}
4242
}
4343

44-
fn main(){
45-
let mut deque: Deque<i32> = Deque::<i32>::new();
46-
deque.add_first(1);
47-
deque.add_last(2);
48-
deque.add_first(3);
49-
println!("{:?}", deque);
50-
deque.remove_last();
51-
deque.remove_first();
52-
println!("{:?}", deque);
53-
println!("length: {:?}, is empty? {:?}", deque.length(), deque.is_empty());
54-
deque.add_first(1);
55-
deque.add_last(2);
56-
deque.add_first(3);
57-
println!("{:?}, {:?}", deque.peek(), deque.peek_last());
58-
}
44+
fn main() {
45+
let mut deque: Deque<i32> = Deque::<i32>::new();
46+
deque.add_first(1);
47+
deque.add_last(2);
48+
deque.add_first(3);
49+
println!("{:?}", deque);
50+
deque.remove_last();
51+
deque.remove_first();
52+
println!("{:?}", deque);
53+
println!(
54+
"length: {:?}, is empty? {:?}",
55+
deque.length(),
56+
deque.is_empty()
57+
);
58+
deque.add_first(1);
59+
deque.add_last(2);
60+
deque.add_first(3);
61+
println!("{:?}, {:?}", deque.peek(), deque.peek_last());
62+
}

‎src/rust/exponentiation_recursive.rs

+11-11
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,13 @@
1-
fn main(){
2-
println!{"3^3 = {:?}", exponentiation_recursive(3,3)}
3-
println!{"3^4 = {:?}", exponentiation_recursive(3,4)}
4-
println!{"2^3 = {:?}", exponentiation_recursive(2,3)}
5-
println!{"5^2 = {:?}", exponentiation_recursive(5,2)}
1+
fn main() {
2+
println! {"3^3 = {:?}", exponentiation_recursive(3,3)}
3+
println! {"3^4 = {:?}", exponentiation_recursive(3,4)}
4+
println! {"2^3 = {:?}", exponentiation_recursive(2,3)}
5+
println! {"5^2 = {:?}", exponentiation_recursive(5,2)}
66
}
77

8-
fn exponentiation_recursive(base: i32, exponent: i32) -> i32{
9-
if exponent <= 1 {
10-
return base;
11-
}
12-
base * exponentiation_recursive(base, exponent - 1)
13-
}
8+
fn exponentiation_recursive(base: i32, exponent: i32) -> i32 {
9+
if exponent <= 1 {
10+
return base;
11+
}
12+
base * exponentiation_recursive(base, exponent - 1)
13+
}

‎src/rust/fatorial.rs

+8-8
Original file line numberDiff line numberDiff line change
@@ -3,20 +3,20 @@
33
- Dromedario de Chapéu
44
55
Fatorial é uma função matematica que consistem em realizar
6-
a multiplicação de todos os antecessores de um numero.
6+
a multiplicação de todos os antecessores de um numero.
77
8-
Ex: 5! = 5 * 4 * 3 * 2 * 1 = 120
8+
Ex: 5! = 5 * 4 * 3 * 2 * 1 = 120
99
*/
1010

11-
// A diferença desta implementação para a com recursão é
11+
// A diferença desta implementação para a com recursão é
1212
// que nesta versão o retorno, é feito utilizado interadores.
1313
fn fatorial(valor: u128) -> u128 {
1414
let total = match valor {
15-
0 => 1,
15+
0 => 1,
1616
// Product faz a multiplicação de todos os valores em um array
17-
1.. => (1..valor+1).product(),
18-
};
19-
return total
17+
1.. => (1..valor + 1).product(),
18+
};
19+
return total;
2020
}
2121

2222
fn main() {
@@ -32,4 +32,4 @@ mod test {
3232
assert_eq!(fatorial(1), 1);
3333
assert_eq!(fatorial(10), 3628800);
3434
}
35-
}
35+
}

‎src/rust/fatorial_recursiva.rs

+6-6
Original file line numberDiff line numberDiff line change
@@ -1,21 +1,21 @@
11
/*
22
Contribuidores
3-
- Heitor582
3+
- Heitor582
44
- Dromedario de Chapéu
55
66
Fatorial é uma função matematica que consistem em realizar
7-
a multiplicação de todos os antecessores de um numero.
7+
a multiplicação de todos os antecessores de um numero.
88
9-
Ex: 5! = 5 * 4 * 3 * 2 * 1 = 120
9+
Ex: 5! = 5 * 4 * 3 * 2 * 1 = 120
1010
*/
1111

1212
// Para realizar uma fatoração com recursão basta fazer o retorno
13-
// de uma função ser valor * a propia função recebendo valor - 1
13+
// de uma função ser valor * a propia função recebendo valor - 1
1414
fn fatorial(valor: u128) -> u128 {
15-
// Para que não chege a multiplicar por 0 quando chegamos a 1 ou 0 é
15+
// Para que não chege a multiplicar por 0 quando chegamos a 1 ou 0 é
1616
// retornado 1 para que o utlimo valor não sejá zerado ao multiplicar por zero
1717
match valor {
18-
0 | 1 => 1,
18+
0 | 1 => 1,
1919
2.. => valor * (fatorial(valor - 1)),
2020
}
2121
}

‎src/rust/fibonacci.rs

+8-8
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,12 @@
1-
fn fibonacci(number: i32) -> i32{
1+
fn fibonacci(number: i32) -> i32 {
22
if number < 2 {
3-
return number;
4-
}else{
5-
return fibonacci(number - 1) + fibonacci(number - 2);
3+
return number;
4+
} else {
5+
return fibonacci(number - 1) + fibonacci(number - 2);
66
}
7-
}
7+
}
88
fn main() {
9-
println!("{:?}", fibonacci(3));
10-
println!("{:?}", fibonacci(15));
11-
println!("{:?}", fibonacci(30));
9+
println!("{:?}", fibonacci(3));
10+
println!("{:?}", fibonacci(15));
11+
println!("{:?}", fibonacci(30));
1212
}

‎src/rust/fila.rs

+34-30
Original file line numberDiff line numberDiff line change
@@ -1,41 +1,45 @@
11
#[derive(Debug)]
22
struct Fila<T> {
3-
fila: Vec<T>
3+
fila: Vec<T>,
44
}
55

66
impl<T> Fila<T> {
7-
fn new() -> Self {
8-
Fila { fila: Vec::new() }
9-
}
7+
fn new() -> Self {
8+
Fila { fila: Vec::new() }
9+
}
1010

11-
fn length(&self) -> usize {
12-
self.fila.len()
13-
}
11+
fn length(&self) -> usize {
12+
self.fila.len()
13+
}
1414

15-
fn enqueue(&mut self, item: T) {
16-
self.fila.push(item)
17-
}
15+
fn enqueue(&mut self, item: T) {
16+
self.fila.push(item)
17+
}
1818

19-
fn dequeue(&mut self) -> T {
20-
self.fila.remove(0)
21-
}
22-
fn is_empty(&self) -> bool {
23-
self.fila.is_empty()
24-
}
19+
fn dequeue(&mut self) -> T {
20+
self.fila.remove(0)
21+
}
22+
fn is_empty(&self) -> bool {
23+
self.fila.is_empty()
24+
}
2525

26-
fn peek(&self) -> Option<&T> {
27-
self.fila.first()
28-
}
26+
fn peek(&self) -> Option<&T> {
27+
self.fila.first()
28+
}
2929
}
3030

31-
fn main(){
32-
let mut fila: Fila<i32> = Fila::<i32>::new();
33-
fila.enqueue(1);
34-
println!("{:?}", fila);
35-
fila.dequeue();
36-
println!("length: {:?}, is empty? {:?}", fila.length(), fila.is_empty());
37-
fila.enqueue(1);
38-
fila.enqueue(2);
39-
fila.enqueue(3);
40-
println!("{:?}", fila.peek());
41-
}
31+
fn main() {
32+
let mut fila: Fila<i32> = Fila::<i32>::new();
33+
fila.enqueue(1);
34+
println!("{:?}", fila);
35+
fila.dequeue();
36+
println!(
37+
"length: {:?}, is empty? {:?}",
38+
fila.length(),
39+
fila.is_empty()
40+
);
41+
fila.enqueue(1);
42+
fila.enqueue(2);
43+
fila.enqueue(3);
44+
println!("{:?}", fila.peek());
45+
}

‎src/rust/gnomesort.rs

+16-16
Original file line numberDiff line numberDiff line change
@@ -1,20 +1,20 @@
1-
fn main(){
2-
println!("{:?}", gnomesort(vec![1,3,5,2]));
1+
fn main() {
2+
println!("{:?}", gnomesort(vec![1, 3, 5, 2]));
33
}
44
fn gnomesort(mut slice: Vec<i32>) -> Vec<i32> {
5-
let mut pivot: i32 = 0;
6-
let size: i32 = slice.len() as i32;
5+
let mut pivot: i32 = 0;
6+
let size: i32 = slice.len() as i32;
77

8-
while pivot < size - 1 {
9-
if slice[pivot as usize] > slice[pivot as usize + 1] {
10-
let temp: i32 = slice[pivot as usize];
11-
slice[pivot as usize] = slice[pivot as usize + 1];
12-
slice[pivot as usize + 1] = temp;
13-
if pivot > 0 {
14-
pivot -= 2;
15-
}
8+
while pivot < size - 1 {
9+
if slice[pivot as usize] > slice[pivot as usize + 1] {
10+
let temp: i32 = slice[pivot as usize];
11+
slice[pivot as usize] = slice[pivot as usize + 1];
12+
slice[pivot as usize + 1] = temp;
13+
if pivot > 0 {
14+
pivot -= 2;
15+
}
16+
}
17+
pivot += 1;
1618
}
17-
pivot += 1;
18-
}
19-
slice
20-
}
19+
slice
20+
}

‎src/rust/grafo.rs

+209-209
Large diffs are not rendered by default.

‎src/rust/insertion_sort.rs

+9-9
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,13 @@
1-
fn main(){
2-
println!{"{:?}", insertion_sort(vec![54,42,11,33,24,99,77,80])};
1+
fn main() {
2+
println! {"{:?}", insertion_sort(vec![54,42,11,33,24,99,77,80])};
33
}
44
fn insertion_sort(mut vetor: Vec<i32>) -> Vec<i32> {
5-
for i in 1..vetor.len() {
6-
let mut index: i32 = i as i32;
7-
while index > 0 && vetor[index as usize] < vetor[index as usize - 1] {
8-
vetor.swap(index as usize, index as usize - 1);
9-
index -= 1;
5+
for i in 1..vetor.len() {
6+
let mut index: i32 = i as i32;
7+
while index > 0 && vetor[index as usize] < vetor[index as usize - 1] {
8+
vetor.swap(index as usize, index as usize - 1);
9+
index -= 1;
10+
}
1011
}
11-
}
12-
vetor
12+
vetor
1313
}

‎src/rust/min_max_iterativo.rs

+4-4
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
fn main() {
2-
min_max(vec![54,42,11,33,24,99,77,80]);
2+
min_max(vec![54, 42, 11, 33, 24, 99, 77, 80]);
33
}
44

55
fn min_max(vetor: Vec<i32>) {
@@ -14,7 +14,7 @@ fn min_max(vetor: Vec<i32>) {
1414
}
1515
}
1616

17-
println!{"Data: {:?}", vetor};
18-
println!{"Min.: {:?}", min};
19-
println!{"Max.: {:?}", max};
17+
println! {"Data: {:?}", vetor};
18+
println! {"Min.: {:?}", min};
19+
println! {"Max.: {:?}", max};
2020
}

‎src/rust/min_max_recursivo.rs

+4-4
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
fn main() {
2-
let vetor = vec![54,42,11,33,24,99,77,80];
2+
let vetor = vec![54, 42, 11, 33, 24, 99, 77, 80];
33
min_max(vetor, i32::MAX, i32::MIN, 0);
44
}
55

@@ -13,8 +13,8 @@ fn min_max(vetor: Vec<i32>, mut min: i32, mut max: i32, indice: usize) {
1313
if indice < vetor.len() - 1 {
1414
min_max(vetor, min, max, indice + 1);
1515
} else {
16-
println!{"Data: {:?}", vetor};
17-
println!{"Min.: {:?}", min};
18-
println!{"Max.: {:?}", max};
16+
println! {"Data: {:?}", vetor};
17+
println! {"Min.: {:?}", min};
18+
println! {"Max.: {:?}", max};
1919
}
2020
}

‎src/rust/pilha.rs

+34-30
Original file line numberDiff line numberDiff line change
@@ -1,42 +1,46 @@
11
#[derive(Debug)]
22
struct Pilha<T> {
3-
pilha: Vec<T>
3+
pilha: Vec<T>,
44
}
55

66
impl<T> Pilha<T> {
7-
fn new() -> Self {
8-
Pilha { pilha: Vec::new() }
9-
}
7+
fn new() -> Self {
8+
Pilha { pilha: Vec::new() }
9+
}
1010

11-
fn length(&self) -> usize {
12-
self.pilha.len()
13-
}
11+
fn length(&self) -> usize {
12+
self.pilha.len()
13+
}
1414

15-
fn push(&mut self, item: T) {
16-
self.pilha.push(item)
17-
}
15+
fn push(&mut self, item: T) {
16+
self.pilha.push(item)
17+
}
1818

19-
fn pop(&mut self) -> Option<T> {
20-
self.pilha.pop()
21-
}
22-
23-
fn is_empty(&self) -> bool {
24-
self.pilha.is_empty()
25-
}
19+
fn pop(&mut self) -> Option<T> {
20+
self.pilha.pop()
21+
}
2622

27-
fn peek(&self) -> Option<&T> {
28-
self.pilha.first()
29-
}
23+
fn is_empty(&self) -> bool {
24+
self.pilha.is_empty()
25+
}
26+
27+
fn peek(&self) -> Option<&T> {
28+
self.pilha.first()
29+
}
3030
}
3131

3232
fn main() {
33-
let mut pilha: Pilha<i32> = Pilha::<i32>::new();
34-
pilha.push(1);
35-
pilha.push(2);
36-
println!("{:?}", pilha);
37-
pilha.pop();
38-
println!("{:?}", pilha);
39-
println!("length: {:?}, is empty? {:?}", pilha.length(), pilha.is_empty());
40-
pilha.push(3);
41-
println!("{:?}", pilha.peek());
42-
}
33+
let mut pilha: Pilha<i32> = Pilha::<i32>::new();
34+
pilha.push(1);
35+
pilha.push(2);
36+
println!("{:?}", pilha);
37+
pilha.pop();
38+
println!("{:?}", pilha);
39+
println!(
40+
"length: {:?}, is empty? {:?}",
41+
pilha.length(),
42+
pilha.is_empty()
43+
);
44+
pilha.push(3);
45+
println!("{:?}", pilha.peek());
46+
}

‎src/rust/quick_sort.rs

+18-19
Original file line numberDiff line numberDiff line change
@@ -2,19 +2,19 @@
22
33
Contribuidores
44
- Dromedario de chapeu
5-
6-
O Quick Sort, é um dos algoritmos de ordenação padrões de se estudar.
5+
6+
O Quick Sort, é um dos algoritmos de ordenação padrões de se estudar.
77
Ele é famoso por ser relativamente eficiente na maioria dos casos, tendo
88
complexidade O(n log n). Porem em casos específicos ele pode chegar a ser
99
O(n²) nos piores casos, como a lista estar basicamente invertida por exemplo.
1010
O Quick Sort adota a estrategia de "dividir e conquistar", que é resumidamente
1111
dividir a lista em sub 2 listas e organizar essas sub listas. A cada execução
1212
é escolhido o Pivot, e a partir deste Pivot nos comparamos todos os elementos
13-
da lista ate encontrar algum valor menor ou igual ao pivot, quando encontrarmos
14-
este valor, ele é colocado a frente do pivot. Quando passarmos por toda a
15-
lista, nos fazemos o swap entre o pivot e o ultimo índice que foi coloca a sua
16-
frene, assim nos teremos a garantia de que todos os itens a esquerda do pivot
17-
sejam menores, e os a direita maiores. E assim nos pegamos essas 2 novas listas,
13+
da lista ate encontrar algum valor menor ou igual ao pivot, quando encontrarmos
14+
este valor, ele é colocado a frente do pivot. Quando passarmos por toda a
15+
lista, nos fazemos o swap entre o pivot e o ultimo índice que foi coloca a sua
16+
frene, assim nos teremos a garantia de que todos os itens a esquerda do pivot
17+
sejam menores, e os a direita maiores. E assim nos pegamos essas 2 novas listas,
1818
e fazemos o mesmo processo.
1919
2020
Recomendo dar uma olhada mais profunda sobre o funcionado e casos específicos,
@@ -25,7 +25,6 @@
2525
2626
*/
2727

28-
2928
// l = limite esquerdo
3029
// r = limite direito
3130
// É preciso indicar esses valores invés de gerar uma nova lista a cada divisão
@@ -38,18 +37,18 @@ fn partition(lista: &mut [i32], l: usize, r: usize) -> isize {
3837
// Para colocarmos os valores menores ou iguais ao pivot na sua frente
3938
// precisamos de uma variável pra contar quantos índices a frente colocar
4039
// o novo valor a frente, para não ficarmos trocando o mesmo valor
41-
let mut count = l;
40+
let mut count = l;
4241

4342
// For para fazer interação na lista. Não usamos enumerate pois precisamso
4443
// simular as sub listas
45-
for j in l + 1..r + 1 {
44+
for j in l + 1..r + 1 {
4645
if lista[j] <= pivot {
47-
count += 1;
48-
lista.swap(count, j);
46+
count += 1;
47+
lista.swap(count, j);
4948
}
5049
}
5150

52-
// Trocamos o índice de pivot de lugar com o ultimo menor/igual valor, pois
51+
// Trocamos o índice de pivot de lugar com o ultimo menor/igual valor, pois
5352
lista.swap(l, count);
5453

5554
// O índice onde apos a troca se encontra o Pivot é retornado, para que sirva
@@ -58,14 +57,14 @@ fn partition(lista: &mut [i32], l: usize, r: usize) -> isize {
5857
return count as isize;
5958
}
6059

61-
fn quick_sort(lista: &mut [i32], l: isize, r: isize) {
60+
fn quick_sort(lista: &mut [i32], l: isize, r: isize) {
6261
// A condição de parda da recuroa é caso tanto o extremo direito quanto esquerdo
6362
// sejam iguais, ou sejá, a lista so tem 1 elemento
6463
if l < r {
6564
let indice_pivot = partition(lista, l as usize, r as usize);
6665
quick_sort(lista, l, indice_pivot - 1);
6766
quick_sort(lista, indice_pivot + 1, r);
68-
}
67+
}
6968
}
7069

7170
fn printa(lista: Vec<i32>) {
@@ -79,9 +78,9 @@ fn main() {
7978
let mut lista = vec![1, 6, 3, 9, 3, 8, 5, 2, 7];
8079
let len = lista.len() as isize;
8180

82-
printa(lista.clone());
81+
printa(lista.clone());
8382
quick_sort(&mut lista, 0, len - 1);
84-
printa(lista.clone());
83+
printa(lista.clone());
8584
}
8685

8786
#[cfg(test)]
@@ -93,11 +92,11 @@ mod test {
9392
let mut lista = vec![9, 8, 7, 6, 5, 4, 3, 2, 1];
9493
let len = lista.len() as isize - 1;
9594
quick_sort(&mut lista, 0, len);
96-
assert_eq!(vec![1,2,3,4,5,6,7,8,9], lista);
95+
assert_eq!(vec![1, 2, 3, 4, 5, 6, 7, 8, 9], lista);
9796

9897
let mut lista = vec![1, 2, 3, 4, 5, 6, 7, 8, 9];
9998
let len = lista.len() as isize - 1;
10099
quick_sort(&mut lista, 0, len);
101100
assert_eq!(vec![1, 2, 3, 4, 5, 6, 7, 8, 9], lista);
102101
}
103-
}
102+
}

‎src/rust/soma_dois_numeros.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@ fn existe_soma(lista: &[i32], x: i32) -> bool {
1515

1616
fn main() {
1717
let lista = vec![1, 2, 3, 4, 5, 6, 7, 8];
18-
println!("{}", existe_soma(&lista, 3));
18+
println!("{}", existe_soma(&lista, 3));
1919
}
2020

2121
#[cfg(test)]
@@ -24,7 +24,7 @@ mod test {
2424
#[test]
2525
fn t_exite_soma() {
2626
let lista = vec![1, 2, 3, 4, 5, 6, 7, 8];
27-
27+
2828
assert_eq!(existe_soma(&lista, 3), true);
2929
assert_eq!(existe_soma(&lista, 5), true);
3030
assert_eq!(existe_soma(&lista, 7), true);
@@ -34,4 +34,4 @@ mod test {
3434
assert_eq!(existe_soma(&lista, 2), false);
3535
assert_eq!(existe_soma(&lista, 16), false);
3636
}
37-
}
37+
}

‎src/rust/torre_hanoi.rs

+11-11
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,12 @@
1-
fn torre_hanoi(pin0: i32, pin2: i32, pin1: i32, num: i32){
2-
if num == 1{
3-
println!("Move from {} to {}", pin0, pin2)
4-
}else{
5-
torre_hanoi(pin0, pin1, pin2, num - 1);
6-
torre_hanoi(pin0, pin2, pin1, 1);
7-
torre_hanoi(pin1, pin2, pin0, num - 1);
8-
}
1+
fn torre_hanoi(pin0: i32, pin2: i32, pin1: i32, num: i32) {
2+
if num == 1 {
3+
println!("Move from {} to {}", pin0, pin2)
4+
} else {
5+
torre_hanoi(pin0, pin1, pin2, num - 1);
6+
torre_hanoi(pin0, pin2, pin1, 1);
7+
torre_hanoi(pin1, pin2, pin0, num - 1);
8+
}
9+
}
10+
fn main() {
11+
torre_hanoi(0, 2, 1, 3);
912
}
10-
fn main(){
11-
torre_hanoi(0,2,1,3);
12-
}

0 commit comments

Comments
 (0)
Please sign in to comment.