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

已于 2024-09-11 18:56:44 修改
阅读量4.6k 收藏 75
点赞数 26
分类专栏： 西农 文章标签： c语言
于 2023-12-08 10:51:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61679138/article/details/134872854
版权

写在开头：

归纳的内容供大家参考和校对

代码能力需要去不断磨练，不要过于依靠参照内容

点个关注不迷路~

如果有错误请留言，会及时答复的~

问题 A: C语言实习题一——1.简单程序设计

#include <stdio.h> // 引入标准输入输出库

int main( ) // 主函数，程序的入口
{
    printf ("Happy New Year!\n"); // 输出 "Happy New Year!" 并换行
    return 0; // 返回0，表示程序正常结束
}

问题 B: C语言实习题一——2.简单计算

#include <stdio.h> // 引入标准输入输出库

int main() // 主函数，程序的入口
{ 
    float a, b, h, c, j, s; // 定义浮点型变量a、b、h、c、j、s
    
    scanf("%f%f", &a, &b); // 从标准输入读取两个浮点数并赋值给a和b
    
    h = a + b; // 计算a和b的和，并将结果赋值给h
    c = a - b; // 计算a和b的差，并将结果赋值给c
    j = a * b; // 计算a和b的积，并将结果赋值给j
    s = a / b; // 计算a除以b的商，并将结果赋值给s
    
    printf("和=%f,差=%f,积=%f,商=%f
",h,c,j,s); // 将h、c、j、s的值按照指定格式输出到标准输出
   
    return 0; // 返回0，表示程序正常结束
}

问题 C: C语言实习题一——3.计算梯形面积

#include <stdio.h> // 引入标准输入输出库

int main() // 主函数，程序的入口
{ 
    float supline,dowline,high,area; // 定义浮点型变量supline、dowline、high、area
    
    scanf("%f",&supline); // 从标准输入读取一个浮点数并赋值给supline
    scanf("%f",&dowline); // 从标准输入读取一个浮点数并赋值给dowline
    scanf("%f",&high); // 从标准输入读取一个浮点数并赋值给high
		
    area = ((supline+dowline)*high)/2.0; // 计算梯形面积公式：((上底+下底)*高)/2
		
    printf("%f\n",area); // 将计算得到的梯形面积输出到标准输出
   	return 0; // 返回0，表示程序正常结束
}

问题 D: C语言实习题一——4.输出字符对应的ASCII码

#include <stdio.h> // 引入标准输入输出库
int main() // 主函数，程序的入口
{ 
    char c; // 定义一个字符变量c
    
    scanf("%c",&c); // 从标准输入读取一个字符并赋值给c
		
    printf("%d\n",c); // 将字符c转换为整数并输出到标准输出
   	return 0; // 返回0，表示程序正常结束
}

问题 E: C语言实习题一——5.数据类型长度测试

#include <stdio.h> // 引入标准输入输出库
int main() // 主函数，程序的入口
{ 
    char a=1; // 定义一个字符变量a并赋值为1
    short b=2; // 定义一个短整型变量b并赋值为2
    int c=4; // 定义一个整型变量c并赋值为4
    long d=8; // 定义一个长整型变量d并赋值为8
    int e=4; // 定义一个整型变量e并赋值为4
    int f=8; // 定义一个整型变量f并赋值为8

    printf("size of char=%d\n",a); // 输出字符变量a的大小
    printf("size of short=%d\n",b); // 输出短整型变量b的大小
    printf("size of int=%d\n",c); // 输出整型变量c的大小
    printf("size of long int=%d\n",d); // 输出长整型变量d的大小
    printf("size of float=%d\n",e); // 输出浮点型变量e的大小
    printf("size of double=%d\n",f); // 输出双精度浮点型变量f的大小
   	return 0; // 返回0，表示程序正常结束
}

问题 F: C语言实习题二——1.成绩判断

#include <stdio.h> // 引入标准输入输出库
int main() // 主函数，程序的入口
{ 
    float mark; // 定义一个浮点型变量mark用于存储分数

    scanf("%f",&mark); // 从标准输入读取一个浮点数并赋值给mark
    if (mark<60) // 如果分数小于60
        printf("Fail\n"); // 输出"Fail"
    else // 否则
        printf("Pass\n"); // 输出"Pass"
        
   return 0; // 返回0，表示程序正常结束
}

 问题 G: C语言实习题二——2.字符转换

#include <stdio.h> // 引入标准输入输出库

int main() {
    char ch; // 定义一个字符变量ch用于存储输入的字符
    ch = getchar(); // 从标准输入读取一个字符并赋值给ch

    if (ch >= 65 && ch <= 90) { // 如果字符是大写字母
        printf("%c\n", ch + 32); // 将字符转换为小写字母并输出
    }
    else if (ch >= 97 && ch <= 122) { // 如果字符是小写字母
        printf("%c\n", ch - 32); // 将字符转换为大写字母并输出
    }
    else { // 如果字符不是字母
        printf("%c\n", ch); // 直接输出字符
    }

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

问题 H: C语言实习题二——3.利用海伦公式求三角形面积

#include<stdio.h> // 引入标准输入输出库
#include<math.h> // 引入数学库

int main() // 主函数
{
    float a,b,c; // 定义三个浮点数变量a、b、c
    float p,area; // 定义两个浮点数变量p、area

    scanf("%f%f%f",&a,&b,&c); // 从标准输入读取三个浮点数并赋值给a、b、c

    p=(a+b+c)*0.5; // 计算半周长

    if(a+b>c&&a+c>b&&b+c>a) // 判断是否能组成三角形
    {
        area=sqrt(p*(p-a)*(p-b)*(p-c)); // 计算三角形面积
        printf("三角形的面积是：%f\n",area); // 输出三角形面积
    }
    else{
        printf("这3个数无法组成三角形！\n"); // 输出无法组成三角形的提示信息
    }

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

问题 I: C语言实习题二——4.判断是否能构成一个三角形

#include<stdio.h> // 引入标准输入输出库

int main() // 主函数
{
    float a, b, c; // 定义三个浮点数变量a、b、c
    scanf("%f%f%f", &a, &b, &c); // 从标准输入读取三个浮点数并赋值给a、b、c

    // 判断是否满足三角形的条件：任意两边之和大于第三边，且三边都大于0
    if (a > 0 && b > 0 && c > 0 && a + b > c && a + c > b && b + c > a)
        printf("Yes\n"); // 如果满足条件，输出"Yes"
    else
        printf("No\n"); // 如果不满足条件，输出"No"

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

问题 J: C语言实习题二——5.按从大到小排序三个数 

#include<stdio.h> // 引入标准输入输出库
int main() // 主函数
{
    int a, b, c; // 定义三个整型变量a、b、c
    int t; // 定义一个整型变量t，用于交换值
    scanf("%d%d%d", &a, &b, &c); // 从标准输入读取三个整数并赋值给a、b、c

    printf("排序前：%d, %d, %d\n", a, b, c); // 输出排序前的a、b、c的值

    // 使用冒泡排序算法对a、b、c进行排序
    if (a < b)
    {
        t = a; // 将a的值赋给t
        a = b; // 将b的值赋给a
        b = t; // 将t的值赋给b
    }

    if (a < c)
    {
        t = a; // 将a的值赋给t
        a = c; // 将c的值赋给a
        c = t; // 将t的值赋给c
    }

    if (b < c)
    {
        t = b; // 将b的值赋给t
        b = c; // 将c的值赋给b
        c = t; // 将t的值赋给c
    }

    printf("排序后：%d, %d, %d\n", a, b, c); // 输出排序后的a、b、c的值
    return 0; // 返回0，表示程序正常结束
}

问题 K: C语言实习题三——1.数据统计

#include <stdio.h> // 引入标准输入输出库
#include <string.h> // 引入字符串处理库
#include <stdlib.h> // 引入动态内存分配库

int main() // 主函数
{
    int n; // 定义整数变量n
    scanf("%d",&n); // 从标准输入读取一个整数并赋值给n
    int *arr=(int *)malloc(sizeof(int)*n); // 动态分配n个整数的内存空间，并将指针赋值给arr
    int i; // 定义整数变量i
    for(i=0;i<n;i++) // 循环n次
    {
        scanf("%d",&arr[i]); // 从标准输入读取一个整数并赋值给arr的第i个元素
    }
    int sum_1=0,sum_2=0,count_1=0,count_2=0; // 定义四个整数变量，分别用于存储奇数和偶数的和以及个数
    for(i=0;i<n;i++) // 循环n次
    {
        if(arr[i]%2!=0) // 如果arr的第i个元素是奇数
        {
            sum_1+=arr[i]; // 将arr的第i个元素加到sum_1上
            count_1++; // 奇数个数加1
        }
        if(arr[i]%2==0) // 如果arr的第i个元素是偶数
        {
            sum_2+=arr[i]; // 将arr的第i个元素加到sum_2上
            count_2++; // 偶数个数加1
        }
    }
    printf("%d\n",sum_1); // 输出奇数和
    printf("%d\n",count_1); // 输出奇数个数
    printf("%d\n",sum_2); // 输出偶数和
    printf("%d",count_2); // 输出偶数个数
    free(arr); // 释放动态分配的内存空间

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

问题 L: C语言实习题三——2.爱因斯坦阶梯问题

#include<stdio.h> // 引入标准输入输出库
int main() // 主函数
{
    int x=1; // 定义整数变量x并初始化为1
    while(1) // 无限循环
    {
        if(x%2==1&&x%3==2&&x%5==4&&x%6==5&&x%7==0) // 判断x是否满足条件
            break; // 如果满足条件，跳出循环
        else
            x=x+1; // 如果不满足条件，x加1
    }
  
    printf("%d\n",x); // 输出x的值
  
    return 0; // 返回0，表示程序正常结束
}

问题 M: C语言实习题三——3.猴子吃桃问题

#include<stdio.h> // 引入标准输入输出库
int main() // 主函数
{
     int N; // 定义整数变量N
     scanf("%d",&N); // 从标准输入读取一个整数并赋值给N
  
     int x=1; // 定义整数变量x并初始化为1
     int i=1; // 定义整数变量i并初始化为1
     while(i<N) // 当i小于N时执行循环
     {
          x=2*(x+1); // 计算2*(x+1)的值并赋值给x
          i++; // i自增1
     }
 
     printf("%d\n",x); // 输出x的值
 
     return 0; // 返回0，表示程序正常结束
}

问题 N: C语言实习题三——4.求两个数的最大公约数和最小公倍数

#include <stdio.h>

int main() {
    int a, b; // 定义两个整数变量a和b
    scanf("%d%d", &a, &b); // 从标准输入读取两个整数并赋值给a和b
    int Div = 0; // 定义一个整数变量Div，用于存储最大公约数
    int Multi = a * b; // 定义一个整数变量Multi，用于存储a和b的乘积
    int rem = 0; // 定义一个整数变量rem，用于存储余数
    rem = a % b; // 计算a除以b的余数，并将结果赋值给rem
    while (rem) { // 当余数不为0时执行循环
        a = b; // 将b的值赋给a
        b = rem; // 将余数的值赋给b
        rem = a % b; // 计算新的a除以b的余数，并将结果赋值给rem
    }
    Div = b; // 将b的值赋给Div，即得到最大公约数
    Multi /= Div; // 将Multi除以Div，得到简化后的乘积

    printf("%d\n", Div); // 输出最大公约数
    printf("%d\n", Multi); // 输出简化后的乘积

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

问题 O: C语言实习题三——5.图形输出

#include<stdio.h> // 引入标准输入输出库
int main() // 主函数
{
     int n; // 定义整型变量n
     char ch; // 定义字符型变量ch
   
     scanf("%c",&ch); // 从标准输入读取一个字符并赋值给ch
     scanf("%d",&n); // 从标准输入读取一个整数并赋值给n
  
     for(int i=0;i<n;i++){ // 外层循环，控制行数
         for(int j=n-i-1;j>0;j--) // 内层循环，控制每行前面的空格数
         {
              printf("%c", ' '); // 输出空格
         }
         for(int k=2*(i)+1;k>0;k--) // 内层循环，控制每行的字符数
         {
              printf("%c", ch); // 输出字符
         }
  
         printf("\n"); // 换行
  
     }
     return 0; // 返回0，表示程序正常结束
}

 问题 P: C语言实习题四——1.字符串连接

#include<stdio.h> // 引入标准输入输出库
int main()
{
    char arr1[10],arr2[10]; // 定义两个字符数组，用于存储输入的字符串
    fgets(arr1,10,stdin); // 从标准输入读取一行字符串，存储到arr1中
    fgets(arr2,10,stdin); // 从标准输入读取另一行字符串，存储到arr2中

    int i=0; // 初始化变量i为0，用于遍历arr1
    while(arr1[i]!='\0') // 当arr1的第i个字符不为空字符时，执行循环体
    {
        i++; // i自增1
    }
    int j=0; // 初始化变量j为0，用于遍历arr2
    while(arr2[j]!='\0') // 当arr2的第j个字符不为空字符时，执行循环体
    {
        j++; // j自增1
    }
    int m; // 定义变量m，用于循环计数
    for(m=0;m<j;m++) // 当m小于j时，执行循环体
    {
        arr1[i-1]=arr2[m]; // 将arr2的第m个字符赋值给arr1的第i-1个字符
        i++; // i自增1
    }

    puts(arr1); // 输出arr1中的字符串
    return 0; // 返回0，表示程序正常结束
}

问题 Q: C语言实习题四——2.简单加密程序

#include<stdio.h>
#include<string.h>
int main()
{
     char arr[100];
     fgets(arr, 100, stdin); // 从标准输入读取一行字符串，存储到arr中
   
     int sz=strlen(arr)/sizeof(arr[0]); // 计算字符串长度
     for(int  i=0;i<sz;i++) // 遍历字符串中的每个字符
     {
   
          if((arr[i]>='a'&&arr[i]<='x')||(arr[i]>='A'&&arr[i]<='X')) // 如果字符是小写字母或大写字母
              arr[i]=arr[i]+2; // 将字符的ASCII码值加2
          else  if((arr[i]>='y'&&arr[i]<='z')||(arr[i]>='Y'&&arr[i]<='Z')) // 如果字符是小写字母或大写字母
              arr[i]=arr[i]-24; // 将字符的ASCII码值减24（即加上26）
     }
     puts(arr); // 输出处理后的字符串
  
     return 0;
}

问题 R: C语言实习题四——3.矩阵对角线元素求和

#include<stdio.h>

int main()
{
     int a[5][5]; // 定义一个5x5的二维数组a
     int i,j;
     for(i=0;i<5;i++) // 遍历数组a的每一行
         for(j=0;j<5;j++) // 遍历数组a的每一列
         {
             scanf("%d",&a[i][j]); // 从标准输入读取一个整数，并将其赋值给数组a的第i行第j列的元素
         }
     int m,n;
     m=a[0][0]+a[1][1]+a[2][2]+a[3][3]+a[4][4]; // 计算数组a的主对角线元素之和，并将结果赋值给变量m
     n=a[0][4]+a[1][3]+a[2][2]+a[3][1]+a[4][0]; // 计算数组a的副对角线元素之和，并将结果赋值给变量n
     printf("%d %d\n",m,n); // 输出变量m和n的值，中间用空格分隔
     return 0; // 返回0，表示程序正常结束
}

问题 S: C语言实习题四——4.数据顺序调整

#include <stdio.h>
int main()
{
    int a[10]; // 定义一个长度为10的整型数组a
    int i;
    for(i=0;i<10;i++){ // 循环10次，用于输入数组a的元素
        scanf("%d",&a[i]);
    }
    int x=0; // 定义一个整型变量x，用于记录最大值的索引
    int max=a[0]; // 将数组a的第一个元素赋值给max，作为初始的最大值
    for(i=1;i<10;i++){ // 循环9次，从第二个元素开始比较
        if(a[i]>max){ // 如果当前元素大于max
            max=a[i]; // 更新最大值
            x=i; // 更新最大值的索引
        }
    }
    int m=a[0]; // 定义一个整型变量m，用于交换最大值和第一个元素的位置
    a[0]=a[x]; // 将最大值与第一个元素交换位置
    a[x]=m;
     
    int y=9; // 定义一个整型变量y，用于记录最小值的索引
    int min=a[9]; // 将数组a的最后一个元素赋值给min，作为初始的最小值
    for(i=1;i<9;i++){ // 循环8次，从第二个元素开始比较
        if(a[i]<min){ // 如果当前元素小于min
            min=a[i]; // 更新最小值
            y=i; // 更新最小值的索引
        }
    }
    int n=a[9]; // 定义一个整型变量n，用于交换最小值和最后一个元素的位置
    a[9]=a[y]; // 将最小值与最后一个元素交换位置
    a[y]=n;
    // 输出排序后的数组a
    for(i=0;i<10;i++){
        printf("%d",a[i]);
        if(i==9){
            break;
        }
        printf(" ");
    }
    return 0;
}

问题 T: C语言实习题四——5.字符个数统计

#include<stdio.h> // 引入标准输入输出库
#include<string.h> // 引入字符串处理库
int main()
{
    char arr[100]={0}; // 定义一个字符数组，用于存储输入的字符串
    fgets(arr,100,stdin); // 从标准输入读取一行字符串，存储到字符数组中
    int sz=0; // 定义一个整型变量，用于存储字符串的长度
    sz=strlen(arr)/sizeof(arr[0]); // 计算字符串的长度，除以每个字符的大小（字节），得到字符个数
    //fgets(arr,100,stdin); 
    int a=0,b=0,c=0,d=0; // 定义四个整型变量，分别用于计数英文字母、数字和其他字符的数量
    for(int i=0;i<sz;i++) // 遍历字符串中的每个字符
    {
         if(arr[i]>='a'&&arr[i]<='z') // 如果字符是小写英文字母
         {
             a++; // 英文字母数量加一
         }
         else  if(arr[i]>='A'&&arr[i]<='Z') // 如果字符是大写英文字母
         {
             b++; // 英文字母数量加一
         }
         else  if(arr[i]>='0'&&arr[i]<='9') // 如果字符是数字
         {
             c++; // 数字数量加一
         }
         else // 如果字符既不是英文字母也不是数字
         {
             d++; // 其他字符数量加一
         }
    }
    d=d-1; // 最后减去一个换行符，因为fgets函数会在字符串末尾添加一个换行符
    printf("%d %d %d %d\n",a,b,c,d); // 输出英文字母、数字和其他字符的数量
  
    return 0; // 程序正常结束，返回0
}

问题 U: C语言实习题四——6.姓名排序

#include<stdio.h>
#include<string.h>
  
int main()
{
    char s[10][100]={0}; // 定义一个二维字符数组，用于存储输入的字符串
    for(int i=0;i<10;i++) // 循环10次，读取10行输入
    {
         fgets(s[i],10,stdin); // 使用fgets函数读取一行输入，存储到s[i]中
    }
  
    for(int i=0;i<10;i++) // 外层循环10次，对每一行进行冒泡排序
    {
        for(int j=0;j<9;j++) // 内层循环9次，比较相邻的两个字符串
        {
            if(strcmp(s[j],s[j+1])>0) // 如果前一个字符串大于后一个字符串
            {
                 char t[100]; // 定义一个临时字符数组，用于交换两个字符串
                 strcpy(t,s[j]); // 将前一个字符串复制到临时数组中
                 strcpy(s[j],s[j+1]); // 将后一个字符串复制到前一个字符串的位置
                 strcpy(s[j+1],t); // 将临时数组中的字符串复制到后一个字符串的位置
            }
         }
     }
  
     for(int m=0;m<10;m++) // 循环10次，输出排序后的字符串
     {
          printf("%s", s[m]);
     }

     return 0;
}

问题 V: C语言实习题四——7.输出杨辉三角形

#include<stdio.h>
int main()
{
     int a[100][100]={0}; // 定义一个100x100的二维数组a，并初始化为0
     int n;
     scanf("%d",&n); // 从标准输入读取一个整数n
     for(int i=0;i<n;i++) // 循环n次
     {
         a[i][i]=1; // 将a[i][i]赋值为1
         a[i][0]=1; // 将a[i][0]赋值为1
     }
     for(int i=2;i<n;i++) // 循环从2到n-1次
     {
         for(int j=0;j<i;j++) // 循环从0到i-1次
         {
             a[i][j]=a[i-1][j-1]+a[i-1][j]; // 根据递推公式计算a[i][j]的值
         }
     }
     for(int i=0;i<n;i++) // 循环n次
     {
         for(int j=0;j-1<i;j++) // 循环从0到i-1次
         {
             printf("%d ",a[i][j]); // 输出a[i][j]的值
         }
  
         printf("\n"); // 换行
     }
  
     return 0;
}

问题 W: C语言实习题五——1.用指针实现排序

#include <stdio.h>
int main()
{
    // 定义一个长度为10的整型数组a
    int a[10];
    int i,j,*p,*q,t;
    // 从键盘输入10个整数，存储到数组a中
    for(i=0;i<10;i++){
        scanf("%d",&a[i]);
    }
    // 使用冒泡排序算法对数组a进行升序排序
    for(i=0;i<9;i++){
        p=a+i; // p指向当前待比较的元素
        for(q=p+1;q<a+10;q++){ // q指向后面的元素
            if(*p>*q){ // 如果当前元素大于后面的元素
                t=*q; // 交换两个元素的位置
                *q=*p;
                *p=t;
            }
        }
    }
    // 输出排序后的数组a
    for(i=0;i<10;i++){
        printf("%d",a[i]);
        if(i==9){
            break;
        }
        printf(" ");
    }
    return 0;
}

问题 X: C语言实习题五——2.用指针实现字符串排序

#include<stdio.h>
#include<string.h>
int main()
{
    // 定义一个二维字符数组a，用于存储输入的字符串
    char a[10][20];
    // 定义一个一维字符指针数组b，用于存储字符串的地址
    char* b[10];

    // 使用循环获取用户输入的字符串，并将其存储到数组a中
    for(int i=0;i<10;i++)
    {
        gets(a[i]);
        b[i]=a[i];
    }

    // 使用冒泡排序算法对字符串进行排序
    for(int i=0;i<10;i++)
    {
        for(int j=0;j<9;j++)
        {
            // 比较相邻的两个字符串，如果前一个字符串大于后一个字符串，则交换它们的位置
            if(strcmp(b[j],b[j+1])>0)
            {
                char t[20];
                // 将前一个字符串复制到临时变量t中
                strcpy(t,b[j]);
                // 将后一个字符串复制到前一个字符串的位置
                strcpy(b[j],b[j+1]);
                // 将临时变量t中的字符串复制到后一个字符串的位置
                strcpy(b[j+1],t);
            }
        }
    }

    // 输出排序后的字符串
    for(int i=0;i<10;i++)
    {n
        printf("%s\n",b[i]);
    }

    return 0;
}

问题 Y: C语言实习题五——3.数据倒置

#include<stdio.h>
int main()
{
    // 定义一个长度为10的整型数组a
    int a[10];
    // 使用for循环，从键盘输入10个整数，存储到数组a中
    for(int i=0;i<10;i++)
    {
        scanf("%d",&a[i]);
    }

    // 定义两个指针p和q，分别指向数组a的第一个元素和最后一个元素的下一个位置
    int *p,*q;
    p=&a[0];
    q=&a[0]+9;
    // 使用for循环，交换数组a中的前5个元素和后5个元素的位置
    for(int i=0;i<5;i++)
    {
        // 定义一个临时变量t，用于存储p指向的元素的值
        int t=*p;
        // 将p指向的元素的值赋给q指向的元素
        *p=*q;
        // 将临时变量t的值赋给q指向的元素
        *q=t;
        // p向后移动一位
        p++;
        // q向前移动一位
        q--;
        // 如果q和p相等，说明已经交换了所有的元素，跳出循环
        if(q==p)
        {
            break;
        }
    }
    // 使用for循环，输出数组a的前9个元素
    for(int i=0;i<9;i++)
    {
        printf("%d ",a[i]);
        // 如果i等于8，说明已经输出了最后一个元素，跳出循环
        if(i==9)
        {
            break;
        }
    }

    // 输出数组a的第10个元素（即原数组的最后一个元素）
    printf("%d\n",a[9]);

    return 0;
}

问题 Z: C语言实习题五——4.用指针实现数据位置调整

#include <stdio.h>

int main() {
    // 定义一个长度为10的整型数组a，并初始化为0
    int a[10] = { 0 };
    // 从标准输入读取10个整数，存储到数组a中
    for (int i = 0; i < 10; i++) {
        scanf("%d", &a[i]);
    }
    // 定义两个指针max和min，分别指向数组a的第一个元素
    int* max = &a[0];
    int* min = &a[0];
    // 遍历数组a，找到最大值和最小值的指针
    for (int i = 1; i < 10; i++) {
        if (a[i] > *max) {
            max = &a[i];
        }
    }
    // 交换最大值和数组最后一个元素的位置
    int tmp = 0;
    tmp = *max;
    *max = *((int*)a + 9);
    *((int*)a + 9) = tmp;
    // 重新遍历数组a，找到最小值的指针
    for (int i = 1; i < 10; i++) {
        if (a[i] < *min) {
            min = &a[i];
        }
    }
    // 交换最小值和数组第一个元素的位置
    tmp = *min;
    *min = *((int*)a);
    *((int*)a) = tmp;

    // 输出排序后的数组a
    for (int i = 0; i < 10; i++) {
        printf("%d", a[i]);
        if (i != 9) {
            printf(" ");
        }
    }

    return 0;
}

装载问题（西农Oj） 解题报告
xxm137164869的专栏
08-13 2347
描述： 有两艘船，载重量分别是c1、 c2，n个集装箱，重量是wi (i=1…n)，且所有集装箱的总重量不超过c1+c2。确定是否有可能将所有集装箱全部装入两艘船。 输入： 多个测例，每个测例的输入占两行。第一行一次是c1、c2和n（n 输出： 对于每个测例在单独的一行内输出Yes或No。 输入样例： 7 8 2 8 7 7 9 2 8 8 0 0
NWAFU-OJ题解
Uaenabaichen的博客
02-27 2136
本文章为西北农林科技大学NWAFU-OJ上的习题讲解（C语言)，作者小郭会持续更新！俗话说：“不敲坏几个键盘就不能成为一名程序员。”让我们一起多动手，去迎接这个崭新的网络世界吧！
NWAFU-OJ(基础)12.简单加密程序
m0_73657553的博客
07-24 631
取余操作常用于字符的循环，例如假设a字符的ascii码值是32，想要前33个字符构成一个循环，a向右移动两个位置，要求还在循环里，这时候a的下标就要变成(a+2)%33=1 (循环中下标从0开始)3.c-'a'+2后变成了26，显然不在我们的循环中，所以进行取余（c-'a'+2）%26，结果为0，就对应这0位置的字符的下标，就是字符a,由键盘任意输入一串字符，对其进行加密，加密原则为：如果为字母，将其循环右移2个字母，其他字符保持不变。对应代码：‘c-'a' (c-'A') c表示字符变量，
有理数类的设计与实现(运算符重载)
最新发布
2301_79587125的博客
04-30 1267
定义有理数类（分母不为0的分数，分子分母均为整数）CRational，实现相应运算符的重载。（1）定义私有数据成员：分子int iUp;分母int iDown。（2）定义私有成员函数：void Reduce()和int Gcd(int l, int r)，分别用于有理数的约简和求两个整数的最大公约数。其中，在约简时需要求取分子与分母的最大公约数。（3）定义构造函数，在构造函数体内可调用Reduce对有理数进行约简。（4）将非运算符!重载为公有成员函数用于判断分母是否为0。
Nwafu-OJ- 1414 Problem M C语言实习题三——3.猴子吃桃问题
qq_53436105的博客
10-07 525
问题 M: C语言实习题三——3.猴子吃桃问题 时间限制: 1 Sec 内存限制: 128 MB 提交: 3675 解决: 2038 [提交][状态][讨论版] 题目描述 一只猴子吃桃子。第一天吃了这堆桃子的一半，觉得不过瘾，又多吃了一个，第2天接着吃了前一天剩下的一半，再多吃了一个，以后每天如此，经过N天后，只剩下1个桃子。若已知N的值，问最初这堆桃子共有多少只？ 输入 吃到只剩下1个桃子所需要的天数N。 输出 最初这堆桃子的数目。 样例输入 10 样例输出 1534 提示 ① 从最后一天的
nwafu-oj1515
01-15
根据引用[2]中的NWAFU-OJ题解，nwafu-oj1515是一个关于字符串处理的问题。该问题要求统计给定字符串中每个字符出现的次数，并按照字符的ASCII码从小到大的顺序输出结果。 以下是一个解决nwafu-oj1515问题的示例代码...
nwafu-oj1520
01-15
根据引用[2]中的NWAFU-OJ题解，nwafu-oj1520是一个题目的编号，具体内容如下： 题目描述： 给定一个整数n，求出1到n之间所有整数的和。 输入： 一个整数n（1 ） 输出： 1到n之间所有整数的和 示例： 输入：5 ...
nwafu-oj补考
01-15
根据提供的引用内容，以下是一个关于nwafu-oj补考的C语言代码示例： ```c #include int main() { float mark; scanf("%f", &mark); if(mark >= 60){ printf("Pass\n"); return 0; } printf("Fail\n"); ...
西北农林科技大学数电（数字逻辑与数字设计）考题及答案
11-28
总的来说，这份资料对于准备西北农林科技大学的数电考试至关重要，它不仅包含了实际的考题，还提供了对应的答案，使得学生能够有针对性地进行复习和练习，提高应试能力。同时，通过反复操练和分析，也能更好地将理论...
西北农林科技大学C++试题及答案
11-28
- **概念**: 数据封装是面向对象编程的一个核心特性，指的是将数据和对该数据的操作封装在一起，形成一个独立的实体。 - **实现**: 在C++中，数据封装通常是通过**类**来实现的。类定义了对象的数据成员（即属性）和...
西北农林科技大学C语言考试题
06-30
西北农林科技大学历年c语言考试题;2005～2006学年第1学期《C语言程序设计》试题；西北农林科技大学本科课程考试试卷2006—2007年第一学期《C语言程序设计》课程A卷
Nwafu-OJ-1421 Problem S C语言实习题四——4.数据顺序调整
qq_53436105的博客
10-13 910
问题 S: C语言实习题四——4.数据顺序调整 时间限制: 1 Sec 内存限制: 128 MB 提交: 13658 解决: 1415 [提交][状态][讨论版] 题目描述 由键盘任意输入10个数，将最大数调到最前面，最小数调到最后面。 输入 任意10个数 输出 数据调整后的10个数。 样例输入 0 1 2 3 4 5 6 7 8 9 样例输出 9 1 2 3 4 5 6 7 8 0 提示 ① 定义四个变量d1、d2、x1、x2，分别存放最大数、最小数及它们的位置； ② 在循环开始前，将第一个
NWAFU-OJ(基础)3.计算梯形面积
m0_73657553的博客
07-21 472
当a/b中,a和b其中有一个数是浮点数时，比如b是浮点数，C语法就会对a进行默认类型转换，让a也变成浮点数，可以理解为即1/2.0变成1.0/2.0，则能正常计算出结果。② 求梯形面积的公式为：面积=(上底+下底)×高/2，即area = ((supline+dowline)*high)/2.0;当a和b都是整数类型时（1和2），相除结果向下取整，本来应该是0.5，但是要向下取整，所以结果就变成了0。已知梯形的上底、下底和高，计算梯形的面积。梯形的上底、下底和高。
Nwafu-Oj-1444 Problem l C语言实习题七——2.结构体数组的定义与引用
qq_53436105的博客
11-28 891
问题 : C语言实习题七——2.结构体数组的定义与引用 时间限制: 1 Sec 内存限制: 128 MB 提交: 4459 解决: 2011 [提交][状态][讨论版] 题目描述 定义一个职工结构体数组，从键盘输入5位职工的信息，打印出最高的工资。 输入 从键盘输入5位职工的信息（4个数据，每个占一行，工资有两位小数）。 输出 打印出最高的工资。 样例输入 liuxin 91736527976271265 11 1234.23 liyixin 91736527976271265 11 5234.24 l
Nwafu-oj 哥德巴赫猜想
wyydsohoo的博客
11-21 323
Nwafu-oj 哥德巴赫猜想
Nwafu-OJ-1409 Problem H C语言实习题二——3.利用海伦公式求三角形面积
qq_53436105的博客
10-06 391
问题 H: C语言实习题二——3.利用海伦公式求三角形面积 时间限制:1 Sec内存限制:128 MB 题目描述 利用海伦公式求三角形面积 输入 三角形三个边长 输出 三角形面积 样例输入 3 4 5 样例输出 三角形的面积是:6.000000 提示 1. 输入格式： scanf("%f%f%f",&a,&b,&c); /*由键盘输入3个数*/ 2. 输出格式： printf("三角形的面积是:%f\n",area); printf("这3个数无
C语言输出杨辉三角（西农oj）
weixin_46105613的博客
12-09 576
西北农林科技大学oj系统题目
NWAFU-OJ 问题 S: C语言实习题四——4.数据顺序调整
2301_79988783的博客
10-22 356
由键盘任意输入10个数，将最大数调到最前面，最小数调到最后面。数据调整后的10个数。
西北农林科技大学NWAFU-OJ习题合集三
m0_61679138的博客
12-11 4178
西北农林科技大学NWAFU-OJ习题合集三
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值