4月编程实例题

已于 2023-11-21 20:36:50 修改
阅读量101 收藏
点赞数
分类专栏： 编程实例 文章标签： 开发语言 c语言
于 2023-04-27 10:54:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77560238/article/details/130401634
版权

编程实例，Time:2023年4月15日

前言

两题编程实例题分为两种提醒，一个字符串处理，一个数组相关。

一、第一题

1.计数二进制子串

一个字符串数组，数据为0和1两个元素，选出里面的有效子串
有效子串条件:
1、数组发生变化
2、两边对称
 例如：
输入 110101001101
输出 9
说明：有效子串 10 01 10 01 10 0011 01 10 01  共9个

int getSum(int fast, int num, char* inputStr, int len)
{
    int sum = 0;
    for(int i = 0; i < num; i++)
    {
        if(fast + i < len)
        {
            sum += inputStr[fast + i] - '0';
        }
    }

    return sum;
}

int GetCorrectSubstrNum(char *inputStr)
{
    int len = strlen(inputStr);

    int count = 0;

    for(int i = 0; i < len; i++)
    {
        int slow = i;
        int fast = i + 1;
        while(fast < len)
        {
            if(inputStr[slow] != inputStr[fast])
            {
                int distance = (fast - slow);
                int num = (fast - slow)* (inputStr[slow] - '0');
                int sum = getSum(fast, distance, inputStr, len);
                if(fast + distance > len)
                {
                    break;
                }
                if(abs(num - sum) == distance)
                {
                    count++;
                }
                break;
            }
            fast++;
        }
    }

    printf("%d",count);
    return count;
}

int main()
{
    char str[] = "110101001101";
    GetCorrectSubstrNum(str);
    return 0;
}

AC。

最大圈复杂度6
最大单函数代码行数29
最大代码嵌套深度5

二、第二题

1.数组相对排序

存在两个数组，数组arr1长度大于数组arr2的长度，arr2的数字都被包含与arr1，要求将arr1的成员按照arr2的顺序排序,剩下的按大小排序。
输入 arr1[2,8,2,8,4,7]  ,arr2[8,2]

输出 arr1[8,8,2,2,4,7]

// 注意：返回的数组必须在给定的函数内进行内存分配，由框架代码进行内存释放。返回的数组长度存在 *returnSize 中。

int compare(const void* a, const void* b)        //这个地方要写const，不然报错，差点懵逼
{
    return *(int*)a - *(int*)b;
}

int *SpecialSort(int *arr1, int arr1Size, int *arr2, int arr2Size, int *returnSize)
{
    int* array = (int*)malloc(sizeof(int) * arr1Size);
    int index = 0;
    for(int i = 0; i < arr2Size; i++)
    {
        for(int j = 0; j < arr1Size; j++)
        {
            if(arr2[i] == arr1[j])
            {
                array[index++] = arr1[j];
                arr1[j] = -1;
            }
        }
    }

    int* arrayTemp = (int*)malloc(sizeof(int) * (arr1Size - index));
    int arrayTempIndex = 0;
    for(int i = 0; i < arr1Size; i++)
    {
        if(arr1[i] != -1)
        {
            arrayTemp[arrayTempIndex++] = arr1[i];
        }
    }

    qsort(arrayTemp, arrayTempIndex, sizeof(int), compare);

    int count = 0;
    for(int i = index; i < arr1Size; i++)
    {
        array[i] = arrayTemp[count++];
    }

    free(arrayTemp);

    *returnSize = arr1Size;

    return array;
}

AC

最大圈复杂度7
最大单函数代码行数33
最大代码嵌套深度4

三、第三题

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

 leetcode题目

打开一个浏览器，此浏览器窗口一般具备浏览历史的特性（如上图所示），请实现如下功能：

BrowserHistorySys(string homepage, int maxCount) — 初始化。homepage作为当前页，并缓存到浏览历史中；浏览历史中最多缓存maxCount个网页。

visit(string url) — 跳转访问页面url，返回访问后浏览历史中的缓存页面数量。

如果入参 url 仍是当前页，则继续浏览此页面，即：当前页不变，且浏览历史也不变；
如果入参 url 不是当前页，则跳转到此 url，并把此 url 页面作为当前页； 同时清除浏览历史中原当前页的前进记录，再将此 url 缓存到浏览历史中。示意如图：
如果新增缓存后，浏览历史缓存页面数量超过 maxCount, 则清除浏览历史中最早的记录。

back() — 在浏览历史中从当前页后退一步，返回停留页面的 url，并作为当前页。

注：如果已退无可退，则不再后退，继续停留在当前页。
forward() — 在浏览历史中从当前页前进一步，返回停留页面的 url，并作为当前页。

注：如果已进无可进，则不再前进，继续停留在当前页。

// 答题框内的代码仅为待实现代码，执行或提交代码时，仅包含待实现部分，不要包含其它代码。

typedef struct {
    char homepage[32];
    char (*history)[32];
    int maxCount;
    int index;
    int count;
} BrowserHistorySys;

