681. Next Closest Time

681. Next Closest Time

Given a time represented in the format "HH:MM", form the next closest time by reusing the current digits. There is no limit on how many times a digit can be reused.
You may assume the given input string is always valid. For example, "01:34", "12:09" are all valid. "1:34", "12:9" are all invalid.
Example 1:
Input: "19:34"
Output: "19:39"
Explanation: The next closest time choosing from digits 1, 9, 3, 4, is 19:39, which occurs 5 minutes later.  It is not 19:33, because this occurs 23 hours and 59 minutes later.

Example 2:
Input: "23:59"
Output: "22:22"
Explanation: The next closest time choosing from digits 2, 3, 5, 9, is 22:22. It may be assumed that the returned time is next day‘s time since it is smaller than the input time numerically.




https://www.youtube.com/watch?v=IAet94C1FCc


https://leetcode.com/problems/next-closest-time/solution/
Solution 2 



%02d means "format the integer with 2 digits, left padding it with zeroes", so:
Format  Data   Result
%02d    1      01
%02d    11     11

 output of integer values in 2 or more digits, the first being zero if number less than or equal to 9


 Math.floorMod() examples 
https://www.geeksforgeeks.org/math-floormod-method-in-java/




// passed half test cases 
Input:
"22:23"
Output:
"22:30"
Expected:
"22:32"

// correct result 

class Solution {
    public String nextClosestTime(String time) {
        int start = 60 * Integer.parseInt(time.substring(0, 2));
        start += Integer.parseInt(time.substring(3));
        int ans = start;
        int elapsed = 24 * 60;
        Set<Integer> allowed = new HashSet();
        for (char c: time.toCharArray()) if (c != ‘:‘) {
            allowed.add(c - ‘0‘);
        }

        for (int h1: allowed) for (int h2: allowed) if (h1 * 10 + h2 < 24) {
            for (int m1: allowed) for (int m2: allowed) if (m1 * 10 + m2 < 60) {
                int cur = 60 * (h1 * 10 + h2) + (m1 * 10 + m2);
                int candElapsed = Math.floorMod(cur - start, 24 * 60);
                if (0 < candElapsed && candElapsed < elapsed) {
                    ans = cur;
                    elapsed = candElapsed;
                }
            }
        }

        return String.format("%02d:%02d", ans / 60, ans % 60);
    }
}



// wrong result
class Solution {
    public String nextClosestTime(String time) {
        int hour = Integer.valueOf(time.substring(0, 2));
        int min = Integer.valueOf(time.substring(3));
        int start = hour * 60 + min;
        int ans = start;
        int minDiff = 24 * 60;
        Set<Integer> allowed = new HashSet<>();
        for(char c : time.toCharArray()){
            allowed.add(c - ‘0‘);
        }
        
        
        for(int a : allowed){
            for(int b : allowed){
                for(int c : allowed){
                    for(int d : allowed){
                        if(a * 10 + b < 24 && c * 10 + d < 60){
                            int newTime = 60 * (a * 10 + b) + (c * 10 + d);
                            int diff = Math.floorMod(newTime - start, 24 * 60);
                            if(ans != start && diff < minDiff){
                                ans = newTime;
                                minDiff = diff;
                            }
                        }
                    }
                }
            }
        }
        return String.format("%02d:%02d", ans / 60 , ans % 60);
    }
}



class Solution {
    public String nextClosestTime(String time) {
      
      // first get all the number in time 
      // get the total minutes of the original time
      // generate all possible combinations 
      // compare them 
      // output the one with closest time 
      
      // get all the num
      // use a hashset to keep the distinct num
      HashSet<Integer> set = new HashSet<>();
      for(char c : time.toCharArray()){
        set.add(c - ‘0‘);
      }
      
      // get the total minutes of original time 
      String hour = time.substring(0, 2);
      String min = time.substring(3);
      // get the total mins
      
      int total = ((hour.charAt(0) - ‘0‘) * 10 + (hour.charAt(1) - ‘0‘)) * 60 + ((min.charAt(0) - ‘0‘) * 10 + (min.charAt(1) -‘0‘)) ;
      // initalize a value for the time difference between the original and new generated 
      int minDiff = 24 * 60;
      int newTime = 0;
      int ans = 0;
    
      
      
      // generate all possible time and compare along the way
      for(int a : set){
        for(int b : set){
          for(int c : set){
            for(int d : set){
              // check if the hour is valid 
              // check if the min is valid
              int h = a * 10 + b;
              int m = c * 10 + d;
              if(h >= 0 && h < 24 && m >= 0 && m < 60){
                newTime = (a * 10 + b) * 60 + (c * 10 + d);
              }
              // }else{
              //   continue;
              // }
          
              int diff = Math.floorMod(newTime - total, 24 * 60); // is combo - total
              // not the other way around, because its tmr or later today - today‘s 
              if(diff < minDiff && diff != 0){
                ans = newTime;
                minDiff = diff;
              }
            }
          }
        }
      }
      return String.format("%02d:%02d", ans / 60, ans % 60);
      
    }
}