C语言上机题（基础）

坚持刷题，开心每一天！！！

1. 递归求n！(简单)

  给你一个数n，使用递归求n！

//递归求阶乘
int factorial(int n)
{
    if(n == 0) return 0;
    else if(n == 1) return 1;
    else return n * factorial(n-1);
} 

2. 几月几号 (简单)

  给你一个年份，还有一个数字 n，以 1 月 1 日为第一天，根据 n 的值来求出是几月几号。

void judge_date(int year, int n)
{
	int num = n,i;
	int arr_common_year[12] = {31,28,31,30,31,30,31,31,30,31,30,31};  //平年月份天数 
	int arr_leap_year[12] = {31,29,31,30,31,30,31,31,30,31,30,31};  //闰年月份天数 
	//年份能被4整除且不能被100整除 或 年份能被400整除则为闰年 
	if((year%4 == 0 & year%100 != 0) || year%400 == 0){
		for(i = 0;i < 12;i++){
			if(n > arr_leap_year[i]){
				n -= arr_leap_year[i];
			}
			else break;
		} 
		printf("在%d年的%d天是%d月%d号",year,num,i+1,n);
	}
	else{
		for(i = 0;i < 12;i++){
			if(n > arr_common_year[i]){
				n -= arr_common_year[i];
			}
			else break;
		} 
		printf("在%d年的%d天是%d月%d号",year,num,i+1,n);
	}
}

3. 数字排序去重 (简单)

  给你一串数字，排序并把排序后重复的数字只留下一个
  例如（3,5,5,2,1,4,6）–> (1,2,3,4,5,6)

//冒泡排序 
int bubble_sort(int arr[], int len)
{
	for(int i = 0;i < len; i++) {
		for(int j = 0;j < len-1-i; j++){
			if(arr[j] > arr[j+1]){
				int temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}
		}
	}
} 
//去重 
int delete_same(int arr[], int len)
{
	int b[len];
	int j = 1;
	b[0] = arr[0];
	for(int i = 1;i < len; i++){
		if(arr[i] != arr[i-1]){
			b[j] = arr[i];
			j++;
		}
	}
	//输出 
	for(int i = 0;i < j;i++){
		printf("%d ",b[i]);
	}
} 

4. 金字塔路径最大值 (简单)

  给你一个数 n，这是一个n层的金字塔，金字塔上面一个数字比它下面两个数字小。从顶层开始往下走，只能向下走相邻的两个数字，从第一层走到最下面一层，求其最大值
（金字塔的数据结构你要自己建），金子塔样子：

                                  3                  3
                                4   5                4  5
                              5   6   6      -->     5  6  6        
                            7  12   13  8            7  12 13 8     

int max_value(int arr[][10], int n)
{
	int max_res = arr[0][0];
	int j = 0;
	for(int i = 0;i < n;i++){
		if(arr[i+1][j] > arr[i+1][j+1]){ //找较大的相加 
			max_res += arr[i+1][j];
		}
		else{
			max_res += arr[i+1][j+1];
			j++;
		}
	}
	return max_res;
}

5. 插入/希尔/选择/冒泡/快速排序 (简单) 归并/堆排序 (中等)

  略，这里为大家介绍一篇博客文章，非常详细：
  十大经典排序算法 https://www.cnblogs.com/onepixel/articles/7674659.html
  之后我也会写一篇关于各种排序算法的博客，供大家学习！

6. 修路砍树 (简单)

  一坐标 x 轴表示某道路，从 0 开始到 L，整数位置上都种有一棵树，现改路维修，要砍掉铁路上的树木（铁路可重叠）。程序要求，输入 L，输入铺设铁路条数 m，然后输入 m 铁路的坐标。求剩下多少颗树。
  例如：L 等于 10，铺设四条铁路，坐标是（1,2）、（2,3）、（2,8）、（3,5），那么 1 到 8 坐标点的树都要砍掉，剩下 0,9,10 三颗。

