bupt2024大一上计导一位数组练习_for(j=i-2;j>=0&& data[j>temp; j==])-优快云博客

本文链接：https://blog.youkuaiyun.com/sleepydeng/article/details/144619741

6-17 实验7_9_简单排序

分数 100

全屏浏览

切换布局

作者 scs

单位北京邮电大学

设计函数 void bubbleSort(int a[],int n);，实现对整型数组的排序。

输入第一行为一个整数n(0<n<=1000),代表待排序元素的个数。第二行是n个整数，每个整数都不会超过int型的存储范围，为待排序元素。

输出只有一行，为输入的n个待排序元素按从小到大排序后的结果。（建议采用起泡排序算法）

建议设计一个辅助函数:

函数功能：依次输出数组中各个元素，数与数之间用空格分开，最后一个数后没有空格而是换行符

参数说明：数组名，数组内元素个数

void outputData(int data[],int elementCount) ;

注：此题大家可以练习各种排序算法。

函数接口定义：

函数原型如下：
void bubbleSort(int a[],int n);
辅助函数原型：
void outputData(int data[],int elementCount) ;

其中 a 和 n 都是用户传入的参数。 n 是大于0且小于等于1000的整数，代表待排序元素的个数； a 是待排序数组。

辅助函数原型：
其中 data 和 elementCount 都是用户传入的参数。 elementCount 是大于0且小于等于1000的整数，代表元素的个数； data 是待输出的数组。

裁判测试程序样例：

设计了辅助函数后，函数被调用的例子如下：
#include<stdio.h>

void bubbleSort(int a[],int n);

//输出数组中所有元素 
void outputData(int data[],int elementCount) ;

int main()
{
    int        n , i,    num[10010] ;
    
    scanf("%d",&n); 
    for( i = 0 ; i < n ; i++ ) 
        scanf("%d",&num[i]) ;
    bubbleSort(num,n) ; 
    outputData(num,n) ;
    return 0 ;
}


/* 请在这里填写答案 */

输入样例：

8
49 38 65 97 76 13 27 4

输出样例：

4 13 27 38 49 65 76 97

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

void bubbleSort(int a[], int n)
{
    int temp, i, j;
    for(i = 1; i <= n-1 ; i++)
    {
        temp = a[i];
        for(j = i - 1; j >= 0&&a[j] > temp; j--)
        {
            a[j + 1] = a[j];
        }
        a[j + 1] = temp;
    }
}

void outputData(int date[], int elementCount)
{
    for(int i = 0; i < elementCount - 1; i++)
    {
        printf("%d ", date[i]);
    }
    printf("%d\n", date[elementCount-1]);
}

6-18 实验7_10_发子弹

分数 100

全屏浏览

切换布局

作者 scs

单位北京邮电大学

在某次实弹射击训练中，班长让战士们围成一圈发子弹。首先，班长给每个人发若干发子弹，然后按如下方法将每个战士手中的子弹进行调整：所有的战士检查自己手中的子弹数，如果子弹数为奇数，则向班长再要一颗。然后每个战士再同时将自己手中的子弹分一半给下一个战士（最后一个战士将手中的子弹分一半给第1个战士)。这种调整会一直进行下去，直到所有战士手中的子弹数相等为止。现请你写一个函数模拟这个调整的过程。

函数接口定义：

void distribute(int * bullets , int size , int number ) ;

其中 bullets 、 size 和 number 都是用户传入的参数。 bullets 为指向一个int 型数组的指针，该数组中依次存储着每个战士手中的子弹数，每次调整后该数组仍然依次存储着每个战士手中的子弹数 ; size 是战士的总数； number为调整的次数。函数没有返回值。

裁判测试程序样例：


#include<stdio.h>

#define        LEN        100

//调整函数 
void distribute(int * bullets , int size , int number ) ;

int main()
{
    int        bullets[LEN] ;
    int        n , m , i ;    
         
    scanf("%d" , &n ) ;    //读入战士总数 
    for( i = 0 ; i < n ; i++ )
    {
        scanf("%d" , &bullets[i] ) ;//读入每个战士手中初始的子弹数 
    }
    scanf("%d" , &m ) ;//读入调整的次数（m>0) 
    distribute(bullets , n , m ) ;//调整 
    for( i = 0 ; i < n - 1 ; i++ )//输出调整后结果 
    {
        printf("%d " , bullets[i] ) ;
    }
    printf("%d\n" , bullets[i] ) ;
    
    return 0;    
}


