当前位置：首页 > news >正文

蓝桥杯高校新生编程赛第一场题解——Java

news 2025/10/24 11:24:02

01. 小猫取名【新生编程赛】

完整解题代码：

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改public class Main {public static void main(String[] args) {Scanner scan = new Scanner(System.in);//在此输入您的代码...StringBuilder sb=new StringBuilder();for(int i=0;i<6;i++){String str1=scan.next();sb.append(str1.charAt(0));}String b=sb.toString();System.out.println(b);//System.out.println(sb);scan.close();}
}

解题思路：

1.明确目标：

本题需要将 6 个单词的首字母按顺序拼接输出。核心思路是依次读取每个单词，提取其首字符，再将这些字符拼接输出。

2.读取并提取首字符：

想要实现这个功能，我们率先想到String类的charAt(int index)方法，该方法用于获取字符串中指定索引的字符（本题中使其索引为0，便可获得首字符）。

3.拼接输出字符：

想要快捷拼接字符，即想使用一种修改字符串的手段，我们可以想到使用StringBuilder类，其中的public StringBuffer append(String s)，可以实现将指定的字符串追加到此字符序列。

4.返回输出字符串：

使用toString() 方法返回此对象本身（它已经是一个字符串）。最后输出完整字符串，即可解答。

（如果后续需要多次使用拼接好的字符串，可先通过 toString() 生成 String 并保存，便于操作。

此题可直接输出原字符串）

涉及知识点：

1.`String`类的`charAt(int index)`方法

Java charAt() 方法

charAt() 方法用于返回指定索引处的字符。索引范围为从 0 到 length() - 1。

语法

public char charAt(int index)

参数

index -- 字符的索引。

返回值

返回指定索引处的字符。

实例

public class Test {public static void main(String args[]) {String s = "www.runoob.com";char result = s.charAt(6);System.out.println(result);}
}

以上代码输出结果为：n

2.Java StringBuffer 和 StringBuilder 类

当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。

和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

在使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，所以如果需要对字符串进行修改推荐使用 StringBuffer。

StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。

由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。

实例：

public class RunoobTest{public static void main(String[] args){StringBuilder sb = new StringBuilder(10);sb.append("Runoob..");System.out.println(sb);  sb.append("!");System.out.println(sb); sb.insert(8, "Java");System.out.println(sb); sb.delete(5,8);System.out.println(sb);  }
}

以上实例编译运行结果如下：

Runoob..

Runoob..!

Runoob..Java!

RunooJava!

图示原理：

然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

实例：

public class Test{public static void main(String[] args){StringBuffer sBuffer = new StringBuffer("菜鸟教程官网：");sBuffer.append("www");sBuffer.append(".runoob");sBuffer.append(".com");System.out.println(sBuffer);  }
}

以上实例编译运行结果：菜鸟教程官网：www.runoob.com

以下是 StringBuffer 类支持的主要方法：

序号	方法描述
1	public StringBuffer append(String s) 将指定的字符串追加到此字符序列。
2	public StringBuffer reverse() 将此字符序列用其反转形式取代。
3	public delete(int start, int end) 移除此序列的子字符串中的字符。
4	public insert(int offset, int i) 将 `int` 参数的字符串表示形式插入此序列中。
5	insert(int offset, String str) 将 `str` 参数的字符串插入此序列中。
6	replace(int start, int end, String str) 使用给定 `String` 中的字符替换此序列的子字符串中的字符。

3.Java toString() 方法

toString() 方法返回此对象本身（它已经是一个字符串）。

语法

public String toString()

参数

无

返回值

字符串本身。

实例

public class Test {public static void main(String args[]) {String Str = new String("WWW.RUNOOB.COM");System.out.print("返回值 :" );System.out.println( Str.toString() );}
}

以上程序执行结果为：返回值 :WWW.RUNOOB.COM

02. 修改编码文件【新生编程赛】

完整解题代码：

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改public class Main {public static void main(String[] args) {Scanner scan = new Scanner(System.in);//在此输入您的代码...String str=scan.next();System.out.println(str.replaceAll("[0-9]","Q").replaceAll("[a-z]","L"));scan.close();}
}

解题思路：

1.明确目标：

本题需要将输入字符串中的小写字母替换为 L，数字替换为 Q。核心思路是利用正则表达式批量匹配目标字符集，通过字符串替换方法完成转换，最终输出结果。

2.正则替换：

调用 replaceAll("[0-9]", "Q")，将所有数字（0~9）替换为 Q；
调用 replaceAll("[a-z]", "L")，将所有小写字母（a~z）替换为 L。

（由于数字和字母是互斥的字符集，替换顺序不影响最终结果）

3.输出结果：

直接打印经过两次替换后的字符串。

涉及知识点：

1.Java replaceAll() 方法

replaceAll() 方法使用给定的参数 replacement 替换字符串所有匹配给定的正则表达式的子字符串。

语法

public String replaceAll(String regex, String replacement)

参数

regex -- 匹配此字符串的正则表达式。

replacement -- 用来替换每个匹配项的字符串。

返回值

成功则返回替换的字符串，失败则返回原始字符串。

实例

public class Test {public static void main(String args[]) {String Str = new String("www.google.com");System.out.print("匹配成功返回值 :" );System.out.println(Str.replaceAll("(.*)google(.*)", "runoob" ));System.out.print("匹配失败返回值 :" );System.out.println(Str.replaceAll("(.*)taobao(.*)", "runoob" ));}
}

以上程序执行结果为：
匹配成功返回值 :runoob
匹配失败返回值 :www.google.com

正则表达式解析：

1. 组件解析

.：匹配任意单个字符（除了换行符）。
*：表示前面的元素可以出现 0 次或多次。因此，.* 组合起来的意思是 “匹配任意长度的任意字符（包括空字符串）”。
()：正则中的 “分组”，用于捕获匹配的内容（也可用于逻辑组合）。

2. 整体含义

(.*)google(.*) 的意思是：

先匹配任意长度的任意字符（(.*)），
然后匹配字符串 “google”，
最后再匹配任意长度的任意字符（(.*)）。

简言之，这个正则是用来匹配包含 “google” 子串的任意字符串，并将 “google” 前后的所有内容都包含在匹配范围内。

03.设计师调度【新生编程赛】

完整解题代码：

import java.util.Arrays;
import java.util.Scanner;
import java.util.Collections;
// 1:无需package
// 2: 类名必须Main, 不可修改public class three{public static void main(String[] args) {Scanner scan = new Scanner(System.in);//在此输入您的代码...int a1=scan.nextInt();int a2=scan.nextInt();int a3=scan.nextInt();scan.close();Integer[] arr={a1,a2,a3};int min=(int)Collections.min(Arrays.asList(arr));int max=(int)Collections.max(Arrays.asList(arr));int mid=a1+a2+a3-max-min;if (mid + min <= max) {System.out.println(max);} else {System.out.println(mid + min);}}
}

解题思路：

1.明确目标：

题目要使三位设计师完成所有任务的总时间最短，需利用并行调度的思想。

2.贪心策略：

设定让两个任务尽可能并行执行，减少等待时间。具体策略是：将三个任务的时间排序为 x ≤ y ≤ z，最小总时间为 max(z, x + y)。

3.排序处理与极值提取：

明确目标后，我们将输入的三个数存入数组，利用 Collections.min 和 Collections.max 分别获取最小值 min和最大值 max，中间值 mid 通过 “总和 - 最小值 - 最大值” 计算得到。

4.结果计算：

比较 max 和 min + mid 的大小，取较大值作为最小总时间。

若 min + mid ≤ max：总时间由最长的任务 max 决定（两个较小任务并行完成后，最长任务仍在执行，总时间为 max）。
若 min + mid > max：总时间由两个较小任务的并行时间 min + mid 决定（两个较小任务并行完成时，最长任务也已完成）。

涉及知识点：

1.集合与数组操作：

将 int 数组转换为 Integer 数组（因 Collections 工具类方法针对对象类型），利用 Arrays.asList 转换为列表，再通过 Collections.min 和 Collections.max 提取极值。

（便于寻找有限个数字中的极值）

注意导入库

import java.util.Arrays;
import java.util.Collections;

实例：

Using Collections.max() . This requires converting the array to a list first.

import java.util.Arrays;import java.util.Collections;public class MaxValueCollections {public static void main(String[] args) {Integer[] arr = {3, 7, 2, 1, -4}; // Use Integer instead of intint max = Collections.max(Arrays.asList(arr));System.out.println("Maximum value: " + max);}}

2.贪心算法：

一、贪心算法的核心逻辑

贪心算法的本质是每一步都做 “当前最有利” 的选择，通过 “局部最优” 的累积，最终得到 “全局最优” 的结果。

二、本题中贪心策略的体现

在 “设计师调度” 问题中，我们的目标是最小化三个任务的总完成时间。由于平台一次只能容纳两名设计师并行工作，因此需要让两个耗时较短的任务优先并行，这就是本题的 “局部最优选择”。

具体推导如下：假设三个任务的时间为 a, b, c，我们先将其排序为 x ≤ y ≤ z（x 是最小值，z 是最大值，y 是中间值）。

让 x 和 y 这两个较小的任务并行执行（充分利用平台的并行能力，减少等待时间）。
此时总时间的判定分为两种情况：
- 若 x + y ≤ z：两个小任务并行完成后，最大的任务 z 仍在执行，因此总时间由 z 决定。
- 若 x + y > z：两个小任务并行的时间里，最大的任务 z 也已完成，因此总时间由 x + y 决定。

三、贪心性质的验证

本题满足贪心算法的两大关键性质：

贪心选择性质：全局最优解（最小总时间）可以通过 “让两个最小任务并行” 这一局部最优选择来构造。
最优子结构性质：总时间的最优解依赖于 “两个较小任务并行” 和 “最大任务耗时” 这两个子问题的最优解（即比较 x+y 和 z 的大小）。

04.妈妈的菜单【新生编程赛】

完整解题代码：

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改public class Main {public static void main(String[] args) {Scanner scan = new Scanner(System.in);//在此输入您的代码...int sum=0;int result=0;for (int i=1;i<=10;i++){int a=scan.nextInt();sum+=a; if(Math.abs(sum-100)<=Math.abs(result-100)){result=sum;}}System.out.println(result);scan.close();}
}

解题思路：

1.明确目标：

本题需要按顺序累加菜品的饱腹值，在每一步都判断当前累加和与100的接近程度，最终找到最接近 100（差距相同时选更大值）的累加和。核心思路是按顺序遍历所有可能的 “前 k 道菜累加和”，动态更新最接近 100 的结果。

2.差距比较与结果更新：

利用Math.abs计算当前sum与 100 的差距，不断赋给result，计算上一步已有结果result与 100 的差距。
若当前sum与 100 的差距更小，或差距相同但sum更大，则更新result为当前sum。

3.遍历结束与输出：

循环结束后，通过本次sum与上一步累加的result进行对比，让result永远为最大且最接近100的累加，最后输出result作为饱腹值。

涉及知识点：

1.绝对值计算：

Math.abs方法用于计算数值的绝对值

2.贪心算法：

在 “妈妈的菜单” 问题中，我们需要在按顺序累加菜品饱腹值的过程中，动态维护 “最接近 100（差距相同时选更大值）” 的累加和。其贪心策略可拆解为以下两点：

1. 局部最优选择：每一步都更新 “当前最接近 100 的累加和”

遍历每一道菜时，我们会计算 “前 i 道菜的总饱腹值”，并与已记录的 “最接近 100 的结果” 比较：

若当前累加和与 100 的差距更小，则更新结果为当前累加和；
若差距相同但当前累加和更大，也更新结果（因为题目要求 “吃撑一点比饿着好”）。

这一步的 “局部最优” 是：在当前遍历到的所有 “前 i 道菜的和” 中，选择最接近 100 的那个。

2. 全局最优的推导：局部最优的累积

由于题目规则是 “一旦不吃某道菜，后续菜都不上”，因此所有可能的候选解只能是 “前 1 道菜的和、前 2 道菜的和…… 前 10 道菜的和”。

我们通过逐一遍历这些候选解，并在每一步都做 “局部最优选择（更新最接近 100 的结果）”，最终这些局部最优的选择会累积成全局最优解—— 即所有候选解中最接近 100（或差距相同时更大）的那个。

3.贪心性质的验证

本题满足贪心算法的两大关键性质：

贪心选择性质：全局最优解一定是 “前 k 道菜的和”（k∈[1,10]），而我们通过每一步的局部最优选择（更新最接近 100 的结果），可以覆盖并找到这个全局最优解。
最优子结构性质：“前 k 道菜的最优解” 依赖于 “前 k-1 道菜的最优解”—— 每一步的选择都基于之前所有步骤的最优结果，从而推导当前步骤的最优选择。

05.挑选题目【新生编程赛】

完整解题代码：

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改public class Main {public static void main(String[] args) {Scanner scan = new Scanner(System.in);//在此输入您的代码...int N = scan.nextInt();int[] A = new int[N];int[] B = new int[N];for (int i = 0; i < N; i++) {A[i] = scan.nextInt();}for (int j = 0; j < N; j++) {B[j] = scan.nextInt();}scan.close();int maxDiff = 0;for (int i = 0; i < A.length; i++) {  int a = A[i]; int minDiffA = Integer.MAX_VALUE;  for (int j = 0; j < B.length; j++) {  int b = B[j];  int diff = Math.abs(a - b);  if (diff < minDiffA) { minDiffA = diff;}}if (minDiffA > maxDiff) {maxDiff = minDiffA;}}System.out.println(maxDiff);}
}

解题思路：

1.明确目标：

小蓝希望最终题目难度差尽可能大，小桥希望尽可能小，且两人均采取最优策略。核心思路是：

小蓝遍历自己的每一道题，对每道题，小桥会选择与它差值最小的题（小桥的最优策略）；
小蓝在这些 “小桥的最小差值” 中，选择最大的那个（小蓝的最优策略），即为最终结果。

（误区：一开始简单认为读取数组后，只需分别找到各自题目难度中的极值，相减即得最终解果）

我一开始理解偏差，是因为忽视了这道题的核心是双方 “轮流删除自己的题目” 的博弈过程，不是 “直接留自己的最大 / 最小”，需要结合双方的策略动态分析：

正确的策略逻辑

我们可以从 “小蓝的视角” 推导：

小蓝遍历自己的每一道题（假设最终留下这道题）；
对于这道题，小桥会选择自己手中与它差值最小的题目（因为小桥要最小化差值，这是小桥的最优策略）；
小蓝在所有 “小桥的最小差值” 中，选择最大的那个（因为小蓝要最大化差值，这是小蓝的最优策略）。

2.循环遍历，动态博弈：

101 变量初始化：int maxDiff = 0

作用：保存最终结果 —— 小蓝在双方最优策略下能得到的最大差值。
初始值设为 0，因为差值不可能为负数（用Math.abs计算，结果≥0）。

202 外层循环：遍历小蓝的每一道题（for (int i = 0; i < A.length; i++)）

逻辑：假设小蓝最终决定留下数组 A 中的第i道题（即a = A[i]），然后计算在这种情况下，小桥会如何应对。
举例：如果 A 是[1, 10]，外层循环会先处理a=1，再处理a=10。

303 内层循环：为当前a找小桥的最优解（for (int j = 0; j < B.length; j++)）

逻辑：对小蓝留下的a，小桥会从自己的数组 B 中选一道题b，使得a和b的差值最小（因为小桥的目标是 “让最终差值尽可能小”）。
关键变量minDiffA：记录 “小桥针对当前a能选出的最小差值”。
- 初始化为Integer.MAX_VALUE（整数最大值），是为了确保第一次比较时，任何实际差值（≥0）都会比它小，从而能正确更新minDiffA。
举例：当a=10，B 是[2, 20]时：
- 先算b=2的差值：|10-2|=8，此时minDiffA更新为 8；
- 再算b=20的差值：|10-20|=10，比 8 大，minDiffA保持 8；
- 因此，小桥对a=10的最优解是 8。

404 小蓝的最终选择：更新maxDiff

逻辑：小蓝的目标是 “让最终差值尽可能大”，所以需要在所有 “小桥的最小差值”（即每个a对应的minDiffA）中，选最大的那个。
举例：小蓝的a=1时，小桥的最小差值是 1（b=2）；小蓝的a=10时，小桥的最小差值是 8（b=2）；因此maxDiff会从 0 更新为 8，最终输出 8。

3.核心逻辑：

使用嵌套循环模拟了双方的动态博弈：