int residue_tree(int L, int m, int arr[][2]) 
{
	int start, end;  //铁路坐标的始末 
	int count = 0;  //剩余树的个数 
	int tree[L+1];  //树的数组，全置1   
	for(int i = 0;i < L+1;i++){
		tree[i] = 1;  
	}
	for(int i = 0;i < m;i++){
		start = arr[i][0];
		end = arr[i][1];
		for(int j = start;j <= end;j++){
			tree[j] = 0;  //修建铁路的区域置0 
		}
	}
	for(int i = 0;i <= L;i++){
		if(tree[i] == 1)
			count++;  //剩余树的个数
	}
	return count; 
}

7. 字符处理 (简单)

输入某字符串，以 “#” 结束。输出的字符串需满足：删除元音字母（包括大小写），辅音字母前加 “！”，字母大小写互换。
例如：输入 “tour#”，输出 “!T!R”。
提示：元音：A/a、E/e、I/i、O/o、U/u；ASCII 值 65~90 为 26 个大写英文字母，97～122 号为 26 个小写英文字母。

void change_string(char str[], int len)
{
	char new_str[100]; //删除元音字母后的新数组 
	int index = 0;  //新数组下标 
	//删除元音字母（包括大小写）
	for(int i = 0;i < len;i++){	
		if(str[i] != 'A' && str[i] != 'a' && 
		   str[i] != 'E' && str[i] != 'e' && 
		   str[i] != 'I' && str[i] != 'i' && 
		   str[i] != 'O' && str[i] != 'o' && 
		   str[i] != 'U' && str[i] != 'u')
		{
			new_str[index] = str[i];
			index++;
		}
	}
	//辅音字母前加“！”，字母大小写互换
	for(int i = 0;i < index;i++){
		if(new_str[i] >= 'a' && new_str[i] <= 'z')
			printf("!%c", new_str[i]-32);
		if(new_str[i] >= 'A' && new_str[i] <= 'Z')
			printf("!%c", new_str[i]+32);
	}	
}

8. 覆盖矩形 (简单)

  有一矩形和正方形。输入矩形的长 n，宽 m 和正方形边长 a。输出至少多少个这样正方形能把该矩形完全覆盖。

int min_square(int n, int m, int a)
{
	int num = 0; //正方形个数 
	
	//分三种情况
	if(a > n)
		num = 1;
	if(a < n && a > m){
		//考虑是否整除的情况 
		if(n%a == 0)
			num = n/a;
		else 
			num = n/a +1;
	}	
	if(a < m){
		int num1, num2;
		if(n%a == 0)
			num1 = n/a;
		else 
			num1 = n/a +1;
		if(m%a == 0)
			num2 = m/a;
		else 
			num2 = m/a +1;
		num = num1 * num2;
	}
		
	return num;
}

9. 比较三个数大小 (简单)

  输入 3 个数 a,b,c，按大小顺序输出(略)
  （1）用 if 语句判断求解
  （2）直接排序输出

10. 数组元素交换 (简单)

  将数组中最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。

//交换 
int swap(int *a, int *b)
{
	int temp = *a;
	*a = *b;
	*b = temp;
}

int *change(int arr[], int len)
{
	int max_index = 0;
	int min_index = 0;
	for(int i = 0;i < len;i++){
		if(arr[max_index] < arr[i]){
			max_index = i;
		}
		if(arr[min_index] > arr[i]){
			min_index = i;
		}	
	}
	
	swap(&arr[0], &arr[max_index]); //最大的与第一个元素交换
	swap(&arr[len-1], &arr[min_index]); //最小的与最后一个元素交换
	
	return arr;
}

11. 字符串排序 (简单)

void swap(char *a, char *b)
{
	char temp[20];
	strcpy(temp, a);
	strcpy(a, b);
	strcpy(b, temp);
	
}