/* 请在这里填写答案 */

输入样例：

10
10 2 8 22 16 4 10 6 14 20
1

输出样例：

15 6 5 15 19 10 7 8 10 17

void distribute(int*bullets, int size, int number)
{
    int i, j, temp;
    for(i = 0; i < number; i++)
    {
        temp = 0;
        for(j = 0; j < size; j++)
        {
            int a;
            if(bullets[j]%2!=0) bullets[j]++;
            a = bullets[j]/2;
            bullets[j] = bullets[j]/2 + temp;
            temp = a;
        }
        if(j == size)
        {
            bullets[0] += temp;
        }
    }
}

6-19 实验7_12_插入排序

分数 100

全屏浏览

切换布局

作者 scs

单位北京邮电大学

设计函数 void InsertSort(int a[],int n); 该函数使用插入排序算法，将数组a的前n个元素按照升序的方式排序。

插入排序算法描述如下：

初始序列：49 38 65 97 76 13 27 49

将元素(38) 插入合适位置： [38 49] 65 97 76 13 27 49

将元素(65) 插入合适位置： [38 49 65] 97 76 13 27 49

将元素(97) 插入合适位置： [38 49 65 97] 76 13 27 49

将元素(76) 插入合适位置： [38 49 65 76 97] 13 27 49

将元素(13) 插入合适位置： [13 38 49 65 76 97] 27 49

将元素(27) 插入合适位置： [13 27 38 49 65 76 97] 49

将元素(49) 插入合适位置： [13 27 38 49 49 65 76 97]

输入与输出要求：
首先输入一个整数n（1<=n<=1000），代表待排序元素的个数。然后输入n个整数，每个整数不会超过int型的存储范围。

输出为n-1行，依次为1到n-1趟排序后数组内各个元素。每行输出的顺序为a[0]至a[n-1]，数与数之间用空格分开，注意第n个数后没有空格而是换行符。

函数接口定义：

函数原型如下：
void InsertSort(int a[],int n);

其中 a 和 n 都是用户传入的参数。 a 为待排序数组； n 需排序的元素的个数。函数没有返回值。

裁判测试程序样例：

函数被调用的例子如下：
#include<stdio.h>

//插入排序（升序） 
//参数说明：数组，数组中已有元素个数 
void InsertSort(int a[],int n);

int main()
{
    int        n , i,    num[1000] ;
    
    scanf( "%d" , &n ); 
    for( i = 0 ; i < n ; i++ ) 
        scanf( "%d", &num[i] ) ;
    InsertSort( num , n ) ; 
    return 0 ;
}

/* 请在这里填写答案 */

输入样例：

8
49 38 65 97 76 13 27 49

输出样例：

在这里给出相应的输出。例如：

38 49 65 97 76 13 27 49
38 49 65 97 76 13 27 49
38 49 65 97 76 13 27 49
38 49 65 76 97 13 27 49
13 38 49 65 76 97 27 49
13 27 38 49 65 76 97 49
13 27 38 49 49 65 76 97

代码长度限制

16 KB

时间限制

400 ms

内存限制

64MB

void InsertSort(int a[], int n)
{
    int i , j ,temp;
    for(i = 1; i < n; i++)
    {
        temp = a[i];
        for(j = i - 1; j >= 0&&a[j] > temp; j--)
        {
            a[j+1] = a[j];
        }
        a[j+1] = temp;
        for(int m = 0; m < n; m++)
        {
            if(m == n - 1) printf("%d\n", a[m]);
            else printf("%d ", a[m]);
        }
    }
}

6-20 实验7_11_循环移位

分数 100

全屏浏览

切换布局

作者 scs

单位北京邮电大学

设计函数void shift(int *array , int num , int size ) ;，实现将整型数组内元素循环向左移若干位置。循环向左移位含义如下：

比如，原始数组a[0],a[1]...a[9]内元素依次为：1 2 3 4 5 6 7 8 9 10，循环向左移1位后，则a[0],a[1]...a[9]内元素依次为：2 3 4 5 6 7 8 9 10 1，循环向左移2位后，则a[0],a[1]...a[9]内元素依次为：3 4 5 6 7 8 9 10 1 2。依次类推。

补充说明：本题测试用例中并没有num >= size的情况，大家也可以想一想，如果有这种情况，算法应该如何实现，与没有时是否一样。

函数接口定义：

