package Question1_9;
import java.util.Scanner;
import java.util.Vector;

public class Question1 {
  public static long count=0;
  private void fullPermutation(Vector<Character>sourse, Vector<Character> result) {
    if(sourse.size()==0){
      for (int i = 0; i < result.size(); i++) {
        System.out.print(result.elementAt(i));
      }
      System.out.print("\n");
      count++;
      return;
    }
    for (int i = 0; i < sourse.size(); i++) {
      Vector<Character>tsourse=new Vector<Character>(sourse);
      Vector<Character>tresult=new Vector<Character>(result);
      tresult.add(sourse.elementAt(i));
      tsourse.remove(i);
      new Question1().fullPermutation(tsourse, tresult);
    }
  }
  public static void main(String[] args) {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    Vector<Character> sourse=new Vector<Character>();
    Vector<Character> result=new Vector<Character>();
    for (int i = 0; i < n; i++) {
      sourse.add((char)('A'+i));
    }
    new Question1().fullPermutation(sourse, result);
    System.out.println(Question1.count);
  }
}

package Question1_9;
import java.util.Scanner;
import java.util.Vector;

public class Question2 {
  public static void main(String[] args) {
    Scanner scanner=new Scanner(System.in);
    String string=scanner.nextLine();
    Vector<Character>vector=new Vector<Character>();
    for (int i = 0; i < string.length(); i++) {
      vector.add(string.charAt(i));
    }

 

    try {

 

      int index=0;
      while (index<vector.size()) {
        if(index==0&&vector.elementAt(index)>='a'&&vector.elementAt(index)<='z'){
          vector.set(index, (char)(vector.elementAt(index)-('a'-'A')));
        }else if(vector.elementAt(index-1)==' '&&vector.elementAt(index)==' '){
          vector.remove(index);
          index--;
        }else if (vector.elementAt(index-1)==' '&&(vector.elementAt(index)>='a'&&vector.elementAt(index)<='z')) {
          vector.set(index, (char)(vector.elementAt(index)-('a'-'A')));
        }else if((vector.elementAt(index)>='a'&&vector.elementAt(index)<='z')&&(vector.elementAt(index-1)>='0'&&vector.elementAt(index-1)<='9')){
          vector.add(index, '_');
          index++;
        }else if((vector.elementAt(index-1)>='a'&&vector.elementAt(index-1)<='z')&&(vector.elementAt(index)>='0'&&vector.elementAt(index)<='9')){
          vector.add(index, '_');
          index++;
        }
        index++;
      }

      for (int i = 0; i <vector.size(); i++) {
        System.out.print(vector.elementAt(i));
      }
      System.out.println();


    } catch (ArrayIndexOutOfBoundsException e) {
      // TODO: handle exception
    }

 

  }
}

package Question1_9;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.Vector;

public class Question3 {
  public static long count=0;
  public static List<Vector<Character>> filteredNonRedundantResults;
  private static boolean isfilter(Vector<Character> result) {
    int a=(result.elementAt(0)-'0')*10+(result.elementAt(1)-'0');
    int b=(result.elementAt(2)-'0')*10+(result.elementAt(3)-'0');
    int c=(result.elementAt(4)-'0')*10+(result.elementAt(5)-'0');
    int d=(result.elementAt(6)-'0')*100+(result.elementAt(7)-'0')*10+(result.elementAt(8)-'0');
    if(a*b==c*d){
      return true;
    }
    return false;

  }
  public static void print(Vector<Character>vector) {
    System.out.printf("%c%c x %c%c = %c%c x %c%c%c",vector.elementAt(0),vector.elementAt(1),vector.elementAt(2),vector.elementAt(3),vector.elementAt(4),vector.elementAt(5),vector.elementAt(6),vector.elementAt(7),vector.elementAt(8));
  }


  private static void fullPermutation(Vector<Character>sourse, Vector<Character> result) {
    if(sourse.size()==0&&isfilter(result)){
      boolean exit=false;
      for (int i = 0; i < filteredNonRedundantResults.size(); i++) {
        int ra=(result.elementAt(0)-'0')*10+(result.elementAt(1)-'0');
        int rb=(result.elementAt(2)-'0')*10+(result.elementAt(3)-'0');
        int fa=(filteredNonRedundantResults.get(i).elementAt(0)-'0')*10+(filteredNonRedundantResults.get(i).elementAt(1)-'0');
        int fb=(filteredNonRedundantResults.get(i).elementAt(2)-'0')*10+(filteredNonRedundantResults.get(i).elementAt(3)-'0');
        if(ra==fb&&rb==fa){
          exit=true;
          break;
        }
      }
      if(exit==false){
        filteredNonRedundantResults.add(new Vector<Character>(result));
      }
      return;
    }
    for (int i = 0; i < sourse.size(); i++) {
      result.add(sourse.elementAt(i));
      sourse.remove(i);
      fullPermutation(sourse, result);
      sourse.add(i, result.elementAt(result.size()-1));
      result.remove(result.size()-1);
    }
  }

 

  public static void main(String[] args) {
    Scanner scanner=new Scanner(System.in);
    int n=9;
    Vector<Character> sourse=new Vector<Character>();
    Vector<Character> result=new Vector<Character>();
    for (int i = 1; i <= n; i++) {
      sourse.add((char)('0'+i));
    }


    Question3.filteredNonRedundantResults=new ArrayList<Vector<Character>>();


    Question3.fullPermutation(sourse, result);


    for (int i = 0; i < Question3.filteredNonRedundantResults.size(); i++) {
      Question3.print(Question3.filteredNonRedundantResults.get(i));
      System.out.println();
    }
  }
}

package Question1_9;
import java.util.Scanner;
import java.util.Stack;
import java.util.Vector;


public class Question4 {
  public static void main(String[] args) {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    scanner.nextLine(); //必須加上的,不然會(huì)導(dǎo)致輸入不準(zhǔn)確!
    while (n>0) {
      String string=scanner.nextLine();
      String strings[]=string.split("C");
      strings[0]=strings[0].substring(1, strings[0].length());
      int hangshu=Integer.parseInt(strings[0]),lieshu=Integer.parseInt(strings[1]);//獲取行數(shù)和列數(shù)
      /*
       * 對(duì)列數(shù)進(jìn)行變換
       */
      Stack<Character>stack=new Stack<Character>();
      while(lieshu>0){
        if(lieshu%26==0){
          stack.push('Z');
          lieshu=lieshu/26-1;
        }else {
          stack.push((char)('A'-1+lieshu%26));
          lieshu=lieshu/26;
        }
      }

      while (!stack.empty()) {
        System.out.print(stack.pop());
      }
      System.out.println(hangshu);
      n--;
    }
  }
}
 

