refactor for format

Author: fishercoder1534

src/main/java/com/fishercoder/solutions/_191.java

@@ -8,40 +8,40 @@ public class _191 {
     //another cool trick that I learned: doing bitwise AND operation between n and n-1 will always flip the least significant 1 bit in n
     //to zero, here's the solution from Editorial:
     //example run for the above editorial solution: input 5, n will be 5&4 and becomes 4, then in the next run, n will become 4&3 which is 0, thus exit the while loop.
-    public int hammingWeight_editorial(int n){
+    public int hammingWeight_editorial(int n) {
         int count = 0;
-        while(n != 0){
+        while (n != 0) {
             count++;
-            n &= (n-1);
+            n &= (n - 1);
         }
         return count;
     }
 
-    public static void main(String...strings){
-        System.out.println(4&5);
+    public static void main(String... strings) {
+        System.out.println(4 & 5);
         _191 test = new _191();
         System.out.println(test.hammingWeight_editorial(5));
     }
 
- // you need to treat n as an unsigned value
+    // you need to treat n as an unsigned value
     public int hammingWeight(int n) {
         //cheers! Made it AC'ed on my own with an ease!
         int count = 0;
-        for(int i = 0; i < 32; i++){
+        for (int i = 0; i < 32; i++) {
             int one = (n >>> i) & 1;//must use unsigned right shift operator
-            if(one == 1) count++;
+            if (one == 1) count++;
         }
         return count;
     }
-    
+
     //then I turned to its Editorial solution: we can make it a little faster: at any time, when n becomes zero, that means there's
     //no more 1's there, then we could safely return! Cool!
     public int hammingWeight_faster(int n) {
         int count = 0;
-        for(int i = 0; i < 32; i++){
+        for (int i = 0; i < 32; i++) {
             int one = (n >>> i) & 1;//must use unsigned right shift operator
-            if(one == 1) count++;
-            if(n == 0) return count;
+            if (one == 1) count++;
+            if (n == 0) return count;
         }
         return count;
     }

src/main/java/com/fishercoder/solutions/_198.java

@@ -13,16 +13,16 @@
 public class _198 {
 
     public int rob(int[] nums) {
-        if(nums == null || nums.length == 0) return 0;
-        if(nums.length == 1) return nums[0];
-        if(nums.length == 2) return Math.max(nums[0], nums[1]);
+        if (nums == null || nums.length == 0) return 0;
+        if (nums.length == 1) return nums[0];
+        if (nums.length == 2) return Math.max(nums[0], nums[1]);
         int[] dp = new int[nums.length];
         dp[0] = nums[0];
         dp[1] = Math.max(nums[0], nums[1]);
-        for(int i = 2; i < nums.length; i++){
-            dp[i] = Math.max(dp[i-2] + nums[i], dp[i-1]);
+        for (int i = 2; i < nums.length; i++) {
+            dp[i] = Math.max(dp[i - 2] + nums[i], dp[i - 1]);
         }
-        return dp[nums.length-1];
+        return dp[nums.length - 1];
     }
 
 }

src/main/java/com/fishercoder/solutions/_25.java

@@ -24,15 +24,17 @@ public class _25 {
     public ListNode reverseKGroup(ListNode head, int k) {
         ListNode curr = head;
         int count = 0;
-        while(curr != null && count != k){//find the k+1 node
+        while (curr != null && count != k) {
+            //find the k+1 node
             curr = curr.next;
             count++;
         }
 
-        if(count == k){//if k+1 is found
+        if (count == k) {
+            //if k+1 is found
             curr = reverseKGroup(curr, k);//reverse list that has k+1 as head
 
-            while(count > 0){
+            while (count > 0) {
                 ListNode temp = head.next;
                 head.next = curr;
                 curr = head;
@@ -44,7 +46,7 @@ public ListNode reverseKGroup(ListNode head, int k) {
         return head;//we run out of nodes before we hit count == k, so we'll just directly return head in this case as well
     }
 
-    public static void main(String...args) {
+    public static void main(String... args) {
         ListNode head = new ListNode(1);
         head.next = new ListNode(2);
         head.next.next = new ListNode(3);

src/main/java/com/fishercoder/solutions/_252.java

@@ -14,26 +14,26 @@
  return false.*/
 public class _252 {
     public boolean canAttendMeetings(Interval[] intervals) {
-        
+
         List<Interval> list = new ArrayList();
-        for(Interval interval : intervals){
+        for (Interval interval : intervals) {
             list.add(interval);
         }
-        
-        Collections.sort(list, new Comparator<Interval>(){
+
+        Collections.sort(list, new Comparator<Interval>() {
 
             @Override
             public int compare(Interval o1, Interval o2) {
-                if(o1.start > o2.start) return 1;
+                if (o1.start > o2.start) return 1;
                 else return -1;
             }
-            
+
         });
-        
-        for(int i = 0; i < list.size()-1; i++){
-            if(list.get(i).end > list.get(i+1).start) return false;
+
+        for (int i = 0; i < list.size() - 1; i++) {
+            if (list.get(i).end > list.get(i + 1).start) return false;
         }
         return true;
-    
+
     }
 }

src/main/java/com/fishercoder/solutions/_256.java

@@ -11,15 +11,15 @@
 public class _256 {
 
     public int minCost(int[][] costs) {
-        if(costs == null || costs.length == 0){
+        if (costs == null || costs.length == 0) {
             return 0;
         }
-        for(int i = 1; i < costs.length; i++){
-            costs[i][0] += Math.min(costs[i-1][1], costs[i-1][2]);
-            costs[i][1] += Math.min(costs[i-1][0], costs[i-1][2]);
-            costs[i][2] += Math.min(costs[i-1][1], costs[i-1][0]);
+        for (int i = 1; i < costs.length; i++) {
+            costs[i][0] += Math.min(costs[i - 1][1], costs[i - 1][2]);
+            costs[i][1] += Math.min(costs[i - 1][0], costs[i - 1][2]);
+            costs[i][2] += Math.min(costs[i - 1][1], costs[i - 1][0]);
         }
-        int n = costs.length-1;
+        int n = costs.length - 1;
         return Math.min(Math.min(costs[n][0], costs[n][1]), costs[n][2]);
     }
 

src/main/java/com/fishercoder/solutions/_258.java

@@ -22,9 +22,9 @@ public class _258 {
 
     //only three cases as the code shows
     public int addDigits(int num) {
-        if(num == 0) return 0;
-        if(num % 9 == 0) return 9;
-        return num%9;
+        if (num == 0) return 0;
+        if (num % 9 == 0) return 9;
+        return num % 9;
     }
 
 }

src/main/java/com/fishercoder/solutions/_259.java

@@ -19,15 +19,15 @@ public class _259 {
 
     /**Basically, very similar to 3Sum, but the key is that you'll have to add result by (right-left), not just increment result by 1!*/
     public int threeSumSmaller(int[] nums, int target) {
-        if(nums == null || nums.length == 0) return 0;
+        if (nums == null || nums.length == 0) return 0;
         int result = 0;
         Arrays.sort(nums);
-        for(int i = 0; i < nums.length-2; i++){
-            int left = i+1, right = nums.length-1;
-            while(left < right){
+        for (int i = 0; i < nums.length - 2; i++) {
+            int left = i + 1, right = nums.length - 1;
+            while (left < right) {
                 int sum = nums[i] + nums[left] + nums[right];
-                if(sum < target) {
-                    result += right-left;//this line is key!
+                if (sum < target) {
+                    result += right - left;//this line is key!
                     left++;
                 } else right--;
             }

src/main/java/com/fishercoder/solutions/_26.java

@@ -13,39 +13,41 @@ public class _26 {
 
     public static int removeDuplicates_editorial_solution(int[] nums) {
         int i = 0;
-        for(int j = 1; j < nums.length; j++){
-            if(nums[i] != nums[j]){
+        for (int j = 1; j < nums.length; j++) {
+            if (nums[i] != nums[j]) {
                 i++;
                 nums[i] = nums[j];
             }
         }
-        return i+1;
+        return i + 1;
     }
 
 
-    public static void main(String...strings){
-        int[] nums = new int[]{1,1,2};
+    public static void main(String... strings) {
+        int[] nums = new int[]{1, 1, 2};
 //        int[] nums = new int[]{1,1,2,2,3};
 //        int[] nums = new int[]{1,1};
         System.out.println(removeDuplicates_editorial_solution(nums));
     }
 
-    /**Same idea as the editorial solution, mine just got more verbose.*/
+    /**
+     * Same idea as the editorial solution, mine just got more verbose.
+     */
     public static int removeDuplicates_my_original(int[] nums) {
         int i = 0;
-        for(int j = i+1; i < nums.length && j < nums.length;){
-            while(j < nums.length && nums[i] == nums[j]){
+        for (int j = i + 1; i < nums.length && j < nums.length; ) {
+            while (j < nums.length && nums[i] == nums[j]) {
                 j++;
             }
-            if(j == nums.length) j--;
+            if (j == nums.length) j--;
             int temp = nums[j];
-            nums[j] = nums[i+1];
-            nums[i+1] = temp;
-            if(nums[i] != nums[i+1]) i++;
-            if(j == nums.length) break;
+            nums[j] = nums[i + 1];
+            nums[i + 1] = temp;
+            if (nums[i] != nums[i + 1]) i++;
+            if (j == nums.length) break;
             j++;
         }
-        return i+1;
+        return i + 1;
     }
 
 }

src/main/java/com/fishercoder/solutions/_260.java

@@ -20,15 +20,15 @@ public class _260 {
     //Approach 1: normal hashmap
     public int[] singleNumber(int[] nums) {
         Map<Integer, Integer> map = new HashMap();
-        for(int i : nums){
-            map.put(i, map.getOrDefault(i, 0)+1);
+        for (int i : nums) {
+            map.put(i, map.getOrDefault(i, 0) + 1);
         }
 
         int[] res = new int[2];
         int index = 0;
-        for(int key : map.keySet()){
-            if(map.get(key) == 1) res[index++] = key;
-            if(index == 2) break;
+        for (int key : map.keySet()) {
+            if (map.get(key) == 1) res[index++] = key;
+            if (index == 2) break;
         }
         return res;
     }

src/main/java/com/fishercoder/solutions/_261.java

@@ -24,29 +24,29 @@
  */
 public class _261 {
 
-    public boolean validTree(int n, int[][] edges){
+    public boolean validTree(int n, int[][] edges) {
         int[] nums = new int[n];
-        for(int i =0; i < n; i++) {
+        for (int i = 0; i < n; i++) {
             nums[i] = i;
         }
 
-        for(int i = 0; i < edges.length; i++){
+        for (int i = 0; i < edges.length; i++) {
             int x = find(nums, edges[i][0]);
             int y = find(nums, edges[i][1]);
 
-            if(x == y) {
+            if (x == y) {
                 return false;
             }
 
             //union
             nums[x] = y;
         }
 
-        return edges.length == n-1;
+        return edges.length == n - 1;
     }
 
-    int find(int[] nums, int i){
-        if(nums[i] == i) {
+    int find(int[] nums, int i) {
+        if (nums[i] == i) {
             return i;
         }
         return find(nums, nums[i]);

src/main/java/com/fishercoder/solutions/_263.java

@@ -9,10 +9,10 @@
 public class _263 {
 
     public boolean isUgly(int num) {
-        if(num == 0) return false;
-        int[] divisors = new int[]{5,3,2};
-        for(int divisor : divisors){
-            while(num%divisor == 0){
+        if (num == 0) return false;
+        int[] divisors = new int[]{5, 3, 2};
+        for (int divisor : divisors) {
+            while (num % divisor == 0) {
                 num /= divisor;
             }
         }

src/main/java/com/fishercoder/solutions/_264.java

@@ -20,17 +20,17 @@ public int nthUglyNumber(int n) {
         for (int i = 1; i < n; i++) {
             int min = Math.min(Math.min(factor2, factor3), factor5);
             ugly[i] = min;
-            if(factor2 == min) {
+            if (factor2 == min) {
                 factor2 = 2 * ugly[++index2];
             }
-            if(factor3 == min) {
+            if (factor3 == min) {
                 factor3 = 3 * ugly[++index3];
             }
-            if(factor5 == min) {
+            if (factor5 == min) {
                 factor5 = 5 * ugly[++index5];
             }
         }
-        return ugly[n-1];
+        return ugly[n - 1];
     }
 
 }

src/main/java/com/fishercoder/solutions/_266.java

@@ -16,20 +16,20 @@
 public class _266 {
 
     public boolean canPermutePalindrome(String s) {
- 
+
         char[] chars = s.toCharArray();
         Map<Character, Integer> map = new HashMap<Character, Integer>();
-        for(char c : chars){
-            if(!map.containsKey(c)) map.put(c, 1); 
-            else map.put(c, map.get(c)+1);
+        for (char c : chars) {
+            if (!map.containsKey(c)) map.put(c, 1);
+            else map.put(c, map.get(c) + 1);
         }
         int evenCount = 0;
-        for(Map.Entry<Character, Integer> e : map.entrySet()){
-            if(e.getValue() % 2 != 0) evenCount++;
-            if(evenCount > 1) return false;
+        for (Map.Entry<Character, Integer> e : map.entrySet()) {
+            if (e.getValue() % 2 != 0) evenCount++;
+            if (evenCount > 1) return false;
         }
         return true;
-           
+
     }
 
 }

src/main/java/com/fishercoder/solutions/_268.java

@@ -14,10 +14,10 @@ public class _268 {
     then a number xor with itself is zero, so after we xor the entire array with all of its indices, the missing number will show up.*/
     public int missingNumber(int[] nums) {
         int xor = 0, i = 0;
-        for(; i < nums.length; i++){
-            xor = xor^i^nums[i];
+        for (; i < nums.length; i++) {
+            xor = xor ^ i ^ nums[i];
         }
-        return xor^i;
+        return xor ^ i;
     }
 
 }