void shift(int *array , int num , int size ) ;

其中 array 、 num和 size 都是用户传入的参数。 array 为指向原始数组的指针； num 为向左移的位数；size 为数组的大小。函数没有返回值。

裁判测试程序样例：


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

void shift(int *array , int num , int size ) ;

int main()
{
    int        i , n , p , array[100] ;
    
    scanf(" %d%d" , &n , &p ) ;//测试用例保证0<p<n<=100
    for( i = 0 ; i < n ; i++ )
        scanf( "%d" , &array[i] ) ;//测试用例保证所有输入可以用整型存储

    shift( array , p , n ) ;//向左移p位
    for( i = 0 ; i < n - 1 ; i++ )
        printf( "%d " , array[i] ) ;
    printf( "%d\n" , array[i] ) ;
        
    return 0;    
}

/* 请在这里填写答案 */

输入样例：

10 1
1 2 3 4 5 6 7 8 9 10

输出样例：

2 3 4 5 6 7 8 9 10 1

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

void shift(int *array , int num , int size )
{
    for(int i = 0; i < num; i++)
    {
        int temp = array[0];
        for(int j = 0; j < (size - 1); j++)
        {
            array[j] = array[j + 1];
        }
        array[size - 1] = temp;
    }
}

6-21 实验7_13_选择排序

分数 100

全屏浏览

切换布局

作者 scs

单位北京邮电大学

设计函数 void SelectSort(int a[],int n); 使用选择排序算法对数组a的前n个元素按照升序的方式排序。

选择排序算法描述如下：
从a[0]到a[n-1]这段元素中找最小元素a[min]，a[0]和a[min]交换；接着，从a[1]到a[n -1]这段元素中找最小元素a[min]，a[1]和a[min]交换；依次类推，直到从a[n－2]到a[n -1]这段元素中找最小元素a[min]，a[n－2]和a[min]交换。

输入：首先输入一个整数n(1<n<=1000)，代表待排序元素的个数。然后是n个整数，每个整数不会超过int型的存储范围

输出为n-1行，依次为1到n-1趟排序后数组内各个元素。每行输出的顺序为a[0]至a[n-1]，数与数之间用空格分开，注意第n个数后没有空格而是换行符。

建议设计两个辅助函数:

函数功能：找数组中的最小值元素，并返回其下标

参数说明：数组名，查找起始位置下标，查找终止位置下标

int findMin(int data[], int startLoc, int endLoc) ;

函数功能：依次输出数组中各个元素，数与数之间用空格分开，最后一个数后没有空格而是换行符

参数说明：数组名，数组内元素个数

void outputData(int data[],int elementCount) ;

函数接口定义：

三个函数原型如下：

//选择排序（升序） 
//参数说明：数组，数组中已有元素个数 
void selectSort(int data[],int elementCount) ;

//函数功能：找数组中的最小值元素，并返回其下标 
//参数说明：数组名，查找起始位置下标，查找终止位置下标
int findMin(int data[], int startLoc, int endLoc) ; 

//输出数组中所有元素 
//参数说明：数组，数组中已有元素个数 
void outputData(int data[],int elementCount) ;

裁判测试程序样例：

函数被调用的例子如下：

#include<stdio.h>

//选择排序（升序） 
//参数说明：数组，数组中已有元素个数 
void selectSort(int data[],int elementCount) ;

//函数功能：找数组中的最小值元素，并返回其下标 
//参数说明：数组名，查找起始位置下标，查找终止位置下标
int findMin(int data[], int startLoc, int endLoc) ; 

//输出数组中所有元素 
//参数说明：数组，数组中已有元素个数 
void outputData(int data[],int elementCount) ;

int main()
{
    int        n , i,    num[1010] ;
    
    scanf("%d",&n); 
    for( i = 0 ; i < n ; i++ ) 
        scanf("%d",&num[i]) ;
    selectSort(num,n) ; 
    return 0 ;
}

/* 请在这里填写答案 */

输入样例：

在这里给出一组输入。例如：

8
49 38 65 97 76 13 27 4

输出样例：

在这里给出相应的输出。例如：

4 38 65 97 76 13 27 49
4 13 65 97 76 38 27 49
4 13 27 97 76 38 65 49
4 13 27 38 76 97 65 49
4 13 27 38 49 97 65 76
4 13 27 38 49 65 97 76
4 13 27 38 49 65 76 97

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

