C编程（西安邮电大学MOOC)

1、最大与次大值

题目内容：编写程序，找出给定的n个数中的最大值及次大值。

输入格式：在第一行中输入一个正整数n（1<n≤10）。第二行输入n个整数，用英文逗号,隔开。

输出格式：在一行中输出最大值及次大值，中间用英文逗号,隔开。

输入样例：7

12,1,2,5,4,7,3

输出样例：12,7

/* 
    求最大值、次大值可以不用排序
 */
#include <stdio.h>
#define N 100
int main()
{    
    int n, a[N] = {0};
    scanf("%d",&n);
    for(int i=0; i<n-1; ++i){
        scanf("%d,",&a[i]);
    }
    scanf("%d",&a[n-1]);
    /* 只一个元素最大次大相同 */
    int max1 = a[0], max2 = a[0];
    a[1] > max1 ? max1 = a[1] : max2  = a[1];
    for(int k=2; k<n; ++k){
        if(a[k]>max1){
            max2 = max1;
            max1 = a[k];
        }
        else if(a[k]>max2){
            max2 = a[k];
        }
    }    
    printf("%d,%d
",max1, max2);
    return 0;
}

/*  
与只求最大值的程序一样吗，
好像是， 可以排序。
*/
#include <stdio.h>
#define N 100
int main()
{    
    int n, a[N] = {0};
    scanf("%d",&n);
    for(int i=0; i<n-1; ++i){
        scanf("%d,",&a[i]);
    }
    scanf("%d",&a[n-1]);
    /* 插入排序 */
    for(int i = 0; i<n; ++i){
        int min = a[i];
        int index = i;
        for(int j = i+1; j<n; ++j){
            if(min>a[j]){ 
                min = a[j];
                index = j;
            }                
        }
        if(index != i){
            a[index] = a[i];
            a[i] = min;
        }
    }    
    printf("%d,%d
",a[n-1],a[n-2]);
    return 0;
}

2、素数排序

题目内容：输入10个正整数到a数组中，对a[10]数组中的素数升序排序。

输入格式：在一行中输入10个用英文逗号,隔开的正整数。

输出格式：在一行中输出升序的素数序列，每个数之间用英文逗号,隔开，末尾没有多余的空格。

输入样例：10,3,1,5,4,8,7,2,9,11

输出样例：2,3,5,7,11

输入样例：16,12,1,6,4,8,14,18,24,21

输出样例：Not found!

/*  */
#include <stdio.h>
#define N 100
/* 判断素数 */
int isPrime(int key)
{
    if(key<2)
        return 0;
    for(int i=2; i<key; ++i)
        if(key%i==0)
            return 0;
    return 1;
}
/* 升序插入 */
void InsertArr(int *arr, int n, int key)
{
    int j=n;
    while(j>=0 && key>arr[j]){
        arr[j+1]=arr[j];/*移动,向后赋值*/
        j--;
    }
    arr[j+1]=key;/**/   
}
int main()
{    
    int n=0, arr[N] = {0},a[N] = {0};    
    
    for(int i=0; i<9; ++i){
        scanf("%d,",&a[i]);
        if(isPrime(a[i])){
            InsertArr(arr,n,a[i]);
            n++;
        }            
    }
    scanf("%d",&a[9]);
    if(isPrime(a[9])){
        InsertArr(arr,n,a[9]);
        n++;
    }    
    if(n==0)
        printf("Not found!");
    else{
        for(int i=n-1; i>0; --i){
            printf("%d,",arr[i]);
        }
        printf("%d",arr[0]);
    }
    return 0;
}

 3、循环右移

题目内容：一个数组A中存有N>0个整数，将每个整数循环向右移M≥0个位置，即将A中的数据由（A0A1⋯AN−1）变换为（AN−M⋯AN−1A0A1⋯AN−M−1）（最后M个数循环移至最前面的M个位置）。

输入格式：第1行输入N（1≤N≤100）和M（≥0）中间用英文逗号,分隔第2行输入N个整数，中间用英文 逗号,分隔。

输出格式：在一行中输出循环右移M位以后的整数序列，中间用英文逗号,分隔，序列结尾不能有多余空格。

输入样例：7,3

1,2,3,4,5,6,7

输出样例：5,6,7,1,2,3,4

输入样例：7,0

1,2,3,4,5,6,7

输出样例：1,2,3,4,5,6,7

#include <stdio.h>
#define N 100

/* 头插入 */
void InsertHead(int *arr, int index, int key)
{    
    for(int j=index-1; j>=0; j--){
        arr[j+1]=arr[j];/*移动*/
    }
    arr[0]=key;
}
int main()
{    
    int n, m, arr[N] = {0};    
    scanf("%d,%d",&n,&m);
    
    for(int i=0; i<n-1; ++i){
        scanf("%d,",&arr[i]);        
    }
    scanf("%d",&arr[n-1]);
    
    while(m--)
        InsertHead(arr,n-1,arr[n-1]);
        
    for(int i=0; i<n-1; ++i){
        printf("%d,",arr[i]);
    }
    printf("%d",arr[n-1]);    
    return 0;
}

/* 算法2 整体右移动m位, 右m位全部移动到数组左边 */
#include <stdio.h>
#define N 100

int main()
{    
    int n, m, arr[N] = {0};    
    scanf("%d,%d",&n,&m);
    
    for(int i=0; i<n-1; ++i){
        scanf("%d,",&arr[i]);        
    }
    scanf("%d",&arr[n-1]);
    /* 1.数组整体向右移动m位 */
    for(int i=n-1; i>=0; --i)
        arr[i+m] = arr[i];
    /* 2.右m位全部移动到数组左边 */
    for(int i=0; i<m; ++i)
        arr[i] = arr[i+n];
        
    for(int i=0; i<n-1; ++i){
        printf("%d,",arr[i]);
    }
    printf("%d",arr[n-1]);    
    return 0;
}

/* 算法3 置换圈 */
#include <stdio.h>
#define N 100
int gcd(int n, int m)//最大公约数
{
    while(n)
    {
        int r = m%n;
        m = n;
        n = r;
    }
    return m;
}
int main()
{    
    int n, m, arr[N] = {0};    
    scanf("%d,%d",&n,&m);
    
    for(int i=0; i<n-1; ++i){
        scanf("%d,",&arr[i]);        
    }
    scanf("%d",&arr[n-1]);
    
    int count = gcd(n,m);//圈数(最大公约数)
    int length = n / count; //圈长度
    for(int i=0; i<count; ++i)//循环处理count圈
    {
        int t = arr[i]; //圈头元素
        int start = i;  //圈头下标
        int end = (start-m+n)%n;//圈尾下标
        for(int j=1; j<length; j++)//圈内移位
        {
            arr[start] = arr[end];
            start  = end;
            end = (end-m+n)%n;
        }
        arr[start] = t;//圈头元素就位
    }
    
    for(int i=0; i<n-1; ++i){
        printf("%d,",arr[i]);
    }
    printf("%d",arr[n-1]);    
    return 0;
}

/* 算法4 逆序 */
#include <stdio.h>
#define N 100
/* 逆序 */
void reverse(int* arr, int left, int right)
{
    while(left<right)
    {
        int t = arr[left];
        arr[left] = arr[right];
        arr[right] = t;
        left++, right--;
    }
}
int main()
{
    int n, k, arr[N] = {0};    
    scanf("%d,%d",&n,&k);
    /* 输入数组 */
    for(int i=0; i<n-1; ++i){
        scanf("%d,",&arr[i]);        
    }
    scanf("%d",&arr[n-1]);
    /* 1.将数组分成两段，左段长为n-k，右段长为k
    分别将两段逆转(即元素排列次序与原次序相反) */
    reverse(arr,0,n-k-1);    
    reverse(arr,n-k,n-1);
    /* 2.再数组元素整体逆转 */
    reverse(arr,0,n-1);
    /* 打印 */
    for(int i=0; i<n-1; ++i){
        printf("%d,",arr[i]);
    }
    printf("%d",arr[n-1]);  
    return 0;
}

/* 算法5.辅助数组 */
#include <stdio.h>
#define N 100
int main()
{
    int n, k, arr1[N] = {0},arr2[N] = {0};    
    scanf("%d,%d",&n,&k);
    /* 输入数组 */
    for(int i=0; i<n-1; ++i){
        scanf("%d,",&arr1[i]);        
    }
    scanf("%d",&arr1[n-1]);
    /* 复制 */
     for(int i=0; i<n; ++i){
        arr2[i] = arr1[(i-k+n)%n];//左移arr1[(i+k)%n];
    }
    /* 打印 */
    for(int i=0; i<n-1; ++i){
        printf("%d,",arr2[i]);
    }
    printf("%d",arr2[n-1]);  
    return 0;
}

/* 算法6.循环队列理论,直接输出 */
#include <stdio.h>
#define N 100
int main()
{
    int i, n, k, arr[N] = {0};    
    scanf("%d,%d",&n,&k);
    /* 输入数组 */
    for(int i=0; i<n-1; ++i){
        scanf("%d,",&arr[i]);        
    }
    scanf("%d",&arr[n-1]);
    
    /* 打印 */
    for(i=0; i<n-1; ++i){
        printf("%d,",arr[(i-k+n)%n]);
    }
    printf("%d",arr[(i-k+n)%n]);  
    return 0;
}

4、爬楼梯

题目内容：可爱的小明特别喜欢爬楼梯，他有的时候一次爬一个台阶，有的时候一次爬两个台阶，有的时候一次爬三个台阶。如果这个楼梯有n个台阶，小明一共有多少种爬法呢？n值从键盘输入。

输入格式：输入一个整数n,(1<=n<46)。

输出格式：输出当楼梯阶数是n时的上楼方式总数。

输入样例：1

输出样例：1

输入样例：4

输出样例：7

输入样例：24

输出样例：1389537

#include <stdio.h>

double fun(int n){
    if(n==1)
        return 1;
    else if(n==2)
        return 2;
    else if(n==3)
        return 4;
    return fun(n-1) + fun(n-2)+ fun(n-3);
}

int main()
{
    int n;
    scanf("%d",&n);
    printf("%.f",fun(n));
    return 0;
}

5、三天打鱼两天晒网

题目内容：中国有句俗语：“三天打鱼两天晒网”，某人从1990年1月1日起开始“三天打鱼两天晒网”。问这个人在以后的某一天是在“打鱼”还是在“晒网”？

输入样例：1990-1-3

输出样例：他在打鱼

输入样例：2018-11-13

输出样例：他在晒网

#include<stdio.h>
int inputdate();
int main()
{
    int n = inputdate();
   /*  if(-1==n){
        printf("Invalid input");
    }
    else  */
    if(n%5==0||n%5==4){
        printf("他在晒网");
    }
    else{
        printf("他在打鱼");
    }
 
    return 0;
}
int inputdate()
{
    int year,month,day;
    int n = scanf("%4d-%2d-%2d",&year,&month,&day);
    /* if(3 != n||year<1990||month>12||month<=0||day>31||day<=0){
        return -1;
    } */
 
    int date[2][12]={{31,28,31,30,31,30,31,31,30,31,30,31},
                     {31,29,31,30,31,30,31,31,30,31,30,31}};
 
    int sum = 0, flag =(year%4==0&&year%100!=0)||(year%400==0);
    for(int i=0;i<month-1;++i){
        sum +=date[flag][i];
    }
 
    return sum+day;
}

6、时间换算

题目内容：编写程序，实现输入的时间，屏幕显示一秒后的时间。显示格式为HH:MM:SS。

 程序需要处理以下三种特殊情况：

（1）若秒数加1后为60，则秒数恢复到0，分钟数增加1；

（2）若分钟数加1后为60，则分钟数恢复到0，小时数增加1；

（3）若小时数加1后为24，则小时数恢复到0。

输入样例：18:1:2

输出样例：18:01:03

输入样例：20:12:59

输出样例：20:13:00

输入样例：23:59:59

输出样例：00:00:00

#include<stdio.h>
void run();
int main()
{
    run();
 
    return 0;
}
void run()
{
    int h,m,s;
    scanf("%d:%d:%d",&h,&m,&s);
 
    s++;
    if(s==60){
        s=0;
        m++;
    }
    if(m==60){
        m=0;
        h++;
    }
    if(h==24){
        h=0;
    }
    printf("%02d:%02d:%02d
",h,m,s);
}

7、正向建立单链表

题目内容：输入若干个正整数（输入-1为结束标志），要求按输入数据的逆序建立单链表并输出。

输入格式：一行内输入若干个正整数，之间用空格隔开，并以-1结束。

输出格式：一行内输出建立的单链表数据结果，之间用两个分隔符 -- 隔开，结束标志-1不输出。

输入样例：2 4 6 8 10 -1

输出样例：--2--4--6--8--10

#include <stdio.h>
#include <malloc.h>
typedef struct node NODE;
typedef struct node* Linklist;
struct node{
    int data;
    Linklist next;
};
/* 
//头插法(输入与输出是逆序)
Linklist create(){
    Linklist L,p;
    L = p = (Linklist)malloc(sizeof(NODE));
    L->next = NULL;
    int x;
    scanf("%d",&x);
    while(x!=-1)
    {
        p = (Linklist)malloc(sizeof(NODE));
        p->data = x;
        p->next = L->next;
        L->next = p;
        scanf("%d",&x);
    }
    return L;
} */
// 尾插法(输入与输出正序) 
Linklist create(){
    Linklist L,p,r;
    L = r = (Linklist)malloc(sizeof(NODE));
    L->next = NULL;
    int x;
    scanf("%d",&x);
    while(x!=-1)
    {
        p = (Linklist)malloc(sizeof(NODE));
        p->data = x;
        p->next = NULL;
        r->next = p;
        r = p;    
        scanf("%d",&x);
    }
    return L;
}
void print(Linklist L){
    while(L->next)
    {
        L = L->next;
        printf("--%d",L->data);
    }
}
int main()
{
    Linklist L = create();
    print(L);
    return 0;
}

8、逆置单链表

题目内容：一个单链表L=(a1 , a2 , … , an-1 , an)，其逆单链表定义为L’=( an , an-1 , … , a2 , a1)，编写算法将单链表L逆置，要求逆单链表仍占用原单链表的空间。

输入格式：一行内输入原单链表中的数据（若干个正整数，之间用空格隔开，并以-1结束）

输出格式：一行内输出建立的原单链表数据结果，之间用两个分隔符 -- 隔开，结束标志-1不输出。

                  下一行内输出逆置后的单链表数据结果，之间用两个分隔符 -- 隔开。

输入样例：2 4 6 8 10 -1

输出样例：--2--4--6--8--10

                  --10--8--6--4--2

#include <stdio.h>
#include <malloc.h>
typedef struct node NODE;
typedef struct node* Linklist;
struct node{
    int data;
    Linklist next;
};
void reverse(Linklist L)
{
    Linklist NEW = NULL, CUR = L->next, TEMP;
    while(CUR)//是否空
    {
        TEMP = CUR->next;//保存新表的当前指针的前驱指针(无前驱为NULL)
        CUR->next = NEW;// 逆序(NEW为新表当前CUR的后继指针)
        NEW = CUR;//更新新表后继指针
        CUR = TEMP;//更新新表当前指针      
    }    
    L->next = NEW;//逆序的头指针插入头结点
}  
Linklist create()
{
    Linklist L,p,r;
    L = r = (Linklist)malloc(sizeof(NODE));
    L->next = NULL;
    int x;
    scanf("%d",&x);
    while(x!=-1)
    {
        p = (Linklist)malloc(sizeof(NODE));
        p->data = x;
        p->next = NULL;
        /* ---------- */
        r->next = p;//尾插
        r = p;    //更新尾指针
        scanf("%d",&x);
    }
    return L;
}
void print(Linklist L)
{
    while(L->next)
    {
        L = L->next;
        printf("--%d",L->data);
    }
    printf("
");
}
int main()
{
    Linklist L = create();
    print(L);
    reverse(L);//逆序
    print(L);
    return 0;
}

9、链表合并

题目内容：已知单链表LA=(a₁，a₂，…，a_m)和LB=(b₁，b₂，…，b_n)，编写程序按以下规则将它们合并成一个单链表LC，要求新表 LC利用原表的存储空间。

          LC=(a₁，b₁，…，a_m，b_m，b_m+1，…，b_n)，m<=n

或者

      LC=(a₁，b₁，…，a_n，b_n，a_n+1，…，a_m)，m>n

输入格式：一行内输入单链表LA中的数据（若干个正整数，之间用空格隔开，并以-1结束）

                  一行内输入单链表LB的数据（若干个正整数，之间用空格隔开，并以-1结束）

输出格式：一行内输出合并后单链表LC的数据结果，之间用两个分隔符 -- 隔开，结束标志-1不输出。 

输入样例：1 3 5 7 -1

                  2 4 6 -1

输出样例：--1--2--3--4--5--6--7

#include <stdio.h>
#include <malloc.h>
typedef struct node NODE;
typedef struct node* Linklist;
struct node{
    int data;
    Linklist next;
};
Linklist mergelist(Linklist LA,Linklist LB)
{
    /* 
        LA的头指针为新链表的头、尾指针
        LB的头结点释放
    */
    Linklist head = LA,rear = LA,temp = LB; 
    LA = LA->next;
    LB = LB->next;
    free(temp);
    /* 逐个结点链接到新链表 */
    while(LA && LB)
    {
        /* 先插LA再插LB */
        if(LA)
        {    
            rear->next = LA;//尾插结点
            rear = rear->next;//更新尾结点
            LA = LA->next;    
        }
        if(LB)
        {        
            rear->next = LB;//尾插结点
            rear = rear->next;//更新尾结点
            LB = LB->next;
        }
    }
    if(LA)
        rear->next = LA;//尾插剩余结点
    if(LB)
        rear->next = LB; 
    return head;
}
Linklist create(){
    Linklist L,p,r;
    L = r = (Linklist)malloc(sizeof(NODE));
    L->next = NULL;
    int x;
    scanf("%d",&x);
    while(x!=-1)
    {
        p = (Linklist)malloc(sizeof(NODE));
        p->data = x;
        p->next = NULL;
        r->next = p;
        r = p;    
        scanf("%d",&x);
    }
    return L;
}
void print(Linklist L){
    while(L->next)
    {
        L = L->next;
        printf("--%d",L->data);
    }
    printf("
");
}
int main()
{
    Linklist L1 = create();
    Linklist L2 = create();
    Linklist L3 = mergelist(L1,L2);
    print(L3);
    return 0;
}

10、求2~2000的所有素数.有足够的内存,要求尽量快

#include <stdio.h>
#include <assert.h>
/* 素数集合 */
int findvalue[2000];
static int find;/*素数集合下标从0开始*/
bool adjust(int value)
{    
    assert(value>=2);/* value>=2 */
    if(value==2) return true; 
    /* 被素数整除的不是素数 */
    for(int i=0;i<=find;i++)
    {
        if(value%findvalue[i]==0)
            return false;
    }
    findvalue[find++];
    return true;
}
int main()
{    
    /* 测试, 2～100中的素数集合 */
    for(int i=2; i<100; ++i)
        if(adjust(i))
            findvalue[find] = i;
    /* 打印素数集合 */
    for(int j=0;findvalue[j]; ++j)
        printf("%d ",findvalue[j]);
    return 0;
}

11、计算器

输入一个四则运算算式，运算符为+、-、*、/，操作数为实型数据，对于除法算式，除数不为0，输出算式中的操作数要求保留小数点后两位。

[测试输入1]1.2+3.4

[测试输出1]1.20+3.40=4.60

[测试输入2]2.5*2

[测试输出2]2.50*2.00=5.00

#include <stdio.h>
#define N 100
int main()
{    
    double a,b;    
    char op;
    scanf("%lf %c%lf",&a,&op,&b);
    double result=0;
    switch(op){
        case '+':result = a+b;break;
        case '-':result = a-b;break;
        case '*':result = a*b;break;
        case '/':result = a/b;break;
    }
    printf("%.2f%c%.2f=%.2f
",a,op,b,result);       
    return 0;
}

12、日期合法性判定

 从键盘输入一个8位整数表示的日期（即yyyymmdd，表示yyyy年mm月dd日），判断该日期是否为合法日期。

[输入样例] 19990101

[输出样例] 1999年1月1日是合法日期

[输入样例] 19361321

[输出样例] 1936年13月21日是非法日期

[输入样例] 19780431

[输出样例] 1978年4月31日是非法日期

[输入样例] 20000229

[输出样例] 2000年2月29日是合法日期

[输入样例] 21000229

[输出样例] 2100年2月29日是非法日期

[输入样例] 19980229

[输出样例] 1998年2月29日是非法日期

#include <stdio.h>
#define N 100
int main()
{    
    int arr[13] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
    int y,m,d,flag =0;
    scanf("%4d%2d%2d",&y,&m,&d);
    int leapyear = y%4==0&&y%100!=0||y%400==0;
    if(leapyear) arr[2]++;
    if(m<=12&&m>=1&&d<=arr[m]&&d>=1)
        flag = 1;
    printf("%d年%d月%d日",y,m,d);  
    if(flag)
        printf("是合法日期");
    else
        printf("是非法日期");         
    return 0;
}

13、求完数

一个正整数如果恰好等于它的因子之和,这个数就称为“完数”，编程找出X之内（包含X）的所有完数并从小到大依次输出各个完数，以空格间隔。例如：6=1+2+3,所以6就是完数。

[样例输入] 100

[样例输出] 6 28

[样例输入] 1000

[样例输出] 6 28 496

#include<stdio.h>
int fun(int i)
{
    int sum=0,t = i-1;  
    while(t)
    {        
        if(i%t==0)     
            sum += t;
        t--;
    }
    if(sum==i) return 1;
    return 0;        
}

int main()
{
    int n,flag=0;
    scanf("%d",&n);
   
    for(int i=6;i<=n;++i)
    {
        if(fun(i)){
            if(flag) printf(" ");
            printf("%d",i);
            flag = 1;
        }
    }    
    return 0;
}

14、生日蜡烛

[题目描述] 某君从某年开始每年都举办一次生日party，并且每次都要吹熄与年龄相同根数的蜡烛。现在算起来，他一共吹熄了N根蜡烛。

请问，他从多少岁开始办生日party的，现在他多少岁？

例如：若N=236，因为236=26+27+28+29+30+31+32+33，所以，他从26岁开始办生日party，他现在33岁。

[输入说明] 输入一共吹熄的蜡烛数N。

[输出说明] 输出他办生日party的起止年龄数，以空格隔开；若有多种情况，输出起始年龄最小的一种情况。

[样例输入] 236

[样例输出] 26 33

[样例输入] 186

[样例输出] 10 21

#include<stdio.h>
void fun(int n, int *s,int *e){
    for(int i=1;i<=100;++i)
    {
        int sum=0;
        for(int j=i; j<=100; ++j){
            sum += j;
            if(sum==n){
                *s=i;
                *e=j;
                return;
            }            
        }            
    }    
}
int main()
{
    int n,s,e;
    scanf("%d",&n);
    fun(n,&s,&e);
    printf("%d %d",s,e);
    return 0;
}

15、整数排序

[题目描述] 从键盘输入n个整数，将其从小到大进行排序，并将排序后的结果输出。特别说明：待排序的整数的个数不超过20个。

[输入说明] 第一行为n值，第二行输入n个整数，以空格间隔。

[输出说明] 输出的数据用空格隔开。

[样例输入] 

5

5 6 1 2 3

[样例输出]

1 2 3 5 6

/*快速排序*/
#include <stdio.h>
void QuickSort(int *a,int n, int left, int right)
{
    int i,j,t; 
        /*左指针left指向数组头 右指针right指向数组尾*/
    if(left<right){
        i=left,j=right+1;/*左右指针*/
        while(i<j){
            while(i+1<n && a[++i]<a[left]);/*左指针右移 指向大于基数的数据停止*/
            while(j-1>-1 && a[--j]>a[left]);/*右指针左移 指向小于基数的数据停止*/
            if(i<j)/*满足左指针小于右指针的条件 两指针指向数据交换*/
                t=a[i],a[i]=a[j],a[j]=t;         
        }
        t=a[left],a[left]=a[j],a[j]=t;/*右指针指向数据与基数交换*/
        QuickSort(a,n,left,j-1);/*左边数据递归*/
        QuickSort(a,n,j+1,right);/*右边数据递归*/
    }
}

int main()
{
    int i,n, arr[20]={0};
    scanf("%d",&n);
    for(i=0; i<n; ++i)
        scanf("%d",&arr[i]);
    QuickSort(arr,n,0,n-1);
    for(i=0; i<n; ++i)        
        printf("%d ",arr[i]);         
    return 0;
}