static BrowserHistorySys *BrowserHistorySysCreate(const char *homepage, int maxCount)
{
    BrowserHistorySys* sys = (BrowserHistorySys*)malloc(sizeof(BrowserHistorySys));
    sys->maxCount = maxCount;
    memcpy(sys->homepage, homepage, strlen(homepage) + 1);
    sys->index = 0;
    sys->count = 0;
    
    for(int i = 0; i < maxCount; i++)
    {
        sys->history = (char(*)[32])malloc(sizeof(char) * 32 * maxCount);
    }
    
    memcpy(sys->history[0], homepage, strlen(homepage) + 1);

    sys->count++;
    
    return sys;
}

static int BrowserHistorySysVisit(BrowserHistorySys *sys, const char *url)
{
    if(sys->index + 1 < sys->maxCount && strcmp(sys->homepage, url) != 0)
    {
        memcpy(sys->homepage, url, strlen(url) + 1);
        sys->index++;
        memcpy(sys->history[sys->index], url, strlen(url) + 1);
        sys->count = sys->index + 1;
    }
    else if(sys->index + 1 == sys->maxCount)
    {
        memcpy(sys->homepage, url, strlen(url) + 1);
        //reformArray(sys);
        memcpy(sys->history[sys->index], url, strlen(url) + 1);
        sys->count = sys->maxCount;
    }
    return sys->count;
}

void reformArray(BrowserHistorySys *sys)
{
    for(int i = 0; i < sys->maxCount; i++)
    {
        memcpy(sys->history[i], sys->history[i+1], strlen(sys->history[i+1]) + 1);
    }
}

static char *BrowserHistorySysBack(BrowserHistorySys *sys)
{
    printf("index:%d",sys->index);
    if(sys->index > 0)
    {
        printf("index1:%d",sys->index);
        sys->index--;
        memcpy(sys->homepage, sys->history[sys->index], strlen(sys->history[sys->index]) + 1); 
    }

    return sys->history[sys->index];
}

static char *BrowserHistorySysForward(BrowserHistorySys *sys)
{
    if(sys->index + 1 < sys->count)
    {
        sys->index++;
        memcpy(sys->homepage, sys->history[sys->index], strlen(sys->history[sys->index]) + 1); 
    }
    return sys->history[sys->index];
}

static void BrowserHistorySysFree(BrowserHistorySys *sys)
{
    free(sys->history);
}

上面的代码有问题，下面这版AC了。赞，之前有问题主要是由于visit里面的逻辑没理清楚。

// 答题框内的代码仅为待实现代码，执行或提交代码时，仅包含待实现部分，不要包含其它代码。

typedef struct {
    char homepage[32];
    char (*history)[32];
    int maxCount;
    int index;
    int count;
} BrowserHistorySys;

static BrowserHistorySys *BrowserHistorySysCreate(const char *homepage, int maxCount)
{
    BrowserHistorySys* sys = (BrowserHistorySys*)malloc(sizeof(BrowserHistorySys));
    sys->maxCount = maxCount;
    memcpy(sys->homepage, homepage, strlen(homepage) + 1);
    sys->index = 0;
    sys->count = 0;
    
    for(int i = 0; i < maxCount; i++)
    {
        sys->history = (char(*)[32])malloc(sizeof(char) * 32 * maxCount);
    }
    
    memcpy(sys->history[0], homepage, strlen(homepage) + 1);

    sys->count++;
    
    return sys;
}

static int BrowserHistorySysVisit(BrowserHistorySys *sys, const char *url)
{
    //入参url仍是当前页，当前页不变，且浏览历史也不变
    if(strcmp(sys->homepage, url) == 0)
    {
        return sys->count;
    }
    else
    {
        if(sys->index + 1 < sys->maxCount)
        {
            memcpy(sys->homepage, url, strlen(url) + 1);
            sys->index++;
            memcpy(sys->history[sys->index], url, strlen(url) + 1);
            sys->count = sys->index + 1;
        }
        else if(sys->index + 1 == sys->maxCount)
        {
            memcpy(sys->homepage, url, strlen(url) + 1);
            reformArray(sys);
            memcpy(sys->history[sys->index], url, strlen(url) + 1);
            sys->count = sys->maxCount;
        }
    }
    
    return sys->count;
}

void reformArray(BrowserHistorySys *sys)
{
    for(int i = 0; i < sys->maxCount; i++)
    {
        memcpy(sys->history[i], sys->history[i+1], strlen(sys->history[i+1]) + 1);
    }
}

static char *BrowserHistorySysBack(BrowserHistorySys *sys)
{
    if(sys->index > 0)
    {
        sys->index--;
        memcpy(sys->homepage, sys->history[sys->index], strlen(sys->history[sys->index]) + 1); 
    }

    return sys->homepage;
}

static char *BrowserHistorySysForward(BrowserHistorySys *sys)
{
    if(sys->index + 1 < sys->count)
    {
        sys->index++;
        memcpy(sys->homepage, sys->history[sys->index], strlen(sys->history[sys->index]) + 1); 
    }
    return sys->homepage;
}

static void BrowserHistorySysFree(BrowserHistorySys *sys)
{
    free(sys->history);
}

但是有安全警告，需要重新理一下。下面是经过代码规范处理过得代码。

// 答题框内的代码仅为待实现代码，执行或提交代码时，仅包含待实现部分，不要包含其它代码。

