T1

这题是真的不会，我以为int是-2^31+1~2^31-1，不过这次错了下次就会了

32 位 int 类型的存储范围是(C)

A，-2,147,483,647~2,147,483,647

B，-2,147,483,647~2,147,483,648

C，-2,147,483,648~2,147,483,647

D，-2,147,483,648~2,147,483,648

阅读程序1

 #include <iostream>
 using namespacestd; 

 bool isPrime(int n) {
 	if (n <= 1) {
       return false; 
   }
   for (int i = 2; i * i <= n; i++) {
   	if (n % i == 0) {
           return false; 
      }
  }
  return true; 
 }

  int countPrimes(int n) {
      int count = 0;
      for (int i = 2; i <= n; i++) {
         if (isPrime(i)) {
             count++; 
         }
      }
      return count; 
  }

  int sumPrimes(int n) {
  	int sum = 0;
  	for (int i = 2; i <= n; i++) {
  		if (isPrime(i)) {
      		sum += i; 
  		}
  	}
  	return sum; 
  }

   int main() {
    int x;
    cin >> x;
    cout << countPrimes(x) << " " << sumPrimes(x) << endl;
    return 0; 
 }

输入n，输出n以内质数个数，n以内所有质数的和

阅读程序2

 #include <iostream> 
 #include <vector>
 using namespacestd; 

 int compute(vector<int> &cost) {
     int n = cost.size();
     vector<int> dp(n + 1, 0);
     dp[1] = cost[0];
     for (int i = 2; i <= n; i++) {
     dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i - 1]; 
    }
     return min(dp[n], dp[n - 1]); 
 }

 int main() {
    int n;
    cin >> n;
    vector<int> cost(n);
    for (inti = 0; i < n; i++) {
         cin >> cost[i]; 
    }
    cout << compute(cost) << endl;
    return 0; 
 }

这段代码实现了一个动态规划算法，用于解决最小花费爬楼梯问题，这是一个经典的动态规划问题，计算爬楼梯的最小花费，dp数组存储到达每个台阶的最小累计花费，递推关系：dp[i] = min(dp[i-1], dp[i-2]) + cost[i-1]，最后返回最后两个台阶中的较小值

阅读程序3

  #include <iostream> 
  #include <cmath>
  using namespacestd; 

  int customFunction(int a, int b) {
   	if (b == 0) {
          return a; 
     }
     return a + customFunction(a , b - 1); 
 }

 int main() {
    int x, y;
 		cin >> x >> y;
 		int result = customFunction(x, y);
 		cout << pow(result, 2) << endl;
 		return 0; 
 }

这段代码用递归函数来计算两个整数的乘积，然后输出该乘积的平方值

完善程序2

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

void move(char src, char tgt)
{
	cout << "从柱子" << src << "挪到柱子" << tgt << endl;
}

void dfs(int i, char src, char tmp, char tgt)
{
	if(i == 1)
	{
		move(src, tgt);
		return;
	}
	dfs(i - 1, src, tgt, tmp);
	move(src, tgt);
	dfs(i - 1, tmp, src, tgt);
}

int main()
{
	int n;
	cin >> n;
	dfs(n, 'A', 'B', 'C');
	return 0;
}

这段代码是经典的汉诺塔问题：

给定三根柱子，分别标记为 A 、B 和C。初始状态下，柱子 A 上有若干个 圆盘，这些圆盘从上到下按从小到大的顺序排列。任务是将这些圆盘全部移到柱子 C上，且 必须保持原有顺序不变。在移动过程中，需要遵守以下规则：

1．只能从一根柱子的顶部取出圆盘，并将其放入另一根柱子的顶部。

2．每次只能移动一个圆盘

3．小圆盘必须始终在大圆盘之上。