2024年C C++最全C语言 每日一题_3，2024年最新别再说你不会

于 2024-05-12 22:45:35 发布
阅读量955 收藏 22
点赞数 9
分类专栏： 程序员 文章标签： c语言 c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84976195/article/details/138770814
版权

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

}

题目：将一个数组逆序输出。

程序分析：用第一个与最后一个交换

//题目：将一个数组逆序输出。
//程序分析：用第一个与最后一个交换
#include <stdio.h>
void main(void)
{
    int temp;
    int a[10] = {0,1,2,3,4,5,6,7,8,9};
    for (int i = 0; i < 5; i++)
    {
        temp = a[i];
        a[i] = a[9-i];
        a[9 - i] = temp;
    }
    for (int i=0;i<10;i++)
    {
        printf(“%-2d”, a[i]);
    }
}

有2个排序过的数组A,B的长度分别为 N1, N2, 用C++代码实现只用N1+N2次循环找出2个数组中相等的值

#include <stdio.h>
int main(void)
{
    int a1[5] = {1,4,7,9,40};
    int a2[5] = {5,7,9,10,50};
    int len1 = sizeof(a1) / sizeof(a1[0]);    //strlen(a1[5])  sizeof是一个运算符
    int len2 = sizeof(a2) / sizeof(a2[0]);    //strlen(a2[5])  strlen是一个函数头文件为string
    int num = 0;                            //要计算长度的字符串起始地址，只能是char*类型，。
    int j = 0;                                //其他类型传入会被强制类型转换为（char*）
    for (int i=0;i<len1;)
    {
        if (a1[i] == a2[j])
        {
            printf(“%-2d”,a1[i]);
            i++;
            j++;
            if (j == len2)
                break;
            
        }
        else if (a1[i] < a2[j])
        {
            i++;
            if (i == len1)
                break;
        }
        else
        {
            j++;
            if (j == len2)
                break;
        }
    }
    return 0;

}

计算一个int类型数据里含有多少个bit 1，尽量使用较快的方式：

#include <stdio.h>
int main()
{
    int num;
    scanf_s(“%d”, &num);
    int count = 0;
    while (num)
    {
        if (num&1)
        {
            count++;
        }
    num = num >> 1; //末尾补0
    }
    printf(“%d”, count);
}

实现把字符串转换为整数函数，，注意：无需调用其他函数;

#include <stdio.h>
int zhuanhua(char* p)
{
    int a=0;
    char i;
    if (*p== ‘-’ || *p== ‘+’)
    {
        i = p[0];
        p++;
        
    }
    while (*p != ‘\0’)
    {
        if (*p < ‘9’ && *p>‘0’)
        {
            a = (*p - ‘0’) + a * 10;// ‘0’=48
            p++;
        }
        else 
            p++;
    }

if (i == ‘+’)
    {
        return a;
    }
    if (i == ‘-’)
    {
        return -a;
    }
    return a;
}
int main(void)
{
    char a[10];
    gets(a);
     
    printf(“%d”,zhuanhua(a));

}

数列F0=1，F1=1，F2=2，…,Fn = Fn-1 + Fn-2,(n >= 2),实现函数int F(int n),返回数列Fn点的数值；

#include <stdio.h>
int F(int n)
{
    int a = 0;
    if (n == 0 || n == 1)
    {
        return 1;
    }
    else
        return F(n - 1) + F(n - 2);
}
int main(void)
{
    printf(“%d”, F(2));

}

完成下列函数

typedef struct node {

int data;

struct node *next;

} Node;

在链表第n个位置插入一个节点，并返回链表的头指针，Node * list_add(Node *List, int n,int value);

include <stdio.h>

include <stdlib.h>

include <string.h>

#pragma warning(disable : 4996)