//1、这边存在数组指针怎么申请内存的点
#define STRING_LENGTH    32

typedef struct {
    char homepage[STRING_LENGTH];
    char (*history)[STRING_LENGTH];
    int maxCount;
    int index;
    int count;
} BrowserHistorySys;

//最大圈复杂度2
static BrowserHistorySys *BrowserHistorySysCreate(const char *homepage, int maxCount)
{
    BrowserHistorySys* sys = (BrowserHistorySys*)malloc(sizeof(BrowserHistorySys));
    sys->maxCount = maxCount;
    //memcpy(sys->homepage, homepage, strlen(homepage) + 1);
    memcpy_s(sys->homepage, STRING_LENGTH, homepage, strlen(homepage) + 1);
    sys->index = 0;
    sys->count = 0;
    
    for(int i = 0; i < maxCount; i++)
    {
        sys->history = (char(*)[32])malloc(sizeof(char) * 32 * maxCount);
    }
    
    //memcpy(sys->history[0], homepage, strlen(homepage) + 1);
    memcpy_s(sys->history[0], STRING_LENGTH, homepage, strlen(homepage) + 1);

    sys->count++;
    
    return sys;
}

//最大圈复杂度5，最大嵌套深度4
static int BrowserHistorySysVisit(BrowserHistorySys *sys, const char *url)
{
    //入参url仍是当前页，当前页不变，且浏览历史也不变
    //if(strcmp(sys->homepage, url) == 0)
    if(strcmp(sys->homepage, url) == 0)        //这边的安全函数不确定
    {
        return sys->count;
    }
    else
    {
        if(sys->index + 1 < sys->maxCount)
        {
            //memcpy(sys->homepage, url, strlen(url) + 1);
            memcpy_s(sys->homepage, STRING_LENGTH, url, strlen(url) + 1);
            sys->index++;
            memcpy_s(sys->history[sys->index], STRING_LENGTH, url, strlen(url) + 1);
            //memcpy(sys->history[sys->index], url, strlen(url) + 1);
            sys->count = sys->index + 1;
        }
        else if(sys->index + 1 == sys->maxCount)
        {
            memcpy_s(sys->homepage, STRING_LENGTH, url, strlen(url) + 1);
            //memcpy(sys->homepage, url, strlen(url) + 1);
            reformArray(sys);
            memcpy_s(sys->history[sys->index], STRING_LENGTH, url, strlen(url) + 1);
            //memcpy(sys->history[sys->index], url, strlen(url) + 1);
            sys->count = sys->maxCount;
        }
    }
    
    return sys->count;
}

void reformArray(BrowserHistorySys *sys)
{
    for(int i = 0; i < sys->maxCount; i++)
    {
        memcpy_s(sys->history[i], STRING_LENGTH, sys->history[i+1], strlen(sys->history[i+1]) + 1);
        //memcpy(sys->history[i], sys->history[i+1], strlen(sys->history[i+1]) + 1);
    }
}

static char *BrowserHistorySysBack(BrowserHistorySys *sys)
{
    if(sys->index > 0)
    {
        sys->index--;
        memcpy_s(sys->homepage, STRING_LENGTH, sys->history[sys->index], strlen(sys->history[sys->index]) + 1); 
        //memcpy(sys->homepage, sys->history[sys->index], strlen(sys->history[sys->index]) + 1); 
    }

    return sys->homepage;
}

static char *BrowserHistorySysForward(BrowserHistorySys *sys)
{
    if(sys->index + 1 < sys->count)
    {
        sys->index++;
        memcpy_s(sys->homepage, STRING_LENGTH, sys->history[sys->index], strlen(sys->history[sys->index]) + 1); 
        //memcpy(sys->homepage, sys->history[sys->index], strlen(sys->history[sys->index]) + 1); 
    }
    return sys->homepage;
}

static void BrowserHistorySysFree(BrowserHistorySys *sys)
{
    free(sys->history);
}

//补充，这里也可可以用strcpy函数，对应的安全函数是strncpy。

3.1代码规范 

合格备注
代码行数77无限制
单函数代码最大行数2550
最大代码长度104120
最大代码圈复杂度51-10
最大代码嵌套深度34那这个最大嵌套深度应该是花括号嵌套深度了
函数的参数最大个数25

安全函数:源码libboundscheck: 华为C语言安全函数库:https://gitee.com/openeuler/libboundscheck - Gitee.com

原函数安全函数函数原型（错误）函数原型（正确）
memcpymemcpy_smemcpy(const void* dest, int destLen, const void* src, srcLen)memcpy_s(void* dest, size_t destMax, const void* src, size_t count)
strcpystrcpy_sstrcpy(const void* dest, int destLen, const void* src, srcLen)strcpy_s(char* strDest, size_t destMax, const char* strSrc);
strcmp无strcpy(const void* dest, const void* src)
strncpystrncpy_sstrncpy_s(char* strDest, size_t destMax, const char* strSrc, size_t count);

3.2strcpy和strncpy区别？

strcpy()
strcpy()用来复制字符串

其原型为char* strcpy(char * destn, const char * src );

