Fixed sonar warnings.

Author: javadev

src/main/java/g1901_2000/s1904_the_number_of_full_rounds_you_have_played/Solution.java

@@ -1,54 +1,40 @@
 package g1901_2000.s1904_the_number_of_full_rounds_you_have_played;
 
-// #Medium #String #Math #2022_05_11_Time_2_ms_(37.11%)_Space_42.1_MB_(40.55%)
+// #Medium #String #Math #2022_05_12_Time_0_ms_(100.00%)_Space_40_MB_(96.23%)
 
 public class Solution {
-    public int numberOfRounds(String startTime, String finishTime) {
-        int rounds = 0;
-        int startHour = Integer.parseInt(startTime.split(":")[0]);
-        int endHour = Integer.parseInt(finishTime.split(":")[0]);
-        int startMin = Integer.parseInt(startTime.split(":")[1]);
-        int endMin = Integer.parseInt(finishTime.split(":")[1]);
-        if (endHour < startHour) {
-            endHour += 24;
-        } else if (endHour == startHour && endMin < startMin) {
-            endHour += 24;
+    private static final int MID_NIGHT_END = 1440;
+    private static final int MID_NIGHT_START = 0;
+    private static final int ROUND_INTERVAL = 15;
+
+    public int numberOfRounds(String loginTime, String logoutTime) {
+        int loginSerializeTime = serializeTime(loginTime);
+        int logoutSerializeTime = serializeTime(logoutTime);
+        if (logoutSerializeTime - 14 < loginSerializeTime
+                && logoutSerializeTime > loginSerializeTime) {
+            return 0;
+        }
+        loginSerializeTime = maskSerializeTime(loginSerializeTime, 14);
+        logoutSerializeTime = maskSerializeTime(logoutSerializeTime, 0);
+        if (loginSerializeTime == logoutSerializeTime) {
+            return 0;
         }
-        if (startHour == endHour) {
-            if (startMin == 0 && endMin >= 15) {
-                rounds++;
-            }
-            if (startMin <= 15 && endMin >= 30) {
-                rounds++;
-            }
-            if (startMin <= 30 && endMin >= 45) {
-                rounds++;
-            }
-            return rounds;
-        } else {
-            // compute all full rounds in the start hour
-            if (startMin == 0) {
-                rounds += 4;
-            } else if (startMin <= 15) {
-                rounds += 3;
-            } else if (startMin <= 30) {
-                rounds += 2;
-            } else if (startMin <= 45) {
-                rounds++;
-            }
+        if (loginSerializeTime > logoutSerializeTime + 14) {
+            return calculateFullRounds(loginSerializeTime, MID_NIGHT_END)
+                    + calculateFullRounds(MID_NIGHT_START, logoutSerializeTime);
+        }
+        return calculateFullRounds(loginSerializeTime, logoutSerializeTime);
+    }
 
-            // compute all full rounds in the finish hour
-            if (endMin >= 45) {
-                rounds += 3;
-            } else if (endMin >= 30) {
-                rounds += 2;
-            } else if (endMin >= 15) {
-                rounds++;
-            }
+    private int maskSerializeTime(int serializeTime, int mask) {
+        return (serializeTime + mask) / ROUND_INTERVAL * ROUND_INTERVAL;
+    }
 
-            // compute all full rounds in the all full hours between finishHour and startHour
-            rounds += (endHour - startHour - 1) * 4;
-            return rounds;
-        }
+    private int serializeTime(String time) {
+        return Integer.parseInt(time.substring(0, 2)) * 60 + Integer.parseInt(time.substring(3, 5));
+    }
+
+    private int calculateFullRounds(int login, int logout) {
+        return (logout - login) / ROUND_INTERVAL;
     }
 }

src/main/java/g1901_2000/s1906_minimum_absolute_difference_queries/Solution.java

@@ -6,7 +6,7 @@
 import java.util.BitSet;
 
 public class Solution {
-    static class SegmentTree {
+    private static class SegmentTree {
         static class Node {
             BitSet bits;
             int minDiff;
@@ -15,7 +15,7 @@ static class Node {
         int len;
         int[] nums;
         Node[] tree;
-        static final int inf = 200;
+        static final int INF = 200;
 
         SegmentTree(int[] nums, int len) {
             this.nums = Arrays.copyOf(nums, len);
@@ -25,21 +25,19 @@ static class Node {
         }
 
         private void buildTree(int i, int j, int ti) {
-            if (i > j) {
-                return;
-            } else if (i == j) {
-                Node node = new Node();
-                node.bits = new BitSet(101);
-                node.bits.set(nums[i]);
-                node.minDiff = inf;
-
-                tree[ti] = node;
-            } else {
-                int mid = i + (j - i) / 2;
-                buildTree(i, mid, 2 * ti + 1);
-                buildTree(mid + 1, j, 2 * ti + 2);
-
-                tree[ti] = combineNodes(tree[2 * ti + 1], tree[2 * ti + 2]);
+            if (i <= j) {
+                if (i == j) {
+                    Node node = new Node();
+                    node.bits = new BitSet(101);
+                    node.bits.set(nums[i]);
+                    node.minDiff = INF;
+                    tree[ti] = node;
+                } else {
+                    int mid = i + (j - i) / 2;
+                    buildTree(i, mid, 2 * ti + 1);
+                    buildTree(mid + 1, j, 2 * ti + 2);
+                    tree[ti] = combineNodes(tree[2 * ti + 1], tree[2 * ti + 2]);
+                }
             }
         }
 
@@ -57,8 +55,9 @@ private Node combineNodes(Node n1, Node n2) {
         }
 
         private int findMinDiff(BitSet bits) {
-            int first = bits.nextSetBit(1); // minimum value of number is 1.
-            int minDiff = inf;
+            // minimum value of number is 1.
+            int first = bits.nextSetBit(1);
+            int minDiff = INF;
             while (first != -1) {
                 int next = bits.nextSetBit(first + 1);
                 if (next != -1) {
@@ -69,42 +68,39 @@ private int findMinDiff(BitSet bits) {
                 }
                 first = next;
             }
-
             return minDiff;
         }
 
         private int findMinAbsDiff(int start, int end, int i, int j, int ti) {
-            Node node = _findMinAbsDiff(start, end, i, j, ti);
-            return node.minDiff == inf ? -1 : node.minDiff;
+            Node node = findMinAbsDiff2(start, end, i, j, ti);
+            return node.minDiff == INF ? -1 : node.minDiff;
         }
 
-        private Node _findMinAbsDiff(int start, int end, int i, int j, int ti) {
+        private Node findMinAbsDiff2(int start, int end, int i, int j, int ti) {
             if (i == start && j == end) {
                 return tree[ti];
             }
-
             int mid = i + (j - i) / 2;
             if (end <= mid) {
-                return _findMinAbsDiff(start, end, i, mid, 2 * ti + 1);
+                return findMinAbsDiff2(start, end, i, mid, 2 * ti + 1);
             } else if (start >= mid + 1) {
-                return _findMinAbsDiff(start, end, mid + 1, j, 2 * ti + 2);
+                return findMinAbsDiff2(start, end, mid + 1, j, 2 * ti + 2);
             } else {
-                Node left = _findMinAbsDiff(start, mid, i, mid, 2 * ti + 1);
-                Node right = _findMinAbsDiff(mid + 1, end, mid + 1, j, 2 * ti + 2);
+                Node left = findMinAbsDiff2(start, mid, i, mid, 2 * ti + 1);
+                Node right = findMinAbsDiff2(mid + 1, end, mid + 1, j, 2 * ti + 2);
                 return combineNodes(left, right);
             }
         }
     }
 
     public int[] minDifference(int[] nums, int[][] queries) {
-        int len = nums.length, qlen = queries.length;
+        int len = nums.length;
+        int qlen = queries.length;
         SegmentTree st = new SegmentTree(nums, len);
         int[] answer = new int[qlen];
-
         for (int i = 0; i < qlen; ++i) {
             answer[i] = st.findMinAbsDiff(queries[i][0], queries[i][1], 0, len - 1, 0);
         }
-
         return answer;
     }
 }

src/test/java/g1901_2000/s1904_the_number_of_full_rounds_you_have_played/SolutionTest.java

@@ -15,4 +15,9 @@ void numberOfRounds() {
     void numberOfRounds2() {
         assertThat(new Solution().numberOfRounds("21:30", "03:00"), equalTo(22));
     }
+
+    @Test
+    void numberOfRounds3() {
+        assertThat(new Solution().numberOfRounds("21:30", "21:30"), equalTo(0));
+    }
 }