CSDN每日一练(编程题)

1. 2023/1/31-非降序数组(类型：数组&排序 难度：中等)

// 请关闭中文输入法，用英文的字母和标点符号。
// 如果你想运行系统测试用例，请点击【执行代码】按钮，如果你想提交作答结果，请点击【提交】按钮，
// 注意：除答案外，请不要打印其他任何多余的字符，以免影响结果验证
// 本OJ系统是基于 OxCoder 技术开发，网址：www.oxcoder.com
// 模版代码提供基本的输入输出框架，可按个人代码习惯修改

#include 

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 

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/4/20 - 代写匿名信(类型：字符串 难度：中等)

// 请关闭中文输入法，用英文的字母和标点符号。
// 如果你想运行系统测试用例，请点击【执行代码】按钮，如果你想提交作答结果，请点击【提交】按钮，
// 注意：除答案外，请不要打印其他任何多余的字符，以免影响结果验证
// 本OJ系统是基于 OxCoder 技术开发，网址：www.oxcoder.com
// 模版代码提供基本的输入输出框架，可按个人代码习惯修改

#include 
#include 
#include
void solution(char words[], char msg[]) {

    // TODO: 请在此编写代码
    int i, arr[26][2] = { 0 }; //创建一个二维数组统计字母的个数
    for (i = 0; i < strlen(words); i++)
    {
        if (words[i] >= 'A' && words[i] <= 'Z') arr[words[i] - 'A'][0]++; //统计大写字母
        else if (words[i] >= 'a' && words[i] <= 'z') arr[words[i] - 'a'][1]++; //统计小写字母
    }
    for (i = 0; i < strlen(msg); i++)
    {
        if (msg[i] >= 'A' && msg[i] <= 'Z') //匹配到大写字母
        {
            if (arr[msg[i] - 'A'][0] <= 0) //但是统计时未计数
            {
                printf("No"); //说明报纸上没有该字母，输出No
                return;
            }
            else arr[msg[i] - 'A'][0]--; //二维数组里有计数过的，累计值减一
        }
        else if (msg[i] >= 'a' && msg[i] <= 'z') //匹配到小写字母
        {
            if (arr[msg[i] - 'a'][1] <= 0) //但是统计时未计数
            {
                printf("No"); //说明报纸上没有该字母，输出No
                return;
            }
            else arr[msg[i] - 'a'][1]--; //二维数组里有计数过的，累计值减一
        }
    }
    printf("Yes"); //当信里的字母都遍历完时，如果还没return，说明可以成功匹配
}

int main() {
    char words[1000];
    gets_s(words);

    char msg[1000];
    gets_s(msg);

    solution(words, msg);
    return 0;
}

• 其实小Q要做的，就是把报纸上的一个个字符“剪”出来，然后拼成一封“匿名信”。于是我们只要检查报纸上每个字符的个数，是否足够拼成要写的匿名信就可以了，比如如果要写的匿名信内容是 ddd，那报纸上至少要有3个d。
• 所以代码实现就很简单了，有很多种做法，比如先找出匿名信里每个字符的个数，然后去报纸里找，是否有这个字符、数量是否足够，还可以先把报纸里的字符及个数统计出来，然后与匿名信的相应字符比较个数，如果少于匿名信，说明字符不够，反之就可以完成。
• 不过还要稍微判断一下，空格是不需要从报纸上剪下来的，所以不用分析空格的数量。

4. 2023/2/2-奇偶排序(类型：数组&奇偶排序 难度：中等)

// 请关闭中文输入法，用英文的字母和标点符号。
// 如果你想运行系统测试用例，请点击【执行代码】按钮，如果你想提交作答结果，请点击【提交】按钮，
// 注意：除答案外，请不要打印其他任何多余的字符，以免影响结果验证
// 本OJ系统是基于 OxCoder 技术开发，网址：www.oxcoder.com
// 模版代码提供基本的输入输出框架，可按个人代码习惯修改

#include 
#include 

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 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; //新数组
    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 
#include 

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 
#include 

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/3/26 - 熊孩子拜访(类型：数组 难度：中等)

// 请关闭中文输入法，用英文的字母和标点符号。
// 如果你想运行系统测试用例，请点击【执行代码】按钮，如果你想提交作答结果，请点击【提交】按钮，
// 注意：除答案外，请不要打印其他任何多余的字符，以免影响结果验证
// 本OJ系统是基于 OxCoder 技术开发，网址：www.oxcoder.com
// 模版代码提供基本的输入输出框架，可按个人代码习惯修改

#include 
#include 

void solution(int n, int A[]) {

    // TODO: 请在此编写代码
    int i = 0;
    while ((i < n - 1) && (A[i] < A[i + 1])) i++;
    
    int j = i;
    while ((j < n - 1) && (A[j] > A[j + 1])) j++;
       
    if (i == n - 1 && j == n - 1) printf("%d %d", 0, 0);
     else printf("%d %d", A[j],A[i]);
    free(A);
}

