第一题 杨辉三角

题目：

二项式的系数规律，我国数学家很早就发现了。
 
如【图1.png】，我国南宋数学家杨辉1261年所著的《详解九章算法》一书里就出现了。
 
其排列规律：
1
1    1
1    2    1
1    3    3    1
1    4    6    4    1
1    5    10   10   5    1
1    6    15   20   15   6    1
1    7    21   35   35   21   7    1
 
如下的程序，用来建立N行的杨辉三角形。请填写划线部分缺少的代码。
 
注意：只填写划线部分的代码，不要填写任何多余的内容。

代码：

public class A
{
    public static void main(String[] args)
    {
        int N = 8;
        int[][] a = new int[N][N] ;
        
        for(int i=0; i<N; i++){
            a[i][0] = 1;
            a[i][i] = 1;
        }
        
        for(int i=1; i<N; i++){
            for(int j=1; j<i; j++) _____________________________;  //填空
        }
        
        for(int i=0; i<N; i++){
            for(int j=0; j<=i; j++)    System.out.print(String.format("%-5d", a[i][j]));
            System.out.println();
        }    
    }
}

在横线部分填入的代码：

a[i][j]=a[i-1][j]+a[i-1][j-1];

第二题 调和级数

题目：

1/1 + 1/2 + 1/3 + 1/4 + ... 在数学上称为调和级数。
 
它是发散的，也就是说，只要加上足够多的项，就可以得到任意大的数字。
 
但是，它发散的很慢：
 
前1项和达到 1.0
前4项和才超过 2.0
前83项的和才超过 5.0
 
那么，请你计算一下，要加多少项，才能使得和达到或超过 15.0 呢？
 
请填写这个整数。
 
注意：只需要填写一个整数，不要填写任何多余的内容。比如说明文字。

代码：

import java.util.*;
 
public class Main
{
    public static void main(String args[])
    {
        double sum = 0;
        for (int i = 1; i < 10000000; i++) {
            sum = sum + 1.0 / i;
            
            if (sum >= 15.0) {
                System.out.println(i);
                break;
            }
        }
    }
}

第三题 回文素数

题目：

10301是个5位的素数。它有个特点，把数字倒过来还是它本身，具有这样特征的素数，我们称之为：回文素数。
 
10501
10601
11311
 
这些都是5位的回文素数。
 
请你计算一下，像这样的5位数的回文素数，一共有多少个？
 
请填写这个表示个数的整数，注意不要写任何其它多余的内容，比如说明或解释文字，也不要列出所有的回文素数。
 
代码：

import java.util.*;
 
public class Main
{
    public static void main(String args[])
    {
        public static void main(String[] args) {
        // TODO Auto-generated method stub
        int count = 0;
        // 所有的五位数
        for (int i = 10000; i <= 99999; i++) {
            int j;
            // 判断是否为素数
            for (j = 2; j <= i; j++) {
                if (i % j == 0) {
                    break;
                }
            }
            // 判断回文数
            if (j == i) {
                int g = i % 10;
                int s = i / 10 % 10;
                int b = i / 100 % 10;
                int q = i / 1000 % 10;
                int w = i / 10000 % 10;
                if (g == w && s == q) {
                    count++;
                }
            }
        }
        System.out.println(count);
    }
    }
}

第四题 让我怎能过大年

题目：

有如下的加法算式。其中每个汉字代表一个数字。
（如存在对齐问题，可参见【图1.png】）

               年
             大年
           过大年
         能过大年
       怎能过大年
     我怎能过大年
+  让我怎能过大年
------------------
   能能能能能能能

请填写“让我怎能过大年” 所代表的整数。
所有数字连在一起，中间不要空格。例如："3125697"。当然，这个不是正确的答案。

注意：只填写一个整数，不要填写任何多余的内容。

代码：

import java.util.*;
 
public class Main
{
    public static void main(String args[])
    {
        public static void main(String[] args){
        for(int i=1000000;i<=9999999;i++){
            int yi=i%10;
            int er=i/10%10;
            int san=i/100%10;
            int si=i/1000%10;
            int wu=i/10000%10;
            int liu=i/100000%10;
            int qi=i/1000000%10;
            if(yi+(er*10+yi)
                    +(san*100+er*10+yi)
                    +(si*1000+san*100+er*10+yi)
                    +(wu*10000+si*1000+san*100+er*10+yi)
                    +(liu*100000+wu*10000+si*1000+san*100+er*10+yi)
                    +(qi*1000000+liu*100000+wu*10000+si*1000+san*100+er*10+yi)
                    ==si*1000000+si*100000+si*10000+si*1000+si*100+si*10+si)
                System.out.println(i);
 
        }
    }
    }
}

第五题 位平方和

题目：

把一个整数的每个数位都平方后求和，又得到一个整数，我们称这个整数为：位平方和。
 
对新得到的整数仍然可以继续这一运算过程。
 
