蓝桥杯训练第一天

 

题目本身不难，但如果发现不了陷阱，这题便无法通过。

求第 20190324 项的最后 4 位数字！

稍不注意，当作直接求该数列的第20190324项，然后再看最后4位数字是多少！然而这样出题的意义在哪里？何不直接让你吧20190324项完全写出？

所以，应当敏锐地察觉必然有坑在其中，很自然地联想到极有可能是因为累加到后面，数列的项过大超过表示范围。那么用long行不行呢？暂时不知道但完全不必去用，在求项时候对项模10000即可（最后4位数）。

public class Fabonacci2 {
    public static void main(String args[]){
        int[] arr = new int[3];
        //给前三项赋初值
        arr[0] = 1;
        arr[1] = 1;
        arr[2] = 1;

        int count = 4;//记录项数，此时表示应求第四项
        int num=0;

        while (count!=20190325){
            num = (count - 1) % 3;
            arr[num] = (arr[0] + arr[1] + arr[2]) % 10000;//依次更新数组中的值
            count++;
        }
        
        System.out.print(arr[num]);
    }
}

 这一题我最开始居然想通过排列组合去解决，简直天方夜谭。依我看，蓝桥杯的选择题除了能够直接看出结果的以外，其他的绝对要通过编程去测算。

思路是，首先，分解成3个各不相同的正整数之和，实现各不相同可以通过使三个数依次递增，反正不分顺序！

public class Break {
    public static void main(String args[]){
        int n = 2019;
        int i,j,k;
        int count = 0;//记录满足题意的式子数
        
        //数递增的思路
        for (i=1;i<n/2;i++){
            if(judge(i))
                continue;
            for (j=i+1;j<n;j++){
                if(judge(j))
                    continue;
                for(k=j+1;k<n;k++){
                    if(judge(k))
                        continue;
                    if(i+j+k==n)
                        count++;
                }
            }
        }
        
        System.out.println(count);
    }

    public static boolean judge(int n){
        int a = n;
        boolean flag = false;
        
        //只要n的某一位有2或者4就满足
        while (a>0){
            if(a%10==2||a%10==4){
                flag = true;
                break;
            }
            a = a / 10;
        }
        
        return flag;
    }
}

 这一题本来毫无含金量可言的，但无奈我对于一些细节的把握尚不到位，还是记录下这一题。

import java.util.*;
public class WordAnalysis {
    public static void main(String args[]){
        Scanner in = new Scanner(System.in);
        String word = in.nextLine();
        int i;
        int k,temp;
        char ch = 'a';
        int[] arr = new int[26];//此数组存各字母出现的个数

        for(i=0;i<word.length();i++){
            k = word.charAt(i) - 'a';//假定arr[0]代表a的个数，arr[1]代表b的个数...以此类推
            arr[k]++;
        }
        temp = 0;

        //直接求出出现次数最多的字母，而且由于是由a到z搜索的，所以满足输出的是字典序最小的字母
        for(k=0;k<26;k++){
            if(temp<arr[k]){
                temp = arr[k];
                ch = (char)('a'+k);//强制类型转换，这是之前没想到的
            }
        }

        System.out.println(ch);
        System.out.println(temp);
    }
}

做个笔记：Math.round(int)四舍五入，前面要写 import java.lang.*;

问题描述

　　魔方可以对它的6个面自由旋转。

　　我们来操作一个2阶魔方，如图：

 为了描述方便，我们为它建立了坐标系。

　　各个面的初始状态如下：
　　x轴正向：绿
　　x轴反向：蓝
　　y轴正向：红
　　y轴反向：橙
　　z轴正向：白
　　z轴反向：黄

　　假设我们规定，只能对该魔方进行3种操作。分别标记为：
　　x 表示在x轴正向做顺时针旋转
　　y 表示在y轴正向做顺时针旋转
　　z 表示在z轴正向做顺时针旋转

　　xyz 则表示顺序执行x,y,z 3个操作

题目的要求是：
　　用户从键盘输入一个串，表示操作序列。
　　程序输出：距离我们最近的那个小方块的3个面的颜色。
　　顺序是：x面，y面，z面。

