rename

fishercoder1534 · fishercoder1534 · commit ddc504bfd199 · 2017-07-28T19:24:30.000-07:00
diff --git a/README.md b/README.md
diff --git a/src/main/java/com/fishercoder/solutions/MinimumUniqueWordAbbreviation.java b/src/main/java/com/fishercoder/solutions/MinimumUniqueWordAbbreviation.java
diff --git a/src/main/java/com/fishercoder/solutions/_111.java b/src/main/java/com/fishercoder/solutions/_111.java
@@ -9,7 +9,7 @@
 
  The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.*/
 
-public class MinimumDepthofBinaryTree {
+public class _111 {
 /**We can solve this problem using both BFS and DFS:
  * DFS is to visit every single root to leaf path and return the shortest one.
  * BFS is to visit every level and return whenever we find the first leaf node.*/
@@ -23,7 +23,7 @@ public int minDepth(TreeNode root) {
     }
     
     public static void main(String[] args){
-        MinimumDepthofBinaryTree test = new MinimumDepthofBinaryTree();
+        _111 test = new _111();
         TreeNode root = new TreeNode(1);
         root.left = new TreeNode(2);
         root.right = new TreeNode(3);
diff --git a/src/main/java/com/fishercoder/solutions/_128.java b/src/main/java/com/fishercoder/solutions/_128.java
@@ -10,7 +10,7 @@
 
  Your algorithm should run in O(n) complexity.
  */
-public class LongestConsecutiveSequence {
+public class _128 {
     //inspired by this solution: https://discuss.leetcode.com/topic/29286/my-java-solution-using-unionfound
     public int longestConsecutive(int[] nums) {
         Map<Integer, Integer> map = new HashMap();//<value, index>
diff --git a/src/main/java/com/fishercoder/solutions/_131.java b/src/main/java/com/fishercoder/solutions/_131.java
@@ -14,7 +14,7 @@
  ["aa","b"],
  ["a","a","b"]
  ]*/
-public class PalindromePartitioning {
+public class _131 {
 
     public List<List<String>> partition(String s) {
         List<List<String>> result = new ArrayList();
@@ -59,7 +59,7 @@ void backtracking(String s, int start, boolean[][] dp, List<String> temp,
 
     
     public static void main(String...strings){
-        PalindromePartitioning test = new PalindromePartitioning();
+        _131 test = new _131();
         String s = "aab";
         List<List<String>> result = test.partition(s);
         for(List<String> list : result){
diff --git a/src/main/java/com/fishercoder/solutions/_132.java b/src/main/java/com/fishercoder/solutions/_132.java
@@ -8,7 +8,7 @@
  Return 1 since the palindrome partitioning ["aa","b"] could be produced using 1 cut.
 
  */
-public class PalindromePartitioningII {
+public class _132 {
     /**This solution is cooler than Jiuzhang: https://discuss.leetcode.com/topic/32575/easiest-java-dp-solution-97-36*/
     
     //cut[i] stands for the minimum number of cut needed to cut [0, i] into palindromes
diff --git a/src/main/java/com/fishercoder/solutions/_203.java b/src/main/java/com/fishercoder/solutions/_203.java
@@ -1,19 +1,16 @@
 package com.fishercoder.solutions;
 
-
 import com.fishercoder.common.classes.ListNode;
 import com.fishercoder.common.utils.CommonUtils;
 
-/**203. Remove Linked List Elements  QuestionEditorial Solution  My Submissions
-Total Accepted: 74027
-Total Submissions: 249238
-Difficulty: Easy
+/**203. Remove Linked List Elements
+ *
 Remove all elements from a linked list of integers that have value val.
 
 Example
 Given: 1 --> 2 --> 6 --> 3 --> 4 --> 5 --> 6, val = 6
 Return: 1 --> 2 --> 3 --> 4 --> 5*/
-public class RemoveLinkedListElements {
+public class _203 {
 	/**This is a very good question to test your understanding of pointers/memory/addresses, although it's marked as EASY.
 	 * All the three nodes: dummy, curr and prev are indispensable.
 
@@ -42,7 +39,7 @@ public ListNode removeElements(ListNode head, int val) {
 	}
 	
 	public static void main(String...strings){
-		RemoveLinkedListElements test = new RemoveLinkedListElements();
+		_203 test = new _203();
 		int val = 6;
 		ListNode head = new ListNode(1);
 		head.next = new ListNode(2);
diff --git a/src/main/java/com/fishercoder/solutions/_209.java b/src/main/java/com/fishercoder/solutions/_209.java
@@ -11,7 +11,7 @@
  More practice:
  If you have figured out the O(n) solution, try coding another solution of which the time complexity is O(n log n).
  */
-public class MinimumSizeSubarraySum {
+public class _209 {
 
     public int minSubArrayLen(int s, int[] nums) {
         if(nums == null || nums.length == 0) return 0;
diff --git a/src/main/java/com/fishercoder/solutions/_233.java b/src/main/java/com/fishercoder/solutions/_233.java
@@ -11,7 +11,7 @@
 
  Beware of overflow.
  */
-public class NumberofDigitOne {
+public class _233 {
 
     public int countDigitOne(int n) {
         int count = 0;
diff --git a/src/main/java/com/fishercoder/solutions/_304.java b/src/main/java/com/fishercoder/solutions/_304.java
@@ -23,7 +23,7 @@ The above rectangle (with the red border) is defined by (row1, col1) = (2, 1) an
  There are many calls to sumRegion function.
  You may assume that row1 ≤ row2 and col1 ≤ col2.
  */
-public class RangeSumQuery2DImmutable {
+public class _304 {
 
     public class NumMatrix {
 
diff --git a/src/main/java/com/fishercoder/solutions/_305.java b/src/main/java/com/fishercoder/solutions/_305.java
@@ -40,7 +40,7 @@
 
  Can you do it in time complexity O(k log mn), where k is the length of the positions?
  */
-public class NumberofIslandsII {
+public class _305 {
 
     public int find(int[] father, int id) {
         int tf = father[id];
diff --git a/src/main/java/com/fishercoder/solutions/_307.java b/src/main/java/com/fishercoder/solutions/_307.java
@@ -12,7 +12,7 @@ The update(i, val) function modifies nums by updating the element at index i to
  Note:
  The array is only modifiable by the update function.
  You may assume the number of calls to update and sumRange function is distributed evenly.*/
-public class RangeSumQueryMutable {
+public class _307 {
 
 	public static void main(String... strings) {
 		//        int[] nums = new int[]{1,3,5};
diff --git a/src/main/java/com/fishercoder/solutions/_308.java b/src/main/java/com/fishercoder/solutions/_308.java
@@ -23,7 +23,7 @@ The above rectangle (with the red border) is defined by (row1, col1) = (2, 1) an
  You may assume the number of calls to update and sumRegion function is distributed evenly.
  You may assume that row1 ≤ row2 and col1 ≤ col2.
  */
-public class RangeSumQuery2DMutable {
+public class _308 {
     class Solution {
         public class NumMatrix {
             int[][] nums;
diff --git a/src/main/java/com/fishercoder/solutions/_323.java b/src/main/java/com/fishercoder/solutions/_323.java
@@ -27,7 +27,7 @@
  Note:
  You can assume that no duplicate edges will appear in edges. Since all edges are undirected, [0, 1] is the same as [1, 0] and thus will not appear together in edges.
  */
-public class NumberOfConnectedComponentsInAnUndirectedGraph {
+public class _323 {
 
     public int countComponents(int n, int[][] edges) {
         if(n <= 1) return n;
diff --git a/src/main/java/com/fishercoder/solutions/_364.java b/src/main/java/com/fishercoder/solutions/_364.java
@@ -16,7 +16,7 @@
 
  Example 2:
  Given the list [1,[4,[6]]], return 17. (one 1 at depth 3, one 4 at depth 2, and one 6 at depth 1; 1*3 + 4*2 + 6*1 = 17)*/
-public class NestedListWeightSumII {
+public class _364 {
 
     public int depthSumInverse(List<NestedInteger> nestedList) {
         Queue<NestedInteger> q = new LinkedList<NestedInteger>();
diff --git a/src/main/java/com/fishercoder/solutions/_381.java b/src/main/java/com/fishercoder/solutions/_381.java
@@ -15,7 +15,7 @@ Design a data structure that supports all following operations in average O(1) t
 Example:
 
 // Init an empty collection.
-RandomizedCollection collection = new RandomizedCollection();
+_381 collection = new _381();
 
 // Inserts 1 to the collection. Returns true as the collection did not contain 1.
 collection.insert(1);
@@ -34,15 +34,15 @@ Design a data structure that supports all following operations in average O(1) t
 
 // getRandom should return 1 and 2 both equally likely.
 collection.getRandom();*/
-public class RandomizedCollection {
+public class _381 {
     
     Map<Integer, Integer> forwardMap;//key is the to-be-inserted number, value is its auto-incremented index
     Map<Integer, Integer> reverseMap;//the other way around
     int index;
     Random rand;
     
     /** Initialize your data structure here. */
-    public RandomizedCollection() {
+    public _381() {
         forwardMap = new HashMap();
         reverseMap = new HashMap();
         index = 0;
@@ -92,7 +92,7 @@ public int getRandom() {
     }
     
     public static void main(String...strings){
-        RandomizedCollection test = new RandomizedCollection();
+        _381 test = new _381();
         System.out.println(test.insert(1));
         System.out.println(test.insert(1));
         System.out.println(test.insert(2));
diff --git a/src/main/java/com/fishercoder/solutions/_447.java b/src/main/java/com/fishercoder/solutions/_447.java
@@ -16,7 +16,7 @@
 
  Explanation:
  The two boomerangs are [[1,0],[0,0],[2,0]] and [[1,0],[2,0],[0,0]]*/
-public class NumberofBoomerangs {
+public class _447 {
     /**Looked at these two posts: https://discuss.leetcode.com/topic/66587/clean-java-solution-o-n-2-166ms and 
      * https://discuss.leetcode.com/topic/66521/share-my-straightforward-solution-with-hashmap-o-n-2, basically,
      * have a HashMap, key is the distance, value is the number of points that are this distance apart to this point.
@@ -54,7 +54,7 @@ private long calcDistance(int[] p1, int[] p2) {
     }
 
     public static void main(String... args) {
-        NumberofBoomerangs test = new NumberofBoomerangs();
+        _447 test = new _447();
         // int[][] points = new int[][]{
         // {0,0},
         // {1,0},
diff --git a/src/main/java/com/fishercoder/solutions/_453.java b/src/main/java/com/fishercoder/solutions/_453.java
@@ -1,15 +1,38 @@
 package com.fishercoder.solutions;
 
-public class MinimumMovestoEqualArrayElements {
+/**
+ * 453. Minimum Moves to Equal Array Elements
+ *
+ * Given a non-empty integer array of size n,
+ * find the minimum number of moves required to make all array elements equal, where a move is incrementing n - 1 elements by 1.
+
+ Example:
+
+ Input:
+ [1,2,3]
+
+ Output:
+ 3
+
+ Explanation:
+ Only three moves are needed (remember each move increments two elements):
+
+ [1,2,3]  =>  [2,3,3]  =>  [3,4,3]  =>  [4,4,4]*/
+
+public class _453 {
     /**Looked at this solution: https://discuss.leetcode.com/topic/66557/java-o-n-solution-short
      * i.e. Add 1 to n-1 elements basically equals to subtracting 1 from one element. So the easiest way
      * to make all elements in this array equal is to make all of them equal to the minimum element.*/
     public static int minMoves(int[] nums) {
         if(nums.length == 0) return 0;
         int min = nums[0];
-        for(int n : nums) min = Math.min(min, n);
+        for(int n : nums) {
+            min = Math.min(min, n);
+        }
         int res = 0;
-        for(int n : nums) res += n - min;
+        for(int n : nums) {
+            res += n - min;
+        }
         return res;
     }
     
diff --git a/src/main/java/com/fishercoder/solutions/_462.java b/src/main/java/com/fishercoder/solutions/_462.java
@@ -2,7 +2,27 @@
 
 import java.util.Arrays;
 
-public class MinimumMovestoEqualArrayElementsII {
+/**462. Minimum Moves to Equal Array Elements II
+ * Given a non-empty integer array,
+ * find the minimum number of moves required to make all array elements equal,
+ * where a move is incrementing a selected element by 1 or decrementing a selected element by 1.
+
+ You may assume the array's length is at most 10,000.
+
+ Example:
+
+ Input:
+ [1,2,3]
+
+ Output:
+ 2
+
+ Explanation:
+ Only two moves are needed (remember each move increments or decrements one element):
+
+ [1,2,3]  =>  [2,2,3]  =>  [2,2,2]*/
+
+public class _462 {
 
     public static int minMoves2(int[] nums) {
         /**sort this array, find the median of this array as the pivot*/
diff --git a/src/main/java/com/fishercoder/solutions/_76.java b/src/main/java/com/fishercoder/solutions/_76.java
@@ -13,7 +13,7 @@
 
  If there are multiple such windows, you are guaranteed that there will always be only one unique minimum window in S.
  */
-public class MinimumWindowSubstring {
+public class _76 {
 
     public String minWindow(String s, String t) {
         int[] counts = new int[256];