dest 为目标字符串指针，src 为源字符串指针。
strcpy() 把src所指的由NULL结束的字符串复制到dest 所指的数组中，返回指向 dest 字符串的起始地址。
源字符串必须以 ‘\0’ 结束。
目标空间必须足够大，以确保能存放源字符串。
仅用于复制字符串，不仅会复制字符串的内容，还会将源字符串中的 ‘\0’ 拷贝到目标空间。
 

strncpy
strncpy()用来复制字符串的前n个字符

其原型为char * strncpy ( char * dest, const char * src, size_t num );

dest 为目标字符串指针，src 为源字符串指针，num为拷贝的字读数。
strncpy()会将字符串src前n个字符拷贝到字符串dest。
如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。
一旦遇到0以后，后面被拷贝的字节就全部是 0
仅用于复制字符串，并且是指定的前n个字符，但不会追加结束符’\0’
 

memcpy
memcpy()提供了一般内存的复制，对于需要复制的内容没有限制

其原型为void * memcpy ( void * dest, const void * src, size_t num );

dest 为目标指针，src 为源指针。num为字节数。
memcpy()会将src前n个字节拷贝到dest中。

可以复制任意内容，不仅限于字符串，同时也需要指定复制长度。
 

总结
strcpy只能复制字符串，并且是整个字符串
strncpt只能复制字符串，但可以指定个数
memcpy可以复制任意类型的数据，并且可以指定个数
strcpy遇到被复制字符的串结束符"\0"才结束，所以容易溢出。
strncpy，memcpy则是根据其第3个参数决定复制的长度。
strncpy一旦遇到0以后，后面被拷贝的字节就全部是 0。
memcpy 是不关注被拷贝的内容是什么的。
复制字符串时用strcpy，strncpy，而需要复制其他类型数据时则一般用memcpy。

3.3 这里的代码还有一个需要注意的就是数组指针的内存申请

我这边的方法是

sys->history = (char(*)[32])malloc(sizeof(char) * 32 * maxCount);

这边两个点，一个是类型强制转换方式，另一个其实是申请了一个一维数组。

那么可不可以直接按照数组指针来申请呢，百度一下。

增加其他的bject题目

四、第四题

/*
题目描述
现有一批杂乱的字符串，请逐个判断每个字符串是否是合法的工号，把非法的直接丢弃，并将合法的整理成规定的格式。

合法工号：去除所有空格后，长度不超过9；首位为字母、其它均为数字（至少有一个数字）。

格式化要求：

工号首字母统一规整成小写字符。
去除所有空格。
如果工号不满9位，在数字前面补零，使工号长度恰好为9。
请对格式化后的合法工号，去重后，按照字典序升序输出。

解答要求
时间限制：1000ms, 内存限制：256MB
输入
一个整数 N ，表示待整理工号的个数，取值范围：[1, 100)
接下来 N 行，每行字符串是一个待整理的工号（长度不超过20）

输出
按照升序排序的规整后的合法工号。
*/

/*
 * Description: 
 * Note: 缺省代码仅供参考，可自行决定使用、修改或删除
 */
#include "securec.h"
#include "stdbool.h"
#include "ctype.h"

#define MAXN 100
#define BUF_LEN 32

bool isValidString(char *strs)
{
    int len = strlen(strs);
    int wordCount = 0;
    int stringLen = 0;
    for(int i = 0; i < len; i++)
    {
        if(strs[i] == ' ' )
        {
            continue;
        }
        
        if(isalpha(strs[i]))
        {
            wordCount++;
        }
        stringLen++;
    }
    
    if(wordCount == 1 && stringLen <= 9 && stringLen > 1)
    {
        return true;
    }
    
    return false;
}

char* getcorrectString(char *strs)
{
    int len = strlen(strs);
    char *str = (char*)malloc(sizeof(char) * 32);
    memset(str, '0', sizeof(char) * 32);
    int count = 9;
    for(int i = len - 1; i >= 0; i--)
    {
        if(isalpha(strs[i]))
        {
            str[0] = strs[i];
        }
        if(strs[i] >= '0' && strs[i] <= '9')
        {
            str[--count] = strs[i];
        }
    }
    str[9] = '\0';
    str[9] = '\n';
    //str[10] = '\n';
    
    return str;
}

int comp(const void* a, const void* b)
{
    //printf("%s\n", (unsigned int*)(*(int*)a));
    int diff = 0;
    //diff = strcmp( (char*) ((unsigned int*)(*(int*)a)), (char*)( (unsigned int*)(*(int*)b)) );
    return diff;
}

