Skip to content

C
contest_exercises_template

禅与计算机程序设计艺术 / contest_exercises_template
该项目与 Fork 源项目分叉

Fork自 CSDN 技术社区 / contest_exercises_template

通知 3
Star 1
Fork 0
C
contest_exercises_template
提交 536de24f 编写于 作者: C chenguangjian.jk
浏览文件
操作

20230803

上级 b49ff100
隐藏空白更改
内联 并排
Showing with 387 addition and 0 deletion
exercises/chenguangjian20230803/中等/最小H值/exercies.md 0 → 100644
浏览文件 @ 536de24f
# 最小H值
给你一个二维 rows x columns 的地图 heights ，
其中 heights[row][col] 表示格子 (row, col) 的高度。
一开始你在最左上角的格子 (0, 0) ，
且你希望去最右下角的格子 (rows-1, columns-1) （注意下标从 0 开始编号）。
你每次可以往 上，下，左，右 四个方向之一移动，你想要找到H值最小的一条路径。
一条路径的 H值 是路径上相邻格子之间 高度差绝对值 的 最大值 决定的。
请你返回从左上角走到右下角的最小H值。
## 输入描述
输入：heights = [[1,2,2],[3,8,2],[5,3,5]]
## 输出描述
输出：2
解释：路径 [1,3,5,3,5] 连续格子的差值绝对值最大为 2 。
这条路径比路径 [1,2,2,2,5] 更优，因为另一条路径差值最大值为 3 。
## 输入样例
* 输入样例1
```
[[1,2,2],[3,8,2],[5,3,5]]
```
* 输入样例2
```
`[[1,2,1,1,1],[1,2,1,2,1],[1,2,1,2,1],[1,2,1,2,1],[1,1,1,2,1]]`
```
## 输出样例
* 输出样例1
`2`
* 输出样例2
`0`
## 提示
无
\ No newline at end of file
exercises/chenguangjian20230803/中等/最小H值/solution.java 0 → 100644
浏览文件 @ 536de24f
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
public class Solution {
public static void main(String[] args) {
// 控制台输入
Scanner scanner = new Scanner(System.in);
String matrixStr = scanner.nextLine();
int[][] matrix = new int[][]{};
// 解析字符串，构造二维数组
matrixStr = matrixStr.replaceAll(" ", "");
if (!"[]".equals(matrixStr)) {
String[] strArr = matrixStr.replaceAll("\\[\\[", "").replaceAll("\\]\\]", "").split("\\],\\[");
matrix = new int[strArr.length][];
for (int i = 0; i < strArr.length; i++) {
String[] innerArr = strArr[i].split(",");
matrix[i] = new int[innerArr.length];
for (int j = 0; j < innerArr.length; j++) {
matrix[i][j] = Integer.parseInt(innerArr[j].trim());
}
}
}
scanner.close();
// 调用方法
int res = minimumEffortPath(matrix);
// 输出结果
System.out.println(res);
}
public static int minimumEffortPath(int[][] heights) {
int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
int m = heights.length;
int n = heights[0].length;
int left = 0, right = 999999, ans = 0;
while (left <= right) {
int mid = (left + right) / 2;
Queue<int[]> queue = new LinkedList<int[]>();
queue.offer(new int[]{0, 0});
boolean[] seen = new boolean[m * n];
seen[0] = true;
while (!queue.isEmpty()) {
int[] cell = queue.poll();
int x = cell[0], y = cell[1];
for (int i = 0; i < 4; ++i) {
int nx = x + dirs[i][0];
int ny = y + dirs[i][1];
if (nx >= 0 && nx < m && ny >= 0 && ny < n && !seen[nx * n + ny] && Math.abs(heights[x][y] - heights[nx][ny]) <= mid) {
queue.offer(new int[]{nx, ny});
seen[nx * n + ny] = true;
}
}
}
if (seen[m * n - 1]) {
ans = mid;
right = mid - 1;
} else {
left = mid + 1;
}
}
return ans;
}
}
exercises/chenguangjian20230803/中等/最小H值/test_cases/1.in 0 → 100644
浏览文件 @ 536de24f
[[1,2,2],[3,8,2],[5,3,5]]
\ No newline at end of file
exercises/chenguangjian20230803/中等/最小H值/test_cases/10.in 0 → 100644
浏览文件 @ 536de24f
[[10,4,12],[13,8,22],[15,25,5]]
\ No newline at end of file
exercises/chenguangjian20230803/中等/最小H值/test_cases/2.in 0 → 100644
浏览文件 @ 536de24f
[[1,2,1,1,1],[1,2,1,2,1],[1,2,1,2,1],[1,2,1,2,1],[1,1,1,2,1]]
\ No newline at end of file
exercises/chenguangjian20230803/中等/最小H值/test_cases/3.in 0 → 100644
浏览文件 @ 536de24f
[[1,2,2],[3,8,2],[5,5,5]]
\ No newline at end of file
exercises/chenguangjian20230803/中等/最小H值/test_cases/4.in 0 → 100644
浏览文件 @ 536de24f
[[1,4,2],[3,8,2],[5,5,5]]
\ No newline at end of file
exercises/chenguangjian20230803/中等/最小H值/test_cases/5.in 0 → 100644
浏览文件 @ 536de24f
[[1,4,2],[13,8,2],[5,5,5]]
\ No newline at end of file
exercises/chenguangjian20230803/中等/最小H值/test_cases/6.in 0 → 100644
浏览文件 @ 536de24f
[[1,4,2],[13,8,22],[5,5,5]]
\ No newline at end of file
exercises/chenguangjian20230803/中等/最小H值/test_cases/7.in 0 → 100644
浏览文件 @ 536de24f
[[1,4,2],[13,8,22],[15,5,5]]
\ No newline at end of file
exercises/chenguangjian20230803/中等/最小H值/test_cases/8.in 0 → 100644
浏览文件 @ 536de24f
[[1,4,2],[13,8,22],[15,25,5]]
\ No newline at end of file
exercises/chenguangjian20230803/中等/最小H值/test_cases/9.in 0 → 100644
浏览文件 @ 536de24f
[[1,4,12],[13,8,22],[15,25,5]]
\ No newline at end of file
exercises/chenguangjian20230803/困难/S数/exercises.md 0 → 100644
浏览文件 @ 536de24f
# S数
如果一个正整数自身是回文数，而且它也是一个回文数的平方，那么我们称这个数为 S数。
现在，给定两个正整数 L 和 R （以字符串形式表示），返回包含在范围 [L, R] 中的S数的数目。
## 输入描述
输入：L = "4", R = "1000"
## 输出描述
输出：4
解释：
4，9，121，484, 共有4个数是S数。
## 输入样例
* 输入样例1
```
4
1000
```
* 输入样例2
```
10
10000
```
## 输出样例
* 输出样例1
```
4
```
* 输出样例2
```
2
```
## 提示
1 <= len(L) <= 18
1 <= len(R) <= 18
L 和 R 是表示 [1, 10^18) 范围的整数的字符串。
int(L) <= int(R)
\ No newline at end of file
exercises/chenguangjian20230803/困难/S数/solution.java 0 → 100644
浏览文件 @ 536de24f
import java.util.Scanner;
class Solution {
public static void main(String[] args) {
// 控制台输入
Scanner scanner = new Scanner(System.in);
String s = scanner.nextLine();
String p = scanner.nextLine();
scanner.close();
// 调用方法
int res = superpalindromesInRange(s, p);
// 输出结果
System.out.println(res);
}
public static int superpalindromesInRange(String sL, String sR) {
long L = Long.valueOf(sL);
long R = Long.valueOf(sR);
int MAGIC = 100000;
int ans = 0;
// count odd length;
for (int k = 1; k < MAGIC; ++k) {
StringBuilder sb = new StringBuilder(Integer.toString(k));
for (int i = sb.length() - 2; i >= 0; --i)
sb.append(sb.charAt(i));
long v = Long.valueOf(sb.toString());
v *= v;
if (v > R) break;
if (v >= L && isPalindrome(v)) {
ans++;
}
}
// count even length;
for (int k = 1; k < MAGIC; ++k) {
StringBuilder sb = new StringBuilder(Integer.toString(k));
for (int i = sb.length() - 1; i >= 0; --i)
sb.append(sb.charAt(i));
long v = Long.valueOf(sb.toString());
v *= v;
if (v > R) break;
if (v >= L && isPalindrome(v)) ans++;
}
return ans;
}
public static boolean isPalindrome(long x) {
return x == reverse(x);
}
public static long reverse(long x) {
long ans = 0;
while (x > 0) {
ans = 10 * ans + x % 10;
x /= 10;
}
return ans;
}
}
exercises/chenguangjian20230803/非编程题/题目.md 0 → 100644
浏览文件 @ 536de24f
# 1：关于软件架构设计，以下哪个原则可以帮助我们降低系统的耦合度？
A. 单一职责原则
B. 开放封闭原则
C. 里氏替换原则
D. 依赖倒置原则
答案：D
解释：依赖倒置原则（Dependency Inversion Principle, DIP）指的是高层模块不应该依赖于低层模块，两者都应该依赖于抽象。抽象不应该依赖于具体，具体应该依赖于抽象。这样可以降低系统的耦合度，提高模块间的可替换性和可维护性。
# 2：以下哪个设计原则鼓励我们在实现功能时，尽量对现有代码进行扩展而不是修改？
A. 单一职责原则
B. 开放封闭原则
C. 里氏替换原则
D. 接口隔离原则
答案：B
解释：开放封闭原则（Open/Closed Principle, OCP）指的是软件实体（类、模块、函数等）应该对扩展开放，对修改封闭。这意味着在实现新功能时，我们应该尽量通过添加新代码来实现，而不是修改现有代码，从而提高系统的稳定性和可维护性。
# 3：以下哪个选项不属于编码规范的内容？
A. 变量命名规则
B. 注释规范
C. 代码缩进和格式化
D. 数据库表设计
答案：D
解释：编码规范主要关注代码的编写风格，包括变量命名规则、注释规范、代码缩进和格式化等。数据库表设计属于数据库设计范畴，与编码规范不是同一概念。
# 4：关于工程效能，以下哪个选项可以帮助提高团队的开发效率？
A. 频繁地进行代码审查
B. 使用自动化测试工具
C. 使用版本控制系统
D. 所有选项都正确
答案：D
解释：所有选项都有助于提高团队的开发效率。频繁地进行代码审查可以帮助发现和修复问题，提高代码质量；使用自动化测试工具可以减少手动测试的工作量，提高测试效率；使用版本控制系统可以更好地管理代码，便于团队协作。
\ No newline at end of file
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或