C++入门练习（1）

题目收集自Coursera《程序设计与算法》课程作业题。

题目

晶晶赴约会

奇数求和

苹果和虫子

大象喝水

整数的个数

1的个数

最高的分数

最大奇数与最小偶数之差的绝对值

分离整数的各个数位

数组逆序重放

奇偶排序

实现冒泡排序

---

晶晶赴约会

注意： 总时间限制: 1000ms 内存限制: 65536kB

描述

晶晶的朋友贝贝约晶晶下周一起去看展览，但晶晶每周的1、3、5有课必须上课，请帮晶晶判断她能否接受贝贝的邀请，如果能输出YES；如果不能则输出NO。

输入

输入有一行，贝贝邀请晶晶去看展览的日期，用数字1到7表示从星期一到星期日。

输出

输出有一行，如果晶晶可以接受贝贝的邀请，输出YES，否则，输出NO。注意YES和NO都是大写字母！

样例输入：

第一组
1
第二组
2
第三组
3

样例输出：

第一组
NO
第二组
YES
第三组
NO

参考答案：

#include 
using namespace std;
int main() {
    int a;
    cin >> a;
    if (a == 1 || a == 3 || a == 5)
        cout << "NO" << endl;
    else
        cout << "YES" << endl;
    return 0;
}

奇数求和

注意： 总时间限制: 1000ms 内存限制: 65536kB

描述

计算正整数 m 到 n（包括m 和 n ）之间的所有奇数的和，其中，m 不大于 n，且n 不大于300。例如 m=3, n=12, 其和则为：3+5+7+9+11=35

输入

两个数 m 和 n，两个数以空格间隔，其中 0<=m <= n <= 300 。

输出

奇数之和

样例输入

第一组
7 15
第二组
0 1
第三组
3 3
第四组
100 100

样例输出

第一组
55
第二组
1
第三组
3
第四组
0

参考答案

#include 
using namespace std;
int main() {
    int m, n, result = 0;
    cin >> m >> n;
    while (m <= n) {
        //对于m和n之间的每一个数， 如果它是奇数，那么就加入到我们的结果里。如果不是就跳过。
        if (m % 2 == 1)
            result += m;
        m++;
    }
    //最后输出
    cout << result << endl;
    return 0;
}
//其实还有更快的算法你能想到吗？

苹果和虫子

注意： 总时间限制: 1000ms 内存限制: 65536kB

描述

你买了一箱n个苹果，很不幸的是买完时箱子里混进了一条虫子。虫子每x小时能吃掉一个苹果，假设虫子在吃完一个苹果之前不会吃另一个，那么经过y小时你还有多少个完整的苹果？

输入

输入仅一行，包括n，x和y（均为整数）。

输出

输出也仅一行，剩下的苹果个数

样例输入

第一组
10 4 9
第二组
10 4 36
第三组
10 4 100

样例输出

第一组
7
第二组
1
第三组
0

参考答案

#include 
using namespace std;

int main(){
	int n = 0, x = 0, y = 0;
	cin >> n >> x >> y;
	if (y / x >= n)
		cout << 0 << endl;
	else if (y % x == 0)
		cout << n - y / x << endl;
	else
		cout << n - y / x - 1 << endl;
        return 0;
}

大象喝水

注意： 总时间限制: 1000ms 内存限制: 65536kB

描述

一只大象口渴了，要喝20升水才能解渴，但现在只有一个深h厘米，底面半径为r厘米的小圆桶(h和r都是整数)。问大象至少要喝多少桶水才会解渴。

输入

输入有一行：包行两个整数，以一个空格分开，分别表示小圆桶的深h和底面半径r，单位都是厘米。

输出

输出一行，包含一个整数，表示大象至少要喝水的桶数。

提示

如果一个圆桶的深为h厘米，底面半径为r厘米，那么它最多能装Pi * r * r * h立方厘米的水。(设Pi=3.14159)

1升 = 1000毫升

1毫升 = 1 立方厘米

样例输入

第一组
23 11
第二组
1 1

样例输出

第一组
3
第二组
6367

参考答案

#include 
using namespace std;

int main(){
	int h = 0, r = 0;
	float cap = 0;
	cin >> h >> r;
	cap = 3.14159 * r*r*h;
	cout << (int)(20000 / cap) + 1 << endl;
        return 0;
}

整数的个数

注意： 总时间限制: 1000ms 内存限制: 65536kB

描述

给定k（1

输入

输入有两行：第一行包含一个正整数k，第二行包含k个正整数，每两个正整数用一个空格分开。

输出

输出有三行，第一行为1出现的次数，，第二行为5出现的次数，第三行为10出现的次数。