/* 按题目要求输出到 outBuf/outBufLen 中，换行使用 '\n' */
void RecularId(char **strs, int strCnt, char *outBuf, int outBufLen)
{
    char outBufTest[MAXN * BUF_LEN];
    char (*p)[32] = (char(*)[32])outBufTest;
    int index = 0;
    
    //qsort(strs, strCnt, sizeof(char), comp);        //这边不能这么传参，二级指针不是数组
    for(int i = 0; i < strCnt; i++)
    {
        for(int j = 0; j < strlen(strs[i]); j++)
        {
            strs[i][j] = tolower(strs[i][j]);
        }
    }
    for(int i = 0; i < strCnt; i++)
    {
        for(int j = i + 1; j < strCnt; j++)
        {
            if(strcmp(strs[i], strs[j]) > 0)
            {
                char temp[BUF_LEN];
                strcpy_s(temp, BUF_LEN, strs[i]);
                strcpy_s(strs[i], BUF_LEN, strs[j]);
                strcpy_s(strs[j], BUF_LEN, temp);
            }
            else if(strcmp(strs[i], strs[j]) == 0)
            {
                printf("equal");
                memset(strs[i], '0', sizeof(char) * BUF_LEN);
            }
        }
    }
    
    for(int i = 0; i < strCnt; i++)
    {
        printf("test:%s\n", strs[i]);
    }
    
    // 在此添加你的代码
    for(int i = 0; i < strCnt; i++)
    {
        if(!isValidString(strs[i]))
        {
            continue;
        }
        
        char *newStr = getcorrectString(strs[i]);
        //strcpy_s(*(p+i), 32, newStr);
        memcpy_s(&outBuf[index * 10], 10, newStr, 10);        //这边不能用strcpy和strncpy
        index++;
        free(newStr);
    }
}

/* 代码仅供参考，注意避免圈复杂度过大 */
int main(void)
{
    int n;
    if (scanf_s("%d\n", &n) != 1) { return -1; }

    static char buf[MAXN][BUF_LEN];
    static char *input[MAXN];
    int i;
    for (i = 0; i < n; i++) {
        if (NULL == gets_s(buf[i], sizeof(buf[i])))  { return -1; }
        input[i] = buf[i];
    }

    static char outBuf[MAXN * BUF_LEN];
    RecularId(input, n, outBuf, sizeof(outBuf));
    (void)printf("%s", outBuf);
    return 0;
}

6

s00123

k23490

s 234

x2 3 5

m 9 9 0

d 8 9 0  

上述的代码对于这个用例通过不了，还需要修改

2023年11月21日20:23:16

经过多次修改终于aced


#include "securec.h"
#include "stdbool.h"
#include "ctype.h"

#define MAXN 100
#define BUF_LEN 32

char** getValidStr(char **strs, int strCnt )
{
    for(int i = 0; i < strCnt; i++)
    {
        int wordCount = 0;
        if(strs[i][0] < 'a' || strs[i][0] > 'z')
        {
            memset_s(strs[i], strlen(strs[i]), '\0', strs[i]);
        }
        for(int j = 0; j < strlen(strs[i]); j++)
        {
            if(strs[i][j] >= 'a' && strs[i][j] <= 'z')
            {
                wordCount++;
            }
        }
        if(wordCount > 1)
        {
            memset_s(strs[i], strlen(strs[i]), '0', strs[i]);
        }
        if(strlen(strs[i]) > 9)
        {
            memset_s(strs[i], strlen(strs[i]), '0', strs[i]);
        }
    }
    
    
    return strs;
}

char* getcorrectString(char *strs)
{
    int len = strlen(strs);
    char *str = (char*)malloc(sizeof(char) * 32);
    memset(str, '0', sizeof(char) * 32);
    int count = 9;
    for(int i = len - 1; i >= 0; i--)
    {
        if(isalpha(strs[i]))
        {
            str[i] = strs[i];
        }
        if(strs[i] >= '0' && strs[i] <= '9')
        {
            str[--count] = strs[i];
        }
    }
    str[9] = '\0';
    return str;
}

void reformString(char **strs, int strCnt)
{       
    for(int i = 0; i < strCnt; i++)
    {
        int index = 0;
        char temp[32] = {'\0'};
        for(int j = 0; j < strlen(strs[i]); j++)
        {
            if(strs[i][j] == ' ')
            {
                continue;
            }
            
            if( !isalpha(strs[i][j]) && !isdigit(strs[i][j]) )
            {
                memset_s(strs[i], BUF_LEN, '0', BUF_LEN);
                continue;
            }
            
            if(isalpha(strs[i][j]))
            {
                strs[i][j] = tolower(strs[i][j]);
            }
            temp[index++] = strs[i][j];     
        }
        temp[index] = '\0';
        strcpy_s(strs[i], BUF_LEN, temp);
    }
}

/* 按题目要求输出到 outBuf/outBufLen 中，换行使用 '\n' */
void RecularId(char **strs, int strCnt, char *outBuf, int outBufLen)
{
    char outBufTest[MAXN * BUF_LEN];
    char (*p)[32] = (char(*)[32])outBufTest;
    
    reformString(strs, strCnt);
    
    char** validStr = getValidStr(strs, strCnt);
    
    char *newStr[100];
    for(int i = 0; i < strCnt; i++)
    {
        newStr[i] = getcorrectString(validStr[i]);
    }
    
    
    for(int i = 0; i < strCnt; i++)
    {
        for(int j = i + 1; j < strCnt; j++)
        {
            if(strcmp(newStr[i], newStr[j]) == 0)
            {
                memset(newStr[j], '0', sizeof(char) * BUF_LEN);
            }
        }
    }
    
    for(int i = 0; i < strCnt; i++)
    {
        for(int j = i + 1; j < strCnt; j++)
        {
            if(strcmp(newStr[i], newStr[j]) > 0)
            {
                char temp[BUF_LEN];
                strcpy_s(temp, BUF_LEN, newStr[i]);
                strcpy_s(newStr[i], BUF_LEN, newStr[j]);
                strcpy_s(newStr[j], BUF_LEN, temp);
            }
        }
    }
    
    int index = 0;
    for(int i = 0; i < strCnt; i++)
    {
        if(newStr[i][0] >= 'a' && newStr[i][0] <= 'z')
        {
            newStr[i][9] = '\n';            //这边不需要'\0'了，有'\n'就可以了
            memcpy_s(outBuf + index * 10, outBufLen, newStr[i], 10);
            index++;
        }
    }
}

