西北农林科技大学NWAFU-OJ习题合集三

楠笙屿海

已于 2023-12-22 15:28:00 修改

阅读量1.7k

点赞数 15

分类专栏：西农文章标签： c语言

于 2023-12-11 21:51:02 首次发布

本文链接：https://blog.csdn.net/m0_61679138/article/details/134936318

版权

西农专栏收录该内容

3 篇文章 4 订阅

订阅专栏

点个关注不迷路~

发现错误请留言，会及时答复的~

问题 BA: 重复数字

#include<stdio.h> // 引入标准输入输出库
#include<math.h> // 引入数学库，但在此代码中未使用
#include<malloc.h> // 引入内存分配库，但在此代码中未使用
#include<string.h> // 引入字符串处理库，但在此代码中未使用
#include<stdlib.h> // 引入标准库，但在此代码中未使用
#include <time.h> // 引入时间库，但在此代码中未使用

int main() // 主函数
{
    int n,i=0,s=n; // 定义变量n, i, s，其中s未初始化
    scanf("%d",&n); // 从标准输入读取一个整数并赋值给n

    // 检查输入是否在有效范围内（1-9999999）
    if(n<=0||n>9999999)
    {
	    printf("Invalid input"); // 如果输入无效，打印错误信息
    	return 0; // 结束程序
    }

    // 初始化一个长度为10的数组a，用于存储每个数字出现的次数
    int a[10]={0},flag=0;

    // 通过循环将n的每一位数字存入数组a中
    while(n)
    {
        a[n%10]++; // n除以10的余数作为索引，对应的数组元素加1
        n/=10; // n除以10取整，去掉最后一位数字
    }

    // 遍历数组a，找出出现次数大于1的数字
    for(;i<10;i++)
    {
       if(a[i]>1)
       {
            printf("%d ",i); // 打印出现次数大于1的数字
            flag=1; // 标记找到了重复的数字
       }
    }

    // 如果没有找到重复的数字，打印提示信息
    if(flag==0)
    {
        printf("No repeated numbers.\n");
    }
}

问题 BB: 超简计算器

#include <stdio.h>
#define STRLEN 80
/*函数原型*/
/*读入表达式字符串*/
int read_line(char*, int);
/*计算结果*/
double calc(const char *);
/*测试函数*/
int main(void)
{
    char exp[STRLEN + 1] = {0};
    double r;

    read_line(exp, STRLEN);
    r = calc(exp);
    printf("%0.3f\n",r);
    
    return(0);
}

int read_line(char *str, int n)
{
    int ch,i=0;
    /*读入字符,直到遇到换行符*/
    while(((ch = getchar()) != EOF) && (ch != '\n'))
    {
        if(i < n) /*最大字符数*/
        {
            str[i++] = ch;
        }
    }
    str[i] = '\0'; /*添加空字符'\0' */
    return i; /* 返回读入的字符数*/
}

double calc(const char *s)
{
    double result = 0.0;
    double X;
    char op;
    int offset;
    /*读取第1个操作数*/
    /* %n用于获取截至目前读入的字符数量*/
    if(sscanf(s,"%lf%n",&X,&offset) == 1)
    {
        result = X;
        /*偏移字符串指针*/
        s += offset;
    }
    else
    {
        return result;
    }
    while(*s != '\0' )
    {
        /*取得运算符*/
        op = *s;
        /* 字符串指针偏移1个字符 */
        s++; 
        /*读取下一个操作数*/
        /* %n用于获取截至目前读入的字符数量*/
        if(sscanf(s,"%lf%n",&X,&offset) != 1)
        {
            break; /*没有读到操作数,结束循环*/
        }
        /*偏移字符里指针*/
        s += offset;
        /*根据运算符实行计算(不考虑优先级) */
        switch(op)
        {
            case '+':
            result += X;
            break;

            case '-':
            result -= X;
            break;

            case '*':
            result *= X;
            break;

            case '/':
            result /= X;
            break;
        }
    }
    return result;
}

问题 BC: 字符的二进制表示

#include <stdio.h>

int main(){
    // 定义一个长度为10的整型数组a，并初始化为0
    int a[10]={0};
    // 定义整型变量i和n，分别赋值为0和8
    int i,n=8;
    // 定义整型变量ch
    int ch;
    // 从标准输入读取一个字符，并将其赋值给ch
    scanf("%c",&ch);

    // 当ch不等于0时，执行循环体
    while(ch!=0){
        // 将ch除以2的余数赋值给a[n]
        a[n]=ch%2;
        // 将ch除以2，向下取整
        ch/=2;
        // n自减1
        n--;
    }

    // 从1到8遍历数组a，打印每个元素的值
    for(i=1;i<=8;i++){
        printf("%d",a[i]);
    }
    // 打印换行符
    printf("\n");

    // 返回0，表示程序正常结束
    return 0;
}

