（PTA）基础编程题目集

PTA基础编程题目集，写着玩，仅供参考，欢迎指正

Misasagi Inori

10797人浏览 · 2022-10-07 13:30:09

Misasagi Inori · 2022-10-07 13:30:09 发布

函数题

1、简单输出整数

本题要求实现一个函数，对给定的正整数N，打印从1到N的全部正整数。

函数接口定义：

void PrintN ( int N );

其中N是用户传入的参数。该函数必须将从1到N的全部正整数顺序打印出来，每个数字占1行。

裁判测试程序样例：

#include <stdio.h>

void PrintN ( int N );

int main ()
{
    int N;

    scanf("%d", &N);
    PrintN( N );

    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

输出样例：

1
2
3

参考答案：

void PrintN( int N)
{
    int i ;
    for(i=1;i<=N;i++)
    {
        if(i<N)
        {
            printf("%d\n",i);
        }
        if(i == N)
        {
            printf("%d",i);
        }
    }
    return 0;
}

2、多项式求值

本题要求实现一个函数，计算阶数为n，系数为a[0] ... a[n]的多项式 $f(x)=\sum_{i=0}^{n}(a[i]\times x^i)$ 在x点的值。

函数接口定义：

double f( int n, double a[], double x );

其中n是多项式的阶数，a[]中存储系数，x是给定点。函数须返回多项式f(x)的值。

裁判测试程序样例：

#include <stdio.h>

#define MAXN 10

double f( int n, double a[], double x );

int main()
{
    int n, i;
    double a[MAXN], x;
    
    scanf("%d %lf", &n, &x);
    for ( i=0; i<=n; i++ )
        scanf("%lf", &a[i]);
    printf("%.1f\n", f(n, a, x));
    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

2 1.1
1 2.5 -38.7

输出样例：

-43.1

参考答案：

#include<math.h>

double f(int n, double a[], double x)
{
    int i=0;
    double b = 0 ;
    for(i;i<=n;i++)
    {
        b += a[i] * pow(x,i);
    }
    return b;
}

3、简单求和

本题要求实现一个函数，求给定的N个整数的和。

函数接口定义：

int Sum ( int List[], int N );

其中给定整数存放在数组List[]中，正整数N是数组元素个数。该函数须返回N个List[]元素的和。

裁判测试程序样例：

#include <stdio.h>

#define MAXN 10

int Sum ( int List[], int N );

int main ()
{
    int List[MAXN], N, i;

    scanf("%d", &N);
    for ( i=0; i<N; i++ )
        scanf("%d", &List[i]);
    printf("%d\n", Sum(List, N));

    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

3
12 34 -5

输出样例：

参考答案：

int Sum(int List[], int N)
{
    int sum = 0;
    int i = 0;
    for(i;i<N;i++)
    {
        sum += List[i];
    }
    return sum;
}

4、求自定类型元素的平均

本题要求实现一个函数，求N个集合元素S[]的平均值，其中集合元素的类型为自定义的ElementType。

函数接口定义：

ElementType Average( ElementType S[], int N );

其中给定集合元素存放在数组S[]中，正整数N是数组元素个数。该函数须返回N个S[]元素的平均值，其值也必须是ElementType类型。

裁判测试程序样例：

#include <stdio.h>

#define MAXN 10
typedef float ElementType;

ElementType Average( ElementType S[], int N );

int main ()
{
    ElementType S[MAXN];
    int N, i;

    scanf("%d", &N);
    for ( i=0; i<N; i++ )
        scanf("%f", &S[i]);
    printf("%.2f\n", Average(S, N));

    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

3
12.3 34 -5

输出样例：

13.77

参考答案：

ElementType Average(ElementType s[], int N)
{
    float sum;
    int i = 0;
    for(i;i<MAXN;i++)
    {
        sum += s[i];
    }
    return sum/N;
}

5、求自定类型元素的最大值

本题要求实现一个函数，求N个集合元素S[]中的最大值，其中集合元素的类型为自定义的ElementType。

函数接口定义：

ElementType Max( ElementType S[], int N );

其中给定集合元素存放在数组S[]中，正整数N是数组元素个数。该函数须返回N个S[]元素中的最大值，其值也必须是ElementType类型。

裁判测试程序样例：

#include <stdio.h>

#define MAXN 10
typedef float ElementType;

ElementType Max( ElementType S[], int N );

int main ()
{
    ElementType S[MAXN];
    int N, i;

    scanf("%d", &N);
    for ( i=0; i<N; i++ )
        scanf("%f", &S[i]);
    printf("%.2f\n", Max(S, N));

    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

3
12.3 34 -5

输出样例：

34.00

参考答案：

ElementType Max( ElementType S[], int N )
{
    float max = S[0];
    for(int i = 0;i<N;i++)
    {
        if(S[i]>max)
        {
            max = S[i];
        }
    }
    return max;
}

6、求单链表结点的阶乘和

本题要求实现一个函数，求单链表L结点的阶乘和。这里默认所有结点的值非负，且题目保证结果在int范围内。

函数接口定义：

int FactorialSum( List L );

其中单链表List的定义如下：

typedef struct Node *PtrToNode;
struct Node {
    int Data; /* 存储结点数据 */
    PtrToNode Next; /* 指向下一个结点的指针 */
};
typedef PtrToNode List; /* 定义单链表类型 */

裁判测试程序样例：

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

typedef struct Node *PtrToNode;
struct Node {
    int Data; /* 存储结点数据 */
    PtrToNode Next; /* 指向下一个结点的指针 */
};
typedef PtrToNode List; /* 定义单链表类型 */

int FactorialSum( List L );

int main()
{
    int N, i;
    List L, p;

    scanf("%d", &N);
    L = NULL;
    for ( i=0; i<N; i++ ) {
        p = (List)malloc(sizeof(struct Node));
        scanf("%d", &p->Data);
        p->Next = L;  L = p;
    }
    printf("%d\n", FactorialSum(L));

    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

3
5 3 6

输出样例：

参考答案：

int Cal(int data);

int FactorialSum(List L)
{
    if(L == NULL)
    {
    return 0;
    }
    int sum = 0;
    while (L->Next != NULL)
    {
        sum += Cal(L->Data);
        L = L->Next;
    }
    
    sum += Cal(L->Data);
    return sum;
}
int Cal(int data)
{
    int i;
    int sum = 1;
    if (data == 0) return 1;
    if (data == 1) return 1;
    if (data > 1)
    {
        for (i = 1; i <=data; i++)
        {
            sum *= i;
        }
        return sum;
    }
}

7、统计某类完全平方数

本题要求实现一个函数，判断任一给定整数N是否满足条件：它是完全平方数，又至少有两位数字相同，如144、676等。

函数接口定义：

int IsTheNumber ( const int N );

其中N是用户传入的参数。如果N满足条件，则该函数必须返回1，否则返回0。

裁判测试程序样例：

#include <stdio.h>
#include <math.h>

int IsTheNumber ( const int N );

int main()
{
    int n1, n2, i, cnt;
    
    scanf("%d %d", &n1, &n2);
    cnt = 0;
    for ( i=n1; i<=n2; i++ ) {
        if ( IsTheNumber(i) )
            cnt++;
    }
    printf("cnt = %d\n", cnt);

    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

105 500

输出样例：

cnt = 6

参考答案：

int IsTheNumber(const int N)
{
    int n = (int)sqrt(N);
    int num = N;
    int m[10] = {0};
    int a;
    if (n*n == N)
    {
        while(num%10 != num)
        {
            a = num % 10;
            num = (int)(num / 10);
            if (m[a] == 1)
            {
                return 1;
            }
            m[a] = 1;
        }
        int a = num % 10;
        if (m[a] == 1)
        {
            return 1;
        }
        return 0;
    }
    return 0;

}

8、简单阶乘计算

本题要求实现一个计算非负整数阶乘的简单函数。

函数接口定义：

int Factorial( const int N );

其中N是用户传入的参数，其值不超过12。如果N是非负整数，则该函数必须返回N的阶乘，否则返回0。

裁判测试程序样例：

#include <stdio.h>

int Factorial( const int N );

int main()
{
    int N, NF;
    
    scanf("%d", &N);
    NF = Factorial(N);
    if (NF)  printf("%d! = %d\n", N, NF);
    else printf("Invalid input\n");

    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

输出样例：

5! = 120

参考答案：

int Factorial(const int N)
{
    int sum = 1;
    if (N < 0) return 0;
    if (N == 0) return 1;
    for (int i = 1; i <= N; i++)
    {
        sum = sum * i;
    }
    return sum;
}

9、统计个位数字

本题要求实现一个函数，可统计任一整数中某个位数出现的次数。例如-21252中，2出现了3次，则该函数应该返回3。

函数接口定义：

int Count_Digit ( const int N, const int D );

其中N和D都是用户传入的参数。N的值不超过int的范围；D是[0, 9]区间内的个位数。函数须返回N中D出现的次数。

裁判测试程序样例：

#include <stdio.h>

int Count_Digit ( const int N, const int D );

int main()
{
    int N, D;
    
    scanf("%d %d", &N, &D);
    printf("%d\n", Count_Digit(N, D));
    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

-21252 2

输出样例：

参考答案：

int Count_Digit(const int N, const int D)
{
    int n = N;
    int num[10] = {0};
    int number;
    if (n < 0) n = n * (-1);
    while(n % 10 != n)
    {
        number = n % 10;
        num[number] ++;
        n /= 10;
    }
    num[n] ++;
    return num[D];
}

10、阶乘计算升级版

本题要求实现一个打印非负整数阶乘的函数。

函数接口定义：

void Print_Factorial ( const int N );

其中N是用户传入的参数，其值不超过1000。如果N是非负整数，则该函数必须在一行中打印出N!的值，否则打印“Invalid input”。

裁判测试程序样例：

#include <stdio.h>

void Print_Factorial ( const int N );

int main()
{
    int N;
    
    scanf("%d", &N);
    Print_Factorial(N);
    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

输出样例：

1307674368000

参考答案：

void Print_Factorial(const int N) {
    long sum = 1;
    if (N >= 0 && N <= 12) {
        for (int i = 0; i <= N; i++) {
            if (i == 0) {
                sum = 1;
            }
            else {
                sum = sum*i;
            }
        }
        printf("%d\n", sum);
    }
    else if (N > 12 && N <= 1000) {
        int Num[3000] = { 0 };  //确保保存最终运算结果的数组足够大：1-9相乘最多有9位，10-99相乘最多有2*90=180位，100-999相乘最多有3*900=2700位，1000是4*1=4位，总计2893，最好数组取大一下
        int i, j, k, n;
        k = 1;  //位数
        n = 0;  //进位
        Num[0] = 1;   //将结果先初始化为1
        int temp;  //阶乘的任一元素与临时结果的某位的乘积结果
 
        for (i = 2; i <= N; i++)  //开始阶乘，阶乘元素从2开始
        {  //和平时乘法方法相同，将临时结果的每位与阶乘元素相乘
 
            for (j = 0; j < k; j++)
            {
                temp = Num[j] * i + n;  //相应阶乘中的一项与当前所得临时结果的某位相乘（加上进位）
                Num[j] = temp % 10;  //更新临时结果的位上信息
                n = temp / 10;   //看是否有进位
            }
 
            while (n != 0)
            {  //如果有进位
                Num[k] = n % 10;  //新加一位，添加信息。位数增1
                k++;
                n = n / 10;   //看还能不能进位
            }
        }
 
        for (i = k - 1; i >= 0; i--)
        {
            printf("%d", Num[i]);  
        }
        printf("\n");
    }
    else {
        printf("Invalid input\n");
    }
}

图片示例

（图和答案是转载的，大佬们写的已经很好懂了，答案来源忘了，太早的事了，可能是他的，图片来源Air-air）

11、求自定类型元素序列的中位数

本题要求实现一个函数，求N个集合元素A[]的中位数，即序列中第⌊(N+1)/2⌋大的元素。其中集合元素的类型为自定义的ElementType。

函数接口定义：

ElementType Median( ElementType A[], int N );

其中给定集合元素存放在数组A[]中，正整数N是数组元素个数。该函数须返回N个A[]元素的中位数，其值也必须是ElementType类型。

裁判测试程序样例：

#include <stdio.h>

#define MAXN 10
typedef float ElementType;

ElementType Median( ElementType A[], int N );

int main ()
{
    ElementType A[MAXN];
    int N, i;

    scanf("%d", &N);
    for ( i=0; i<N; i++ )
        scanf("%f", &A[i]);
    printf("%.2f\n", Median(A, N));

    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

3
12.3 34 -5

输出样例：

12.30

参考答案：

ElementType Median(ElementType A[], int N)
{
    int gap, i, j;
    float temp;
    for (gap = N / 2; gap > 0; gap /= 2)
    {
        for (i = gap; i < N; i++)
        {
            for (j = i - gap; j >= 0 && A[j]>A[j+gap]; j -= gap)
            {
                temp = A[j];
                A[j] = A[j+gap];
                A[j+gap] = temp;

            }
        }
    }
    if (N % 2 == 0)
    {
        return A[N / 2];
    }
    else
    {
        return A[(N + 1) / 2 - 1];
    }
}

12、判断奇偶性

本题要求实现判断给定整数奇偶性的函数。

函数接口定义：

int even( int n );

其中n是用户传入的整型参数。当n为偶数时，函数返回1；n为奇数时返回0。注意：0是偶数。

裁判测试程序样例：

#include <stdio.h>

int even( int n );

int main()
{    
    int n;

    scanf("%d", &n);
    if (even(n))
        printf("%d is even.\n", n);
    else
        printf("%d is odd.\n", n);
    
    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例1：

-6

输出样例1：

-6 is even.

输入样例2：

输出样例2：

5 is odd.

参考答案：

int even(int n)
{
    if (n % 2 == 0)
        return 1;
    else
        return 0;
}

13、折半查找

给一个严格递增数列，函数int Search_Bin(SSTable T, KeyType k)用来二分地查找k在数列中的位置。

函数接口定义：

int  Search_Bin(SSTable T, KeyType k)

其中T是有序表，k是查找的值。

裁判测试程序样例：


#include <iostream>
using namespace std;

#define MAXSIZE 50
typedef int KeyType;

typedef  struct                     
{ KeyType  key;                                             
} ElemType;  

typedef  struct
{ ElemType  *R; 
  int  length;
} SSTable;                      

void  Create(SSTable &T)
{ int i;
  T.R=new ElemType[MAXSIZE+1];
  cin>>T.length;
  for(i=1;i<=T.length;i++)
     cin>>T.R[i].key;   
}

int  Search_Bin(SSTable T, KeyType k);

int main () 
{  SSTable T;  KeyType k;
   Create(T);
   cin>>k;
   int pos=Search_Bin(T,k);
   if(pos==0) cout<<"NOT FOUND"<<endl;
   else cout<<pos<<endl;
   return 0;
}

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

###输入格式：

第一行输入一个整数n，表示有序表的元素个数，接下来一行n个数字，依次为表内元素值。然后输入一个要查找的值。

###输出格式：

输出这个值在表内的位置，如果没有找到，输出"NOT FOUND"。

输入样例：

5
1 3 5 7 9
7

输出样例：

输入样例：

5
1 3 5 7 9
10

输出样例：

NOT FOUND

参考答案：

int Search_Bin(SSTable T, KeyType k)
{
    for (int i = 0; i < T.length; i++)
    {
        if (T.R[i].key == k)
            return i;
    }
    return 0;
}
/*   //其实不用二分也能过
int Search_Bin(SSTable T, KeyType k)
{
    int high,low,mid;
    high = T.length-1;
    low = 0 ;
    mid = (low+high)/2;
    while(low<high)
    {
        if(T.R[mid].key<k)
        {
            low = mid+1;
            mid = (low+high)/2;
        }
        if(T.R[mid].key>k)
        {
            high =mid-1;
            mid = (low+high)/2;
        }
        if(T.R[mid].key==k)
        {
            return mid;
        }
    }
    return 0;
}
*/

编程题

1、厘米换算英尺英寸

如果已知英制长度的英尺foot和英寸inch的值，那么对应的米是(foot+inch/12)×0.3048。现在，如果用户输入的是厘米数，那么对应英制长度的英尺和英寸是多少呢？别忘了1英尺等于12英寸。

输入格式：

输入在一行中给出1个正整数，单位是厘米。

输出格式：

在一行中输出这个厘米数对应英制长度的英尺和英寸的整数值，中间用空格分开。

输入样例：

输出样例：

5 6

参考答案：

#include<iostream>

using namespace std;

int main()
{
    int foot,inch;
    double centimeter,meter;
    cin >> centimeter;

    meter = centimeter /100;
    // meter/0.3048 = 整数部分 + 小数部分
    foot = meter /0.3048;  //整数部分
    inch = (meter/0.3048-foot)*12; //小数部分*12

    cout << foot<<" "<<inch;
}

2、然后是几点

有时候人们用四位数字表示一个时间，比如 1106 表示 11 点零 6 分。现在，你的程序要根据起始时间和流逝的时间计算出终止时间。

读入两个数字，第一个数字以这样的四位数字表示当前时间，第二个数字表示分钟数，计算当前时间经过那么多分钟后是几点，结果也表示为四位数字。当小时为个位数时，没有前导的零，例如 5 点 30 分表示为 530；0 点 30 分表示为 030。注意，第二个数字表示的分钟数可能超过 60，也可能是负数。

输入格式：

输入在一行中给出 2 个整数，分别是四位数字表示的起始时间、以及流逝的分钟数，其间以空格分隔。注意：在起始时间中，当小时为个位数时，没有前导的零，即 5 点 30 分表示为 530；0 点 30 分表示为 030。流逝的分钟数可能超过 60，也可能是负数。

输出格式：

输出不多于四位数字表示的终止时间，当小时为个位数时，没有前导的零。题目保证起始时间和终止时间在同一天内。

输入样例：

1120 110

输出样例：

参考答案：

//7-2 然后是几点
/*
#include<iostream>
#include<iomanip>
using namespace std;


int main()
{
    int in_time,past,out_time;

    cin >> in_time >> past;

    out_time = (in_time /100) *60 + (in_time%100) + past;
    //cout.fill('0');
    //cout << out_time/60<<setw(2)<<setfill('0')<<out_time%60;
    cout << out_time/60<<cout.width(2)<<out_time%60;
}
*/

//7-2 然后是几点

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


int main()
{
    int in_time,past,out_time;

    cin >> in_time >> past;

    out_time = (in_time /100) *60 + (in_time%100) + past;
    cout.fill('0');
    //cout << out_time/60<<setw(2)<<setfill(0)<<out_time%60;
    cout << out_time/60;
    cout.width(2);
    cout<<out_time%60;
}

3、逆序的三位数

程序每次读入一个正3位数，然后输出按位逆序的数字。注意：当输入的数字含有结尾的0时，输出不应带有前导的0。比如输入700，输出应该是7。

输入格式：

每个测试是一个3位的正整数。

输出格式：

输出按位逆序的数。

输入样例：

输出样例：

参考答案：

#include<iostream>

using namespace std;

int main()
{
    int num,result;
    cin >> num;
    result = num/100 + (num%100)/10*10 + (num%10)*100; 
    cout << result;
    return 0;
}

4、BCD解密

BCD数是用一个字节来表达两位十进制的数，每四个比特表示一位。所以如果一个BCD数的十六进制是0x12，它表达的就是十进制的12。但是小明没学过BCD，把所有的BCD数都当作二进制数转换成十进制输出了。于是BCD的0x12被输出成了十进制的18了！

现在，你的程序要读入这个错误的十进制数，然后输出正确的十进制数。提示：你可以把18转换回0x12，然后再转换回12。

输入格式：

输入在一行中给出一个[0, 153]范围内的正整数，保证能转换回有效的BCD数，也就是说这个整数转换成十六进制时不会出现A-F的数字。

输出格式：

输出对应的十进制数。

输入样例：

输出样例：

参考答案：

//7-4 BCD解密

/*
    BCD数     每四位表示十进制一个数  一个字节八位表示两位十进制的数，前四位表示十位，后四位表示个位
    二进制    0001 0010
    十六进制  0x12
    十进制    12

    实际   小明不懂BCD数 当成普通二进制
    二进制    0001 0010
    十六进制  c
    十进制    18
*/

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

int DecimalToBinary(int num)
{
    stack<int> t;
    while(num)
    {
        t.push(num%2);
        num/=2;
    }
    while(t.size()<8)
    {
        t.push(0);
    }
    int temp[8];
    for(int i =0;i<8;i++)
    {
        temp[i] = t.top();
        t.pop();
    }

    int result;
    result = (temp[0]*8 + temp[1]*4 + temp[2]*2 + temp[3] *1)*10 +  temp[4]*8 + temp[5]*4 + temp[6]*2 + temp[7] *1;

    return result;
}

int main()
{
    int num;
    cin >> num;
    num = DecimalToBinary(num);
    cout <<num;
    return 0;
}

5、表格输出

本题要求编写程序，按照规定格式输出表格。

输入格式：

本题目没有输入。

输出格式：

要求严格按照给出的格式输出下列表格：

------------------------------------
Province      Area(km2)   Pop.(10K)
------------------------------------
Anhui         139600.00   6461.00
Beijing        16410.54   1180.70
Chongqing      82400.00   3144.23
Shanghai        6340.50   1360.26
Zhejiang      101800.00   4894.00
------------------------------------

参考答案：

// 7-5 表格输出

#include <iostream>

using namespace std;

int main()
{
    cout << "------------------------------------" << endl;
    cout << "Province      Area(km2)   Pop.(10K)" << endl;
    cout << "------------------------------------" << endl;
    cout << "Anhui         139600.00   6461.00" << endl;
    cout << "Beijing        16410.54   1180.70" << endl;
    cout << "Chongqing      82400.00   3144.23" << endl;
    cout << "Shanghai        6340.50   1360.26" << endl;
    cout << "Zhejiang      101800.00   4894.00" << endl;
    cout << "------------------------------------" << endl;
}

6、混合类型数据格式化输入

本题要求编写程序，顺序读入浮点数1、整数、字符、浮点数2，再按照字符、整数、浮点数1、浮点数2的顺序输出。

输入格式：

输入在一行中顺序给出浮点数1、整数、字符、浮点数2，其间以1个空格分隔。

输出格式：

在一行中按照字符、整数、浮点数1、浮点数2的顺序输出，其中浮点数保留小数点后2位。

输入样例：

2.12 88 c 4.7

输出样例：

c 88 2.12 4.70

参考答案：

//7-6 混合类型数据格式化输入

#include<iostream>
#include<iomanip>

using namespace std;

int main()
{
    float num1,num2;
    int num;
    char ch;
    cin >> num1;
    cin >> num;
    cin >> ch;
    cin>>num2;

    cout <<fixed<<setprecision(2)<< ch << " "<< num << " "<< num1  << " "<<num2;
}

7、12-24小时制

编写一个程序，要求用户输入24小时制的时间，然后显示12小时制的时间。

输入格式：

输入在一行中给出带有中间的:符号（半角的冒号）的24小时制的时间，如12:34表示12点34分。当小时或分钟数小于10时，均没有前导的零，如5:6表示5点零6分。

提示：在scanf的格式字符串中加入:，让scanf来处理这个冒号。

输出格式：

在一行中输出这个时间对应的12小时制的时间，数字部分格式与输入的相同，然后跟上空格，再跟上表示上午的字符串AM或表示下午的字符串PM。如5:6 PM表示下午5点零6分。注意，在英文的习惯中，中午12点被认为是下午，所以24小时制的12:00就是12小时制的12:0 PM；而0点被认为是第二天的时间，所以是0:0 AM。

输入样例：

21:11

输出样例：

9:11 PM

参考答案：

//7-7 12-24小时制

#include<iostream>
#include<string>

using namespace std;

int main()
{
    string s;
    int len,hour,min;
    cin >> s;
    len = s.find(":");
    hour = stoi(s.substr(0,len));
    min = stoi(s.substr(len+1));

    if(hour<12)
    {
        cout << hour << ":" << min << " AM";
    }
    else if (hour == 12)
    {
        cout << hour << ":" << min << " PM";   
    }
    else
    {
        cout << hour-12 << ":" << min << " PM";
    }

}

8、超速判断

模拟交通警察的雷达测速仪。输入汽车速度，如果速度超出60 mph，则显示“Speeding”，否则显示“OK”。

输入格式：

输入在一行中给出1个不超过500的非负整数，即雷达测到的车速。

输出格式：

在一行中输出测速仪显示结果，格式为：Speed: V - S，其中V是车速，S或者是Speeding、或者是OK。

输入样例1：

输出样例1：

Speed: 40 - OK

输入样例2：

输出样例2：

Speed: 75 - Speeding

参考答案：

//7-8 超速判断

#include<iostream>

using namespace std;

int main()
{
    int num;
    cin >>num;
    if(num >60)
    {
        cout << "Speed: " << num <<" - Speeding";
    }
    else
    {
        cout << "Speed: " << num <<" - OK";
    }
}

9、用天平找小球

三个球A、B、C，大小形状相同且其中有一个球与其他球重量不同。要求找出这个不一样的球。

输入格式：

输入在一行中给出3个正整数，顺序对应球A、B、C的重量。

输出格式：

在一行中输出唯一的那个不一样的球。

输入样例：

1 1 2

输出样例：

参考答案：

//7-9 用天平找小球

#include<iostream>

using namespace std;

int main()
{
    int a,b,c;
    cin >> a >> b >> c;
    if(a == b)
    {
        cout << "C";
    }
    else if(a == c)
    {
        cout << "B";
    }
    else
    {
        cout << "A";
    }
}

10、计算工资

某公司员工的工资计算方法如下：一周内工作时间不超过40小时，按正常工作时间计酬；超出40小时的工作时间部分，按正常工作时间报酬的1.5倍计酬。员工按进公司时间分为新职工和老职工，进公司不少于5年的员工为老职工，5年以下的为新职工。新职工的正常工资为30元/小时，老职工的正常工资为50元/小时。请按该计酬方式计算员工的工资。

输入格式：

输入在一行中给出2个正整数，分别为某员工入职年数和周工作时间，其间以空格分隔。

输出格式：

在一行输出该员工的周薪，精确到小数点后2位。

输入样例1：

5 40

输出样例1：

2000.00

输入样例2：

3 50

输出样例2：

1650.00

参考答案：

// 7-10 计算工资

#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
    int year, hour;
    float salary;
    cin >> year >> hour;
    if (year < 5)
    {
        if (hour <= 40)
        {
            salary = hour * 30;
        }
        else
        {
            salary = (hour - 40) * 30 * 1.5 + 40 * 30;
        }
    }
    else
    {
        if (hour <= 40)
        {
            salary = hour * 50;
        }
        else
        {
            salary = (hour - 40) * 50 * 1.5 + 40 * 50;
        }
    }
    cout << fixed <<setprecision(2)<<salary;
    return 0;
}

11、分段计算居民水费

为鼓励居民节约用水，自来水公司采取按用水量阶梯式计价的办法，居民应交水费y（元）与月用水量x（吨）相关：当x不超过15吨时，y=4x/3；超过后，y=2.5x−17.5。请编写程序实现水费的计算。

输入格式：

输入在一行中给出非负实数x。

输出格式：

在一行输出应交的水费，精确到小数点后2位。

输入样例1：

输出样例1：

16.00

输入样例2：

输出样例2：

22.50

参考答案：

//7-11 分段计算居民水费

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

int main()
{
    float num,money;
    cin >>num;
    if(num < 15)
    {
        money = num * 4 / 3;
    }
    else
    {
        money = num * 2.5 - 17.5;
    }
    cout <<fixed<<setprecision(2)<< money;
    return 0;
}

12、两个数的简单计算器

本题要求编写一个简单计算器程序，可根据输入的运算符，对2个整数进行加、减、乘、除或求余运算。题目保证输入和输出均不超过整型范围。

输入格式：

输入在一行中依次输入操作数1、运算符、操作数2，其间以1个空格分隔。操作数的数据类型为整型，且保证除法和求余的分母非零。

输出格式：

当运算符为+、-、*、/、%时，在一行输出相应的运算结果。若输入是非法符号（即除了加、减、乘、除和求余五种运算符以外的其他符号）则输出ERROR。

输入样例1：

-7 / 2

输出样例1：

-3

输入样例2：

3 & 6

输出样例2：

ERROR

参考答案：

//7-12 两个数的简单计算器

#include<iostream>

using namespace std;

int main()
{
    int a,b;
    char c;
    cin >>a >> c >>b;
    if(c=='+')
    {
        cout << a+b;
    }
    else if(c == '-')
    {
        cout << a-b;
    }
    else if(c == '*')
    {
        cout << a*b;
    }
    else if(c == '/')
    {
        cout << a/b;
    }
    
    else if (c == '%')
    {
        cout << a%b;
    }
    else
    {
        cout <<"ERROR";
    }
    return 0;
}

13、日K蜡烛图

股票价格涨跌趋势，常用蜡烛图技术中的K线图来表示，分为按日的日K线、按周的周K线、按月的月K线等。以日K线为例，每天股票价格从开盘到收盘走完一天，对应一根蜡烛小图，要表示四个价格：开盘价格Open（早上刚刚开始开盘买卖成交的第1笔价格）、收盘价格Close（下午收盘时最后一笔成交的价格）、中间的最高价High和最低价Low。

如果Close<Open，表示为“BW-Solid”（即“实心蓝白蜡烛”）；如果Close>Open，表示为“R-Hollow”（即“空心红蜡烛”）；如果Open等于Close，则为“R-Cross”（即“十字红蜡烛”）。如果Low比Open和Close低，称为“Lower Shadow”（即“有下影线”），如果High比Open和Close高，称为“Upper Shadow”（即“有上影线”）。请编程序，根据给定的四个价格组合，判断当日的蜡烛是一根什么样的蜡烛。

输入格式：

输入在一行中给出4个正实数，分别对应Open、High、Low、Close，其间以空格分隔。

输出格式：

在一行中输出日K蜡烛的类型。如果有上、下影线，则在类型后加上with 影线类型。如果两种影线都有，则输出with Lower Shadow and Upper Shadow。

输入样例1：

5.110 5.250 5.100 5.105

输出样例1：

BW-Solid with Lower Shadow and Upper Shadow

输入样例2：

5.110 5.110 5.110 5.110

输出样例2：

R-Cross

输入样例3：

5.110 5.125 5.112 5.126

输出样例3：

R-Hollow

参考答案：

//7-13 日K蜡烛图

#include<iostream>

using namespace std;

int main()
{
    double open,close,high,low;

    cin >> open>>high>>low>>close;
    if(close < open)
    {
        cout << "BW-Solid";
    }
    else if(close > open)
    {
        cout << "R-Hollow";
    }
    else if(open == close)
    {
        cout << "R-Cross";
    }

    if(low < open && low <close && !(high > open && high > close))
    {
        cout << " with Lower Shadow";
    }
    else if(high > open && high > close && !(low < open && low <close))
    {
        cout << " with Upper Shadow";
    }
    else if(low < open && low <close && high > open && high > close)
    {
        cout << " with Lower Shadow and Upper Shadow";
    }

}

14、求整数段和

给定两个整数A和B，输出从A到B的所有整数以及这些数的和。

输入格式：

输入在一行中给出2个整数A和B，其中−100≤A≤B≤100，其间以空格分隔。

输出格式：

首先顺序输出从A到B的所有整数，每5个数字占一行，每个数字占5个字符宽度，向右对齐。最后在一行中按Sum = X的格式输出全部数字的和X。

输入样例：

-3 8

输出样例：

   -3   -2   -1    0    1
    2    3    4    5    6
    7    8
Sum = 30

参考答案：

//7-14 求整数段和

#include<iostream>
#include<iomanip>

using namespace std;


int main()
{
    int front,end;
    cin >> front>>end;
    int temp = 0;
    int sum = 0 ;
    for(int i = front;i<=end;i++)
    {
        sum +=i;
        cout << setw(5) << i ;
        temp++;
        if(temp % 5 == 0)
        {
            cout << endl;
        }
    }
    if(temp % 5 != 0)
    {
            cout << endl;
    }
    cout << "Sum = " << sum;
}

15、计算圆周率

根据下面关系式，求圆周率的值，直到最后一项的值小于给定阈值。

$\frac{\pi}{2} = 1 + \frac{1}{3} + \frac{2!}{3\times 5} + \frac{3!}{3\times 5\times 7}+ ... + \frac{n!}{3\times 5\times 7 \times ... \times (2n-1)}+...$

输入格式：

输入在一行中给出小于1的阈值。

输出格式：

在一行中输出满足阈值条件的近似圆周率，输出到小数点后6位。

输入样例：

0.01

输出样例：

3.132157

参考答案：

//7-15 计算圆周率

#include<iostream>
#include<iomanip>

using namespace std;

int main()
{
    double num;
    double pai = 0;
    cin>>num;
    double temp = 1; // 暂存1，代表第n项的值，用于跟阈值进行判断
    double denominator =1;//分母
    double molecule = 1;//分子
    double i = 1;
    double j = 0;
    while(temp > num)
    {
        if(j==0)
        {
            temp = 1;
            j+=1;
            i+=2;
            pai += temp;
        }
        else
        {
        molecule *= j;
        j++; 
        denominator *= i ;
        i+=2;
        temp = molecule/denominator;
        pai += temp;
        }
    }
    cout <<fixed<<setprecision(6)<< pai * 2 ;
    return 0;
}

16、求符合给定条件的整数集

给定不超过6的正整数A，考虑从A开始的连续4个数字。请输出所有由它们组成的无重复数字的3位数。

输入格式：

输入在一行中给出A。

输出格式：

输出满足条件的的3位数，要求从小到大，每行6个整数。整数间以空格分隔，但行末不能有多余空格。

输入样例：

输出样例：

234 235 243 245 253 254
324 325 342 345 352 354
423 425 432 435 452 453
523 524 532 534 542 543

参考答案：

//7-16 求符合给定条件的整数集

#include<iostream>

using namespace std;

int main()
{
    int num;
    cin >> num;
    int temp = 0;
    for(int i =num;i<num+4;i++)
    {
        for(int j = num;j<num+4;j++)
        {
            if(i == j) continue;
            for(int k = num;k<num+4;k++)
            {
                if(i == k || j == k) continue;
                temp++;
                cout << i<<j<<k;
                if(temp%6!=0) cout <<" ";
            }
        }
        cout << endl;
    }
}

17、爬动的蠕虫

一条蠕虫长1寸，在一口深为N寸的井的底部。已知蠕虫每1分钟可以向上爬U寸，但必须休息1分钟才能接着往上爬。在休息的过程中，蠕虫又下滑了D寸。就这样，上爬和下滑重复进行。请问，蠕虫需要多长时间才能爬出井？

这里要求不足1分钟按1分钟计，并且假定只要在某次上爬过程中蠕虫的头部到达了井的顶部，那么蠕虫就完成任务了。初始时，蠕虫是趴在井底的（即高度为0）。

输入格式：

输入在一行中顺序给出3个正整数N、U、D，其中D<U，N不超过100。

输出格式：

在一行中输出蠕虫爬出井的时间，以分钟为单位。

输入样例：

12 3 1

输出样例：

参考答案：

//7-17 爬动的蠕虫

#include<iostream>

using namespace std;

int main()
{
    int high,clam,down;
    cin>> high >>clam >> down;

    int now_high = 0;
    now_high+=clam;
    int minutes = 1;
    while(high>now_high)
    {
        now_high -= down;
        minutes++;
        now_high += clam;
        minutes++;
    }
    cout << minutes ;
}

18、二分法求多项式单根

二分法求函数根的原理为：如果连续函数f(x)在区间[a,b]的两个端点取值异号，即f(a)f(b)<0，则它在这个区间内至少存在1个根r，即f(r)=0。

二分法的步骤为：

检查区间长度，如果小于给定阈值，则停止，输出区间中点(a+b)/2；否则
如果f(a)f(b)<0，则计算中点的值f((a+b)/2)；
如果f((a+b)/2)正好为0，则(a+b)/2就是要求的根；否则
如果f((a+b)/2)与f(a)同号，则说明根在区间[(a+b)/2,b]，令a=(a+b)/2，重复循环；
如果f((a+b)/2)与f(b)同号，则说明根在区间[a,(a+b)/2]，令b=(a+b)/2，重复循环。

本题目要求编写程序，计算给定3阶多项式f(x)=a3x3+a2x2+a1x+a0在给定区间[a,b]内的根。

输入格式：

输入在第1行中顺序给出多项式的4个系数a3、a2、a1、a0，在第2行中顺序给出区间端点a和b。题目保证多项式在给定区间内存在唯一单根。

输出格式：

在一行中输出该多项式在该区间内的根，精确到小数点后2位。

输入样例：

3 -1 -3 1
-0.5 0.5

输出样例：

0.33

参考答案：

//7-18 二分法求多项式单根
//setprecision本身就是四舍五入
#include<iostream>
#include<cmath>
#include<iomanip>

using namespace std;

double a3,a2,a1,a0,a,b;

double calculate(double num)
{
    return a3 *pow(num,3) + a2 * pow(num,2) + a1 * num + a0;
    
}

int main()
{
    cin >> a3 >> a2 >> a1 >> a0 >> a >> b;

    // f(x)=a3 *x^3+a2 *x^2 +a1 *x+a0
    double mid_ab = (a + b)/2;
    double mid ;
    double sum_a = calculate(a);
    double sum_b = calculate(b);

    while(b - a >= 0.01)
    {
        if(sum_a == 0)
        {
            //a = round(a*100)/100;
            cout << fixed << setprecision(2) << a;
            return 0;
        }
        else if(sum_b == 0)
        {
            //b = round(b*100)/100;
            cout << fixed << setprecision(2) << b;
            return 0;
        }
        if(sum_a*sum_b<0)
        {
            mid = calculate(mid_ab);
            if(mid == 0.00 )
            {
                //mid_ab = round(mid_ab*100)/100;
                cout << fixed << setprecision(2) << mid_ab;
                return 0;
            }
            else if( sum_a * mid > 0)//a和mid同号,区间缩到 mid--b
            {
                a = mid_ab;
                sum_a = calculate(a);
                mid_ab = (a+b)/2;
            }
            else if(sum_b * mid > 0)
            {
                b = mid_ab;
                sum_b = calculate(b);
                mid_ab = (a+b)/2;
            }
        }
    }
    //mid_ab = round((a+b)/2*100)/100;
    cout << fixed << setprecision(2) <<mid_ab;
    return 0;

}

19、支票面额

一个采购员去银行兑换一张y元f分的支票，结果出纳员错给了f元y分。采购员用去了n分之后才发觉有错，于是清点了余额尚有2y元2f分，问该支票面额是多少？

输入格式：

输入在一行中给出小于100的正整数n。

输出格式：

在一行中按格式y.f输出该支票的原始面额。如果无解，则输出No Solution。

输入样例1：

输出样例1：

25.51

输入样例2：

输出样例2：

No Solution

参考答案：

//7-19 支票面额

#include<iostream>

using namespace std;

int main()
{
    int yuan,fen,money,n;

    cin >> n;

    //因为原本是y元f分，所以f<100
    //而给成了f元y分，所以y<100

    for(yuan = 0;yuan<100;yuan++)
    {
        for(fen = 0;fen<100;fen++)
        {
            if(2*yuan*100 + 2*fen + n == fen*100 + yuan)
            {
                cout << yuan << "." << fen <<endl;
                return 0;
            }
        }
    }
    cout << "No Solution" << endl;

    return 0;
}

20、打印九九口诀表

下面是一个完整的下三角九九口诀表：

1*1=1   
1*2=2   2*2=4   
1*3=3   2*3=6   3*3=9   
1*4=4   2*4=8   3*4=12  4*4=16  
1*5=5   2*5=10  3*5=15  4*5=20  5*5=25  
1*6=6   2*6=12  3*6=18  4*6=24  5*6=30  6*6=36  
1*7=7   2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49  
1*8=8   2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64  
1*9=9   2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81

本题要求对任意给定的一位正整数N，输出从1*1到N*N的部分口诀表。

输入格式：

输入在一行中给出一个正整数N（1≤N≤9）。

输出格式：

输出下三角N*N部分口诀表，其中等号右边数字占4位、左对齐。

输入样例：

输出样例：

1*1=1   
1*2=2   2*2=4   
1*3=3   2*3=6   3*3=9   
1*4=4   2*4=8   3*4=12  4*4=16

参考答案：

//7-20 打印九九口诀表

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

int main()
{
    int num;
    cin >> num;

    for(int i = 1;i<=num;i++)
    {
        for(int j = 1;j<=i;j++)
        {
            cout << j << "*" << i << "=" <<setw(4)<<setiosflags(ios::left) << i*j;//设置宽度为4，左对齐
            // <<setw(4)<<left<< i*j  效果一样，但是还是不要这么写，不好区分变量和关键字（流操纵算子）
        }
        cout<<endl;
    }
    return 0;
}

21、求特殊方程的正整数解

本题要求对任意给定的正整数N，求方程 $X^2+Y^2=N$ 的全部正整数解。

输入格式：

输入在一行中给出正整数N（≤10000）。

输出格式：

输出方程 $X^2+Y^2=N$ 的全部正整数解，其中X≤Y。每组解占1行，两数字间以1空格分隔，按X的递增顺序输出。如果没有解，则输出No Solution。

输入样例1：

输出样例1：

10 28
20 22

输入样例2：

输出样例2：

No Solution

参考答案：

//7-21 求特殊方程的正整数解

#include<iostream>

int main()
{
    int num;
    std::cin >> num;

    int x,y;
    int sum ;
    bool exist = false;
    
    for(y=100;y>0;y--)
    {
        for(x=1;x<=y;x++)
        {
            sum = x*x + y*y;
            if(sum == num)
            {
                std::cout << x << " " << y <<std::endl;
                exist = true;
            }
        }
    }
        
    
    if(exist == false)std::cout<< "No Solution";

    return 0;
}

22、龟兔赛跑

乌龟与兔子进行赛跑，跑场是一个矩型跑道，跑道边可以随地进行休息。乌龟每分钟可以前进3米，兔子每分钟前进9米；兔子嫌乌龟跑得慢，觉得肯定能跑赢乌龟，于是，每跑10分钟回头看一下乌龟，若发现自己超过乌龟，就在路边休息，每次休息30分钟，否则继续跑10分钟；而乌龟非常努力，一直跑，不休息。假定乌龟与兔子在同一起点同一时刻开始起跑，请问T分钟后乌龟和兔子谁跑得快？

输入格式：

输入在一行中给出比赛时间T（分钟）。

输出格式：

在一行中输出比赛的结果：乌龟赢输出@_@，兔子赢输出^_^，平局则输出-_-；后跟1空格，再输出胜利者跑完的距离。

输入样例：

输出样例：

@_@ 726

参考答案：

//7-22 龟兔赛跑\

#include<iostream>


int main()
{
    int minute;
    std::cin>>minute;

    int rabbit_speed = 9;
    int rabbit_distance = 0;
    int turtle_speed = 3;
    int turtle_distance = 0;

    int i=0;
    while(i<minute)
    {
        i++;
        rabbit_distance+=9;
        turtle_distance+=3;
        
        if(i%10==0 && rabbit_distance>turtle_distance)
        {
            if(i+30<minute)
            {
                turtle_distance += 90;
                i+=30;
            }
            else
            {
                turtle_distance += 3* (minute - i);
                break;
            }
        }
    }

    if(rabbit_distance>turtle_distance)
    {
        std::cout << "^_^ " << rabbit_distance;
    }
    else if(rabbit_distance<turtle_distance)
    {
        std::cout << "@_@ " << turtle_distance;
    }
    else if(rabbit_distance == turtle_distance)
    {
        std::cout << "-_- " << turtle_distance ;//平局
    }
    return 0;
}

23、币值转换

输入一个整数（位数不超过9位）代表一个人民币值（单位为元），请转换成财务要求的大写中文格式。如23108元，转换后变成“贰万叁仟壹百零捌”元。为了简化输出，用小写英文字母a-j顺序代表大写数字0-9，用S、B、Q、W、Y分别代表拾、百、仟、万、亿。于是23108元应被转换输出为“cWdQbBai”元。

输入格式：

输入在一行中给出一个不超过9位的非负整数。

输出格式：

在一行中输出转换后的结果。注意“零”的用法必须符合中文习惯。

输入样例1：

813227345

输出样例1：

iYbQdBcScWhQdBeSf

输入样例2：

输出样例2：

gQjB

参考答案：

// 7-23 币值转换

#include <iostream>
#include <vector>
#include <algorithm>
int main()
{
    std::string num;
    std::cin >> num;

    std::vector<char> str;

    int danwei = 0;
    for (int i = num.size() - 1; i >= 0; i--,danwei++)
    {
        switch ( danwei )
        {
            case 0:break;
            case 1:str.push_back('S');break;
            case 2:str.push_back('B');break;
            case 3:str.push_back('Q');break;
            case 4:str.push_back('W');break;
            case 5:str.push_back('S');break;
            case 6:str.push_back('B');break;
            case 7:str.push_back('Q');break;
            case 8:str.push_back('Y');break;
            default:break;
        }
        switch ( num[i] )
        {
            case '0':str.push_back('a');break;
            case '1':str.push_back('b');break;
            case '2':str.push_back('c');break;
            case '3':str.push_back('d');break;
            case '4':str.push_back('e');break;
            case '5':str.push_back('f');break;
            case '6':str.push_back('g');break;
            case '7':str.push_back('h');break;
            case '8':str.push_back('i');break;
            case '9':str.push_back('j');break;
            default:break;
        }
    }

    bool cunling = false;
    if(str.size()==1&&str.back()=='a')
    {
        std::cout<<'a';
        return 0;
    }

    while(!str.empty())
    {
        if(str.back()=='a')
        {
            cunling =true;
            int temp = 0;
            str.pop_back();
            if(!str.empty() && str.back()!='W')str.pop_back();
        }
        else{
            if(cunling && str.back()!='W')std::cout<<'a';
            std::cout<<str.back();
            str.pop_back();
            cunling = false;
        }
    }
}

24、约分最简分式

分数可以表示为分子/分母的形式。编写一个程序，要求用户输入一个分数，然后将其约分为最简分式。最简分式是指分子和分母不具有可以约分的成分了。如6/12可以被约分为1/2。当分子大于分母时，不需要表达为整数又分数的形式，即11/8还是11/8；而当分子分母相等时，仍然表达为1/1的分数形式。

输入格式：

输入在一行中给出一个分数，分子和分母中间以斜杠/分隔，如：12/34表示34分之12。分子和分母都是正整数（不包含0，如果不清楚正整数的定义的话）。

提示：

对于C语言，在scanf的格式字符串中加入/，让scanf来处理这个斜杠。
对于Python语言，用a,b=map(int, input().split('/'))这样的代码来处理这个斜杠。

输出格式：

在一行中输出这个分数对应的最简分式，格式与输入的相同，即采用分子/分母的形式表示分数。如
5/6表示6分之5。

输入样例：

66/120

输出样例：

11/20

参考答案：

//7-24 约分最简分式

#include<iostream>
int gcd_force(int a,int b)//待求最大公约数的两个数
{
    int min = a; //默认传入第一个参数为较小的值
    int gcd = 0; //默认最大公约数是0
    if(min <b) min =b; //选择两个数中较小的那一个
    for(int i=1;i<=min;i++) // 寻找最大公约数从1到较小的那个数即可
    {
        if(a%i==0 && b%i==0) //判断是不是公约数 循环到最后gcd即是最大公约数
        {
            gcd = i;
        }
    }
    return gcd; //返回最大公约数
}
int gcd_Euclid(int a,int b)
{
    int max = a; //默认第一个参数为较大的值
    int min = b; //默认第二个参数为较小的值
    int temp; //临时变量，用来存储余数
    if(max < b) //判断两个值正确的大小
    {   
        max = b;
        min = a;
    }
    while(max%min!=0) //辗转相除，直到余数为0，此时min为最大公约数
    {
        temp = max%min; // 保存余数
        max = min;  // 将除数挪到被除数
        min = temp; // 将余数挪到除数
    }
    return min; //返回最大公约数
}
int main()
{
    int a,b;
    scanf("%d/%d",&a,&b);
    int gcd_num = gcd_Euclid(a,b);
    printf("%d/%d",a/gcd_num,b/gcd_num);
}

25、念数字

输入一个整数，输出每个数字对应的拼音。当整数为负数时，先输出fu字。十个数字对应的拼音如下：

0: ling
1: yi
2: er
3: san
4: si
5: wu
6: liu
7: qi
8: ba
9: jiu

输入格式：

输入在一行中给出一个整数，如：1234。

提示：整数包括负数、零和正数。

输出格式：

在一行中输出这个整数对应的拼音，每个数字的拼音之间用空格分开，行末没有最后的空格。如
yi er san si。

输入样例：

-600

输出样例：

fu liu ling ling

参考答案：

//7-25 念数字

#include<iostream>
#include<vector>

int main()
{
    std::string num;
    std::cin >>num;

    for(int i = 0;i<num.size();i++)
    {
        switch (num[i])
        {
        case '-':std::cout<<"fu";break;
        case '0':std::cout<<"ling";break;
        case '1':std::cout<<"yi";break;
        case '2':std::cout<<"er";break;
        case '3':std::cout<<"san";break;
        case '4':std::cout<<"si";break;
        case '5':std::cout<<"wu";break;
        case '6':std::cout<<"liu";break;
        case '7':std::cout<<"qi";break;
        case '8':std::cout<<"ba";break;
        case '9':std::cout<<"jiu";break;
        }
        if(i!=num.size()-1)std::cout<<" ";
    }


}

26、单词长度

你的程序要读入一行文本，其中以空格分隔为若干个单词，以.结束。你要输出每个单词的长度。这里的单词与语言无关，可以包括各种符号，比如it's算一个单词，长度为4。注意，行中可能出现连续的空格；最后的.不计算在内。

输入格式：

输入在一行中给出一行文本，以.结束

提示：用scanf("%c",...);来读入一个字符，直到读到.为止。

输出格式：

在一行中输出这行文本对应的单词的长度，每个长度之间以空格隔开，行末没有最后的空格。

输入样例：

It's great to see you here.

输出样例：

4 5 2 3 3 4

参考答案：

//7-26 单词长度
#include<iostream>
#include<string>

int main()
{
    std::string str;

    int count = 0;
    bool qian_space = false;

    while (std::cin >> str)
    {
        for (int i = 0; i < str.size(); i++)
        {
            if (str[i] == '.')
            {
                if(count!=0)
                {
                    if(qian_space==false)
        {
            std::cout<<count;
            qian_space =true;
        }
        else{
            std::cout<< " " <<count;
        }
                }
                return 0;
            }
            count++;
        }
        if(qian_space==false)
        {
            std::cout<<count;
            qian_space =true;
        }
        else{
            std::cout<< " " <<count;
        }
        count =0;
    }
    return 0;
}

27、冒泡法排序

将N个整数按从小到大排序的冒泡排序法是这样工作的：从头到尾比较相邻两个元素，如果前面的元素大于其紧随的后面元素，则交换它们。通过一遍扫描，则最后一个元素必定是最大的元素。然后用同样的方法对前N−1个元素进行第二遍扫描。依此类推，最后只需处理两个元素，就完成了对N个数的排序。

本题要求对任意给定的K（<N），输出扫描完第K遍后的中间结果数列。

输入格式：

输入在第1行中给出N和K（1≤K<N≤100），在第2行中给出N个待排序的整数，数字间以空格分隔。

输出格式：

在一行中输出冒泡排序法扫描完第K遍后的中间结果数列，数字间以空格分隔，但末尾不得有多余空格。

输入样例：

6 2
2 3 5 1 6 4

输出样例：

2 1 3 4 5 6

参考答案：

//7-27 冒泡法排序

#include<iostream>

int main()
{
    int n,k;
    std::cin>>n>>k;

    int *nums = new int[n];
    for(int i=0;i<n;i++)
    {
        std::cin>>nums[i];
    }    

    for(int i=0;i<k;i++)
    {
        for(int j=0;j<n-i-1;j++)
        {
            if(nums[j]>nums[j+1])
            {
                int temp = nums[j];
                nums[j] = nums[j+1];
                nums[j+1] = temp;
            }
        }
    }

    for(int i=0;i<n;i++)
    {
        std::cout<<nums[i];
        if(i!=n-1) std::cout<<" ";
    }    
}

28、猴子选大王

一群猴子要选新猴王。新猴王的选择方法是：让N只候选猴子围成一圈，从某位置起顺序编号为1~N号。从第1号开始报数，每轮从1报到3，凡报到3的猴子即退出圈子，接着又从紧邻的下一只猴子开始同样的报数。如此不断循环，最后剩下的一只猴子就选为猴王。请问是原来第几号猴子当选猴王？

输入格式：

输入在一行中给一个正整数N（≤1000）。

输出格式：

在一行中输出当选猴王的编号。

输入样例：

输出样例：

参考答案：

#include<stdio.h>
int main()
{   
   int i,j,k,temp;
   int m[1001];   
   int n;
   scanf("%d",&n);
   for(i=0;i<n;i++)   
   {       
       m[i]=i+1;
   }   
    //长度减一去掉第三个
   for(i=n-1;i>=0;i--)
   {       
    //将第三个移到最后
     for(k=1;k<=3;k++)
        {           
          temp=m[0];      
        //每个元素循环向前移动     
        for(j=0;j<i;j++)
           {               
              m[j]=m[j+1];           
           }           
           m[i]=temp;   
        }   
    }   
    //直到长度为1，此时为最后的一个猴子
    printf("%d",m[0]);   
    return 0;
}

29、删除字符串中的子串

输入2个字符串S1和S2，要求删除字符串S1中出现的所有子串S2，即结果字符串中不能包含S2。

输入格式：

输入在2行中分别给出不超过80个字符长度的、以回车结束的2个非空字符串，对应S1和S2。

输出格式：

在一行中输出删除字符串S1中出现的所有子串S2后的结果字符串。

输入样例：

Tomcat is a male ccatat
cat

输出样例：

Tom is a male

参考答案：

// 7-29 删除字符串中的子串

#include <iostream>
#include <stdio.h>

int main()
{
    std::string str1, str2;

    std::getline(std::cin, str1);
    std::getline(std::cin, str2);
    int left = 0;
    int right = 0;
    int key = 0;

    for (left = 0; left < str1.size(); left++)
    {
        if (str1[left] == str2[key])
        {
            for (right = left, key; key < str2.size() && right < str1.size(); key++, right++)
            {

                if (str1[right] == str2[key] && key == str2.size() - 1)
                {
                    for (int i = 0; i < str1.size()-left-1; i++)
                    {
                        str1[right - str2.size()+1] = str1[right+1];
                        right++;
                    }
                    str1 = str1.substr(0, str1.size() - str2.size());
                    key = 0;
                    left = -1;
                    break;
                }
                else if(str1[right]!=str2[key])
                {
                    key = 0;
                    break;
                }
                
            }
        }

    }
    std::cout << str1 << std::endl;
}

30、字符串的冒泡排序

我们已经知道了将N个整数按从小到大排序的冒泡排序法。本题要求将此方法用于字符串序列，并对任意给定的K（<N），输出扫描完第K遍后的中间结果序列。

输入格式：

输入在第1行中给出N和K（1≤K<N≤100），此后N行，每行包含一个长度不超过10的、仅由小写英文字母组成的非空字符串。

输出格式：

输出冒泡排序法扫描完第K遍后的中间结果序列，每行包含一个字符串。

输入样例：

6 2
best
cat
east
a
free
day

输出样例：

best
a
cat
day
east
free

参考答案：

//7-30 字符串的冒泡排序

#include<iostream>

int main()
{
    int num,k;
    
    std::cin>>num>>k;
    std::string nums[num];
    
    for(int i=0;i<num;i++)
    {
        std::cin>>nums[i];
    }

    for(int i =0;i<k;i++)
    {
        for (int j = 0; j < num - 1; j++)
        {
            for (int k = 0; k < nums[j].size(); k++)
            {
                if (nums[j][k] > nums[j + 1][k])
                {
                    std::string temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                    break;
                }
                else if(nums[j][k] < nums[j + 1][k])
                {
                    break;
                }
            }
        }
    }

    for(int i=0;i<num;i++)
    {
        std::cout<<nums[i]<<std::endl;
    }

}

31、字符串循环左移

输入一个字符串和一个非负整数N，要求将字符串循环左移N次。

输入格式：

输入在第1行中给出一个不超过100个字符长度的、以回车结束的非空字符串；第2行给出非负整数N。

输出格式：

在一行中输出循环左移N次后的字符串。

输入样例：

Hello World!
2

输出样例：

llo World!He

参考答案：

// 7-31 字符串循环左移

#include <iostream>

int main()
{
    std::string str;
    std::getline(std::cin, str);
    int num;
    std::cin >> num;

    for (int i = 0; i < num; i++)
    {
        char ch = str[0];
        int j = 0;
        for (j; j < str.size() - 1; j++)
        {
            str[j] = str[j + 1];
        }
        str[j] = ch;
    }

    std::cout << str;
}

32、说反话-加强版

给定一句英语，要求你编写程序，将句中所有单词的顺序颠倒输出。

输入格式：

测试输入包含一个测试用例，在一行内给出总长度不超过500 000的字符串。字符串由若干单词和若干空格组成，其中单词是由英文字母（大小写有区分）组成的字符串，单词之间用若干个空格分开。

输出格式：

每个测试用例的输出占一行，输出倒序后的句子，并且保证单词间只有1个空格。

输入样例：

Hello World   Here I Come

输出样例：

Come I Here World Hello

参考答案：

//7-32 说反话-加强版

#include<iostream>
#include<vector>
int main()
{
    std::string str;
    std::cin>>str;
    std::vector<std::string> result;
    while(!str.empty())
    {
        result.push_back(str);
        str.clear();
        std::cin>>str;
    }
    while(!result.empty())
    {
        std::cout<<result.back();
        result.pop_back();
        if(!result.empty())
        {
            std::cout<<" ";
        }
    }
}

33、有理数加法

本题要求编写程序，计算两个有理数的和。

输入格式：

输入在一行中按照a1/b1 a2/b2的格式给出两个分数形式的有理数，其中分子和分母全是整形范围内的正整数。

输出格式：

在一行中按照a/b的格式输出两个有理数的和。注意必须是该有理数的最简分数形式，若分母为1，则只输出分子。

输入样例1：

1/3 1/6

输出样例1：

1/2

输入样例2：

4/3 2/3

输出样例2：

参考答案：

//7-33 有理数加法

#include<iostream>

int gcd_Euclid(int a,int b)
{
    int max = a;
    int min = b;
    int temp;

    if(max<b)
    {
        max = b;
        min = a;
    }
    while(max%min!=0)
    {
        temp = max%min;
        max = min;
        min = temp;
    }
    return min;
}

int main()
{
    int a1,b1,a2,b2;
    scanf("%d/%d %d/%d",&a1,&b1,&a2,&b2);
    int molecule;
    int denominator = b1;

    if(b1!=b2)
    {
        denominator = b1 * b2;
        a1 = a1 * b2;
        a2 = a2 * b1;
    }
    molecule = a1 + a2;

    int gcd_num = gcd_Euclid(molecule,denominator);

    molecule = molecule/gcd_num;
    denominator = denominator/gcd_num;
    if(denominator!=1)
    {
        std::cout<<molecule<<"/"<<denominator;
    }
    else
    {
        std::cout<<molecule;
    }
    return 0;
}

34、通讯录的录入与显示

通讯录中的一条记录包含下述基本信息：朋友的姓名、出生日期、性别、固定电话号码、移动电话号码。
本题要求编写程序，录入N条记录，并且根据要求显示任意某条记录。

输入格式：

输入在第一行给出正整数N（≤10）；随后N行，每行按照格式姓名生日性别固话手机给出一条记录。其中姓名是不超过10个字符、不包含空格的非空字符串；生日按yyyy/mm/dd的格式给出年月日；性别用M表示“男”、F表示“女”；固话和手机均为不超过15位的连续数字，前面有可能出现+。

在通讯录记录输入完成后，最后一行给出正整数K，并且随后给出K个整数，表示要查询的记录编号（从0到N−1顺序编号）。数字间以空格分隔。

输出格式：

对每一条要查询的记录编号，在一行中按照姓名固话手机性别生日的格式输出该记录。若要查询的记录不存在，则输出Not Found。

输入样例：

3
Chris 1984/03/10 F +86181779452 13707010007
LaoLao 1967/11/30 F 057187951100 +8618618623333
QiaoLin 1980/01/01 M 84172333 10086
2 1 7

输出样例：

LaoLao 057187951100 +8618618623333 F 1967/11/30
Not Found

参考答案：

// 7-34 通讯录的录入与显示

#include <iostream>
#include <vector>

struct Person
{
    std::string name;
    std::string birthday;
    char gender;
    std::string phone;
    std::string mobile_phone;

    
};

int main()
{
    int count;
    std::cin >> count;
    getchar();
    std::vector<Person> mail_list(count);

    std::string str;
    for (int i = 0; i < count; i++)
    {
        std::cin >> mail_list[i].name;
        std::cin >> mail_list[i].birthday;
        std::cin >> mail_list[i].gender;
        std::cin >> mail_list[i].phone;
        std::cin >> mail_list[i].mobile_phone;
    }

    int search_count;
    std::cin >> search_count;
    int search_num[search_count];
    int num = 0;
    while(search_count)
    {
        std::cin>>search_num[num];
        num++;
        search_count--;
    }
    for(int i=0;i<num;i++)
    {
        if (search_num[i] >= count || search_num[i]<0)
        {
            std::cout << "Not Found" <<std::endl;
        }
        else
        {
            std::cout << mail_list[search_num[i]].name << " ";
            std::cout << mail_list[search_num[i]].phone << " ";
            std::cout << mail_list[search_num[i]].mobile_phone << " ";
            std::cout << mail_list[search_num[i]].gender << " ";
            std::cout << mail_list[search_num[i]].birthday << std::endl;
        }
        search_count--;
    }
}

35、有理数均值

本题要求编写程序，计算N个有理数的平均值。

输入格式：

输入第一行给出正整数N（≤100）；第二行中按照a1/b1 a2/b2 …的格式给出N个分数形式的有理数，其中分子和分母全是整形范围内的整数；如果是负数，则负号一定出现在最前面。

输出格式：

在一行中按照a/b的格式输出N个有理数的平均值。注意必须是该有理数的最简分数形式，若分母为1，则只输出分子。

输入样例1：

4
1/2 1/6 3/6 -5/10

输出样例1：

1/6

输入样例2：

2
4/3 2/3

输出样例2：

参考答案：

// 7-35 有理数均值

#include <iostream>

int gcd_Euclid(int a, int b)
{
    //a为分子，b为分母
    //a可能为0，b一定不为0，所以下边可以改
    if (a == 0 || b == 0)
    {
        return 0;
    }
    int max = a;
    int min = b;
    int temp;
    if (min > max)
    {
        max = b;
        min = a;
    }
    while (max % min != 0)
    {
        temp = max % min;
        max = min;
        min = temp;
    }
    return min;
}

int main()
{
    int num, result, molecule1, denominator1, molecule2, denominator2;

    std::cin >> num;
    scanf("%d/%d", &molecule1, &denominator1);//格式化输入分数
    int gcd_num = gcd_Euclid(molecule1, denominator1);//求最大公约数
    //由于分母不能为0，所以当最大公约数为0时，分子一定是0，直接将分子置0，分母置1，以应对接下来的加法通分
    if (gcd_num == 0)
    {
        molecule1 = 0;
        denominator1 = 1;
    }
    else
    {
        molecule1 = molecule1 / gcd_num;
        denominator1 = denominator1 / gcd_num;
    }

    for (int i = 1; i < num; i++)
    {
        scanf("%d/%d", &molecule2, &denominator2);
        molecule1 = molecule1 * denominator2 + molecule2 * denominator1;
        denominator1 = denominator1 * denominator2;
        gcd_num = gcd_Euclid(molecule1, denominator1);
        if (gcd_num == 0)
        {
            molecule1 = 0;
            denominator1 = 1;
        }
        else
        {
            molecule1 = molecule1 / gcd_num;
            denominator1 = denominator1 / gcd_num;
        }
    }

    denominator1 = denominator1 * num;
    gcd_num = gcd_Euclid(molecule1, denominator1);
    if (gcd_num == 0)
    {
        molecule1 = 0;
        denominator1 = 1;
    }
    else
    {
        molecule1 = molecule1 / gcd_num;
        denominator1 = denominator1 / gcd_num;
    }
    
    if (molecule1 == 0)//分子为0时直接打印0
    {
        printf("0");
    }
    else if (denominator1 != 1)//分母不为1，分子分母都要打印
    {
        printf("%d/%d", molecule1, denominator1);
    }
    else//分母为1时只打印分母
    {
        printf("%d", molecule1);
    }
    return 0;
}

36、复数四则运算

本题要求编写程序，计算2个复数的和、差、积、商。

输入格式：

输入在一行中按照a1 b1 a2 b2的格式给出2个复数C1=a1+b1i和C2=a2+b2i的实部和虚部。题目保证C2不为0。

输出格式：

分别在4行中按照(a1+b1i) 运算符 (a2+b2i) = 结果的格式顺序输出2个复数的和、差、积、商，数字精确到小数点后1位。如果结果的实部或者虚部为0，则不输出。如果结果为0，则输出0.0。

输入样例1：

2 3.08 -2.04 5.06

输出样例1：

(2.0+3.1i) + (-2.0+5.1i) = 8.1i
(2.0+3.1i) - (-2.0+5.1i) = 4.0-2.0i
(2.0+3.1i) * (-2.0+5.1i) = -19.7+3.8i
(2.0+3.1i) / (-2.0+5.1i) = 0.4-0.6i

输入样例2：

1 1 -1 -1.01

输出样例2：

(1.0+1.0i) + (-1.0-1.0i) = 0.0
(1.0+1.0i) - (-1.0-1.0i) = 2.0+2.0i
(1.0+1.0i) * (-1.0-1.0i) = -2.0i
(1.0+1.0i) / (-1.0-1.0i) = -1.0

参考答案：

//7-36 复数四则运算

#include<iostream>
#include<iomanip>
#include<math.h>


double a1,b1,a2,b2,c1,c2;
double real_part;
double imaginary_part ;

//要么前边加这些东西  其实写print_result就够了，要么把print_result放第一个，因为要执行的函数必须在执行它时已经声明，大概是这么个意思，不太懂专业术语怎么说
void sum(double a1,double b1,double a2,double b2);
void diffence(double a1,double b1,double a2,double b2);
void product(double a1,double b1,double a2,double b2);
void quotient(double a1,double b1,double a2,double b2);
void print_result(char operator_char);

void sum(double a1,double b1,double a2,double b2)
{
    real_part = round((a1 + a2)*10)/10;
    imaginary_part = round((b1 + b2)*10)/10;
    print_result('+');
}

void diffence(double a1,double b1,double a2,double b2)
{
    real_part = round((a1-a2)*10)/10;
    imaginary_part = round((b1 - b2)*10)/10;
    print_result('-');
}

void product(double a1,double b1,double a2,double b2)
{
    real_part = round((a1 * a2 + (-1)* b1 * b2)*10)/10;
    imaginary_part = round((a1 * b2 + a2 * b1)*10)/10;
    print_result('*');
}

void quotient(double a1,double b1,double a2,double b2)
{
    real_part = round((a1*a2 + b1*b2)/(a2*a2 + b2*b2)*10)/10;
    imaginary_part = round((b1*a2-a1*b2)/(a2*a2+b2*b2)*10)/10;
    print_result('/');
}

void print_result(char operator_char)
{
    if(a1!=0 || b1!=0)
    {
        printf("(%.1lf",a1);
        if(b1>=0)
        {
            printf("+");
        }
        printf("%.1lfi) %c ",b1,operator_char);
    }

    if(a2!=0 || b2!=0)
    {
        printf("(%.1lf",a2);
        if(b2>=0)
        {
            printf("+");
        }
        printf("%.1lfi) = ",b2);
    }

    if(real_part != 0 && imaginary_part !=0)
    {
        printf("%.1lf",real_part);
        if(imaginary_part>=0)
        {
            printf("+");
        }
        printf("%.1lfi\n",imaginary_part);
    }
    else if(real_part != 0 && imaginary_part ==0)
    {
        printf("%.1lf\n",real_part);
    }
    else if(real_part == 0 && imaginary_part !=0)
    {
        printf("%.1lfi\n",imaginary_part);
    }
    if(real_part==0 && imaginary_part==0)
    {
        printf("0.0\n");
    }
}


int main()
{
    scanf("%lf %lf %lf %lf",&a1,&b1,&a2,&b2);


    sum(a1,b1,a2,b2);
    diffence(a1,b1,a2,b2);
    product(a1,b1,a2,b2);
    quotient(a1,b1,a2,b2);
}

37、整数分解为若干项之和

将一个正整数N分解成几个正整数相加，可以有多种分解方法，例如7=6+1，7=5+2，7=5+1+1，…。编程求出正整数N的所有整数分解式子。

输入格式：

每个输入包含一个测试用例，即正整数N (0<N≤30)。

输出格式：

按递增顺序输出N的所有整数分解式子。递增顺序是指：对于两个分解序列N1={n1,n2,⋯}和N2={m1,m2,⋯}，若存在i使得n1=m1,⋯,ni=mi，但是ni+1<mi+1,则N1序列必定在N2序列之前输出。每个式子由小到大相加，式子间用分号隔开，且每输出4个式子后换行。

输入样例：

输出样例：

7=1+1+1+1+1+1+1;7=1+1+1+1+1+2;7=1+1+1+1+3;7=1+1+1+2+2
7=1+1+1+4;7=1+1+2+3;7=1+1+5;7=1+2+2+2
7=1+2+4;7=1+3+3;7=1+6;7=2+2+3
7=2+5;7=3+4;7=7

参考答案：

//7-37 整数分解为若干项之和
//https://www.cxybb.com/article/royzdr/78894938

#include<iostream>

int top = -1;
int n = 0;
int i = 0;
int cnt = 1;
int sum = 0;
int s[31] = {0};

void division(int i);

int main()
{
    scanf("%d", &n);
    division(1);
    system("pause");
}
void division (int i)
{
    int j;
    if(sum>n)
    {
        return;
    }
    if(sum == n)
    {
        printf("%d=", n);
        for(j=0; j<top; j++)
        {
            printf("%d+", s[j]);
        }
        if(cnt%4==0 || s[j]==n)
        {
            printf("%d\n", s[j]);
        }
        else
        {
            printf("%d;",s[j]);
        }
        cnt++;
        return;
    }
    for(j=i; j<=n; j++)
    {
        s[++top] = j;
        sum += j;
        division(j);
        top--;
        sum -= j;
    }
}

38、数列求和-加强版

给定某数字A（1≤A≤9）以及非负整数N（0≤N≤100000），求数列之和S=A+AA+AAA+⋯+AA⋯A（N个A）。例如A=1, N=3时，S=1+11+111=123。

输入格式：

输入数字A与非负整数N。

输出格式：

输出其N项数列之和S的值。

输入样例：

1 3

输出样例：

参考答案：

//7-38 数列求和-加强版

#include<iostream>
#include<vector>


int main()
{
    int num,num_length,sum;
    std::cin>>num>>num_length;
    int temp =0;

    std::vector<int> result(num_length+1);
    
    // 超时写法hhhhhh
    // for(int i=1;i<=num_length;i++)
    // {
    //     std::vector<int> num_vec(i,num);
    //     for(int j=0;j<i;j++)
    //     {
    //         result[j] += num_vec[j]+temp;
    //         temp = result[j]/10;
    //         result[j] = result[j]%10;
            
    //     }
    //     result[i] +=temp;
    // }

    // for(int i=0;i<num_length;i++)
    // {
    //     int sum = num *(num_length-i);
    //     result[i] = (sum + temp)%10;
    //     temp = (sum + temp) /10;
    // }
    // if(temp!=0)
    // {
    //     result[result.size()-1]=temp;
    // }
    // 如果不等于num_length 那就要判断最后是否有超出长度的最后一个进位
    // 等于num_length能在最后再加一次，此时sum=0，无影响，只加了是否进位的tmep，即使为0，后边的非零出栈依旧可以处理，去掉前置零
    for(int i=0;i<=num_length;i++)
    {
        int sum = num *(num_length-i);
        result[i] = (sum + temp)%10;
        temp = (sum + temp) /10;
    }

    if(result.back()==0 && result.size()!=1)
    {
        result.pop_back();
    }

    for(int i=result.size()-1;i>=0;i--)
    {
        std::cout<<result[i];
    }
}

2048 AI社区

有“AI”的1024 = 2048，欢迎大家加入2048 AI社区

更多推荐

数据湖中的AI技术集成：架构师的实战解决方案

数据湖是企业数字化转型的“数据资产仓库”，但传统数据湖的“原始数据堆”模式难以满足AI对结构化、高质量、可复用数据的需求。本文从架构师视角出发，结合实战经验，系统讲解数据湖与AI技术集成的全流程：从数据治理（让数据“可找到、可信任”）到特征工程（将数据转化为AI能理解的“语言”），再到模型部署（让AI真正产生业务价值）。通过“仓库-工厂”的生活化比喻、具体的架构设计（湖仓一体）、代码示例（Feas

2048 AI社区

表格数据的机器学习（五）

第七章中展示的东京 Airbnb 问题的 XGBoost 解决方案提供了一个基线，我们可以用它来评估深度学习解决相同问题的有效性。以第七章中的 XGBoost 解决方案为起点，我们可以为东京 Airbnb 问题创建一个深度学习解决方案。fastai 库提供了一个紧凑且相对性能良好的深度学习解决方案。通过在从 100% XGBoost 到 100% fastai 的一系列比例中混合 XGBoost