每日一练(编程题-C/C++)

CSDN每日一练
- 1. 2023/2/27- 一维数组的最大子数组和(类型：数组难度：中等)
- 2. 2023/4/7 - 小艺照镜子(类型：字符串难度：困难)
- 3. 2023/4/14 - 最近的回文数(难度：中等)
- 4. 2023/2/1-蛇形矩阵(难度：困难)
- 6. 2023/5/26 - 单词逆序(类型：字符串、逆序难度：中等)
LeetCode题库-C语言
- 674. 最长连续递增序列（难度：简单）
- 1309. 解码字母到整数映射（难度：简单）

CSDN每日一练

1. 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;
}

示例1：
9 【-2 1 -3 4 -1 2 -5 4】起始：3 终止：6

示例2：
5 【1 -2 3 5 -1 2】起始：2 终止：5

2. 2023/4/7 - 小艺照镜子(类型：字符串难度：困难)

最长回文子串问题（四种方法）

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



#include <stdio.h>
#include <stdlib.h>
#include<string.h>

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


void solution(char s[]) {

    // TODO: 请在此编写代码
    int i, n, length1, length2, maxlen = 1, count1, count2;
    n = strlen(s); //计算字符串的长度
    if (n == 2 && s[0] == s[1]) maxlen = 2;
    for (i = 1; i < n - 1; i++) //循环不包括开头和结尾
    {
        count1 = ExpandPalindrome(s, n, i - 1, i + 1); //回文串长度是奇数的情况
        length1 = 2 * count1 - 1; 
        if (length1 >= maxlen) maxlen = length1;
        if (s[i + 1] == s[i]) //回文串长度是偶数的情况
        {
            count2 = ExpandPalindrome(s, n, i, i + 1); 
            length2 = 2 * (count2 - 1);
            if (length2 >= maxlen) maxlen = length2;
        } 
    }
    printf("%d", maxlen);
}

int main() {

    char* s = (char*)malloc(sizeof(char) * 1000); //动态开辟内存空间
    scanf_s("%s", s);

    solution(s);
    free(s);
    return 0;
}

3. 2023/4/14 - 最近的回文数(难度：中等)

#include <iostream>
#include<string>
using namespace std;

int main()
{
    int n;
    cin >> n;
    
    int flag = 0, length, count;
    int i, j, k;
    for (i = n; !flag; i++) //从当前数开始，逐个判断
    {
        length = 0, count = 0; k = 0;
        string str = to_string(i); //函数to_string用于把数字类型转换为string类型
        length = str.length(); //获取字符串的长度
        int times = length / 2; //比较次数
        while (times--)
        {
            if (str[k] == str[length - 1 - k]) //头尾对比
            {
                count++; //计数比较次数
                k++;
            }
            else break; //一旦不相等就开始下一个数的判断
        }
        if (count == length / 2) 
        {
            flag = 1; //找到最近的回文数
            cout << i; //输出
        }
    }
    
    return 0;
}

运行超时，您的程序未能在规定的时间内运行结束，请检查是否循环有错或算法复杂度过大。

4. 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;
}

运行结果：

6. 2023/5/26 - 单词逆序(类型：字符串、逆序难度：中等)


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



#include <stdio.h>
#include <stdlib.h>
#include<string.h>

void solution(char str[1000]) {

    // TODO: 请在此编写代码
    int i, j = 0, length, count = 0, array[100];
    length = strlen(str); //字符串的长度
    for (i = 0; i < length; i++)
    {
        if (str[i] == ' ')
        {
            array[j++] = i + 1;
            count++; //统计空格的数量
        }
    }

    //for (i = 0; i < count; i++) printf("%d ", array[i]);
    //printf("\n");



    int location = count - 1;
    for (i = count; i > 0; i--) //输出除第一段外其他的部分
    {
        for (j = array[location]; j < length && str[j] != ' '; j++) printf("%c", str[j])；
            location = location - 1;
        printf(" "); //输出后带上空格
    }
    for (i = 0; i < length && str[i] != ' '; i++) printf("%c", str[i]); //第一段单独输出

}

int main() {
    char str[1000];
    gets_s(str);   //可以读取空格， 回车才会结束输入

    solution(str);
    return 0;
}

整数类型	数值范围	转换函数
有符号8位整数	$2^7$ ~ $2^7-1$	int8
无符号8位整数	$0$ ~ $2^8-1$	unit8
有符号16位整数	$2^{15}$ ~ $2^{15}-1$	int16
无符号16位整数	$0$ ~ $2^{16}-1$	unit16
有符号32位整数	$2^{31}$ ~ $2^{31}-1$	int32
无符号32位整数	$0$ ~ $2^{32}-1$	unit32
有符号64位整数	$2^{63}$ ~ $2^{63}-1$	int64
无符号64位整数	$0$ ~ $2^{64}-1$	unit64

LeetCode题库-C语言

674. 最长连续递增序列（难度：简单）

在这里插入图片描述

int findLengthOfLCIS(int* nums, int numsSize){
    int result = 0, count;

    // TODO: 请在此编写代码
    for (int i = 0; i < numsSize; i++)
    {
        count = 0;
        for (int j = i + 1; j < numsSize; j++)
        {
            if (nums[j] > nums[j - 1]) count++;
            else break;
        }
        if (count > result) result = count;
    }

    return result + 1;
}

1309. 解码字母到整数映射（难度：简单）

char * freqAlphabets(char * s){
   char *arr=malloc(sizeof(char)*strlen(s));
	int i = 0, count = 0;
	while (i < strlen(s))
	{
		if (i < strlen(s) - 2 && s[i + 2] == '#')
		{
			arr[count++] = 'j' + (s[i] - '0') * 10 + (s[i + 1] - '0') -10; //'j' - 'z'
			i = i + 3; //跳到#号后一位数字开始判断
		}
		else
		{
			arr[count++] = 'a' + (s[i] - '0') - 1; //'a' - 'i'
			i = i + 1; //接着下一位数字开始判断
		}
	}
    arr[count] =  '\0'; //字符串结束符
	return arr;
}