AI 助理
备案控制台
开发者社区 云计算 文章 正文

指针作业来喽~

2024-03-19 52
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 指针作业来喽~

将一个字符串str的内容颠倒过来，并输出

# define _CRT_SECURE_NO_WARNINGS 
#include<stdio.h>
#include<string.h>
void Reverse(char* str) {
  char* left = str;
  char* right = str + strlen(str) - 1;//right指向数组的最右边
  while (left < right) {
    char tmp = *left;
    *left = *right;
    *right = tmp;
    left++;
    right--;
  }
}
int main()
{
  char str[10000] = { 0 };
  //while(scanf("%s",str)!=EOF)scanf有一个问题，就是遇到空格就不会读取了
  while (gets(str)) {
    Reverse(str);
    printf("%s", str);
  }
  return 0; 
}

实现一个函数，可以左旋字符串中的k个字符

方法一：

# define _CRT_SECURE_NO_WARNINGS 
#include<stdio.h>
#include<string.h>
void leftRound(char* str, int k)
{
  int len = strlen(str);
  int time = k % len;//计算要循环多少次
  for (int i = 0; i < time; i++)
  {
    char tmp = str[0];//把第一个值暂时放到tmp当中
    int j = 0;
    for (j = 0; j < len - 1; j++)//如果j等于3，那么3+1就越界了
    {
      str[j] = str[j + 1];
    }
    str[j] = tmp;//把第一个值放到最后
  }
}
  int main()
  {
    char str[] = "abcdef";
    leftRound(str, 2);
    printf("%s\n", str);
    return 0;
  }
}

方法二：

# define _CRT_SECURE_NO_WARNINGS 
#include<stdio.h>
#include<string.h>
void leftRound(char* str, int k)
{
  int len = strlen(str);
  int time = k % len;//计算要循环多少次
  char tmp[256] = { 0 };
  strcpy(tmp, str + time);//cd
  strncat(tmp, str, time);//cdab
  strcpy(str, tmp);
}
int main()
{
  char str[] = "abcd";
  leftRound(str, 2);
  printf("%s\n", str);
  return 0;
}
}

方法三：

分段翻转

# define _CRT_SECURE_NO_WARNINGS 
#include<stdio.h>
#include<string.h>
void ReverseRange(char* str, int start, int end)
{
  int left = start;
  int right = end;
  while (left < right)
  {
    int tmp = str[left];
    str[left] = str[right];
    str[right] = tmp;
    left++;
    right--;
  }
}
void leftRound(char* str, int k)
{
  int len = strlen(str);
  int time = k % len;//计算要循环多少次
  ReverseRange(str, 0, time - 1);
  ReverseRange(str, time, len - 1);
  ReverseRange(str, 0, len - 1);
}
int main()
{
  char str[] = "abcdef";
  leftRound(str, 2);
  printf("%s\n", str);
  return 0;
}

模拟实现库函数strlen

#include <stdio.h>  
  
size_t my_strlen(const char *str) {  
    size_t len = 0;  
    while (*str != '\0') {  
        len++;  
        str++;  
    }  
    return len;  
}  
  
int main() {  
    char str[] = "Hello, world!";  
    printf("The length of the string is: %zu\n", my_strlen(str));  
    return 0;  
}

调整数组使奇数全部都位于偶数前面

输入一个整数数组，实现一个函数，来调整该数组中数字的顺序使得数组中所有的奇数位于数组的前半部分，所有偶数位于数组的后半部分。

l遇到偶数就交换，r遇到奇数就交换。 

# define _CRT_SECURE_NO_WARNINGS 
#include<stdio.h>
void Function(int* p, int len)
{
  int* left = p;
  int* right = p + len-1;
  while (left < right) {
    while(left < right && *left % 2 !=0) {
      left++;
    }
    while (left < right && *right % 2 ==0) {
      right--;
    }
    int tmp = *left;
    *left = *right;
    *right = tmp;
  }
}
int main()
{
  int arr[] = { 1,2,3,4,5,6 };
  int len = sizeof(arr) / sizeof(arr[0]);
  Function(arr, len);
  for(int i=0;i<len;i++)
  {
    printf("%d ", arr[i]);
  }
  return 0;
}

使用指针打印数组arr

写一个函数打印arr数组的内容，不使用数组下标，使用指针。arr是一个整形一维数组。

# define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
void printArray(int* p, int len)
{
  for (int i = 0; i < len; i++)
  {
    printf("%d", *(p + i));
  }
}
int main()
{
  int arr[10] = { 0 };
  printArray(arr, 10);
  return 0;
}

