pta作业

最新推荐文章于 2024-04-01 19:25:08 发布
最新推荐文章于 2024-04-01 19:25:08 发布
阅读量1.3k 收藏 5
点赞数 5
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yxy18908677969/article/details/118502646
版权

6-1 谁编程最厉害？

int  Max2(int d[],int n){
    int a[n];
    for(int k=0;k<n;k++){
        a[k]=-1;
    }
    for(int i=0;i<n;i++){
        if(d[i]%2==0){
            a[i]=d[i];
        }
    }
    int max=-1;
    for(int j=0;j<n;j++){
        if(a[j]>max){
            max=a[j];
            
        }
    }
    return max;
}
6-2 高效查重

int fun(int n){
    int b[n];
    for(int i=0;i<n;i++){
        b[i]=0;
    }
    for(int j=0;j<n;j++){
        b[getDi(j)]++;
    }
    for(int k=0;k<n;k++){
        if(b[k]>1){
            return 1;
        }
    }
    return 0;
}
6-3 高效查单I 

int Fun(int n){
    static int j=0;
    for(int i=0;i<n;i++){
        j^=getDi(i);
    }
    return j;
}
6-4 移除指定元素 

int fun (int *A,int N,int val){
    int j=0;
    for(int i=0;i<N;i++){
        if(A[i]!=val){
            A[j]=A[i];
            j++;
        }
    }
    return j;
}
6-5 字符串高效去噪

  #include "stdio.h"
int num=0;
void j2i(char *p,int i,int j);//p[i]<--p[j]  字符移动时必须调用的移动函数（移动并统计移动次数），此处不表
void stringDel(char *a);//函数接口
int main(){
    int i,k;scanf("%d",&k);srand(k);
    char A[888];gets(A);
    stringDel(A);
    puts(A);
    printf("%d",num);
    return 0;
}
/* 请在这里填写答案 */ 
 
答案：
void  stringDel (char *st ){
    int i=0;
    int j=0;
    for(i=0;st[i]!='\0';i++){
        if(st[i]>='0'&&st[i]<='9')
            continue;
        else if(i==j){
            j++;
            continue;
        }else{
            j2i(st,j,i);
            j++;
        }
    }
    if(i!=j)
    {
        st[i]='\0';
        j2i(st,j,i);
    }else{
        st[i]='\0';
    }
}
6-6 数组去最值 

int delMaxMin(int A[],int n){
    int max=0,min=0;
    int cnt=0;
    for(int i=0;i<n;i++){
        if(A[i]>=A[max])
            max=i;
        if(A[i]<=A[min])
            min=i;
    }
   // printf("%d %d",index_max,index_min);
 
    
    if(max<min){
        for(int i=max+1;i<min;i++){
            A[i-1]=A[i];
            cnt++;
        }
        for(int i=min+1;i<n;i++){
            A[i-2]=A[i];
            cnt++;
        }
    }
    if(max>min){
        for(int i=min+1;i<max;i++){
            A[i-1]=A[i];
            cnt++;
        }
        for(int i=max+1;i<n;i++){
            A[i-2]=A[i];
            cnt++;
        }
    }
    
    return cnt;
}
6-7 日期几何 

struct DateG days2Date(int x) {
    struct DateG QWQ;
    QWQ.yy = 1;
    QWQ.mm = 1;
    QWQ.dd = 1;
    while (x--) {
        QWQ.dd++;
        if ((QWQ.yy % 4 == 0 && QWQ.yy % 100 != 0) || QWQ.yy % 400 == 0) {//是闰年   
            if ((QWQ.mm == 1 || QWQ.mm == 3 || QWQ.mm == 5 || QWQ.mm == 7 || QWQ.mm == 8 || QWQ.mm == 10 || QWQ.mm == 12) && QWQ.dd > 31)
            {
                QWQ.dd = 1;
                QWQ.mm++;
                if (QWQ.mm > 12) {
                    QWQ.mm = 1;
                    QWQ.yy++;
                }
            }
            else if (QWQ.mm == 2 && QWQ.dd > 29) {//闰年二月单独讨论   
                QWQ.dd = 1;
                QWQ.mm++;
            }
            else if ((QWQ.mm == 4 || QWQ.mm == 6 || QWQ.mm == 9 || QWQ.mm == 11) && QWQ.dd > 30) {
                QWQ.dd = 1;
                QWQ.mm++;
            }
        }
        else {//非闰年   
            if ((QWQ.mm == 1 || QWQ.mm == 3 || QWQ.mm == 5 || QWQ.mm == 7 || QWQ.mm == 8 || QWQ.mm == 10 || QWQ.mm == 12) && QWQ.dd > 31)
            {
                QWQ.dd = 1;
                QWQ.mm++;
                if (QWQ.mm > 12) {
                    QWQ.mm = 1;
                    QWQ.yy++;
                }
            }
            else if (QWQ.mm == 2 && QWQ.dd > 28) {//二月单独讨论   
                QWQ.dd = 1;
                QWQ.mm++;
            }
            else if ((QWQ.mm == 2 || QWQ.mm == 4 || QWQ.mm == 6 || QWQ.mm == 9 || QWQ.mm == 11) && QWQ.dd > 30) {
                QWQ.dd = 1;
                QWQ.mm++;
            }
        }
    }
    return QWQ;
}
 