/*
30年的改革開放，給中國(guó)帶來(lái)了翻天覆地的變化。2011全年中國(guó)手機(jī)產(chǎn)量約為11.72億部。手機(jī)已經(jīng)成為百姓的基本日用品！ 給手機(jī)選個(gè)好聽又好記的號(hào)碼可能是許多人的心愿。
但號(hào)源有限，只能輔以有償選號(hào)的方法了。
這個(gè)程序的目的就是：根據(jù)給定的手機(jī)尾號(hào)（4位），按照一定的規(guī)則來(lái)打分。其規(guī)則如下：
1. 如果出現(xiàn)連號(hào)，不管升序還是降序，都加5分。例如：5678,4321都滿足加分標(biāo)準(zhǔn)。
2. 前三個(gè)數(shù)字相同，或后三個(gè)數(shù)字相同，都加3分。例如：4888,6665,7777都滿足加分的標(biāo)準(zhǔn)。
注意：7777因?yàn)闈M足這條標(biāo)準(zhǔn)兩次，所以這條規(guī)則給它加了6分。
3. 符合AABB或者ABAB模式的加1分。例如：2255,3939,7777都符合這個(gè)模式，所以都被加分。
注意：7777因?yàn)闈M足這條標(biāo)準(zhǔn)兩次，所以這條標(biāo)準(zhǔn)給它加了2分。
4. 含有：6，8，9中任何一個(gè)數(shù)字，每出現(xiàn)一次加1分。例如4326,6875,9918都符合加分標(biāo)準(zhǔn)。其中，6875被加2分；9918被加3分。
尾號(hào)最終得分就是每條標(biāo)準(zhǔn)的加分總和！
要求程序從標(biāo)準(zhǔn)輸入接收數(shù)據(jù)，在標(biāo)準(zhǔn)輸出上輸出結(jié)果。
輸入格式為：第一行是一個(gè)整數(shù)n（<100），表示下邊有多少輸入行，接下來(lái)是n行4位一組的數(shù)據(jù)，就是等待計(jì)算加分的手機(jī)尾號(hào)。

例如，輸入：
14
3045
….
…..
6789
8866
則輸出：
0
0
….
…
8
5
*/

package Question1_9;
import java.util.Scanner;
import java.util.Stack;
import java.util.Vector;


public class Question5 {
  public static void main(String[] args) {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    scanner.nextLine();
    while ((n--)>0) {
      String telphone=scanner.nextLine();
      int sum=0;
      /*
       * 情況一
       */
      if(telphone.charAt(0)-telphone.charAt(1)==1){
        char ch=telphone.charAt(0);
        int index=0;
        while (index<4&&ch==telphone.charAt(index)) {
          ch--;
          index++;
        }
        if(index>=4){
          sum+=5;
        }
      }
      if (telphone.charAt(0)-telphone.charAt(1)==-1) {
        char ch=telphone.charAt(0);
        int index=0;
        while (index<4&&ch==telphone.charAt(index)) {
          ch++;
          index++;
        }
        if(index>=4){
          sum+=5;
        }
      }
      /*
       * 情況二
       */
      if (telphone.charAt(0)==telphone.charAt(1)&&telphone.charAt(1)==telphone.charAt(2)) {
        sum+=3;
      }
      if(telphone.charAt(1)==telphone.charAt(2)&&telphone.charAt(2)==telphone.charAt(3)){
        sum+=3;
      }

      /*
       * 情況三
       */
      if(telphone.charAt(0)==telphone.charAt(1)&&telphone.charAt(2)==telphone.charAt(3)){
        sum+=1;
      }
      if(telphone.charAt(0)==telphone.charAt(2)&&telphone.charAt(1)==telphone.charAt(3)){
        sum+=1;
      }
      /*
       * 情況四
       */
      for (int i = 0; i < 4; i++) {
        if(telphone.charAt(i)=='6'||telphone.charAt(i)=='8'||telphone.charAt(i)=='9'){
          sum+=1;
        }
      }
      System.out.println(sum);
    }
  }
}

import java.util.*;

public class Demo06 {
  public static boolean isGoodBracket(String s) {
    Stack<Character> a = new Stack<Character>();
    for (int i = 0; i < s.length(); i++) {
      char c = s.charAt(i);
      if (c == '(')
        a.push(')');
      if (c == '[')
        a.push(']');
      if (c == '{')
        a.push('}');
      if (c == ')' || c == ']' || c == '}') {
        if (a.size()==0)
          return false; // 填空
        if (a.pop() != c)
          return false;
      }
    }
    if (a.size()!=0)
      return false; // 填空
    return true;
  }
  public static void main(String[] args) {
    System.out.println(isGoodBracket("...(..[.)..].{.(..).}..."));
    System.out.println(isGoodBracket("...(..[...].(.).).{.(..).}..."));
    System.out.println(isGoodBracket(".....[...].(.).){.(..).}..."));
    System.out.println(isGoodBracket("...(..[...].(.).){.(..)...."));
  }
}

/*
下面代碼模擬了一套撲克牌（初始排序A~K，共13張）的操作過(guò)程。
操作過(guò)程是：
手里拿著這套撲克牌，從前面拿一張放在后面，再?gòu)那懊婺靡粡埛抛雷由?，再?gòu)那懊婺靡粡埛旁诤竺妫?...
如此循環(huán)操作，直到剩下最后一張牌也放在桌子上。
下面代碼的目的就是為了求出最后桌上的牌的順序。
初始的排列如果是A,2,3...K，則最后桌上的順序?yàn)椋?
[2, 4, 6, 8, 10, Q, A, 5, 9, K, 7, 3, J]
請(qǐng)分析代碼邏輯，并推測(cè)劃線處的代碼。
答案寫在 “解答.txt” 文件中
注意：只寫劃線處應(yīng)該填的內(nèi)容，劃線前后的內(nèi)容不要抄寫。
*/
package Question1_9;
import java.util.Arrays;
import java.util.List;
import java.util.Vector;