冒泡排序 

#include <stdio.h>  
  
void bubbleSort(int arr[], int n) {  
    int i, j, temp;  
    for (i = 0; i < n-1; i++) {  
        for (j = 0; j < n-i-1; j++) {  
            if (arr[j] > arr[j+1]) {  
                // 交换 arr[j] 和 arr[j+1]  
                temp = arr[j];  
                arr[j] = arr[j+1];  
                arr[j+1] = temp;  
            }  
        }  
    }  
}  
  
void printArray(int arr[], int size) {  
    int i;  
    for (i=0; i < size; i++)  
        printf("%d ", arr[i]);  
    printf("\n");  
}  
  
int main() {  
    int arr[] = {64, 34, 25, 12, 22, 11, 90};  
    int n = sizeof(arr)/sizeof(arr[0]);  
    bubbleSort(arr, n);  
    printf("Sorted array: \n");  
    printArray(arr, n);  
    return 0;  
}

字符串旋转结果

方法一：

将字符串旋转多次，与原字符串进行比较：

# define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int leftRound(char* str, char* str2)
{
  int len = strlen(str);
  int k = len;
  while (k--) {
    char tmp = str[0];
    int j = 0;
    for (; j < len - 1; j++)
    {
      str[j] = str[j + 1];
    }
    str[j] = tmp;
    if (strcmp(str, str2) == 0)
    {
      return 1;
    }
  }
    return 0;
  }
int main()
{
  char str1[] = "abcde";
  char* str2 = "cdeab";
  int ret = leftRound(str1, str2);
  if (ret == 1)
  {
    printf("是旋转后的结果！\n");
  }
  return 0;
}

方法二：

库函数方法：strstr （将字符串进行拼接，要找的字符串一定在拼接的字符串当中，并用strstr函数查找子函数）

# define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int findRound(char* str1, char* str2)
{
  char tmp[256] = { 0 };
  strcpy(tmp, str1);//把str1中的内容复制到tmp
  strcat(tmp,str1);//再把str1的内容拼接到tmp数组中
  return strstr(tmp, str2) != NULL;
}
int main()
{
  char str1[] = "abcde";
  char* str2 = "cdeab";
  int ret=findRound(str1, str2);
  if (ret == 1)
  {
    printf("是旋转后的结果");
  }
  else
    printf("不是");
  return 0;
}

杨氏矩阵

第一步：将要查找的数字先与右上角的数字进行比较，如果比要查找的数字小，就证明要查找的数字一定在该数字下方。

# define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int FindNum(int arr[][3],int x,int y,int key)
{
  int i = 0;
  int j = y - 1;//这两个横纵坐标是为了定位到最右边的值
  //要满足i是合法的，j也是合法的
  while (i < x && y >= 0)
  {
    if (arr[i][j] < key)
    {
      i++;//如果比要找的数字小，就加行
    }
    else if (arr[i][j] > key)
    {
      j--;//如果大，就减去列，向前挪
    }
    else
    {
      return 1;
    }
  }
  return 0;
}
int main()
{
  int arr[][3] = { {1,2,3},{4,5,6},{7,8,9} };
  int ret = FindNum(arr,3,3,5);
  if (ret == 1)
  {
    printf("找到了\n");
  }
  else
  {
    printf("不是旋转后的结果\n");
  }
  return 0;
}

猜凶手

# define _CRT_DEFINE_NO_WARNINGS 
#include<stdio.h>
void Func()
{
  for (char killer = 'a'; killer < 'd'; killer++)//分别假设abcd为凶手，逐个尝试
  {
    if ((killer != 'a') + (killer == 'c') + (killer == 'd') + (killer != 'd') == 3)
    {
      printf("%c", killer);
    }
  }
}
int main()
{
  Func();
  return 0;
}

杨辉三角

由图可知，当i==j或j==1时，为1，其他位置上的数字：arr[i][j]=arr[i-1][j-1]+arr[i-1][j]。

#include<stdio.h>
void Yanghui(int arr[][4],int n)
{
  for (int i = 0; i < n; i++)
  {
    for (int j = 0; j <=i; j++)
    {
      if (j == 0 || i==j)
      {
          arr[i][j] = 1;
      }
      else
      {
        arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
      }
    }
  }
}
void print(int arr[][4], int n)
{
  for (int i = 0; i < n; i ++ )
  {
    for (int j = 0; j <=i; j++)
    {
      printf("%d ", arr[i][j]);
    }
    printf("\n");
  }
}
int main()
{
  int arr[4][4] = { 0 };
  Yanghui(arr,4);
  print(arr,4);
  return 0;
}