//字符串排序、字符串比较 
void string_sort(char str1[], char str2[], char str3[]) 
{
	if(strcmp(str1,str2) > 0) swap(str1, str2);
	if(strcmp(str2,str3) > 0) swap(str2, str3);
	if(strcmp(str1,str3) > 0) swap(str1, str3);
	printf("排序后：%s %s %s",str1,str2,str3);	
} 

12. 高精度乘法计算 (中等)

  计算机内部直接用 int 或 double 等数据类型储存数字是有范围限制的，即当数据运算大小过大后，计算机将会出现溢出情况，使得计算结果不够精确。为了能够使计算机精确地计算高位的数字，我们需要学会使用高精度乘法。

  高精度乘法的大致流程：
  （1）通过两个字符串输入两个整数；
  （2）引入两个数组，将两个字符串通过一定的运算，分别将每一位的数字储存进数组中；
  （3）进行每一位的运算；
  （4）处理进位；
  （5）输出结果；

//高精度乘法
int *high_pre_mul(char *str1, char *str2, int mul_res[])
{
	int len1 = strlen(str1);
	int len2 = strlen(str2);
	int arr1[len1], arr2[len2]; 
	int i, j;
	
	/* 2 将字符数组转至数字数组；*/
	//arr1[0]表示个位，arr1[1]表示十位
	for(i = 0,j = len1-1;i < len1;i++,j--){
		arr1[i] = str1[j] - '0';
	}
	for(i = 0,j = len2-1;i < len2;i++,j--){
		arr2[i] = str2[j] - '0';
	}
	
	/* 3 计算乘法后的每一位，即mul_res数组每一位；*/
	for(i = 0;i < len1;i++){
		for(j = 0;j < len2;j++){
			mul_res[i+j] += arr1[i] * arr2[j];
		}
	}
	
	/* 4 处理进位问题；*/
	int n = len1+len2;
	for(i = 0;i < n;i++){
		if(mul_res[i] >= 10){
			mul_res[i+1] += mul_res[i] / 10;
			mul_res[i] = mul_res[i] % 10;
		} 
	} 
	
	return mul_res;
}

int main()
{	
	/* 1 通过两个字符串输入两个整数 */
	int *p;
	int mul_res[3000] = {0}; //存放乘法结果
	char str1[1500], str2[1500];
	scanf("%s %s",str1,str2);
	
	/* 2 3 4 高精度乘法计算 */
	p = high_pre_mul(str1, str2, mul_res);
	
	/* 5 输出结果 */
	int i, j;
	//将数组为0的元素略掉 
	for(i = 2999;i > 0;i--){
		if(*(p + i) == 0) continue;
		break;
	}
	//倒序输出数组，*(p + 0)是个位
	for(j = i;j >= 0;j--){
		printf( "%d", *(p + j));
	}	
	return 0;
}

13. 两素数之和 (简单)

随便给一个不大于 1000 的数 A，列出所有的可能，两个素数 B、C 相加等于 A。
例如：10=3+7；10=5+5；

//判断是否为素数 
int isPrime(int n)
{
	if(n == 2) return true;
	for(int i = 2;i < sqrt(n)+1;i++){
		if(n%i == 0) {
			return false;
		}	
	}
	return true;
}

int main()
{
	int num;
	printf("输入一个小于1000的数，num = ");
	scanf("%d",&num);

	for(int i = 2;i <= num/2;i++){
		if(isPrime(i) && isPrime(num-i)){
			printf("%d + %d = %d\n",i,num-i,num);
		}
	}
	return 0;
} 

14. 一条龙式矩阵 (简单)

给出一个数n，则形成一个一条龙式的n*n矩阵。

//例如：n = 3，则res为下图所示
1    2    3
6    5    4
7    8    9

