Restructuring Codeforces Solutions and Creating Rust Directory

All Languages/Rust Codes/bfs.rs

@@ -0,0 +1,40 @@
+use std::collections::VecDeque;
+type Graph = Vec<Vec<usize>>;
+
+// BFS
+fn bfs(graph: &Graph, start: usize) -> Vec<usize> {
+    let mut visited = vec![false; graph.len()];
+    let mut queue = VecDeque::new();
+    let mut order = Vec::new();
+
+    visited[start] = true;
+    queue.push_back(start);
+
+    while let Some(node) = queue.pop_front() {
+        order.push(node);
+
+        for &next in &graph[node] {
+            if !visited[next] {
+                visited[next] = true;
+                queue.push_back(next);
+            }
+        }
+    }
+
+    return order;
+
+}
+
+fn main() {
+    let graph = vec![
+        vec![1, 2],
+        vec![0, 3, 4],
+        vec![0, 5],
+        vec![1],
+        vec![1, 5],
+        vec![2, 4],
+    ];
+
+    let order = bfs(&graph, 0);
+    println!("{:?}", order); // [0, 1, 2, 3, 4, 5]
+}

All Languages/Rust Codes/dfs.rs

@@ -0,0 +1,27 @@
+
+
+// DFS
+fn dfs(graph: &Vec<Vec<i32>>, start: i32, visited: &mut Vec<bool>) {
+    visited[start as usize] = true;
+    println!("{}", start);
+    for i in 0..graph[start as usize].len() {
+        if graph[start as usize][i] == 1 && !visited[i] {
+            dfs(graph, i as i32, visited);
+        }
+    }
+}
+
+
+fn main() {
+    let graph = vec![
+        vec![0, 1, 1, 0, 0, 0],
+        vec![1, 0, 0, 1, 1, 0],
+        vec![1, 0, 0, 0, 1, 0],
+        vec![0, 1, 0, 0, 1, 1],
+        vec![0, 1, 1, 1, 0, 1],
+        vec![0, 0, 0, 1, 1, 0],
+    ];
+    let mut visited = vec![false; graph.len()];
+    dfs(&graph, 0, &mut visited);
+}
+

All Languages/Rust Codes/factorial.rs

@@ -0,0 +1,34 @@
+
+
+// Factorial recursive function
+def factorial_recursive(n: i32) -> i32 {
+    if n == 0 {
+        return 1;
+    } else {
+        return n * factorial(n - 1);
+    }
+}
+
+
+
+// Factorial iterative function
+def factorial_iterative(n: i32) -> i32 {
+    let mut result = 1;
+    for i in 1..=n {
+        result *= i;
+    }
+    return result;
+}
+
+
+
+
+
+
+fn main() {
+    // test the factorial_recursive function
+    let n = 5;
+    println!("Recursive Factorial of {} is {}", n, factorial_recursive(n));
+    // test the factorial_iterative function
+    println!("Iterative Factorial of {} is {}", n, factorial_iterative(n));
+}

All Languages/Rust Codes/fibonnaci.rs

@@ -0,0 +1,20 @@
+
+// fibonnaci function
+
+fn fibonnaci(n: u32) -> u32 {
+    if n == 0 {
+        return 0;
+    } else if n == 1 {
+        return 1;
+    } else {
+        return fibonnaci(n - 1) + fibonnaci(n - 2);
+    }
+}
+
+
+
+fn main() {
+    let n = 10;
+    println!("Fibonnaci of {} is {}", n, fibonnaci(n));
+}
+```

All Languages/Rust Codes/quick_sort.rs

@@ -0,0 +1,38 @@
+
+
+// quick sort
+fn quick_sort(arr: &mut [i32]) {
+    let len = arr.len();
+    if len < 2 {
+        return;
+    }
+    let pivot = arr[len / 2];
+    let mut i = 0;
+    let mut j = len - 1;
+    while i <= j {
+        while arr[i] < pivot {
+            i += 1;
+        }
+        while arr[j] > pivot {
+            j -= 1;
+        }
+        if i <= j {
+            arr.swap(i, j);
+            i += 1;
+            j -= 1;
+        }
+    }
+    if 0 < j {
+        quick_sort(&mut arr[0..=j]);
+    }
+    if i < len - 1 {
+        quick_sort(&mut arr[i..]);
+    }
+}
+
+fn main() {
+    let mut arr = [4, 2, 5, 3, 1];
+    quick_sort(&mut arr);
+    println!("{:?}", arr);
+}
+```