int Days(struct DateG x) {
    int res = 0, flag = 1;
    while (flag == 1) {
        res++;
        x.dd--;
        if ((x.yy % 4 == 0 && x.yy % 100 != 0) || x.yy % 400 == 0) {//闰年  
            if ((x.mm == 1 || x.mm == 3 || x.mm == 5 || x.mm == 7 || x.mm == 8 || x.mm == 10 || x.mm == 12) && x.dd == 0) {
                if (x.mm == 8 || x.mm == 1)
                    x.dd = 31;
                else if (x.mm == 3)
                    x.dd = 29;
                else
                    x.dd = 30;
                x.mm--;
                if (x.mm == 0) {
                    x.mm = 12;
                    x.yy--;
                }
            }
            else if ((x.mm == 2 || x.mm == 4 || x.mm == 6 || x.mm == 9 || x.mm == 11) && x.dd == 0) {
                x.dd = 31;
                x.mm--;
            }
        }
        else {//非闰年  
            if ((x.mm == 1 || x.mm == 3 || x.mm == 5 || x.mm == 7 || x.mm == 8 || x.mm == 10 || x.mm == 12) && x.dd == 0) {
                if (x.mm == 8 || x.mm == 1)
                    x.dd = 31;
                else if (x.mm == 3)
                    x.dd = 28;
                else
                    x.dd = 30;
                x.mm--;
                if (x.mm == 0) {
                    x.mm = 12;
                    x.yy--;
                }
            }
            else if ((x.mm == 2 || x.mm == 4 || x.mm == 6 || x.mm == 9 || x.mm == 11) && x.dd == 0) {
                x.dd = 31;
                x.mm--;
            }
        }
 
        if (x.yy == 1 && x.mm == 1 && x.dd == 1)
            flag = 0;
    }
    return res;
}
6-8 强者几何

int* fun(int *d,int N){
    int *s;
    s=(int *)malloc(sizeof(int)*N);
    int a[101]={0};
    for(int i=0;i<N;i++){
        a[d[i]]++;
    }
    int k=0;
    for(int i=0;i<N;i++){
        for(int j=100;j>d[i];j--)
            k+=a[j];
        s[i]=k;
        k=0;
    }
    return s;
}
6-9 反转的最大矩阵

unsigned int fun(char** D, int M, int N)
{
    for (int i = 0; i < M; i++)
    {
        if (D[i][0] != 1)
        {
            for (int j = 0; j < N; j++)
            {
                D[i][j] = !D[i][j];
            }
        }
    }
    for (int j = 1; j < N; j++)
    {
        int count = 0;
        for (int i = 0; i < M; i++)
        {
            if (D[i][j]) count++;
        }
        if (count < M/2)
        {
            for (int i = 0; i < M; i++)
            {
                D[i][j] = !D[i][j];
            }
        }
    }
    int num = 0;
    for (int j = 0; j < N; j++)
    {
        int P = pow(2, N - j - 1);
        for (int i = 0; i < M; i++)
        {
            num += D[i][j] * P;
        }
    }
    return num;
}
6-10 数据二进制的样子 

小明知道数据在计算机中是以二进制方式存储的，不同的数据占用的字节数还不同，实际存储是什么情况并不十分清楚。请编写一个函数，将传入的数据按二进制的形式输出（返回字符串首地址）。 知道数据的初地址和数据的总字节数就可以读出相应的数据（一批由0，1组成的序列）。因不同数据的地址类型有别，考虑到函数的通用性（不同的数据类型均可调用它进行访问），故传入的是一个无类型的地址void*和它实际占用的字节数。

        
6-11 摘桃几何

//在这里描述函数接口。例如：
int fun ( int *nums,int N ){
    int a[N];
    int A,B;
    a[0]=nums[0];
    a[1]=nums[0]>nums[1]?nums[0]:nums[1];
    for(int i=2;i<N;i++){
        A=a[i-2]+nums[i];
        B=a[i-1];
        a[i]=A>B?A:B;
    }
    return a[N-1];
}
6-12 字符串转结构体 