void selectSort(int data[], int elementCount)
{
    int i, j ,temp, min;
    for(i = 0; i < (elementCount - 1); i++)
    {
        min = i;
        for(j = i; j < elementCount; j++)
        {
            if(data[j] < data[min]) min = j;
        }
        if(i != min)
        {
            temp = data[i];
            data[i] = data[min];
            data[min] = temp;
        }
        for(int a = 0; a < elementCount; a++)
        {
            if(a == (elementCount - 1))
            {
                printf("%d\n", data[a]);
            }
            else
            {
                printf("%d ", data[a]);
            }
        }
    }
}

6-22 实验7_14_二分查找

分数 100

全屏浏览

切换布局

作者 scs

单位北京邮电大学

设计函数 int BinarySearch(int a[],int n,int key);

利用二分查找算法，在升序排列的数组a的前n个元素中查找值为key的数组元素的下标。如果数组a中存在整数key，则返回下标；否则返回－1。假设数组a中的元素互不相同。

输入与输出要求：

首先输入两个整数n，m，分别代表数组a中元素的个数与需要查找的整数的个数，n（0<n<=2000000）与m(0<m<=100000)。然后分别输入n个整数和m个整数，分别代表存放在数组中的数以及要查找的数。

输出m个整数，分别为要查找的数在数组a中的下标，如果数组a中不存在某个数，则输出-1。数与数之间用空格分开，注意第n个数后没有空格而是换行符。

函数接口定义：

int BinarySearch(int a[],int n,int key) ;

其中 a 、 n和 key 都是用户传入的参数。 a被查找的数组； n 是数组长度； key 是要查找的元素。如果找到，则返回该元素在数组中的下标，否则返回-1。

裁判测试程序样例：

#include<stdio.h>

//函数功能：二分查找
//函数参数：分别为被查找的数组，数组长度，所查找的元素
//函数返回值：如果找到，则返回该元素在数组中的下标，否则返回-1 
int BinarySearch(int a[],int n,int key) ; 

int main()
{
    int    num[2000000] ; //这个数组比较大，如果在你的电脑中无法分配这么大的内存，请改小后测试。
    int        n , m, i;    
    int        key ;
    
    scanf("%d%d",&n,&m); 
    for( i = 0 ; i < n ; i++ ) 
        scanf("%d",&num[i]) ;
        
    for( i = 0 ; i < m ; i++ ) 
    {
        scanf("%d",&key) ;
        printf("%d",BinarySearch(num,n,key)) ;
        if ( i != m - 1 ) printf(" ") ;
        else printf("\n") ;
    }
    return 0 ;
}


/* 请在这里填写答案 */

输入样例：

15
20
-293 -213 -23 0 1 5 11 23 56 67 87 273 999 2132 10000
-23 -99999 0 999 953 67 56 44 33 87 -293 23 11 273 -213 2132 10000 87654 1 5

输出样例：

2 -1 3 12 -1 9 8 -1 -1 10 0 7 6 11 1 13 14 -1 4 5

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

int BinarySearch(int a[], int n, int key)
{
    int i, j, m;
    for(i = 0, j = (n - 1); i <= j;)
    {
        m = (i + j)/2;
        if(a[m] == key) return m;
        else if(a[m] < key) i = m + 1;
        else j = m - 1;
    }
    return -1;
}

6-23 实验7_15_二分查找递归实现

分数 100

全屏浏览

切换布局

作者 scs

单位北京邮电大学

设计递归函数 int RecurBinarySearch( int a[] , int key , int left , int right ) ; 利用二分查找算法，在升序排列的数组中查找值为key的数组元素的下标。如果数组中存在整数key，则返回下标；否则返回-1。假设数组a中的元素互不相同。

输入与输出要求：

输出为m个整数，分别为要查找的数在数组a中的下标，如果数组a中不存在某个数，则输出-1。数与数之间用空格分开，注意第m个数后没有空格而是换行符。

注意：此题要求递归求解，且算法为二分查找，否则不得分。

函数接口定义：

int RecurBinarySearch( int a[] , int key , int left , int right ) ;

其中 a 、 key 、left 和 right 都是用户传入的参数。 a 为元素升序排列的整型数组； key 待查找元素；left 和 right 分别为查找范围的左右边界。如果数组中存在整数 key，则返回下标；否则返回-1。

裁判测试程序样例：

#include<stdio.h>

#define MAXN 2000000

