精华内容
下载资源
问答
  • 2020年第11届蓝桥杯国赛javaC组
    2021-06-06 08:33:36

    6.2020国赛javaC组

    https://blog.csdn.net/qq_43449564/article/details/109841937

    https://blog.csdn.net/imreal_/article/details/114272929

    https://www.dtmao.cc/news_show_375163.shtml

    C 扩散

    import java.util.LinkedList;
    import java.util.Queue;
    //定义每一个点,记录坐标和它是经过多少步到达的
    class Node{
    	int x,y,step;
    }
    public class 扩散 {
    	//声明n1和n2两个变量
    	static Node n1,n2;
    	//记录点是否被访问过
    	static boolean flag;
    	static int N = 6200;
    	static boolean[][] book = new boolean[N][N];
    	//定义方向,上,下,右,左
    	static int[][] dirs = {
    			{-1,0},
    			{1,0},
    			{0,1},
    			{0,-1}
    	};
    	//定义队列,offer():压栈,poll():出栈,peek():返回队顶的元素,但不删除
    	static Queue<Node> queue = new LinkedList<Node>();
    	//初始就4个点
    	private static int ans = 4;
    	public static void main(String[] args) {
    		//初始化原始的四个点
    		//而本题是在一个画布上无限的扩散,
    		//所以是没有边界的,故我们要在二维数组上加上2020即可。
    		init(2020,2020);
    		init(4040,2031);
    		init(2031,2034);
    		init(4020,4020);
    		//开始广搜
    		bfs();
    		System.out.println(ans);
    	}
    	private static void bfs() {
    		//队列中的元素不为空
    		while (!queue.isEmpty()) {
    			//取出并删掉队列头元素,以这个点的视角进行判断
    			n1 = queue.poll();
    			//如果取出的点已经是第2020分钟后的,直接结束广搜
    			if (n1.step == 2020) {
    				break;
    			}
    			//进行四个方向的选择
    			for (int i = 0; i < 4; i++) {
    				//新建节点
    				n2 = new Node();
    				n2.x =n1.x+dirs[i][0];
    				n2.y =n1.y+dirs[i][1];
    				//在当前节点的步骤上+1步,第2020分钟后,叫变成+2020
    				//这代表了n2的step值是2020
    				n2.step = n1.step+1;
    				//这个点没被访问过,而且还没有到第2020步
    				if (n2.step <=2020 &&!book[n2.x][n2.y]  ) {
    //					System.out.println(n2.x+":"+n2.y);
    					//标记这个点被访问过了
    					book[n2.x][n2.y] = true;
    					ans++;
    					queue.offer(n2);
    				}
    			}	
    		}	
    	}
    	private static void init(int x, int y) {
    		book[x][y] = true;
    		n1  = new Node();
    		n1.x = x;
    		n1.y = y;
    		n1.step = 0;
    		queue.offer(n1);
    		
    	}
    }
    

    D阶乘约数

    • 本题考查约数个数定理
    import java.math.BigInteger;
    
    public class 阶乘约数 {
       public static void main(String[] args) {
            BigInteger num = BigInteger.ONE;
            //算出100阶乘的值
            for (int i = 1; i <= 5; i++)
                num = num.multiply(new BigInteger(String.valueOf(i)));
            long res = 1;
            //从2开始,知道i*I>num为止
            for (BigInteger i = new BigInteger("2"); i.multiply(i).compareTo(num) <= 0; i = i.add(BigInteger.ONE)) {
                long cnt = 1;
                //约数个数定理
                //num%i == 0,是约数,然后执行while语句
                /*
    		             例题:正整数378000共有多少个正约数?
    		解:将378000分解质因数378000=2^4×3^3×5^3×7^1
    		由约数个数定理可知378000共有正约数(4+1)×(3+1)×(3+1)×(1+1)=160个。
                 */
                while (num.mod(i).compareTo(BigInteger.ZERO) == 0) {
                	
                	 num = num.divide(i);
                     cnt++;
                }
                if (cnt > 1)
                    res *= cnt;
            }
            if (num.compareTo(BigInteger.ONE) > 0) res <<= 1;
            System.out.println(res);
        }
    
    }
    

    E: 本质上升序列

    https://blog.csdn.net/m0_51955470/article/details/115706911

    https://blog.csdn.net/qq_44443766/article/details/111601650

    https://blog.csdn.net/u013098139/article/details/117150847

    设str为题目中的目标字符串,定义dp[i]为以str[i]为结尾时的递增子序列的个数。
    考虑j<i,遍历j=0~i-1,则有如下讨论:

    str[j] < str[i],此时dp[i]=dp[i]+dp[j]
    str[j] = str[i],此时dp[i]=dp[i]-dp[j]
    str[j] > str[i],此时是降序,不考虑
    为了观察方便,就以数字2、1、3、8、5、7、4、5为例:

    package 国赛2020C组;
    
    public class 本质上升子序列 {
    	public static void main(String[] args) {
    		//一个动态规划的题目
    		String string = 
    				 "tocyjkdzcieoiodfpbgcncsrjbhmugdnojjddhllnofawllbhfiadgdcdjstemphmnjihecoapdjjrprrqnhgccevdarufmliqijgihhfgdcmxvicfauachlifhafpdccfseflcdgjncadfclvfmadvrnaaahahndsikzssoywakgnfjjaihtniptwoulxbaeqkqhfwl";
    	    int result = 0;
    	    
    		long ans = 0;
    		//声明一个数组,里面的的值全为1
    		int dp[] = new int[string.length()];
    		for (int i = 0; i < dp.length; i++) {
    			dp[i] = 1;
    		}
    		//每一个都遍历
    		for (int i = 0; i < dp.length; i++) {
    			
    			for (int j = 0; j < i; j++) {
    				if (string.charAt(j) < string.charAt(i)) {
    					dp[i] = dp[i]+dp[j];
    				}else if(string.charAt(j) == string.charAt(i)) {
    					dp[i] = dp[i]-dp[j];
    				}
    			}
    		}
    		
    		for (int i = 0; i < dp.length; i++) {
    			ans += dp[i];
    		}
    		
    		System.out.println(ans);
    	}
    }
    
    

    F 天干地支

    import java.util.Scanner;
    
    public class 天干地支 {
    	static String[] tiangan = {"jia","yi","bing","ding","wu","ji","geng","xin","ren","gui"};
    	static String[] dizhi = {"zi","chou","yin","mao","chen","si","wu","wei","shen","you","xu","hai"};
    	
    	public static void main(String[] args) {
    		Scanner scanner = new Scanner(System.in);
    		int n = scanner.nextInt();
    //		以2020为基准算一下偏移量就行
    		System.out.print(tiangan[(n + 6)% 10]);
            System.out.print(dizhi[(n - 4) % 12]);
    	}
    }
    
    

    G皮亚诺曲线距离

    https://www.cnblogs.com/valk3/p/14036850.html

    H 蓝肽子序列

    https://blog.csdn.net/hrn1216/article/details/51534607

    public class 蓝肽子序列 {
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            char [] s1=scanner.nextLine().toCharArray();
            char [] s2=scanner.nextLine().toCharArray();
            int len1=s1.length;
            int len2=s2.length;
            int [][]dp=new int[len1+1][len2+1];
            for (int i = 1; i <= len1; i++) {
                for (int j = 1; j <= len2; j++) {
    //            	元素相同时
                    if(s2[j-1]==s1[i-1])
                    {
    //                	这个元素等于左上角的值
                        dp[i][j]=dp[i-1][j-1];
    //                  当这个元素为大写的时候,才+1,也就是算一个
                        if('A'<=s2[j-1]&&s2[j-1]<='Z') dp[i][j]++;
                    }
    //            	元素不相同    
                    else
                    {
    //                	把上面和左面的最大值赋给
                        if(dp[i-1][j]>=dp[i][j-1])
                        	dp[i][j]=dp[i-1][j];
                        else dp[i][j]=dp[i][j-1];
                    }
                }
            }
            System.out.println(dp[len1][len2]);
        }
    }
    

    I 画廊

    import java.text.DecimalFormat;
    import java.util.Scanner;
    
    public class 贪心 {
    
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		DecimalFormat fmt = new DecimalFormat("#.00");
    		// long n = sc.nextLong();
    		int l = sc.nextInt();
    		int r = sc.nextInt();
    		int d = sc.nextInt();
    		int w = sc.nextInt();
    //		左右画廊
    		int[] la = new int[l];
    		int[] ra = new int[r];
    //   	左面赋值
    		for (int i = 0; i < l; ++i) {
    			la[i] = sc.nextInt();
    		}
    //		右面赋值
    		for (int i = 0; i < r; ++i) {
    			ra[i] = sc.nextInt();
    		}
    //      表示走完了第几个
    		int li = 0;
    		int ri = 0;
    //		求出中间点
    		double sx = (double) w / 2;
    		double sy = 0.0;
    //		这是总的距离
    		double dist = 0;
    //		没要找到所有的作品,就一直循环
    		while (li < l || ri < r) {
    //			人到作品的距离
    			double ld = Double.MAX_VALUE, rd = Double.MAX_VALUE;
    //			如果左面的作品没找完
    			if (li < l) {
    //				这里是以左边作为y轴,所以x的方向为01
    				double x = sx - 0;
    //				负负得正
    				double y = sy - la[li];
    				ld = Math.sqrt(x * x + y * y);
    			}
    //			右面的作品没找完
    			if (ri < r) {
    //				直接求出-w,然后负负得正
    				double x = sx - w;
    				double y = sy - ra[ri];
    				rd = Math.sqrt(x * x + y * y);
    			}
    //			比较到左面和到右面的距离
    			if (ld < rd) {
    //				到左面近
    //				记录距离
    				dist += ld;
    //				跟新y的坐标
    				sy = la[li];
    //				x坐标移到左面
    				sx = 0;
    				++li;
    			} else {
    //				到右面近
    				dist += rd;
    				sy = ra[ri];
    //				
    				sx = w;
    				++ri;
    			}
    		}
    		
    		
    //			这时已经到了最后一个作品,然后求出到终点的距离
    			double x = sx - (double) w / 2;
    			double y = sy - d;
    			dist += Math.sqrt(x * x + y * y);
    		
    
    		System.out.println(fmt.format(dist));
    
    	}
    }
    
    

    J 答疑

    import java.util.Arrays;
    import java.util.Scanner;
    /*
    3
    10000 10000 10000
    20000 50000 20000
    30000 20000 30000
    
    Output:
     */
    public class 答疑 {
    	public static void main(String[] args) {
    		Scanner scanner = new Scanner(System.in);
    		int n = scanner.nextInt();
    //		这里是每个人的数据
    		Task[] tasks = new Task[n];
    //		存贮着发消息的时刻
    		long[] arr = new long[n];
    		int s,a,e;
    		long ans = 0,tem = 0;
    		for (int i = 0; i < tasks.length; i++) {
    			s = scanner.nextInt();
    			a = scanner.nextInt();
    			e = scanner.nextInt();
    			tasks[i] = new Task(s, a, e);
    		}
    //		按照排序规则,进行排序
    		Arrays.sort(tasks);
    //		发消息时刻的存贮
    		for (int i = 0; i < tasks.length; i++) {
    			tem += tasks[i].sum;
    			arr[i] = tem- tasks[i].e;
    		}
    //		最终答案的获取
    		for (int i = 0; i < tasks.length; i++) {
    			ans += arr[i];
    		}
    //		
    //		for (int i = 0; i < arr.length; i++) {
    //			System.out.println(arr[i]);
    //		}
    		System.out.println(ans);
    	}
    }
    
    class Task implements Comparable<Task>{
    	int s,a,e,sum;
    //	这里的sum是这三个数的和,并以此来进行排序,看一个人的耗时小,就往前
    	public Task(int s, int a, int e) {
    		super();
    		this.s = s;
    		this.a = a;
    		this.e = e;
    		this.sum = this.s+this.a+this.e;
    	}
    	
    	@Override
    	public String toString() {
    		return "Task [s=" + s + ", a=" + a + ", e=" + e + "]";
    	}
    	@Override
    	public int compareTo(Task o) {
    //如果总耗时相同,就比较回答时间的长短
    		if (this.sum == o.sum ) 
    			return this.e - o.e;
    		return this.sum - o.sum;
    	}
    }
    

    7.2020国赛javaB组

    E 玩具蛇

    public class 玩具蛇 {
    //	默认都是false
        static boolean [][] key=new boolean[5][5];
    //    四个方向的移动 上,下,左,右
        static int [][]move={{-1,0},{1,0},{0,-1},{0,1}};
        static int ans=0;
        
        public static void main(String[] args) {
            for (int i = 1; i <= 4; i++) {
                for (int j = 1; j <= 4; j++) {
    //            	开始点变为ture
                    key[i][j]=true;
                    dfs(i,j,1);
                    key[i][j]=false;
                }
            }
     
            System.out.println(ans);
        }
        /**
         * 
         * @param x
         * @param y
         * @param cur 代表是第走的步数,到了16步,就终止
         */
        private static void dfs(int x,int y,int cur)
        {
    //    	终点判断
            if(cur==16)
            {
                ans++;
                return;
            }
    //        朝着四个方向移动  上,下,左,右
            for (int i = 0; i < move.length; i++) {
                int x2=x+move[i][0];
                int y2=y+move[i][1];
                /**
                要去的点并没有超过临界值,并且没有被访问,那就就说明访问的点是合格的
                 */
                if(x2>=1&&x2<=4&&y2>=1&&y2<=4&&!key[x2][y2])
                {
    //            	将合格的点标记为访问过的
                    key[x2][y2]=true;
    //                在这个点的基础上,在进行选择
                    dfs(x2,y2,cur+1);
    //               说明这个点应经不是合格的点了,或者说已经到了终点了
    //                需要回退,然后换个方向进行
                    key[x2][y2]=false;
                }
            }
        }
    }
    

    I: 补给

    https://blog.csdn.net/weixin_45640260/article/details/110252819

    J 质数行者

    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collections;
    import java.util.List;
    import java.util.Scanner;
    /*
    5 6 1
    3 4 1 1 2 1
    
    
     */
    public class 质数行者 {
    	static int n,m,w;
    	static int r1,c1,h1,r2,c2,h2;
    //	存放着质数点
    	static List<Integer> prime;
    
    	static int[][][] dp ;
    	static long Mood = 1000000007;
    	public static void main(String[] args) {
    		Scanner scanner = new Scanner(System.in);
    		
    		n = scanner.nextInt();
    		m = scanner.nextInt();
    		w = scanner.nextInt();
    		r1 = scanner.nextInt();
    		c1 = scanner.nextInt();
    		h1 = scanner.nextInt();
    		r2 = scanner.nextInt();
    		c2 = scanner.nextInt();
    		h2 = scanner.nextInt();
    		prime = new ArrayList<Integer>();
    //		所有dp的值都是-1
    		dp = new int[n+1][m+1][w+1];
    		   for (int i = 1; i <= n; i++)
    	            for (int j = 1; j <= m; j++)
    	            	 Arrays.fill(dp[i][j], -1);
    //	   两个陷阱的值为0
    		dp[r1][c1][h1] = 0;
    		dp[r2][c2][h2] = 0;
    //		访问过的值为1
    		dp[1][1][1] = 1;
    //		得到所有可行的质数
    		int tem = Math.max(n, m);
    		tem = Math.max(tem, w);
    		int j;
    		for (int i = 2; i <= tem ; i++) {
    			for ( j = 2; j <= (int)Math.sqrt(i); j++) {
    				if (i%j == 0) {
    					break;
    				}
    			}
    			
    			if (j> (int)Math.sqrt(i)) {
    				prime.add(i);
    			}
    		}
    	
    
    //	    开始递归,这个点也就是要去的点
    		System.out.println(dfs(n,m,w));
    	}
    
    	private static long dfs(int x, int y, int z) {
    //		这个点被访问或者说是陷阱
    		if (dp[x][y][z] >= 0) {
    			return dp[x][y][z] ;
    		}
    
    		
    		long res = 0;
    //		对所有质数进行遍历
    		for (int i = 0; i < prime.size(); i++) {
    //			if的判断,决定了是否越界
    			if (x - prime.get(i) > 0) {
    //				去下一个点
    				res = (res+dfs(x-prime.get(i), y, z))%Mood;
    			}
    			
    			if (y - prime.get(i) > 0) {
    				res = (res+dfs(x, y-prime.get(i), z))%Mood;
    			}
    			
    			if (z - prime.get(i) > 0) {
    				res = (res+dfs(x, y, z-prime.get(i)))%Mood;
    			}
    		}
    		
    //		到了这里,递归已经完成了,这个点将被表记为访问过
    		System.out.println(dp[x][y][z] = (int) res);
    		return dp[x][y][z] = (int) res;
    	}
    }
    
    更多相关内容
  • 省赛and国赛
  • 2020年第十一届蓝桥杯JavaC组(十月场)真题解析

    千次阅读 多人点赞 2021-04-08 18:45:52
    相关题目: 2016年第七届蓝桥杯真题解析JavaB组 2016年第七届蓝桥杯真题解析JavaC组 2017年第八届蓝桥杯真题解析JavaB组 2017年第八届蓝桥杯真题解析JavaC组 2018年第九届蓝桥杯真题解析JavaB组 2018年第九届蓝桥杯...

    相关题目:

    2016年第七届蓝桥杯真题解析JavaB组

    2016年第七届蓝桥杯真题解析JavaC组

    2017年第八届蓝桥杯真题解析JavaB组

    2017年第八届蓝桥杯真题解析JavaC组

    2018年第九届蓝桥杯真题解析JavaB组

    2018年第九届蓝桥杯真题解析JavaC组

    2019年第十届蓝桥杯真题解析JavaB组

    2019年第十届蓝桥杯真题解析JavaC组

    2020年第十一届蓝桥杯JavaB组(七月场)真题解析

    2020年第十一届蓝桥杯JavaC组(七月场)真题解析

    2020年第十一届蓝桥杯JavaB组(十月场)真题解析

    2020年第十一届蓝桥杯JavaC组(十月场)真题解析

    A 约数个数

    【问题描述】

    对于一个整数,能整除这个整数的数称为这个数的约数。
    例如:1, 2, 3, 6 都是 6 的约数。
    请问 78120 有多少个约数。

    【答案提交】

    思路:直接遍历判断

    代码:

    
    public class 约数个数 {
        public static void main(String[] args) {
            int ans = 0;
            for (int i = 1; i <= 78120; i++) {
                if (78120 % i == 0) ans++;
            }
            System.out.println(ans);
        }
    }
    
    

    答案 :96

    B 寻找2020

    题目:
    小蓝有一个数字矩阵,里面只包含数字 0 和 2。小蓝很喜欢 2020,他想找
    到这个数字矩阵中有多少个 2020 。
    小蓝只关注三种构成 2020 的方式:

    1.同一行里面连续四个字符从左到右构成 2020。
    2.同一列里面连续四个字符从上到下构成 2020。
    3.在一条从左上到右下的斜线上连续四个字符,从左上到右下构成 2020。
    

    例如,对于下面的矩阵:

    220000
    000000
    002202
    000000
    000022
    002020
    

    一共有 5 个 2020。其中 1 个是在同一行里的,1 个是在同一列里的,3 个
    是斜线上的。
    小蓝的矩阵比上面的矩阵要大,由于太大了,他只好将这个矩阵放在了一
    个文件里面,在试题目录下有一个文件 2020.txt,里面给出了小蓝的矩阵。
    请帮助小蓝确定在他的矩阵中有多少个 2020。
    (测试数据太大了我就不放这里了,我放个图片大概是这样子的)
    在这里插入图片描述思路:

    1.暴力搜之前,要知道它每行每列的长度,一个简单的方法
    从最左上角把鼠标按往一直往最右下角拉,记事本右下角
    就会自己显示,我考试的时候没想起来这样做,吐血。
    
    2.然后就是搜索,从左往右从上往下,只要找到一个"2",就
    可以开始深搜,分别找每个'2'的四个方向上下左右,左上到右下,
    每当有一个方向上是符合条件的就count++;
    

    代码:

    import java.util.Scanner;
    public class 寻找2020 {
        static int count=0;
       static char [][]arr2=new char[400][400];
       static char []arr3={'2','0','2','0'};
        public static void main(String[] args) {
            Scanner input=new Scanner(System.in);
            String []arr=new String[301];
            for(int i=0;i<300;i++){
                arr[i]=input.next();
            }
            for(int i=0;i<300;i++){
                arr2[i]=arr[i].toCharArray();
            }
            for(int i=0;i<300;i++){
                for(int j=0;j<300;j++){
                    if(arr2[i][j]=='2'){
                        dfs(i,j);
                    }
                }
            }
            System.out.println(count);
        }
        public static void dfs(int x,int y){
            int flag=1;//用来判断是否满足条件
            //找从左往右
            for(int i=1;i<=3;i++){
                //越界了就说明这个方向肯定不行
                if(y+i<0||y+i>=300)
                {
                    flag=0;
                    break;
                }
                if(arr2[x][y+i]!=arr3[i]){
                    flag=0;
                    break;
                }
            }
            if(flag==1)
                count++;
            //每判断一次要更新flag=1,以免对下一次判断造成误解
            flag=1;
            //从上到下
            for(int i=1;i<=3;i++){
                if(x+i<0||x+i>=300)
                {
                    flag=0;
                    break;
                }
                if(arr2[x+i][y]!=arr3[i]) {
                    flag=0;
                    break;
                }
            }
            if(flag==1 )
                count++;
            flag=1;
            //左上到右下
    
            for(int i=1;i<=3;i++){
                if((y+i<0||y+i>=300)||(x+i<0&&x+i>=300)){
                    flag=0;
                    break;
                }
                if(arr2[i+x][y+i]!=arr3[i]){
                    flag=0;
                    break;
                }
            }
            if(flag==1)
                count++;
        }
    }
    

    答案:

    16520
    

    试题 C: 跑步锻炼

    本题总分:10 分

    【问题描述】

    小蓝每天都锻炼身体。
    正常情况下,小蓝每天跑 1 千米。如果某天是周一或者月初(1 日),为了激励自己,小蓝要跑 2 千米。如果同时是周一或月初,小蓝也是跑 2 千米。
    小蓝跑步已经坚持了很长时间,从 2000 年 1 月 1 日周六(含)到 2020 年10 月 1 日周四(含)。请问这段时间小蓝总共跑步多少千米?

    思路:

    先要把判断是不是闰年,然后2020年的时候要特判一下,因为
    2020年只到101日,判断星期几的时候只要取余就好了一月一号
    是星期六 那么对应的就是 2号对应星期天,3号对应星期一,4号
    对应星期二......天数下标从0开始
    
    public class 跑步锻炼 {
        static int []week={6,7,1,2,3,4,5};//一月一号星期六,依次往后推
        static int []months={0,31,28,31,30,31,30,31,31,30,31,30,31};
        public static void main(String[] args) {
            int ans=0;
            int sumday=0;//总天数.用来判断星期几
            //年
            for(int year=2000;year<=2020;year++){
    
                //判断是否是闰年
                if(!check(year)){
                    //不是闰年就按正常的来
                    for(int month=1;month<=12;month++){
                        for(int day=1;day<=months[month];day++){
                            if(day==1||week[sumday%7]==1)
                                ans+=2;
                            else ans++;
                            sumday++;
                        }
                    }
                }
                //是闰年
                else {
                    if(year==2020){//特判一下2020年因为今年就10个月跑
                        for (int month = 1; month <= 10; month++) {
                            if(month==10){
                                ans+=2;
                                break;
                            }
                            if (month != 2&&month<10) {
                                for (int day = 1; day <= months[month]; day++) {
                                    if (day == 1 || week[sumday % 7] == 1)
                                        ans += 2;
                                    else ans++;
                                    sumday++;
                                }
                            }
                            else if(month==2){
                                for (int day = 1; day <= 29; day++) {
                                    if (day == 1 || week[sumday % 7] == 1)
                                        ans += 2;
                                    else ans++;
                                    sumday++;
                                }
                            }
                        }
                    }
                   else {
                        for (int month = 1; month <= 12; month++) {
                            if (month != 2) {
                                for (int day = 1; day <= months[month]; day++) {
                                    if (day == 1 || week[sumday % 7] == 1)
                                        ans += 2;
                                    else ans++;
                                    sumday++;
                                }
                            } else {
                                for (int day = 1; day <= 29; day++) {
                                    if (day == 1 || week[sumday % 7] == 1)
                                        ans += 2;
                                    else ans++;
                                    sumday++;
                                }
                            }
                        }
    
                    }
    
                }
    
            }
            System.out.println(ans);
        }
        static boolean check(int year){
            if((year%4==0&&year%100!=0)||year%400==0){
                return true;
            }
            else return false;
        }
    }
    
    

    答案:8879

    D 平面分割

    本题总分:10 分

    【问题描述】

    20 个圆和 20 条直线最多能把平面分成多少个部分?

    抱歉能力有限写不来
    

    D 七段码

    题目:

    小蓝要用七段码数码管来表示一种特殊的文字。

    上图给出了七段码数码管的一个图示,数码管中一共有 7 段可以发光的二
    极管,分别标记为 a, b, c, d, e, f, g。

    小蓝要选择一部分二极管(至少要有一个)发光来表达字符。在设计字符
    的表达时,要求所有发光的二极管是连成一片的。

    例如:b 发光,其他二极管不发光可以用来表达一种字符。
    例如:c 发光,其他二极管不发光可以用来表达一种字符。
    这种方案与上一行的方案可以用来表示不同的字符,尽管看上去比较相似。

    例如:a, b, c, d, e 发光,f, g 不发光可以用来表达一种字符。
    例如:b, f 发光,其他二极管不发光则不能用来表达一种字符,因为发光
    的二极管没有连成一片。

    请问,小蓝可以用七段码数码管表达多少种不同的字符?

    思路:

    大体思路是这样
    1.要求多少种不同的表达式,换一种说法a~g所有的灯排成一行,放进一个
    一维数组(递归实现指数型枚举),每次从中选取人n个灯,选到的灯变亮,
    不选的不亮,这样就把所有情况都包含进来,我们只需判断每一种情况是否
    合法,和发则ans++;
    
    2.为了更好的判断所有亮的灯是否联通,把原图转换成一下这种二维图
    然后六个方向搜索就行了,哪六个呢:右下、左下、左上、右上、下两格、上两格;
    
    3.注意并不是所有的灯都有以上这六种方向,看原图的灯,如果a和g这
    两个灯亮了并不满足题意,因为它们不相连,因此a、g、d这个一列所搜的
    时候不会有六个方向只会有四个;
    
    
    

    在这里插入图片描述
    代码:

    import java.util.Scanner;
    public class 七段码 {
        static int N=7;
        static int ans=0;
        static int countdeng=0;//每一次深搜时亮灯的个数
    
        public static void main(String[] args) {
            Scanner input=new Scanner(System.in);
            //把所有灯的情况全部判断出来,然后判断此时的情况是否合法
            //第一步深搜枚举
            int []arr=new int[8];
            int []vis=new int[8];
            dfs(arr,vis,1);
    
            System.out.println(ans);
        }
        static void dfs(int []arr,int []vis,int level){
            if(level>7){
                check(arr);
                return;
            }
            //一共就两种情况,一种是要当前这个灯亮,一种是不要,分别深搜就行
            vis[level]=1;
            arr[level]=1;
            dfs(vis,arr,level+1);
            vis[level]=0;
            arr[level]=0;
            dfs(vis,arr,level+1);
        }
        static void check(int []arr){
            //先把此时灯亮的情况,在表格中显示出来,如果某一个灯需要亮
            //在二维表格中它对应的数就为1;
            int [][]map=new int[6][4];
            int [][]tempmap=new int[6][4];
            //a
            map[1][2]=arr[1];
            //b
            map[2][3]=arr[2];
            //c
            map[4][3]=arr[3];
            //d
            map[5][2]=arr[4];
            //e
            map[4][1]=arr[5];
            //f
            map[2][1]=arr[6];
            //g
            map[3][2]=arr[7];
    
            //我们要看此时灯是否能连起来
            //可以还用深搜,先把所有的灯亮的个数记录起来
            //然后以其中一个亮点为起点,向其中六个方向深搜
            //每找到一个一个可以联通的点总的灯数就减去一
            //最后全部搜完后还剩一盏灯亮着就说明当前方案可行,反之则不行
            //找总共有多少盏灯亮着
            //所欲多次深搜要初始化
            countdeng=0;
            for(int i=1;i<=5;i++) {
                for (int j = 1; j <= 3; j++) {
                    if (map[i][j] != 0)
                        countdeng++;
                }
            }
            //找到了所有灯之后,找一个亮灯的点,开始深搜
            int flag=0;//只需要找一个点深搜即可,搜一次后就全部停止
            for(int i=1;i<=5;i++){
                for(int j=1;j<=3;j++) {
                    if (map[i][j] != 0) {
                        flag = 1;
                        check2(map,tempmap, i, j);
                        break;
                    }
                }
                if (flag==1)
                    break;
            }
            if(countdeng-1==0)
            {
            ans++;
            }
        }
        //能走的六个方向
        public static  int []xx={1,1,-1,-1,-2,2};//2和-2是因为原图中两个边上的相连也算 
                                                 //转换成二维图就是加-2和加2
        public static  int []yy={-1,1,-1,1,0,0};
    
    
        static void check2(int [][]map,int [][]temp,int x,int y){
            temp[x][y]=1;//起始点也要标记下
            for(int i=0;i<6;i++){
                if(y==2&&i>=4){
                    continue;
                }
                //这一步很重要,因为中间的a,g,d按原图来是不能上下跳的,这样按原图来是不连续的
                //然后就是判断是否越界,是否已经找过,是否灯亮
                int tempx=x+xx[i];
                int tempy=y+yy[i];
                //看是否越界
                if(tempx>5||tempx<1)
                    continue;
                if(tempy>3||tempy<1)
                    continue;
                //是否找到过
                if(temp[tempx][tempy]!=0)
                    continue;
                //判断这个点是否有
                if(map[tempx][tempy]==0)
                    continue;
                if (map[tempx][tempy]==1) {
                    temp[tempx][tempy] = 1;
                    countdeng--;
                    check2(map, temp, tempx, tempy);
                }
            }
            return ;
        }
    
    }
    
    

    F: 成绩统计

    时间限制: 1.0s 内存限制: 512.0MB
    本题总分:15 分
    【问题描述】

    小蓝给学生们组织了一场考试,卷面总分为 100 分,每个学生的得分都是一个 0 到 100 的整数。
    如果得分至少是 60 分,则称为及格。如果得分至少为 85 分,则称为优秀。
    请计算及格率和优秀率,用百分数表示,百分号前的部分四舍五入保留整数。

    【输入格式】

    输入的第一行包含一个整数 n,表示考试人数。
    接下来 n 行,每行包含一个 0 至 100 的整数,表示一个学生的得分。

    【输出格式】

    输出两行,每行一个百分数,分别表示及格率和优秀率。百分号前的部分四舍五入保留整数。

    
    【样例输入】
    7
    80
    92
    56
    74
    88
    100
    0
    
    【样例输出】
    71%
    43%
    

    【评测用例规模与约定】

    对于 50% 的评测用例,1 ≤ n ≤ 100。
    对于所有评测用例,1 ≤ n ≤ 10000。

    思路:用Math.round四舍五入的时候要先乘100,因为小数点后的数不需要

    代码:

    import java.util.Scanner;
    public class 成绩统计 {
        public static void main(String[] args) {
           Scanner input=new Scanner(System.in);
            int N=input.nextInt();
            double []arr=new double[N+1];
            double hege=0;
            double better=0;
            for(int i=0;i<N;i++){
                arr[i]=input.nextDouble();
                if(arr[i]>=60)
                    hege++;
                if(arr[i]>=85)
                    better++;
            }
    
            System.out.println(Math.round((hege/N)*100)+"%");
            System.out.println(Math.round((better/N)*100)+"%");
    
        }
    }
    
    

    G 单词分析

    【问题描述】:

    小蓝正在学习一门神奇的语言,这门语言中的单词都是由小写英文字母组成,有些单词很长,远远超过正常英文单词的长度。小蓝学了很长时间也记不住一些单词,他准备不再完全记忆这些单词,而是根据单词中哪个字母出现得最多来分辨单词。

    现在,请你帮助小蓝,给了一个单词后,帮助他找到出现最多的字母和这个字母出现的次数。

    输入格式

    输入一行包含一个单词,单词只由小写英文字母组成。

    输出格式

    输出两行,第一行包含一个英文字母,表示单词中出现得最多的字母是哪
    个。如果有多个字母出现的次数相等,输出字典序最小的那个。
    第二行包含一个整数,表示出现得最多的那个字母在单词中出现的次数

    测试样例1

    输入:
    
    lanqiao
    
    输出:
    a
    2
    

    测试样例2

    输入:
    longlonglongistoolong
    
    输出:
    o
    6
    

    注意: 这个输出字典序最小的

    import java.util.Scanner;
    public class 单词分析 {
        public static void main(String[] args) {
            Scanner input=new Scanner(System.in);
            String a=input.next();
            char []arr=a.toCharArray();
            int max=-1;
            int  maxchar=' ';
            int []count=new int[129];
            for(int i=0;i<arr.length;i++){
                count[arr[i]]++;
            }
            for(int i=0;i<=128;i++){
                if(count[i]>max){
                    max=count[i];
                    maxchar=i;
                }
            }
            System.out.println((char)(maxchar));
            System.out.println(max);
    
        }
    }
    
    

    H 数字三角形

    【问题分析】:
    在这里插入图片描述

    上图给出了一个数字三角形。从三角形的顶部到底部有很多条不同的路径。
    对于每条路径,把路径上面的数加起来可以得到一个和,你的任务就是找到最大的和。
    路径上的每一步只能从一个数走到下一层和它最近的左边的那个数或者右边的那个数。此外,向左下走的次数与向右下走的次数相差不能超过 1。

    输入格式

    输入的第一行包含一个整数 N (1 < N ≤ 100),表示三角形的行数。下面的
    N 行给出数字三角形。数字三角形上的数都是 0 至 100 之间的整数

    输出格式

    输出一个整数,表示答案。

    思路:

    这题要想的一点就是`“左下走的次数与向右下走的次数相差不能超过 1”
    看着两个草图就比较好理解了,只要理解的剩下的就是dp
    

    在这里插入图片描述在这里插入图片描述代码:

    import java.util.Scanner;
    public class 数字三角形 {
        public static void main(String[] args) {
            Scanner input=new Scanner(System.in);
            int n=input.nextInt();
            int [][]arr=new int[n+1][n+1];
            int [][]dp=new int[n+1][n+1];
            for(int i=1;i<=n;i++){
                for(int j=1;j<=i;j++){
                    arr[i][j]=input.nextInt();
                }
            }
            for(int i=1;i<=n;i++){
                for(int j=1;j<=i;j++){
                  //最里面一列只能从上面下来
                  if(j==1){
                      dp[i][j]=dp[i-1][j]+arr[i][j];
                  }
                  //每行最边上一列只能从左上角下来
                  else if(i==j){
                      dp[i][j]=dp[i-1][j-1]+arr[i][j];
                  }
                  else {
                      dp[i][j]=Math.max(dp[i-1][j],dp[i-1][j-1])+arr[i][j];
                  }
                }
            }
            if(n%2!=0){
                System.out.println(dp[n][n/2+1]);
            }
            else {
                System.out.println(Math.max(dp[n][n/2+1],dp[n][n/2]));
            }
        }
    }
    
    

    I: 作物杂交

    时间限制: 1.0s 内存限制: 512.0MB
    本题总分:25 分

    【问题描述】

    作物杂交是作物栽培中重要的一步。已知有 N 种作物 (编号 1 至 N ),第i 种作物从播种到成熟的时间为 Ti。作物之间两两可以进行杂交,杂交时间取两种中时间较长的一方。

    如作物 A 种植时间为 5 天,作物 B 种植时间为 7 天,则 AB 杂交花费的时间为 7 天。作物杂交会产生固定的作物,新产生的作物仍然属于 N 种作物中的一种。

    初始时,拥有其中 M 种作物的种子 (数量无限,可以支持多次杂交)。同时可以进行多个杂交过程。求问对于给定的目标种子,最少需要多少天能够得到。

    如存在 4 种作物 ABCD,各自的成熟时间为 5 天、7 天、3 天、8 天。初始拥有 AB 两种作物的种子,目标种子为 D,

    已知杂交情况为 A × B → C,A × C → D。则最短的杂交过程为:
    第 1 天到第 7 天 (作物 B 的时间),A × B → C。
    第 8 天到第 12 天 (作物 A 的时间),A × C → D。

    花费 12 天得到作物 D 的种子。
    【输入格式】

    输入的第 1 行包含 4 个整数 N, M, K, T,N 表示作物种类总数 (编号 1 至N),M 表示初始拥有的作物种子类型数量,K 表示可以杂交的方案数,T 表示目标种子的编号。
    第 2 行包含 N 个整数,其中第 i 个整数表示第 i 种作物的种植时间Ti(1 ≤ Ti ≤ 100)。
    第 3 行包含 M 个整数,分别表示已拥有的种子类型 Kj(1 ≤ Kj ≤ M),Kj两两不同。
    第 4 至 K + 3 行,每行包含 3 个整数 A, B,C,表示第 A 类作物和第 B 类作物杂交可以获得第 C 类作物的种子。
    【输出格式】

    输出一个整数,表示得到目标种子的最短杂交时间。

    【样例输入】

    6 2 4 6
    5 3 4 6 4 9
    1 2
    1 2 3
    1 3 4
    2 3 5
    4 5 6
    

    【样例输出】

    16

    【样例说明】

    第 1 天至第 5 天,将编号 1 与编号 2 的作物杂交,得到编号 3 的作物种子。
    第 6 天至第 10 天,将编号 1 与编号 3 的作物杂交,得到编号 4 的作物种子。
    第 6 天至第 9 天,将编号 2 与编号 3 的作物杂交,得到编号 5 的作物种子。
    第 11 天至第 16 天,将编号 4 与编号 5 的作物杂交,得到编号 6 的作物种子。
    

    总共花费 16 天。

    【评测用例规模与约定】

    对于所有评测用例,1 ≤ N ≤ 2000, 2 ≤ M ≤ N, 1 ≤ K ≤ 100000, 1 ≤ T ≤ N,保证目标种子一定可以通过杂交得到。

    抱歉能力有限,没写来

    J 子串分值和

    问题描述:

    对于一个字符串 S,我们定义 S 的分值 f(S ) 为 S 中恰好出现一次的字符个数。例如 f(”aba”) = 1,f(”abc”) = 3, f(”aaa”) = 0。
    现在给定一个字符串 S [0…n - 1](长度为 n),请你计算对于所有 S 的非空子串 S [i… j] (0 ≤ i ≤ j < n),f(S [i… j]) 的和是多少。

    输入格式

    输入一行包含一个由小写字母组成的字符串 S。

    输出格式

    输出一个整数表示答案。

    数据范围

    对于 20%的评测用例,1≤n≤10;
    对于 40% 的评测用例,1≤n≤100;
    对于 50% 的评测用例,1≤n≤1000;
    对于 60% 的评测用例,1≤n≤10000;
    对于所有评测用例,1≤n≤100000。

    输入样例:

    ababc

    输出样例:

    21

    样例说明

    所有子串 f

    值如下:

    a     1
    ab    2
    aba   1
    abab  0
    ababc 1
     b    1
     ba   2
     bab  1
     babc 2
      a   1
      ab  2
      abc 3
       b  1
       bc 2
        c 1
    

    AcWing大佬题解

    展开全文
  • 第十一届蓝桥杯真题解析JavaC组

    千次阅读 2021-04-11 11:20:23
    第十一届蓝桥杯真题解析JavaC组 文章目录***第十一届蓝桥杯真题解析JavaC组***前言一、pandas是什么?二、使用步骤1.引入库2.读入数据总结 前言 提示:这里可以添加本文要记录的大概内容: 例如:随着人工智能的...

    第十一届蓝桥杯真题解析JavaC组


    前言

    希望以下的能够给你带来帮助。


    提示:以下是本篇文章正文内容,下面案例可供参考

    1.指数计算

    本题总分:5分


    问题描述

    请计算:7 ^ 2020 mod 1921,其中 A mod B 表示 A 除以 B 的余数。


    答案提交
    这是一道结果填空题,你只需要算出结果后提交即可。本题的结果为一个
    整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。


    480

    只需要使用到BigInteger这个类。

    代码如下(示例):

    import java.math.BigInteger;
    
    public class Eleven1_指数计算 {
    
    	public static void main(String[] args) {
    		BigInteger a = new BigInteger("7");
    		BigInteger b = a.pow(2020).mod(new BigInteger("1921"));
    		System.out.println(b);
    		//结果为480
    		
    		//这下面的是我自己对这些方法的尝试,为了熟悉
    //		BigInteger c = a.pow(2);
    //		System.out.println(c);
    //		BigInteger d = c.mod(new BigInteger("8"));
    //		System.out.println(d);
    	}
    }
    

    2.解密

    本题总分:5分


    题目描述
    小明设计了一种文章加密的方法:对于每个字母c,将它变成某个另外的字符Tc。下表给出了字符变换的规则:
    在这里插入图片描述
    例如,将字符串 YeRi 加密可得字符串 EaFn。
    小明有一个随机的字符串,加密后为
    EaFnjISplhFviDhwFbEjRjfIBBkRyY
    (由 30 个大小写英文字母组成,不包含换行符),请问原字符串是多少?
    (如果你把以上字符串和表格复制到文本文件中,请务必检查复制的内容
    是否与文档中的一致。在试题目录下有一个文件 str.txt,第一行为上面的字符
    串,后面 52 行依次为表格中的内容。)


    答案提交
    这是一道结果填空题,你只需要算出结果后提交即可。本题的结果为一个
    只包含 30 个大小写英文字母的字符串,在提交答案时只填写这个字符串,填写
    多余的内容将无法得分。

    YeRikGSunlRzgDlvRwYkXkrGWWhXaA

    这道题也有取巧的地方:就是根据题目给的表一个一个的对过去(不过一定要仔细!)
    当然,上面这个方法是鉴于题目给出的数据小。
    使用代码也不难,只要掌握了Map集合的运用即可。

    代码如下(示例):

    import java.util.HashMap;
    import java.util.Map;
    import java.util.Scanner;
    
    public class Eleven2_解密 {
    
    	public static void main(String[] args) {
    		Scanner scanner = new Scanner(System.in);
    		String str = scanner.next();	//加密之后的字符串
    		//使用Map集合。原因是:这里是成对出现的
    		Map<String, String> map = new HashMap<String, String>();
    		//循环52次:因为大小写字母共52个
    		for (int i = 0; i < 52; i++) {
    			String s1 = scanner.next();	//加密前的字符
    			String s2 = scanner.next();	//加密后的字符
    			
    			map.put(s2, s1);//加密后的为键,加密前的为值。因为我们已知的是加密后的
    		}
    		
    		String str2 = "";
    		//循环字符串
    		for (int i = 0; i < str.length(); i++) {
    			str2 += map.get(str.charAt(i) + "");	//拿到加密前的字符		拿到之后做拼接
    		}
    		System.out.println(str2);
    	}
    }
    

    3.跑步训练

    本题总分:10分


    题目描述
    小明要做一个跑步训练。
    初始时,小明充满体力,体力值计为 10000。如果小明跑步,每分钟损耗
    600 的体力。如果小明休息,每分钟增加 300 的体力。体力的损耗和增加都是
    均匀变化的。
    小明打算跑一分钟、休息一分钟、再跑一分钟、再休息一分钟……如此循
    环。如果某个时刻小明的体力到达 0,他就停止锻炼。
    请问小明在多久后停止锻炼。为了使答案为整数,请以秒为单位输出答案。
    答案中只填写数,不填写单位。


    答案提交

    这是一道结果填空题,你只需要算出结果后提交即可。本题的结果为一个
    整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。


    3880

    思路:
    可以看出,奇数时,就是在跑步;偶数时,就是在休息。
    要注意,不一定会刚刚好用完体力,而剩余的体力照样可以继续跑步
    由题中可推算出,每秒钟跑步消耗10体力
    推算:10000 / (600 - 300) = 33.33…
    32 * (600 - 300) = 9600
    剩:400
    总时间:32 * 2 * 60 + 400 / 10 = 3880
    所以这道题除了可使用代码实现,还可以直接计算出来

    注意:题目输出的最终结果是秒,不是分钟!

    代码如下(示例):

    public class Eleven3_跑步训练 {
    	
    	//初始体力
    	static int power = 10000;
    
    	public static void main(String[] args) {
    		int sum = 0;//统计跑了多久时间(分钟)
    		boolean juge = true;
    		for (int i = 1;; i++) {
    			if(power < 600 && juge) {
    				break;
    			}
    			//跑步
    			if(i % 2 != 0 && juge) {
    				power -= 600;
    				juge = false;
    			}else {	//休息
    				power += 300;
    				juge = true;
    			}
    			sum++;
    		}
    		System.out.println(sum * 60 + power / 10);
    	}
    }
    

    4.合并检测

    本题总分:10分


    题目描述

    新冠疫情由新冠病毒引起,最近在 A 国蔓延,为了尽快控制疫情,A 国准
    备给大量民众进病毒核酸检测。
    然而,用于检测的试剂盒紧缺。
    为了解决这一困难,科学家想了一个办法:合并检测。即将从多个人(k
    个)采集的标本放到同一个试剂盒中进行检测。如果结果为阴性,则说明这 k
    个人都是阴性,用一个试剂盒完成了 k 个人的检测。如果结果为阳性,则说明
    至少有一个人为阳性,需要将这 k 个人的样本全部重新独立检测(从理论上看,
    如果检测前 k − 1 个人都是阴性可以推断出第 k 个人是阳性,但是在实际操作中
    不会利用此推断,而是将 k 个人独立检测),加上最开始的合并检测,一共使用
    了 k + 1 个试剂盒完成了 k 个人的检测。
    A 国估计被测的民众的感染率大概是 1%,呈均匀分布。请问 k 取多少能
    最节省试剂盒?


    答案提交
    这是一道结果填空题,你只需要算出结果后提交即可。本题的结果为一个
    整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。


    10

    代码如下(示例):

    public class Eleven4_合并检测 {
    	
    	/**
    	 * 这里是学习视频上的
    	 * 思路:由题意得每一百个人中至少有一个人是被感染的,所以由此可推出k的取值范围为[1,100)。
    	 * 假设A国有n个人,每k个人为一组
    	 * n/k为所分的组数
    	 * n/100为感染的人数
    	 * 所以感染的人均匀分布在n/k这么多组里面
    	 * 
    	 * 假设一组中只有一个感染的人(最坏的情况)
    	 * 所需要的个数:
    	 * 	n/k(表示一开始每组都需要一个) + n/100*k(最坏的情况下,需要这么多试剂盒)
    	 * n(1/k + k/100)
    	 * @param args
    	 */
    
    	public static void main(String[] args) {
    		int allPerson = 1000;//随机确定的人数
    		int num = 0;//试剂盒的个数
    		int minx = 9999999;//试剂盒最少的个数
    		int answer = 0;//答案
    		
    		for (int k = 1; k < allPerson; k++) {
    			if(allPerson % k == 0) {
    				num = (allPerson / k) + (int) Math.floor(0.01 * allPerson * k);
    			}else {
    				num = (allPerson / k) + (int) Math.floor(0.01 * allPerson * k + 1);
    			}
    			//判断出最小试剂盒的情况就ok了
    			if(num < minx) {
    				minx = num;
    //				System.out.println(num);
    				answer = k;
    			}
    		}
    		System.out.println(answer);
    		print();
    	}
    	
    	public static void print() {
    		int people = 10000;//假设需要检测的人数
    		int min = people;//最少要用到的试剂盒
    		int k = 1;
    		int m = (int)(people * 0.01);//感染人数
    		for (int i = 2; i <= people; i++) {	//每i个人检测一次
    			int count = people / i;//表示第一次检测所需的试剂盒
    			if(people % i != 0) count++;
    			if(m >= count) {	//感染人数大于检测盒子数目,表明每个盒子都是阳性
    				count += people;
    			}else {
    				count += m * i;
    			}
    			if(count < min) {
    				k = i;
    				min = count;
    			}
    		}
    		System.out.println(k);
    	}
    }
    

    5.REPEAT程序

    本题总分:15分


    题目描述
    附件 prog.txt 中是一个用某种语言写的程序。
    其中 REPEAT k 表示一个次数为 k 的循环。循环控制的范围由缩进表达,
    从次行开始连续的缩进比该行多的(前面的空白更长的)为循环包含的内容。
    例如如下片段:

    REPEAT 2:
    	A = A + 4
    	REPEAT 5:
    		REPEAT 6:
    			A = A + 5
    		A = A + 7
    	A = A + 8
    A = A + 9
    

    该片段中从 A = A + 4 所在的行到 A = A + 8 所在的行都在第一行的循环两次中。
    REPEAT 6: 所在的行到 A = A + 7 所在的行都在 REPEAT 5: 循环中。
    A = A + 5 实际总共的循环次数是 2 × 5 × 6 = 60 次。
    请问该程序执行完毕之后,A 的值是多少?


    答案提交
    这是一道结果填空题,你只需要算出结果后提交即可。本题的结果为一个
    整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。


    241830

    代码如下(示例):

    import java.util.ArrayList;
    import java.util.List;
    
    public class Eleven5_REPEAT程序 {
    
    	public static void main(String[] args) {
    		//先实现举例中的
    		int A = 0;
    		for (int i = 0; i < 2; i++) {
    			A = A + 4;
    			for (int j = 0; j < 5; j++) {
    				for (int k = 0; k < 6; k++) {
    					A = A + 5;
    				}
    				A = A + 7;
    			}
    			A = A + 8;
    		}
    		A = A + 9;
    		System.out.println(A);
    		//例子的最终结果是403
    		print();
    	}
    	
    	//最终结果为241830
    	/**
    	 * 方法:替换
    	 * 这道题使用的方法是将它们进行替换。替换成for循环中的语句,最后将替换后得到的for循环运行一下,输出结果
    	 */
    	public static void print() {
    //		String str1 = "REPEAT 2:\n" + 
    //				"    A = A + 4\n" + 
    //				"    REPEAT 5:\n" + 
    //				"        REPEAT 6:\n" + 
    //				"            A = A + 5\n" + 
    //				"        A = A + 7\n" + 
    //				"    A = A + 8\n" + 
    //				"A = A + 9\n";
    		String str1 = "REPEAT 2:\r\n" + 
    				"    A = A + 4\r\n" + 
    				"    REPEAT 5:\r\n" + 
    				"        REPEAT 6:\r\n" + 
    				"            A = A + 5\r\n" + 
    				"        A = A + 7\r\n" + 
    				"    REPEAT 6:\r\n" + 
    				"        A = A + 7\r\n" + 
    				"        REPEAT 4:\r\n" + 
    				"            A = A + 2\r\n" + 
    				"            A = A + 7\r\n" + 
    				"        A = A + 2\r\n" + 
    				"    REPEAT 7:\r\n" + 
    				"        REPEAT 4:\r\n" + 
    				"            A = A + 8\r\n" + 
    				"            A = A + 7\r\n" + 
    				"            A = A + 4\r\n" + 
    				"            A = A + 5\r\n" + 
    				"        A = A + 8\r\n" + 
    				"    REPEAT 8:\r\n" + 
    				"        A = A + 5\r\n" + 
    				"        REPEAT 1:\r\n" + 
    				"            A = A + 2\r\n" + 
    				"        REPEAT 7:\r\n" + 
    				"            A = A + 5\r\n" + 
    				"        A = A + 5\r\n" + 
    				"    REPEAT 2:\r\n" + 
    				"        REPEAT 3:\r\n" + 
    				"            A = A + 1\r\n" + 
    				"        A = A + 1\r\n" + 
    				"    REPEAT 5:\r\n" + 
    				"        A = A + 1\r\n" + 
    				"    REPEAT 9:\r\n" + 
    				"        REPEAT 6:\r\n" + 
    				"            A = A + 5\r\n" + 
    				"            A = A + 1\r\n" + 
    				"        REPEAT 6:\r\n" + 
    				"            A = A + 2\r\n" + 
    				"            A = A + 8\r\n" + 
    				"            A = A + 3\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 5\r\n" + 
    				"        REPEAT 3:\r\n" + 
    				"            A = A + 9\r\n" + 
    				"        REPEAT 1:\r\n" + 
    				"            A = A + 4\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 9\r\n" + 
    				"        REPEAT 1:\r\n" + 
    				"            A = A + 6\r\n" + 
    				"            A = A + 6\r\n" + 
    				"            A = A + 4\r\n" + 
    				"        REPEAT 3:\r\n" + 
    				"            A = A + 7\r\n" + 
    				"        A = A + 1\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 3\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 2\r\n" + 
    				"            A = A + 5\r\n" + 
    				"            A = A + 2\r\n" + 
    				"        A = A + 4\r\n" + 
    				"    A = A + 3\r\n" + 
    				"REPEAT 4:\r\n" + 
    				"    A = A + 4\r\n" + 
    				"    A = A + 3\r\n" + 
    				"    A = A + 7\r\n" + 
    				"    REPEAT 5:\r\n" + 
    				"        REPEAT 4:\r\n" + 
    				"            A = A + 5\r\n" + 
    				"            A = A + 7\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 3\r\n" + 
    				"        REPEAT 3:\r\n" + 
    				"            A = A + 3\r\n" + 
    				"            A = A + 1\r\n" + 
    				"        A = A + 8\r\n" + 
    				"        A = A + 2\r\n" + 
    				"        REPEAT 9:\r\n" + 
    				"            A = A + 5\r\n" + 
    				"        REPEAT 1:\r\n" + 
    				"            A = A + 5\r\n" + 
    				"        A = A + 2\r\n" + 
    				"    A = A + 8\r\n" + 
    				"A = A + 6\r\n" + 
    				"REPEAT 3:\r\n" + 
    				"    REPEAT 4:\r\n" + 
    				"        A = A + 9\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 2\r\n" + 
    				"        A = A + 1\r\n" + 
    				"    REPEAT 9:\r\n" + 
    				"        A = A + 9\r\n" + 
    				"        A = A + 2\r\n" + 
    				"        REPEAT 1:\r\n" + 
    				"            A = A + 6\r\n" + 
    				"            A = A + 8\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 9\r\n" + 
    				"            A = A + 4\r\n" + 
    				"        A = A + 7\r\n" + 
    				"    REPEAT 2:\r\n" + 
    				"        REPEAT 7:\r\n" + 
    				"            A = A + 3\r\n" + 
    				"            A = A + 5\r\n" + 
    				"        REPEAT 3:\r\n" + 
    				"            A = A + 5\r\n" + 
    				"            A = A + 3\r\n" + 
    				"            A = A + 6\r\n" + 
    				"            A = A + 4\r\n" + 
    				"        REPEAT 9:\r\n" + 
    				"            A = A + 2\r\n" + 
    				"            A = A + 8\r\n" + 
    				"            A = A + 2\r\n" + 
    				"        A = A + 3\r\n" + 
    				"    REPEAT 2:\r\n" + 
    				"        REPEAT 8:\r\n" + 
    				"            A = A + 5\r\n" + 
    				"            A = A + 1\r\n" + 
    				"        A = A + 6\r\n" + 
    				"        A = A + 1\r\n" + 
    				"    A = A + 2\r\n" + 
    				"    REPEAT 6:\r\n" + 
    				"        REPEAT 1:\r\n" + 
    				"            A = A + 3\r\n" + 
    				"        REPEAT 1:\r\n" + 
    				"            A = A + 2\r\n" + 
    				"        REPEAT 4:\r\n" + 
    				"            A = A + 7\r\n" + 
    				"            A = A + 1\r\n" + 
    				"        A = A + 8\r\n" + 
    				"        REPEAT 6:\r\n" + 
    				"            A = A + 5\r\n" + 
    				"        REPEAT 6:\r\n" + 
    				"            A = A + 3\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 2\r\n" + 
    				"            A = A + 9\r\n" + 
    				"        A = A + 7\r\n" + 
    				"    REPEAT 9:\r\n" + 
    				"        A = A + 8\r\n" + 
    				"        REPEAT 9:\r\n" + 
    				"            A = A + 8\r\n" + 
    				"            A = A + 9\r\n" + 
    				"            A = A + 3\r\n" + 
    				"        A = A + 2\r\n" + 
    				"        REPEAT 6:\r\n" + 
    				"            A = A + 3\r\n" + 
    				"        REPEAT 9:\r\n" + 
    				"            A = A + 1\r\n" + 
    				"        A = A + 9\r\n" + 
    				"        A = A + 5\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 4\r\n" + 
    				"            A = A + 9\r\n" + 
    				"        A = A + 8\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 6\r\n" + 
    				"            A = A + 9\r\n" + 
    				"        A = A + 1\r\n" + 
    				"    REPEAT 1:\r\n" + 
    				"        A = A + 4\r\n" + 
    				"    A = A + 2\r\n" + 
    				"    REPEAT 9:\r\n" + 
    				"        REPEAT 3:\r\n" + 
    				"            A = A + 4\r\n" + 
    				"        REPEAT 7:\r\n" + 
    				"            A = A + 8\r\n" + 
    				"            A = A + 3\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 9\r\n" + 
    				"        REPEAT 8:\r\n" + 
    				"            A = A + 9\r\n" + 
    				"            A = A + 8\r\n" + 
    				"        REPEAT 4:\r\n" + 
    				"            A = A + 7\r\n" + 
    				"        A = A + 7\r\n" + 
    				"    A = A + 3\r\n" + 
    				"A = A + 5\r\n" + 
    				"REPEAT 6:\r\n" + 
    				"    A = A + 7\r\n" + 
    				"REPEAT 7:\r\n" + 
    				"    A = A + 2\r\n" + 
    				"    A = A + 2\r\n" + 
    				"A = A + 1\r\n" + 
    				"REPEAT 8:\r\n" + 
    				"    REPEAT 1:\r\n" + 
    				"        REPEAT 4:\r\n" + 
    				"            A = A + 6\r\n" + 
    				"            A = A + 6\r\n" + 
    				"            A = A + 2\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 4\r\n" + 
    				"            A = A + 8\r\n" + 
    				"            A = A + 4\r\n" + 
    				"        REPEAT 1:\r\n" + 
    				"            A = A + 5\r\n" + 
    				"        REPEAT 7:\r\n" + 
    				"            A = A + 8\r\n" + 
    				"        REPEAT 6:\r\n" + 
    				"            A = A + 4\r\n" + 
    				"        A = A + 4\r\n" + 
    				"        A = A + 8\r\n" + 
    				"        REPEAT 4:\r\n" + 
    				"            A = A + 2\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 4\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 3\r\n" + 
    				"        REPEAT 1:\r\n" + 
    				"            A = A + 2\r\n" + 
    				"        A = A + 8\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 7\r\n" + 
    				"        REPEAT 8:\r\n" + 
    				"            A = A + 6\r\n" + 
    				"            A = A + 1\r\n" + 
    				"        A = A + 7\r\n" + 
    				"    REPEAT 8:\r\n" + 
    				"        A = A + 2\r\n" + 
    				"    REPEAT 8:\r\n" + 
    				"        REPEAT 6:\r\n" + 
    				"            A = A + 1\r\n" + 
    				"            A = A + 6\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 4\r\n" + 
    				"            A = A + 1\r\n" + 
    				"        A = A + 7\r\n" + 
    				"    A = A + 4\r\n" + 
    				"REPEAT 4:\r\n" + 
    				"    REPEAT 9:\r\n" + 
    				"        A = A + 2\r\n" + 
    				"    REPEAT 1:\r\n" + 
    				"        A = A + 2\r\n" + 
    				"    A = A + 5\r\n" + 
    				"REPEAT 8:\r\n" + 
    				"    REPEAT 6:\r\n" + 
    				"        A = A + 3\r\n" + 
    				"    REPEAT 4:\r\n" + 
    				"        A = A + 1\r\n" + 
    				"        A = A + 6\r\n" + 
    				"        A = A + 1\r\n" + 
    				"    REPEAT 7:\r\n" + 
    				"        A = A + 7\r\n" + 
    				"        REPEAT 7:\r\n" + 
    				"            A = A + 3\r\n" + 
    				"            A = A + 9\r\n" + 
    				"            A = A + 1\r\n" + 
    				"            A = A + 9\r\n" + 
    				"        REPEAT 3:\r\n" + 
    				"            A = A + 5\r\n" + 
    				"        A = A + 5\r\n" + 
    				"        A = A + 6\r\n" + 
    				"        A = A + 2\r\n" + 
    				"    REPEAT 1:\r\n" + 
    				"        A = A + 4\r\n" + 
    				"    REPEAT 2:\r\n" + 
    				"        A = A + 7\r\n" + 
    				"    REPEAT 1:\r\n" + 
    				"        A = A + 7\r\n" + 
    				"        REPEAT 4:\r\n" + 
    				"            A = A + 7\r\n" + 
    				"        A = A + 2\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 9\r\n" + 
    				"            A = A + 1\r\n" + 
    				"            A = A + 9\r\n" + 
    				"            A = A + 5\r\n" + 
    				"            A = A + 9\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 5\r\n" + 
    				"        REPEAT 1:\r\n" + 
    				"            A = A + 6\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 3\r\n" + 
    				"            A = A + 2\r\n" + 
    				"            A = A + 6\r\n" + 
    				"            A = A + 8\r\n" + 
    				"            A = A + 8\r\n" + 
    				"            A = A + 7\r\n" + 
    				"        A = A + 5\r\n" + 
    				"    A = A + 5\r\n" + 
    				"REPEAT 2:\r\n" + 
    				"    A = A + 1\r\n" + 
    				"    A = A + 7\r\n" + 
    				"A = A + 3\r\n" + 
    				"REPEAT 2:\r\n" + 
    				"    A = A + 7\r\n" + 
    				"A = A + 1\r\n" + 
    				"A = A + 4\r\n" + 
    				"REPEAT 1:\r\n" + 
    				"    REPEAT 7:\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 3\r\n" + 
    				"            A = A + 5\r\n" + 
    				"            A = A + 2\r\n" + 
    				"        A = A + 6\r\n" + 
    				"    A = A + 1\r\n" + 
    				"A = A + 2\r\n" + 
    				"A = A + 4\r\n" + 
    				"A = A + 9\r\n" + 
    				"REPEAT 1:\r\n" + 
    				"    A = A + 8\r\n" + 
    				"REPEAT 8:\r\n" + 
    				"    REPEAT 4:\r\n" + 
    				"        REPEAT 8:\r\n" + 
    				"            A = A + 4\r\n" + 
    				"        REPEAT 3:\r\n" + 
    				"            A = A + 1\r\n" + 
    				"            A = A + 8\r\n" + 
    				"        REPEAT 7:\r\n" + 
    				"            A = A + 8\r\n" + 
    				"        REPEAT 7:\r\n" + 
    				"            A = A + 7\r\n" + 
    				"        A = A + 7\r\n" + 
    				"        REPEAT 7:\r\n" + 
    				"            A = A + 6\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 9\r\n" + 
    				"        A = A + 3\r\n" + 
    				"        REPEAT 4:\r\n" + 
    				"            A = A + 5\r\n" + 
    				"        A = A + 5\r\n" + 
    				"    A = A + 4\r\n" + 
    				"    REPEAT 9:\r\n" + 
    				"        REPEAT 3:\r\n" + 
    				"            A = A + 4\r\n" + 
    				"            A = A + 3\r\n" + 
    				"            A = A + 6\r\n" + 
    				"        REPEAT 1:\r\n" + 
    				"            A = A + 3\r\n" + 
    				"            A = A + 3\r\n" + 
    				"            A = A + 6\r\n" + 
    				"        REPEAT 6:\r\n" + 
    				"            A = A + 7\r\n" + 
    				"            A = A + 7\r\n" + 
    				"            A = A + 5\r\n" + 
    				"            A = A + 5\r\n" + 
    				"            A = A + 1\r\n" + 
    				"            A = A + 2\r\n" + 
    				"        A = A + 6\r\n" + 
    				"        A = A + 6\r\n" + 
    				"    REPEAT 9:\r\n" + 
    				"        A = A + 6\r\n" + 
    				"    REPEAT 1:\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 4\r\n" + 
    				"            A = A + 7\r\n" + 
    				"        REPEAT 3:\r\n" + 
    				"            A = A + 6\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 3\r\n" + 
    				"        A = A + 6\r\n" + 
    				"        REPEAT 9:\r\n" + 
    				"            A = A + 3\r\n" + 
    				"        A = A + 6\r\n" + 
    				"    REPEAT 5:\r\n" + 
    				"        A = A + 8\r\n" + 
    				"        A = A + 8\r\n" + 
    				"        REPEAT 3:\r\n" + 
    				"            A = A + 7\r\n" + 
    				"            A = A + 9\r\n" + 
    				"            A = A + 8\r\n" + 
    				"            A = A + 3\r\n" + 
    				"        A = A + 3\r\n" + 
    				"    A = A + 9\r\n" + 
    				"REPEAT 6:\r\n" + 
    				"    A = A + 9\r\n" + 
    				"A = A + 1\r\n" + 
    				"REPEAT 4:\r\n" + 
    				"    REPEAT 1:\r\n" + 
    				"        A = A + 7\r\n" + 
    				"    REPEAT 9:\r\n" + 
    				"        A = A + 2\r\n" + 
    				"        A = A + 9\r\n" + 
    				"    A = A + 1\r\n" + 
    				"A = A + 2\r\n" + 
    				"A = A + 8\r\n" + 
    				"A = A + 7\r\n" + 
    				"A = A + 9\r\n" + 
    				"A = A + 6\r\n" + 
    				"REPEAT 4:\r\n" + 
    				"    REPEAT 2:\r\n" + 
    				"        A = A + 3\r\n" + 
    				"    REPEAT 3:\r\n" + 
    				"        A = A + 4\r\n" + 
    				"    A = A + 4\r\n" + 
    				"REPEAT 6:\r\n" + 
    				"    A = A + 6\r\n" + 
    				"A = A + 1\r\n" + 
    				"A = A + 5\r\n" + 
    				"A = A + 8\r\n" + 
    				"REPEAT 2:\r\n" + 
    				"    A = A + 6\r\n" + 
    				"    REPEAT 1:\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 2\r\n" + 
    				"        REPEAT 3:\r\n" + 
    				"            A = A + 1\r\n" + 
    				"        REPEAT 1:\r\n" + 
    				"            A = A + 8\r\n" + 
    				"            A = A + 7\r\n" + 
    				"            A = A + 4\r\n" + 
    				"            A = A + 2\r\n" + 
    				"            A = A + 8\r\n" + 
    				"        A = A + 4\r\n" + 
    				"    REPEAT 5:\r\n" + 
    				"        REPEAT 6:\r\n" + 
    				"            A = A + 8\r\n" + 
    				"        REPEAT 9:\r\n" + 
    				"            A = A + 5\r\n" + 
    				"        A = A + 5\r\n" + 
    				"    REPEAT 5:\r\n" + 
    				"        A = A + 5\r\n" + 
    				"    REPEAT 3:\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 4\r\n" + 
    				"        REPEAT 4:\r\n" + 
    				"            A = A + 6\r\n" + 
    				"            A = A + 3\r\n" + 
    				"        REPEAT 7:\r\n" + 
    				"            A = A + 3\r\n" + 
    				"            A = A + 3\r\n" + 
    				"            A = A + 1\r\n" + 
    				"            A = A + 7\r\n" + 
    				"            A = A + 7\r\n" + 
    				"            A = A + 6\r\n" + 
    				"            A = A + 5\r\n" + 
    				"            A = A + 5\r\n" + 
    				"        A = A + 6\r\n" + 
    				"    REPEAT 1:\r\n" + 
    				"        A = A + 9\r\n" + 
    				"    A = A + 3\r\n" + 
    				"    REPEAT 1:\r\n" + 
    				"        REPEAT 1:\r\n" + 
    				"            A = A + 1\r\n" + 
    				"        REPEAT 8:\r\n" + 
    				"            A = A + 5\r\n" + 
    				"        REPEAT 8:\r\n" + 
    				"            A = A + 6\r\n" + 
    				"        REPEAT 4:\r\n" + 
    				"            A = A + 9\r\n" + 
    				"        A = A + 4\r\n" + 
    				"    REPEAT 2:\r\n" + 
    				"        A = A + 3\r\n" + 
    				"        A = A + 7\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 7\r\n" + 
    				"            A = A + 5\r\n" + 
    				"            A = A + 8\r\n" + 
    				"        A = A + 7\r\n" + 
    				"        A = A + 8\r\n" + 
    				"    A = A + 5\r\n" + 
    				"    REPEAT 2:\r\n" + 
    				"        A = A + 5\r\n" + 
    				"    A = A + 7\r\n" + 
    				"    A = A + 8\r\n" + 
    				"A = A + 5\r\n" + 
    				"A = A + 9\r\n" + 
    				"REPEAT 2:\r\n" + 
    				"    REPEAT 6:\r\n" + 
    				"        A = A + 9\r\n" + 
    				"        A = A + 1\r\n" + 
    				"        A = A + 8\r\n" + 
    				"        A = A + 7\r\n" + 
    				"        A = A + 1\r\n" + 
    				"        A = A + 5\r\n" + 
    				"    REPEAT 3:\r\n" + 
    				"        A = A + 3\r\n" + 
    				"        A = A + 9\r\n" + 
    				"        A = A + 7\r\n" + 
    				"    REPEAT 3:\r\n" + 
    				"        A = A + 9\r\n" + 
    				"    A = A + 1\r\n" + 
    				"    REPEAT 6:\r\n" + 
    				"        A = A + 1\r\n" + 
    				"    REPEAT 9:\r\n" + 
    				"        REPEAT 7:\r\n" + 
    				"            A = A + 3\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 5\r\n" + 
    				"            A = A + 8\r\n" + 
    				"            A = A + 8\r\n" + 
    				"            A = A + 1\r\n" + 
    				"            A = A + 2\r\n" + 
    				"        REPEAT 4:\r\n" + 
    				"            A = A + 6\r\n" + 
    				"        REPEAT 3:\r\n" + 
    				"            A = A + 3\r\n" + 
    				"        A = A + 7\r\n" + 
    				"    REPEAT 8:\r\n" + 
    				"        REPEAT 1:\r\n" + 
    				"            A = A + 7\r\n" + 
    				"        A = A + 8\r\n" + 
    				"        A = A + 3\r\n" + 
    				"    A = A + 1\r\n" + 
    				"A = A + 2\r\n" + 
    				"A = A + 4\r\n" + 
    				"A = A + 7\r\n" + 
    				"REPEAT 1:\r\n" + 
    				"    REPEAT 1:\r\n" + 
    				"        REPEAT 1:\r\n" + 
    				"            A = A + 4\r\n" + 
    				"            A = A + 6\r\n" + 
    				"        REPEAT 1:\r\n" + 
    				"            A = A + 3\r\n" + 
    				"            A = A + 9\r\n" + 
    				"            A = A + 6\r\n" + 
    				"        REPEAT 9:\r\n" + 
    				"            A = A + 1\r\n" + 
    				"            A = A + 6\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 3\r\n" + 
    				"            A = A + 9\r\n" + 
    				"        A = A + 5\r\n" + 
    				"        A = A + 5\r\n" + 
    				"    A = A + 7\r\n" + 
    				"    A = A + 2\r\n" + 
    				"    REPEAT 2:\r\n" + 
    				"        A = A + 7\r\n" + 
    				"    A = A + 7\r\n" + 
    				"    REPEAT 7:\r\n" + 
    				"        REPEAT 4:\r\n" + 
    				"            A = A + 6\r\n" + 
    				"        A = A + 8\r\n" + 
    				"        REPEAT 6:\r\n" + 
    				"            A = A + 6\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 1\r\n" + 
    				"        A = A + 7\r\n" + 
    				"        A = A + 6\r\n" + 
    				"    A = A + 7\r\n" + 
    				"    REPEAT 4:\r\n" + 
    				"        REPEAT 7:\r\n" + 
    				"            A = A + 1\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 2\r\n" + 
    				"            A = A + 5\r\n" + 
    				"        A = A + 8\r\n" + 
    				"    A = A + 2\r\n" + 
    				"A = A + 1\r\n" + 
    				"A = A + 4\r\n" + 
    				"REPEAT 8:\r\n" + 
    				"    A = A + 5\r\n" + 
    				"A = A + 6\r\n" + 
    				"REPEAT 7:\r\n" + 
    				"    REPEAT 6:\r\n" + 
    				"        REPEAT 9:\r\n" + 
    				"            A = A + 7\r\n" + 
    				"            A = A + 8\r\n" + 
    				"        REPEAT 4:\r\n" + 
    				"            A = A + 6\r\n" + 
    				"            A = A + 4\r\n" + 
    				"            A = A + 3\r\n" + 
    				"            A = A + 6\r\n" + 
    				"        REPEAT 9:\r\n" + 
    				"            A = A + 3\r\n" + 
    				"        REPEAT 9:\r\n" + 
    				"            A = A + 2\r\n" + 
    				"        A = A + 7\r\n" + 
    				"    A = A + 5\r\n" + 
    				"    A = A + 2\r\n" + 
    				"REPEAT 7:\r\n" + 
    				"    REPEAT 8:\r\n" + 
    				"        REPEAT 6:\r\n" + 
    				"            A = A + 4\r\n" + 
    				"            A = A + 9\r\n" + 
    				"            A = A + 5\r\n" + 
    				"            A = A + 3\r\n" + 
    				"        A = A + 9\r\n" + 
    				"    REPEAT 4:\r\n" + 
    				"        REPEAT 1:\r\n" + 
    				"            A = A + 6\r\n" + 
    				"            A = A + 8\r\n" + 
    				"        REPEAT 1:\r\n" + 
    				"            A = A + 6\r\n" + 
    				"        A = A + 4\r\n" + 
    				"        A = A + 6\r\n" + 
    				"    REPEAT 3:\r\n" + 
    				"        A = A + 7\r\n" + 
    				"        REPEAT 3:\r\n" + 
    				"            A = A + 4\r\n" + 
    				"            A = A + 4\r\n" + 
    				"            A = A + 2\r\n" + 
    				"        A = A + 3\r\n" + 
    				"        A = A + 7\r\n" + 
    				"    REPEAT 5:\r\n" + 
    				"        A = A + 6\r\n" + 
    				"        A = A + 5\r\n" + 
    				"    REPEAT 1:\r\n" + 
    				"        REPEAT 8:\r\n" + 
    				"            A = A + 5\r\n" + 
    				"        REPEAT 3:\r\n" + 
    				"            A = A + 6\r\n" + 
    				"        REPEAT 9:\r\n" + 
    				"            A = A + 4\r\n" + 
    				"        A = A + 3\r\n" + 
    				"    REPEAT 6:\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 1\r\n" + 
    				"        A = A + 5\r\n" + 
    				"    A = A + 2\r\n" + 
    				"A = A + 2\r\n" + 
    				"A = A + 7\r\n" + 
    				"REPEAT 4:\r\n" + 
    				"    A = A + 7\r\n" + 
    				"A = A + 9\r\n" + 
    				"A = A + 2\r\n" + 
    				"REPEAT 8:\r\n" + 
    				"    A = A + 9\r\n" + 
    				"    REPEAT 9:\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 3\r\n" + 
    				"            A = A + 2\r\n" + 
    				"            A = A + 1\r\n" + 
    				"            A = A + 5\r\n" + 
    				"        REPEAT 9:\r\n" + 
    				"            A = A + 1\r\n" + 
    				"            A = A + 3\r\n" + 
    				"        A = A + 9\r\n" + 
    				"        REPEAT 7:\r\n" + 
    				"            A = A + 2\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 9\r\n" + 
    				"            A = A + 3\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 4\r\n" + 
    				"        REPEAT 8:\r\n" + 
    				"            A = A + 9\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 5\r\n" + 
    				"            A = A + 4\r\n" + 
    				"        A = A + 2\r\n" + 
    				"    A = A + 4\r\n" + 
    				"    REPEAT 6:\r\n" + 
    				"        A = A + 2\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 7\r\n" + 
    				"            A = A + 7\r\n" + 
    				"            A = A + 8\r\n" + 
    				"            A = A + 3\r\n" + 
    				"        REPEAT 8:\r\n" + 
    				"            A = A + 2\r\n" + 
    				"            A = A + 5\r\n" + 
    				"        REPEAT 1:\r\n" + 
    				"            A = A + 8\r\n" + 
    				"            A = A + 5\r\n" + 
    				"            A = A + 1\r\n" + 
    				"            A = A + 1\r\n" + 
    				"        A = A + 5\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 6\r\n" + 
    				"        REPEAT 6:\r\n" + 
    				"            A = A + 9\r\n" + 
    				"            A = A + 2\r\n" + 
    				"        A = A + 5\r\n" + 
    				"        REPEAT 4:\r\n" + 
    				"            A = A + 7\r\n" + 
    				"        A = A + 1\r\n" + 
    				"        REPEAT 6:\r\n" + 
    				"            A = A + 8\r\n" + 
    				"        A = A + 4\r\n" + 
    				"    REPEAT 3:\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 1\r\n" + 
    				"            A = A + 5\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 7\r\n" + 
    				"        REPEAT 9:\r\n" + 
    				"            A = A + 6\r\n" + 
    				"            A = A + 8\r\n" + 
    				"            A = A + 9\r\n" + 
    				"        A = A + 5\r\n" + 
    				"    REPEAT 9:\r\n" + 
    				"        REPEAT 3:\r\n" + 
    				"            A = A + 7\r\n" + 
    				"            A = A + 7\r\n" + 
    				"        A = A + 9\r\n" + 
    				"        A = A + 7\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 7\r\n" + 
    				"            A = A + 2\r\n" + 
    				"        A = A + 1\r\n" + 
    				"    A = A + 8\r\n" + 
    				"    A = A + 3\r\n" + 
    				"    A = A + 5\r\n" + 
    				"A = A + 1\r\n" + 
    				"REPEAT 8:\r\n" + 
    				"    A = A + 4\r\n" + 
    				"A = A + 2\r\n" + 
    				"A = A + 2\r\n" + 
    				"A = A + 8\r\n" + 
    				"REPEAT 4:\r\n" + 
    				"    REPEAT 4:\r\n" + 
    				"        A = A + 8\r\n" + 
    				"        REPEAT 7:\r\n" + 
    				"            A = A + 5\r\n" + 
    				"            A = A + 2\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 6\r\n" + 
    				"        REPEAT 4:\r\n" + 
    				"            A = A + 8\r\n" + 
    				"            A = A + 6\r\n" + 
    				"        A = A + 1\r\n" + 
    				"    A = A + 3\r\n" + 
    				"A = A + 2\r\n" + 
    				"A = A + 7\r\n" + 
    				"A = A + 4\r\n" + 
    				"REPEAT 8:\r\n" + 
    				"    A = A + 2\r\n" + 
    				"    A = A + 4\r\n" + 
    				"REPEAT 5:\r\n" + 
    				"    REPEAT 3:\r\n" + 
    				"        REPEAT 6:\r\n" + 
    				"            A = A + 8\r\n" + 
    				"            A = A + 1\r\n" + 
    				"        A = A + 6\r\n" + 
    				"    A = A + 5\r\n" + 
    				"    A = A + 9\r\n" + 
    				"REPEAT 8:\r\n" + 
    				"    A = A + 7\r\n" + 
    				"REPEAT 6:\r\n" + 
    				"    A = A + 4\r\n" + 
    				"A = A + 5\r\n" + 
    				"REPEAT 3:\r\n" + 
    				"    A = A + 1\r\n" + 
    				"    REPEAT 1:\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 6\r\n" + 
    				"        A = A + 2\r\n" + 
    				"    REPEAT 9:\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 9\r\n" + 
    				"            A = A + 3\r\n" + 
    				"        REPEAT 9:\r\n" + 
    				"            A = A + 9\r\n" + 
    				"        A = A + 8\r\n" + 
    				"    REPEAT 8:\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 9\r\n" + 
    				"            A = A + 4\r\n" + 
    				"        REPEAT 9:\r\n" + 
    				"            A = A + 3\r\n" + 
    				"        A = A + 4\r\n" + 
    				"    A = A + 5\r\n" + 
    				"REPEAT 9:\r\n" + 
    				"    REPEAT 7:\r\n" + 
    				"        A = A + 5\r\n" + 
    				"    REPEAT 3:\r\n" + 
    				"        A = A + 7\r\n" + 
    				"    REPEAT 9:\r\n" + 
    				"        REPEAT 6:\r\n" + 
    				"            A = A + 4\r\n" + 
    				"        A = A + 6\r\n" + 
    				"    REPEAT 5:\r\n" + 
    				"        REPEAT 6:\r\n" + 
    				"            A = A + 5\r\n" + 
    				"            A = A + 3\r\n" + 
    				"        A = A + 3\r\n" + 
    				"    A = A + 3\r\n" + 
    				"    A = A + 5\r\n" + 
    				"    REPEAT 7:\r\n" + 
    				"        A = A + 5\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 5\r\n" + 
    				"            A = A + 6\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 2\r\n" + 
    				"        A = A + 5\r\n" + 
    				"    A = A + 3\r\n" + 
    				"A = A + 5\r\n" + 
    				"A = A + 5\r\n" + 
    				"REPEAT 4:\r\n" + 
    				"    A = A + 2\r\n" + 
    				"    A = A + 1\r\n" + 
    				"    REPEAT 9:\r\n" + 
    				"        A = A + 9\r\n" + 
    				"        A = A + 5\r\n" + 
    				"        A = A + 6\r\n" + 
    				"        A = A + 2\r\n" + 
    				"        A = A + 2\r\n" + 
    				"        A = A + 5\r\n" + 
    				"    REPEAT 9:\r\n" + 
    				"        A = A + 5\r\n" + 
    				"    A = A + 4\r\n" + 
    				"    REPEAT 4:\r\n" + 
    				"        REPEAT 4:\r\n" + 
    				"            A = A + 1\r\n" + 
    				"            A = A + 2\r\n" + 
    				"        REPEAT 6:\r\n" + 
    				"            A = A + 9\r\n" + 
    				"            A = A + 3\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 5\r\n" + 
    				"            A = A + 1\r\n" + 
    				"            A = A + 1\r\n" + 
    				"            A = A + 3\r\n" + 
    				"        A = A + 8\r\n" + 
    				"        REPEAT 7:\r\n" + 
    				"            A = A + 4\r\n" + 
    				"        REPEAT 6:\r\n" + 
    				"            A = A + 9\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 9\r\n" + 
    				"            A = A + 8\r\n" + 
    				"            A = A + 3\r\n" + 
    				"        A = A + 9\r\n" + 
    				"        A = A + 4\r\n" + 
    				"    A = A + 6\r\n" + 
    				"REPEAT 7:\r\n" + 
    				"    A = A + 9\r\n" + 
    				"REPEAT 9:\r\n" + 
    				"    A = A + 4\r\n" + 
    				"    A = A + 9\r\n" + 
    				"    A = A + 1\r\n" + 
    				"    A = A + 3\r\n" + 
    				"    REPEAT 5:\r\n" + 
    				"        REPEAT 1:\r\n" + 
    				"            A = A + 4\r\n" + 
    				"            A = A + 4\r\n" + 
    				"        REPEAT 8:\r\n" + 
    				"            A = A + 9\r\n" + 
    				"            A = A + 6\r\n" + 
    				"            A = A + 2\r\n" + 
    				"        REPEAT 3:\r\n" + 
    				"            A = A + 4\r\n" + 
    				"            A = A + 4\r\n" + 
    				"        REPEAT 3:\r\n" + 
    				"            A = A + 5\r\n" + 
    				"            A = A + 2\r\n" + 
    				"            A = A + 8\r\n" + 
    				"            A = A + 3\r\n" + 
    				"            A = A + 6\r\n" + 
    				"            A = A + 4\r\n" + 
    				"            A = A + 9\r\n" + 
    				"            A = A + 1\r\n" + 
    				"        A = A + 9\r\n" + 
    				"        A = A + 5\r\n" + 
    				"        A = A + 3\r\n" + 
    				"        REPEAT 3:\r\n" + 
    				"            A = A + 2\r\n" + 
    				"            A = A + 5\r\n" + 
    				"            A = A + 8\r\n" + 
    				"            A = A + 2\r\n" + 
    				"        A = A + 5\r\n" + 
    				"    REPEAT 8:\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 6\r\n" + 
    				"        A = A + 7\r\n" + 
    				"    A = A + 6\r\n" + 
    				"    A = A + 9\r\n" + 
    				"    A = A + 2\r\n" + 
    				"REPEAT 2:\r\n" + 
    				"    A = A + 3\r\n" + 
    				"    REPEAT 8:\r\n" + 
    				"        A = A + 7\r\n" + 
    				"        A = A + 2\r\n" + 
    				"        A = A + 1\r\n" + 
    				"        A = A + 4\r\n" + 
    				"        A = A + 1\r\n" + 
    				"        A = A + 5\r\n" + 
    				"    A = A + 2\r\n" + 
    				"    A = A + 1\r\n" + 
    				"    REPEAT 1:\r\n" + 
    				"        A = A + 1\r\n" + 
    				"    REPEAT 6:\r\n" + 
    				"        A = A + 4\r\n" + 
    				"        A = A + 3\r\n" + 
    				"    A = A + 3\r\n" + 
    				"    REPEAT 5:\r\n" + 
    				"        A = A + 3\r\n" + 
    				"    REPEAT 6:\r\n" + 
    				"        REPEAT 1:\r\n" + 
    				"            A = A + 5\r\n" + 
    				"            A = A + 7\r\n" + 
    				"            A = A + 7\r\n" + 
    				"            A = A + 7\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 9\r\n" + 
    				"        A = A + 7\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 9\r\n" + 
    				"            A = A + 1\r\n" + 
    				"            A = A + 9\r\n" + 
    				"        A = A + 8\r\n" + 
    				"        REPEAT 1:\r\n" + 
    				"            A = A + 2\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 8\r\n" + 
    				"        REPEAT 3:\r\n" + 
    				"            A = A + 2\r\n" + 
    				"            A = A + 9\r\n" + 
    				"        A = A + 6\r\n" + 
    				"        A = A + 3\r\n" + 
    				"    REPEAT 5:\r\n" + 
    				"        REPEAT 6:\r\n" + 
    				"            A = A + 5\r\n" + 
    				"            A = A + 5\r\n" + 
    				"        REPEAT 4:\r\n" + 
    				"            A = A + 5\r\n" + 
    				"        A = A + 4\r\n" + 
    				"        REPEAT 8:\r\n" + 
    				"            A = A + 9\r\n" + 
    				"            A = A + 1\r\n" + 
    				"        REPEAT 8:\r\n" + 
    				"            A = A + 8\r\n" + 
    				"            A = A + 1\r\n" + 
    				"        A = A + 4\r\n" + 
    				"        REPEAT 6:\r\n" + 
    				"            A = A + 6\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 3\r\n" + 
    				"            A = A + 9\r\n" + 
    				"            A = A + 6\r\n" + 
    				"            A = A + 9\r\n" + 
    				"        REPEAT 1:\r\n" + 
    				"            A = A + 4\r\n" + 
    				"        REPEAT 3:\r\n" + 
    				"            A = A + 3\r\n" + 
    				"            A = A + 4\r\n" + 
    				"            A = A + 2\r\n" + 
    				"            A = A + 8\r\n" + 
    				"        REPEAT 2:\r\n" + 
    				"            A = A + 4\r\n" + 
    				"        A = A + 1\r\n" + 
    				"        REPEAT 9:\r\n" + 
    				"            A = A + 2\r\n" + 
    				"        A = A + 9\r\n" + 
    				"    A = A + 7\r\n" + 
    				"REPEAT 7:\r\n" + 
    				"    REPEAT 7:\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 7\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 1\r\n" + 
    				"        A = A + 1\r\n" + 
    				"    REPEAT 5:\r\n" + 
    				"        A = A + 6\r\n" + 
    				"        REPEAT 1:\r\n" + 
    				"            A = A + 4\r\n" + 
    				"        REPEAT 9:\r\n" + 
    				"            A = A + 4\r\n" + 
    				"        A = A + 1\r\n" + 
    				"    REPEAT 6:\r\n" + 
    				"        A = A + 8\r\n" + 
    				"        A = A + 5\r\n" + 
    				"        REPEAT 1:\r\n" + 
    				"            A = A + 4\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 8\r\n" + 
    				"            A = A + 7\r\n" + 
    				"        A = A + 2\r\n" + 
    				"    REPEAT 3:\r\n" + 
    				"        A = A + 3\r\n" + 
    				"    REPEAT 8:\r\n" + 
    				"        REPEAT 8:\r\n" + 
    				"            A = A + 4\r\n" + 
    				"        A = A + 7\r\n" + 
    				"        REPEAT 5:\r\n" + 
    				"            A = A + 1\r\n" + 
    				"        REPEAT 8:\r\n" + 
    				"            A = A + 7\r\n" + 
    				"            A = A + 8\r\n" + 
    				"            A = A + 4\r\n" + 
    				"        A = A + 7\r\n" + 
    				"        A = A + 6\r\n" + 
    				"    A = A + 9\r\n" + 
    				"    A = A + 5\r\n" + 
    				"REPEAT 3:\r\n" + 
    				"    A = A + 5\r\n" + 
    				"    REPEAT 9:\r\n" + 
    				"        A = A + 1\r\n" + 
    				"    A = A + 7\r\n" + 
    				"REPEAT 1:\r\n" + 
    				"    A = A + 8\r\n" + 
    				"A = A + 4\r\n" + 
    				"REPEAT 8:\r\n" + 
    				"    REPEAT 7:\r\n" + 
    				"        A = A + 2\r\n" + 
    				"        REPEAT 4:\r\n" + 
    				"            A = A + 6\r\n" + 
    				"        A = A + 6\r\n" + 
    				"    REPEAT 1:\r\n" + 
    				"        A = A + 7\r\n" + 
    				"    A = A + 1\r\n" + 
    				"REPEAT 9:\r\n" + 
    				"    REPEAT 5:\r\n" + 
    				"        A = A + 6\r\n" + 
    				"        A = A + 5\r\n" + 
    				"        REPEAT 7:\r\n" + 
    				"            A = A + 3\r\n" + 
    				"            A = A + 6\r\n" + 
    				"        A = A + 8\r\n" + 
    				"    REPEAT 2:\r\n" + 
    				"        A = A + 7\r\n" + 
    				"    A = A + 1\r\n" + 
    				"    A = A + 9\r\n" + 
    				"    REPEAT 3:\r\n" + 
    				"        REPEAT 3:\r\n" + 
    				"            A = A + 5";
    //		System.out.println(str1);
    		String[] arr = str1.split("\n");//以换行符为分割	分割成一个数组
    		
    		int temp = 1;
    		List<Integer> list = new ArrayList<Integer>();	//代表要加反括号(“}”)的缩减位置
    		for (int i = 0; i < arr.length; i++) {
    			String str2 = arr[i];
    			int a = str2.indexOf("R");//先找R
    			
    			if(a == -1) {
    				a = str2.indexOf("A");//没找到R,就找A
    				if(list.contains(new Integer(a))) {
    					System.out.print("}");
    					list.remove(new Integer(a));
    				}
    //				str2 += ";";
    				System.out.println(str2 + ";");
    			}else {
    				if(list.contains(new Integer(a))) {
    					System.out.print("}");
    					list.remove(new Integer(a));
    				}
    				//变成像for循环的样子
    //				str2.replace("REPEAT", "for (int i " + temp +" = 0; i " + temp +" <").replace(":", "; i " + temp + "++) {");
    				System.out.println(str2.replace("REPEAT", "for (int i" + temp +" = 0; i" + temp +" <").replace(":", "; i" + temp + "++) {"));
    				temp++;
    				//需要在以后某一行加“}”
    				list.add(a);
    			}
    		}
    		for (Integer integer : list) {
    			System.out.println("}");
    		}
    	}
    
    }
    

    之后将得到的for循环运出来即可。


    6.分类计数

    时间限制: 1.0s 内存限制: 512.0MB 本题总分:15 分


    问题描述

    输入一个字符串,请输出这个字符串包含多少个大写字母,多少个小写字
    母,多少个数字。


    输入格式:

    输入一行包含一个字符串。


    输出格式:

    输出三行,每行一个整数,分别表示大写字母、小写字母和数字的个数。


    测试样例

    Input:
    1+a=Aab
    
    Output:
    1
    3
    1
    

    评测用例规模与约定
    对于所有评测用例,字符串由可见字符组成,长度不超过 100。


    这道题很简单。

    思路:
    大写字母就是A-Z之间,小写字母是a-z之间,数字就是0-9之间

    代码如下(示例):

    import java.util.Scanner;
    
    public class Eleven6_分类计数 {
    
    	public static void main(String[] args) {
    		Scanner scanner = new Scanner(System.in);
    		String str = scanner.next();
    		scanner.close();
    		//记录大写字母的个数
    		int capital = 0;
    		//记录小写字母的个数
    		int lowercase = 0;
    		//记录数字的个数
    		int nums = 0;
    		for (int i = 0; i < str.length(); i++) {
    			char arr = str.charAt(i);
    			if(arr >= 'A' && arr <= 'Z') {
    				capital++;
    			}else if(arr >= 'a' && arr <= 'z') {
    				lowercase++;
    			}else if(arr >= '0' && arr <= '9') {
    				nums++;
    			}
    		}
    		System.out.println(capital);
    		System.out.println(lowercase);
    		System.out.println(nums);
    	}
    }
    

    7.整除序列

    时间限制: 1.0s 内存限制: 512.0MB 本题总分:20 分


    问题描述

    有一个序列,序列的第一个数是 n,后面的每个数是前一个数整除 2,请输
    出这个序列中值为正数的项。


    输入格式

    输入一行包含一个整数 n。


    输出格式

    输出一行,包含多个整数,相邻的整数之间用一个空格分隔,表示答案。


    测试样例

    Input:
    20
    
    Output:
    20 10 5 2 1
    

    评测用例规模与约定

    对于 80% 的评测用例,1 ≤ n ≤ 10^9。
    对于所有评测用例,1 ≤ n ≤ 10^18。

    这道题同样不难。

    代码如下(示例):

    import java.util.Scanner;
    
    public class Eleven7_整除序列 {
    
    	public static void main(String[] args) {
    		Scanner scanner = new Scanner(System.in);
    		int n = scanner.nextInt();
    		scanner.close();
    		while(n > 0) {
    			System.out.print(n + " ");
    //			n /= 2;
    			n = n >> 1;
    		}
    	}
    }
    

    8.走方格

    时间限制: 1.0s 内存限制: 512.0MB 本题总分:20 分


    题目描述
    在平面上有一些二维的点阵。
    这些点的编号就像二维数组的编号一样,从上到下依次为第 1 至第 n 行,从左到右依次为第 1 至第 m 列,每一个点可以用行号和列号来表示。
    现在有个人站在第 1 行第 1 列,要走到第 n 行第 m 列。只能向右或者向下走。
    注意,如果行号和列数都是偶数,不能走入这一格中。
    问有多少种方案。


    输入格式

    输入一行包含两个整数 n, m。


    输出格式

    输出一个整数,表示答案。


    测试样例1:

    Input:
    3 4
    
    Output:
    2
    

    测试案例2:

    Input:
    6 6
    
    Output:
    0
    

    评测用例规模与约定
    对于所有评测用例,1 ≤ n ≤ 30, 1 ≤ m ≤ 30。


    通过推算得出:当n,m的值均为偶数时,是不可能走到目标位的,所以输出的就是0

    使用深搜

    代码如下(示例):

    import java.util.Scanner;
    
    public class Eleven8_走方格 {
    	
    	static int n;
    	static int m;
    	static int sum;//记录最终需要多少方法的变量
    	
    	public static void main(String[] args) {
    		Scanner scanner = new Scanner(System.in);
    		n = scanner.nextInt();
    		m = scanner.nextInt();
    		scanner.close();
    		sum = 0;
    		long startTime = System.currentTimeMillis();
    		dfs(1, 1);
    		System.out.println(sum);
    		long midTime = System.currentTimeMillis();
    		System.out.println((midTime - startTime) + "ms");	//通过测试,得出这种方法很耗时间,效率不高
    		print(n, m);
    		long endTime = System.currentTimeMillis();
    		System.out.println((endTime - midTime) + "ms");	//通过测试,显然这个更快
    	}
    	
    	public static void dfs(int i, int j) {
    		if(i > n || j > m) {
    			return;
    		}
    		//如果为偶数
    		if(i % 2 == 0 && j % 2 == 0) {
    			return;
    		}
    		if(i == n && j == m) {
    			sum++;
    			return;
    		}
    		//走的方向:向右或者向下
    		dfs(i, j + 1);
    		dfs(i + 1, j);
    	}
    	
    	//优化
    	public static void print(int n, int m) {
    		int[][] arr = new int[30][30];
    		for (int i = 0; i < 30; i++) {
    			for (int j = 0; j < 30; j++) {
    				if(i == 0 || j == 0) {
    					arr[i][j] = 1;
    				}else if(i % 2 == 1 && j % 2 == 1) {
    					arr[i][j] = 0;
    				}else {
    					arr[i][j] = arr[i - 1][j] + arr[i][j - 1];
    				}
    			}
    		}
    		System.out.println(arr[n - 1][m - 1]);
    	}
    }
    

    9.字符串编码

    时间限制: 1.0s 内存限制: 512.0MB 本题总分:25 分


    问题描述

    小明发明了一种给由全大写字母组成的字符串编码的方法。对于每一个大
    写字母,小明将它转换成它在 26 个英文字母中序号,即 A → 1, B → 2, … Z →
    26。
    这样一个字符串就能被转化成一个数字序列:
    比如 ABCXYZ → 123242526。
    现在给定一个转换后的数字序列,小明想还原出原本的字符串。当然这样
    的还原有可能存在多个符合条件的字符串。小明希望找出其中字典序最大的字
    符串。


    输入格式

    一个数字序列


    输出格式

    一个只包含大写字母的字符串,代表答案


    测试样例

    Input:
    123242526
    
    Output:
    LCXYZ
    

    评测用例规模与约定
    对于 20% 的评测用例,输入的长度不超过 20。
    对于所有评测用例,输入的长度不超过 200000。


    这道题也没什么难度,理解题目,理好思路即可。 代码如下(示例):
    import java.util.Scanner;
    
    public class Eleven9_字符串编码 {
    
    	public static void main(String[] args) {
    		Scanner scanner = new Scanner(System.in);
    		String str = scanner.nextLine();
    		scanner.close();
    		String result = "";
    		for (int i = 0; i < str.length(); i++) {
    			//判断i+2是否小于等于26,此时还有加上i+2的大小是否会超出字符串的长度
    			if(i + 2 <= str.length() && (Integer.valueOf(str.substring(i, i + 2))) <= 26) {
    				int k = (Integer.valueOf(str.substring(i, i + 2)));
    				char ch = (char)('A' - 1 + k);
    				result += ch;
    				i++;//加一的原因是:此时已经取了两位了
    			}else {
    				int k = (Integer.valueOf(str.substring(i, i + 1)));
    				char ch = (char)('A' - 1 + k);
    				result += ch;
    			}
    		}
    		System.out.println(result);
    	}
    }
    

    10.整数小拼接

    时间限制: 1.0s 内存限制: 512.0MB 本题总分:25 分


    问题描述
    给定义个长度为 n 的数组 A1 , A2 , ⋅ ⋅ ⋅ , An。
    你可以从中选出两个数 Ai和 Aj(i不等于j),然后将 Ai和 Aj一前一后拼成一个新的整数。例如 12 和 345 可以拼成 12345 或 34512 。
    注意交换 Ai和Aj的顺序总是被视为 2 种拼法,即便是 Ai=Aj时。
    请你计算有多少种拼法满足拼出的整数小于等于 K。


    输入格式
    第一行包含 2 个整数n和 K。
    第二行包含 n 个整数 A1 , A2 , ⋅ ⋅ ⋅ , An.


    输出格式
    一个整数代表答案。


    测试样例

    Input:
    4 33
    1 2 3 4
      
    Output:
    8
    

    评测用例规模与约定:
    对于 30% 的评测用例,1 ≤ N ≤ 1000, 1 ≤ K ≤ 10^8,1 <= Ai <= 10^4.
    对于所有评测用例,1 ≤ N ≤ 100000,1 ≤ K ≤ 10^10,1 <= Ai <= 10^9.


    这道题嘛,单单使用暴力破解法是没啥问题的。 但这只能得一些分,要拿全部分需要进行优化

    代码如下(示例):

    import java.util.Arrays;
    import java.util.Scanner;
    
    public class Eleven10_整数小拼接 {
    	
    	static int[] nums;
    	static int n;
    	static int k;
    	static String m;
    
    	public static void main(String[] args) {
    		inits();
    	}
    	
    	//暴力破解法——对于 30% 的评测用例,1 ≤ N ≤ 1000, 1 ≤ K ≤ 10^8,1 <= Ai <= 10^4.
    	public static void inits() {
    		Scanner scanner = new Scanner(System.in);
    		n = scanner.nextInt();
    		k = scanner.nextInt();
    		nums = new int[n];
    		for (int i = 0; i < n; i++) {
    			nums[i] = scanner.nextInt();
    		}
    		scanner.close();
    		int sum = 0;
    		for (int i = 0; i < n; i++) {
    			for (int j = 0; j < n; j++) {
    				if(i != j) {
    					String str = "" + nums[i] + nums[j];
    					int newArray = Integer.parseInt(str);
    					if(newArray <= k) {
    					sum++;
    					}
    				}
    			}
    		}
    		System.out.println(sum);
    	}
    

    以下是优化的代码。

    import java.util.Arrays;
    import java.util.Scanner;
    
    public class Eleven10_整数小拼接优化 {
    	
    	static int[] nums;
    	static int n;
    	static String k;
    
    	public static void main(String[] args) {
    		print();
    	}
    	
    	//优化——对于所有评测用例,1 ≤ N ≤ 100000,1 ≤ K ≤ 10^10,1 <= Ai <= 10^9.
    	public static void print() {
    		Scanner scanner = new Scanner(System.in);
    		n = scanner.nextInt();
    		k = scanner.next();
    		nums = new int[n];
    		for (int i = 0; i < n; i++) {
    			nums[i] = scanner.nextInt();
    		}
    		scanner.close();
    		
    		Arrays.sort(nums);
    		
    		int sum = 0;
    		for (int i = 0; i < nums.length; i++) {
    			String is = nums[i] + "";	//放在前面的数
    			if(is.length() >= k.length()) {	//如果数组中的某一个元素起始长度大于要比较的数字k时,直接跳出。
    				break;
    			}
    			//先截取前面的数的位数
    			String begin = k.substring(0, is.length());
    			if(begin.compareTo(is) < 0) {	//说明	345678	45后只能接999之内的数字(不能大于)
    				int a = k.length() - is.length();	//后面有多少位
    				int temp = (int)(Math.pow(10, a - 1)) - 1;
    				sum += findIndex(temp);
    				//如果我nums[i]这个数(放在前面的数),比temp还要小
    				if(nums[i] <= temp) {
    					sum--;
    				}
    			}else if(begin.compareTo(is) == 0) {
    				int temp = Integer.parseInt(k.substring(is.length()));
    				sum += findIndex(temp);
    				//如果我nums[i]这个数(放在前面的数),比temp还要小
    				if(nums[i] <= temp) {
    					sum--;
    				}
    			}else {
    				int a = k.length() - is.length();	//后面有多少位
    				int temp = (int)(Math.pow(10, a)) - 1;
    				sum += findIndex(temp);
    				//如果我nums[i]这个数(放在前面的数),比temp还要小
    				if(nums[i] <= temp) {
    					sum--;
    				}
    			}
    		}
    		System.out.println(sum);
    	}
    	
    	
    	//二分查找
    	public static int findIndex(int k) {
    		int left = 0;
    		int right = nums.length - 1;
    		int mid = (left + right) >> 1;
    		while(left < right) {
    			if(nums[mid] == k) {
    				return mid + 1;
    			}else if(nums[mid] < k) {
    				left = mid + 1;
    			}else {
    				right = mid;
    			}
    			mid = (left + right) >> 1;
    		}
    		//如果用二分法没有找到k
    		if(nums[mid] < k) {
    			return mid + 1;	//k比中间数大,那么只要小于等于中间数的,都比k小
    		}else {
    			return mid;	//k比中间数小,那么只要小于等于中间数下标为-1的这个数,比k小
    		}
    	}
    }
    

    总结

    对于算法题,还是要多做,才能熟练。一起加油吧!

    展开全文
  • import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner sc=new Scanner(System.in); int n=sc.nextInt(); Long arr[]=new Long[n]; for(int i=0;...

    import java.util.Scanner;
    public class Main {
    	public static void main(String[] args) {
    		Scanner sc=new Scanner(System.in);
    		int n=sc.nextInt();
    		Long arr[]=new Long[n];
    		for(int i=0;i<n;i++) {
    			arr[i]=sc.nextLong();
    		}
    		System.out.println(c(arr));
    	}
    
    	public static Long c(Long arr[]) {
    		Long sum=0L;
    		if(arr.length==0) {
    			return sum;
    		}		
    		for(int i=0;i<arr.length;i++) {
    			for(int j=0;j<i;j++) {
    				sum+=arr[i]*arr[j];
    			}			 
    		}
    		return sum;
    	}	
    }

    展开全文
  • 2019年第十届蓝桥杯真题解析JavaC组

    千次阅读 多人点赞 2020-09-21 14:40:28
    A.求和 【问题描述】 小明对数位中含有 2、0、...这题我跟用的强转,跟B的F题很类似,直接输入2019就能得到答案 代码: import java.util.Scanner; public class 求和A { public static void main(String[] args)
  • 第十一届蓝桥杯——javaC组

    千次阅读 热门讨论 2020-10-17 21:24:32
    } } 试题 G: 单词分析 时间限制: 1.0s 内存限制: 512.0MB 本题总分:20 分 【问题描述】 小蓝正在学习一门神奇的语言,这门语言中的单词都是由小写英文字母 成,有些单词很长,远远超过正常英文单词的长度。...
  • 蓝桥杯第十一届Javac组国二感想    打过第11届蓝桥杯的javac组国二的大二选手    参加蓝桥杯的原因最开始是想证明自己的能力,同时也完成了对自己内心的一场救赎。    故事从高中开始讲吧,高中的时候,我...
  • 2022第十三届蓝桥杯大赛软件赛省赛JavaC组真题
  • /* (程序头部注释开始)* 程序的版权和版本声明部分* Copyright (c) 2016, 广州科技贸易职业学院信息工程系学生* All rights reserved.* 文件名称: 蓝桥杯赛题* 作 者: 彭俊豪* 完成日期: 2016 年 04月 01日* 版 ...
  • 2016年第七届蓝桥杯真题解析JavaC组

    千次阅读 2020-10-06 11:26:22
    相关题目: 2016年第七届蓝桥杯真题解析JavaB组 2016年第七届蓝桥杯真题解析JavaC组 2017年第八届蓝桥杯真题解析JavaB组 2017年第八届蓝桥杯真题解析JavaC组 2018年第九届蓝桥杯真题解析JavaB组 2018年第九届蓝桥杯...
  • 第九届蓝桥杯国赛JavaC组测试数据包.rar
  • 2018年第九届蓝桥杯真题解析JavaC组

    千次阅读 2020-09-27 21:54:42
    相关题目: 2016年第七届蓝桥杯真题解析JavaB组 2016年第七届蓝桥杯真题解析JavaC组 2017年第八届蓝桥杯真题解析JavaB组 2017年第八届蓝桥杯真题解析JavaC组 2018年第九届蓝桥杯真题解析JavaB组 2018年第九届蓝桥杯...
  • 目录 A、美丽的 2 B、合数个数 C、扩散 D、阶乘约数 ...  他很好奇,在公元 1 年到公元 2020 年(包含)中,有多少个年份的数位中包含数字 2 ?...本题的结果为一个整数,在提交答案时只填写这个整数,填写
  • REPEAT 程序 试题 E: REPEAT 程序 本题总分:15 分 【问题描述】 附件 prog.txt 中是一个用某种语言写的程序。 其中 REPEAT k 表示一个次数为 k 的循环。循环控制的范围由缩进表达, 从次行开始连续的缩进比该行多的...
  • 第七届蓝桥杯JavaC组国(决)赛真题

    万次阅读 多人点赞 2019-07-18 21:18:02
    解题代码部分来自网友,如果有不对的地方,欢迎各位大佬评论 题目1、平方末尾 能够表示为某个整数的平方的数字称为“平方数” 比如,25,64 虽然无法立即说出某个数是平方数,但经常可以断定某个数不是平方数。...
  • // 将52密码输入并且存入Map中 for (int i = 0; i ; i++) { char c = sc.next().trim().charAt(0); char tc = sc.next().trim().charAt(0); coadMap.put(tc , c); //解密的 } String str = sc.next(); // 输入要...
  • 第六届蓝桥杯JavaC组国(决)赛真题

    万次阅读 多人点赞 2019-07-18 18:33:27
    解题代码部分来自网友,如果有不对的地方,欢迎各位大佬评论 题目1、机器人数目 少年宫新近邮购了小机器人配件,共有3类,其中, A类含有:8个轮子,1个传感器 B类含有: 6个轮子,3个传感器 C类含有:4个轮子,4个...
  • 文章目录A: 指数计算B:解密C:跑步训练D: 合并检测E: REPEAT 程序F: 分类计数G: 整除序列H: 走方格I: 字符串编码J: 整数小拼接 A: 指数计算 本题总分:5 分 【问题描述】 请计算:7 ^ 2020 mod 1921,其中 A mod B ...
  • A、哪天返回 小明被不明势力劫持。后被扔到x星站再无问津。小明得知每天都有飞船飞往地球,但需要108元的船票,而他却身无分文。 他决定在x星战打工。好心的老板答应包食宿,第1天给他1元钱。...
  •   接下来 T 行,每行包含一询问,其中第 i 行包含两个整数 li和 ri,表示询问数列中第 li个数到第 ri个数的和。 输出格式   输出 T 行,每行包含一个整数表示对应询问的答案。 测试样例1 Input: 3 1 1 1 3 5...
  • 第十一届蓝桥杯省赛JavaC组第三题跑步锻练 题目 package Work11; public class T03 { /* * 先设定一个类判断是否为闰年 闰年可以被4整除,但不能被100整数 ,或 可以被400整除 * 再设定一个日期数组,存放每个月...
  • 第十一届蓝桥杯java c国赛题解 目录第十一届蓝桥杯java c国赛题解试题 A: 美丽的 2试题 B: 合数个数试题 C: 扩散试题 D: 阶乘约数试题 E: 本质上升序列试题 F: 天干地支试题 G: 皮亚诺曲线距离试题 H: 蓝肽子...
  • //dp状态数 int dp[][] = new int[a.length()+1][b.length()+1];//0行和0列 为0 //循环查找公共子序列 for (int i = 1; i ; i++) {//字符串a for (int j = 1; j [0].length; j++) {//字符串b if(a...
  • 隔行变色 Excel表的格子很多,为了避免把某行的数据和相邻行混淆,可以采用隔行变色的样式。 小明设计的样式为:第1行蓝色,第2行白色,第3行蓝色,第4行白色,.... 现在小明想知道,从第21行到第50行一共包含了...
  • 六届 校赛 标题:杨辉三角 标题:调和级数 标题:回文素数 标题:让我怎能过大年 标题:位平方和。...标题:1/a的分数称为单位分数。...标题:隔行变色 标题:立方尾不变 标题:无穷分数 标题:循环节长度 标题:格子...
  • 目录 #A 浮点数 #B 求余 #C 双阶乘 #D 格点 #E 整数分解 #F 3 的倍数 #G 特殊年份 ...IEEE 754 规定一个双精度浮点数由 1位符号位、11 位阶和 52 位尾数组成(以上位数都表示二进制位数)。...这个整数
  •  只要一个的成员确定了,另一个的成员也就确定了。枚举一个的成员就可以了。  凭直觉,两个的成员数目不会差太多吧。 歪歪有话说:  既然求 1 所在的那个,那只要枚举剩余的成员就可以了。  貌似...
  • 目录 A :ASC B: 空间 试题 C: 卡片 D: 相乘 E: 路径 F: 时间显示 G: 最少砝码 H: 杨辉三角形 ...【问题描述】已知大写字母 A 的 ASCII 码为 65,请问大写字母 L 的 ASCII 码是多少?... System...
  • 蓝桥杯历年省赛真题汇总及题目详解 蓝桥杯历年决赛试题汇总及试题详解 目录 第一题:平方末尾 第二题:七星填数 第三题:打印数字 ...虽然无法立即说出某个数是平方数,但经常可以断定某个数不是平方数。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 40,562
精华内容 16,224
关键字:

javac组

java 订阅