Added task 268.

Author: javadev

src/main/java/g0201_0300/s0268_missing_number/Solution.java

@@ -0,0 +1,12 @@
+package g0201_0300.s0268_missing_number;
+
+public class Solution {
+    public int missingNumber(int[] nums) {
+        int a = nums.length;
+        for (int i = 0; i < nums.length; i++) {
+            a ^= i;
+            a ^= nums[i];
+        }
+        return a;
+    }
+}

src/main/java/g0201_0300/s0268_missing_number/readme.md

@@ -0,0 +1,46 @@
+268\. Missing Number
+
+Easy
+
+Given an array `nums` containing `n` distinct numbers in the range `[0, n]`, return _the only number in the range that is missing from the array._
+
+**Example 1:**
+
+**Input:** nums = \[3,0,1\]
+
+**Output:** 2
+
+**Explanation:****:** n = 3 since there are 3 numbers, so all numbers are in the range \[0,3\]. 2 is the missing number in the range since it does not appear in nums. 
+
+**Example 2:**
+
+**Input:** nums = \[0,1\]
+
+**Output:** 2
+
+**Explanation:****:** n = 2 since there are 2 numbers, so all numbers are in the range \[0,2\]. 2 is the missing number in the range since it does not appear in nums. 
+
+**Example 3:**
+
+**Input:** nums = \[9,6,4,2,3,5,7,0,1\]
+
+**Output:** 8
+
+**Explanation:****:** n = 9 since there are 9 numbers, so all numbers are in the range \[0,9\]. 8 is the missing number in the range since it does not appear in nums. 
+
+**Example 4:**
+
+**Input:** nums = \[0\]
+
+**Output:** 1
+
+**Explanation:****:** n = 1 since there is 1 number, so all numbers are in the range \[0,1\]. 1 is the missing number in the range since it does not appear in nums. 
+
+**Constraints:**
+
+*   `n == nums.length`
+*   <code>1 <= n <= 10<sup>4</sup></code>
+*   `0 <= nums[i] <= n`
+*   All the numbers of `nums` are **unique**.
+
+**Follow up:** Could you implement a solution using only `O(1)` extra space complexity and `O(n)` runtime complexity?

src/main/java/g0201_0300/s0273_integer_to_english_words/Solution.java

@@ -20,7 +20,6 @@ public class Solution {
     String[] twenties = {
         "Twenty ", "Thirty ", "Forty ", "Fifty ", "Sixty ", "Seventy ", "Eighty ", "Ninety "
     };
-
     String zero = "Zero";
     String hundred = "Hundred ";
     String thousand = "Thousand ";
@@ -31,26 +30,21 @@ public String numberToWords(int num) {
         if (num == 0) {
             return zero;
         }
-
         StringBuilder sb = new StringBuilder();
-
         processThreeDigits(sb, num / 1_000_000_000, billion);
         processThreeDigits(sb, num / 1_000_000, million);
         processThreeDigits(sb, num / 1_000, thousand);
         processThreeDigits(sb, num, null);
-
         return sb.toString().trim();
     }
 
     private void processThreeDigits(StringBuilder sb, int input, String name) {
         int threeDigit = input % 1000;
-
         if (threeDigit > 0) {
             if (threeDigit / 100 > 0) {
                 sb.append(ones[threeDigit / 100 - 1]);
                 sb.append(hundred);
             }
-
             if (threeDigit % 100 >= 20) {
                 sb.append(twenties[(threeDigit % 100) / 10 - 2]);
                 if (threeDigit % 10 > 0) {
@@ -61,7 +55,6 @@ private void processThreeDigits(StringBuilder sb, int input, String name) {
             } else if (threeDigit % 100 > 0 && threeDigit % 100 < 10) {
                 sb.append(ones[threeDigit % 10 - 1]);
             }
-
             if (name != null) {
                 sb.append(name);
             }

src/test/java/g0201_0300/s0268_missing_number/SolutionTest.java

@@ -0,0 +1,28 @@
+package g0201_0300.s0268_missing_number;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.Test;
+
+public class SolutionTest {
+    @Test
+    public void missingNumber() {
+        assertThat(new Solution().missingNumber(new int[] {3, 0, 1}), equalTo(2));
+    }
+
+    @Test
+    public void missingNumber2() {
+        assertThat(new Solution().missingNumber(new int[] {3, 0, 1}), equalTo(2));
+    }
+
+    @Test
+    public void missingNumber3() {
+        assertThat(new Solution().missingNumber(new int[] {9, 6, 4, 2, 3, 5, 7, 0, 1}), equalTo(8));
+    }
+
+    @Test
+    public void missingNumber4() {
+        assertThat(new Solution().missingNumber(new int[] {0}), equalTo(1));
+    }
+}