int RecurBinarySearch( int a[] , int key , int left , int right ) ;

int main()
{
    int        a[MAXN];//这个数组比较大，如果在你的电脑中无法分配这么大的内存，请改小后测试。
    int        n , m , i , key ;
    
    scanf("%d %d",&n , &m );    
    for( i = 0 ; i < n ; i++ )
        scanf("%d", &a[i]);
        
    for( i =0 ; i < m ; i++ )
    {
        scanf("%d",&key);
        printf( "%d" , RecurBinarySearch( a , key , 0 , n - 1 ) );
        if ( i != m - 1 ) printf(" ") ;
        else printf("\n") ; 
    }

    return 0;
}

/* 请在这里填写答案 */

输入样例：

15 
20
-293 -213 -23 0 1 5 11 23 56 67 87 273 999 2132 10000
-23 -99999 0 999 953 67 56 44 33 87 -293 23 11 273 -213 2132 10000 87654 1 5

输出样例：

2 -1 3 12 -1 9 8 -1 -1 10 0 7 6 11 1 13 14 -1 4 5

代码长度限制

16 KB

时间限制

2000 ms

内存限制

64 MB

int RecurBinarySearch(int a[], int key, int left, int right)
{
    int m;
    if(left <= right)
    {
        m = (right + left)/2;
        if(a[m] == key) return m;
        else if(a[m] < key) return RecurBinarySearch(a, key, m+1, right);
        else return RecurBinarySearch(a, key, left, m-1);
    }
    else return -1;
}

7-36 实验7_1_平均成绩

分数 100

全屏浏览

切换布局

作者 scs

单位北京邮电大学

已知某个学生n门课的成绩,求平均成绩。

输入格式:

共两行，第一行为一个整数n，代表课程数，n不会超过100。第二行为n个用空格分隔的整数，代表该学生的n门课成绩，每门成绩的取值范围是0-100。要求这n个成绩必须使用数组存储。

输出格式:

只有一行，为该同学的平均成绩，保留两位小数。为了提高精度，求出的平均成绩建议使用double类型存储。

输入样例:

5
80 75 67 90 97

输出样例:

81.80

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

#include <stdio.h>

int main()
{
    int n;
    scanf("%d", &n);

    double a[100];
    for(int i = 0; i < n; i++)
    {
        scanf("%lf", &a[i]);
    }

    double sum = 0;
    for(int i = 0; i < n; i++)
    {
        sum += a[i];
    }
    double res = sum / (n * 1.0);
    printf("%.2lf", res);
    return 0;
}

7-37 实验7_2_数组查找

分数 100

全屏浏览

切换布局

作者 scs

单位北京邮电大学

有n个互不相同的整数，存储在数组中。在这n个整数中查找m个整数，如果存在，则打印出与之相邻的整数；否则就显示无此数。

输入格式:

共4行，第一行为一个整数n（0<n<=1000），第二行为用空格分隔的n个整数。第三行为一个整数 m(0<m<=100)，代表查询次数。第四行为用空格分隔的m个整数。测试用例保证所有整数可以用int存储。

输出格式:

共m行，依次对应输入m次查询结果，每次的查询结果中可能有一个数、两个数或没有数。若没有数则输出“NULL”。具体见样例。

输入样例:

5
89 7890 22 56 87
6
89 7890 22 56 87 999

输出样例:

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

#include <stdio.h>

int findEle(int a[], int n, int x)
{
    int i;
    for (i = 0; i < n && a[i]!= x; i++)
    {
    }
    if (i >= n)
        return -1;
    else
        return i;
}

int main()
{
    int n;
    scanf("%d", &n);

    int a[1000];
    int key[100];

    for(int i = 0; i < n; i++)
    {
        scanf("%d", &a[i]);
    }

    int m;
    scanf("%d", &m);
    for(int i = 0; i < m; i++)
    {
        scanf("%d", &key[i]);
    }

    for(int i = 0; i < m; i++)
    {
        int x = key[i];
        int ele = findEle(a, n, x);
        if(ele == -1) printf("NULL\n");
        else if(ele == 0)
        {
            if(n == 1) printf("NULL\n");
            else
            printf("%d\n", a[1]);
        }
        else if(ele == (n - 1)) printf("%d\n", a[n - 2]);
        else printf("%d %d\n", a[ele - 1], a[ele + 1]);
    }
    return 0;
}

7-38 实验7_3_奇数偶数

分数 100