/* 代码仅供参考，注意避免圈复杂度过大 */
int main(void)
{
    int n;
    if (scanf_s("%d\n", &n) != 1) { return -1; }

    static char buf[MAXN][BUF_LEN];
    static char *input[MAXN];
    int i;
    for (i = 0; i < n; i++) {
        if (NULL == gets_s(buf[i], sizeof(buf[i])))  { return -1; }
        input[i] = buf[i];
    }

    static char outBuf[MAXN * BUF_LEN];
    RecularId(input, n, outBuf, sizeof(outBuf));
    (void)printf("%s", outBuf);
    return 0;
}

存在扣分项，

最大圈复杂度扣5
安全函数扣8

 更改了2个memset，将一段代码封装进函数，成功解决代码规范扣分，代码规范代码如下

#include "securec.h"
#include "stdbool.h"
#include "ctype.h"

#define MAXN 100
#define BUF_LEN 32

char** getValidStr(char **strs, int strCnt )
{
    for(int i = 0; i < strCnt; i++)
    {
        int wordCount = 0;
        if(strs[i][0] < 'a' || strs[i][0] > 'z')
        {
            memset_s(strs[i], strlen(strs[i]), '\0', strs[i]);
        }
        for(int j = 0; j < strlen(strs[i]); j++)
        {
            if(strs[i][j] >= 'a' && strs[i][j] <= 'z')
            {
                wordCount++;
            }
        }
        if(wordCount > 1)
        {
            memset_s(strs[i], strlen(strs[i]), '0', strs[i]);
        }
        if(strlen(strs[i]) > 9)
        {
            memset_s(strs[i], strlen(strs[i]), '0', strs[i]);
        }
    }
    
    
    return strs;
}

char* getcorrectString(char *strs)
{
    int len = strlen(strs);
    char *str = (char*)malloc(sizeof(char) * BUF_LEN);
    memset_s(str, BUF_LEN, '0', sizeof(char) * BUF_LEN);
    int count = 9;
    for(int i = len - 1; i >= 0; i--)
    {
        if(isalpha(strs[i]))
        {
            str[i] = strs[i];
        }
        if(strs[i] >= '0' && strs[i] <= '9')
        {
            str[--count] = strs[i];
        }
    }
    str[9] = '\0';
    return str;
}

void reformString(char **strs, int strCnt)
{       
    for(int i = 0; i < strCnt; i++)
    {
        int index = 0;
        char temp[BUF_LEN] = {'\0'};
        for(int j = 0; j < strlen(strs[i]); j++)
        {
            if(strs[i][j] == ' ')
            {
                continue;
            }
            
            if( !isalpha(strs[i][j]) && !isdigit(strs[i][j]) )
            {
                memset_s(strs[i], BUF_LEN, '0', BUF_LEN);
                continue;
            }
            
            if(isalpha(strs[i][j]))
            {
                strs[i][j] = tolower(strs[i][j]);
            }
            temp[index++] = strs[i][j];     
        }
        temp[index] = '\0';
        strcpy_s(strs[i], BUF_LEN, temp);
    }
}

char **sortStrFunc(char **newStr, int strCnt)
{
    for(int i = 0; i < strCnt; i++)
    {
        for(int j = i + 1; j < strCnt; j++)
        {
            if(strcmp(newStr[i], newStr[j]) == 0)
            {
                memset_s(newStr[j], BUF_LEN, '0', sizeof(char) * BUF_LEN);
            }
        }
    }
    
    for(int i = 0; i < strCnt; i++)
    {
        for(int j = i + 1; j < strCnt; j++)
        {
            if(strcmp(newStr[i], newStr[j]) > 0)
            {
                char temp[BUF_LEN];
                strcpy_s(temp, BUF_LEN, newStr[i]);
                strcpy_s(newStr[i], BUF_LEN, newStr[j]);
                strcpy_s(newStr[j], BUF_LEN, temp);
            }
        }
    }
    
    return newStr;
}

/* 按题目要求输出到 outBuf/outBufLen 中，换行使用 '\n' */
void RecularId(char **strs, int strCnt, char *outBuf, int outBufLen)
{   
    reformString(strs, strCnt);
    
    char** validStr = getValidStr(strs, strCnt);
    
    char *newStr[MAXN];
    for(int i = 0; i < strCnt; i++)
    {
        newStr[i] = getcorrectString(validStr[i]);
    }
    
    char** sortStr = sortStrFunc(newStr, strCnt);

    int index = 0;
    for(int i = 0; i < strCnt; i++)
    {
        if(sortStr[i][0] >= 'a' && sortStr[i][0] <= 'z')
        {
            sortStr[i][9] = '\n';            //这边不需要'\0'了，有'\n'就可以了
            memcpy_s(outBuf + index * 10, outBufLen, sortStr[i], 10);
            index++;
        }
    }
}