public class Question7 {
  public static List moveCard(List src) {
    if (src == null)
      return null;

    List dst = new Vector();
    for (;;) {
      if (src.size()==0)
            break;   // 填空
      src.add(src.remove(0));
      dst.add(src.remove(0));        // 填空
    }

    return dst;
  }

  public static void main(String[] args) {
    List a = new Vector();
    a.addAll(Arrays.asList("A", "2", "3", "4", "5", "6", "7", "8", "9",
        "10", "J", "Q", "K"));

    System.out.println(moveCard(a));
  }
}

/*
以下的靜態(tài)方法實(shí)現(xiàn)了：把串s中第一個(gè)出現(xiàn)的數(shù)字的值返回。
如果找不到數(shù)字，返回-1
例如：
s = "abc24us43" 則返回2
s = "82445adb5" 則返回8
s = "ab"  則返回-1
請(qǐng)分析代碼邏輯，并推測(cè)劃線處的代碼。
答案寫在 “解答.txt” 文件中
注意：只寫劃線處應(yīng)該填的內(nèi)容，劃線前后的內(nèi)容不要抄寫。
*/
public class Demo04 {
  public static int getFirstNum(String s) {
    if (s == null || s.length() == 0)
      return -1;

    char c = s.charAt(0);
    if (c >= '0' && c <= '9')
      return s.charAt(0)-'0'; // 填空

    return getFirstNum(s.substring(1)); // 填空
  }
  public static void main(String[] args) {
    String s1 = "abc24us43"; //則返回2
    String s2 = "82445adb5"; //則返回8
    String s3 = "ab";  //則返回-1  
    System.out.println(getFirstNum(s1));
    System.out.println(getFirstNum(s2));
    System.out.println(getFirstNum(s3));
  }
}

/*  
你一定聽說(shuō)過(guò)這個(gè)故事。國(guó)王對(duì)發(fā)明國(guó)際象棋的大臣很佩服，
問他要什么報(bào)酬，大臣說(shuō)：請(qǐng)?jiān)诘?個(gè)棋盤格放1粒麥子，
在第2個(gè)棋盤格放2粒麥子，在第3個(gè)棋盤格放4粒麥子，
在第4個(gè)棋盤格放8粒麥子，......后一格的數(shù)字是前一格的兩倍，
直到放完所有棋盤格（國(guó)際象棋共有64格）。
國(guó)王以為他只是想要一袋麥子而已，哈哈大笑。
當(dāng)時(shí)的條件下無(wú)法準(zhǔn)確計(jì)算，但估算結(jié)果令人吃驚：即使全世界都鋪滿麥子也不夠用！
請(qǐng)你借助計(jì)算機(jī)準(zhǔn)確地計(jì)算，到底需要多少粒麥子。
答案寫在“解答.txt”中，不要寫在這里！
*/
package Question1_9;
import java.math.BigInteger;


public class Question9 {
  public static void main(String[] args) {
    BigInteger total=new BigInteger("0"); 
    BigInteger base=new BigInteger("2");
    for (int i = 0; i < 64; i++) {
      total=total.add(base.pow(i));
      //System.out.println(total);
    }
    System.out.println(total);
    System.out.println(base.pow(64).add(new BigInteger("-1")));

  }

}

package Question10_19;

import java.math.BigInteger;
import java.util.Scanner;

class Question10Think2OptimizeMustRemember {
  public static int size;
  public static int array[]={0,1,2,3,4,5,6,7,8,9};
  public static BigInteger powArray[] = new BigInteger[10]; // 記錄0~9的size次方
  public static int usedTimes[]=new int[10];// 記錄0~9的使用次數(shù)
  public static BigInteger iPowSizeMultiplyj[][]; //記錄0到9中任意數(shù)字i的N次方乘以i出現(xiàn)的次數(shù)j的結(jié)果（i^N*j）
  public static BigInteger MAX; // size位的數(shù)字能表示的最大值
  public static BigInteger MIN; // size位的數(shù)字能表示的最小值

  public static void init() {// 用于初始化powArray[],MAX,MIN

    for (int i = 0; i < 10; i++) {// 初始化powArray[]
      powArray[i] = (new BigInteger("" + i)).pow(size);
    }

    MIN = (new BigInteger("10")).pow(size - 1); // 初始化最小值
    MAX = (new BigInteger("10").pow(size).add(new BigInteger("-1")));// 初始化最大值


    iPowSizeMultiplyj=new BigInteger[10][size+1]; //初始化iPowSizeMultiplyj[][]
    for (int i = 0; i < 10; i++) {
      iPowSizeMultiplyj[i][0]=BigInteger.valueOf(0);
      for (int j = 1; j < size+1; j++) {
        iPowSizeMultiplyj[i][j]=iPowSizeMultiplyj[i][j-1].add(powArray[i]);
      }
    }
  }

  public static void exhaustion(int arrayIndex,int used,BigInteger current) { 
    if (current.compareTo(MAX)>1) {//超過(guò)最大值,遞歸結(jié)束
      return;
    }


    if(used==size){//size位全部分配完畢
      if(current.compareTo(MIN)<0){ //已獲得的值小于最小值
        return;
      }else {
        String s=current+"";
        int avaliableValueUsed[]=new int[10];
        for (int i = 0; i < s.length(); i++) {
          avaliableValueUsed[s.charAt(i)-'0']++;
        }
        for (int i = 0; i < 10; i++) {
          if(usedTimes[i]!=avaliableValueUsed[i]){
            return;
          }
        }
        System.out.println(current);
        return;
      }

    }
    if(arrayIndex==0){
      usedTimes[0]=size-used;
      exhaustion(-1, size, current);
      usedTimes[0]=0;
      return;
    }
    if(current.add(iPowSizeMultiplyj[arrayIndex][size-used]).compareTo(MIN)<0){
      return;
    }

    if(arrayIndex>=0){
      for (int i = 0; i <= size-used; i++) {
        if(current.add(iPowSizeMultiplyj[arrayIndex][i]).compareTo(MAX)>0){
          return;
        }
        usedTimes[arrayIndex]=i;
        exhaustion(arrayIndex-1, used+i,current.add(iPowSizeMultiplyj[arrayIndex][i]));
        usedTimes[arrayIndex]=0;
      }
    }else {
      return;//1到9已分配完畢,不可再延伸了
    }
  }

