Develop

src/homework/hw01.rs

@@ -1,4 +1,30 @@
-#[test]
-fn test1() {
-    assert_eq!(1 + 1, 2);
+const W: usize = 40;
+const H: usize = 20;
+
+fn main() {
+    let mut output = String::new();
+
+    for y in 0..H {
+        for x in 0..W {
+            if y == 0 || y == H - 1 {
+                // Верхній або нижній край
+                output.push('*');
+            } else if x == 0 || x == W - 1 {
+                // Лівий або правий край
+                output.push('*');
+            } else if x * H == y * W {
+                // Діагональ зліва направо
+                output.push('\\');
+            } else if (W - 1 - x) * H == y * W {
+                // Діагональ справа наліво
+                output.push('/');
+            } else {
+                output.push(' ');
+            }
+        }
+        output.push('\n');
+    }
+
+    print!("{}", output);
 }
+

src/homework/hw03.rs

@@ -0,0 +1,30 @@
+const W: usize = 40;
+const H: usize = 20;
+
+fn main() {
+    let mut output = String::new();
+
+    for y in 0..H {
+        for x in 0..W {
+            if y == 0 || y == H - 1 {
+                // Верхній або нижній край
+                output.push('*');
+            } else if x == 0 || x == W - 1 {
+                // Лівий або правий край
+                output.push('*');
+            } else if x * H == y * W {
+                // Діагональ зліва направо
+                output.push('\\');
+            } else if (W - 1 - x) * H == y * W {
+                // Діагональ справа наліво
+                output.push('/');
+            } else {
+                output.push(' ');
+            }
+        }
+        output.push('\n');
+    }
+
+    print!("{}", output);
+}
+

src/homework/hw04.rs

@@ -0,0 +1,25 @@
+const W: usize = 30;
+const H: usize = 15;
+
+fn main() {
+    let mut result = String::new();
+
+    for y in 0..H {
+        for x in 0..W {
+            if y == 0 || y == H - 1 {
+                result.push('*'); // Верхній або нижній край
+            } else if x == 0 || x == W - 1 {
+                result.push('*'); // Лівий або правий край
+            } else if y * (W - 1) == x * (H - 1) {
+                result.push('\\'); // Діагональ зліва направо
+            } else if y * (W - 1) == (W - 1 - x) * (H - 1) {
+                result.push('/'); // Діагональ справа наліво
+            } else {
+                result.push(' ');
+            }
+        }
+        result.push('\n');
+    }
+
+    print!("{}", result);
+}

src/homework/hw05.rs

@@ -0,0 +1,21 @@
+// hw05.rs
+
+fn gcd(a: u32, b: u32) -> u32 {
+  let mut a = a;
+  let mut b = b;
+
+  while b != 0 {
+      let temp = b;
+      b = a % b;
+      a = temp;
+  }
+
+  a
+}
+
+fn main() {
+  let x = 48;
+  let y = 18;
+
+  println!("GCD of {} and {} is {}", x, y, gcd(x, y));
+}

src/homework/hw06.rs

@@ -0,0 +1,23 @@
+const LEVELS: usize = 4; // Кількість трикутників
+
+fn main() {
+    let mut result = String::new();
+
+    (0..LEVELS).for_each(|level| {
+        (0..=level + 2).for_each(|i| {
+            let width = (LEVELS + 2) * 2 - 1;
+            let stars = 1 + i * 2;
+            let spaces = (width - stars) / 2;
+            result += &" ".repeat(spaces);
+            result += &"*".repeat(stars);
+            result += "\n";
+        });
+    });
+
+    // Стовбур
+    let trunk_width = 3;
+    let trunk_height = 2;
+    let total_width = (LEVELS + 2) * 2 - 1;
+    let padding = (total_width - trunk_width) / 2;
+
+    (0..trunk_height_

src/homework/hw07.rs

@@ -0,0 +1,23 @@
+// hw07.rs
+
+fn swap_case(input: &str) -> String {
+  input
+      .chars()
+      .map(|c| {
+          if c.is_lowercase() {
+              c.to_ascii_uppercase()
+          } else if c.is_uppercase() {
+              c.to_ascii_lowercase()
+          } else {
+              c
+          }
+      })
+      .collect()
+}
+
+fn main() {
+  let text = "ПрИвІт, WoRlD!";
+  let swapped = swap_case(text);
+  println!("Original: {}", text);
+  println!("Swapped: {}", swapped);
+}

src/homework/hw08.rs

@@ -0,0 +1,25 @@
+// hw08.rs
+
+fn is_prime(n: u32) -> bool {
+  if n <= 1 {
+      return false;
+  }
+  if n == 2 {
+      return true;
+  }
+  if n % 2 == 0 {
+      return false;
+  }
+  let sqrt_n = (n as f64).sqrt() as u32;
+  for i in (3..=sqrt_n).step_by(2) {
+      if n % i == 0 {
+          return false;
+      }
+  }
+  true
+}
+
+fn main() {
+  let num = 29;
+  println!("Число {} є простим? -> {}", num, is_prime(num));
+}

src/homework/hw09.rs

@@ -0,0 +1,37 @@
+fn rotate(s: String, n: isize) -> String {
+  let len = s.len();
+  if len == 0 {
+      return s;
+  }
+
+  let n = ((n % len as isize) + len as isize) % len as isize;
+  let n = n as usize;
+
+  format!("{}{}", &s[len - n..], &s[..len - n])
+}
+
+// Можна включити тест прямо тут:
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn test() {
+      let s = "abcdefgh".to_string();
+      let shifts = [
+          (0,  "abcdefgh"),
+          (8,  "abcdefgh"),
+          (-8, "abcdefgh"),
+          (1,  "habcdefg"),
+          (2,  "ghabcdef"),
+          (10, "ghabcdef"),
+          (-1, "bcdefgha"),
+          (-2, "cdefghab"),
+          (-10,"cdefghab"),
+      ];
+
+      for (n, expected) in shifts.iter() {
+          assert_eq!(rotate(s.clone(), *n), expected.to_string());
+      }
+  }
+}

src/homework/hw10.rs

@@ -0,0 +1,25 @@
+// hw10.rs
+
+fn is_palindrome(x: u32) -> bool {
+  let s = x.to_string();
+  s.chars().eq(s.chars().rev())
+}
+
+// Тести
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn test() {
+      let data = [
+          (123, false),
+          (121, true),
+          (1221, true),
+      ];
+
+      data.iter().for_each(|(n, exp)| {
+          assert_eq!(is_palindrome(*n), *exp);
+      });
+  }
+}

src/homework/hw11.rs

@@ -0,0 +1,35 @@
+use rand::Rng;
+
+fn gen_random_vector(n: usize) -> Vec<i32> {
+    let mut rng = rand::thread_rng();
+    (0..n).map(|_| rng.gen_range(10..100)).collect()
+}
+
+fn min_adjacent_sum(data: &[i32]) -> (usize, i32) {
+    data.windows(2)
+        .enumerate()
+        .map(|(i, w)| (i, w[0] + w[1]))
+        .min_by_key(|&(_, sum)| sum)
+        .unwrap()
+}
+
+fn print_vector_with_highlight(data: &[i32], min_index: usize) {
+    println!("Згенерований вектор:");
+    for (i, &val) in data.iter().enumerate() {
+        if i == min_index {
+            print!("[{} ", val);
+        } else if i == min_index + 1 {
+            print!("{}] ", val);
+        } else {
+            print!("{} ", val);
+        }
+    }
+    println!();
+}
+
+fn main() {
+    let vec = gen_random_vector(20);
+    let (min_index, min_sum) = min_adjacent_sum(&vec);
+    print_vector_with_highlight(&vec, min_index);
+    println!("Мінімальна сума пари: {} (позиції {} і {})", min_sum, min_index, min_index + 1);
+}

src/homework/hw12.rs

@@ -0,0 +1,45 @@
+use rand::Rng;
+
+/// Підрахунок мінімальної кількості перенесень вантажу
+fn count_permutation(shipments: &Vec<u32>) -> usize {
+    let total: u32 = shipments.iter().sum();
+    let n = shipments.len() as u32;
+
+    if total % n != 0 {
+        panic!("Неможливо рівномірно розподілити вантаж між кораблями");
+    }
+
+    let target = total / n;
+    let mut moves = 0;
+
+    for &ship in shipments {
+        if ship > target {
+            moves += (ship - target) as usize;
+        }
+    }
+
+    moves
+}
+
+/// Генерація коректного вектора вантажів, що можуть бути розподілені рівномірно
+fn gen_shipments(n: usize) -> Vec<u32> {
+    let mut rng = rand::thread_rng();
+    let target = rng.gen_range(10..50);
+    let mut shipments = vec![target; n];
+
+    // випадковим чином зменшимо кілька кораблів, а іншим додамо
+    for i in 0..n / 2 {
+        let delta = rng.gen_range(0..=target.min(10));
+        shipments[i] -= delta;
+        shipments[n - 1 - i] += delta;
+    }
+
+    shipments
+}
+
+fn main() {
+    let shipments = gen_shipments(6);
+    println!("Грузи по кораблях: {:?}", shipments);
+    let moves = count_permutation(&shipments);
+    println!("Мінімальна кількість переміщень: {}", moves);
+}

src/homework/hw13.rs

@@ -0,0 +1,16 @@
+/// Функція для обчислення зайнятої площі в двовимірному масиві
+fn calculate_occupied_area(grid: &[Vec<u8>]) -> usize {
+  grid.iter().flatten().filter(|&&cell| cell == 1).count()
+}
+
+fn main() {
+  let grid = vec![
+      vec![1, 0, 0, 1],
+      vec![0, 1, 1, 0],
+      vec![1, 1, 0, 0],
+      vec![0, 0, 1, 1],
+  ];
+
+  let occupied_area = calculate_occupied_area(&grid);
+  println!("Зайнята площа: {}", occupied_area);
+}

src/homework/hw14.rs

@@ -0,0 +1,39 @@
+// hw14.rs
+
+fn gray(n: u8) -> Vec<String> {
+  let mut result = vec!["".to_string()];
+
+  for i in 0..n {
+      let mut new_codes = Vec::new();
+      for code in result.iter().rev() {
+          new_codes.push(format!("1{}", code));
+      }
+      for code in result.iter() {
+          new_codes.push(format!("0{}", code));
+      }
+      result = new_codes;
+  }
+
+  result
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn test() {
+      let test_data = [
+          (0, vec!("")),
+          (1, vec!("0", "1")),
+          (2, vec!("00", "01", "10", "11")),
+          (3, vec!("000", "001", "010", "011", "100", "101", "110", "111")),
+          (4, vec!("0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111", 
+                   "1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111")),
+      ];
+
+      test_data.iter().for_each(|(n, out)| {
+          assert_eq!(gray(*n), *out);
+      });
+  }
+}