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]);
}
}
}
{
// 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));
}
}