  public static void main(String[] args) {
//   Scanner scanner = new Scanner(System.in);
//   Question10Think2.size = scanner.nextInt();

    long startTime = System.currentTimeMillis();  // 程序開始時(shí)間
    Question10Think2OptimizeMustRemember.size=21;
    Question10Think2OptimizeMustRemember.init();

    Question10Think2OptimizeMustRemember.exhaustion(9, 0, BigInteger.valueOf(0));


    long endTime = System.currentTimeMillis(); // 程序結(jié)束時(shí)間
    System.out.println((endTime-startTime)/1000f+"秒"); // 運(yùn)行總時(shí)
  }
}

/* 
今年的植樹節(jié)（2012年3月12日），小明和他的叔叔還有小伙伴們一起去植樹。
休息的時(shí)候，小明的同學(xué)問他叔叔多大年紀(jì)，他叔叔說(shuō)：“我說(shuō)個(gè)題目，看你們誰(shuí)先猜出來(lái)！”
“把我出生的年月日連起來(lái)拼成一個(gè)8位數(shù)（月、日不足兩位前補(bǔ)0）正好可以被今天的年、月、日整除！”
他想了想，又補(bǔ)充到：“再給個(gè)提示，我是6月出生的。”
根據(jù)這些信息，請(qǐng)你幫小明算一下，他叔叔的出生年月日。
答案寫在“解答.txt”中，不要寫在這里！
格式是年月日連成的8位數(shù)。
例如，如果是1948年6月12日，就寫：19480612
 */
package Question10_19;

public class Question11 {
  public static void main(String[] args) {
    for (int i = 20120312; ; i--) {
      String s=""+i;
      int year=Integer.parseInt(s.substring(0, 4));
      int month=Integer.parseInt(s.substring(4, 6));
      int day=Integer.parseInt(s.substring(6, 8));

  //   System.out.println(year+" "+month+" "+day);
      if(day==0||day>31){
        continue;
      }
      if(!(i%2012==0&&i%3==0&&i%12==0)){
        continue;
      }
      if(month!=6){
        continue;
      }
      System.out.println(i);
      break;
    }
  }
}

/*
看這個(gè)算式：
☆☆☆ + ☆☆☆ = ☆☆☆
如果每個(gè)五角星代表 1 ~ 9 的不同的數(shù)字。
這個(gè)算式有多少種可能的正確填寫方法？
173 + 286 = 459
295 + 173 = 468
173 + 295 = 468
183 + 492 = 675
以上都是正確的填寫法！
注意：
111 + 222 = 333 是錯(cuò)誤的填寫法！
因?yàn)槊總€(gè)數(shù)字必須是不同的！
也就是說(shuō)：1~9中的所有數(shù)字，每個(gè)必須出現(xiàn)且僅出現(xiàn)一次！
注意：
不包括數(shù)字“0”！
注意：
滿足加法交換率的式子算兩種不同的答案。
所以答案肯定是個(gè)偶數(shù)！

注意：
只要求計(jì)算不同的填法的數(shù)目
不要求列出所有填寫法
更不要求填寫源代碼！
*/

package Question10_19;

import java.util.Vector;

public class Question12 {
  public static int count;
  public static void AllType(Vector<Character> sourse,Vector<Character>result) {
    if(sourse.size()==0){
      //System.out.println(result);
      int a=(result.elementAt(0)-'0')*100+(result.elementAt(1)-'0')*10+result.elementAt(2)-'0';
      int b=(result.elementAt(3)-'0')*100+(result.elementAt(4)-'0')*10+result.elementAt(5)-'0';
      int c=(result.elementAt(6)-'0')*100+(result.elementAt(7)-'0')*10+result.elementAt(8)-'0';
      if(a+b==c){
        System.out.printf("%d + %d = %d\n",a,b,c);
        count++;
      }
    }else{
      for (int i = 0; i < sourse.size(); i++) {
        result.add(sourse.elementAt(i));
        sourse.remove(i);
        AllType(sourse, result);
        sourse.add(i, result.elementAt(result.size()-1));
        result.remove(result.size()-1);
      }
    }
  }
  public static void main(String[] args) {
    Vector<Character>sourse=new Vector<Character>();
    Vector<Character>result=new Vector<Character>();
    for (int i = 1; i <= 9; i++) {
      sourse.add((char)('0'+i));
    }
    AllType(sourse, result);
    System.out.println(count);
  }
}

/*
【編程題】(滿分34分)
這是一個(gè)縱橫火柴棒游戲。如圖[1.jpg]，在3x4的格子中，游戲的雙方輪流放置火柴棒。其規(guī)則是：
1. 不能放置在已經(jīng)放置火柴棒的地方（即只能在空格中放置）。
2. 火柴棒的方向只能是豎直或水平放置。
3. 火柴棒不能與其它格子中的火柴“連通”。所謂連通是指兩根火柴棒可以連成一條直線，
且中間沒有其它不同方向的火柴“阻攔”。
例如：圖[1.jpg]所示的局面下，可以在C2位置豎直放置（為了方便描述格子位置，圖中左、下都添加了標(biāo)記），
但不能水平放置，因?yàn)闀?huì)與A2連通。同樣道理，B2，B3，D2此時(shí)兩種方向都不可以放置。但如果C2豎直放置后，
D2就可以水平放置了，因?yàn)椴辉贂?huì)與A2連通（受到了C2的阻擋）。
4. 游戲雙方輪流放置火柴，不可以棄權(quán)，也不可以放多根。直到某一方無(wú)法繼續(xù)放置，則該方為負(fù)（輸?shù)囊环剑?
游戲開始時(shí)可能已經(jīng)放置了多根火柴。
你的任務(wù)是：編寫程序，讀入初始狀態(tài)，計(jì)算出對(duì)自己最有利的放置方法并輸出。
如圖[1.jpg]的局面表示為：
00-1
-000
0100
即用“0”表示空閑位置，用“1”表示豎直放置，用“-”表示水平放置。
【輸入、輸出格式要求】
用戶先輸入整數(shù) n(n<100), 表示接下來(lái)將輸入 n 種初始局面，每種局面占3行(多個(gè)局面間沒有空白行)。
程序則輸出：每種初始局面情況下計(jì)算得出的最佳放置法（行號(hào)+列號(hào)+放置方式）。
例如：用戶輸入：
2
0111
-000
-000
1111
----
0010
則程序可以輸出：
00-
211
不難猜出，輸出結(jié)果的含義為：
對(duì)第一個(gè)局面，在第0行第0列水平放置
對(duì)第二個(gè)局面，在第2行第1列垂直放置
注意：
行號(hào)、列號(hào)都是從0開始計(jì)數(shù)的。
對(duì)每種局面可能有多個(gè)最佳放置方法（解不唯一），只輸出一種即可。
例如，對(duì)第一個(gè)局面，001 也是正解；最第二個(gè)局面，201也是正解。
*/

