第5周题目:翻硬币

[问题描述]（老师已经为宝宝们翻译好啦）
堆栈和队列通常被认为是数据结构的面包和黄油，可用于体系结构、解析，操作系统和离散事件模拟。堆栈在形式语言理论中也很重要。
现在的问题涉及黄油和煎饼(而不是面包)，同时还有一个根据唯一但完整的规则来翻煎饼的服务器。
给你一栈的煎饼，请你编写一个程序用于指示这个栈如何被排序以使得最大的煎饼在最下面而最小的煎饼在最上面。

煎饼的直径将被给出。

栈中的所有煎饼的直径都不一样。

对栈排序是通过一系列"翻转"来完成的。

一次翻转的意思是：在两个煎饼之间插入铲子，然后将铲子上面的一堆煎饼整体翻过来。也就是指定一个位置，其上的子栈整体翻转。

翻转的位置将会被给出。

位置是这样定义的：栈底编号为1，栈顶编号为n

一个栈的煎饼的给出方式，是从上到下给出煎饼的直径。

 
举例来说，这是三个栈，左边的栈的最上面的煎饼直径为8
8 7 2
4 6 5
6 4 8
7 8 4
5 5 6
2 2 7
 
左侧栈，可在位置3（即直径7）处翻转，得到中间的那个栈，而中间那个栈可在位置1（即直径2）处翻转，得到右侧的栈。
 
Input（输入）
输入由多个煎饼栈组成。每个栈有1到30个煎饼，每个煎饼的直径在1-100之间。以文档结束为输入结束。每个栈，独占一行，从左到右依次代表从栈顶到栈底的煎饼的直径，空格隔开。
 
Output（输出）
对于每个煎饼栈，输出首先应原样将栈的数据打印成一行。
随后的一行是翻转位置的次序，空格隔开，以0结束。（结束的目标是最大直径在最下面，最小直径在最上面）。

Sample Input
1 2 3 4 5
5 4 3 2 1
5 1 2 3 4
Sample Output
1 2 3 4 5
0
5 4 3 2 1
1 0
5 1 2 3 4
1 2 0

解析：
这个题目，一看就知道是模拟，当时我理解错误题目的意思了，我认为输入的N个状态就是需要我们进行推进的办法，结果不是，题目要求我们模拟每一种状态到目标状态的最后结果。

我写错的代码：

public class Solution1 {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        ArrayList list=new ArrayList<>();
        while (input.hasNext()){
            String s = input.nextLine();
            list.add(s);
        }
        /*list.add("1 2 3 4 5");
        list.add("5 4 3 2 1");
        list.add("5 1 2 3 4");*/
        for (int i = 0; i < 1; i++) {
            System.out.print(list.get(0));
        }
        System.out.println();
        System.out.println(0);
        StringBuilder tag = new StringBuilder();
        int len=list.get(0).split(" ").length;
        for (int i = 0; i < list.size()-1; i++) {
            String str1 = list.get(i).trim();
            String str2 = list.get(i + 1).trim();
            for (int j = 0; j < len; j++) {

                String[] s = str1.split(" ");
                String temp=s[0]+s[1]+s[2]+s[3]+s[4];
                String[] s1 = str2.split(" ");
                String temp2=s1[0]+s1[1]+s1[2]+s1[3]+s1[4];

                String dststr = temp.substring(j);
                String srcstr = temp.substring(0, j);
                StringBuffer reverse = new StringBuffer(dststr).reverse();
                String finalstr= srcstr+reverse;

                if(finalstr.equals(temp2)){
                    System.out.println(str2);
                    if (tag.length()!=0){
                        System.out.print(tag);
                    }
                    System.out.print((j+1)+" ");
                    if(tag.length()%2==0){
                        tag.append((j+1)+" ");
                    }else{
                        tag.append((j+1));
                    }
                    break;
                }
            }
            System.out.println(0);
        }
    }
}

正确模拟每一项解到目标解的写法：

public class Solution2{


    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()){
            String str = in.nextLine();
            String[] data_s1 = str.split(" ");
            int [] data= new int[data_s1.length];
            int i=0;
            for (String s:data_s1){
                data[i++]=Integer.parseInt(s);
            }
            System.out.println(str);
            Disposal(data);
        }
    }

    private static void Disposal(int[] data) {

        //目标数组
        int [] target=new int[data.length];
        System.arraycopy(data,0,target,0,data.length);
        Arrays.sort(target);

        int len=data.length;
        int p=len-1;
        while(p>0){
            // 从栈底开始搜索
            int i=indexOfData(data,target[p]);

            if(i==p){
                p--;
                continue;
            }
            if(i>0){
                fillP(data,len,len-i);
            }
            // 一次性全部翻转
            fillP(data,len,len-p);
            p--;
        }
        System.out.println(0);
    }

    private static void fillP(int[] data, int len, int i) {
        System.out.print(i+" ");
        int start=0;
        int end=len-i;
        while (start<end){
            data[start]^=data[end];
            data[end]^=data[start];
            data[start]^=data[end];
            start++;
            end--;
        }
    }

    private static int indexOfData(int[] data, int key) {
        for (int i = 0; i < data.length; i++) {
            if(data[i]==key){
                return i;
            }
        }
        return -1;
    }
}