转移表代码实践

使用函数指针数组实现转移表的代码。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>  
int add(int a, int b)
{
  return a + b;
}
int sub(int a, int b)
{
  return a - b;
}
int mul(int a, int b)
{
  return a * b;
}
int div(int a, int b)
{
  return a / b;
}
int main()
{
  int x, y;
  int input = 0;
  int ret = 0;
  do
  {
    printf("*********************\n");
    printf(" 1:add       2:sub   \n");
    printf(" 3:mul       4.div   \n");
    printf(" 0.exit                ");
    printf("请选择：");
    scanf("%d", &input);
    switch (input)
    {
    case 1:
      printf("输入操作数：");
      scanf("%d %d", &x, &y);
      ret = add(x, y);
      printf("ret=%d\n", ret);
      break;
    case 2:
      printf("输入操作数：");
      scanf("%d %d", &x, &y);
      ret = sub(x, y);
      printf("ret=%d\n", ret);
      break;
    case 3:
      printf("输入操作数：");
      scanf("%d %d", &x, &y);
      ret = mul(x, y);
      printf("ret=%d\n", ret);
      break;
    case 4:
      printf("输入操作数：");
      scanf("%d %d", &x, &y);
      ret = div(x, y);
      printf("ret=%d\n", ret);
      break;
    }
  } while (input);
  return 0;
}

找单身狗2

一个数组中只有两个数字是出现一次，其他所有数字都出现了两次。

编写一个函数找出这两个只出现一次的数字。

例如：

有数组的元素是：1，2，3，4，5，1，2，3，4，6

只有5和6只出现1次，要找出5和6。

方法一：

# define _CRT_SECURE_NO_WARNINGS 
#include<stdio.h>
void FindNum(int arr[], int n, int* pnum1, int* pnum2)
{
  //1.将整个数组异或起来，得到两个不同数字的异或结果，即5和6的异或结果
  int tmp = 0;
  for (int i = 0; i < n; i++)
  {
    tmp ^= arr[i];//tmp将包含两个不同的数字异或的结果 
  }
  //2.找到tmp中，二进制为1的某一位k（用于储存tmp中第一个变量为1的二进制位的位置
  int k = 0;
  for (int i = 0; i < 32; i++)
  {
    if ((tmp >> i) & 1 != 0)
    {
      k = i;
      break;
    }
  }
  //3.遍历数组，把每个数据第k位为1的，分到一个组进行异或，最终得道的值存储到pnum1或者pum2当中
  *pnum1 = *pnum2 = 0;//0异或任何数都是其本身
  for (int i = 0; i < n; i++)
  {
    if (((arr[i] >> k) & 1) != 0)//对于数组中的每个元素，它检查第k位是否为1
    {
      //第k位是1
      *pnum1 ^= arr[i];
      //由于我们已经知道tmp（即两个不同数字的异或结果）的第k位为1，这意味着这两个数字在第k位上的值是相反的
      // 因此，通过根据第k位的值将数组元素分配到两个不同的组并进行异或，我们可以得到这两个只出现一次的数字
    }
    else
    {
      //第k位是0
      *pnum2 ^= arr[i];
    }
  }
}
  int main()
  {
    int arr[] = { 1,2,3,4,5,1,2,3,4,6 };
    int len = sizeof(arr) / sizeof(arr[0]);
    int num1 = 0;
    int num2 = 0;
    FindNum(arr, len, &num1, &num2);
    printf("%d %d\n", num1, num2);
    return 0;
  }

方法二：

 

#include <stdio.h>  
  
void findSingleNumbers(int* nums, int numsSize, int* result) {  
    int xorResult = 0;  
    // 第一步：计算所有数字的异或结果  
    for (int i = 0; i < numsSize; i++) {  
        xorResult ^= nums[i];  
    }  
  
    // 第二步：找到最低位的1  
    int lowestBitOne = xorResult & (-xorResult);  
  
    // 第三步：根据最低位的1将数字分组，并分别进行异或操作  
    int num1 = 0, num2 = 0;  
    for (int i = 0; i < numsSize; i++) {  
        if (nums[i] & lowestBitOne) {  
            num1 ^= nums[i];  
        } else {  
            num2 ^= nums[i];  
        }  
    }  
  
    // 将结果存储在result数组中  
    result[0] = num1;  
    result[1] = num2;  
}  
  