输入输出用例

　　例如：在初始状态，应该输出：
　　绿红白

　　初始状态下，如果用户输入：
　　x
　　则应该输出：
　　绿白橙


　　初始状态下，如果用户输入：
　　zyx
　　则应该输出：
　　红白绿

这个应该是暂时碰到的最具挑战性的题目。倒不是说解题过程有多么深奥难懂，相反，答案易于理解。难点在于此题要找到合适的方法去存放数据，像我一开始想靠一个三维数组存放结果就贻笑大方了。三维数组放点还差不多，这一个一个小方块怎么用三维数组存？

看了答案本来都打算直接复制粘贴了，可一想到这是个绝佳的锻炼敲码能力的机会，还是“绝知此事要躬行”！

有点无语的是，同样的算法，如果用c++一点毛病也没有，而用Java就超时了。唉，既然选择了Java组便只能一条路走到黑了。。。以后如果想到新点子再重新测试一下。

import java.util.Scanner;
public class MagicCube {
    public static void main(String args[]){
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        int j,k;
        for (j=0;j<6;j++){//初始化颜色
            for (k=0;k<4;k++){
                arr1[j][k] = j;
            }
        }
        for(int i=0;i<str.length();i++){
            init();//每次把arr2变为变化前的颜色状态
            if(str.charAt(i)=='x')
                turnx();
            else if(str.charAt(i)=='y')
                turny();
            else if(str.charAt(i)=='z')
                turnz();
        }
        print(arr1[0][2]);
        print(arr1[2][0]);
        print(arr1[4][3]);
    }
    public static int[][] arr1 = new int[6][4];
    public static int[][] arr2 = new int[6][4];
    public static void init(){
        for (int i=0;i<6;i++){
            for (int j=0;j<4;j++){
                arr2[i][j] = arr1[i][j];
            }
        }
    }
    public static void print(int a){
        switch (a){
            case 0:
                System.out.print("绿");
                break;
            case 1:
                System.out.print("蓝");
                break;
            case 2:
                System.out.print("红");
                break;
            case 3:
                System.out.print("橙");
                break;
            case 4:
                System.out.print("白");
                break;
            case 5:
                System.out.print("黄");
                break;
        }
    }
    public static void turnx(){
        arr1[0][0] = arr2[0][1];
        arr1[0][1] = arr2[0][3];
        arr1[0][2] = arr2[0][0];
        arr1[0][3] = arr2[0][2];
        arr1[2][0] = arr2[4][1];
        arr1[2][1] = arr2[4][3];
        arr1[5][2] = arr2[2][0];
        arr1[5][0] = arr2[2][1];
        arr1[3][3] = arr2[5][2];
        arr1[3][2] = arr2[5][0];
        arr1[4][1] = arr2[3][3];
        arr1[4][3] = arr2[3][2];
    }
    public static void turny(){
        arr1[2][0] = arr2[2][1];
        arr1[2][1] = arr2[2][3];
        arr1[2][3] = arr2[2][2];
        arr1[2][2] = arr2[2][0];
        arr1[5][2] = arr2[4][2];
        arr1[5][3] = arr2[4][3];
        arr1[0][3] = arr2[5][3];
        arr1[0][2] = arr2[5][2];
        arr1[4][2] = arr2[0][2];
        arr1[4][3] = arr2[0][3];
        arr1[1][2] = arr2[4][2];
        arr1[1][3] = arr2[4][3];
    }
    public static void turnz(){
        arr1[4][0] = arr2[4][1];
        arr1[4][1] = arr2[4][3];
        arr1[4][2] = arr2[4][0];
        arr1[4][3] = arr2[4][2];
        arr1[1][1] = arr2[3][2];
        arr1[1][3] = arr2[3][0];
        arr1[3][2] = arr2[0][2];
        arr1[3][0] = arr2[0][0];
        arr1[0][0] = arr2[2][0];
        arr1[0][2] = arr2[2][2];
        arr1[2][0] = arr2[1][3];
        arr1[2][2] = arr2[1][1];
    }

}