/* 代码仅供参考，注意避免圈复杂度过大 */
int main(void)
{
    int n;
    if (scanf_s("%d\n", &n) != 1) { return -1; }

    static char buf[MAXN][BUF_LEN];
    static char *input[MAXN];
    int i;
    for (i = 0; i < n; i++) {
        if (NULL == gets_s(buf[i], sizeof(buf[i])))  { return -1; }
        input[i] = buf[i];
    }

    static char outBuf[MAXN * BUF_LEN];
    RecularId(input, n, outBuf, sizeof(outBuf));
    (void)printf("%s", outBuf);
    return 0;
}

五、矩阵倒置

//矩阵转置
//题目描述
//一个正方矩阵是长宽等长，由单个十进制数字字符构成的矩阵。 比如，这是一个 3 x 3 的正方矩阵：
//该正方矩阵有两种表达：
//
//行优先表达：即先从左到右，再从上到下罗列所有元素；上述正方矩阵描述为235743819
//列优先表达：即先从上到下，再从左到右罗列所有元素；上述正方矩阵描述为278341539
//给定正方矩阵的行优先表达，请输出对应的列优先表达；如果输入不能表达为一个正方矩阵，即长度不满足整数平方数时，对应输出字符串 ERROR。


#include "securec.h"
#define BUF_LEN 10005

// 待实现函数，在此函数中填入答题代码
void Transpose(const char* input, char* outBuf, int outBufLen)
{
    int len = strlen(input);
    int value = sqrt(len);
    if(pow(value, 2) != len)
    {
        strcpy_s(outBuf, outBufLen, "ERROR");
        return;
    }

    //way 1
    int count = 0;
    char array[value][value];
    for(int i = 0; i < value; i++)
    {
        for(int j = 0; j < value; j++)
        {
            array[i][j] = input[count++];
        }
    }

    count = 0;
    for(int i = 0; i < value; i++)
    {
        for(int j = 0; j < value; j++)
        {
            outBuf[count++] = array[j][i];
        }
    }

    //way 2
    count = 0;
    char (*p)[value] = (char(*)[value])input;
    for(int j = 0; j < value; j++)
    {
        for(int i = 0; i < value; i++)
        {
             outBuf[count++] = *((*(p + i)) + j);
        }
    }
}

// 代码仅供参考，注意避免圈复杂度过大
int main(void)
{
    static char buf[BUF_LEN];
    if (gets_s(buf, sizeof(buf)) == NULL) { return -1; }
    static char outBuf[BUF_LEN];
    Transpose(buf, outBuf, sizeof(outBuf));
    (void)printf("%s", outBuf);

    return 0;
}

//这个题目需要注意的点有：
//sqrt开平方根
//pow平方

总结


注意细节。

