小白代码学习题1

1.根据随便给一个年份和月份和日期怎么知道它是星期几，还能算出这是这一年的第几天

#include<stdio.h>

struct date {

    int year, month, day;

};// 定义一个结构体，用于存储日期信息

int isyear(int year) {

    int key = 0;

    if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {

        key = 1;

    }

    return key;

}// 判断一个年份是否是闰年 

int getDayOfWeek(int year, int month, int day) {

    if (month < 3) {

        month += 12;

        year--;

    }

    int k = year % 100;

    int j = year / 100;

    int dayOfWeek = (day + 13 * (month + 1) / 5 + k + k / 4 + j / 4 + 5 * j) % 7;

    // 0代表星期六，1代表星期日，2代表星期一，依此类推

    return (dayOfWeek + 5) % 7;

}// 根据给定的年、月、日计算这一天是星期几，基于儒略日历算法 

int main() {

    int t,ac;

    struct date x;

    int uncommonday=0;

    int nmonth[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };

    char xinqi[9][10] = { {"0"}, {"Monday"}, {"Tuesday"} ,{"Wednesday"}, {"Thursday"}, {"Friday"}, {"Saturday"}, {"Sunday"}, {"0"}};

    scanf("%d", &t);

    for (int i = 0; i < t; i++) {

        scanf("%d-%d-%d", &x.year, &x.month, &x.day);

        if (isyear(x.year) == 1) {

             nmonth[2] = 29;

        }

        else{

             nmonth[2] = 28;

        }

        for (int k = 1; k < x.month; k++) {

             uncommonday = uncommonday + nmonth[k];

        }

        uncommonday = uncommonday + x.day;

        ac = getDayOfWeek(x.year, x.month, x.day);

        printf("%d %s\n", uncommonday, xinqi[ac+1]);

        uncommonday = 0;

    }

    return 0;

}

2. 代码现实了从一句话中删除一个给定的单词，并改成自己想要的单词

#include <stdio.h> 

#include <string.h>

void replaceAll(char* str, char* target, const char* replacement) {

    int targetLen = strlen(target);// 获取要替换的单词的长度。

    int replacementLen = strlen(replacement);// 获取替换后的单词的长度

    char* pos = str;

    //定义一个指针pos，初始指向目标字符串的开始位置。

   

    if (targetLen >= strlen(str)) return;

//如果目标单词的长度大于或等于整个字符串的长度，则直接返回，不进行任何操作。

    while ((pos = strstr(pos, target)) != NULL) {//使用strstr函数在字符串中查找目标单词的位置，直到没有找到为止。

        memmove(pos + replacementLen, pos + targetLen, strlen(pos + targetLen) + 1);// 使用memmove函数将目标单词后面的内容移动到正确的位置，以覆盖目标单词。

        memcpy(pos, replacement, replacementLen);// 使用memcpy函数将替换后的单词复制到目标位置。

        pos += replacementLen;// 更新指针的位置，以便在下一次循环中处理下一个目标单词

    }//定义一个名为replaceAll的函数，该函数接受三个参数：目标字符串str、要替换的单词target和替换后的单词

}

int main() {

    char str[2000];// 用于存储输入的文本

    char target[53];  //用于存储要替换的单词

    const char* replacement = "doctorZ";//定义一个常量字符指针replacement，指向替换后的单词。

    int t;

    scanf("%d", &t);

    getchar();   

    while (t--) {

        fgets(target, 51, stdin);  //从标准输入读取最多50个字符（考虑到末尾的空字符）并存储在target中。

        target[strcspn(target, "\n")] = 0;  //找到换行符的位置，并将其替换为字符串结束符（null字符）。

        fgets(str, 1000, stdin);// 从标准输入读取最多999个字符（考虑到末尾的空字符）并存储在str中。  

        str[strcspn(str, "\n")] = 0; 

        replaceAll(str, target, replacement);

        printf("%s\n", str);

    }

    return 0;

}

3. A和B都是字符串 —— 即从字符串A中把字符串B所包含的字符全删掉，剩下的字符组成的就是字符串A−B。

方法（1）：                                                   方法（2）（好方法）：

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

#include<string.h>                                      #include<string.h>

#include<stdlib.h>                                      int main(){

char delete(char *str,char target);                           char a[100000],b[100000];

int main(){                                               gets(a);

       char a[100000];                                                                 gets(b);

       char b[100000];                                                                    for(int i=0;i<strlen(a);i++){

       gets(a);                                                                                if(strchr(b,a[i]))

       gets(b);                                                                                       continue;

       int len1=strlen(a);                                                                       else

       int len2=strlen(b);                                                                              printf(“%c”,a[i]);

       for(int i=0;i<len2;i++){                                                         }

              delete(a,b[i]);                                                            return 0;

       }                                                                        }

       printf("%s\n",a);

       return 0;

}