问题 BD: 调整正整型数组

#include <stdio.h>
#include <stdlib.h>
 
/* 交换指针a和b所指向的两个整数 */
void ex_num(int *a, int *b)
{ int temp;
    temp=*a;
    *a=*b;
    *b=temp;
}
 
/* 调整正整型数组a，其中n为数组元素的个数 */
void exchange(int a[], int n)
{
    int left, right;
    int cnt=0;
 
    left = 0;
    right = n-1;
    while (left < right)
    {
        if (!(a[left] & 1) && (a[right] & 1)) { cnt++;
            printf("Times %d: %d<==>%d\n", cnt, a[left], a[right]);
            ex_num(&a[left], &a[right]);
        }
        left = (a[left] & 1) ? left+1 : left;
        right = !(a[right] & 1) ? right-1 : right;
     }
    return;
}
 
int main()
{
    int  *arr, sz;
    int i;
    while(scanf("%d",&sz)!= 1);
    arr=(int *)malloc(sz * sizeof(int));
    if (arr==NULL){
        free(arr);return 0;}
    for (i = 0; i < sz; i++)  {
        while(scanf("%d",&arr[i])!=1);
    }
    exchange(arr, sz);
    for (i = 0; i < sz-1; i++) {
        printf("%d ",arr[i]);
    }
    printf("%d",arr[i]);
    printf("\n");
   realloc(arr,0);
    return 0;
}

问题 BE: 除法的精确表示

#include<stdio.h>
int main()
{ int a,b,n;
  char ch;
  scanf("%d",&a);
  scanf("%c",&ch);
  scanf("%d",&b);
  printf("0.");
  int c=0;
  for(;c!=200;c++){
     for(n=0;((a*10)-(b*n))>=b;n++);
         printf("%d",n);
      a=(a*10)%b;
     if((a*10)%b==0)
     { for(n=0;((a*10)-(b*n))>=b;n++);
         printf("%d",n);
         break;}
  }
   printf("\n");
  return 0;
}

问题 BF: 匹配花括号

#include<stdio.h>
int main()
{
    int cnt=0;
    char ch;
   while((scanf("%c",&ch))!=EOF)
   {
       if(ch=='{')
           cnt++;
       if(ch=='}')
           cnt--;
   }
   if(cnt==0)
   printf("Yes");
   else if(cnt>0)
       printf("No(%d)",cnt);
   else if(cnt<0)
       printf("No(-1)");
   return 0;
}

问题 BG: 分数约分问题

// 计算两个整数的最大公约数
int getGCD(int m, int n) {
    // 如果m小于n，交换m和n的值
    if (m < n) {
        int t = m;
        m = n;
        n = t;
    }
    // 使用辗转相除法计算最大公约数
    int rem = n;
    while (rem != 0) {
        rem = m % n;
        m = n;
        n = rem;
    }
    return m;
}

// 根据状态输出结果
void Output(int status, int nNum, int nDenom) {
    // 如果状态为0，输出0
    if (status == 0) {
        printf("0\n");
        return;
    }
    // 如果状态为1，输出1
    if (status == 1) {
        printf("1\n");
        return;
    }
    // 如果状态为-1，输出错误信息
    if (status == -1) {
        printf("Error!\n");
        return;
    }
    // 如果状态为2，根据分母是否为1输出不同的格式
    if (status == 2) {
        if (nDenom == 1) {
            printf("%d\n", nNum);
        } else {
            printf("%d/%d\n", nNum, nDenom);
        }
        return;
    }
    return;
}

