(第六届蓝桥杯个人赛省赛)结果填空、代码填空

一、三角形面积（暴力解法，容易）

答案：28

如图所示。图中的所有小方格面积都是1。
那么，图中的三角形面积应该是多少呢？

请填写三角形的面积。不要填写任何多余内容或说明性文字。

分析：直接做，送分题。

public class Main {

    /**
     * 三角形面积
     */
    public static void main(String[] args) {
        //一个8×8的正方形里面有个三角形
        float Sz = 64;
        float s1 = 8, s2 = 12, s3 = 16;

        System.out.println(Sz-s1-s3-s2);
    }

}

二、立方变自身（暴力解法，容易）

答案：6

观察下面的现象,某个数字的立方，按位累加仍然等于自身。
1^3 = 1 
8^3  = 512    5+1+2=8
17^3 = 4913   4+9+1+3=17
...

请你计算包括1,8,17在内，符合这个性质的正整数一共有多少个？

请填写该数字，不要填写任何多余的内容或说明性的文字。

分析：将一个数的立方拆成一个一个的数，然后相加，判断是不是等于自身。这个方法比较笨。
说一个特别简单的方法，这个题可以用字符串，将一个数的立方放到字符串里边，然后将每一位取出来并相加，然后与自身比较。
这个题还有一个关键点就是 范围。当大于多少时，就不会出现立方变自身数。举个例子：50的立方的75000，50的立方一共5位数，我们知道，这5位数如果都取9，那么5位数的和才45，并没有达到50。所以循环到50即可。

public class Main {

    /**
     * 立方变自身
     */
    static boolean test(int a, int b){
        String s = ""+b;
        int sum = 0;
        int n = 0;
        int size = s.length();
        for (int i = 0; i < size; i++) {

            n = b/(int)(Math.pow(10, size-1-i));
            sum += n;
            b -= n*(int)(Math.pow(10, size-1-i));

        }
        if (sum == a) {
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        int count = 0;
        for (int i = 1; i <= 100; i++) {
            if (test(i,i*i*i)) {
                count++;
            }
        }

        System.out.println(count);
    }

}

三、三羊献瑞（暴力解法，有技巧）

答案：1085

观察下面的加法算式：

      祥 瑞 生 辉
  +   三 羊 献 瑞
-------------------
   三 羊 生 瑞 气


其中，相同的汉字代表相同的数字，不同的汉字代表不同的数字。

请你填写“三羊献瑞”所代表的4位数字（答案唯一），不要填写任何多余内容。

分析：
这道题与第七届的凑算式是一种类型的。
这道题根据题目的要求，给每个字一个数字，然后进行计算即可。
此题的技巧就是用String，即将算式的第一行，第二行的数字表示分别放到String里，然后将这两行转化成int型进行计算，计算结果再放到字符串里；将第三行的数字表示放到String里，然后与计算结果相比较，如果相等则记录下“三洋献瑞”这4个字的数字符号，然后跳出循环即可。

public class Main {

    /**
     * 三羊献瑞
     */
    public static void main(String[] args) {
        String s1,s2,s3,s,res="";
        int flag = 0;
        for (int i = 0; i <= 9; i++) {//祥
            for (int j = 0; j <= 9; j++) {//瑞
                for (int k = 0; k <= 9; k++) {//生
                    for (int l = 0; l <= 9; l++) {//辉
                        for (int m = 0; m <= 9; m++) {//三
                            for (int n = 0; n <= 9; n++) {//羊
                                for (int p = 0; p <= 9; p++) {//献
                                    for (int q = 0; q <=9; q++) {//气

                                        if (i != j && i != k && i != l && i != m && i != n && i != p && i != q
                                                && j != k && j != l && j != m && j != n && j != p && j != q
                                                && k != l && k != m && k != n && k != p && k != q
                                                && l != m && l != n  && l !=p && l != q
                                                && m != n && m != p && m != q
                                                && n != p && n != q 
                                                && p != q) {
                                            s1 = ""+i+j+k+l;
                                            s2 = ""+m+n+p+j;
                                            s = Integer.parseInt(s1)+Integer.parseInt(s2)+"";//先进行加操作，再进行转换成字符串

                                            s3 = ""+m+n+k+j+q;
                                            if (s.equals(s3)) {
                                                flag = 1;
                                                res = ""+m+n+p+j;
                                                break;
                                            }
                                        }
                                    }
                                    if (flag == 1) {
                                        break;
                                    }
                                }
                                if (flag == 1) {                            
                                    break;
                                }
                            }
                            if (flag == 1) {
                                break;
                            }
                        }
                        if (flag == 1) {
                            break;
                        }
                    }
                    if (flag == 1) {
                        break;
                    }
                }
                if (flag == 1) {
                    break;
                }
            }
            if (flag == 1) {
                break;
            }
        }
        System.out.println(res);
    }

}

可能会有人想，为什么会有那么多break；
因为break 只会跳出一层循环，所以当你找到答案时，你需要跳出每层循环。

四、循环节长度（代码填空）

答案是return v.size() - v.indexOf(n)

两个整数做除法，有时会产生循环小数，其循环部分称为：循环节。
比如，11/13=6=>0.846153846153….. 其循环节为[846153] 共有6位。
下面的方法，可以求出循环节的长度。

请仔细阅读代码，并填写划线部分缺少的代码。

public static int f(int n, int m)
{
    n = n % m;  
    Vector v = new Vector();

    for(;;)
    {
        v.add(n);
        n *= 10;
        n = n % m;
        if(n==0) return 0;
        if(v.indexOf(n)>=0)  ____________________ ;  //填空
    }
}
注意,只能填写缺少的部分,不要重复抄写已有代码,不要填写任何多余的文字。

解题过程：
将n=11，m=13带入求解。
按照代码顺序执行，当v.indexOf(n) >= 0满足时，向量v中的数为{11,6,8,2,7,5,11},且当前n=11。
此时，因为题目中给出的例子的循环节长度为6，且此时v.size()也等于6，所以就误以为答案是return v.size()
其实答案是return v.size() - v.indexOf(n)
没有大量的数学知识储备，做对这个题不容易。

五、九数组分数（代码填空，简单）

答案：{t=x[k]; x[k]=x[i]; x[i]=t;}

1,2,3...9 这九个数字组成一个分数，其值恰好为1/3，如何组法？

下面的程序实现了该功能，请填写划线部分缺失的代码。

public class A
{
    public static void test(int[] x)
    {
        int a = x[0]*1000 + x[1]*100 + x[2]*10 + x[3];
        int b = x[4]*10000 + x[5]*1000 + x[6]*100 + x[7]*10 + x[8];     
        if(a*3==b) System.out.println(a + " " + b);
    }

    public static void f(int[] x, int k)
    {
        if(k>=x.length){
            test(x);
            return;
        }

        for(int i=k; i<x.length; i++){
            {int t=x[k]; x[k]=x[i]; x[i]=t;}
            f(x,k+1);
            _______________________________________       // 填空
        }
    }

    public static void main(String[] args)
    {
        int[] x = {1,2,3,4,5,6,7,8,9};      
        f(x,0);
    }
}

注意，只能填写缺少的部分，不要重复抄写已有代码。不要填写任何多余的文字。

分析：太简单了。做过很多类似的题目了，一看就知道要填什么。
这个题就是全排列算法（递归+回溯）。