Reorganized solutions by topic; sqrt, set-bits, reverse-bits, add-binary

Author: OmnicWolf

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "leetcode_rust"
-version = "0.1.0"
+version = "0.2.4"
 edition = "2021"
 authors = ["Ryo Light <[email protected]>"]
 

Cargo.toml

@@ -1 +1,26 @@
-# Leetcode Solutions in Rust
+# LeetCode Solutions in Rust
+
+- Leetcode Profile - [OmnicWolf | Leetcode](https://leetcode.com/OmnicWolf/)
+- Solutions Visualized – [@CoffeelessProgrammer | Instagram](https://www.instagram.com/coffeelessprogrammer/)
+
+## Environment
+- <span>Rust v1.72.1</span>
+
+## Problems Completed
+
+### By Topic
+
+- **Math**
+  - <span>69. Sqrt(x)</span>
+- **Bit Manipulation**
+  - <span>190. Reverse Bits</span>
+  - <span>191. Number of 1 Bits</span>
+- **Strings**
+  - <span>67. Add Binary</span>
+
+## Resources
+
+- Solutions in Java – [CoffeelessProgrammer/leetcode-java](https://github.com/CoffeelessProgrammer/leetcode-java)
+- Solutions in C# – [OmnicWolf/leetcode-csharp](https://github.com/OmnicWolf/leetcode-csharp)
+- Solutions in TypeScript – [Ryo112358/leetcode-typescript](https://github.com/Ryo112358/leetcode-typescript)
+- Interview Prep Resources Curated by Koi Creek – [koicreek/interview-prep](https://github.com/koicreek/interview-prep)

Readme.md

@@ -0,0 +1,2 @@
+pub fn run() {
+}

src/array/mod.rs

@@ -0,0 +1,39 @@
+/*
+ * Problem: 191. Number of 1 Bits (Easy)
+ * URL: https://leetcode.com/problems/number-of-1-bits/
+ *
+ * Runtime: 0 ms (100%)
+ * Memory Usage: 1.93 MB (91.44%)
+ */
+
+pub fn solve(mut n: u32) -> i32 {
+  let mut set_bits = 0;
+
+  while n > 0 {
+    n &= n-1;
+    set_bits += 1;
+  }
+
+  return set_bits;
+}
+
+
+#[cfg(test)]
+mod hamming_weight_tests {
+  use super::*;
+
+  #[test]
+  fn happy_path() {
+    assert_eq!(solve(0b000110010), 3);
+  }
+
+  #[test]
+  fn none_set() {
+    assert_eq!(solve(0b000000000), 0);
+  }
+
+  #[test]
+  fn all_set() {
+    assert_eq!(solve(0b11111111_11111111_11111111_11111111), 32);
+  }
+}

src/bit_manipulation/count_set_bits.rs

@@ -0,0 +1,5 @@
+pub mod count_set_bits;
+pub mod reverse_bits;
+
+pub fn run() {
+}

src/bit_manipulation/mod.rs

@@ -0,0 +1,37 @@
+/*
+ * Problem: 190. Reverse Bits (Easy)
+ * URL: https://leetcode.com/problems/reverse-bits/
+ *
+ * Runtime: 2 ms (55.42%)
+ * Memory Usage: 2.02 MB (54.22%)
+ */
+
+pub fn solve(mut x: u32) -> u32 {
+  let mut result: u32 = 0;
+  let mask = 1;
+
+  for i in 0..32 {
+    // println!("\n({i}) x={:#32b}\nresult={:#32b}", x, result);
+    result <<= 1;
+
+    if (x & mask == 1) { result += 1 }
+    x >>= 1;
+  }
+
+  return result;
+}
+
+#[cfg(test)]
+mod reverse_bits_tests {
+  use super::*;
+
+  #[test]
+  fn leading_zeroes() {
+    assert_eq!(solve(0b00000010_10010100_00011110_10011100), 0b00111001_01111000_00101001_01000000);
+  }
+
+  #[test]
+  fn leftmost_bit_set() {
+    assert_eq!(solve(0b11111111_11111111_11111111_11111101), 0b10111111_11111111_11111111_11111111);
+  }
+}

src/bit_manipulation/reverse_bits.rs

@@ -1,7 +1,12 @@
-// #![allow(dead_code)]
+#![allow(unused)]
 
-pub mod easy;
+pub mod math;
+pub mod bit_manipulation;
+pub mod array;
+pub mod string;
 
 fn main() {
-    easy::run();
+    // array::run();
+    // string::run();
+    // bit_manipulation::run();
 }

src/main.rs

@@ -0,0 +1,4 @@
+pub mod sqrt;
+
+pub fn run() {
+}

src/math/mod.rs

@@ -0,0 +1,43 @@
+/*
+ * Problem: 69. Sqrt(x) (Easy)
+ * URL: https://leetcode.com/problems/sqrtx/
+ *
+ * Runtime: 0 ms (100%)
+ * Memory Usage: 1.92 MB (88.50%)
+ */
+
+pub fn solve(x: i32) -> i32 {
+  let mut lb=0;
+  let mut rb= if x < 46_340 { x } else { 46_340 };  // sqrt(2_147_483_647) = 46_340.9
+  let mut mid=0;
+
+  while lb < rb {
+    mid = (lb+rb)/2;
+    // println!("range={}...{}, mid={}", lb, rb, mid);
+
+    if (mid*mid < x) { lb = mid+1; }
+    else { rb = mid; }
+  }
+
+  return if lb*lb > x { lb-1 } else { lb };
+}
+
+#[cfg(test)]
+mod sqrt_tests {
+  use super::*;
+
+  #[test]
+  fn happy_path() {
+    assert_eq!(solve(16), 4);
+  }
+
+  #[test]
+  fn round_down() {
+    assert_eq!(solve(27), 5);
+  }
+
+  #[test]
+  fn i32_upper_limit() {
+    assert_eq!(solve(i32::MAX), 46_340);
+  }
+}

src/math/sqrt.rs

@@ -0,0 +1,96 @@
+/*
+ * Problem: 67. Add Binary (Easy)
+ * URL: https://leetcode.com/problems/add-binary/
+ *
+ * Runtime: 1 ms (66.20%)
+ * Memory Usage: 2.02 MB (71.83%)
+ */
+
+pub fn solve(a: String, b: String) -> String {
+  let short: String;
+  let long = if b.len() > a.len() { 
+    short = a;
+    b
+  } else { 
+    short = b;
+    a
+  };
+
+  let mut result = "0".repeat(long.len()+1);
+
+  let mut i = 0;
+  let mut carryover = false;
+
+  let mut i_long: &str;
+  let mut i_short: &str;
+  let mut oper_range;
+
+  // Step 1: Add short string into long string
+  while(i < short.len()) {
+    i_long = &long[long.len()-i-1..long.len()-i];
+    i_short = &short[short.len()-i-1..short.len()-i];
+
+    oper_range = long.len()-i..long.len()-i+1;
+
+    if(carryover) {
+      if(i_long == "0" && i_short == "0") {
+        result.replace_range(oper_range, "1");
+        carryover = false;
+      }
+      else if (i_long == "1" && i_short == "1") {
+        result.replace_range(oper_range, "1");
+      }
+    } else {
+      if(i_long == "0" && i_short == "0") {}
+      else if (i_long == "1" && i_short == "1") { carryover = true; }
+      else { result.replace_range(oper_range, "1") }
+    }
+
+    i += 1;
+
+    // println!("{}: {}", i, result);
+  }
+
+  // Step 2: Complete addition of long string with carryover
+  while i < long.len() {
+    i_long = &long[long.len()-i-1..long.len()-i];
+    oper_range = long.len()-i..long.len()-i+1;
+
+    if(carryover) {
+      if i_long == "0" {
+        carryover = false;
+        result.replace_range(oper_range, "1");
+      }
+    } else {
+      if i_long== "1" { result.replace_range(oper_range, "1") }
+    }
+
+    i += 1;
+  }
+
+  // Step 3: Add "1" if remaining carryover
+  if carryover { result.replace_range(0..1, "1") }
+
+  return if &result[0..1] == "1" { result } else { result[1..result.len()].to_string()};
+}
+
+#[cfg(test)]
+mod add_binary_tests {
+  use super::*;
+
+  #[test]
+  fn equal_length() {
+    let a = String::from("1010");
+    let b = String::from("1011");
+
+    assert_eq!(solve(a, b), "10101");
+  }
+
+  #[test]
+  fn different_lengths() {
+    let a = String::from("100");
+    let b = String::from("10001");
+
+    assert_eq!(solve(a, b), "10101");
+  }
+}

src/string/add_binary.rs

@@ -1,4 +1,5 @@
 pub mod roman_to_int;
+pub mod add_binary;
 
 pub fn run() {
   display_roman_to_int("XIV");

src/easy/mod.rs src/string/mod.rs

@@ -1,4 +1,4 @@
-#![allow(dead_code)]
+// #![allow(dead_code)]
 
 use phf::phf_map;
 
@@ -10,7 +10,7 @@ use phf::phf_map;
  * Memory Usage: ? MB (%)
  */
 
-static ROMAN_NUMERALS_STR: phf::Map<&'static str, i32> = phf_map! {
+static ROMAN_NUMERALS_STR: phf::Map<&str, i32> = phf_map! {
   "I" => 1,
   "V" => 5,
   "X" => 10,