// 获取最简分数形式
int getLowestTerms(int m, int n, int *pNum, int *pDenom) {
    // 如果m为0，返回0
    if (m == 0) {
        return 0;
    }
    // 如果m等于n，返回1
    else if (m == n) {
        return 1;
    }
    // 如果n为0，返回-1
    else if (n == 0) {
        return -1;
    }
    // 初始化符号变量
    int msign = 1, nsign = 1, numsign;
    // 如果m小于0，将msign设为-1
    if (m < 0) {
        msign = -1;
    }
    // 如果n小于0，将nsign设为-1
    if (n < 0) {
        nsign = -1;
    }
    // 计算符号的乘积
    numsign = nsign * msign;
    // 取m和n的绝对值
    m = abs(m);
    n = abs(n);
    // 将m和n分别赋值给*pNum和*pDenom
    *pNum = m;
    *pDenom = n;
    // 计算最大公约数
    int gcd = getGCD(m, n);
    // 将分子和分母分别除以最大公约数，并乘以符号的乘积
    *pNum /= gcd;
    *pNum *= numsign;
    *pDenom /= gcd;
    // 返回2表示成功获取最简分数形式
    return 2;
}

问题 BH: 等差数列

// 函数名：judge
// 参数：int a[], int n, int *cd
// 返回值：int
// 功能：判断数组a中的元素是否构成等差数列，并计算公差cd
int judge(int a[], int n, int *cd) {
    // 如果数组长度小于3，则无法构成等差数列，返回-1
    if (n < 3)
        return -1;

    int i, j;
    // 对数组进行冒泡排序，将较大的元素放在后面
    for (i = 0; i < n; i++) {
        for (j = i + 1; j < n; j++) {
            if (a[j] < a[i]) {
                int t = a[i];
                a[i] = a[j];
                a[j] = t;
            }
        }
    }

    // 计算公差cd为数组中第二个元素与第一个元素的差
    *cd = a[1] - a[0];

    // 遍历数组，判断相邻元素之间的差是否等于公差cd
    for (i = 1; i < n; i++) {
        if (a[i] - a[i - 1] != *cd) {
            // 如果存在不相等的差，则说明不是等差数列，返回1
            return 1;
        }
    }

    // 如果所有相邻元素之间的差都等于公差cd，则是等差数列，返回0
    return 0;
}

问题 BI: 哥德巴赫猜想验证

// 判断一个数是否为质数的函数
int isprime(int n)
{
    int i;
    int flag =1;
    scanf("%d", &n); // 读取输入的整数n
    for (i = 2; i < n; i++) // 从2开始遍历到n-1
    {
        if (n % i == 0) // 如果n能被i整除，说明n不是质数
        {
            flag = 0; // 将flag设为0
            break; // 跳出循环
        }
    }
    if (flag) // 如果flag为1，说明n是质数
        return 1; // 返回1
    else
        return 0; // 否则返回0
}

// 寻找两个质数之和等于给定数n的函数
int resolve(int n)
{    
    int i;
    for(i=2;i<=n/2;i++) // 从2开始遍历到n/2
        if (isprime(i)&&isprime(n-i))                              // 如果i和n-i都是质数
            return i; // 返回i
}

问题 BJ: 二分法解方程

// 定义一个求解双根的函数，接受一个函数指针fun和两个double类型的参数a和b
double BiRoot(double(*fun)(double), double a, double b)
{
    double c = 1; // 初始化中间值c为1
    // 如果a和b的符号相同，说明没有根或者有重根，返回0并输出错误信息
    if (fun(a) * fun(b) > 0)
    {
        printf("error!a,b have the same sign.\n");
        return 0;
    }
    // 当c的绝对值大于等于0.000001时，继续迭代
    do
    {
        c = (a + b) / 2; // 计算中间值c
        // 如果a和c的乘积小于0，说明根在[a, c]之间，更新b为c
        if (fun(a) * fun(c) < 0)
            b = c;
        // 如果b和c的乘积小于0，说明根在[c, b]之间，更新a为c
        if (fun(b) * fun(c) < 0)
            a = c;
    } while (fun(c) >= 0.000001 || fun(c) <= -0.000001); // 当c的绝对值小于等于0.000001时，认为已经找到根
    return c; // 返回找到的根
}

问题 BK: 手机按键

// 计算文件中第n行的字符数量
int CountLine(FILE *fp, int n) {
    int alpha[26] = {1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 1, 2, 3, 4}; // 字母权重数组
    char str[200] = {0}; // 存储读取到的行内容
    int len, i, keys = 0; // len为行长度，i为循环计数器，keys为字符数量

    if (fp == NULL || n < 1) // 如果文件指针为空或n小于1，返回0
        return 0;

    ReadLine(str, fp, n); // 读取第n行的内容到str中
    len = strlen(str); // 计算行长度

    if (len == 0) // 如果行长度为0，返回0
        return 0;

    for (i = 0; i < len; i++) { // 遍历行中的每个字符
        if (str[i] >= 'a' && str[i] <= 'z') // 如果字符是小写字母
            keys += alpha[str[i] - 'a']; // 根据字母权重数组累加权重
        else keys++; // 否则字符数量加1
    }

    return keys; // 返回字符数量
}