int main() {
    int n;
    scanf("%d", &n);

    int* A;
    A = (int*)malloc(n * sizeof(int));

    for (int i = 0; i < n; i++) scanf("%d", &A[i]);

    solution(n, A);
    return 0;
}

8. 2023/4/6 - 吃!吃!吃!(类型：数学 难度：简单)

// 请关闭中文输入法，用英文的字母和标点符号。
// 如果你想运行系统测试用例，请点击【执行代码】按钮，如果你想提交作答结果，请点击【提交】按钮，
// 注意：除答案外，请不要打印其他任何多余的字符，以免影响结果验证
// 本OJ系统是基于 OxCoder 技术开发，网址：www.oxcoder.com
// 模版代码提供基本的输入输出框架，可按个人代码习惯修改



#include 
#include 
#include
#define M 3 //每3个数算一个周期

char solution(int n, int arr[]) {

    // TODO: 请在此编写代码
    int i, m = M - n % M, group = (n + M - 1) / M;
    for (i = 0; i < m; i++) arr[n + i] = 0; //不足一个周期补0

    int a[3] = { 0 }; //三个数的最大权值
    for (i = 0; i < group; i++)
    {
        a[0] += arr[i * 3];
        a[1] += arr[i * 3 + 1];
        a[2] += arr[i * 3 + 2];
    }
    if (a[0] >= a[1] && a[0] >= a[2]) return 'J';
    else if (a[1] >= a[0] && a[1] >= a[2]) return 'H';
    else return 'B';
}

int main() {
    int n;
    scanf("%d", &n);

    int* arr;
    arr = (int*)malloc((n + M) * sizeof(int)); //动态开辟内存单元时，保留需要补0的位置
    for (int i = 0; i < n; i++) scanf("%d", &arr[i]);

    printf("%c", solution(n, arr));
    free(arr);
    return 0;
}

9. 2023/4/10 - 最长回文串(类型：字符串 难度：简单)

#include
#include
#include

int ExpandPalindrome(char s[],int a[], int n, int left, int right)
{
    int length = 1;
    while (left >= 0 && right < n && s[left] == s[right])
    {
        left--;
        right++;
        length++;
    }
    return length;
}

/*int Odd(char s[], int a[])
{
    // TODO: 请在此编写代码
    int i, n, length, maxlen1 = 1;
    n = strlen(s); //计算字符串的长度
    for (i = 1; i < n - 1; i++) //循环不包括开头和结尾
    {
        length = 2*ExpandPalindrome(s,a, n, i - 1, i + 1)-1; //回文串长度是奇数的情况
        if (length > maxlen1)
        {
            a[0] = i - (length - 1) / 2;
            a[1] = i + (length - 1) / 2;
            maxlen1 = length;
        }
    }
    return maxlen1;
}

int Even(char s[], int a[])
{
    // TODO: 请在此编写代码
    int i, n, length, maxlen2 = 1;
    n = strlen(s); //计算字符串的长度
    for (i = 1; i < n - 1; i++) //循环不包括开头和结尾
    {
        length = 2*(ExpandPalindrome(s, a, n, i, i + 1)-1); //回文串长度是偶数的情况
        if (length > maxlen2)
        {
            a[2] = i - length / 2 + 1;
            a[3] = i + length / 2;
            maxlen2 = length;
        }
    }
    return maxlen2;
}*/

void solution(char s[], int a[])
{
    // TODO: 请在此编写代码
    int i, n, length, maxlen1=1,maxlen2 = 1;
    n = strlen(s); //计算字符串的长度
    for (i = 1; i < n - 1; i++) //循环不包括开头和结尾
    {
        length = 2 * ExpandPalindrome(s, a, n, i - 1, i + 1) - 1; //回文串长度是奇数的情况
        if (length > maxlen1)
        {
            a[0] = i - (length - 1) / 2;
            a[1] = i + (length - 1) / 2;
            maxlen1 = length;
        }
        length = 2 * (ExpandPalindrome(s, a, n, i, i + 1) - 1); //回文串长度是偶数的情况
        if (length > maxlen2)
        {
            a[2] = i - length / 2 + 1;
            a[3] = i + length / 2;
            maxlen2 = length;
        }
    }
    if (maxlen2 > maxlen1)
    {
        for (int i = a[2]; i <= a[3]; i++) printf("%c", s[i]);
    }
    else
    {
        for (int i = a[0]; i <= a[1]; i++) printf("%c", s[i]);
    }
}

int main() {

    int a[4] = { 0 };
    char* s = (char*)malloc(sizeof(char) * 1000); //动态开辟内存空间
    scanf("%s", s);

    solution(s, a);
    //printf("%d %d\n", len1, len2);
  
    
    
    free(s);
    return 0;
}

