天梯初级练习题目 6-51 ~ 6-57 含全部测试点

已于 2023-12-27 02:34:17 修改
阅读量875 收藏 22
点赞数 26
分类专栏： 天梯初级练习题目 文章标签： 算法 c语言
于 2023-12-27 01:12:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74431187/article/details/135234225
版权

6-51 逆序数据建立链表 分数 20

本题要求实现一个函数，按输入数据的逆序建立一个链表。

函数接口定义：

struct ListNode *createlist();

函数createlist利用scanf从输入中获取一系列正整数，当读到−1时表示输入结束。按输入数据的逆序建立一个链表，并返回链表头指针。链表节点结构定义如下：

struct ListNode {
    int data;
    struct ListNode *next;
};

裁判测试程序样例：

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

struct ListNode {
    int data;
    struct ListNode *next;
};

struct ListNode *createlist();

int main()
{
    struct ListNode *p, *head = NULL;

    head = createlist();
    for ( p = head; p != NULL; p = p->next )
        printf("%d ", p->data);
    printf("\n");

    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

1 2 3 4 5 6 7 -1

输出样例：

7 6 5 4 3 2 1

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

typedef struct ListNode list;
list* createlist()
{
    list* hd = malloc(sizeof(list));
    hd->next = NULL;
    int e;
    while(scanf("%d", &e), e != -1)
    {
        list* node = malloc(sizeof(list));
        node->data = e;
        node->next = hd->next;
        hd->next = node;
    }
    return hd->next;
}

6-52 链表拼接 分数 20

本题要求实现一个合并两个有序链表的简单函数。链表结点定义如下：

struct ListNode {
    int data;
    struct ListNode *next;
};

函数接口定义：

struct ListNode *mergelists(struct ListNode *list1, struct ListNode *list2);

其中list1和list2是用户传入的两个按data升序链接的链表的头指针；函数mergelists将两个链表合并成一个按data升序链接的链表，并返回结果链表的头指针。

裁判测试程序样例：

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

struct ListNode {
    int data;
    struct ListNode *next;
};

struct ListNode *createlist(); /*裁判实现，细节不表*/
struct ListNode *mergelists(struct ListNode *list1, struct ListNode *list2);
void printlist( struct ListNode *head )
{
     struct ListNode *p = head;
     while (p) {
           printf("%d ", p->data);
           p = p->next;
     }
     printf("\n");
}

int main()
{
    struct ListNode  *list1, *list2;

    list1 = createlist();
    list2 = createlist();
    list1 = mergelists(list1, list2);
    printlist(list1);
    
    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

1 3 5 7 -1
2 4 6 -1

输出样例：

1 2 3 4 5 6 7

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

typedef struct ListNode list;
list* mergelists(list* list1, list* list2)
{
    list* hd = malloc(sizeof(list)); hd->next = NULL;
    
    list* node1 = list1, *node2 = list2, *node = hd;
    while(node1 && node2)
    {
        if(node1->data < node2->data) node->next = node1, node1 = node1->next;
        else node->next = node2, node2 = node2->next;
        node = node->next;
    }
    while(node1) node->next = node1, node1 = node1->next, node = node->next;
    while(node2) node->next = node2, node2 = node2->next, node = node->next;
    node->next = NULL;
    return hd->next;
}

6-53 奇数值结点链表 分数 20

本题要求实现两个函数，分别将读入的数据存储为单链表、将链表中奇数值的结点重新组成一个新的链表。链表结点定义如下：

struct ListNode {
    int data;
    ListNode *next;
};

函数接口定义：

struct ListNode *readlist(); struct ListNode *getodd( struct ListNode **L );

函数readlist从标准输入读入一系列正整数，按照读入顺序建立单链表。当读到−1时表示输入结束，函数应返回指向单链表头结点的指针。

函数getodd将单链表L中奇数值的结点分离出来，重新组成一个新的链表。返回指向新链表头结点的指针，同时将L中存储的地址改为删除了奇数值结点后的链表的头结点地址（所以要传入L的指针）。

裁判测试程序样例：

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

struct ListNode {
    int data;
    struct ListNode *next;
};

struct ListNode *readlist();
struct ListNode *getodd( struct ListNode **L );
void printlist( struct ListNode *L )
{
     struct ListNode *p = L;
     while (p) {
           printf("%d ", p->data);
           p = p->next;
     }
     printf("\n");
}

int main()
{
    struct ListNode *L, *Odd;
    L = readlist();
    Odd = getodd(&L);
    printlist(Odd);
    printlist(L);

    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

1 2 2 3 4 5 6 7 -1

输出样例：

1 3 5 7 
2 2 4 6

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

typedef struct ListNode list;
list* readlist()
{
    int e;
    list* hd = NULL, *tail = NULL;
    while(scanf("%d", &e), e != -1)
    {
        list* node = malloc(sizeof(list));
        node->data = e;
        if(!hd) hd = tail = node;
        else
        {
            tail->next = node;
            tail = node;
        }
    }
    return hd;
}

list* getodd(list** L)
{
    list* ans = malloc(sizeof(list)); ans->next = NULL;
    list* odd = malloc(sizeof(list)); odd->next = *L;
    
    list* hd = *L, *nd = ans;
    for(list* node = hd, *pd = odd; node; )
    {
        if(node->data % 2)
        {
            nd->next = node;
            nd = nd->next;
            
            pd->next = node->next;
            node = node->next;
        }
        else
        {
            node = node->next;
            pd = pd->next;
        }
    }
    nd->next = NULL;
    *L = odd->next;
    return ans->next;
}

6-54 单链表结点删除 分数 20

本题要求实现两个函数，分别将读入的数据存储为单链表、将链表中所有存储了某给定值的结点删除。链表结点定义如下：

struct ListNode {
    int data;
    ListNode *next;
};

函数接口定义：

struct ListNode *readlist();
struct ListNode *deletem( struct ListNode *L, int m );

函数readlist从标准输入读入一系列正整数，按照读入顺序建立单链表。当读到−1时表示输入结束，函数应返回指向单链表头结点的指针。

函数deletem将单链表L中所有存储了m的结点删除。返回指向结果链表头结点的指针。

裁判测试程序样例：

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

struct ListNode {
    int data;
    struct ListNode *next;
};

struct ListNode *readlist();
struct ListNode *deletem( struct ListNode *L, int m );
void printlist( struct ListNode *L )
{
     struct ListNode *p = L;
     while (p) {
           printf("%d ", p->data);
           p = p->next;
     }
     printf("\n");
}

int main()
{
    int m;
    struct ListNode *L = readlist();
    scanf("%d", &m);
    L = deletem(L, m);
    printlist(L);

    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

10 11 10 12 10 -1
10

输出样例：

11 12

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

typedef struct ListNode list;
list* readlist()
{
    int e;
    list* hd = NULL, *tail = NULL;
    while(scanf("%d", &e), e != -1)
    {
        list* node = malloc(sizeof(list));
        node->data = e;
        if(!hd) hd = tail = node;
        else tail->next = node, tail = node;
    }
    return hd;
}

list* deletem(list* L, int n)
{
    list* hd = malloc(sizeof(list)); hd->next = L;
    for(list* p = hd, *node = L; node;)
    {
        if(node->data == n)
        {
            list* temp = node;
            p->next = node->next;
            node = node->next;
            free(temp);
        }
        else
        {
            node = node->next;
            p = p->next;
        }
    }
    return hd->next;
}

6-55 链表逆置 分数 20

本题要求实现一个函数，将给定单向链表逆置，即表头置为表尾，表尾置为表头。链表结点定义如下：

struct ListNode {
    int data;
    struct ListNode *next;
};

函数接口定义：

struct ListNode *reverse( struct ListNode *head );

其中head是用户传入的链表的头指针；函数reverse将链表head逆置，并返回结果链表的头指针。

裁判测试程序样例：

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

struct ListNode {
    int data;
    struct ListNode *next;
};

struct ListNode *createlist(); /*裁判实现，细节不表*/
struct ListNode *reverse( struct ListNode *head );
void printlist( struct ListNode *head )
{
     struct ListNode *p = head;
     while (p) {
           printf("%d ", p->data);
           p = p->next;
     }
     printf("\n");
}

int main()
{
    struct ListNode  *head;

    head = createlist();
    head = reverse(head);
    printlist(head);
    
    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

1 2 3 4 5 6 -1

输出样例：

6 5 4 3 2 1

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

typedef struct ListNode list;
list* reverse(list* hd)
{
    list* p = NULL, *node = hd;
    while(node)
    {
        list* e = node->next;
        node->next = p;
        p = node, node = e;
    }
    return p;
}

6-56 统计专业人数 分数 15

本题要求实现一个函数，统计学生学号链表中专业为计算机的学生人数。链表结点定义如下：

struct ListNode {
    char code[8];
    struct ListNode *next;
};

这里学生的学号共7位数字，其中第2、3位是专业编号。计算机专业的编号为02。

函数接口定义：

int countcs( struct ListNode *head );

其中head是用户传入的学生学号链表的头指针；函数countcs统计并返回head链表中专业为计算机的学生人数。

裁判测试程序样例：

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

struct ListNode {
    char code[8];
    struct ListNode *next;
};

struct ListNode *createlist(); /*裁判实现，细节不表*/
int countcs( struct ListNode *head );

int main()
{
    struct ListNode  *head;

    head = createlist();
    printf("%d\n", countcs(head));
    
    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

1021202
2022310
8102134
1030912
3110203
4021205
#

输出样例：

3

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

typedef struct ListNode list;
int countcs(list* head)
{
    int cnt = 0;
    for(list* node = head; node; node = node->next)
        if(node->code[1] == '0' && node->code[2] == '2') cnt ++;
    return cnt;
}

6-57 删除单链表偶数节点 分数 20

本题要求实现两个函数，分别将读入的数据存储为单链表、将链表中偶数值的结点删除。链表结点定义如下：

struct ListNode {
    int data;
    struct ListNode *next;
};

函数接口定义：

struct ListNode *createlist();
struct ListNode *deleteeven( struct ListNode *head );

函数createlist从标准输入读入一系列正整数，按照读入顺序建立单链表。当读到−1时表示输入结束，函数应返回指向单链表头结点的指针。

函数deleteeven将单链表head中偶数值的结点删除，返回结果链表的头指针。

裁判测试程序样例：

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

struct ListNode {
    int data;
    struct ListNode *next;
};

struct ListNode *createlist();
struct ListNode *deleteeven( struct ListNode *head );
void printlist( struct ListNode *head )
{
     struct ListNode *p = head;
     while (p) {
           printf("%d ", p->data);
           p = p->next;
     }
     printf("\n");
}

int main()
{
    struct ListNode *head;

    head = createlist();
    head = deleteeven(head);
    printlist(head);

    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

1 2 2 3 4 5 6 7 -1

输出样例：

1 3 5 7

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

typedef struct ListNode list;
list* createlist()
{
    int e;
    list* hd = NULL, *tail = NULL;
    while(scanf("%d", &e), e != -1)
    {
        list* node = malloc(sizeof(list));
        node->data = e;
        if(!hd) hd = tail = node;
        else tail->next = node, tail = node;
    }
    return hd;
}

list* deleteeven(list* hd)
{
    list* ans = malloc(sizeof(list)); ans->next = hd;

    for(list* p = ans, *node = hd; node;)
        if(node->data % 2 == 0)
        {
            list* temp = node;
            p->next = node->next;
            node = node->next;
            free(temp);
        }
        else node = node->next, p = p->next;
    return ans->next;
}

我辈其实蓬蒿人
关注
专栏目录
天梯初级练习题目 6-41 ~ 6-50 含全部测试点
m0_74431187的博客
12-27 974
天梯初级练习题目
天梯初级练习题目 7-1 ~ 7-10 含全部测试点
m0_74431187的博客
12-27 800
天梯初级练习题目
PTA 天梯赛练习题集 L2-003 月饼 测试点2，测试点3分析
qascetic的博客
07-04 1165
月饼是中国人在中秋佳节时吃的一种传统食品，不同地区有许多不同风味的月饼。现给定所有种类月饼的库存量、总售价、以及市场的最大需求量，请你计算可以获得的最大收益是多少。注意：销售时允许取出一部分库存。样例给出的情形是这样的：假如我们有 3 种月饼，其库存量分别为 18、15、10 万吨，总售价分别为 75、72、45 亿元。如果市场的最大需求量只有 20 万吨，那么我们最大收益策略应该是卖出全部 15 万吨第 2 种月饼、以及 5 万吨第 3 种月饼，获得 72 + 45/2 = 94.5（亿元）。输入格式：
计算机天梯赛pat练习集L1-(1~30题)
晨的博客
04-13 1652
文章目录：1、hello word2、打印沙漏3、个位数统计4、计算摄氏温度5、考试座位号6、连续因子7、念数字8、求整数段和9、N个数求和10、比较大小11、A-B12、计算指数13、计算阶乘和14、简单题15、和奥巴马一起画方块16、查验身份证17、到底有多二18、大笨钟19、谁先倒20、帅到没朋友21、重要的事情说三遍22、奇偶分家23、输出GPLT24、后天25、正整数A+B26、I LOVE GPLT27、出租28、判断素数29、是不是太胖了30、一帮一 1、hello word #include
2024团体程序设计天梯赛 L1-1~L3-1 AC代码
2301_80278604的博客
04-26 2068
2024团体程序设计天梯赛；天梯赛；天梯赛2024；第九届GPLT团体程序设计；天梯赛2024年；L1-1编程解决一切； L1-2再进去几个人； L1-3帮助色盲； L1-4四项全能； L1-5别再来这么多猫娘了！； L1-6兰州牛肉面； L1-7整数的持续性； L1-8九宫格； L2-1鱼与熊掌； L2-2懂蛇语； L2-3满树的遍历； L2-4吉利矩阵； L3-1 夺宝大赛
团体程序设计天梯赛-练习集L1-011~L1-020
张小艾博客
04-12 1849
一个整数“犯二的程度”定义为该数字中包含2的个数与其位数的比值。如果这个数是负数，则程度增加0.5倍；如果还是个偶数，则再增加1倍。例如数字“-13142223336”是个11位数，其中有3个2，并且是负数，也是偶数，则它的犯二程度计算为：3/11*1.5*2*100%，约为81.82%。本题就请你计算一个给定整数到底有多二。 输入格式： 输入第一行给出一个不超过50位的整数N。 输出格式：...
PTA团体程序设计天梯赛(L1-051~L1-060)
qq_52384627的博客
10-02 1753
L1-051 打折 (5 分) 去商场淘打折商品时，计算打折以后的价钱是件颇费脑子的事情。例如原价 ￥988，标明打 7 折，则折扣价应该是 ￥988 x 70% = ￥691.60。本题就请你写个程序替客户计算折扣价。 输入格式： 输入在一行中给出商品的原价（不超过1万元的正整数）和折扣（为[1, 9]区间内的整数），其间以空格分隔。 输出格式： 在一行中输出商品的折扣价，保留小数点后 2 位。 输入样例： 988 7 结尾无空行 输出样例： 691.60 结尾无空行 L1-052 2018我们要
【2023团体程序设计天梯赛CCCC】GPLT2023，L1~L2部分（PTA，L1-089~L1-096，L2-045~L2-048）题解代码&复盘
小哈里的博客
04-25 3116
【2023团体程序设计天梯赛CCCC】GPLT2023，L1~L2部分（PTA，L1-089~L1-096，L2-045~L2-048）题解代码&复盘概要 L1-089 最好的文档 5 L1-090 什么是机器学习 5 L1-091 程序员买包子 10 L1-092 进化论 10 L1-093 猜帽子游戏 15 L1-094 剪切粘贴 15 L1-095 分寝室 20 L1-096 谁管谁叫爹 20 L2-045 堆宝塔 25 L2-046 天梯赛的赛场安排 L2-047 锦标赛 25 L2-048 寻宝图
天梯赛练习集 L2-042 老板的作息表（25分）极短代码 含测试点分析
m0_73876538的博客
10-31 1097
新浪微博上有人发了某老板的作息时间表，表示其每天 4:30 就起床了。但立刻有眼尖的网友问：这时间表不完整啊，早上九点到下午一点干啥了？本题就请你编写程序，检查任意一张时间表，找出其中没写出来的时间段。
团体程序设计天梯赛-练习集 （L1-025 - L1-036）完整代码&题解
04-02
[团体程序设计天梯赛-练习集 （L1-013 - L1-024）](https://blog.csdn.net/weixin_45741872/article/details/137237660) [团体程序设计天梯赛-练习集 （L1-025 - L1-036）]...
天梯赛编程练习GPLT-2022-exercises-main.zip
04-21
"天梯赛编程练习GPLT-2022-exercises-main.zip" 是一个包含编程练习的压缩文件，可能源自某次编程竞赛或训练活动。这个压缩包的核心是帮助参赛者或者学习者提升他们的编程技能，特别是针对“天梯赛”这种形式的竞赛...
2024年备战天梯赛刷题练习practice-master.zip
04-21
2024年备战天梯赛刷题练习practice-master.zip
团体程序设计天梯赛-练习集 （L1-037 - L1-048）完整代码&题解
04-02
[团体程序设计天梯赛-练习集 （L1-013 - L1-024）](https://blog.csdn.net/weixin_45741872/article/details/137237660) [团体程序设计天梯赛-练习集 （L1-025 - L1-036）]...
团体程序设计天梯赛-练习集 （L1-013 - L1-024
04-02
天梯赛题解合集 [团体程序设计天梯赛-练习集 （L1-013 - L1-024）](https://blog.csdn.net/weixin_45741872/article/details/137237660) [团体程序设计天梯赛-练习集 （L1-025 - L1-036）]...
【LeetCode】【算法】136. 只出现一次的数字
passer__jw767的博客
11-12 242
LeetCode 136. 只出现一次的数字
16 合并区间
weixin_47521269的博客
11-12 751
【代码】16 合并区间。
数据库范式、MySQL 架构、算法与树的深入解析
lrh35的博客
11-11 1169
在数据库设计中，范式是一系列规则，用于确保数据的组织和存储具有良好的结构、完整性以及最小化的数据冗余。如果不遵循范式设计，数据可能会以平铺式罗列，仅使用冒号、分号等简单分隔。这种方式存在诸多弊端，例如在数据搜索时极为不便，数据修改也会变得十分棘手。由此，范式的概念应运而生。
1-Equity-Transformer：求解NP-Hard Min-Max路由问题的顺序生成算法（AAAI-24)(完)（code）
太极生两鱼
11-12 162
最小最大路由问题旨在通过智能体合作完成任务来最小化多个智能体中最长行程的长度。这些问题包括对现实世界有重大影响的应用场景，但已知属于NP-hard问题。现有方法在大规模问题上面临挑战，尤其是在需要协调大量智能体以覆盖数千个城市的情况下。本文提出了Equity-Transformer来解决大规模最小最大路由问题。首先，我们采用顺序规划方法来处理最小最大路由问题，使我们能够利用强大的序列生成器（例如，Transformer）。其次，我们提出了关键的归纳偏差，以确保智能体之间的公平工作量分配。
24/11/14 算法笔记 GMM高斯混合模型
最新发布
yyyy2711的博客
11-14 739
高斯混合模型（Gaussian Mixture Model，简称 GMM）是一种概率模型，用于表示具有多个子群体的数据集，其中每个子群体的数据分布可以用高斯分布（正态分布）来描述。GMM 是一种软聚类方法，意味着它为每个数据点分配一个属于每个聚类的概率分布，而不是硬聚类方法中的严格分类。
团体程序设计天梯赛-练习集 L1-022 奇偶分家
07-28
这段代码可以用来解决团体程序设计天梯赛-练习集 L1-022 奇偶分家的问题。 #### 引用[.reference_title] - *1* [PTA团队天梯赛║L1-022 奇偶分家](https://blog.csdn.net/m0_46492118/article/details/114481127)...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值