// 从文件中读取第n行的内容到s中，最多读取200个字符
int ReadLine(char *s, FILE *fp, int n) {
    int i = 0; // i为循环计数器
    int ch = 0; // ch为当前读取到的字符

    if (s == NULL || fp == NULL || n < 1) // 如果参数有误，返回0
        return 0;

    rewind(fp); // 将文件指针重置到文件开头
    while (n != 1 && ch != EOF) { // 当n不等于1且未到达文件末尾时
        ch = fgetc(fp); // 读取一个字符
        if (ch == '\n') // 如果读取到换行符
            n--; // n减1
    }

    while ((ch = fgetc(fp)) != EOF && ch != '\n' && i < 200) { // 当未到达文件末尾且已读取的字符数小于200时
        if ((ch >= 'a' && ch <= 'z') || (ch == ' ')) { // 如果字符是小写字母或空格
            s[i++] = ch; // 将字符存入s中
        }
    }
    s[i] = '\0'; // 在s末尾添加字符串结束符

    return i; // 返回实际读取到的字符数
}

问题 BL: 变位词统计

void lowcase(char *s){
    int len=strlen(s); // 获取字符串长度
    int i;
    for(i=0;i<len;i++){ // 遍历字符串中的每个字符
        if(s[i]>='A'&&s[i]<='Z'){ // 如果字符是大写字母
            s[i]+=32; // 将其转换为小写字母
        }
    }
}
 
int areAnagrams(const char *word1,const char *word2){
    int a[27]={0},b[27]={0}; // 初始化两个数组，用于存储单词中每个字母出现的次数
    int l1,l2,i;
    l1=strlen(word1); // 获取第一个单词的长度
    l2=strlen(word2); // 获取第二个单词的长度
 
    if(l1!=l2)return 0; // 如果两个单词的长度不相等，则它们不可能是字谜词
 
    for(i=0;i<l1;i++){ // 遍历第一个单词中的每个字符
        a[word1[i]-96]++; // 将字符转换为数组索引，并增加对应字母的计数
    }
    for(i=0;i<l2;i++){ // 遍历第二个单词中的每个字符
        b[word2[i]-96]++; // 将字符转换为数组索引，并增加对应字母的计数
    }
 
    for(i=1;i<=26;i++){ // 比较两个数组中的每个元素
        if(a[i]!=b[i]) // 如果两个数组中的元素不相等，则这两个单词不是字谜词
            return 0;
    }
    return 1; // 如果两个数组中的所有元素都相等，则这两个单词是字谜词
}
 
int countAnagrams(const char *text,const char *word){
    int l1,l2,i=0,sum=0,j;
    char word2[50],word1[50];
    l1=strlen(text); // 获取文本的长度
    l2=strlen(word); // 获取单词的长度
 
    while(l1-i>=l2){ // 当文本剩余长度大于等于单词长度时，继续查找字谜词
        for(j=i;j<i+l2;j++){ // 将文本中的子串复制到word2中
            word2[j-i]=text[j];
        }
        for(j=0;j<l2;j++){ // 将单词复制到word1中
            word1[j]=word[j];
        }
        word1[l2]='\0'; // 在word1末尾添加空字符，表示字符串结束
        word2[l2]='\0'; // 在word2末尾添加空字符，表示字符串结束
        lowcase(word1); // 将word1转换为小写
        lowcase(word2); // 将word2转换为小写
        if(areAnagrams(word1,word2)==1){ // 如果word1和word2是字谜词
            i+=l2; // 更新搜索起始位置
            sum++; // 增加找到的字谜词数量
        }
        else
            i++; // 否则，只移动一个字符的位置
    }
    return sum; // 返回找到的字谜词数量
}

问题 BM: 13和17的倍数和

#include<stdio.h>

int main(){
    int n,m; // 定义两个整型变量n和m
    scanf("%d%d",&n,&m); // 从标准输入读取两个整数，分别赋值给n和m

    int sum=0; // 定义一个整型变量sum，用于存储满足条件的数的和

    while(m!=0&&n>0){ // 当m不为0且n大于0时，执行循环
        if(n%13==0||n%17==0){ // 如果n能被13或17整除
            sum+=n; // 将n加到sum上
            m--; // m减1
        }
        n--; // n减1
    }
    printf("%d\n",sum); // 输出sum的值
    return 0; // 返回0，表示程序正常结束
}