ST* InitData(int n){
    ST *p=(ST*)malloc(sizeof(ST)*n);
    for(int i=0;i<n;i++){
        scanf("%s %s %d %d %lf",&p[i].name,&p[i].id,&p[i].gender,&p[i].age,&p[i].scored);
    }
    return p;
}
6-13 赛程安排 (10 分)

N个人报名参加羽毛球初赛，这里的初赛只进行两两的淘汰赛（N假定为偶数，淘汰一半的选手），赛程规定采用抽签决定比赛对手与比赛顺序。抽签的结果存储在数组A[]中，A[i]表示第i个选手抽得的编号（均在[0--N-1]中)，并规定，编号0与1比，2与3比，……N-2与N-1比。显然 ，数组A[]中比赛的选手并不一定是相邻的，现要求你编写函数，通过交换两个选手位置的方式将两个比赛的选手交换到一块，计算最少的交换次数。你能否将时间复杂性控制在O(N)以内？

   int fun ( int *A,int N ) {
    int cnt=0;
    int temp;
    for(int i=0;i<N;i+=2){
        if(A[i]/2!=A[i+1]/2){
            for(int j=i+2;j<N;j++){
                if(A[j]/2==A[i]/2){
                    temp=A[j];
                    A[j]=A[i+1];
                    A[i+1]=temp;
                    cnt++;
                    break;
                }
            }
        }
    }
    return cnt;
}
6-14 数组就地循环左移（高效版） (10 分)

编写函数，对传入的指定长度的整数数组进行就地循环左移k（k>=0）位。就地的意思是不使用额外的数组转存，当然为了移动，长度为n的数组正常下标为0--n-1,我们允许使用下标为n的单元进行暂存数据。高效是指以尽量少的移动次数完成任务（除了暂存外，源数据向目标位置要求一次到位），为此，我们提供了一个数组内（下标范围：0-n）的数据移动函数j2i()供调用，必须通过调用该函数来实现数据的内部移动，以方便我们统计移动次数（包括向下标为n的单元进行暂存）。循环左移k位的意思是最前边的k个数据移动数组的最后，相对位置保持不变，具体见输出样例。

             
6-15 链表分区

struct ListNode* partition(struct ListNode* head, int x){//双指针
    if(head==NULL||head->next==NULL)
        return head;
    struct ListNode*p1=(struct ListNode*)malloc(sizeof(struct ListNode));//申请双指针；
    struct ListNode*p2=(struct ListNode*)malloc(sizeof(struct ListNode));
    
    struct ListNode*temp1=p1;
    struct ListNode*temp2=p2;
    
    while(head){
        if(head->data<x){
            temp1->next=head;
            temp1=temp1->next;
        }
        else{
            temp2->next=head;
            temp2=temp2->next;
        }
        head=head->next;
    }
    temp2->next=NULL;
    temp1->next=p2->next;
    temp1=p1->next;
    
    free(p1);
    free(p2);
    
    return temp1;
}
————————————————
版权声明：本文为CSDN博主「✘✘皮卡丘✘✘」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_54907233/article/details/118371153

