一道机试题 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

明显少了很多循环次数