add 2423

Author: fishercoder1534

Diff for: paginated_contents/algorithms/3rd_thousand/README.md

@@ -54,6 +54,7 @@
 | 2433 | [Find The Original Array of Prefix Xor](https://leetcode.com/problems/find-the-original-array-of-prefix-xor/)                                                                                | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2433.java)                                       | [:tv:](https://youtu.be/idcT-p_DDrI) | Medium                         ||
 | 2432 | [The Employee That Worked on the Longest Task](https://leetcode.com/problems/the-employee-that-worked-on-the-longest-task/)                                                                  | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2432.java)                                       || Easy                                 ||
 | 2427 | [Number of Common Factors](https://leetcode.com/problems/number-of-common-factors/)                                                                                                          | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2427.java)                                       || Easy                                 ||
+| 2423 | [Remove Letter To Equalize Frequency](https://leetcode.com/problems/remove-letter-to-equalize-frequency/)                                                                                                       | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2423.java)                                       || Easy                                 ||
 | 2418 | [Sort the People](https://leetcode.com/problems/sort-the-people/)                                                                                                       | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2418.java)                                       || Easy                                 ||
 | 2413 | [Smallest Even Multiple](https://leetcode.com/problems/smallest-even-multiple/)                                                                                                      | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2413.java)                                       || Easy                                 ||
 | 2409 | [Count Days Spent Together](https://leetcode.com/problems/count-days-spent-together/)                                                                                                      | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2409.java)                                       || Easy                                 ||

Diff for: src/main/java/com/fishercoder/solutions/thirdthousand/_2423.java

@@ -0,0 +1,66 @@
+package com.fishercoder.solutions.thirdthousand;
+
+import java.util.Arrays;
+
+public class _2423 {
+    public static class Solution1 {
+        /**
+         * This is my original, but unnecessarily verbose solution.
+         * Instead, you can just brute force each one of the 26 letters, as long as any one of them makes it meet the requirement, it returns true.
+         */
+        public boolean equalFrequency(String word) {
+            int[] count = new int[26];
+            for (char c : word.toCharArray()) {
+                count[c - 'a']++;
+            }
+            Arrays.sort(count);
+            return decLast(count) || decFirst(count) || allOnes(count);
+        }
+
+        private boolean allOnes(int[] count) {
+            for (int i : count) {
+                if (i != 1 && i != 0) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        private boolean decFirst(int[] count) {
+            int start = 0;
+            int firstVal = -1;
+            for (int i = 0; i < 26; i++) {
+                if (count[i] != 0) {
+                    start = i + 1;
+                    firstVal = count[i] - 1;
+                    break;
+                }
+            }
+            if (firstVal == 0) {
+                int nextVal = count[start++];
+                for (; start < 26; start++) {
+                    if (count[start] != nextVal) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            for (; start < 26; start++) {
+                if (count[start] != firstVal) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        private boolean decLast(int[] count) {
+            int last = count[25] - 1;
+            for (int i = 24; i >= 0; i--) {
+                if (count[i] != 0 && count[i] != last) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+}

Diff for: src/test/java/com/fishercoder/thirdthousand/_2423Test.java

@@ -0,0 +1,47 @@
+package com.fishercoder.thirdthousand;
+
+import com.fishercoder.solutions.thirdthousand._2423;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class _2423Test {
+    private static _2423.Solution1 solution1;
+
+    @BeforeEach
+    public void setup() {
+        solution1 = new _2423.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        assertTrue(solution1.equalFrequency("abcc"));
+    }
+
+    @Test
+    public void test2() {
+        assertTrue(solution1.equalFrequency("abc"));
+    }
+
+    @Test
+    public void test3() {
+        assertFalse(solution1.equalFrequency("ddaccb"));
+    }
+
+    @Test
+    public void test4() {
+        assertTrue(solution1.equalFrequency("abbcc"));
+    }
+
+    @Test
+    public void test5() {
+        assertFalse(solution1.equalFrequency("aazz"));
+    }
+
+    @Test
+    public void test6() {
+        assertTrue(solution1.equalFrequency("ab"));
+    }
+}