int matrix(int n)
{
	int res[n][n];
	int row, col;
	//形成一条龙式的n*n矩阵
	for(row = 0;row < n;row++){
		if(row%2 == 0){
			for(col = 0;col < n;col++){
				res[row][col] = row * n + (col+1);
			}
		}
		else{
			for(col = 0;col < n;col++){
				res[row][col] = res[row-1][n-1] + n - col;
			}
		}
	}
	//输出 
	for(int i = 0;i < n;i++){
		for(int j = 0;j < n;j++){
			printf( "%d\t", res[i][j]);
		}
		printf("\n");
	}
}

15. 最长上升/递增子序列(LIS) – 动态规划 (中等)

Leetcode300. 给定一个无序的整数数组，找到其中最长上升子序列的长度。
输入: [10,9,2,5,3,7,101,18]
输出: 4
解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。

首先，补充一个知识点，通过vector创建数组：

//一维
vector<int> arr(10);   //表示arr的长度为10
vector<int> arr(6, 4);   //表示arr的长度为6，每个元素都为4
vector<int> arr(n, 0);   //表示arr的长度为n，每个元素都为0
//二维
vector<vector<int>> dp(rows, vector<int>(cols));  //表示dp的行数rows，列数cols

思路：
  定义 dp[i] 为考虑前i个元素，以第i个数字结尾的最长上升子序列的长度。在计算 dp[i] 之前，我们已经计算出 dp[0]，dp[1]，…，dp[i−1] 的值，设定 0<=j<=i，如果nums[j] < nums[i]，则状态转移方程为 dp[i] = max(dp[i], dp[j]+1)，最终最长上升子序列的长度为 dp 数组中的最大值，返回即可。

int lengthOfLIS(vector<int>& nums) {
    int len = nums.size();
    if(len == 0) return 0;
    vector<int> dp(len, 0); //一维数组，长度len

    for(int i = 0;i < len;i++){
        dp[i] = 1;                 //子序列至少长度为1
        for(int j = 0;j < i;j++){
            if(nums[j] < nums[i]){
                dp[i] = max(dp[i], dp[j]+1);
            }
        }
    }

	//找到dp数组中最大值
    int max = 0;
    for(int i = 1;i < len;i++){
        if(dp[i] > dp[max]){
            max = i;
        }
    }

    return dp[max];
}

16. 最长公共子序列(LCS) – 动态规划 (中等)

给定两个字符串，求解这两个字符串的最长公共子序列（Longest Common Sequence）。比如字符串 L：BDCABA；字符串 S：ABCBDAB。则这两个字符串的最长公共子序列长度为 4，最长公共子序列是：BCBA

思路：
1.若text1[i-1] == text2[j-1]，则dp[i][j] = dp[i-1][j-1] + 1
2.若text1[i-1] != text2[j-1]，则dp[i][j] = max(dp[i-1][j], dp[i][j-1])

int longestCommonSubsequence(string text1, string text2) {
    int len1 = text1.length(); //长度
    int len2 = text2.length();

    //int dp[1005][1005]; //dp数组
    vector<vector<int>> dp(len1+1,vector<int>(len2+1)); //dp二维数组
    for(int i = 0;i < len1+1;i++){
        for(int j = 0;j < len2+1;j++){
            dp[i][j] = 0; //表中元素全部赋值为0
        }
    }
        
    for(int i = 1;i < len1+1;i++){
        for(int j = 1;j < len2+1;j++){
            if(text1[i-1] == text2[j-1]){ // 遇到匹配字符，左上角+1
				dp[i][j] = dp[i-1][j-1] + 1; 
			}  
            else{  // 不匹配，继承左、上的较大值
				dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
			}
                
        }
    }

    return dp[len1][len2];
}

17. 零钱兑换 – 动态规划 (中等)

Leetcode322. 给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数，每种硬币的数量是无限的。如果没有任何一种硬币组合能组成总金额，返回 -1。
输入: coins = [1, 2, 5], amount = 11
输出: 3
解释: 11 = 5 + 5 + 1

思路：
  采用自下而上的方式，定义 dp[i] 为组成金额 i 所需最少的硬币数量，则状态转移方程为 dp[i] = min(dp[i], dp[i-coin]+1)，coin 代表的是硬币的面值。

