一道机试题 2018-4-18

题目大意是：写一个方法，入参是六个整数，组合成当天最小时间，如果数字组不起来就输出NOT PROSSIBLE。
大致写了一个可以基本实现功能的，后续有时间再改进。如果大家有好的建议，欢迎指导。

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * @author Kevin 2018-4-18
 * 实现内容：实现六个数字组合的最小時間
 * 记录：
 *  逻辑基本实现  
 *  算法待优化，60秒60分24时自增待处理
 * 
 * 
 * 
 * 
 *
 */
public class Solution {
	public static void main(String[] args) throws ParseException {
		String date = solution0(2,3,5,0,1,0);
		System.out.println("result:"+date);
	}
	
	 /**
	  * 
	  * 2018-4-18
	 * @param A
	 * @param B
	 * @param C
	 * @param D
	 * @param E
	 * @param F
	 * @return
	 * @throws ParseException 
	 */
	public static String solution0(int A, int B, int C, int D, int E, int F) throws ParseException {
        // write your code in Java SE 8
		 
		 int[] a = {A,B,C,D,E,F};
		 Map<String,String> hourMap = new HashMap<>();
		 Map<String,String> secondMap = new HashMap<>();
		 String doubleZero = "00";
		 for(int i=0;i<a.length;i++){
			 
			 for(int j=0;j<a.length;j++){
				 
				 if(i == j)
					 continue;
				 int m = Integer.valueOf(String.valueOf(a[i])+String.valueOf(a[j]));
				 if(m>=0 && m<=24){
					 String key = String.valueOf(i)+String.valueOf(j);
					 if(m==0){
						 hourMap.put(key, doubleZero);
					 } else if(m<10){
						 hourMap.put(key, "0"+String.valueOf(m));
					 } else {
						 hourMap.put(key, String.valueOf(m));
					 }
				 }
				 if(m<=59){//暂且不处理60问题
					 String key = String.valueOf(i)+String.valueOf(j);
					 if(m==0){
						 secondMap.put(key, doubleZero);
					 } else if(m < 10){
						 secondMap.put(key, "0"+String.valueOf(m));
					 } else {
						 secondMap.put(key, String.valueOf(m));
					 }
				 }
				 
			 }
		 }
		 
		 Set<String> dateSet = new HashSet<>();
		 for(String key : hourMap.keySet()){
			 
			 for(String key1 : secondMap.keySet()){
				 
				 if(key == key1)
					 continue;
				 String first = key.substring(0, 1);
				 String second = key.substring(1, 2);
				 if(key1.contains(first) || key1.contains(second)){
					continue; 
				 }else{
					 for(String key2 : secondMap.keySet()){
						 if(key1 == key2 || key == key2)
							 continue;
						 String first0 = key1.substring(0, 1);
						 String second0 = key1.substring(1, 2);
						 if(key2.contains(first0) || key2.contains(second0)
								 || key2.contains(first) || key2.contains(second)){
							continue; 
						 }else{
							 //TODO 60分 60秒 24时 待处理
							 dateSet.add("2018-4-18 "+hourMap.get(key) + ":" +secondMap.get(key1) +":" +secondMap.get(key2));
						 }
					 }
				 }
			 }
		 }
		 
		 if(dateSet.size() == 0){
			 return "NOT PROSSIBLE";
		 }
		 
		 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//		 Date zeroDate = sdf.parse("2018-4-18 00:00:00");//作为当天最小时间基准值
//		 System.out.println(zeroDate.getTime());
		 List<Long> l = new ArrayList<>();
		 for(String s : dateSet){
			 Date date = sdf.parse(s);
			 l.add(date.getTime());
		 }
		 
		 //升序排序
		 Collections.sort(l,new Comparator<Long>(){
			@Override
			public int compare(Long o1, Long o2) {
				return (int) (o1 - o2);
			}
		 });
		 
		 return sdf.format(new Date((Long)l.get(0)));
     }

}