int main() {  
    int nums[] = {1, 2, 3, 4, 5, 1, 2, 3, 4, 6};  
    int numsSize = sizeof(nums) / sizeof(nums[0]);  
    int result[2];  
  
    findSingleNumbers(nums, numsSize, result);  
  
    printf("The two numbers that appear once are: %d and %d\n", result[0], result[1]);  
  
    return 0;  
}

获得月份天数

# define _CRT_SECURE_NO_WARNINGS 
#include<stdio.h>
int Day(int year, int month)
{
  int arr[] = { 31,28,31,30,31,30,31,31,30,31,30,31 };
  int day = arr[month - 1];//月份在数组中的顺序等于输入的数值减去1
  //判断闰年
  if (year % 2 == 0 && year % 100 != 0 || year % 400 == 0)
  {
    if (month == 2)
    {
      day += 1;
    }
  }
  return day;
}
  int main()
  {
    int year, month;
    while (scanf("%d %d", &year, &month) != EOF)
    {
      int ret = Day(year, month);
      printf("%d ", ret);
    }
    return 0;
  }

刚写这篇博客的时候还在放假，现在已经在学校了，五月一号才能回家，有点难过。

pearlthriving
目录
相关文章
冲冲冲c
|
6月前
|
数据采集 分布式计算 DataWorks
DataWorks产品使用合集之赋值节点output是有数据的，引用参数运行打印时是空的，该如何解决
DataWorks作为一站式的数据开发与治理平台，提供了从数据采集、清洗、开发、调度、服务化、质量监控到安全管理的全套解决方案，帮助企业构建高效、规范、安全的大数据处理体系。以下是对DataWorks产品使用合集的概述，涵盖数据处理的各个环节。
冲冲冲c
41 4
Skrrapper
|
7月前
|
C语言
指针(4)---转移表
指针(4)---转移表
Skrrapper
35 0
sky_qiyi
|
6月前
|
存储 算法
数据结构和算法学习记录——特殊线性表之队列-队列的概念、队列结构体类型定义 、基本接口函数、初始化函数、销毁队列函数、入队列函数、判断队列是否为空、出队列函数、读取队头队尾的数据 、计算队列数据个数
数据结构和算法学习记录——特殊线性表之队列-队列的概念、队列结构体类型定义 、基本接口函数、初始化函数、销毁队列函数、入队列函数、判断队列是否为空、出队列函数、读取队头队尾的数据 、计算队列数据个数
sky_qiyi
42 0
beloved000
|
算法 C语言
如何在C语言中实现队列和堆栈的动态扩容
队列和堆栈是在C语言中常用的数据结构，它们可以帮助我们高效地处理数据。然而，在实际编程中，我们经常会遇到数据量超过容量限制的情况。这时，我们需要实现队列和堆栈的动态扩容，以满足实际需求。
beloved000
136 1
高高的胖子
|
存储 C语言
学C的第五天（初识指针，内存产生内存单元地址过程，指针函数介绍和其大小；结构体补充）-2
*%p -- 专门用来打印地址的，以十六进制的形式表示地址
高高的胖子
76 0
高高的胖子
学C的第五天（初识指针，内存产生内存单元地址过程，指针函数介绍和其大小；结构体补充）-1
13*指针： 13.1 -- 内存： 内存是电脑上特别重要的存储器，计算机中程序的运行都是在内存中进行的。 【32位操作系统的内存由32根地址线产生的高低电位（1/0）， 划分为2的32次方个地址（编号\指针），一个地址为一个字节， 等于8比特。】
高高的胖子
93 0
m5suanqf6o2n6
|
存储 C语言
(指针内容)当你申请一个变量，在这期间内存会发生什么？
(指针内容)当你申请一个变量，在这期间内存会发生什么？
m5suanqf6o2n6
123 0
(指针内容)当你申请一个变量，在这期间内存会发生什么？
zsq243gia4mp6
|
C语言
指针数组等作业
指针数组等作业
zsq243gia4mp6
109 0
指针数组等作业
zsq243gia4mp6
结构体作业等
结构体作业等
zsq243gia4mp6
70 0
结构体作业等
灬爱码士灬
|
算法
算法练习——(10)小明的作业详解与分析（栈，数组，遍历，逻辑练习）
题目分析 动手解题
灬爱码士灬
94 0
算法练习——(10)小明的作业详解与分析（栈，数组，遍历，逻辑练习）