目录
- 1. 2023/1/31-非降序数组(类型：数组&排序 难度：中等)
- 2. 2023/2/1- 走楼梯(类型：递归&循环 难度：中等)
- 3. 2023/2/1-蛇形矩阵(难度：困难)
- 4. 2023/2/2-奇偶排序(类型：数组&奇偶排序 难度：中等)
- 5. 2023/2/6- 查找整数(类型：数组&二分查找 难度：中等)
- 6. 2023/2/13-最长递增区间(类型：数组 难度：简单)
- 7. 2023/2/27- 一维数组的最大子数组和(类型：数组 难度：中等)
1. 2023/1/31-非降序数组(类型：数组&排序 难度：中等)
// 请关闭中文输入法，用英文的字母和标点符号。
// 如果你想运行系统测试用例，请点击【执行代码】按钮，如果你想提交作答结果，请点击【提交】按钮，
// 注意：除答案外，请不要打印其他任何多余的字符，以免影响结果验证
// 本OJ系统是基于 OxCoder 技术开发，网址：www.oxcoder.com
// 模版代码提供基本的输入输出框架，可按个人代码习惯修改
#include <stdio.h>
void solution(int n, int m, int arr1[], int arr2[], int result[]){
// TODO: 请在此编写代码
int j = 0, k = 0;
for (int i = 0; i < m + n; i++)
{
if (arr1[j] <= arr2[k])
{
result[i] = arr1[j];
j++;
}
else
{
result[i] = arr2[k];
k++;
}
if (i < m + n && j == n)
{
while (m - k)
{
result[++i] = arr2[k];
k++;
}
break;
}
if (i < m + n && k == m)
{
while (n - j)
{
result[++i] = arr1[j];
j++;
}
break;
}
}
}
int main()
{
int n;
int m;
scanf("%d", &n);
scanf("%d", &m);
int arr1[n];
for (int i = 0; i < n; i++) scanf("%d", &arr1[i]);
int arr2[m];
for (int i = 0; i < m; i++) scanf("%d", &arr2[i]);
int return_size = m + n;
int result[return_size];
solution(n, m, arr1, arr2, result);
for (int i = 0; i < return_size; i++) printf("%d ", result[i]);
return 0;
}
2. 2023/2/1- 走楼梯(类型：递归&循环 难度：中等)
// 请关闭中文输入法，用英文的字母和标点符号。
// 如果你想运行系统测试用例，请点击【执行代码】按钮，如果你想提交作答结果，请点击【提交】按钮，
// 注意：除答案外，请不要打印其他任何多余的字符，以免影响结果验证
// 本OJ系统是基于 OxCoder 技术开发，网址：www.oxcoder.com
// 模版代码提供基本的输入输出框架，可按个人代码习惯修改
#include <stdio.h>
long long solution(int m) {
// TODO: 请在此编写代码
long long arr[100];
arr[0] = arr[1] = 1;
for (int i = 2; i <= m; i++) arr[i] = arr[i - 1] + arr[i - 2];
return arr[m];
}
int main()
{
int m;
scanf("%d", &m);
long long result = solution(m);
printf("%lld", result);
return 0;
}
3. 2023/2/1-蛇形矩阵(难度：困难)
#include<stdio.h>
#include<stdlib.h>
void Print(int num, int **arr) //打印蛇形矩阵
{
if (num == 0) printf("%d", arr[0][0]);
else
{
for (int i = 0; i < num; i++)
{
for (int j = 0; j < num; j++)
printf("%d ", arr[i][j]);
printf("\n");
}
}
}
int main()
{
int i, j, m, n, num;
scanf_s("%d", &num);
int** arr = (int**)malloc(num * sizeof(int*)); //动态开辟存储单元
for (int i = 0; i < num; i++) {
arr[i] = (int*)malloc(num * sizeof(int));
}
arr[0][0] = 1;
for (i = 1; i < num; i++) //上三角
{
if (i % 2 == 1) //奇数次循环的话，斜向下累加
{
m = 0; n = i;
arr[0][i] = arr[0][i - 1] + 1; //偶数次循环,第一行的数为左边一个数加1
for (j = 0; j < i; j++) arr[++m][--n] = arr[m - 1][n + 1] + 1; //从第二行开始斜向下累加
}
else //偶数次循环的话，斜向上累加
{
m = i; n = 0;
arr[i][0] = arr[i - 1][0] + 1; //奇数次循环,第一列的数为上边一个数加1
for (j = 0; j < i; j++) arr[--m][++n] = arr[m + 1][n - 1] + 1; //从第二列开始斜向上累加
}
}
for (i = 0; i < (num - 1); i++) //下三角
{
if ((num + i) % 2 == 0) //num为偶数时，先斜向上累加
{
m = num-1, n = i + 1;
arr[num-1][i + 1] = arr[num-1][i] + 1;
for (j = num-1; j > (i+1); j--) arr[--m][++n] = arr[m + 1][n - 1] + 1;
}
else //num为奇数时，先斜向下累加
{
m = i + 1; n = num-1;
arr[i + 1][num-1] = arr[i][num-1] + 1;
for (j = num-1; j > (i+1); j--) arr[++m][--n] = arr[m - 1][n + 1] + 1;
}
}
Print(num, arr);
free(arr); //释放存储单元
return 0;
}
运行结果：
4. 2023/2/2-奇偶排序(类型：数组&奇偶排序 难度：中等)
// 请关闭中文输入法，用英文的字母和标点符号。
// 如果你想运行系统测试用例，请点击【执行代码】按钮，如果你想提交作答结果，请点击【提交】按钮，
// 注意：除答案外，请不要打印其他任何多余的字符，以免影响结果验证
// 本OJ系统是基于 OxCoder 技术开发，网址：www.oxcoder.com
// 模版代码提供基本的输入输出框架，可按个人代码习惯修改
#include <stdio.h>
#include <stdlib.h>
void solution(int m, int arr1[], int result[]) {
// TODO: 请在此编写代码
int j = 0;
for (int i = 0; i < m; i++) //奇数在前
{
if (arr1[i] % 2 == 1)
{
result[j] = arr1[i];
j++;
}
}
for (int i = 0; i < m; i++) //偶数在后
{
if (arr1[i] % 2 == 0)
{
result[j] = arr1[i];
j++;
}
}
}
int main() {
int* arr; //原数组
arr = (int*)malloc(1000 * sizeof(int));
for (int i = 0; i < 1000; i++) scanf("%d", &arr[i]);
int* result; //新数组
result = (int*)malloc(n * sizeof(int));
solution(n, arr, result);
for (int i = 0; i < n; i++) printf("%d ", result[i]);
return 0;
}
5. 2023/2/6- 查找整数(类型：数组&二分查找 难度：中等)
// 请关闭中文输入法，用英文的字母和标点符号。
// 如果你想运行系统测试用例，请点击【执行代码】按钮，如果你想提交作答结果，请点击【提交】按钮，
// 注意：除答案外，请不要打印其他任何多余的字符，以免影响结果验证
// 本OJ系统是基于 OxCoder 技术开发，网址：www.oxcoder.com
// 模版代码提供基本的输入输出框架，可按个人代码习惯修改
#include <stdio.h>
#include <stdlib.h>
int solution(int n, int m, int arr[]) {
// TODO: 请在此编写代码
int low, high, mid;
low = 0; high = n - 1;
while (low <= high)
{
mid = (low + high) / 2; //取中间位置
if (m < arr[mid]) high = mid - 1; //从前半部分继续查找
else if (m > arr[mid]) low = mid + 1; //从后半部分继续查找
else
{
for (int i = mid; i < n; i++)
{
if (mid == n - 1) return mid; //目标值在数组的最后一个位置
if ((mid < n - 1) && (m != arr[i])) return i - 1;
}
}
}
return -1; //查找失败
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
int* arr;
arr = (int*)malloc(n * sizeof(int));
for (int i = 0; i < n; i++) scanf("%d", &arr[i]);
int result = solution(n, m, arr);
printf("%d", result);
free(arr);
return 0;
}
6. 2023/2/13-最长递增区间(类型：数组 难度：简单)
// 请关闭中文输入法，用英文的字母和标点符号。
// 如果你想运行系统测试用例，请点击【执行代码】按钮，如果你想提交作答结果，请点击【提交】按钮，
// 注意：除答案外，请不要打印其他任何多余的字符，以免影响结果验证
// 本OJ系统是基于 OxCoder 技术开发，网址：www.oxcoder.com
// 模版代码提供基本的输入输出框架，可按个人代码习惯修改
#include <stdio.h>
#include <stdlib.h>
int solution(int n, int arr[]) {
int result = 0, count;
// TODO: 请在此编写代码
for (int i = 0; i < n; i++)
{
count = 0;
for (int j = i + 1; j < n; j++)
{
if (arr[j] > arr[j - 1]) count++;
else break;
}
if (count > result) result = count;
}
return result + 1;
}
int main() {
int n;
scanf("%d", &n);
int* arr;
arr = (int*)malloc(n * sizeof(int));
for (int i = 0; i < n; i++) scanf("%d", &arr[i]);
int result = solution(n, arr);
printf("%d", result);
return 0;
}
- 两题可用相同的代码，均通过测试
7. 2023/2/27- 一维数组的最大子数组和(类型：数组 难度：中等)
通过率80%
// 请关闭中文输入法，用英文的字母和标点符号。
// 如果你想运行系统测试用例，请点击【执行代码】按钮，如果你想提交作答结果，请点击【提交】按钮，
// 注意：除答案外，请不要打印其他任何多余的字符，以免影响结果验证
// 本OJ系统是基于 OxCoder 技术开发，网址：www.oxcoder.com
// 模版代码提供基本的输入输出框架，可按个人代码习惯修改
#include <stdio.h>
#include <stdlib.h>
void solution(int n, int arr[]) {
// TODO: 请在此编写代码
int max = arr[0], start = 0, end = 0;
for (int i = 0; i < n; i++)
{
int current = 0;
for (int j = i; j < n; j++)
{
current = current + arr[j];
if (current >= max)
{
max = current;
start = i;
end = j;
}
}
}
printf("%d %d", start, end);
}
int main() {
int n;
scanf("%d", &n);
int* arr;
arr = (int*)malloc(n * sizeof(int));
for (int i = 0; i < n; i++) scanf("%d", &arr[i]);
solution(n, arr);
return 0;
}