//节点
typedef struct xxx
{
    char data[20];
    struct xxx* next; //地址域  保存下一个节点的地址
}NODE;
void printfs(NODE* p);
void frees(NODE* p);
NODE* list_add(NODE* List, int n, char* value)//List 原链表的首地址
{
    NODE* New = malloc(sizeof(NODE));
    if (New==NULL)
    {
        printf(“表明空间申请失败\n”);
        return -1;
    }
    strcpy(New->data, value);
    NODE* Temp = List;
    if (n == 0)
    {
        New->next = List;;//将首节点的地址给到新节点的地址域
        List=New;
    }
    else
    {
        for (int i = 0; i < n - 1; i++)//节点访问的偏移  偏移到前一个前一个节点（如果要插入在 2 3节点之间 当前就要偏移到节点1）
        {
            List = List->next;// p:  待插入位置的前一个节点（如果要插入在 2 3节点之间 当前p就是节点2的地址）
        }
        New->next = List->next;
        List->next = New;
        return Temp;//返回原地址
    }

}
void printfs(NODE* p);
void frees(NODE* p);

int main(void)
{
    //动态申请节点空间
    NODE* p1 = (NODE*)malloc(sizeof(NODE));
    NODE* p2 = (NODE*)malloc(sizeof(NODE));
    NODE* p3 = (NODE*)malloc(sizeof(NODE));
    //NODE* px = (NODE*)malloc(sizeof(NODE));
    //------当前堆区中  有三个独立的节点 没有任何东西
    if (p1 == NULL || p2 == NULL || p3 == NULL )
    {
        printf(“表明空间申请失败\n”);
        return -1;
    }
    printf(“表明空间申请成功\n”);

//每个数据域进行复制
    strcpy(p1->data, “包子”);
    strcpy(p2->data, “油条”);
    strcpy(p3->data, “豆浆”);
    
    //地址域
    p1->next = p2;//节点1的地址域保存的是节点2的地址
    p2->next = p3;//节点2的地址域保存的是节点3的地址
    p3->next = NULL;
    printfs(p1);
    //frees(p1);
    list_add(p1,2, “学不懂，根本学不懂”);
    printfs(p1);
    frees(p1);
    return 0;
}
//遍历输出
void printfs(NODE* p)
{
    NODE* head = NULL;
    for (head = p; head != NULL; head = head->next)
    {
        printf(“商品的名称： %s\n”, head->data);
    }
}

//一次释放所有的节点  free()函数的参数是当前节点的地址 void frees(NODE* p) {     NODE* head = NULL;     NODE* temp = NULL;     for (head = p; head != NULL; )     {         temp = head->next;//当释放之前先保存地址域中的数据         free(head);         head = temp;     }      } 图片在内存中存放是按一维数组存放的，先存放第一行，接着第一行的行尾再存放第二行， 以此类推；横轴为X坐标，垂直方向为Y坐标，如上图右图，大图的高为H，宽为W，左上角为起始点坐标为（0, 0），右下脚坐标为（W - 1，H - 1)；现需要将小图（高为h，宽为w）内容拷贝至大图的（x，y）的起始的虚线矩形位置，假设每个像素只占一个字节；大图图像存储char* dest地址的内存里，小图图像存储在char* src地址内存里，所谓拷贝，就是内存中的像素值的赋值，如把src的起始像素拷贝到dest的起始像素，* dest = *src；void cpoyBitmap(int W，int H，int w，int  h，int x， int y，char * dest，char * src)；

#include <stdio.h>
void cpoyBitmap(int W,int H ,int w,int  h,int x,int y,char* dest,char* src )
{
    int x1 = x;
    dest += (y * W) + x; //位置偏移到（x，y）上
    for (int i = 0; i < w * h; i++) //小图像数字大小
    {
        *dest = *src;
        x++;
        dest++;
        src++;
        if (x == (x1 + w))//当到达像素w-1行上换下一行
        {
            x = x1;//复原 换下一行
            y++;  
            dest += W - w;
        }
    }
}

  1. 有一个数组，里面存放着N个正整数，随机选取相邻两个数相乘后加1，替换掉之前的两个数，数组长度变为N-1，重复上述操作，直至数组长度变为1为止，如何保证最后得的那个数最大？

e.g. {1,2,3,4,5} => {1*2+1,3,4,5} => {3*3+1,4,5} => {10,4*5+1} => {10*21+1} => {211}

int getMaxResult(int* array, int N);

