Added tasks 476, 477, 478, 479.

Author: ThanhNIT

src/main/java/g0401_0500/s0476_number_complement/Solution.java

@@ -0,0 +1,9 @@
+package g0401_0500.s0476_number_complement;
+
+// #Easy #Bit_Manipulation
+
+public class Solution {
+    public int findComplement(int num) {
+        return ~num & ((Integer.highestOneBit(num) << 1) - 1);
+    }
+}

src/main/java/g0401_0500/s0476_number_complement/readme.md

@@ -0,0 +1,31 @@
+476\. Number Complement
+
+Easy
+
+The **complement** of an integer is the integer you get when you flip all the `0`'s to `1`'s and all the `1`'s to `0`'s in its binary representation.
+
+*   For example, The integer `5` is `"101"` in binary and its **complement** is `"010"` which is the integer `2`.
+
+Given an integer `num`, return _its complement_.
+
+**Example 1:**
+
+**Input:** num = 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:**
+
+**Input:** num = 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.
+
+**Constraints:**
+
+*   <code>1 <= num < 2<sup>31</sup></code>
+
+**Note:** This question is the same as 1009: [https://leetcode.com/problems/complement-of-base-10-integer/](https://leetcode.com/problems/complement-of-base-10-integer/)

src/main/java/g0401_0500/s0477_total_hamming_distance/Solution.java

@@ -0,0 +1,18 @@
+package g0401_0500.s0477_total_hamming_distance;
+
+// #Medium #Array #Math #Bit_Manipulation
+
+public class Solution {
+    public int totalHammingDistance(int[] nums) {
+        int ans = 0;
+        int n = nums.length;
+        for (int i = 0; i < 32; i++) {
+            int ones = 0;
+            for (int k : nums) {
+                ones += ((k >> i) & 1);
+            }
+            ans = ans + (ones * (n - ones));
+        }
+        return ans;
+    }
+}

src/main/java/g0401_0500/s0477_total_hamming_distance/readme.md

@@ -0,0 +1,27 @@
+477\. Total Hamming Distance
+
+Medium
+
+The [Hamming distance](https://en.wikipedia.org/wiki/Hamming_distance) between two integers is the number of positions at which the corresponding bits are different.
+
+Given an integer array `nums`, return _the sum of **Hamming distances** between all the pairs of the integers in_ `nums`.
+
+**Example 1:**
+
+**Input:** nums = [4,14,2]
+
+**Output:** 6
+
+**Explanation:** In binary representation, the 4 is 0100, 14 is 1110, and 2 is 0010 (just showing the four bits relevant in this case). The answer will be: HammingDistance(4, 14) + HammingDistance(4, 2) + HammingDistance(14, 2) = 2 + 2 + 2 = 6.
+
+**Example 2:**
+
+**Input:** nums = [4,14,4]
+
+**Output:** 4
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>4</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>9</sup></code>
+*   The answer for the given input will fit in a **32-bit** integer.

src/main/java/g0401_0500/s0478_generate_random_point_in_a_circle/Solution.java

@@ -0,0 +1,37 @@
+package g0401_0500.s0478_generate_random_point_in_a_circle;
+
+// #Medium #Math #Geometry #Randomized #Rejection_Sampling
+
+import java.security.SecureRandom;
+
+public class Solution {
+    private final double radius;
+    private final double xCenter;
+    private final double yCenter;
+    private final SecureRandom random = new SecureRandom();
+
+    public Solution(double radius, double xCenter, double yCenter) {
+
+        this.radius = radius;
+        this.xCenter = xCenter;
+        this.yCenter = yCenter;
+    }
+
+    public double[] randPoint() {
+        double x = getCoordinate(xCenter);
+        double y = getCoordinate(yCenter);
+        while (getDistance(x, y) >= radius * radius) {
+            x = getCoordinate(xCenter);
+            y = getCoordinate(yCenter);
+        }
+        return new double[] {x, y};
+    }
+
+    private double getDistance(double x, double y) {
+        return (xCenter - x) * (xCenter - x) + (yCenter - y) * (yCenter - y);
+    }
+
+    private double getCoordinate(double center) {
+        return center - radius + random.nextDouble() * 2 * radius;
+    }
+}

src/main/java/g0401_0500/s0478_generate_random_point_in_a_circle/readme.md

@@ -0,0 +1,24 @@
+478\. Generate Random Point in a Circle
+
+Medium
+
+Given the radius and the position of the center of a circle, implement the function `randPoint` which generates a uniform random point inside the circle.
+
+Implement the `Solution` class:
+
+*   `Solution(double radius, double x_center, double y_center)` initializes the object with the radius of the circle `radius` and the position of the center `(x_center, y_center)`.
+*   `randPoint()` returns a random point inside the circle. A point on the circumference of the circle is considered to be in the circle. The answer is returned as an array `[x, y]`.
+
+**Example 1:**
+
+**Input** ["Solution", "randPoint", "randPoint", "randPoint"] [[1.0, 0.0, 0.0], [], [], []]
+
+**Output:** [null, [-0.02493, -0.38077], [0.82314, 0.38945], [0.36572, 0.17248]]
+
+**Explanation:** Solution solution = new Solution(1.0, 0.0, 0.0); solution.randPoint(); // return [-0.02493, -0.38077] solution.randPoint(); // return [0.82314, 0.38945] solution.randPoint(); // return [0.36572, 0.17248]
+
+**Constraints:**
+
+*   <code>0 < radius <= 10<sup>8</sup></code>
+*   <code>-10<sup>7</sup> <= x_center, y_center <= 10<sup>7</sup></code>
+*   At most <code>3 * 10<sup>4</sup></code> calls will be made to `randPoint`.

src/main/java/g0401_0500/s0479_largest_palindrome_product/Solution.java

@@ -0,0 +1,27 @@
+package g0401_0500.s0479_largest_palindrome_product;
+
+// #Hard #Math
+
+public class Solution {
+    public int largestPalindrome(int n) {
+        long pow10 = (long) Math.pow(10, n);
+        long max = (pow10 - 1) * (pow10 - (long) Math.sqrt(pow10) + 1);
+        long left = (max / pow10);
+        long t = pow10 / 11;
+        t -= ~t & 1;
+        for (long i = left; i > 0; i--) {
+            for (long j = t, num = gen(i); j >= i / 11; j -= 2) {
+                if (num % j == 0) {
+                    return (int) (num % 1337);
+                }
+            }
+        }
+        return 9;
+    }
+
+    private long gen(long x) {
+        long r = x;
+        for (; x > 0; r = r * 10 + x % 10, x /= 10) {}
+        return r;
+    }
+}

src/main/java/g0401_0500/s0479_largest_palindrome_product/readme.md

@@ -0,0 +1,21 @@
+479\. Largest Palindrome Product
+
+Hard
+
+Given an integer n, return _the **largest palindromic integer** that can be represented as the product of two `n`\-digits integers_. Since the answer can be very large, return it **modulo** `1337`.
+
+**Example 1:**
+
+**Input:** n = 2
+
+**Output:** 987 Explanation: 99 x 91 = 9009, 9009 % 1337 = 987
+
+**Example 2:**
+
+**Input:** n = 1
+
+**Output:** 9
+
+**Constraints:**
+
+*   `1 <= n <= 8`

src/test/java/com_github_leetcode/CommonUtils.java

@@ -13,6 +13,13 @@ public static void printArray(int[] nums) {
         System.out.println();
     }
 
+    public static void printArray(double[] nums) {
+        for (double i : nums) {
+            System.out.print(i + ", ");
+        }
+        System.out.println();
+    }
+
     public static char[][] convertLeetCodeRegular2DCharArrayInputIntoJavaArray(String input) {
         /*
          * LeetCode 2-d char array usually comes in like this:

src/test/java/g0401_0500/s0476_number_complement/SolutionTest.java

@@ -0,0 +1,18 @@
+package g0401_0500.s0476_number_complement;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void findComplement() {
+        assertThat(new Solution().findComplement(5), equalTo(2));
+    }
+
+    @Test
+    void findComplement2() {
+        assertThat(new Solution().findComplement(1), equalTo(0));
+    }
+}