改进：先利用一次排序获取到小时，如果不满足就抛错，满足就只进行剩余四个数字的组合来满足分钟和秒数

public class Solution {
	public static void main(String[] args) throws ParseException {
		
		//取到排序后的
		int[] a = getSortedArr(2,3,5,8,1,9);
		String hourStr = String.valueOf(a[0]) + String.valueOf(a[1]);
		if(Integer.valueOf(hourStr) > 24){//如果最小的都不能满足小时，那就只能抛错。
			System.out.println("NOT PROSSIBLE");
			return;
		}
		
		//思路就是：先排序，取最小的两位，来充当小时；然后再把剩余的四个数放进去组合出分钟和秒数，减少循环次数
		int[] hour = new int[2];
		hour[0] = a[0];
		hour[1] = a[1];
		
		int[] four = new int[4];
		four[0] = a[2];
		four[1] = a[3];
		four[2] = a[4];
		four[3] = a[5];
		String str = solution(hour,four);
		System.out.println(str);
		
	}
	
	
	 /**
	  * 
	  * 2018-4-19
	 * @param A
	 * @param B
	 * @param C
	 * @param D
	 * @param E
	 * @param F
	 * @return
	 * @throws ParseException 
	 */
	public static String solution(int[] hour, int[] four) throws ParseException {

		Map<String, String> secondMap = new HashMap<>();
		String doubleZero = "00";
		for (int i = 0; i < four.length; i++) {
			for (int j = 0; j < four.length; j++) {
				if (i == j)
					continue;
				int m = Integer.valueOf(String.valueOf(four[i]) + String.valueOf(four[j]));
				if (m <= 59) {// 暂且不处理60问题
					String key = String.valueOf(i) + String.valueOf(j);
					if (m == 0) {
						secondMap.put(key, doubleZero);
					} else if (m < 10) {
						secondMap.put(key, "0" + String.valueOf(m));
					} else {
						secondMap.put(key, String.valueOf(m));
					}
				}
			}
		}

		Set<String> dateSet = new HashSet<>();
		for (String key1 : secondMap.keySet()) {

			for (String key2 : secondMap.keySet()) {
				if (key1 == key2)
					continue;
				String first0 = key1.substring(0, 1);
				String second0 = key1.substring(1, 2);
				if (key2.contains(first0) || key2.contains(second0)) {
					continue;
				} else {
					// TODO 60分 60秒 24时 待处理
					dateSet.add(
							"2018-4-18 " + hour[0] + hour[1] + ":" + secondMap.get(key1) + ":" + secondMap.get(key2));
				}
			}
		}

		if (dateSet.size() == 0) {
			return "NOT PROSSIBLE";
		}

		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		// Date zeroDate = sdf.parse("2018-4-18 00:00:00");//作为当天最小时间基准值
		// System.out.println(zeroDate.getTime());
		List<Long> l = new ArrayList<>();
		for (String s : dateSet) {
			Date date = sdf.parse(s);
			l.add(date.getTime());
		}

		// 升序排序
		Collections.sort(l, new Comparator<Long>() {
			@Override
			public int compare(Long o1, Long o2) {
				return (int) (o1 - o2);
			}
		});

		return sdf.format(new Date((Long) l.get(0)));
	}


	public static int[] getSortedArr(int A, int B, int C, int D, int E, int F){
		int[] arr = {A,B,C,D,E,F};
		
		int temp;//临时变量
	     for(int i=0; i<arr.length-1; i++){   //表示趟数，一共arr.length-1次。
	         for(int j=arr.length-1; j>i; j--){
	             if(arr[j] < arr[j-1]){
	                 temp = arr[j];
	                 arr[j] = arr[j-1];
	                 arr[j-1] = temp;
	             }
	         }
	     }
 
		return arr;
	}

}

结果：

old method循环了：1040次。
result:2018-04-18 12:38:59

firts sort count :15
new method循环了：56次。
2018-04-18 12:38:59

明显少了很多循环次数