问题 BN: Operator函数

int Operator(int *a, int *b, int *c)
{
    int a2 = 0, *a1, b2 = 0, *b1, c2 = 0, *c1;
    int max = 0;

    a1 = &a2; // 将a2的地址赋给a1
    b1 = &b2; // 将b2的地址赋给b1
    c1 = &c2; // 将c2的地址赋给c1

    // 比较a和b的大小，将较大的值赋给max
    if (*a > *b)
        max = *a;
    else
        max = *b;

    // 如果c大于max，则将c的值赋给max
    if (*c > max)
        max = *c;

    // 计算a+b的值，并将结果赋给a1指向的变量
    *a1 = *a + *b;
    // 计算b+c的值，并将结果赋给b1指向的变量
    *b1 = *b + *c;
    // 计算c+a的值，并将结果赋给c1指向的变量
    *c1 = *c + *a;
    // 将a1指向的变量的值赋给a
    *a = *a1;
    // 将b1指向的变量的值赋给b
    *b = *b1;
    // 将c1指向的变量的值赋给c
    *c = *c1;

    return max; // 返回max的值
}

问题 BO: 封闭的圆圈

#include<stdio.h> // 引入标准输入输出库
int main() // 主函数
{
    int low = 0, high = 0, i = 0, n = 0, temp = 0, k = 0, sum = 0; // 定义变量
    scanf("%d%d",&low,&high); // 从标准输入读取两个整数，分别赋值给low和high
    n = high - low + 1; // 计算范围内的数字数量

    for(;i < n;i++){ // 遍历范围内的每个数字
        temp = low; // 将当前数字赋值给temp
        if(temp < 0) // 如果temp为负数
            temp = -temp; // 取其绝对值
        do{ // 循环处理temp的每一位数字
            k = temp % 10; // 取出最后一位数字
            temp = temp / 10; // 去掉最后一位数字
            switch(k){ // 根据取出的数字进行判断
                case 0:case 6:case 9: // 如果数字为0、6或9
                    sum++; // sum加1
                    break;
                case 8: // 如果数字为8
                    sum += 2; // sum加2
                    break;
            }
        }while(temp > 0); // 当temp大于0时，继续处理下一位数字
        low++; // 处理完当前数字后，将low加1，处理下一个数字
    }
    printf("%d\n",sum); // 输出结果
    return 0; // 程序正常结束
}

问题 BP: 二分法解方程

#define _CRT_SECURE_NO_WARNINGS 1

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

/* 非线性函数原型 */
double f(double x);

/* 二分求解函数原型 */
double BinarySearch(double, double);

int main()
{
    double x, a, b;

    scanf("%lf%lf", &a, &b);
    if (f(a) * f(b) > 0)     /* 此处填空 */
    {
        printf("错误,a和b同号!\n");
        return 0;
    }
    x = BinarySearch(a, b);  /* 此处填空 */
    printf("%5.3f\n", x);
    return 0;
}

double f(double x)
{
    return x * x * x - 10 * x * x + 3 * x + 20.0;
}

double BinarySearch(double a, double b)
{
    double x;

    x = (a + b) / 2.0;
    if (x-a < 1E-6)   /* 此处填空 */
        return x;
    else
    {
        if (f(a) * f(x) > 0)
            return BinarySearch(x, b);    /* 此处填空 */
        else
            return BinarySearch(a, x);    /* 此处填空 */
    }
}

问题 BQ: 整理数组

// 交换两个整数的值
void swap(int *a, int *b) {
    int t = *a;
    *a = *b;
    *b = t;
}

// 冒泡排序算法
void BubbleSort(int a[], int n) {
    int i, j;
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - 1 - i; j++) {
            if (a[j] < a[j + 1])
                swap(&a[j], &a[j + 1]);
        }
    }
}

// 重置数组函数
void ResetArray(int input[], int n, int output[]) {
    int k = 1, a = 1;
    BubbleSort(input, n); // 对输入数组进行冒泡排序

    output[n / 2] = input[0]; // 将排序后的第一个元素放到输出数组的中间位置
    while (k < n) {
        output[n / 2 - a] = input[k++]; // 将排序后的前半部分元素放到输出数组的前半部分
        a++;
        output[n / 2 + a - 1] = input[k++]; // 将排序后的后半部分元素放到输出数组的后半部分
    }
}