10. 2023/4/17 - 小艺读书(类型：数学 难度：中等)

// 请关闭中文输入法，用英文的字母和标点符号。
// 如果你想运行系统测试用例，请点击【执行代码】按钮，如果你想提交作答结果，请点击【提交】按钮，
// 注意：除答案外，请不要打印其他任何多余的字符，以免影响结果验证
// 本OJ系统是基于 OxCoder 技术开发，网址：www.oxcoder.com
// 模版代码提供基本的输入输出框架，可按个人代码习惯修改



#include 
#include 


void solution(int n, int pages[7]) {

    // TODO: 请在此编写代码

    int count = 0, day = 0, i = 0;
    while (count < n)
    {
        count = count + pages[i]; //累计页数
        if (count < n)
        {
            day++; i++;
            if (day % 7 == 0) //每周一循环
            {
                day = 0; //星期清零
                i = 0; //数组下标清零
            }
        }
        else 
        {
            day++;
            printf("%d", day); //输出最终结果
        }
    }

}
int main() {
    int n;
    scanf("%d", &n);
    int pages[7];

    for (int i = 0; i < 7; i++) scanf("%d", &pages[i]);

    solution(n, pages);
    return 0;
}

11. 2023/5/30 - 小玉家的电费(类型：数学 难度：简单)

$$sun=\{\begin{array}{l}[0,150]0.4463\\ (151,400]0.4663\\ (401,10000]0.5663\end{array}$$

// 请关闭中文输入法，用英文的字母和标点符号。
// 如果你想运行系统测试用例，请点击【执行代码】按钮，如果你想提交作答结果，请点击【提交】按钮，
// 注意：除答案外，请不要打印其他任何多余的字符，以免影响结果验证
// 本OJ系统是基于 OxCoder 技术开发，网址：www.oxcoder.com
// 模版代码提供基本的输入输出框架，可按个人代码习惯修改



#include 
#include 

void solution(int amount) {

    // TODO: 请在此编写代码
    float part1 = 150 * 0.4463;
    float part2 = (400 - 150) * 0.4663;
    float sum;
    
    if (amount <= 150) sum = amount * 0.4463;
    else if (amount > 150 && amount <= 400) sum = part1 + (amount - 150) * 0.4663;
    else sum = part1 + part2 + (amount - 400) * 0.5663;
    printf("%.1f", sum);
}

int main() {
    int amount;
    scanf("%d", &amount);

    solution(amount);
    return 0;
}

12. 2023/6/15 - 阿波罗的魔力宝石(类型：冒牌排序 难度：中等)

// 请关闭中文输入法，用英文的字母和标点符号。
// 如果你想运行系统测试用例，请点击【执行代码】按钮，如果你想提交作答结果，请点击【提交】按钮，
// 注意：除答案外，请不要打印其他任何多余的字符，以免影响结果验证
// 本OJ系统是基于 OxCoder 技术开发，网址：www.oxcoder.com
// 模版代码提供基本的输入输出框架，可按个人代码习惯修改

#include 
#include 

void solution(int n,int a []){
 
	// TODO: 请在此编写代码
int temp, i, j;
	for (i = 0; i < n - 1; i++)
	{
		for (j = n - 1; j > i; j--) //一趟冒泡过程
			if (a[j - 1] > a[j]) //若为逆序
			{
				temp = a[j - 1]; //交换
				a[j - 1] = a[j];
				a[j] = temp;
			}
  }
    for(i=0;i<n;i++) printf("%d\n",a[i]);
}

int main() {
    int n;
    scanf("%d", &n);
     
    int* a;
    a = (int*)malloc(n * sizeof(int));

    for (int i = 0; i < n; i++) scanf("%d", &a[i]);

	solution(n, a);
    return 0;
}

13. 2023/5/11-计数问题(类型：计数 难度：简单)

// 请关闭中文输入法，用英文的字母和标点符号。
// 如果你想运行系统测试用例，请点击【执行代码】按钮，如果你想提交作答结果，请点击【提交】按钮，
// 注意：除答案外，请不要打印其他任何多余的字符，以免影响结果验证
// 本OJ系统是基于 OxCoder 技术开发，网址：www.oxcoder.com
// 模版代码提供基本的输入输出框架，可按个人代码习惯修改

#include 
#include 

void solution(int arr[2]) {

    // TODO: 请在此编写代码
    int count = 0, t;
    for (int i = 1; i <= arr[0]; i++)
    {
        t = i;
        while (t != 0)
        {
            if (t % 10 == arr[1]) count++;
            t = t / 10;
        }
    }
    printf("%d", count);
}

int main() {
    int arr[2];

    for (int i = 0; i < 2; i++) scanf("%d", &arr[i]);

    solution(arr);
    return 0;
}