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 <68205373+CoffeelessProgrammer@users.noreply.github.com>"]
 

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);
+  }
+}