yxy18908677969
关注
  • 5
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【华为OD机试真题 C++】加扰字符串
steven_my的博客
03-15 197
给定两个字符串string 1和string2。 string1是一个被加扰的字符串。string1由小写英文字母（‘a’~‘z’）和数字字符 (‘0’‘9’)组成，而加扰字符串由’0’‘9’、‘a’~'f’组成。string1里面可能包含0个或多个加扰子串，剩下可能有0个或多个有效子串，这些有效子串被加扰子串隔开。 string2是一个参考字符串，仅由小写英文字母(‘a’-‘z’)组成。 你需要在string1字符串里找到一个有效子串，这个有效子串要同时满足下面两个条件： (1） 这个有效子串里不同字母的
PTA(Basic Level) 1075：链表元素分类（C语言实现）
LIve1AnD1LeARN的博客
04-11 263
PTA(Basic Level) 1075：链表元素分类（C语言实现） 分析：这个题和反转链表那个题处理方法相似（都有游离结点）。 ①如果对所有有效结点先排好序，测试点5运行超时。 ②因此，直接三次遍历，判断结点的值，并用数组存储满足条件的结点。 #include <stdio.h> #include <stdlib.h> typedef struct node { in...
数组循环左移
12-19 1030
另外，如果需要对数组进行多次循环左移操作，我们可以先计算出数组的总长度，然后将每次操作的偏移量转换为相对于总长度的偏移量。例如，如果k的值等于数组的长度，那么循环左移后数组中的元素位置将不会发生变化。需要注意的是，这个算法中的k可以是任意正整数，也可以是负整数。此外，如果k的值非常大，那么可能会导致数组中的元素被移动到非常靠后的位置，从而影响算法的效率。数组循环左移是指将数组的元素向左移动一定的位置，使得数组的最后一个元素移动到数组的第一个位置，数组的倒数第二个元素移动到数组的第二个位置，以此类推。
第十七周-day71-Python编程基础day03
linux丶晨星
07-24 783
老男孩教育-张导博客：https://www.cnblogs.com/Neeo/articles/11204572.html 1. 字符串基本操作 # 按索引取值 s = 'abcdef' print(s[0]) print(s[-2]) print(s[0:2]) # 取范围 print(s[0:6]) print(s[0:6:1]) print(s[0:6:2]) # 取a ...
单场淘汰制场次计算方法_淘汰赛_羽毛球新闻
weixin_42593701的博客
02-05 2万+
淘汰赛什么意思淘汰赛是指体育比赛和其它各种比赛中的一种赛制，在这种赛制中赛员两两相对，输一场即淘汰出局。每一轮淘汰掉一半选手，直至产生最后的冠军。此外还有双败淘汰赛制和三败淘汰赛制，其中参赛者在失去争夺冠军的机会之前分别最多可以输掉2场和3场比赛。淘汰制赛事通常会设有种子或排名制度，以避免水平较高的参赛者过早对赛。因此，实力最强的参赛者有相当机会在决赛相遇。扩展资料体育竞赛的方法：：淘汰法：分为单...
字符串处理
weixin_60283679的博客
10-15 1804
字符串或串（String）是由数字、字母、下划线组成的一串字符。 在 Python 中，字符串用单引号或者双引号括起来。 第1关：字符串的拼接：名字的组成 Python 中使用+来合并两个字符串，这种合并字符串的方法叫做拼接。其基本语法如下： String = String_one + String_two 本关的编程任务是补全src/Step1/full_name.py文件中 Begin-End...
CJLU 2023 Python 数据结构 PTA 作业.zip
最新发布
06-14
总的来说，"CJLU 2023 Python 数据结构 PTA 作业.zip"提供了一个良好的平台，让初学者能够通过实践来掌握Python中的数据结构，增强编程技能，为今后的编程生涯做好准备。"zgl_resource"可能是资源文件夹，里面可能...
PTA作业7-函数-ANSWER.html
03-11
PTA作业7-函数-ANSWER.html
2022-2023第一学期PTA作业和实验答案(1).zip
01-22
2022-2023第一学期PTA作业和实验答案(1).zip
数据结构基础PTA作业，19道题目的C语言源代码，直接完美运行
06-19
两个链表多项式相加 单链表反转 栈能否弹出特定序列 两个二叉树是否同构 之字遍历二叉树 最小二叉堆的插入和删除 完全二叉搜索树，中序遍历转层序遍历 并查集操作 判断某个序列是否是拓扑排序 判断某个序列是否是...
单链表的分段逆转pta（超级简单简洁）
supupupupupup的博客
04-01 297
题目在最后面，先说思路，创建一个p和pre指向L的后一个结点（p是每次都先后走，便于a记录数据，而pre是每一小段的起点，集齐K个后，以pre为起点开始放数据），一个数组a用来记录当前一段的所有数据，每次先把p的数据放入a里面，然后i++；在后面判断i是否等于K，也就是是否集齐K个，及其即可逆转，若满足则将a中元素从i-1到0一个个放入pre->Data中，完成当前一段的逆转，这段代码巧妙在如果最后一段不满足K个，就不会逆转，省去了判断，超级简洁，测试点一把过。
Python 数据降噪处理的四种方法——均值滤波、小波变换、奇异值分解、改变binSize
哦豁灬
11-09 4万+
Python 数据降噪处理的四种方法——均值滤波、小波变换、奇异值分解、改变binSize github主页：https://github.com/Taot-chen 一、均值滤波 1）算法思想  给定均值滤波窗口长度，对窗口内数据求均值，作为窗口中心点的数据的值，之后窗口向后滑动1，相邻窗口之间有重叠；边界值不做处理，即两端wid_length//2长度的数据使用原始数据。 2）Python实现 ''' 均值滤波降噪： 函数ava_filter用于单次计算给定窗口长度的均值滤波 函数den
PTA练习题：数组循环左移
weixin_45735242的博客
04-29 6365
本题要求实现一个对数组进行循环左移的简单函数：一个数组a中存有n（>0）个整数，在不允许使用另外数组的前提下，将每个整数循环向左移m（≥0）个位置，即将a中的数据由（a ​0 ​​ a ​1 ​​ ⋯a ​n−1 ​​ ）变换为（a ​m ​​ ⋯a ​n−1 ​​ a ​0 ​​ a ​1 ​​ ⋯a ​m−1 ​​ ）（最前面的m个数循环移至最后面的m个位置）。如果还需要考虑程序移动数据...
习题2.2 数组循环左移（20 分）浙大版《数据结构（第2版）》题目集
weixin_30622107的博客
10-07 608
本题要求实现一个对数组进行循环左移的简单函数：一个数组a中存有n（>0）个整数，在不允许使用另外数组的前提下，将每个整数循环向左移m（≥0）个位置，即将a中的数据由（a​0​​a​1​​⋯a​n−1​​）变换为（a​m​​⋯a​n−1​​a​0​​a​1​​⋯a​m−1​​）（最前面的m个数循环移至最后面的m个位置）。如果还需要考虑程序移动数据的次数尽量少，要如何设计移动的方法？ ...
1-8 数组循环左移 (20 分)
韩旭051的博客
08-27 3530
1-8数组循环左移(20分) 本题要求实现一个对数组进行循环左移的简单函数：一个数组a中存有n（>0）个整数，在不允许使用另外数组的前提下，将每个整数循环向左移m（≥0）个位置，即将a中的数据由（a​0​​a​1​​⋯a​n−1​​）变换为（a​m​​⋯a​n−1​​a​0​​a​1​​⋯a​m−1​​）（最前面的m个数循环移至最后面的m个位置）。如果还需要考虑程序移动数据的次数尽量...
非局部均值去噪（NL-means）
热门推荐
xiaoluo91的专栏
09-06 4万+
非局部均值（NL-means）是近年来提出的一项新型的去噪技术。该方法充分利用了图像中的冗余信息，在去噪的同时能最大程度地保持图像的细节特征。基本思想是：当前像素的估计值由图像中与它具有相似邻域结构的像素加权平均得到。理论上，该算法需要在整个图像范围内判断像素间的相似度，也就是说，每处理一个像素点时，都要计算它与图像中所有像素点间的相似度。但是考虑到效率问题，实现的时候，会设定两个固定大小的窗口：...
字符串快速过滤
Hello_World_Learner的博客
12-06 477
keep = "1 2 3 4 5 6 7 8 9 0".split(); a = "adfh23aks4j5dh234fe3412uiw1\n!";# lazy filter new_a = "".join(ch for ch in a if ch in keep);
python学习-10 运算符1
weixin_30240349的博客
06-13 207
1.加+，减-，乘*，除/ 例如： a = 1 b = 2 c = a + b print(c) 运算结果： 3 Process finished with exit code 0 a = 1 b = 2 c = a - b print(c) 运算结果： -1 Process finished with exit code 0 ...
pta作业7函数
05-29
很高兴为您解答有关 PTA 作业 7 函数的问题。 PTA 作业 7 中，主要涉及到函数的定义、调用和使用。下面是一些常见的函数问题： 1. 如何定义函数？ 函数定义的一般形式为： ``` 返回值类型 函数名(参数列表) { 函数体 } ``` 其中，返回值类型可以是任意类型，函数名是用户自己定义的函数名，参数列表是函数的输入参数，可以有多个参数，也可以没有参数。函数体是函数的具体实现，包括一系列的语句和逻辑。 例如，定义一个求两个整数之和的函数： ``` int add(int a, int b) { return a + b; } ``` 2. 如何调用函数？ 函数调用的一般形式为： ``` 函数名(参数列表); ``` 其中，函数名是需要调用的函数名，参数列表是函数的输入参数，需要按照函数定义的顺序传入。 例如，调用上面定义的 add 函数： ``` int result = add(3, 4); ``` 3. 如何使用函数？ 函数的使用主要包括两个方面：函数的调用和函数的返回值的使用。 函数的调用已经在上面介绍过了，在这里重点讲解函数的返回值的使用。 如果函数有返回值，可以将函数调用的返回值赋值给一个变量，然后在程序中使用这个变量。 例如，使用上面定义的 add 函数： ``` int a = 3; int b = 4; int result = add(a, b); printf("%d + %d = %d\n", a, b, result); ``` 这样，程序就会输出：3 + 4 = 7。 希望这些信息对您有所帮助。如果您有任何其他问题，请随时问我。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值