第四届蓝桥杯真题解析【JavaC组】

业精于勤，荒于嬉；行成于思，毁于随。——韩愈

文章目录

***第四届蓝桥杯真题解析【JavaC组】***
前言
A：猜年龄
B：组素数
C：马虎的算式
D：第39级台阶
E：有理数类
F：逆波兰表达式
G：核桃的数量
H：打印十字图
I：买不到的数目
J：剪格子
总结

前言

以下是我做第四届蓝桥杯真题时的一些收获和笔记，希望对你们有帮助。

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

A：猜年龄

问题描述：

美国数学家维纳(N.Wiener)智力早熟，11岁就上了大学。他曾在1935~1936年应邀来中国清华大学讲学。

一次，他参加某个重要会议，年轻的脸孔引人注目。于是有人询问他的年龄，他回答说：
“我年龄的立方是个4位数。我年龄的4次方是个6位数。这10个数字正好包含了从0到9这10个数字，每个都恰好出现1次。”
请你推算一下，他当时到底有多年轻。
通过浏览器，直接提交他那时的年龄数字。
注意：不要提交解答过程，或其它的说明文字。

思路：

这道题的方法很简单，我们可以直接根据题目的要求写出代码。这个方法也就是模拟。

代码如下（示例）：

package Past_Exam_4.C组;import org.junit.Test;
import java.util.Arrays;ublic class Past1_猜年龄 {public static void guess_Age(){for (int i = 1;i < 100;i++){//判断i的立方是否是四位数if(Math.pow(i, 3) < 1000 || Math.pow(i, 3) > 9999){continue;}//判断i的四次方是否是六位数if(Math.pow(i, 4) < 100000 || Math.pow(i, 4) > 999999){continue;}String str = "" + (int)Math.pow(i, 3) + (int)Math.pow(i, 4);char[] tempCh = str.toCharArray();Arrays.sort(tempCh);String temp = String.valueOf(tempCh);if (temp.equals("0123456789")) {System.out.println(i);}}}@Testpublic void test1(){guess_Age();}public static void main(String[] args) {guess_Age();}}

B：组素数

问题描述：

素数就是不能再进行等分的数。比如：2 3 5 7 11 等。 9 = 3 * 3 说明它可以3等分，因而不是素数。

我们国家在1949年建国。如果只给你 1 9 4 9 这4个数字卡片，可以随意摆放它们的先后顺序
（但卡片不能倒着摆放啊，我们不是在脑筋急转弯！），那么，你能组成多少个4位的素数呢？
比如：1949，4919 都符合要求。
请你提交：能组成的4位素数的个数，不要罗列这些素数!!
注意：不要提交解答过程，或其它的辅助说明文字。

分析：

这首先，我们需要知道的是如何判断素数。所谓的素数其实就是除了1和本身的以外的都不能被整除的数，这个自然简单。
但重点是，我们该如何取出所有的组合（1，9，4，9），这其实可能会取到有重复出现的，这个是要考虑的。

思路：

我们先通过循环找出所有可能的组合，由于这里是通过for循环的方式来寻找的，所以就不会出现重复的。
当我们取出所有的组合后，再进行判断每个组合是否是素数，如果是，则累加1；不是，则下一个。最后，返回最终得到的数量。

代码如下（示例）：

package Past_Exam_4.C组;import org.junit.Test;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;public class Past2_组素数 {public static int set_Of_Primes1(){HashSet<String> set = new HashSet<>();//统计数量int count = 0;//因为题目给定了组合的数字，所以最小为1499，最大为9941for (int i = 1499;i <= 9941;i++){String tempStr = String.valueOf(i);char[] ch = tempStr.toCharArray();Arrays.sort(ch);String str = String.valueOf(ch);//判断是否由1,4,9,9所组成的if(str.equals("1499")){set.add(tempStr);}}Iterator<String> iterator = set.iterator();while (iterator.hasNext()){String str = (String)iterator.next();if(judge(Integer.valueOf(str))){count++;}}return count;}public static boolean judge(int n){//首先默认是素数boolean isPrimes = true;for (int i = 2;i < n;i++){if(n % i == 0){isPrimes = false;break;}}return isPrimes;}@Testpublic void test1(){System.out.println(set_Of_Primes1());}}

C：马虎的算式

问题描述：

小明是个急性子，上小学的时候经常把老师写在黑板上的题目抄错了。

有一次，老师出的题目是：36 x 495 = ?
他却给抄成了：396 x 45 = ?
但结果却很戏剧性，他的答案竟然是对的！！
因为 36 * 495 = 396 * 45 = 17820
类似这样的巧合情况可能还有很多，比如：27 * 594 = 297 * 54
假设 a b c d e 代表1~9不同的5个数字（注意是各不相同的数字，且不含0）
能满足形如： ab * cde = adb * ce 这样的算式一共有多少种呢？
请你利用计算机的优势寻找所有的可能，并回答不同算式的种类数。
满足乘法交换律的算式计为不同的种类，所以答案肯定是个偶数。
答案直接通过浏览器提交。
注意：只提交一个表示最终统计种类数的数字，不要提交解答过程或其它多余的内容。

思路：

这道题是很简单的，我们可以直接使用暴力破解法来实现该题。

代码如下（示例）：

package Past_Exam_4.C组;import org.junit.Test;public class Past3_马虎的算式 {public static void careless_Equation(){//统计数量int count = 0;for (int a = 1;a <= 9;a++){for (int b = 1;b <= 9;b++){for (int c = 1;c <= 9;c++){for (int d = 1;d <= 9;d++){for (int e = 1;e <= 9;e++){if(a != b && a != c && a != d && a != e &&b != c && b != d && b != e &&c != d && c != e &&d != e){if((a * 10 + b) * (c * 100 + d * 10 + e) == (a * 100 + d * 10 + b) * (c * 10 + e)){count++;}}}}}}}System.out.println(count);}@Testpublic void test1(){careless_Equation();}}

D：第39级台阶

问题描述：

小明刚刚看完电影《第39级台阶》，离开电影院的时候，他数了数礼堂前的台阶数，恰好是39级! 站在台阶前，他突然又想着一个问题：

如果我每一步只能迈上1个或2个台阶。
先迈左脚，然后左右交替，最后一步是迈右脚，也就是说一共要走偶数步。那么，上完39级台阶，有多少种不同的上法呢？
请你利用计算机的优势，帮助小明寻找答案。
要求提交的是一个整数。
注意：不要提交解答过程，或其它的辅助说明文字。

思路：

一道不算太难的题目。所使用的方法为递归。
首先，这道题和《走楼梯》是相似的，那么思路也是一样的。
我们所需要的考虑的是两个部分：奇数部分和偶数部分。
也就是说，整体阶梯将有奇数和偶数两种情况，对此要分开。
对于这两个部分，我们将其分开递归

代码如下（示例）：

package Past_Exam_4.C组;import org.junit.Test;public class Past4_第39级台阶 {/*** 求奇数阶的* @param n* @return*/public int ji(int n){if(n == 1) return 1;if(n == 2) return 1;return ou(n - 1) + ou(n - 2);}/*** 求偶数阶的* @param n* @return*/public int ou(int n){if(n == 1) return 0;if(n == 2) return 1;return ji(n - 1) + ji(n - 2);}@Testpublic void test1(){System.out.println(ou(39));}}

E：有理数类

问题描述：

有理数就是可以表示为两个整数的比值的数字。一般情况下，我们用近似的小数表示。但有些时候，不允许出现误差，必须用两个整数来表示一个有理数。这时，我们可以建立一个“有理数类”，下面的代码初步实现了这个目标。为了简明，它只提供了加法和乘法运算。

class Rational{private long ra;private long rb;private long gcd(long a, long b){if(b==0) return a;return gcd(b,a%b);}public Rational(long a, long b){ra = a;rb = b;long k = gcd(ra,rb);if(k>1){ //需要约分ra /= k;rb /= k;}}// 加法public Rational add(Rational x){return ______________________________________;//填写位置}// 乘法public Rational mul(Rational x){return new Rational(ra*x.ra, rb*x.rb);}public String toString(){if(rb==1) return "" + ra;return ra + "/" + rb;}}

使用该类的示例：

Rational a = new Rational(1,3);
Rational b = new Rational(1,6);
Rational c = a.add(b);
System.out.println(a + "+" + b + "=" + c);

请分析代码逻辑，并推测划线处的代码，通过网页提交
注意：仅把缺少的代码作为答案，千万不要填写多余的代码、符号或说明文字！！

思路：

这道题只需要根据题目所给出的示例进行推算，就可以一步步推出最终的结果。

代码如下（示例）：

//最终的答案为
new Rational(ra * x.rb + rb * x.ra, rb * x.rb);

F：逆波兰表达式

问题描述：
正常的表达式称为中缀表达式，运算符在中间，主要是给人阅读的，机器求解并不方便。

例如：3 + 5 * (2 + 6) - 1而且，常常需要用括号来改变运算次序。
相反，如果使用逆波兰表达式（前缀表达式）表示，上面的算式则表示为：- + 3 * 5 + 2 6 1
不再需要括号，机器可以用递归的方法很方便地求解。
为了简便，我们假设：

只有 + - * 三种运算符；
每个运算数都是一个小于10的非负整数；

下面的程序对一个逆波兰表示串进行求值。
其返回值为一个数组：其中第一元素表示求值结果，第二个元素表示它已解析的字符数。

static int[] evaluate(String x) {if(x.length()==0) return new int[] {0,0};char c = x.charAt(0);if(c>='0' && c<='9') return new int[] {c-'0',1};int[] v1 = evaluate(x.substring(1));int[] v2 = __________________________________________;  //填空位置int v = Integer.MAX_VALUE;if(c=='+') v = v1[0] + v2[0];if(c=='*') v = v1[0] * v2[0];if(c=='-') v = v1[0] - v2[0];return new int[] {v,1+v1[1]+v2[1]};}

请分析代码逻辑，并推测划线处的代码，通过网页提交。
注意：仅把缺少的代码作为答案，千万不要填写多余的代码、符号或说明文字！！

分析过程：

在题目中，实际需要我们计算的只有v2的表达式，v无需考虑；
若要确定v2，我们要根据v的赋值表达式进行判断；
根据例子思考，第一步进行完后式子变为v=3-v2；
由于原式样式还未求出，所以v2也应该是一个表达式，所以推断出v2形式可能与v1类似v2 = evaluate(x.substring(？))；
？处应添加相应index，又由于v1[1]表示处理过的字符数，若将index=v1[1]+1，则可以对下一个字符进行处理；
将代码代入尝试。

建议：如果不清楚什么是逆波兰表达式的话，最好去补充一下。

代码如下（示例）：

//最终的答案为
evaluate(x.substring(1 + v1[1]));

G：核桃的数量

问题描述：

小张是软件项目经理，他带领3个开发组。工期紧，今天都在加班呢。为鼓舞士气，小张打算给每个组发一袋核桃（据传言能补脑）。他的要求是：

各组的核桃数量必须相同；
各组内必须能平分核桃（当然是不能打碎的）；
尽量提供满足1,2条件的最小数量（节约闹革命嘛）。

程序从标准输入读入：
a b c
a,b,c都是正整数，表示每个组正在加班的人数，用空格分开（a,b,c<30）
程序输出：
一个正整数，表示每袋核桃的数量。

例如：
用户输入：
2 4 5
程序输出：
20

再例如：
用户输入：
3 1 1
程序输出：
3

资源约定：
峰值内存消耗（含虚拟机） < 64M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

思路：

根据题目可得，这道题其实就是一道由求三个数的最小公倍数转变的。那么，我们只需要求这
三个数的最小公倍数即可。

代码如下（示例）：

package Past_Exam_4.C组;import java.util.Scanner;public class Past7_核桃的数量 {public static int walnutSum(int a, int b, int c){int count = 0;for (int i = 1;;i++){if(i % a == 0 && i % b == 0 && i % c == 0){count = i;break;}}return count;}public static void main(String[] args) {Scanner scanner = new Scanner(System.in);int a = scanner.nextInt();int b = scanner.nextInt();int c = scanner.nextInt();scanner.close();System.out.println(walnutSum(a, b, c));}
}

H：打印十字图

问题描述：

小明为某机构设计了一个十字型的徽标（并非红十字会啊），如下所示(可参见p1.jpg)

  $$$$$$$$$$$$$$           $
$$$ $$$$$$$$$ $$$
$   $       $   $
$ $$$ $$$$$ $$$ $
$ $   $   $   $ $
$ $ $$$ $ $$$ $ $
$ $ $   $   $ $ $
$ $ $ $$$$$ $ $ $
$ $ $   $   $ $ $
$ $ $$$ $ $$$ $ $
$ $   $   $   $ $
$ $$$ $$$$$ $$$ $
$   $       $   $
$$$ $$$$$$$$$ $$$$           $$$$$$$$$$$$$$

对方同时也需要在电脑dos窗口中以字符的形式输出该标志，并能任意控制层数。
为了能准确比对空白的数量，程序要求对行中的空白以句点（.）代替。
输入格式：
一个正整数 n (n<30) 表示要求打印图形的层数
输出：
对应包围层数的该标志。

例如：
用户输入：
1
程序应该输出：

..$$$$$..
..$...$..
$$$.$.$$$
$...$...$
$.$$$$$.$
$...$...$
$$$.$.$$$
..$...$..
..$$$$$..

再例如：
用户输入：
3
程序应该输出：

..$$$$$$$$$$$$$..
..$...........$..
$$$.$$$$$$$$$.$$$
$...$.......$...$
$.$$$.$$$$$.$$$.$
$.$...$...$...$.$
$.$.$$$.$.$$$.$.$
$.$.$...$...$.$.$
$.$.$.$$$$$.$.$.$
$.$.$...$...$.$.$
$.$.$$$.$.$$$.$.$
$.$...$...$...$.$
$.$$$.$$$$$.$$$.$
$...$.......$...$
$$$.$$$$$$$$$.$$$
..$...........$..
..$$$$$$$$$$$$$..

请仔细观察样例，尤其要注意句点的数量和输出位置。
资源约定：
峰值内存消耗（含虚拟机） < 64M
CPU消耗 < 1000ms

思路：

这道题是有一定难度的，但是我们通过对题目中给出的示例，可以推出这个图的规律。
总的来说，这道题考的就是分析能力和细心能力。

代码如下（示例）：

package Past_Exam_4.C组;import java.util.Scanner;public class Past8_打印十字图 {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);int n = scanner.nextInt();scanner.close();//通过分析得：每层周期的变化为5 + 4 * nint len = 5 + 4 * n;//取中心点int mid = len / 2;char[][] result = new char[len][len];for (int i = 0;i < len;i++){for (int j = 0;j < len;j++){result[i][j] = '.';}}//打印中心的十字for (int i = mid - 2;i <= mid + 2;i++){result[mid][i] = '&';result[i][mid] = '&';}//现在从中心开始向外打印for (int i = 1;i <= n;i++){     //控制打印几层for (int j = mid - 2 * i;j <= mid + 2 * i;j++){result[mid - 2 * (i + 1)][j] = '&'; //上横result[mid + 2 * (i + 1)][j] = '&'; //下横result[j][mid - 2 * (i + 1)] = '&'; //左侧result[j][mid + 2 * (i + 1)] = '&'; //右侧}//还差四个角//左上角result[mid - 2 * i][mid - 2 * i - 1] = '&';result[mid - 2 * i][mid - 2 * i] = '&';result[mid - 2 * i - 1][mid - 2 * i] = '&';//右上角result[mid - 2 * i][mid + 2 * i] = '&';result[mid - 2 * i][mid + 2 * i + 1] = '&';result[mid - 2 * i - 1][mid + 2 * i] = '&';//左下角result[mid + 2 * i][mid - 2 * i] = '&';result[mid + 2 * i + 1][mid - 2 * i] = '&';result[mid + 2 * i][mid - 2 * i - 1] = '&';//右下角result[mid + 2 * i][mid + 2 * i] = '&';result[mid + 2 * i][mid + 2 * i + 1] = '&';result[mid + 2 * i + 1][mid + 2 * i] = '&';}for (int i = 0;i < len;i++){for (int j = 0;j < len;j++){System.out.print(result[i][j]);}System.out.println();}}
}

I：买不到的数目

问题描述：

小明开了一家糖果店。他别出心裁：把水果糖包成4颗一包和7颗一包的两种。糖果不能拆包卖。小朋友来买糖的时候，他就用这两种包装来组合。当然有些糖果数目是无法组合出来的，比如要买 10 颗糖。你可以用计算机测试一下，在这种包装情况下，最大不能买到的数量是17。大于17的任何数字都可以用4和7组合出来。本题的要求就是在已知两个包装的数量时，求最大不能组合出的数字。

输入：
两个正整数，表示每种包装中糖的颗数(都不多于1000)
要求输出：
一个正整数，表示最大不能买到的糖数
不需要考虑无解的情况

例如：
用户输入：
4 7
程序应该输出：
17

再例如：
用户输入：
3 5
程序应该输出：
7

资源约定：
峰值内存消耗（含虚拟机） < 64M
CPU消耗 < 3000ms

思路：

这道题其实我也是半懂的状态

补充知识点：（什么是互质？）

解释：互质是公约数只有1的两个整数，叫做互质整数。公约数只有1的两个自然数，叫做互质自然数，后者是前者的特殊情形。

定义：

互质，若N个整数的最大公因数是1，则称这N个整数互质。例如，8和10的最大公约数是2，不是1，因此它们不是整数互质；
而7、11和13的最大公约数是1，因此这是整数互质。5和5不互质，因为5和5的公因数有1、5。
1和任何数都成倍数关系，但和任何数都互质。因为1的因数只有1，而互质数的原则是：只要两数的公因数只有1时，就说两数是互质数。
因为1只有一个因数所以1既不是质数（素数），也不是合数，无法再找到1和其他数的别的公因数了。1和-1与所有整数互素，而且它们是唯一与0互素的整数。
注意：这里有一个误区，认为0不与任何数互质。严格地按照互质的定义来看0与1，-1均互质，通过任意有理数的表示方式a/b（a,b互质且b为正整数），
同样可以得出0与1，-1均必须互质，否则0不是有理数。

代码如下（示例）：

方法一：数学（这个方法不会，毕竟还久没学数学了）

public int cannot_Buy1(int a, int b){return a * b - a - b;
}

方法二：暴力破解法

package Past_Exam_4.C组;import java.util.HashSet;
import java.util.Set;public class Past9_买不到的数目 {/*** 方法二：暴力破解法* 思路与算法：*      当x,y可以小于0时，那么买不到的数目是不存在的，所以无需考虑。*      当x,y大于等于0时，存在一个最大的买不到的数目，且一旦超过这个最大的买不到的数目，后面的数均可以买到。*      那么，我们就枚举所有的组合存储到集合中。然后，当c = ab时ab为最小公倍数时，c是一定有解，我们逆序枚举，*      只要是集合中第一次没有出现过的数，那就是最大的买不到的数目。* @param a* @param b*/public void cannot_Buy2(int a, int b){Set<Integer> set = new HashSet<>();for (int x = 0;a * x <= a * b;x++){for (int y = 0;a * x + b * y <= a * b;y++){set.add(a * x + b * y);}}for (int i = a * b;i > 0;i--){if(!set.contains(i)){System.out.println(i);break;}}}

J：剪格子

问题描述：

如图p1.jpg所示，3 x 3 的格子中填写了一些整数。

我们沿着图中的红色线剪开，得到两个部分，每个部分的数字和都是60。
本题的要求就是请你编程判定：对给定的m x n 的格子中的整数，是否可以分割为两个部分，使得这两个区域的数字和相等。
如果存在多种解答，请输出包含左上角格子的那个区域包含的格子的最小数目。
如果无法分割，则输出 0
程序输入输出格式要求：
程序先读入两个整数 m n 用空格分割 (m,n<10)
表示表格的宽度和高度
接下来是n行，每行m个正整数，用空格分开。每个整数不大于10000
程序输出：在所有解中，包含左上角的分割区可能包含的最小的格子数目。

例如：
用户输入：
3 3
10 1 52
20 30 1
1 2 3
则程序输出：
3

再例如：
用户输入：
4 3
1 1 1 1
1 30 80 2
1 1 1 100
则程序输出：
10
(参见p2.jpg)

资源约定：
峰值内存消耗（含虚拟机） < 64M
CPU消耗 < 5000ms

思路：

这道题挺难的，我也是借鉴他人的，才完成的。

代码如下（示例）：

package Past_Exam_4.C组;import java.util.Scanner;public class Past10_剪格子_暂未完全搞懂 {static int n, m;static int[][] arr;static int[] array;static boolean[][] flag;static boolean[][] visit;static int total = 0;static int result = 0;static int finalResult = Integer.MAX_VALUE;static int index = 0;/*** 以下是借鉴他人的！* 方法：DP + DFS* 思路与算法：*      一、输入m行n列，存入二维数组arr[n][m]即一位数组array[m*n]；*      二、总价为奇数时，输出0；总价为偶数时，到步骤三；*      三、用动态规划得到总和为count/2的最优解，每次得到最优解时进行步骤四的验证；*      四、将步骤三得到的最优解记录到一个flag[m][n]中，对标记在flag中的格子进行深度遍历。若连通说明符号条件，然后对未被*          标记在flag中的格子也进行深度遍历。若连通说明格子确实被分成了两部分而不是更多的部分，这样就成功验证了。*      五、输出步骤三中验证成功并且最终最优的那个解的格子数。* 注意：这道题难点在于剪开的必须是“两部分”，如果其中一部分是连通的，但可能把另一部分截断，如：*  4   4*  20  30  40  1*  110 1   10  1*  1   2   10  1*  1   1   10  1*  这种情况是不符合的，而且很难验证。本程序反过来先算值为total/2的两部分，然后分别计算连通，这种思路比较清晰。* @param args*/public static void main(String[] args) {Scanner scanner = new Scanner(System.in);Scanner sc = new Scanner(scanner.nextLine()).useDelimiter("\\s*");//列m = sc.nextInt();//行n = sc.nextInt();arr = new int[n][m];array = new int[n*m];flag = new boolean[n][m];for (int i = 0;i < n;i++){sc = new Scanner(scanner.nextLine());for (int j = 0;j < m;j++){arr[i][j] = sc.nextInt();array[index++] = arr[i][j];total += arr[i][j];}}if(total % 2 != 0 || array[0] > total / 2){ //奇数不可分割System.out.println(0);}else {flag[0][0] = true;result++;dp(total / 2 - array[0], 1);if(finalResult == Integer.MAX_VALUE) finalResult = 0;System.out.println(finalResult);}}//动态规划，找到和等于total / 2的情况并验证,取最优解public static void dp(int count, int start){if(count==0){   //和为total/2的情况if(confirm() && finalResult > result){finalResult=result; //验证并取最优解return;}}for (int i = start;i < index;i++){if(count >= array[i]){count -= array[i];//访问过，标记flag[i / m][i % m] = true;result++;//..i+1dp(count, i + 1);//退栈时注意还原count += array[i];flag[i / m][i % m] = false;result--;}}}//验证是否是连通图public static boolean confirm(){//..打印这种情况for (int i = 0;i < n;i++){for (int j = 0;j < m;j++){System.out.print(flag[i][j] + " ");}System.out.println();}System.out.println();int row = 0, col = 0;visit = new boolean[n][m];//找到一个属性“另一部分”的方格for (int i = 1;i < index;i++){if(flag[i / m][i % m] == false){row = i / m;col = i % m;break;}}//两部分都为连通图,则满足题意if(dfs(0, 0, 1) == result && dfs(row, col, 0) == index - result){return true;}else {return false;}}public static int dfs(int row, int col, int f){int num1 = 0;int num2 = 0;int num3 = 0;int num4 = 0;//包含左上角方块的部分if(f == 1 && flag[row][col] == true){visit[row][col] = true;if(row + 1 < n && !visit[row + 1][col]) num1 = dfs(row + 1, col, 1);if(col + 1 < m && !visit[row][col + 1]) num2 = dfs(row, col + 1, 1);return num1 + num2 + 1;}else if (f == 0 && flag[row][col] == false){    //另外一部分visit[row][col] = true;if(row + 1 < n && !visit[row + 1][col]) num1 = dfs(row + 1, col, 0);if(col + 1 < m && !visit[row][col + 1]) num2 = dfs(row, col + 1, 0);if(row - 1 >= 0 && !visit[row - 1][col]) num3 = dfs(row - 1, col, 0);if(col - 1 >= 0 && !visit[row][col - 1]) num4 = dfs(row, col - 1, 0);return num1 + num2 + num3 + num4 + 1;}else {return 0;}}
}

总结

这一届的题目总的来说，其实难度还可以，主要是最后两题和逆波兰表达式，这些如果我们没有做过或者熟练的掌握，那么将很难完成它们。
最后，让我们努力学习吧！