蓝桥杯——3

• 星系炸弹

  有一个贝塔炸弹，2014年11月9日放置，定时为> 1000天，请你计算它爆炸的准确日期。
  请填写该日期，格式为 yyyy-mm-dd

  public class Main{
      static SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
  
      public static void main(String[] args) {
          Calendar calendar = new GregorianCalendar();
  
          calendar.set(2014, 10, 9);
          System.out.println(df.format(calendar.getTime()));
          calendar.add(Calendar.DATE, 1000);
          System.out.println(df.format(calendar.getTime()));
      }
  }
  

• 九数分三组

  1~9的数字可以组成3个3位数，设为：A,B,C, 现在要求满足如下关系：
  B = 2 * A
  C = 3 * A
  请你写出A的所有可能答案，数字间用空格分开，数字按升序排列。

  public class Main{
      public static int[] a = new int[15];
      public static boolean[] book = new boolean[15];
      public static int n=9;
      public static void dfs(int step)
      {
          if(step== n+1)
          {
              if(2*(a[1]*100+a[2]*10+a[3]) == a[4]*100+a[5]*10+a[6] &&
                      3*(a[1]*100+a[2]*10+a[3]) == a[7]*100+a[8]*10+a[9]) {
                  System.out.println(a[1]+" "+a[2]+" "+a[3]);
              }
              return;
          }
          for(int x=1;x<=9;x++)
          {
              if(!book[x])
              {
                  book[x] = true;
                  a[step] = x;
                  dfs(step+1);
                  book[x] = false;
              }
          }
      }
      public static void main(String[] args) {
          dfs(1);
      }
  }
  

• 循环节长度

  11/13=6=>0.846153846153… 其循环节为[846153] 共有6位。
  下面的方法，可以求出循环节的长度。

  public class Main{
      /**
       * 11___13
       * 6___13____1
       * 8___13____2
       * 2___13____3
       * 7___13____4
       * 5___13____5
       * 11___13____6
       * 6___13____7
       * 8___13____8
       * 2___13____9
       * 7___13____10
       */
      public static int f(int n, int m){
          n = n % m;
          int i = 0;
          Vector v = new Vector();
          for(;;){
              v.add(n);
              i++;
              n *= 10;
              n = n % m;
              if(i == 10) break;
              if(n == 0) return 0;
              if(v.indexOf(n) >= 0){
                  return v.size();
              }
          }
          return 0;
      }
  
      public static void main(String[] args) {
          System.out.print(f(11, 13));
      }
  }
  

• 打印菱形

  /*
  .......*
  ......*.*
  .....*...*
  ....*.....*
  ...*.......*
  ..*.........*
  .*...........*
  *.............*
  .*...........*
  ..*.........*
  ...*.......*
  ....*.....*
  .....*...*
  ......*.*
  .......*
  * */
  public class Main{
      public static void f(int n) {
          String s = "*";
          for(int i = 0; i < 2 * n - 3; i++) s += ".";
          s += "*";
          //    .*...........*
          // S   .............
          String s1 = s + "\n";
          String s2 = "";
  
          //System.out.println("********".replaceFirst("\\*", "\\l"));
          for( int i = 0; i < n - 1; i++){
              s = "." + s1.substring(0,2*n-i-4) + "*";
              s1 = s + "\n" + s1;
              s2 += s + "\n";
          }
          System.out.println(s1 + s2);
      }
  
      public static void main(String[] args) {
          f(8);
      }
  }
  