#include <stdio.h>
int* Buble_Sort(int* array, int N)
{
    for (int i = 0; i < N - 1; i++)
    {
        for (int j = 0; j < N - 1 - i; j++)
        {
            if (array[j] > array[j + 1])
            {
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
    return array;
}

int getMaxResult(int* array, int N)
{
    array = Buble_Sort(array, N);

for (int i = 1; i <= N - 1; i++)
    {    
            array[0] = array[0] * array[1] + 1;
            for (int j = 1; j <= N - 2; j++)
            {
                array[j] = array[j + 1];
            }
            Buble_Sort(array, N -i);
    }
    return array[0];
}

int main(void)
{
    int array[] = { 1,2,3,4,5 };
    int data = getMaxResult(array, 5);
    printf(“data=%d\n”, data);
    return 0;
}

完成下列函数，假设有int ramdom（int max）函数返回一个在[0, max）区间的随机数可供使用，请写一个函数将一个数组array[100]里的数打乱，array[100] = {0，1, 2, 3, ……， 98,99}
注意：时间复杂度最好是O（n），O（n^2）也可以

void Srand(int *array,int max)

{

int num;

for(int i=0;i<max;i++)

{

num=ramdom(max);

int temp = array[num];

array[num] = array[max-num-1];

array[max-1-num] = temp;

}

}

实现整型数组的冒泡排序

#include <stdio.h>
MaoPao(int *buff,int length)   （冒泡法 ：i<n-1 j<n-i-1）
{
for (int i = 0; i < length - 1; i++)
{
for (int j = 0; j < length - 1 - i; j++)
{
if (buff[j] < buff[j + 1])
{
buff[j] = buff[j] ^ buff[j + 1];
buff[j + 1] = buff[j] ^ buff[j + 1];
buff[j]= buff[j] ^ buff[j + 1];
}
}
}
}
int main(void)
{
int array[10] = { 2,4,6,1,3,7,8,10,9,5 };
int len = sizeof(array) / sizeof(array[0]);
MaoPao(array, len);
for (int i = 0; i < len; i++)
{
printf("%d ", array[i]);
  }
return 0;
}

编写strcpy(strcmp)函数

#include <stdio.h>
char* mstrcpy(char* strDest, const char* strSrc)
{
    while (*strSrc != ‘\0’) //等价于while（（*strDest++ = *strSrc++）！=‘\0’);
    {
        *strDest = *strSrc;
        strDest++;
        strSrc++;
    }
    return strDest;
}
int main(void)
{
    char buff[] = “hello”;
    char buff1[10] = { 0 };
    mstrcpy(buff1, buff);
    printf(“buff1=%s\n”, buff1);
    return 0;
}

编写指针函数：从键盘输入一个字符串，去掉其中重复的字符（12分）

eg:

字符串：helloworld

去掉重复字符：helowrd

//编写函数：从键盘输入一个字符串，去掉其中重复的字符

#include <stdio.h>
void del_string(char* p)
{
    for (int i = 0; *(p + i + 1) != ‘\0’; i++)//遍历数组 当i固定查找后面每个元素是否相同
    {
        for (int j = i + 1; *(p + j) != ‘\0’; j++) //每次对比一个直到数组末尾
        {
            if (*(p + i) == *(p + j))//相同贼把所有字符提前
            {
                //元素重复，后方字符前移
                for (int k = j; *(p + k) != ‘\0’; k++)
                {
                    *(p + k) = *(p + k + 1);//把第i+1个字符去掉 把所有字符提前1位
                }
                j–;
            }

}
    }
}

int main(void)
{
    char a[] = “hellllorld”;
    del_string(a);
    printf(“%s\n”, a);
    return 0;
}

其他思路

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

-;
            }

}
    }
}

int main(void)
{
    char a[] = “hellllorld”;
    del_string(a);
    printf(“%s\n”, a);
    return 0;
}

其他思路

[外链图片转存中…(img-oTXM3iuQ-1715525112459)]
[外链图片转存中…(img-jKEEeOSD-1715525112459)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

2401_84976195
关注
  • 9
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值