int coinChange(vector<int>& coins, int amount) {
        if(amount < 0) return -1;
        if(amount == 0) return 0;
        
        vector<int> dp(amount+1, amount+1); //数组每个元素初始化均为amount+1 
        dp[0] = 0;
        //遍历金额 1--amount
        for(int i = 0;i < amount+1;i++){
            //遍历每个面额的硬币
            for(int c = 0;c < coins.size();c++){
                if(i - coins[c] < 0) continue; //继续下一个面额
                dp[i] = min(dp[i], dp[i-coins[c]]+1); //状态转移方程
            }   
        }
        //dp[amount] == amount+1 说明没有改变初值，返回-1
        return (dp[amount] == amount+1) ? -1 : dp[amount];
    }

18. 报数问题 (简单)

  有 n 个小朋友坐成一圈，顺时针编号 1-n。顺时针从 1-k 报数，谁报到k谁退出，后重新 1-k 报数。问最后剩下的是几号？

#include<iostream>
#include <queue>
#include <vector>
using namespace std;

int main()
{
	int n, k;
	cin >> n >> k;
	int num = 1;
	
	//方法一：队列 
	queue<int> q; 
	for(int i = 1;i <= n;i++){
		q.push(i); //队列元素赋值 
	}
	while(q.size() > 1){
		int top = q.front(); //保存栈顶元素 
		q.pop(); //栈顶元素弹出 
		if(num != k){
			q.push(top); //把栈顶元素重新压入栈底 
			num++;
		}
		else{ //num == k，num置为1，重新开始增  
			num = 1;	
		}
		
	}
	cout<<q.front()<<endl;
	
	//方法二：数组
	int len = n; //记录数组还剩几个元素 
	vector<int> arr(n,1); //数组元素初始化全为1 
	while(len > 1){
		for(int i = 0;i < n;i++){
			if(arr[i] == 0) continue;
			if(num == k){ 
				arr[i] = 0; //数组元素置为0，表示该元素已出局 
				num = 1;    //num置为1，重新开始增 
				len--;      //数组元素个数减一 
			}
			else{ //num != k则继续加数 
				num++;	
			}
			if(i == n-1) break; //数组数到最后一个元素，从头开始 
		}
	} 
	for(int i = 0;i < n;i++){ //数组只剩一个元素，输出 
		if(arr[i] == 1){
			cout<<i+1<<endl;
		}
	}
	
	return 0;	
}	

19. 求函数定积分 (简单)

这里以函数 sin(x) 为例

#include<cmath>
#include<iostream>
using namespace std;

//梯形法求定积分 
void trapezoid(float a, float b) 
{
	int n;
	float l = 0.001, res = 0.0; //l表示划分的单位宽度
	n = (b-a)/l;  //单位宽度的个数 
	for(int i = 0;i < n;i++){
		//（上底+下底）*高/2 
		res += (sin(a+l*i) + sin(a+l*(i+1))) * l / 2.0;
	} 
	cout<<"梯形法求函数sin(x)，区间("<<a<<","<<b<<")的定积分为:"<<res<<endl;
	
}

//矩形法求定积分
void rectangle(float a, float b) 
{
	int n;
	float l = 0.001, res = 0.0; //l表示划分的单位宽度
	n = (b-a)/l;  //单位宽度的个数 
	for(int i = 0;i < n;i++){ 
		res += sin(a+l*i)*l;
	} 
	cout<<"矩形法求函数sin(x)，区间("<<a<<","<<b<<")的定积分为:"<<res<<endl;
}

int main()
{
	float upper_limit, lower_limit;
	cin >> lower_limit >> upper_limit;
	trapezoid(lower_limit, upper_limit); //梯形法求定积分 
	rectangle(lower_limit, upper_limit); //矩形法求定积分 
	return 0;	
}

持续更新…

本笔记记录 C 编程题，若有错误，欢迎批评指正，学习交流。