• 加法变乘法

  1+2+3+ … + 49 = 1225
  把其中两个不相邻的加号变成乘号，使得结果为2015
  1+2+3+…+1011+12+…+2728+29+…+49 = 2015
  可以假设靠前乘号的左边数字为a, 则右边的数字为a+1,靠后乘号的左边的数字为b,则乘号右边的数字为b+1。
  1+2+3+…+a+(a+1)+(a+2)+…+b+(b+1)+…+49=1225 (1)
  1+2+3+…+a*(a+1)+(a+2)+…+b*(b+1)+…+49=2015 (2)
  (2)-(1)=a*(a+1)+b*(b+1)-a-(a+1)-b-(b+1)=2015-1225=790

  public class 加法变乘法 {
  	public static void main(String[] args) {
  		int a,b,c,d;
  		for(int i=1;i<=49;i++) {
  			a=i;
  			b=i+1;
  			for(int j=i+2;j<=49;j++) {
  				c=j;
  				d=j+1;
  				if(a*b+c*d-(a+b)-(c+d)==790&&a!=10) {
  					System.out.println(a);
  					break;
  				}
  			}
  		}
  	}
  }
  

• 牌型种数

  一副扑克牌（去掉大小王牌，共52张），均匀发给4个人，每个人13张。
  这时，小明脑子里突然冒出一个问题：
  如果不考虑花色，只考虑点数，也不考虑自己得到的牌的先后顺序，自己手里能拿到的初始牌型组合一共有多少种呢？

  思路：循环遍历每个点数所选择的张数，每个点数最多可以选4张，最少可以选0张即不选，每当牌总数达到13张则计数。

  #include <iostream>
  using namespace std;
  int main()
  {
      int sum=0;
      for(int a=0; a<=4; a++)
          for(int b=0; b<=4; b++)
              for(int c=0; c<=4; c++)
                  for(int d=0; d<=4; d++)
                      for(int e=0; e<=4; e++)
                          for(int f=0; f<=4; f++)
                              for(int g=0; g<=4; g++)
                                  for(int h=0; h<=4; h++)
                                      for(int i=0; i<=4; i++)
                                          for(int j=0; j<=4; j++)
                                              for(int k=0; k<=4; k++)
                                                  for(int l=0; l<=4; l++)
                                                      for(int m=0; m<=4; m++)
                                                      {
                                                          if(a+b+c+d+e+f+g+h+i+j+k+l+m==13)
                                                              sum++;
                                                      }
                                                      cout<<sum<<endl;
      return 0;
  }
  

  dfs

  import  java.util.*;
   
  public class Main
  {	
  	static int k[]={1,2,3,4,5,6,7,8,9,10,11,12,13};
  	static int count=0;
  	public static void main(String args[])
  	{
  		
  		int t[]=new int[14];    //记录每个牌已经拿了几张
  		Get(0,0,t);    // 每一张可以拿0，1，2，3，4张， 
  						//	第一个0代表1~13中的第一张的点数   第二个0代表拿到的总数
  		System.out.println(count);
  	}
  	public static void Get(int q,int w,int t[])
  	{
  		if(w==13)    //牌数够了
  		{
  			count++;return;
  		}
  		if(q==13)return;     //已经拿了最后点数位13的牌了
  		for(int i=0;i<=4;i++)
  		{
  			w+=i;
  			t[q]=i;
  			Get(q+1,w,t);//深度优先搜索
  			w-=i;      //回溯法     
  		}
  	}
  }
  

• 移动距离

  w m n
  w是一行有几个 m是一个楼号 n是另一个楼号
  排列方式：蛇形排列
  1 2 3 4 5 6
  12 11 10 9 8 7
  13 14 15 …
  输入6 8 2 ，输出 4

  public static void main(String[] args) {
      Scanner input =new Scanner(System.in);
      int length = input.nextInt();
      int one = input.nextInt();
      int two = input.nextInt();
  
      int ox=one/length;
      int oy=one%length;
      int tx=two/length;
      int ty=two%length;
  
      if(one%length==0){
          oy=length;
      }else{
          ox=ox+1;
      }
      if(two%length==0){
          ty=length;
      }else{
          tx=tx+1;
      }
      if(ox%2==0){
          oy=length-oy+1;
      }
      if(tx%2==0){
          ty=length-ty+1;
      }
      System.out.println(Math.abs(ox-tx)+Math.abs(oy-ty));
  }