晴山ぺ
关注
专栏目录
2024年03月CCF-GESP编程能力等级认证C++编程四级真题解析
人生就是一个不断学习的过程
03-27 1267
若函数声明为 int f(int &x){ x+=3; return x; } ，则对声明的变量 int a=3 ，下面哪个调用能够改变 a 的值( )。 A. f(&a) ; B. f(*a) ; C. f(a) ; D. f(a-3) ;
(完整版)C语言编程实例100题.doc
11-15
本资源摘要信息涵盖了C语言编程实例100题的学习指南，包括四个程序实例的详细分析和源代码解释。 程序1：有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？ 该程序的目的是计算有1、2、3、4个数字...
浏览器（C++题解）
IamOPandQP的博客
08-16 233
今天又做了一道题哈，直接上代码，边看边解释。
【Leetcode刷题篇】- Leetocde1472 设计游览器历史记录
Mind_programmonkey的博客
06-25 242
你有一个只支持单个标签页的 浏览器 ，最开始你浏览的网页是 homepage ，你可以访问其他的网站 url ，也可以在浏览历史中后退 steps 步或前进 steps 步。 请你实现 BrowserHistory 类： BrowserHistory(string homepage) ，用 homepage 初始化浏览器类。 void visit(string url) 从当前页跳转访问 url 对应的页面 。执行此操作会把浏览历史前进的记录全部删除。 string back(int steps) 在浏览
Python日期计算，编程练习题实例四
尘埃落定
07-24 841
Python练习题问题如下： 简述：要求输入某年某月某日 提问：求判断输入日期是当年中的第几天？ Python解题思路分析： 我们就以3月5日这一天为例。首先把前两个月的加起来，然后再加上5天即本年的第几天。这里有一种特殊的情况，就是闰月，遇到这种情况且输入月份大于2时需考虑多加一天。如果不是很明白，可以看下边的python源码。 Python日期计算，最新编程练习题实例四，解题源代...
c语言编程经典100题app,C语言经典编程实例100题+答案
weixin_31924507的博客
05-18 882
《C语言经典编程实例100题+答案》由会员分享，可在线阅读，更多相关《C语言经典编程实例100题+答案(59页珍藏版)》请在人人文库网上搜索。1、C语言程序实例100个(一)【程序1】题目：有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？1.程序分析：可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去掉不满足条件的排列。2.程序源代码：main()in...
c语言编程入门实例程序100,C语言编程实例程序100题.doc
weixin_30898967的博客
05-18 990
【程序1】题目：有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？1.程序分析：可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去掉不满足条件的排列。2.程序源代码：main(){int i,j,k;printf("\n");for(i=1;i<5;i++)　　　　／*以下为三重循环*/for(j=1;j<5;j++)for (k=1;k&l...
C语言经典100道编程练习题
热门推荐
Sophia_hust的博客
10-30 3万+
1.生成不重复的三位数，有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？ 2.企业发放的奖金根据利润提成。利润(I)低于或等于10万元时，奖金可提10%； 利润高于10万元，低于20万元时，低于10万元的部分按10%提成，高于10万元的部分，可提成7.5%； 20万到40万之间时，高于20万元的部分，可提成5%； 40万到60万之间时高于40万元的部分，可提成3%； 60万到100万之间时，高于60万元的部分，可提成1.5%； 高于100万元时，超过100万元的部分按1%提成。
Rust语言编程实例100题-004
我是小学生的博客
06-14 286
<h1 id="rust语言编程实例100题-004">Rust语言编程实例100题-004</h1> <p><strong>题目：</strong>输入某年某月某日，判断这一天是这一年的第几天？</
Rust语言编程实例100题-011
我是小学生的博客
06-24 132
<h1 id="rust语言编程实例100题-011">Rust语言编程实例100题-011</h1> <p><strong>题目</strong>：古典问题（兔子生崽）：有一对兔子，从出生后第3个月
C语言考试编程题模板,c语言编程题
weixin_32374445的博客
05-23 545
c语言编程题Tag内容描述：1、C 语言编程题精选 1.有函数 F(x)=(x+1) 2和 G(x)=2x+1，输入 X 值计算 F(G(x)的值。 2.任意输入三个字符，要求首先按逆序输出，然后同行原序输出。 3.在屏幕上输出如下图案(考虑能否将输出的行数由输入的值来控制) ： * * * * 4.在屏幕上输出如下图案(考虑将输出的行数由输入的值来控制) ： * * * * * 5.编程输出如下...
C语言编程实例100题.pdf
07-02
【C语言编程实例100题.pdf】是一个包含100道C语言编程题目的文档，旨在帮助学习者提升C语言编程技能，并适用于C语言笔试准备。这些题目涵盖了从基础到中等难度的问题，每道题都提供了参考答案，便于理解和实践。 第...
C语言经典编程实例100题+答案
12-25
在《C语言经典编程实例100题+答案》中，通过一系列具体的编程题目，我们能够学习到C语言的基本语法结构、编程逻辑以及算法实现。以下是对书中部分程序实例的详细知识点解析： 程序1解析： 该程序的目的是找出所有...
C语言编程实例100题.doc
07-19
### C语言编程实例知识点概述 #### 知识点一：组合数学与循环结构的应用（程序1） **背景介绍**： 程序1的任务是从1、2、3、4这四个数字中生成所有可能的不同三位数，并计算这些数的总数。这个问题本质上是在考察...
C语言编程实例100题经典版.doc
07-19
### C语言编程实例知识点概述 #### 知识点一：组合数学与循环结构的应用 **题目背景**：通过使用三个不同的数字（1、2、3、4）来组成所有可能的三位数，并确保这些数字在每个数位上不重复。 **程序分析**： 1. **...
网站建设中常见的网站后台开发语言有哪几种，各自优缺点都是什么？
2301_80154636的博客
09-24 2357
总的来说，每种语言都有其特定的优势和局限，选择哪种语言取决于项目需求、团队技能和预期的维护成本等多种因素。理解这些语言的核心特性和适用场景可以帮助开发者做出更明智的选择，从而有效提升项目的成功率和开发效率。这些语言各有其独特的优缺点，适用于不同的开发场景和需求。市场上常见的网站后台开发语言有。
C语言 | Leetcode C语言题解之第454题四数相加II
m0_59237910的博客
10-04 574
C语言 | Leetcode C语言题解之第454题四数相加II
多台三相逆变器并联（本模型为三台并联，市面上多为两台并联）matlab simulink仿真 功能：实现并联系统中各逆变器输出
最新发布
10-09
多台三相逆变器并联（本模型为三台并联，市面上多为两台并联）matlab simulink仿真。 功能：实现并联系统中各逆变器输出功率均分。 （有能力的话还可以研究下垂特性、功率指令以及静态功工作点三者之间的联系） 控制策略：VSG控制策略（同步机控制） 逆变器主电路：三相逆变器，LCL滤波电路，VSG控制模块。 VSG控制模块：定、转子方程，dq变，电压电流双闭环，预同步，pwm发生器。
TIJ4 Java编程思想第四版课后习题完整源码
这个Annotated Solution Guide（注解解决方案指南）提供了详尽的编程实例和答案，所有代码可以直接编译使用。它强调了版权保护，明确指出此资源并非免费软件，禁止在网站上发布、复制或分发，也不允许公开展示或作为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值