package Question10_19;

import java.util.Scanner;

public class Question13 {
  public static boolean isOk(char[][] state, int i, int j) {
    if (state[i][j] == '-') {
      for (int j2 = j + 1; j2 < 4; j2++) {
        if (state[i][j2] == '-') {
          return false;
        } else if (state[i][j2] == '1') {
          return true;
        }
      }
      for (int j2 = j - 1; j2 >= 0; j2--) {
        if (state[i][j2] == '-') {
          return false;
        } else if (state[i][j2] == '1') {
          return true;
        }
      }

    } else if (state[i][j] == '1') {
      for (int i2 = i + 1; i2 < 3; i2++) {
        if (state[i2][j] == '1') {
          return false;
        } else if (state[i2][j] == '-') {
          return true;
        }
      }
      for (int i2 = i - 1; i2 >= 0; i2--) {
        if (state[i2][j] == '1') {
          return false;
        } else if (state[i2][j] == '-') {
          return true;
        }
      }
    }

    return true;
  }

  private static void jasdklf(char[][] state) {
    for (int i = 0; i < 3; i++) {
      for (int j = 0; j < 4; j++) {
        if (state[i][j] == '0') {
          state[i][j] = '-';
          if (isOk(state, i, j)) {
            System.out.println(i + "" + j + '-');
            return;
          }
          state[i][j] = '0';

          state[i][j] = '1';
          if (isOk(state, i, j)) {
            System.out.println(i + "" + j + '1');
            return;
          }
          state[i][j] = '0';
        }
      }
    }
  }

  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int n = scanner.nextInt();
    scanner.nextLine();
    char[][] state = new char[3][4];
    String s;
    while ((n--) > 0) {
      for (int i = 0; i < 3; i++) {
        s = scanner.nextLine();
        for (int j = 0; j < 4; j++) {
          state[i][j] = s.charAt(j);
        }

      }
      jasdklf(state);
    }
  }

}

/* 
 * 【編程題】(滿分23分)
俗話說(shuō)：十賭九輸。因?yàn)榇蠖鄶?shù)賭局的背后都藏有陰謀。不過(guò)也不盡然，有些賭局背后藏有的是：“陽(yáng)謀”。
有一種賭局是這樣的：桌子上放六個(gè)匣子，編號(hào)是1至6。多位參與者（以下稱玩家）可以把任意數(shù)量的錢押在某個(gè)編號(hào)的匣子上。
所有玩家都下注后，莊家同時(shí)擲出3個(gè)骰子（骰子上的數(shù)字都是1至6）。輸贏規(guī)則如下：
1. 若某一個(gè)骰子上的數(shù)字與玩家所押注的匣子號(hào)相同，則玩家拿回自己的押注，莊家按他押注的數(shù)目賠付（即1比1的賠率）。
2. 若有兩個(gè)骰子上的數(shù)字與玩家所押注的匣子號(hào)相同，則玩家拿回自己的押注，莊家按他押注的數(shù)目的2倍賠付（即1比2的賠率）。
3. 若三個(gè)骰子上的數(shù)字都與玩家所押注的匣子號(hào)相同，則玩家拿回自己的押注，莊家按他押注的數(shù)目的6倍賠付（即1比6的賠率）。
4. 若玩家所押注匣子號(hào)與某個(gè)骰子示數(shù)乘積等于另外兩個(gè)骰子示數(shù)的乘積，則玩家拿回自己的押注，莊家也不賠付（流局）。
5. 若以上規(guī)則有同時(shí)滿足者，玩家可以選擇對(duì)自己最有利的規(guī)則。規(guī)則執(zhí)行后，則莊家收獲所有匣子上剩余的押注。
乍一看起來(lái)，好像規(guī)則對(duì)玩家有利，莊家吃虧。但經(jīng)過(guò)大量實(shí)戰(zhàn)，會(huì)發(fā)現(xiàn)局面很難說(shuō)，于是懷疑是否莊家做了手腳，
莊家則十分爽快地說(shuō)：可以由玩家提供骰子，甚至也可以由玩家來(lái)投擲骰子。
你的任務(wù)是：通過(guò)編程模擬該過(guò)程。模擬50萬(wàn)次，假定只有1個(gè)玩家，他每次的押注都是1元錢，其押注的匣子號(hào)是隨機(jī)的。
再假定莊家有足夠的資金用于賠付。最后計(jì)算出莊家的盈率（莊家盈利金額/押注總金額）。
【輸入、輸出格式要求】
程序無(wú)輸入，程序運(yùn)行輸出莊家的盈率，四舍五入保留到小數(shù)后3位。
【注意】
請(qǐng)仔細(xì)調(diào)試！您的程序只有能運(yùn)行出正確結(jié)果的時(shí)候才有機(jī)會(huì)得分！
請(qǐng)把所有類寫在同一個(gè)文件中，調(diào)試好后，存入與【考生文件夾】下對(duì)應(yīng)題號(hào)的“解答.txt”中即可。
相關(guān)的工程文件不要拷入。
請(qǐng)不要使用package語(yǔ)句。
源程序中只能出現(xiàn)JDK1.5中允許的語(yǔ)法或調(diào)用。不能使用1.6或更高版本。
 */
package Question10_19;

import java.util.Scanner;

public class Question14 {
  public static void main(String[] args) {
    int a,b,c,d,sum = 0;
    for (int i = 0; i < 500000; i++) {
      a=(int) (Math.random()*6)+1;
      b=(int) (Math.random()*6)+1;
      c=(int) (Math.random()*6)+1;
      d=(int) (Math.random()*6)+1;
    // System.out.println(a+" "+b+" "+c+" "+d);


      if(a==b&&a==c&&a==d){
        sum-=6;
      }else if((a==b&&a==c)||(a==c&&a==d)||(a==b&&a==d)){
        sum-=2;
      }else if(a==b||a==c||a==d){
        sum-=1;
      }else if ((a*b==c*d)||(a*c==b*d)||(a*d==b*c)) {
        sum-=0;
      }else {
        sum+=1;
      }
    }
    System.out.printf("%.3f",sum/500000f);
  }
}

/* 
超文本標(biāo)記語(yǔ)言（即HTML），是用于描述網(wǎng)頁(yè)文檔的一種標(biāo)記語(yǔ)言。
HTML通過(guò)文本來(lái)描述文檔顯示出來(lái)應(yīng)該具有的“樣子”。它主要通過(guò)標(biāo)簽來(lái)定義對(duì)象的顯示屬性或行為。
如果把java的源文件直接拷貝到HTML文檔中，用瀏覽器直接打開，會(huì)發(fā)現(xiàn)本來(lái)整齊有序的源文件變成了一團(tuán)遭。
這是因?yàn)椋谋局械脑S多回車和空格都被忽略了。而有些符號(hào)在html中有特殊的含義，引起了更復(fù)雜的局面。
為了源文件能正常顯示，我們必須為文本加上適當(dāng)?shù)臉?biāo)簽。對(duì)特殊的符號(hào)進(jìn)行轉(zhuǎn)義處理。
常用的有：
HTML 需要轉(zhuǎn)義的實(shí)體：
&   ---> &
空格     --->  
<   ---> <
>   ---> >
"   ---> "
此外，根據(jù)源碼的特點(diǎn)，可以把 TAB 轉(zhuǎn)為4個(gè)空格來(lái)顯示。
TAB  ---> &nbsp;&nbsp;&nbsp;&nbsp;
為了顯示為換行，需要在行尾加<br/>標(biāo)簽。
為了顯示美觀，對(duì)關(guān)鍵字加粗顯示，即在關(guān)鍵字左右加<b>標(biāo)簽。比如：
<b>public</b>
對(duì)單行注釋文本用綠色顯示，可以使用<font>標(biāo)簽，形如：
<font color=green>//這是我的單行注釋！</font>
注意：如果“//”出現(xiàn)在字符串中，則注意區(qū)分，不要錯(cuò)誤地變?yōu)榫G色。
不考慮多行注釋的問題 /* .... */  /*或*/  /** .... */
/*
你的任務(wù)是：編寫程序，把給定的源文件轉(zhuǎn)化為相應(yīng)的html表達(dá)。
【輸入、輸出格式要求】
與你的程序同一目錄下，存有源文件 a.txt，其中存有標(biāo)準(zhǔn)的java源文件。要求編寫程序把它轉(zhuǎn)化為b.html。
例如：目前的 a.txt 文件與 b.html 文件就是對(duì)應(yīng)的。可以用記事本打開b.html查看轉(zhuǎn)換后的內(nèi)容。用瀏覽器打開b.html則可以看到顯示的效果。
注意：實(shí)際評(píng)測(cè)的時(shí)候使用的a.txt與示例是不同的。
 */

package Question10_19;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class Question15FinishedBefore {

  private String BoldComments(String tempString, String note) {
    return null;
  }

  public static void main(String[] args) {

    try {
      File inFile = new File("test.java");
      FileInputStream fileInputStream;
      fileInputStream = new FileInputStream(inFile);
      InputStreamReader inputStreamReader = new InputStreamReader(
          fileInputStream);
      BufferedReader bufferedReader = new BufferedReader(
          inputStreamReader);

      File outFile = new File("test.html");
      FileOutputStream fileOutputStream = new FileOutputStream(outFile);
      OutputStreamWriter outStreamWriter = new OutputStreamWriter(
          fileOutputStream);
      BufferedWriter bufferedWriter = new BufferedWriter(outStreamWriter);

      outStreamWriter.write("<html>\n");
      outStreamWriter.write("<body>\n");
      String tempString;
      while ((tempString = bufferedReader.readLine()) != null) {

        tempString = tempString.replaceAll("&", "&amp;");
        tempString = tempString.replaceAll(" ", "&nbsp;");
        tempString = tempString.replaceAll("<", "&lt;");
        tempString = tempString.replaceAll(">", "&gt;");

        int index1 = tempString.lastIndexOf("http://");
        int index2 = tempString.indexOf("\"");
        if (index1 != -1 && index2 == -1) {
          String s1 = tempString.substring(0, index1);
          String s2 = tempString.substring(index1);
          s2 = "<font color=green>" + s2 + "</font>";
          tempString = s1 + s2;
        } else if (index1 != -1 && index2 != -1) {

          int startMark = -1, endMark = -1;
          boolean isNote = true;
          for (int i = 0; i < tempString.length(); i++) {

            if ('\"' == tempString.charAt(i)) {
              if (startMark == -1) {
                startMark = i;
              } else {

                endMark = i;
                if (index1 > startMark && index1 < endMark) {
                  isNote = false;
                  break;
                } else {
                  startMark = -1;
                  endMark = -1;
                }

              }
            }

          }
          if (isNote == true) {
            String s1 = tempString.substring(0, index1);
            String s2 = tempString.substring(index1);
            s2 = "<font color=green>" + s2 + "</font>";
            tempString = s1 + s2;
          }

        }

        tempString = tempString.replaceAll("\"", "&quot;");
        tempString = tempString.replaceAll("\t",
            "&nbsp;&nbsp;&nbsp;&nbsp;");

        tempString = tempString.replaceAll("&nbsp;public&nbsp;",
            "&nbsp;<b>public</b>&nbsp;");
        tempString = tempString.replaceAll("&nbsp;class&nbsp;",
            "&nbsp;<b>class</b>&nbsp;");
        tempString = tempString.replaceAll("&nbsp;static&nbsp;",
            "&nbsp;<b>static</b>&nbsp;");
        tempString = tempString.replaceAll("&nbsp;void&nbsp;",
            "&nbsp;<b>void</b>&nbsp;");

        outStreamWriter.write(tempString + "<br/>" + "\r\n");
      }
      outStreamWriter.write("\n</body>\n");
      outStreamWriter.write("</html>\n");

      bufferedWriter.flush();
      bufferedReader.close();
      bufferedWriter.close();

    } catch (FileNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }

  }

}

// 我的工具類
public class MyTool
{
  public static void main(String[] args)
  {
    int a = 100;
    int b = 20;
    if(a>b && true)
      System.out.println(a);
    else
      System.out.println("this! //aaa//kkk"); // 測(cè)試注釋顯示是否正確
  }
}

/* 
復(fù)雜現(xiàn)象背后的推動(dòng)力，可能是極其簡(jiǎn)單的原理?？茖W(xué)的目標(biāo)之一就是發(fā)現(xiàn)紛
繁復(fù)雜的自然現(xiàn)象背后的簡(jiǎn)單法則。愛因斯坦的相對(duì)論是這方面的典范例證。
很早的時(shí)候，生物學(xué)家觀察某區(qū)域某種昆蟲的數(shù)量（稱為蟲口數(shù)）之逐年變化規(guī)律，
就十分迷惑：有的時(shí)候是逐漸增多達(dá)到一個(gè)平衡值。有的時(shí)候在兩個(gè)數(shù)字間周期跳動(dòng)。
有的時(shí)候則進(jìn)入一片混亂，類似隨機(jī)數(shù)字一樣變化（稱為混沌現(xiàn)象）。
慢慢地，人們從數(shù)學(xué)中更清晰地觀察到了這一現(xiàn)象，并因此開創(chuàng)了：符號(hào)動(dòng)力學(xué)、非線性動(dòng)力學(xué)等研究領(lǐng)域。
一個(gè)著名的蟲口數(shù)目簡(jiǎn)化模型如下：
x' = x * (1 - x) * r
這里，x x' r 都是浮點(diǎn)數(shù)。
其中，x 表示當(dāng)年的蟲口數(shù)，x' 表示下一年的蟲口數(shù)。
它們的取值范圍在 0 與 1 之間，實(shí)際上表示的是：蟲口的總數(shù)占環(huán)境所能支持的最大數(shù)量的比率。
r 是常數(shù)（環(huán)境參數(shù)），r的取值范圍在 [0,4]。
令人驚訝的是：這個(gè)簡(jiǎn)單的迭代公式有著不同尋常的神秘性質(zhì)！
一般來(lái)說(shuō)，多次迭代后，蟲口數(shù)的穩(wěn)定模式與x的初始值無(wú)關(guān)，而與 r 有關(guān)！
例如：無(wú)論x初始值是多少，當(dāng) r = 2.5 的時(shí)候，x 多次迭代后會(huì)趨向于 0.6。
而當(dāng) r = 3.2 的時(shí)候，x 的值會(huì)趨向于在 0.799 與 0.513 之間周期性擺動(dòng)。
那么，r = 3.62 的時(shí)候，你觀察到有什么周期現(xiàn)象發(fā)生嗎？

不需要提交源代碼，只要寫出你的結(jié)論即可！
答案寫在：“解答.txt”中，不要寫在這里。
 */
public class Demo01 {
  static int count = 100; // 執(zhí)行100次退出
  public static void f(double x,double r){
    if(count<=0) return;
    x = x * (1 - x) * r;
    System.out.println(x);
    count--;
    f(x,r);
  }
  public static void main(String[] args){
    double x = 0.2;
    double r = 3.62;
    f(x,r);
    System.out.println("網(wǎng)絡(luò)某某結(jié)論：蟲口數(shù)目函數(shù)呈鋸齒狀變化，" +
        "蟲口數(shù)目不存在連續(xù)兩年增加和連續(xù)兩年減少的情況。");
  }
}

/*
串“abcba”以字母“c”為中心左右對(duì)稱；串“abba” 是另一種模式的左右對(duì)稱。
這兩種情況我們都稱這個(gè)串是鏡像串。特別地，只含有1個(gè)字母的串，可以看成是第一種模式的鏡像串。
一個(gè)串可以含有許多鏡像子串。我們的目標(biāo)是求一個(gè)串的最大鏡像子串（最長(zhǎng)的鏡像子串），
如果有多個(gè)最大鏡像子串，對(duì)稱中心靠左的優(yōu)先選中。例如：“abcdeefghhgfeiieje444k444lmn”的最大鏡像子串是：“efghhgfe”
下面的靜態(tài)方法實(shí)現(xiàn)了該功能，請(qǐng)仔細(xì)閱讀并分析代碼，填寫空白處的代碼，使得程序的邏輯合理，結(jié)果正確。

方法一：
*/
public class Demo02_two {
  public static String maxS(String s){
    String maxS = "";
    char[] c = s.toCharArray();

    for(int i=0;i<c.length-1;i++){
      int mark = 0;  // 下標(biāo)標(biāo)記
      String temp = "";  // 記錄一個(gè)鏡像串
      if(c[i]==c[i+1]){
        for(;;){  // abba模式
          if((i-mark<0)||c[i-mark]!=c[i+mark+1]) break;
          mark++;
        }
        temp = s.substring(i-mark+1,i+mark+1);
      }else if((i+2)<c.length&&c[i]==c[i+2]){
        for(;;){  // abcba模式
          if((i-mark<0)||c[i-mark]!=c[i+mark+2]) break;
          mark++;
        }
        temp = s.substring(i-mark+1,i+mark+2);
      }
      if(temp.length()>maxS.length()){
        maxS = temp;
      }
    }

    return maxS;
  }
  public static void main(String[] args){
    String s = "abcdeefghhgfeiieje444k444lmn";
    System.out.println(maxS(s));
  }
}

方法二：
public class Demo02 {
  public static String getMaxMirrorString(String s) {
    String max_s = ""; // 所求的最大對(duì)稱子串

    for (int i = 0; i < s.length(); i++) {
      // 第一種對(duì)稱模式
      int step = 1;
      try {
        for (;;) {
          if (s.charAt(i - step) != s.charAt(i + step))
            break;
          step++;
        }
      } catch (Exception e) {
      }
      String s1 = s.substring(i - step + 1, i + step); // 填空1

      // 第二種對(duì)稱模式
      step = 0;
      try {
        for (;;) {
          if (s.charAt(i - step) != s.charAt(i + step + 1))
            break; // 填空2
          step++;
        }
      } catch (Exception e) {
      }
      String s2 = s.substring(i - step + 1, i + step + 1);

      if (s1.length() > max_s.length())
        max_s = s1;
      if (s2.length() > max_s.length())
        max_s = s2;
    }

    return max_s;
  }

  public static void main(String[] args) {
    String s = "abcdeefghhgfeiieje444k444lmn";
    System.out.println(getMaxMirrorString(s));
  }
}

/*
今盒子里有n個(gè)小球，A、B兩人輪流從盒中取球，每個(gè)人都可以看到另一個(gè)人取了多少個(gè)，
也可以看到盒中還剩下多少個(gè)，并且兩人都很聰明，不會(huì)做出錯(cuò)誤的判斷。
我們約定：
每個(gè)人從盒子中取出的球的數(shù)目必須是：1，3，7或者8個(gè)。
輪到某一方取球時(shí)不能棄權(quán)！
A先取球，然后雙方交替取球，直到取完。
被迫拿到最后一個(gè)球的一方為負(fù)方（輸方）

請(qǐng)編程確定出在雙方都不判斷失誤的情況下，對(duì)于特定的初始球數(shù)，A是否能贏？
程序運(yùn)行時(shí)，從標(biāo)準(zhǔn)輸入獲得數(shù)據(jù)，其格式如下：
先是一個(gè)整數(shù)n(n<100)，表示接下來(lái)有n個(gè)整數(shù)。然后是n個(gè)整數(shù)，每個(gè)占一行（整數(shù)<10000），表示初始球數(shù)。
程序則輸出n行，表示A的輸贏情況（輸為0，贏為1）。
例如，用戶輸入：
4
1
2
10
18
則程序應(yīng)該輸出：
0
1
1
0
 */
package Question10_19;

import java.util.Scanner;

 

public class Question18Think2MustRemember {
  public static boolean array[]=new boolean[10020];

  public static void main(String[] args) {

    array[0]=true;
    for (int i = 1; i < array.length; i++) {
      array[i]=(i>=8&&!array[i-8])||(i>=7&&!array[i-7])||(i>=3&&!array[i-3])||(i>=1&&!array[i-1]);
    }

 

 

    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int total;
    scanner.nextLine();
    while ((n--)>0) {
      total=scanner.nextInt();
      System.out.println(array[total]?1:0);
    }
  }
}

 

/*
在對(duì)銀行賬戶等重要權(quán)限設(shè)置密碼的時(shí)候，我們常常遇到這樣的煩惱：如果為了好記用生日吧，
容易被破解，不安全；如果設(shè)置不好記的密碼，又擔(dān)心自己也會(huì)忘記；如果寫在紙上，擔(dān)心紙張被別人發(fā)現(xiàn)或弄丟了...
這個(gè)程序的任務(wù)就是把一串拼音字母轉(zhuǎn)換為6位數(shù)字（密碼）。
我們可以使用任何好記的拼音串(比如名字，王喜明，就寫：wangximing)作為輸入，程序輸出6位數(shù)字。
變換的過(guò)程如下：
第一步. 把字符串6個(gè)一組折疊起來(lái)，比如wangximing則變?yōu)椋?
wangxi
ming
第二步. 把所有垂直在同一個(gè)位置的字符的ascii碼值相加，得出6個(gè)數(shù)字，如上面的例子，則得出：
228 202 220 206 120 105
第三步. 再把每個(gè)數(shù)字“縮位”處理：就是把每個(gè)位的數(shù)字相加，得出的數(shù)字如果不是一位數(shù)字，
就再縮位，直到變成一位數(shù)字為止。例如: 228 => 2+2+8=12 => 1+2=3
上面的數(shù)字縮位后變?yōu)椋?44836, 這就是程序最終的輸出結(jié)果！
要求程序從標(biāo)準(zhǔn)輸入接收數(shù)據(jù)，在標(biāo)準(zhǔn)輸出上輸出結(jié)果。
輸入格式為：第一行是一個(gè)整數(shù)n（<100），表示下邊有多少輸入行，接下來(lái)是n行字符串，就是等待變換的字符串。
輸出格式為：n行變換后的6位密碼。
例如，輸入：
5
zhangfeng
wangximing
jiujingfazi
woaibeijingtiananmen
haohaoxuexi
則輸出：
772243
344836
297332
716652
875843
*/

package Question10_19;

import java.util.Scanner;

 

public class Question19 {
  public static int simplify(int n) {
    String s;
    while (n>=10) {
      s=n+"";
      n=0;
      for (int i = 0; i < s.length(); i++) {
        n+=s.charAt(i)-'0';
      }
    }
    return n;
  }
  public static void main(String[] args) {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    String s;
    scanner.nextLine();
    while((n--)>0){
      int array[]=new int[6];
      s=scanner.nextLine();
      for (int i = 0; i < s.length(); i++) {
        array[i%6]+=(int)(s.charAt(i));
      }
      for (int i = 0; i < 6; i++) {
        System.out.print(simplify(array[i]));
      }
      System.out.println();
    }

//   System.out.println(simplify(123456789));
  }
}

 

/*
對(duì)一個(gè)方陣轉(zhuǎn)置，就是把原來(lái)的行號(hào)變列號(hào)，原來(lái)的列號(hào)變行號(hào)
例如，如下的方陣：
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
轉(zhuǎn)置后變?yōu)椋?
1 5 9 13
2 6 10 14
3 7 11 15
4 8 12 16
但，如果是對(duì)該方陣順時(shí)針旋轉(zhuǎn)（不是轉(zhuǎn)置），卻是如下結(jié)果：
13 9 5 1
14 10 6 2
15 11 7 3
16 12 8 4
下面的代碼實(shí)現(xiàn)的功能就是要把一個(gè)方陣順時(shí)針旋轉(zhuǎn)。
*/

public class Demo03 {
  // 矩陣順時(shí)針旋轉(zhuǎn)
  public static void rotation(int[][] n,int [][] m,int i,int j){
    int t = j; // 標(biāo)記最后一行的位置
    if(i>=n.length) return;
    for(int k=0;k<n.length;k++){
      m[i][k] = n[j--][i];  // 解決一行
    }
    rotation(n,m,++i,t);  // 遞歸解決下一行
  }
  // 輸出矩陣
  public static void print(int[][] t){
    for(int[] x: t){
      for(int y:x){
        System.out.print(y+"\t");
      }
      System.out.println();
    }
  }
  public static void main(String[] args){
    int[][] n = {
        {1 ,2 ,3 ,4 },
        {5 ,6 ,7 ,8 },
        {9 ,10,11,12},
        {13,14,15,16}
    };
    print(n);  // 顯示原矩陣
    int len = n.length;
    int[][] m = new int[len][len]; // 目標(biāo)矩陣
    rotation(n,m,0,len-1); // 矩陣順時(shí)針旋轉(zhuǎn)
    System.out.println("順時(shí)針旋轉(zhuǎn)結(jié)果:");
    print(m);  // 顯示目標(biāo)矩陣
  }
}