样例输入

第一组
5
1 5 8 10 5
第二组
5
2 2 2 2 2

样例输出

第一组
1
2
1
第二组
0
0
0

参考答案

#include 
using namespace std;
int main(){
    int k;
    cin>>k;
    int n1=0, n5=0, n10=0;
    for (int i=0;i>n;
        if (n == 1) n1++;
        else if (n == 5) n5++;
        else if (n == 10) n10++;
    }
    cout<

1的个数

注意： 总时间限制: 1000ms 内存限制: 65536kB

描述

给定一个十进制整数N，求其对应2进制数中1的个数

输入

第一个整数表示有N组测试数据，其后N行是对应的测试数据，每行为一个整数。

输出

N行，每行输出对应一个输入。

样例输入

5
2
100
1000
66
0

样例输出

1
3
6
2
0

参考答案

# include 
using namespace std;

int main() {
    int n;
    cin >> n;
    for (int i = 0; i < n; i++) {
        int x, ans = 0;
        cin >> x;
        while (x > 0) {
            ans += x % 2;
            x /= 2;
        }
        cout << ans << endl;
    }
    return 0;
}
//这道题的解法就是反复地除以2，看最低位是1还是0。有些知道位运算的同学喜欢用位运算，但其实没必要，因为编译器优化之后的程序其实效率是一样的。

最高的分数

注意： 总时间限制: 1000ms 内存限制: 65536kB

描述

孙老师讲授的《计算概论》这门课期中考试刚刚结束，他想知道考试中取得的最高分数。因为人数比较多，他觉得这件事情交给计算机来做比较方便。你能帮孙老师解决这个问题吗？

输入

输入两行，第一行为整数n（1 <= n < 100），表示参加这次考试的人数.第二行是这n个学生的成绩，相邻两个数之间用单个空格隔开。所有成绩均为0到100之间的整数。

输出

输出一个整数，即最高的成绩。

样例输入

5
85 78 90 99 60

样例输出

99

参考答案

# include 
using namespace std;

int main() {
        int n = 0, score[100] = { 0 }, max = 0;
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> score[i];
	}
	max = score[0];
	for (int i = 1; i < n; i++) {
		if (max < score[i])
			max = score[i];
	}
	cout << max << endl;
        return 0;
}

最大奇数与最小偶数之差的绝对值

注意： 总时间限制: 1000ms 内存限制: 65536kB

描述

输入6个正整数，且这6个正整数中至少存在一个奇数和一个偶数。

设这6个正整数中最大的奇数为a，最小的偶数为b，求出|a-b|的值

输入

输入为一行，6个正整数,且6个正整数都小于100

输入保证这6个数中至少存在一个奇数和一个偶数

输出

输出为一行，输出最大的奇数与最小的偶数之差的绝对值

样例输入

第一组
1 2 3 4 5 6
第二组
1 6 3 8 5 10

样例输出

第一组
3
第二组
1

参考答案

#include 
using namespace std;

int main(){
        int nums[6] = { 0 };
	int maxOdd = 0, minEven = 100;
	for (int i = 0; i < 6; i++) {
		cin >> nums[i];
		if (nums[i] % 2 == 0 && nums[i] < minEven)
			minEven = nums[i];
		else if (nums[i] % 2 == 1 && nums[i] > maxOdd)
			maxOdd = nums[i];
	}
	cout << (maxOdd > minEven ? (maxOdd - minEven) : (minEven - maxOdd));*/
        return 0;
}

 

分离整数的各个数位

注意： 总时间限制: 1000ms 内存限制: 65536kB

描述

从键盘输入一个任意的三位整数，要求正确地分离出它的百位、十位和个位数，并分别在屏幕上输出，输出采用每行输出一个数的方式，不带其它符号。

输入

一个任意的三位整数

输出

三位整数的每一位

样例输入

123

样例输出

1
2
3

参考答案

#include 
using namespace std;

int main(){
        int n = 0;
	cin >> n;
	for (int i = 2; i >= 0; i--) {
		int temp = 1;
		for (int j = 0; j < i; j++)
			temp *= 10;
		cout << n / temp << endl;
		n %= temp;
	}
        return 0;
}

 

数组逆序重放

注意： 总时间限制: 1000ms 内存限制: 65536kB

描述

将一个数组中的值按逆序重新存放。例如，原来的顺序为8,6,5,4,1。要求改为1,4,5,6,8。

输入

输入为两行：第一行数组中元素的个数n（1

输出

输出为一行：输出逆序后数组的整数，每两个整数之间用空格分隔。

样例输入

