solve problems

Author: songyzh

src/problem/mod.rs

@@ -1,4 +0,0 @@
-mod p0447_number_of_boomerangs;
-mod p0448_find_all_numbers_disappeared_in_an_array;
-mod p0453_minimum_moves_to_equal_array_elements;
-mod p0455_assign_cookies;

src/solution/mod.rs

@@ -256,3 +256,11 @@ mod s0704_binary_search;
 mod s0969_pancake_sorting;
 mod s1018_binary_prefix_divisible_by_5;
 mod s1046_last_stone_weight;
+mod s0459_repeated_substring_pattern;
+mod s0461_hamming_distance;
+mod s0447_number_of_boomerangs;
+mod s0448_find_all_numbers_disappeared_in_an_array;
+mod s0453_minimum_moves_to_equal_array_elements;
+mod s0455_assign_cookies;
+mod s0463_island_perimeter;
+mod s0476_number_complement;

src/problem/p0447_number_of_boomerangs.rs renamed to src/solution/s0447_number_of_boomerangs.rs

@@ -0,0 +1,68 @@
+/**
+ * [459] Repeated Substring Pattern
+ *
+ * Given a non-empty string check if it can be constructed by taking a substring of it and appending multiple copies of the substring together. You may assume the given string consists of lowercase English letters only and its length will not exceed 10000.
+ *
+ *
+ *
+ * Example 1:
+ *
+ *
+ * Input: "abab"
+ * Output: True
+ * Explanation: It's the substring "ab" twice.
+ *
+ *
+ * Example 2:
+ *
+ *
+ * Input: "aba"
+ * Output: False
+ *
+ *
+ * Example 3:
+ *
+ *
+ * Input: "abcabcabcabc"
+ * Output: True
+ * Explanation: It's the substring "abc" four times. (And the substring "abcabc" twice.)
+ *
+ *
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+impl Solution {
+    pub fn repeated_substring_pattern(s: String) -> bool {
+        let chars: Vec<char> = s.chars().collect();
+        let mut pattern_len = s.len() / 2;
+        while pattern_len >= 1 {
+            if s.len() % pattern_len == 0 {
+                let substring = &s[0..pattern_len];
+                let mut start = 0;
+                while start + pattern_len <= s.len() {
+                    if &s[start..start + pattern_len] != substring {
+                        break;
+                    }
+                    start += pattern_len;
+                }
+                if start == s.len() {
+                    return true;
+                }
+            }
+            pattern_len -= 1;
+        }
+        false
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_459() {}
+}

src/problem/p0448_find_all_numbers_disappeared_in_an_array.rs renamed to src/solution/s0448_find_all_numbers_disappeared_in_an_array.rs

@@ -0,0 +1,55 @@
+/**
+ * [461] Hamming Distance
+ *
+ * The <a href="https://en.wikipedia.org/wiki/Hamming_distance" target="_blank">Hamming distance</a> between two integers is the number of positions at which the corresponding bits are different.
+ *
+ * Given two integers x and y, calculate the Hamming distance.
+ *
+ * Note:<br />
+ * 0 &le; x, y < 2^31.
+ *
+ *
+ * Example:
+ *
+ * Input: x = 1, y = 4
+ *
+ * Output: 2
+ *
+ * Explanation:
+ * 1   (0 0 0 1)
+ * 4   (0 1 0 0)
+ *        &uarr;   &uarr;
+ *
+ * The above arrows point to positions where the corresponding bits are different.
+ *
+ *
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+impl Solution {
+    pub fn hamming_distance(x: i32, y: i32) -> i32 {
+        let mut ret = 0;
+        let mut x = x;
+        let mut y = y;
+        while x != 0 || y != 0 {
+            if x & 1 != y & 1 {
+                ret += 1;
+            }
+            x >>= 1;
+            y >>= 1;
+        }
+        ret
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_461() {}
+}

src/problem/p0453_minimum_moves_to_equal_array_elements.rs renamed to src/solution/s0453_minimum_moves_to_equal_array_elements.rs

@@ -0,0 +1,66 @@
+/**
+ * [463] Island Perimeter
+ *
+ * You are given a map in form of a two-dimensional integer grid where 1 represents land and 0 represents water.
+ *
+ * Grid cells are connected horizontally/vertically (not diagonally). The grid is completely surrounded by water, and there is exactly one island (i.e., one or more connected land cells).
+ *
+ * The island doesn't have "lakes" (water inside that isn't connected to the water around the island). One cell is a square with side length 1. The grid is rectangular, width and height don't exceed 100. Determine the perimeter of the island.
+ *
+ *
+ *
+ * Example:
+ *
+ *
+ * Input:
+ * [[0,1,0,0],
+ *  [1,1,1,0],
+ *  [0,1,0,0],
+ *  [1,1,0,0]]
+ *
+ * Output: 16
+ *
+ * Explanation: The perimeter is the 16 yellow stripes in the image below:
+ *
+ * <img src="https://assets.leetcode.com/uploads/2018/10/12/island.png" style="width: 221px; height: 213px;" />
+ *
+ *
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+impl Solution {
+    pub fn island_perimeter(grid: Vec<Vec<i32>>) -> i32 {
+        let mut ret = 0;
+        for i in 0..grid.len() {
+            for j in 0..grid[0].len() {
+                if grid[i][j] == 1 {
+                    if i == 0 || grid[i - 1][j] == 0 {
+                        ret += 1;
+                    }
+                    if i == grid.len() - 1 || grid[i + 1][j] == 0 {
+                        ret += 1;
+                    }
+                    if j == 0 || grid[i][j - 1] == 0 {
+                        ret += 1;
+                    }
+                    if j == grid[0].len() - 1 || grid[i][j + 1] == 0 {
+                        ret += 1;
+                    }
+                }
+            }
+        }
+        ret
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_463() {}
+}

src/problem/p0455_assign_cookies.rs renamed to src/solution/s0455_assign_cookies.rs

@@ -0,0 +1,55 @@
+/**
+ * [476] Number Complement
+ *
+ * Given a positive integer, output its complement number. The complement strategy is to flip the bits of its binary representation.
+ *
+ * Note:<br>
+ * <ol>
+ * The given integer is guaranteed to fit within the range of a 32-bit signed integer.
+ * You could assume no leading zero bit in the integer’s binary representation.
+ * </ol>
+ *
+ *
+ * Example 1:<br />
+ *
+ * Input: 5
+ * Output: 2
+ * Explanation: The binary representation of 5 is 101 (no leading zero bits), and its complement is 010. So you need to output 2.
+ *
+ *
+ *
+ * Example 2:<br />
+ *
+ * Input: 1
+ * Output: 0
+ * Explanation: The binary representation of 1 is 1 (no leading zero bits), and its complement is 0. So you need to output 0.
+ *
+ *
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+impl Solution {
+    pub fn find_complement(num: i32) -> i32 {
+        let mut num = num;
+        let mut ret = 0;
+        let mut offset = 0;
+        while num != 0 {
+            ret |= (1 - (num & 1)) << offset;
+            num >>= 1;
+            offset += 1;
+        }
+        ret
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_476() {}
+}