Java 摩根和一串黑客

我在hackerrank中尝试Morgan和字符串挑战 （）

我的尝试如下：

public static void main(String[] args) {
        /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
        Scanner in = new Scanner(System.in);
        int testCases = in.nextInt();
        for(int i=0; i<testCases; i++){
            StringBuilder a = new StringBuilder(in.next());
            StringBuilder b = new StringBuilder(in.next());
            StringBuilder result = new StringBuilder();
            int indexA = 0;
            int indexB = 0;
            while(indexA < a.length() && indexB < b.length()){
                if(a.charAt(indexA)<=b.charAt(indexB)){
                    result.append(a.charAt(indexA));
                    indexA++;
                }
                else{
                    result.append(b.charAt(indexB));
                    indexB++;
                }
            }
            if(indexA==a.length()){
                result.append(b.substring(indexB,b.length()));
            }
            else{
                result.append(a.substring(indexA,a.length()));
            }
            System.out.println(result.toString());
        }

    }

publicstaticvoidmain（字符串[]args）{
/*在此处输入代码。从STDIN读取输入。将输出打印到STDOUT。您的类应命名为Solution*/
扫描仪输入=新扫描仪（系统输入）；
int testCases=in.nextInt（）；
对于（int i=0；i我认为，当两个堆栈的顶部都有相同的字母时，就会出现问题：你不能随意选择（你总是选择第一个或一个堆栈），但必须比较两个堆栈上的下一个字母（如果它们相等，那么后面的字母也相等，依此类推），这样您就可以确保最佳的连续性

例如

import java.util.ArrayDeque；
导入java.util.ArrayList；
导入java.util.Scanner；
导入java.util.Stack；
公共课晨练2{
静态字符串morganAndString（字符串a、字符串b）{
char[]a1=a.toCharArray（）；
char[]b1=b.toCharArray（）；
ArrayList s1=新的ArrayList（）；
ArrayDeque jackStack=新ArrayDeque（）；
ArrayDeque danielStack=新ArrayDeque（）；
对于（int i=a1.length-1；i>=0；i--）{
顶推（a1[i]）；
}
对于（int i=b1.length-1；i>=0；i--）{
danielStack.push（b1[i]）；
}
int min=数学min（a1.长度，b1.长度）；
int max=数学最大值（a1.长度，b1.长度）；
int杰克=0；
int=0；
int c=0；
而（！（jackStack.isEmpty（）| | danielStack.isEmpty（））{
if（jackStack.peek（）danielStack.peek（））{
s1.添加（danielStack.pop（））；
丹尼尔++；
}否则{
如果（a.子字符串（jack）.与（b.子字符串（daniel））>相比>0）{
s1.添加（danielStack.pop（））；
丹尼尔++；
}如果（a.子字符串（jack）.与（b.子字符串（daniel））=0，则为else{
s1.添加（danielStack.pop（））；
丹尼尔++；
}否则，如果（a.比较（b）哦！你的陈述似乎是正确的，而且这个例子非常清楚，我将尝试解决这个问题。虽然看起来不太容易。如果它们很容易，解决它们就没有乐趣了；）
input: bbb bba

your output: bbbbba
correct output: bbabbb

    import java.util.ArrayDeque;
    import java.util.ArrayList;
    import java.util.Scanner;
    import java.util.Stack;
    public class MorganStack2 {
    static String morganAndString(String a, String b) {


    char[] a1 = a.toCharArray();
    char[] b1 = b.toCharArray();


    ArrayList<Character> s1 = new ArrayList<>();

    ArrayDeque<Character> jackStack = new ArrayDeque<>();
    ArrayDeque<Character> danielStack = new ArrayDeque<>();


    for (int i = a1.length - 1; i >= 0; i--) {
        jackStack.push(a1[i]);

    }

    for (int i = b1.length - 1; i >= 0; i--) {
        danielStack.push(b1[i]);
    }


    int min = Math.min(a1.length, b1.length);
    int max = Math.max(a1.length, b1.length);

    int jack = 0;
    int daniel = 0;

    int c = 0;
    while (!(jackStack.isEmpty() || danielStack.isEmpty())) {
        if (jackStack.peek() < danielStack.peek()) {
            s1.add(jackStack.pop());
            jack++;
        } else if (jackStack.peek() > danielStack.peek()) {
            s1.add(danielStack.pop());
            daniel++;

        } else {
                if (a.substring(jack).compareTo(b.substring(daniel))>0){
                    s1.add(danielStack.pop());
                    daniel++;
                }else if (a.substring(jack).compareTo(b.substring(daniel))<0) 
                  {
                    s1.add(jackStack.pop());
                    jack++;
                }else{
                    if(a.compareTo(b)>=0){
                        s1.add(danielStack.pop());
                        daniel++;

                    }else  if(a.compareTo(b)<0){
                        s1.add(jackStack.pop());
                        jack++;

                    }else{
                        System.out.println("hyy");
                    }
                }


            }
            c++;
        }
      }
        // System.out.println(c);         AAAAAAAAAA
        //System.out.println(max);
        // System.out.println(min);
        if (jackStack.isEmpty()) {
            while (!danielStack.isEmpty()) {
                s1.add(danielStack.pop());
            }
        } else {
            while (!jackStack.isEmpty()) {
                s1.add(jackStack.pop());
            }
        }


        StringBuilder sb = new StringBuilder();

        for (Character s : s1) {
            sb.append(s);

        }


        return sb.toString();
    }



    private static final Scanner scanner = new Scanner(System.in);

    public static void main(String[] args)  {

    int t = scanner.nextInt();
    scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");

    for (int tItr = 0; tItr < t; tItr++) {
        String a = scanner.nextLine();

        String b = scanner.nextLine();

        String result = morganAndString(a, b);
        System.out.println(result);


       }



       scanner.close();
      }


  }