5
8 6 5 4 1

样例输出

1 4 5 6 8

参考答案

#include 
using namespace std;
int a[100];
int main() {
    int n;
    cin >> n;
    for (int i = 0; i> a[i];
    while (n--) { //常用的倒序计数循环，等价于while(n-->0)
        cout << a[n];
        if (n > 0) cout << " "; //如果不是最后一个数那么就要用空格分隔开
    }
    return 0;
}
//顺序输入倒序输出，但是如果我们要求通过修改数组本身实现逆序重放应该怎么做呢？

 

奇偶排序

注意： 总时间限制: 1000ms 内存限制: 65536kB

描述

输入十个整数，将十个整数按升序排列输出，并且奇数在前，偶数在后。

输入：输入十个整数

输出：按照奇偶排序好的十个整数

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

样例输出：1 3 5 7 9 2 4 6 8 10

参考答案：

方法一

#include 
    using namespace std;
    
    int main() {
      int a[10];
      for (int i = 0; i < 10; i++) {
        cin >> a[i];
      }
      // 首先，我们把奇数放到数组左边，偶数放到数组右边
      int l = 0, r = 9; //用左手和右手分别指向数组两端
      while (l <= r) {
        bool leftIsOdd = a[l] % 2 == 1;
        bool rightIsEven = a[r] % 2 == 0;
        if (leftIsOdd) {
          l++;
        } else if (rightIsEven) {
          r--;
        } else if (!leftIsOdd && !rightIsEven) {
          int temp = a[l];
          a[l] = a[r];
          a[r] = temp;
        }
      }
      // 对l左边（奇数部分）冒泡，不断比较相邻的两个数，如果顺序错了，那么就交换
      int start = 0, end = l;
      for (int i = start; i < end - 1; i++) {
        for (int j = start + 1; j < start + end - i; j++) {
          if (a[j - 1] > a[j]) {
            int temp = a[j];
            a[j] = a[j - 1];
            a[j - 1] = temp;
          }
        }
      }
      // 对l右边（偶数部分）冒泡，不断比较相邻的两个数，如果顺序错了，那么就交换
      start = l, end = 10;
      for (int i = start; i < end - 1; i++) {
        for (int j = start + 1; j < start + end - i; j++) {
          if (a[j - 1] > a[j]) {
            int temp = a[j];
            a[j] = a[j - 1];
            a[j - 1] = temp;
          }
        }
      }
      for (int i = 0; i < 10; i++) {
        cout << a[i] << ' ';
      }
      return 0;
    }

方法二：

 #include 
    using namespace std;
    
    int main() {
      int a[10];
      for (int i = 0; i < 10; i++) {
        cin >> a[i];
      }  
      // 冒泡，不断比较相邻的两个数，如果顺序错了，那么就交换
      for (int i = 0; i < 9; i++) {
        for (int j = 1; j < 10 - i; j++) {      
      // 与刚才的冒泡排序不同，我们不只是通过较数字的大小决定顺序
      // 如果左边的为偶数，右边的为奇数，那么顺序也需要颠倒
      bool leftIsEven = a[j - 1] % 2 == 0;
      bool rightIsEven = a[j] % 2 == 0;
      if ((leftIsEven && !rightIsEven) ||
          (leftIsEven == rightIsEven && a[j - 1] > a[j])) {        
        int temp = a[j];        
        a[j] = a[j - 1];
        a[j - 1] = temp;
      }
    }
  }  
  for (int i = 0; i < 10; i++) {
    cout << a[i] << ' ';
  }  
  return 0;
}

 

实现冒泡排序

注意： 总时间限制: 1000ms 内存限制: 65536kB

描述

请根据自己的理解编写冒泡排序算法，数组大小1000以内

输入：第一行是n，表示数组的大小，接着n行是数组的n个元素

输出：排序之后的结果，一个元素一行

参考答案：

    #include 
    using namespace std;

    int main() {
        int n, a[1000]; // 一共n个数，n不超过1000。a用来保存这些数
        cin >> n;  
        // 输入n个数  
        for (int i = 0; i < n; i++) {
          cin >> a[i];
    }  
    // 冒泡，不断比较相邻的两个数，如果顺序错了，那么就交换
    for (int i = 0; i < n - 1; i++) {
      for (int j = 1; j < n - i; j++) {      
        if (a[j - 1] > a[j]) {
          int temp = a[j];
          a[j] = a[j - 1];
          a[j - 1] = temp;
        }    
      }  
    }  
    // 依次输出
   for (int i = 0; i < n; i++) {
     cout << a[i] << endl;  
   }  
   return 0;
}