比如，给定整数为4，则一系列的运算结果为：
 
16,37,58,89,....
 
本题的要求是，已知一个整数x，求第n步的运算结果。
 
数据格式要求：
 
输入，两个整数x n，中间以空格分开。表示求x的第n步位平方和。其中，x，n都大于0，且小于100000。
输出，一个整数，表示所求结果。
 
例如，
输入：
4 3
则程序应该输出：
58
 
再例如，
输入：
1314 10
则程序应该输出：
20
 
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗  < 1000ms
 
 请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
 
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。

代码：

import java.util.*;
 
public class Main
{
    public static void main(String args[])
    {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        int sum=0;
        //循环步数
        for(int i=0;i<m;i++)
        {
            sum=0;
            while(n!=0)
            {
                //平方和
                sum+=Math.pow(n%10, 2);
                n/=10;
            }
            n=sum;
        }
        System.out.println(sum);
    }
}

第六题 单位分数

题目：

 形如：1/a 的分数称为单位分数。
 
可以把1分解为若干个互不相同的单位分数之和。
例如：
1 = 1/2 + 1/3 + 1/9 + 1/18
1 = 1/2 + 1/3 + 1/10 + 1/15
1 = 1/3 + 1/5 + 1/7 + 1/9 + 1/11 + 1/15 + 1/35 + 1/45 + 1/231
等等，类似这样的分解无穷无尽。
 
我们增加一个约束条件：最大的分母必须不超过30
 
请你求出分解为n项时的所有不同分解法。
 
数据格式要求：
 
输入一个整数n，表示要分解为n项（n<12）
输出分解后的单位分数项，中间用一个空格分开。
每种分解法占用一行，行间的顺序按照分母从小到大排序。
 
例如，
输入：
4
程序应该输出：
1/2 1/3 1/8 1/24
1/2 1/3 1/9 1/18
1/2 1/3 1/10 1/15
1/2 1/4 1/5 1/20
1/2 1/4 1/6 1/12
 
再例如，
输入：
5
程序应该输出：
1/2 1/3 1/12 1/21 1/28
1/2 1/4 1/6 1/21 1/28
1/2 1/4 1/7 1/14 1/28
1/2 1/4 1/8 1/12 1/24
1/2 1/4 1/9 1/12 1/18
1/2 1/4 1/10 1/12 1/15
1/2 1/5 1/6 1/12 1/20
1/3 1/4 1/5 1/6 1/20
 
 资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗  < 2000ms
 
 请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
 
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。代码：

package five;
import java.util.Scanner;
public class fs {
    static Scanner sr = new Scanner(System.in);
    static int n=sr.nextInt();
    public static void main(String[] args) {
        int[] sum=new int[n];
         dg(0,sum,2);
    }
    public static void dg(int num,int[] sum,int fm){    
        if(num==n){    
            int z=1;
            int m=sum[0];
            for(int i=1;i<sum.length;i++){    
                z=z*sum[i]+m;
                m*=sum[i];
                
            }
            //System.out.println();
            if(z==m){
                for(int i=0;i<sum.length;i++){    
                    System.out.print("1/"+sum[i]+" ");
                }
                System.out.println("*******"+num);
            }
            
            return;
        }
        for(int i=fm;i<30;i++){
            sum[num]=i;
            dg(num+1,sum,i+1);
        }
    }
}

这道题我也没搞明白，这是在网上看的大佬的方法......

第七题 台阶

题目：

有n级台阶。从地面（第0级）出发，首先连续的上台阶，上到不超过第n级的某一个位置后再连续的下台阶，直到回到地面。若每次上下台阶只允许走1级或2级，请问可能的上下台阶的方案数是多少？
特别地，在0级站着不动也算一种方案。
 
数据格式：
 
输入一行包含两个正整数n和m。
输出一个整数，表示n级台阶有多少种合法的走楼梯方案，答案对m取余。
 
例如：输入：
2 10007
程序应该输出
6
 
【样例说明1】
共有6种方案(其中+表示上台阶，-表示下台阶)：
(1) 原地不动
(2) +1 -1
(3) +2 -2
(4) +2 -1 -1
(5) +1 +1 -2
(6) +1 +1 -1 -1
 
再例如，输入：
3 14
程序应该输出：
1
 
【样例说明2】
共有15种方案，对14取余后得1。
 
【数据规模】
对于30%的数据，n<=10000；
对于100%的数据，n<=10^17，m<=2*10^9。
 
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗  < 1000ms
 
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
 
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。

代码：

import java.util.*;
 
public class Main
{
    public static void main(String args[])
    {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int sum = 1;
 
        // 这个就是解题的重点
        for (int i = 0; i <= n; i++) {
            sum += i * i;
        }
        System.out.println(sum % m);
    }
}

这些题还都是比较简单了，这是蓝桥杯一开始训练的题，还算是比较好理解的，后边慢慢的就上难度了。