char delete(char *str,char target){

       int i,j=0;

       for(i=0;str[i]!='\0';i++){

              if(str[i]!=target){

                     str[j++]=str[i];

              }

       }

       str[j]='\0';

       return str;

}

4. 如何输入两个二进制数并计算他们的和，并以二进制输出

#include <stdio.h>

#include <string.h>

int main() {

    char binary_num1[100], binary_num2[100];

    long int num1, num2, sum;

    printf("请输入第一个二进制数：");

    scanf("%s", binary_num1);

    printf("请输入第二个二进制数：");

scanf("%s", binary_num2);

//首先，我们需要将输入的二进制字符串转换为整数。这可以通过使用strtol函数实现，该函数可以将字符串转换为长整数。在这个例子中，我们将基数设置为2，因为我们正在处理二进制数。

    num1 = strtol(binary_num1, NULL, 2);

    num2 = strtol(binary_num2, NULL, 2);

    while (num2 != 0) {

        sum = num1 ^ num2;

        num2 = (num1 & num2) << 1;

        num1 = sum;

    }

//然后，我们使用位运算符^（异或）来计算两个数的和。异或运算符会比较两个数的每一位，如果两位不同，则结果为1，否则为0。接下来，我们使用位运算符&（与）和左移运算符<<来计算两个数的进位。与运算符会比较两个数的每一位，如果两位都为1，则结果为1，否则为0。左移运算符会将一个数的所有位向左移动指定的位数。我们重复上述步骤，直到没有进位为止。

    printf("两个二进制数的和为：%ld\n", num1);

    printf("对应的二进制数为：%s\n", strtoul(NULL, &binary_num1, 2));

    return 0;

}

5．利用深度搜索来找两个城市之间的最短路径

问题描述：input:1行 n m(n是城市个数，m是两个城市之间连接线的个数)

                    m行 a b l（a，b是两个城市，l是两个城市之间的路径长度）

                       1行是 x y （x是现在所在的城市，y是想去的城市）

#include<stdio.h>

#include<string.h>

void dfs(int startx, int sum);

int book[110], s[110][110], j, m, n, x, y, min;

int main()

{

    int i, a, b, c;

    while (scanf("%d%d", &n, &m) != EOF)// 读取输入的城市个数n和线段个数m。

    {

        min = 99999999;

        memset(book, 0, sizeof(book));

        for (i = 1; i <= n; i++)

             for (j = 1; j <= n; j++)

             {

                 if (i == j)

                     s[i][j] = 0;

                 else

                     s[i][j] = 99999999;

         }//初始化距离数组s，并将所有节点之间的距离设置为一个较大的值99999999，将自身到自身的距离设为0。

for (i = 1; i <= m; i++)

        {

             scanf("%d%d%d", &a, &b, &c);

             s[a][b] = c;

             s[b][a] = c;

        }//读取每条线段的信息，更新距离数组s

        scanf("%d%d", &x, &y);

        book[x] = 1;

        dfs(x, 0); 调用dfs函数进行深度优先搜索，传入起始城市x和当前路径总长度0

        if (min == 99999999)

             printf("No path\n");

        else

             printf("%d\n", min);

    }

    return 0;

}在主函数中，通过函数依次读入城市个数n、线段数m，然后利用一个嵌套循环读入每个城市之间的连接线以及对应的长度。最后读入越越鸟所在的城市x和打算飞往的城市y。

void dfs(int startx, int sum)//startx表示当前所在城市的编号，sum表示当前已经走过的路径长度。

{

    int i;

    if (sum >= min)

        return;// 判断当前路径长度是否已经超过最小路径长度min，如果是，则返回

    if (startx == y)

    {

        if (sum < min)

             min = sum;

     return;// 如果当前城市为目标城市y，则更新最小路径长度min。

}

    for (i = 1; i <= n; i++)

    {

        if (book[i] == 0 && s[startx][i] != 99999999)

        {

             book[i] = 1;

             dfs(i, sum + s[startx][i]);

             book[i] = 0;

        }

    }//遍历所有与当前城市相连的城市，如果该城市未被访问且与当前城市有边相连，将其标记为已访问，递归调用dfs函数，并更新路径长度。

    return;

}

知识点：

1. 深度优先搜索（DFS）算法：通过递归不断深入直到无法继续深入，然后回溯到上一个节点，继续深入其他路径，直到找到目标或全部遍历完。
2. 图的表示：使用邻接矩阵来表示图，其中节点间距离存储在距离数组中。
3. 最短路径问题：通过搜索算法找到两个节点之间的最短路径，这里使用DFS来实现。