全屏浏览

切换布局

作者 scs

单位北京邮电大学

已知一个长度为n的整数数组，在保证原顺序的前提下，将该数组中所有的偶数放到所有的奇数之前，存到一个新数组中，并将新数组输出。

输入格式:

共2行，第一行为一个整数n(0<n<=200)，代表输入整数个数，第二行为n个用空格分隔的整数，需保存在待处理数组中。测试用例保证所有整数可以用int存储。

输出格式:

只有一行，为新数组中的元素，数与数之间用一个空格分隔，第n个数后是换行符。

输入样例:

10
3 9 4 5 8 7 10 2 6 1

输出样例:

4 8 10 2 6 3 9 5 7 1

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

#include <stdio.h>

int main()
{
    int n;
    scanf("%d", &n);

    int a[200];
    int b[200];
    int num = 0;
    for(int i = 0; i < n; i++)
    {
        scanf("%d", &a[i]);
        if(a[i]%2 == 0)
        {
            b[num] = a[i];
            num++;
        }
    }

    for(int j = 0; j < n; j++)
    {
        if(a[j]%2 == 1)
        {
            b[num] = a[j];
            num++;
        }
    }

    int i;
    for(i = 0; i < num-1; i++)
    {
        printf("%d ", b[i]);
    }
    printf("%d\n", b[i]);
    
    return 0;
}

7-39 实验7_4_向量的内积

分数 100

全屏浏览

切换布局

作者 scs

单位北京邮电大学

请写程序计算并输出向量的内积。

输入格式:

共两行，第一行一个整数n，1<=n<=10，第二行2Xn个整数（以空格分隔），即两个长度为n的一维数组（向量）。

输出格式:

只有一个整数，为计算结果。测试用例保证所有整数（包括计算过程中的）可以用int存储。

输入样例:

3
1 2 3 4 5 6

输出样例:

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

#include <stdio.h>

int main()
{
    int n;
    scanf("%d", &n);

    int a[20];
    for(int i = 0; i <= 2*n-1; i++)
    {
        scanf("%d", &a[i]);
    }

    int sum = 0;
    for(int j = 0; j < n; j++)
    {
        sum += a[j] * a[n + j];
    }
    printf("%d\n", sum);

    return 0;
}

7-40 实验7_5_发工资

分数 100

全屏浏览

切换布局

作者 scs

单位北京邮电大学

每到月底，公司就要给员工发工资。每个员工的工资都是由（100，50，20，10，5，2，1) 7种面值的钞票组成的。为了发工资的简便，公司会尽量给员工发较大面值的钞票，例如某个员工的工资为1260，那么公司会给员工12张100元的、1张50元的、1张10的钞票。你的任务是，告诉你某员工的工资，你来计算如何给员工发工资。

输入格式:

为一个正整数n（可以用int存储），代表某位员工的工资。

输出格式:

为给该员工发的钞票面值与数量。具体格式见样例。

输入样例:

输出样例:

100:23
50:1
2:1

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

#include <stdio.h>

int main()
{
    int n;
    scanf("%d", &n);

    int money[7];

    money[0] = n/100;
    if(money[0] != 0)
    {
        n %= 100;
        printf("100:%d\n", money[0]);
    }
    money[1] = n/50;
    if(money[1] != 0)
    {
        n %= 50;
        printf("50:%d\n", money[1]);
    }
    money[2] = n/20;
    if(money[2] != 0)
    {
        printf("20:%d\n", money[2]);
        n %= 20;
    }
    money[3] = n/10;
    if(money[3] != 0)
    {
        n %= 10;
        printf("10:%d\n", money[3]);
    }
    money[4] = n/5;
    if(money[4]!=0)
    {
        n %= 5;
        printf("5:%d\n", money[4]);
    }
    money[5] = n/2;
    if(money[5] != 0)
    {
        n %= 2;
        printf("2:%d\n", money[5]);
    }
    money[6] = n/1;
    if(money[6] != 0)
        printf("1:%d", money[6]);

    return 0;
}

7-41 实验7_6_数组交换

分数 100

全屏浏览

切换布局

作者 scs

单位北京邮电大学

设有整数数组A和B，它们长度均为n。A数组中的元素为任意整数，不超过int型数据范围。B数组中元素的值互不相同，且取值介于0至n-1之间。现要求按数组B的内容调整A中数据的次序，比如当B[0]=9时，则要求将A[0]的内容与A[9]互换。

