Skip to content

Instantly share code, notes, and snippets.

@edwingsm

edwingsm/Earlytime.java

Last active October 16, 2018 09:44
Show Gist options
  • Save edwingsm/bde126b55b4354d2bdaefb4681258996 to your computer and use it in GitHub Desktop.
Save edwingsm/bde126b55b4354d2bdaefb4681258996 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
Earlytime.java
package com.example.spring.integration.springintegrationdemo;
import java.util.Arrays;
import java.util.stream.IntStream;
public class EarlyTime {
public static void main(String[] args) {
long t1 = System.currentTimeMillis();
System.out.println(solution(1, 8, 2, 3, 6, 4));
System.out.println(solution(0, 0, 0, 7, 8, 9));// goes to nums[3]>6
System.out.println(solution(0, 1, 2, 7, 8, 9));// goes to nums[3]>6
System.out.println(solution(2, 4, 5, 9, 5, 9));// Invalid time
System.out.println(solution(2, 5, 5, 9, 5, 9));// Invalid time
System.out.println(solution(6, 5, 4, 3, 2, 1));// Happy path
System.out.println(solution(8, 1, 2, 4, 3, 6));
System.out.println(solution(9, 2, 8, 6, 7, 0));// Invalid time
System.out.println(solution(0, 0, 0, 0, 0, 0));// end points
System.out.println(solution(0, 0, 0, 0, 0, 1));// Happy Path
System.out.println(solution(2, 3, 5, 9, 5, 9));// goes to nums[3]<6 , endpoints
System.out.println(solution(0, 0, 2, 4, 0, 0));// Happy path
System.out.println(solution(4, 4, 4, 5, 9, 9));// Invalid time
// System.out.println(solution(4, -1, 4, 5, 9, 9));// Invalid time
long t2 = System.currentTimeMillis();
System.out.println(t2 - t1);
System.out.println("--------------------------------");
t1 = System.currentTimeMillis();
System.out.println(solve(1, 8, 2, 3, 6, 4));
System.out.println(solve(0, 0, 0, 7, 8, 9));// goes to nums[3]>6
System.out.println(solve(0, 1, 2, 7, 8, 9));// goes to nums[3]>6
System.out.println(solve(2, 4, 5, 9, 5, 9));// Invalid time
System.out.println(solve(2, 5, 5, 9, 5, 9));// Invalid time
System.out.println(solve(6, 5, 4, 3, 2, 1));// Happy path
System.out.println(solve(8, 1, 2, 4, 3, 6));
System.out.println(solve(9, 2, 8, 6, 7, 0));// Invalid time
System.out.println(solve(0, 0, 0, 0, 0, 0));// end points
System.out.println(solve(0, 0, 0, 0, 0, 1));// Happy Path
System.out.println(solve(2, 3, 5, 9, 5, 9));// goes to nums[3]<6 , endpoints
System.out.println(solve(0, 0, 2, 4, 0, 0));// Happy path
System.out.println(solve(4, 4, 4, 5, 9, 9));// Invalid time
t2 = System.currentTimeMillis();
System.out.println(t2 - t1);
System.out.println("--------------------------------");
t1 = System.currentTimeMillis();
System.out.println(solve_StringBuilder(1, 8, 2, 3, 6, 4));
System.out.println(solve_StringBuilder(0, 0, 0, 7, 8, 9));// goes to nums[3]>6
System.out.println(solve_StringBuilder(0, 1, 2, 7, 8, 9));// goes to nums[3]>6
System.out.println(solve_StringBuilder(2, 4, 5, 9, 5, 9));// Invalid time
System.out.println(solve_StringBuilder(2, 5, 5, 9, 5, 9));// Invalid time
System.out.println(solve_StringBuilder(6, 5, 4, 3, 2, 1));// Happy path
System.out.println(solve_StringBuilder(8, 1, 2, 4, 3, 6));
System.out.println(solve_StringBuilder(9, 2, 8, 6, 7, 0));// Invalid time
System.out.println(solve_StringBuilder(0, 0, 0, 0, 0, 0));// end points
System.out.println(solve_StringBuilder(0, 0, 0, 0, 0, 1));// Happy Path
System.out.println(solve_StringBuilder(2, 3, 5, 9, 5, 9));// goes to nums[3]<6 , endpoints
System.out.println(solve_StringBuilder(0, 0, 2, 4, 0, 0));// Happy path
System.out.println(solve_StringBuilder(4, 4, 4, 5, 9, 9));// Invalid time
t2 = System.currentTimeMillis();
System.out.println(t2 - t1);
// System.out.println(solve(4, -1, 4, 5, 9, 9));// Invalid time
}
public static String solution(int A, int B, int C, int D, int E, int F) {
// We need minimum of 2 integers in range [0,3] to make a valid hour
// We need minimum of 3 integers [0,5] to make valid seconds,min,hour
// Sort the number in ASC order
int[] nums = IntStream.of(A, B, C, D, E, F).filter(n -> n >= 0).sorted().toArray();
if (nums.length != 6)
return "NOT POSSIBLE";
int[] splittedTime = new int[] { nums[0] * 10 + nums[1], nums[2] * 10 + nums[3], nums[4] * 10 + nums[5] };
// splittedTime[0]=hour:splittedTime[1]=minutes:splittedTime[2]=seconds
if (!validateHour(splittedTime[0]) || !validateMinute(splittedTime[1])) {
// This means among given 6 integers , 5 integers are > 3, so can't make up a
// valid hour under 24 "OR"
// This means among given 6 integers, 4 integers are greater than > 5, so can't
// make up valid minutes, seconds
return "NOT POSSIBLE";
}
// Once the above condition passed, that means we have satisfied 2 rules, we can
// make valid time with given set of integers .
// It might/might not need some re-arrangement in order of elements in array to
// get earliest time
if (!validateSecond(splittedTime[2])) {
if (nums[3] < 6) {
// swapping maximum from minute with, minimum from second
int swapMin = nums[4];
int swapSecond = nums[3];
nums[3] = swapMin;
nums[4] = swapSecond;
// Can directly assign no need to keep it in temp variable
} else if (nums[3] > 6) {
// Kind of circular swapping between hour, minute and second
int[] firstHalf = Arrays.copyOfRange(nums, 0, nums.length / 2);
int[] secondHalf = Arrays.copyOfRange(nums, nums.length / 2, nums.length);
nums = IntStream
.of(firstHalf[0], secondHalf[0], firstHalf[1], secondHalf[1], firstHalf[2], secondHalf[2])
.toArray();
}
}
return String.format("%1$d%2$d:%3$d%4$d:%5$d%6$d", nums[0], nums[1], nums[2], nums[3], nums[4], nums[5]);
}
public static boolean validateHour(int hour) {
return hour < 24;
}
public static boolean validateMinute(int minute) {
return minute < 60;
}
public static boolean validateSecond(int second) {
return second < 60;
}
public static String solve(int A, int B, int C, int D, int E, int F) {
int[] d = IntStream.of(A, B, C, D, E, F).filter(n -> n >= 0).sorted().toArray();
final String timeSeparator = ":";
StringBuilder builder = new StringBuilder();
if (d[4] < 6) { // 2nd largest digit is smaller 6, we can just fill up
if (10 * d[0] + d[1] < 24)
return "" + d[0] + d[1] + ":" + d[2] + d[3] + ":" + d[4] + d[5];
else
return "impossible";
} else if (d[3] < 6) { // 3rd largest digit is smaller 6, put 2nd largest in 4th position
if (10 * d[0] + d[1] < 24)
return "" + d[0] + d[1] + ":" + d[2] + d[4] + ":" + d[3] + d[5];
else
return "impossible";
} else if (d[2] < 6) { // 4th largest digit is smaller 6, put 3rd largest in 2nd position
if (10 * d[0] + d[3] < 24)
return "" + d[0] + d[3] + ":" + d[1] + d[4] + ":" + d[2] + d[5];
else
return "impossible";
} else {
return "impossible";
}
}
public static String solve_StringBuilder(int A, int B, int C, int D, int E, int F) {
int[] d = IntStream.of(A, B, C, D, E, F).filter(n -> n >= 0).sorted().toArray();
final String timeSeparator = ":";
StringBuilder builder = new StringBuilder("impossible");
if (d[4] < 6) { // 2nd largest digit is smaller 6, we can just fill up
if (10 * d[0] + d[1] < 24) {
builder.setLength(0);
builder.append(d[0]).append(d[1]).append(timeSeparator).append(d[2]).append(d[3]).append(timeSeparator)
.append(d[4]).append(d[5]);
}
} else if (d[3] < 6) { // 3rd largest digit is smaller 6, put 2nd largest in 4th position
if (10 * d[0] + d[1] < 24) {
builder.setLength(0);
builder.append(d[0]).append(d[1]).append(timeSeparator).append(d[2]).append(d[4]).append(timeSeparator)
.append(d[3]).append(d[5]);
}
} else if (d[2] < 6) { // 4th largest digit is smaller 6, put 3rd largest in 2nd position
if (10 * d[0] + d[3] < 24) {
builder.setLength(0);
builder.append(d[0]).append(d[3]).append(timeSeparator).append(d[1]).append(d[4]).append(timeSeparator)
.append(d[2]).append(d[5]);
}
}
return builder.toString();
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment