1. 日期與星期

大數學家高斯有個好習慣：無論如何都要記日記。
他的日記有個與眾不同的地方，他從不注明年月日，而是用一個整數代替，比如：4210
后來人們知道，那個整數就是日期，它表示那一天是高斯出生后的第幾天。這或許也是個好習慣，它時時刻刻提醒着主人：日子又過去一天，還有多少時光可以用於浪費呢？
高斯出生於：1777年4月30日。
在高斯發現的一個重要定理的日記上標注着：5343，因此可算出那天是：1791年12月15日。
高斯獲得博士學位的那天日記上標着：8113
請你算出高斯獲得博士學位的年月日。
1949年的國慶節（10月1日）是星期六。
今年（2012）的國慶節是星期一。
那么，從建國到現在，有幾次國慶節正好是星期日呢？
只要答案，不限手段！
可以用windows日歷，windows計算器，Excel公式，。。。。。
當然，也可以編程！
【源代碼】

【JAVA：於航】

很多關於日期的求解問題可以歸結為：求兩個日期之間的差值（但不建議使用Date類計算日期/日歷）

// 日期差問題
// 2015-3-2 距離 1979-12-15 多少天？

// 日期表示法？？ 距離基點的天數

基點為1年1月1日     A-B=（A-基准）】-（B-基准）

public class A
{
    static int day_dif(int year1,int month1,int day1, int year2,int month2,int day2){
        return get_days(year2,month2,day2) - get_days(year1,month1,day1);
    }
   
    static boolean is_leap_year(int year){//閏年
        boolean tag = false;
        if(year%4==0) tag = true;
        if(year%100==0) tag = false;
        if(year%400==0) tag = true;
        return tag;
    }
   
    static int get_days(int year, int month, int day){
        int[] M = {0,31,28,31,30,31,30,31,31,30,31,30,31};
        if(is_leap_year(year)) M[2]++;
       
        int sum = 0;
        for(int i=1; i<year; i++){
            sum += 365;
            if(is_leap_year(i)) sum++;
        }
       
        for(int i=1; i<month; i++){
            sum += M[i];
        }
       
        sum += day;
        return sum;
    }
   
    public static void main(String[] args){
        System.out.println(day_dif(1979,12,15,2015,3,2));
    }

}

2. excel地址

Excel單元格的地址表示很有趣，它使用字母來表示列號，比如：
A表示第1列，
B表示第2列，
Z表示第26列，
AA表示第27列，
AB表示第28列，
BA表示第53列，
….
當然Excel的最大列號是有限度的，所以轉換起來不難。
如果我們想把這種表示法一般化，可以把很大的數字轉換為很長的字母序列呢？
本題目既是要求對輸入的數字, 輸出其對應的Excel地址表示方式。
例如，
輸入：
26
則程序應該輸出：
Z
再例如，
輸入：
2054
則程序應該輸出：
BZZ
我們約定，輸入的整數范圍[1,2147483647]
【源代碼】

【JAVA：於航】

public class A         //不超過三個字母的解法
{
    // n 轉換為excel列地址
    static String f(int n){
        for(int i=0; i<=26; i++)
        for(int j=(i==0)?0:1; j<=26; j++)//若i=0，則j=0  否則：i=1，j=1

        for(int k=(j==0)?0:1; k<=26; k++){ //若j=0，則k=0  否則：j=1，k=1

                int x = i*26*26 + j*26 + k; 

                if(x==n){ String s =""; 

                if(i>0) s += (char)(i-1+'A');

                if(j>0) s += (char)(j-1+'A');
                if(k>0) s += (char)(k-1+'A');              
                return s;
            }
        }
        return "";
    }
   
    public static void main(String[] args){
        for(int i=700; i<750; i++){
            System.out.println(i + ": " + f(i));
        }
    }
}

另一種方法：

import java.util.Scanner;  
public class Main{  
    public static void main(String[] args) {  
        Scanner in = new Scanner(System.in);  
        int[] iA = new int[5000];  
        int n = in.nextInt();  
        int i = 1;  
        while (n != 0) {  
            if (n % 26 == 0) {  
                // +64轉大寫字母，+96轉小寫字母  
                iA[i] = 26 + 64;  
                n -= 1;  
            } else {  
                iA[i] = n % 26 + 64;  
            }  
            n /= 26;  
            i++;  
        }  
        for (int j = i - 1; j > 0; j--) {  
            System.out.print((char)iA[j]);  
        }  
    }  
}  

public class B
{
    // excel列地址轉換為n
    static int f(String s){
        int n = 0;
        for(int i=0; i<s.length(); i++){
            n = n * 26 + (s.charAt(i)-'A' + 1);
        }
        return n;
    }
   
    public static void main(String[] args){
        System.out.println(f("AA"));
        System.out.println(f("BA"));
        System.out.println(f("ZZ"));
        System.out.println(f("AAA"));
    }

}

3. 取球博弈

今盒里有n個小球，A、B兩人輪流從盒中取球。
每個人都可以看到另一個人取了多少個，也可以看到盒中還剩下多少個。
兩人都很聰明，不會做出錯誤的判斷。
每個人從盒子中取出的球的數目必須是：1，3，7或者8個。
輪到某一方取球時不能棄權！
A先取球，然后雙方交替取球，直到取完。
被迫拿到最后一個球的一方為負方（輸方）

編程確定出在雙方都不判斷失誤的情況下，對於特定的初始球數，A是否能贏？

思路：

       f（局面x）{
            for(可能的所有走法){
            試走x->y;
            if(f(y)==輸)
        then return 贏;
            回溯;
            }
            return 輸;

        }

//當調用的雙方共用了某個數據結構，則需要回溯，否則，當另一方下次調用時，會發生錯誤

【源代碼】

【JAVA：於航】

public class A        //數據量比較大時，程序會癱瘓（跑不動了）
{
    static boolean f(int n){//n:球數
        if(n==0) return true;//必贏
       
        if(n>=1 && f(n-1)==false) return true;
        if(n>=3 && f(n-3)==false) return true;
        if(n>=7 && f(n-7)==false) return true;
        if(n>=8 && f(n-8)==false) return true;
       
        return false;
    }
   
    public static void main(String[] args){
        for(int i=1; i<=50; i++){
            System.out.println(i + ": " + f(i));
        }
    }

}

4. 填字母游戲

K大師在紙上畫了一行n個格子，要小明和他交替往其中填入字母。
1. 輪到某人填的時候，只能在某個空格中填入L或O
2. 誰先讓字母組成了“LOL”的字樣，誰獲勝。
3. 如果所有格子都填滿了，仍無法組成LOL，則平局。
小明試驗了幾次都輸了，他很慚愧，希望你能用計算機幫他解開這個謎。
本題的輸入格式為：
第一行，數字n（n<10），表示下面有n個初始局面。
接下來，n行，每行一個串，表示開始的局面。
比如：“******”, 表示有6個空格。“L****”, 表示左邊是一個字母L，它的右邊是4個空格。
要求輸出n個數字，表示對每個局面，如果小明先填，當K大師總是用最強着法的時候，小明的最好結果。
1 表示能贏
-1 表示必輸
0 表示可以逼平
例如，
輸入：
4
***
L**L
L**L***L
L*****L
則程序應該輸出：
0
-1
1
1
【源代碼】

【JAVA：於航】

import java.util.*;
public class A
{
    // -1: 必輸，0: 平局, 1: 必贏
    static int f(char[] x)
    {
        String s = new String(x);      
        if(s.contains("LOL")) return -1;
        if(s.contains("*")==false) return 0;
       
        boolean ping = false;  // 假設無法平局
       
        for(int i=0; i<x.length; i++){
            if(x[i]=='*'){
                try{
                    x[i]='L';  //試着填L
                    switch(f(x)){
                        case -1: return 1;
                        case 0: ping = true;
                    }
                    x[i]='O';  //試着填O
                    switch(f(x)){
                        case -1: return 1;
                        case 0: ping = true;
                    }
                }
                finally{           
                    x[i]='*';//回溯
                }
            }
        }
       
        if(ping) return 0;
        return -1;
    }
   
    static int game(String s)
    {
        return f(s.toCharArray());
    }
   
    public static void main(String[] args)
    {  
        System.out.println(game("***"));
        System.out.println(game("L**L"));
        System.out.println(game("L**L***L"));
        System.out.println(game("L*****L"));
    }
}


import java.util.*;
public class LOL
{
    static Map<String, Integer> map = new HashMap<String, Integer>();
   
    // -1: 必輸，0: 平局, 1: 必贏
    static int f(char[] x)
    {
        String s = new String(x);
        if(map.get(s) != null) return map.get(s);
       
        if(s.contains("LOL")) {
            map.put(s,-1);
            return -1;
        }
        if(s.contains("*")==false) {
            map.put(s,0);
            return 0;
        }
       
        boolean ping = false;
       
        for(int i=0; i<x.length; i++){
            if(x[i]=='*'){
                try{
                    x[i]='L';
                    {
                        int t = f(x);
                        if(t<0) {
                            map.put(s,1);
                            return 1;
                        }
                        if(t==0) ping = true;
                    }
                    x[i]='O';
                    {
                        int t = f(x);
                        if(t<0) {
                            map.put(s,1);
                            return 1;
                        }
                        if(t==0) ping = true;
                    }      
                }
                finally{           
                    x[i]='*';
                }
            }
        }
       
        if(ping){
            map.put(s,0);
            return 0;
        }
       
        map.put(s,-1);
        return -1;
    }
   
    static int game(String s)
    {
        map.clear();
        return f(s.toCharArray());
    }
   
    public static void main(String[] args)
    {  
        Scanner scan = new Scanner(System.in);
       
        int n = Integer.parseInt(scan.nextLine().trim());
        for(int i=0; i<n; i++){
            System.out.println(game(scan.nextLine().trim()));
        }
    }

}

尼姆定理：

斯普萊格-格隆第定理：任何一個無偏游戲都可以等價到尼姆堆

5. 高僧斗法

古時喪葬活動中經常請高僧做法事。
儀式結束后，有時會有“高僧斗法”的趣味節目，以舒緩壓抑的氣氛。
節目大略步驟為：先用糧食（一般是稻米）在地上“畫”出若干級台階（表示N級浮屠）。
又有若干小和尚隨機地“站”在某個台階上。
最高一級台階必須站人，其它任意。(如圖所示)


兩位參加斗法的法師分別指揮某個小和尚向上走任意多級的台階，但會被站在高級台階上的小和尚阻擋，不能越過。
兩個小和尚也不能站在同一台階，也不能向低級台階移動。
兩法師輪流發出指令，最后所有小和尚必然會都擠在高段台階，再也不能向上移動。
輪到哪個法師指揮時無法繼續移動，則游戲結束，該法師認輸。
對於已知的台階數和小和尚的分布位置，請你計算先發指令的法師該如何決策才能保證勝出。
輸入數據為一行用空格分開的N個整數，表示小和尚的位置。台階序號從1算起，所以最后一個小和尚的位置即是台階的總數。（N<100, 台階總數<1000）
輸出為一行用空格分開的兩個整數: A B, 表示把A位置的小和尚移動到B位置。
若有多個解，輸出A值較小的解，若無解則輸出-1。
例如：
用戶輸入：
1 5 9
則程序輸出：
1 4
再如：
用戶輸入：
1 5 8 10
則程序輸出：
1 3
【源代碼】

【JAVA：於航】

// 組合博弈論....轉化為尼姆堆：兩個人之間的空台階數，組成一個尼姆堆
import java.util.*;
public class A
{
    static boolean f(int[] x){//尼姆堆中的元素即是數組中兩兩元素的差
        int sum = 0;

        for(int i=0; i<x.length-1; i+=2){ //最后一個元素不能使用

            sum ^= x[i+1] - x[i] - 1; // 相鄰兩人差的空台階數===>尼姆堆

        }
        return sum != 0;
    }
   
    static void solve(int[] x)
    {
        for(int i=0; i<x.length-1; i++){

            for(int k=x[i]+1; k<x[i+1]; k++){   

                     // x [i] +1:當前這一階的下級   k<x[i+1]：不能撞上/越過下一個小和尚的位置

                int old = x[i];  //試着走
                try{
                    x[i] = k;
                    if(f(x)==false) {
                        System.out.println(old + " " + k);
                        return;
                    }
                }
                finally{
                    x[i] = old; //回溯
                }
            }
        }
    }
   
    public static void main(String[] args)
    {  
        solve(new int[]{1,5,9});
        solve(new int[]{1,5,8,10});
        solve(new int[]{1,4,8,12,16,19,28,33,35,36,40,45,52,66,67,68,69,77
          ,85,99,102,134,155,211,214,216,355,376,400,412});
    }

}

6. 古代賭局

俗話說：十賭九輸。因為大多數賭局的背后都藏有陰謀。
不過也不盡然，有些賭局背后藏有的是：“陽謀”。
有一種賭局是這樣的：桌子上放六個匣子，編號是1至6。
多位參與者（以下稱玩家）可以把任意數量的錢押在某個編號的匣子上。
所有玩家都下注后，庄家同時擲出3個骰子（骰子上的數字都是1至6）。
輸贏規則如下：
1.若只有1個骰子上的數字與玩家所押注的匣子號相同，則玩家拿回自己的押注，庄家按他押注的數目賠付（即1比1的賠率）。
2.若2個骰子上的數字與玩家所押注的匣子號相同，則玩家拿回自己的押注，庄家按他押注的數目的2倍賠付（即1比2的賠率）。
3.若3個骰子上的數字都與玩家押注的匣子號相同，則玩家拿回自己的押注，庄家按他押注的數目的10倍賠付（即1比10的賠率）。
乍一看起來，好像規則對玩家有利，庄家吃虧。但經過大量實戰，會發現局面很難說，於是懷疑是否庄家做了手腳，庄家則十分爽快地說：可以由玩家提供骰子，甚至也可以由玩家來投擲骰子。