输入格式:

首先输入一个整数n（0<n<=10），代表数组A、B元素的个数。然后输入n个整数代表数组A中的元素。最后输入 n个整数代表数组B中的元素，注意B中元素的要求。测试用例保证所有整数可以用int存储。

输出格式:

调整后A数组的内容，数与数之间用空格分开，注意第n个数后没有空格而是换行符。

输入样例:

10
5 10 3 9 4 12 8 7 11 2
1 3 6 9 2 7 0 8 5 4

输出样例:

3 9 4 2 5 12 10 11 7 8

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

#include <stdio.h>

int main()
{
    int n;
    scanf("%d", &n);

    int a[10], b[10];
    for(int i = 0; i < n; i++)
    {
        scanf("%d", &a[i]);
    }
    for(int j = 0; j < n; j++)
    {
        scanf("%d", &b[j]);
    }

    for(int i = 0; i < n; i++)
    {
        int m = b[i];
        int temp = a[i];
        a[i] = a[m];
        a[m] = temp;
    }

    for(int j = 0; j < n-1; j++)
    {
        printf("%d ", a[j]);
    }
    printf("%d\n", a[n-1]);

    return 0;
}

7-42 实验7_7_连续子序列

分数 100

全屏浏览

切换布局

作者 scs

单位北京邮电大学

已知两个由正整数组成的无序序列A、B，每个序列的元素个数未知，但至少有一个元素。你的任务是判断序列B是否是序列A的连续子序列。假设B是“1 9 2 4 18”，A是“33 64 1 9 2 4 18 7”，B是A的连续子序列；假设B是“1 9 2 4 18”，A是“33 1 9 64 2 4 18 7”，B不是A的连续子序列。

输入格式:

依次输入两个乱序的正整数序列A、B，序列中元素个数未知，但每个序列至少有一个元素，并以输入“-1”结束（-1不算序列中元素），每个序列占一行。两个数列的长度均不超过1000。

输入保证合法，且所有整数均可用int存储。

输出格式:

如果序列B是序列A的连续子序列，则输出“ListB is the sub sequence of ListA.”，否则输出“ListB is not the sub sequence of ListA.”。

输入样例:

5 4 3 2 1 -1
3 2 1 -1

输出样例:

ListB is the sub sequence of ListA.

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

#include<stdio.h>
int main()
{
	int a[1000],b[1000],c[1000];
	int m=-1,n=-1;
	int i;
	int k=0,d=1;
	while(a[m]!=-1)
	{
		m++;
		scanf("%d",&a[m]);
	}
	while(b[n]!=-1)
	{
		n++;
		scanf("%d",&b[n]);
	}
    
	for(i=0;i<m;i++)
	{
		if(a[i]==b[0])
		{
			c[k]=i;
			k++;
		}
		
	}
	while(k!=0)
	{
		d=0;
		k--;
		for(i=0;i<n;i++)
		{
			if(a[c[k]+i]!=b[i])
			d++;
		}
		if(d==0)
		break;
	}
	if(d==0)
	printf("ListB is the sub sequence of ListA.\n");
	else
	printf("ListB is not the sub sequence of ListA.\n");
	return 0;
}

7-43 实验7_8_最长平台

分数 100

全屏浏览

切换布局

作者 scs

单位北京邮电大学

给定一个长度为n的整数数组，数组中连续的相等元素构成的子序列称为平台。试设计算法，求出数组中最长平台的长度。

输入格式:

共2行，第一行为一个整数n(0<n<=1000)，代表输入整数个数，第二行为n个用空格分隔的整数。测试用例保证所有整数可以用int存储。

输出格式:

只有一行，为一个整数，代表输入数组的最长平台长度。

输入样例:

15
1 1 2 2 4 5 7 7 7 7 7 7 3 3 9

输出样例:

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

#include <stdio.h>

int main()
{
    int n;
    scanf("%d", &n);

    int a[1000];
    for(int i = 0; i < n; i++)
    {
        scanf("%d", &a[i]);
    }

    int k = 0, m = 0;
    int b[1000];
    for(int j = 0; j <= n-1; j++)
    {
        if(a[j] == a[j + 1]) k++;
        else
        {
            b[m] = k+1;
            m++;
            k = 0;
        }
    }

    int max = b[0];
    for(int i = 1; i < m; i++)
    {
        if(max < b[i]) max = b[i];
    }

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

    return 0;
}