你的任務是：通過編程模擬該過程。模擬50萬次，假定只有1個玩家，他每次的押注都是1元錢，其押注的匣子號是隨機的。再假定庄家有足夠的資金用於賠付。最后計算出庄家的盈率（庄家盈利金額/押注總金額）。

【源代碼】

【JAVA：於航】

public class DuJu
{
    public static double f()
    {
        int a = (int)(Math.random() * 6) + 1;
        int b = (int)(Math.random() * 6) + 1;
        int c = (int)(Math.random() * 6) + 1;
       
        int w = (int)(Math.random() * 6) + 1;
       
        int n = 0;
        if(a==w) n++;
        if(b==w) n++;
        if(c==w) n++;
       
        if(n==3) return -10;
        if(n==2) return -2;
        if(n==1) return -1;
       
        return 1;
    }
   
    public static void main(String[] args)
    {
        int N = 500*1000;
       
        double sum = 0;
        for(int i=0; i<N; i++)
        {
            sum += f();
        }
       
        System.out.println(sum/N);//即贏率  由於押注總是1元
    }

}

7. 火柴游戲（沒有半局）

這是一個縱橫火柴棒游戲。
如圖1，在3×4的格子中，游戲的雙方輪流放置火柴棒。
其規則是：
1. 不能放置在已經放置了火柴棒的地方（即只能在空格中放置）。
2. 火柴棒的方向只能是豎直或水平放置。
3. 火柴棒不能與其它格子中的火柴“連通”。
所謂連通是指兩根火柴棒可以連成一條直線，且中間沒有其它不同方向的火柴“阻攔”。
例如：


圖1所示的局面下，可以在C2位置豎直放置（為了方便描述格子位置，圖中左、下都添加了標記），但不能水平放置，因為會與A2連通。
同樣道理，B2，B3，D2此時兩種方向都不可以放置。
但如果C2豎直放置后，D2就可以水平放置了，因為不再會與A2連通（受到了C2的阻擋）。
4. 游戲雙方輪流放置火柴，不可以棄權，也不可以放多根。
如某一方無法繼續放置，則該方為負（輸的一方）。
游戲開始時可能已經放置了多根火柴。
你的任務是：編寫程序，讀入初始狀態，計算出對自己最有利的放置方法並輸出放置后的局面。
圖1的局面表示為：
00-1
-000
0100
即用“0”表示空閑位置，用“1”表示豎直放置，用“-”表示水平放置。
解法不唯一，找到任意解法即可。
例如，局面：
0111
-000
-000
的解：
-111
-000
-000

再例如，局面：
1111
—-
0010
的解：
1111
—-
0110

【源代碼】

【JAVA：於航】

import java.util.*;
public class A
{
    static void show(char[][] data){
        System.out.println();
        for(int i=0; i<data.length; i++){
            System.out.println(new String(data[i]));
        }
    }
   
    static boolean f(char[][] data){      //遞歸：判斷是否贏 
        for(int i=0; i<data.length; i++){//檢查是否橫着連通
            String s = new String(data[i]).replaceAll("0","");//把空格壓縮掉，看是否連着
            if(s.contains("--")) return true;
        }
       
        for(int i=0; i<data[0].length; i++){//檢查是否豎着連通
            String s = ("" + data[0][i] + data[1][i] + data[2][i]).replaceAll("0","");
            if(s.contains("11")) return true;
        }  
       
        for(int i=0; i<data.length; i++){//典型的博弈框架
            for(int j=0; j<data[i].length; j++){
                if(data[i][j]=='0'){
                    try{
                        data[i][j] = '1';
                        if(f(data)==false) return true;
                        data[i][j] = '-';
                        if(f(data)==false) return true;
                    }
                    finally{
                        data[i][j] = '0';
                    }
                }
            }
        }
   
        return false;    //所有的試走都為true
    }
   
    static void solve(char[][] data){
        for(int i=0; i<data.length; i++){
            for(int j=0; j<data[i].length; j++){
                if(data[i][j]=='0'){
                    try{
                        data[i][j] = '1';
                        if(f(data)==false) {
                            show(data);
                            //return
                        }
                        data[i][j] = '-';
                        if(f(data)==false){
                            show(data);//找到了一個解
                            //return;
                        }
                    }
                    finally{
                        data[i][j] = '0';
                    }
                }
            }
        }
    }
   
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
       
        char[][] data = new char[3][];
        data[0] = scan.nextLine().trim().toCharArray();
        data[1] = scan.nextLine().trim().toCharArray();
        data[2] = scan.nextLine().trim().toCharArray();
       
        solve(data);
        //System.out.println(f(data));
    }

}