练习题31-45 翻译59

935962026-03-28 9:54

题目31:丑数

作者: Turbo

时间限制: 1s

章节: 枚举

问题描述

对于一给定的素数集合 S = {p1, p2, ..., pK}, 来考虑那些质因数全部属于S 的数的集合。

这个集合包括，p1, p1p2（即p1乘以p2）, p1p3, 和 p1p2p3 (还有其它很多)。

这是个对于一个集合S的丑数集合。注意：我们不认为1 是一个丑数。

你的工作是对于输入的集合S去寻找集合中的第N个丑数。

说明：结果不超过32位整数能表示的范围

比如：S={2, 3, 5, 7}

则前15个丑数为：

2,3,4,5,6,7,8,9,10,12,14,15,16,18,20

输入说明

第 1 行: 2个被空格分开的整数:K 和 N ， 1<= K<=100 ， 1<= N<=100,000.

第 2 行: K 个被空格分开的整数，即集合S的元素

输出说明

单独的一行，即第N个丑数。

cpp 复制代码 
/*算法思想:动态规划，
s[0]存放1，下一个数是已有丑数与质数数组中的乘积来确定，
找出最小的进行填充。
b[i]的值是a[i]质数应该乘的s[]上的位置，
这个b[i]的值要动态变化，
只要当前的a[i]*s[b[i]]不大于前一个丑数，
那么必须让b[i]+1也就是取下一个丑数来比较
*/
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
int main()
{
    int a[103],b[103];
    int k,n,i;
    int
    long s[100001];
    scanf("%d %d",&k,&n);
    for(i=0;i<k;i++)
    {
        scanf("%d",&a[i]);
        b[i]=0;
    }
    s[0]=1;
    for(i=1;i<=n;i++)
    {
        //这是最大的整型数 int（因为第一位是符号位，0 表示他是正数） 用 INT_MAX 常量可以替代这个值。
        s[i]=0x7fffffff;
        for(int j=0;j<k;j++)
        {
            //双重数组套用逻辑 
            while(a[j]*s[b[j]]<=s[i-1])
                b[j]++;
            if(a[j]*s[b[j]]<s[i])
                s[i]=a[j]*s[b[j]];
        }
    }
    printf("%ld\n",s[n]);
    return 0;
 
}

题目32：笨小猴

作者: Turbo

时间限制: 1s

章节: 基本练习（字符串）

问题描述

笨小猴的词汇量很小，所以每次做英语选择题的时候都很头疼。但是他找到了一种方法，经试验证明，用这种方法去选择选项的时候选对的几率非常大！

这种方法的具体描述如下：假设maxn是单词中出现次数最多的字母的出现次数，minn是单词中出现次数最少的字母的出现次数，如果maxn-minn是一个质数，那么笨小猴就认为这是个Lucky Word，这样的单词很可能就是正确的答案。

样例输入

error

样例输出

Lucky Word

2

样例说明

单词error中出现最多的字母r出现了3次，出现次数最少的字母出现了1次，3-1=2，2是质数。

样例输入

olympic

样例输出

No Answer

0

样例说明

单词olympic中所有字母都只出现了1次，1-1=0，0不是质数。

输入说明

输入文件只有一行，是一个单词，其中只可能出现小写字母，并且长度小于100。

输出说明

输出文件共两行，第一行是一个字符串，假设输入的的单词是Lucky Word，那么输出"Lucky Word"，否则输出"No Answer"；第二行是一个整数，如果输入单词是Lucky Word，输出maxn-minn的值，否则输出0。

cpp 复制代码 
#include <stdio.h>
#include <string.h>
#include <math.h>
int is_su(int n){
    if(n < 2)
        return 0;
    if(n == 2)
        return 1;
    for(int i = 2; i <= sqrt(n); i++){
        if(n % i == 0)
            return 0;
    }
    return 1;
}
int main(){
    char str[100];
    scanf("%s", str);
    int len = strlen(str), maxn = 0, minn = 100;
    int status[26] = {0};
    for(int i = 0; i < len; i++){
        int num = str[i] - 'a';
        status[num]++;
    }
    for(int i = 0; i < 26; i++){
        if(status[i] > 0){
            if(status[i] > maxn)
                maxn = status[i];
            if(status[i] < minn)
                minn = status[i];
        }
    }
    int num = maxn - minn;
    if(is_su(num))
        printf("Lucky Word\n%d", num);
    else
        printf("No Answer\n0");
    return 0;
}

题目33：字串统计

作者: Turbo

时间限制: 1s

章节: 基本练习（字符串）

问题描述

给定一个长度为n的字符串S，还有一个数字L，统计长度大于等于L的出现次数最多的子串（不同的出现可以相交），如果有多个，输出最长的，如果仍然有多个，输出第一次出现最早的。

输入说明

第一行一个数字L。

第二行是字符串S。

L大于0，且不超过S的长度。

n<=60

S中所有字符都是小写英文字母。

输出说明

一行，题目要求的字符串。

输入样例1：

4

bbaabbaaaaa

输出样例1：

bbaa

输入样例2：

2

bbaabbaaaaa

输出样例2：

aa

cpp 复制代码 
#include <stdio.h>
#include <string.h>

int main() {
    int L;
    char S[65];
    scanf("%d\n%s", &L, S);
    
    int len = strlen(S);
    
    char result[65] = "";
    int max_count = 0;
    int result_len = 0;
    int first_pos = len;
    
    // 遍历所有可能的子串
    for (int i = 0; i < len; i++) {
        for (int j = i + L - 1; j < len; j++) {
            int sub_len = j - i + 1;
            char current[65];
            strncpy(current, S + i, sub_len);
            current[sub_len] = '\0';
            
            // 统计出现次数
            int count = 0;
            for (int k = 0; k <= len - sub_len; k++) {
                if (strncmp(S + k, current, sub_len) == 0) {
                    count++;
                }
            }
            
            // 更新结果
            if (count > max_count || 
                (count == max_count && sub_len > result_len) ||
                (count == max_count && sub_len == result_len && i < first_pos)) {
                max_count = count;
                strcpy(result, current);
                result_len = sub_len;
                first_pos = i;
            }
        }
    }
    
    printf("%s\n", result);
    
    return 0;
}

34：Anagrams问题

作者: Turbo

时间限制: 1s

章节: 基本练习（字符串）

问题描述

Anagrams指的是具有如下特性的两个单词：在这两个单词当中，每一个英文字母（不区分大小写）所出现的次数都是相同的。例如，"Unclear"和"Nuclear"、"Rimon"和"MinOR"都是Anagrams。编写一个程序，输入两个单词，然后判断一下，这两个单词是否是Anagrams。每一个单词的长度不会超过80个字符，而且是大小写无关的。

输入说明

输入有两行，分别为两个单词。

输出说明

输出只有一个字母Y或N，分别表示Yes和No。

cpp 复制代码 
#include <stdio.h>
#include <string.h>
int main(){
    char s1[50], s2[50];
    scanf("%s\n%s", s1, s2);
    int len1 = strlen(s1), len2 = strlen(s2);
    int a[26] = {0}, b[26] = {0};
    if(len1 != len2){
        printf("N");
        return 0;
    }
    for(int i = 0; i < len1; i++){
        if(s1[i] >= 'A' && s1[i] <= 'Z')
            s1[i] += 32;
        int idx = s1[i] - 'a';
        a[idx]++;
    }
    for(int i = 0; i < len2; i++){
        if(s2[i] >= 'A' && s2[i] <= 'Z')
            s2[i] += 32;
        int idx = s2[i] - 'a';
        b[idx]++;
    }
    int flag = 1;
    for(int i = 0; i < 26; i++){
        if(a[i] != b[i]){
            flag = 0;
            break;
        }
    }
    if(flag == 1)
        printf("Y");
    else
        printf("N");
    return 0;
}

35：身份证号码升级

作者: Turbo

时间限制: 1s

章节: 基本练习（字符串）

问题描述

从1999年10月1日开始，公民身份证号码由15位数字增至18位。(18位身份证号码简介)。升级方法为：

1、把15位身份证号码中的年份由2位(7,8位)改为四位。

2、最后添加一位验证码。验证码的计算方案：

将前 17 位分别乘以对应系数 (7 9 10 5 8 4 2 1 6 3 7 9 10 5 8 4 2) 并相加，然后除以 11 取余数，0-10 分别对应 1 0 x 9 8 7 6 5 4 3 2。

请编写一个程序，用户输入15位身份证号码，程序生成18位身份证号码。假设所有要升级的身份证的四位年份都是19××年

输入说明

一个15位的数字串，作为身份证号码

不用判断输入的15位字符串是否合理

输出说明

一个18位的字符串，作为升级后的身份证号码

cpp 复制代码 
#include <stdio.h>
#include <string.h>
int main(){
    char s1[20], s2[20];
    scanf("%s", s1);
    int len = strlen(s1);
    int sum = 0;
    int num[17] = {7, 9, 10, 5, 8, 4, 2, 1, 6, 3,
                    7, 9, 10, 5, 8, 4, 2};
    char str[11] = {'1', '0', 'x', '9', '8', '7',
                    '6', '5', '4', '3', '2'};
    for(int i = 0; i < 18; i++){
        if(i < 6){
            s2[i] = s1[i];
            sum += (s2[i] - '0') * num[i];
        }
        else if(i == 6){
            s2[i] = '1';
            sum += (s2[i] - '0') * num[i];
        }
        else if(i == 7){
            s2[i] = '9';
            sum += (s2[i] - '0') * num[i];
        }
        else if(i < 17){
            s2[i] = s1[i - 2];
            sum += (s2[i] - '0') * num[i];
        }
        else if(i == 17){
            int result = sum % 11;
            s2[i] = str[result];
        }
    }
    for(int i = 0; i < 18; i++)
        printf("%c", s2[i]);
    return 0;
}

36：彩票

作者: Turbo

时间限制: 1s

章节: 基本练习（数组）

问题描述

为丰富男生节活动，女生设置彩票抽奖环节，规则如下：

1、每张彩票上印有7个各不相同的号码，且这些号码的取值范围为[1, 33]；

2、每次在兑奖前都会公布一个由七个互不相同的号码构成的中奖号码；

3、共设置7个奖项，特等奖和一等奖至六等奖。兑奖规则如下：

特等奖：要求彩票上的7个号码都出现在中奖号码中；

一等奖：要求彩票上的6个号码出现在中奖号码中；

二等奖：要求彩票上的5个号码出现在中奖号码中；

......

六等奖：要求彩票上的1个号码出现在中奖号码中；

注：不考虑号码出现的顺序，例如若中奖号码为23 31 1 14 19 17 18，则彩票12 8 9 23 1 16 7由于其中有两个号码（23和1）出现在中奖号码中，所以该彩票中了五等奖。

现已知中奖号码和李华买的若干彩票的号码，请你写一个程序判断他的彩票中奖情况。

输入说明

第一行一个正整数n，表示彩票数量，第二行7个整数，表示中奖号码，下面n行每行7个整数，描述n张彩票。

n<=100000

输出说明

7个数字，第1个数字表示特等奖的中奖张数，第2个数字表示一等奖的中奖张数，第3个数字表示二等奖的中奖张数......第7个数字表示六等奖的中奖张数。

每个数字后都跟一个空格。

cpp 复制代码 
#include <stdio.h>
int main(){
    int n;
    scanf("%d", &n);
    int arr[7], result[8] = {0};//存储六等奖五等奖...特等奖
    for(int i = 0; i < 7; i++)
        scanf("%d", &arr[i]);
    for(int i = 0; i < n; i++){
        int a[7], count = 0;
        for(int j = 0; j < 7; j++)
            scanf("%d", &a[j]);
        for(int j = 0; j < 7; j++){
            for(int k = 0; k < 7; k++){
                if(a[j] == arr[k]){
                    count++;
                    break;
                }
            }
        }
        result[count]++;
    }
    for(int i = 7; i > 0; i--)
        printf("%d ", result[i]);
    return 0;
}

37：质数的后代

作者: Turbo

时间限制: 1s

章节: 基本练习（数组）

问题描述

如果一个合数由两个质数相乘而得，那么我们就叫它是质数们的直接后代。现在，给你一系列自然数，判断它们是否是质数的直接后代。

输入说明

第一行一个正整数T，表示需要判断的自然数数量

接下来T行，每行一个要判断的自然数

1<=T<=20

2<=要判断的自然数<=105

输出说明

共T行，依次对于输入中给出的自然数，判断是否为质数的直接后代，是则输出Yes，否则输出No

cpp 复制代码 
#include <stdio.h>
#include <math.h>
int is_su(int n){
    if(n < 2) return 0;
    if(n == 2) return 1;
    for(int i = 2; i <= sqrt(n); i++){
        if(n % i == 0)
            return 0;
    }
    return 1;
}
int main(){
    int t;
    scanf("%d", &t);
    for(int i = 0; i < t; i++){
        int n, flag = 0;
        scanf("%d", &n);
        for(int i = 2; i <= n / 2; i++){
            if(is_su(i)){
                int num = n / i;
                if(is_su(num) && num * i == n){
                    flag = 1;
                    break;
                }
            }
        }
        if(flag == 0)
            printf("No\n");
        else
            printf("Yes\n");
    }
    return 0;
}

38：高精度乘法

作者: Turbo

时间限制: 1s

章节: 基本练习（数组）

问题描述

在C/C++语言中，整型所能表示的范围一般为-231到231（大约21亿）,即使long long型，一般也只能表示到-263到263。要想计算更加规模的数，就要用软件来扩展了，比如用数组或字符串来模拟更多规模的数及共运算。

现在输入两个整数，请输出它们的乘积。

输入说明

两行，每行一个正整数，每个整数不超过10000位

输出说明

一行，两个整数的乘积。

cpp 复制代码 
#include <stdio.h>
#include <string.h>

// 高精度乘法函数
void multiply(char* num1, char* num2, char* result) {
    int len1 = strlen(num1);
    int len2 = strlen(num2);
    int len = len1 + len2;
    
    // 初始化结果数组为0
    int res[len];
    for (int i = 0; i < len; i++) {
        res[i] = 0;
    }
    
    // 模拟手算乘法
    for (int i = len1 - 1; i >= 0; i--) {
        for (int j = len2 - 1; j >= 0; j--) {
            int mul = (num1[i] - '0') * (num2[j] - '0');
            int p1 = i + j;      // 进位位置
            int p2 = i + j + 1;  // 当前位位置
            
            int sum = mul + res[p2];
            res[p2] = sum % 10;
            res[p1] += sum / 10;  // 进位
        }
    }
    
    // 将结果转换为字符串
    int idx = 0;
    int start = 0;
    
    // 跳过前导0
    while (start < len && res[start] == 0) {
        start++;
    }
    
    // 如果结果为0
    if (start == len) {
        result[0] = '0';
        result[1] = '\0';
        return;
    }
    
    for (int i = start; i < len; i++) {
        result[idx++] = res[i] + '0';
    }
    result[idx] = '\0';
}

int main() {
    char num1[10010], num2[10010];
    char result[20020];  // 两数相乘，结果最多为len1+len2位
    
    // 读取输入
    scanf("%s", num1);
    scanf("%s", num2);
    
    // 计算乘积
    multiply(num1, num2, result);
    
    // 输出结果
    printf("%s\n", result);
    
    return 0;
}

39：阶乘末尾

作者: Turbo

时间限制: 1s

章节: 基本练习（数组）

问题描述

给定n和len，输出n!末尾len位。

输入说明

一行，两个正整数n和len。

n<=30, len<=10。

输出说明

一行，一个字符串，表示答案。长度不足用前置零补全。

cpp 复制代码 
#include <stdio.h>
int main(){
    int n, len;
    scanf("%d %d", &n, &len);
    int arr[100];
    arr[0] = 1;
    int idx = 1;
    for(int i = 2; i <=n; i++){
        int carry = 0;
        for(int j = 0; j < idx; j++){
            int num = arr[j] * i + carry;
            arr[j] = num % 10;
            carry = num / 10;
        }
        while(carry > 0){
            arr[idx] = carry % 10;
            idx++;
            carry /= 10;
        }
    }
    if(idx < len){
        for(int i = idx; i < len; i++)
            printf("0");
        //从高位到低位输出
        for(int i = idx - 1; i >= 0; i--)
            printf("%d", arr[i]);
    }
    else{
        for(int i = len - 1; i >= 0; i--)
            printf("%d", arr[i]);
    }
    return 0;
}

40：寂寞的数

作者: Turbo

时间限制: 1s

章节: 基本练习（数组）

问题描述

道德经曰：一生二，二生三，三生万物。

对于任意正整数n，我们定义d(n)的值为为n加上组成n的各个数字的和。例如，d(23)=23+2+3=28, d(1481)=1481+1+4+8+1=1495。

因此，给定了任意一个n作为起点，你可以构造如下一个递增序列：n,d(n),d(d(n)),d(d(d(n)))....例如，从33开始的递增序列为：

33, 39, 51, 57, 69, 84, 96, 111, 114, 120, 123, 129, 141, ...

我们把n叫做d(n)的生成元，在上面的数列中，33是39的生成元，39是51的生成元，等等。有一些数字甚至可以有两个生成元，比如101，可以由91和100生成。但也有一些数字没有任何生成元，如42。我们把这样的数字称为寂寞的数字。

输入说明

一行，一个正整数n。

n<=10000

输出说明

按照升序输出小于n的所有寂寞的数字，每行一个。

cpp 复制代码 
#include <stdio.h>
int dn(int n){
    int temp = n;
    int result = n;
    while(temp > 0){
        result += temp % 10;
        temp /= 10;
    }
    return result;
}
int main(){
    int n;
    scanf("%d", &n);
    int status[10001] = {0};
    for(int i = 0; i < n; i++){
        int d = dn(i);
        if(d < n)
            status[d] = 1;
    }
    for(int i = 1; i < n; i++){
        if(status[i] == 0)
            printf("%d\n", i);
    }
    return 0;
}

41：数列

作者: Turbo

时间限制: 1s

章节: 枚举

问题描述

给定一个正整数k(3≤k≤15),把所有k的方幂及所有有限个互不相等的k的方幂之和构成一个递增的序列，例如，当k=3时，这个序列是：

1，3，4，9，10，12，13，...

（该序列实际上就是：30，31，30+31，32，30+32，31+32，30+31+32，...）

请你求出这个序列的第N项的值（用10进制数表示）。

例如，对于k=3，N=100，正确答案应该是981。

输入说明

只有1行，为2个正整数，用一个空格隔开：k N

（k、N的含义与上述的问题描述一致，且3≤k≤15，10≤N≤1000）。

输出说明

计算结果，是一个正整数（在所有的测试数据中，结果均不超过2.1*109）。（整数前不要有空格和其他符号）。

cpp 复制代码 
/*把自然数1,2,3,4,5,6,7,...转换为k进制，然后把k进制数当作"二进制"来读
比如：
1(十进制) = 1(二进制) → 看作3⁰ = 1
2(十进制) = 10(二进制) → 看作3¹ = 3
3(十进制) = 11(二进制) → 看作3⁰+3¹ = 4
4(十进制) = 100(二进制) → 看作3² = 9
*/
#include <stdio.h>
int main(){
    int k, N;
    scanf("%d %d", &k, &N);
    long long result = 0;
    long long power = 1;//当前k的幂，从k⁰=1开始
    //不断处理N的每一位
    while(N > 0){
        int digit = N % 2;  //获取N的二进制最低位
        if(digit == 1)
            result += power;  //如果这一位是1，就加上对应的k的幂
        power *= k;  //计算下一个k的幂
        N /= 2;      //去掉N的二进制最低位
    }
    printf("%lld\n", result);
    return 0;
}

42：孪生素数

作者: xxx

时间限制: 1s

章节: 一维数组

问题描述

孪生素数就是指相差2的素数对，例如3和5，5和7，11和13...。这个猜想正式由希尔伯特在1900年国际数学家大会的报告上第8个问题中提出，可以这样描述：存在无穷多个素数p，使得p + 2是素数。素数对（p, p + 2）称为孪生素数。

现在给定任何正整数 N (< 10 ^ 5), 请你计算不大于 N 的孪生素数的对数。

输入说明

你的程序必须从标准输入中读取测试用例。输入文件由几组测试用例组成。每组测试用例占一行, 其中包含一个整数 N。当输入的 N为负数表示结束输入。

输出说明

对于每组测试数据，输出一行，包括一个整数，表示不大于 N 的孪生素数的对数

cpp 复制代码 
#include <stdio.h>
#include <math.h>
int is_su(int n){
    if(n < 2) return 0;
    if(n == 2) return 1;
    for(int i = 2; i <= sqrt(n); i++){
        if(n % i == 0)
            return 0;
    }
    return 1;
}
int main(){
    int n;
    while(scanf("%d", &n) != EOF){
        if(n < 0)
            break;
        int count = 0;
        for(int i = 2; i <= n; i++){
            if(is_su(i - 2) && is_su(i))
                count++;
        }
        printf("%d\n", count);
    }
    return 0;
}

43：区间k大数查询

作者: Turbo

时间限制: 1s

章节: 基本练习（数组）

问题描述

给定一个序列，每次询问序列中第l个数到第r个数中第K大的数是哪个。

注意，由于存在相等的元素，因此，第2大的数可能和第1大的数相等。

输入说明

第一行包含一个数n，表示序列长度。

第二行包含n个正整数，表示给定的序列。

第三个包含一个正整数m，表示询问个数。

接下来m行，每行三个数l,r,K，表示询问序列从左往右第l个数到第r个数中，从大往小第K大的数是哪个。序列元素从1开始标号。

n,m<=1000；

保证k<=(r-l+1)，序列中的数<=106。

输出说明

总共输出m行，每行一个数，表示询问的答案。

cpp 复制代码 
#include <stdio.h>
int main(){
    int n;
    scanf("%d", &n);
    int arr[n];
    for(int i = 0; i < n; i++)
        scanf("%d", &arr[i]);
    int m;
    scanf("%d", &m);
    for(int q = 0; q < m; q++){
        int l, r, k;
        scanf("%d %d %d", &l, &r, &k);
        int temp[n];
        for(int i = 0; i < n; i++)
            temp[i] = arr[i];
        int start = l - 1;  //区间起始索引
        int end = r - 1;    //区间结束索引
        for(int i = start; i < end; i++){
            for(int j = i + 1; j <= end; j++){
                if(temp[i] < temp[j]){
                    int tmp = temp[i];
                    temp[i] = temp[j];
                    temp[j] = tmp;
                }
            }
        }
        printf("%d\n", temp[start + k - 1]);
    }
    return 0;
}

44：数的统计

作者: Turbo

时间限制: 1s

章节: 基本练习（数组）

问题描述

在一个有限的正整数序列中，有些数会多次重复出现在这个序列中。

如序列：3，1，2，1，5，1，2。其中1就出现3次，2出现2次，3出现1 次，5出现1次。

你的任务是对于给定的正整数序列，从小到大依次输出序列中出现的数及出现的次数。

输入说明

第一行正整数n，表示给定序列中正整数的个数。

第二行是n 个用空格隔开的正整数x，代表给定的序列。

n<=1000；0<x<=1000,000。

输出说明

若干行，每行两个用一个空格隔开的数，第一个是数列中出现的数，第二个是该数在序列中出现的次数。

cpp 复制代码 
#include <stdio.h>
int main(){
    int n;
    scanf("%d", &n);
    int arr[n];
    for(int i = 0; i < n; i++)
        scanf("%d", &arr[i]);
    for(int i = 0; i < n - 1; i++){
        for(int j = i + 1; j < n; j++){
            if(arr[i] > arr[j]){
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
    int current = arr[0];
    int count = 1;
    for(int i = 1; i < n; i++){
        if(arr[i] == current)
            count++;
        else{
            printf("%d %d\n", current, count);
            current = arr[i];
            count = 1;
        }
    }
    printf("%d %d\n", current, count);
    return 0;
}

45：数字黑洞

作者: Turbo

时间限制: 1s

章节: 基本练习（数组）

问题描述

任意一个四位数，只要它们各个位上的数字是不全相同的，就有这样的规律：

1)将组成该四位数的四个数字由大到小排列，形成由这四个数字构成的最大的四位数；

2)将组成该四位数的四个数字由小到大排列，形成由这四个数字构成的最小的四位数(如果四个数中含有0，则得到的数不足四位)；

3)求两个数的差，得到一个新的四位数(高位零保留)。

重复以上过程，最后一定会得到的结果是6174。

比如：4312 3087 8352 6174，经过三次变换，得到6174

输入说明

一个四位整数，输入保证四位数字不全相同

输出说明

一个整数，表示这个数字经过多少次变换能得到6174

cpp 复制代码 
#include <stdio.h>
int main(){
    int num;
    scanf("%d", &num);
    int count = 0;
    while(num != 6174){
        int digits[4];
        digits[0] = num / 1000;
        digits[1] = (num / 100) % 10;
        digits[2] = (num / 10) % 10;
        digits[3] = num % 10;
        for(int i = 0; i < 3; i++){
            for(int j = i + 1; j < 4; j++){
                if(digits[i] > digits[j]){
                    int temp = digits[i];
                    digits[i] = digits[j];
                    digits[j] = temp;
                }
            }
        }
        int min_num = 0;
        for(int i = 0; i < 4; i++)
            min_num = min_num * 10 + digits[i];
        int max_num = 0;
        for(int i = 3; i >= 0; i--)
            max_num = max_num * 10 + digits[i];
        num = max_num - min_num;
        count++;
    }
    printf("%d", count);
    return 0;
}

翻译：

Pretrained models have become a dominant paradigm in modern artificial intelligence. These models are first trained on large-scale datasets to learn general representations and then fine-tuned on specific downstream tasks. This approach significantly reduces the need for labeled data and improves model performance. In natural language processing, models like BERT and GPT are pre-trained using self-supervised learning objectives. Fine-tuning allows these models to adapt to tasks such as text classification, sentiment analysis, and question answering. Transfer learning plays a crucial role in this process by leveraging knowledge from one domain to another. Despite their effectiveness, pretrained models require substantial computational resources, raising concerns about efficiency and environmental impact.

预训练模型已经变成现代人工智能的主要范例。这些模型首先在大规模数据集上训练学习普遍的展示，然后在特定的下采样任务中进行微调。这种方法显著减少了对有标签模型的需要，并且提升了模型性能。在自然语言处理中，像BERT和GPT模型使用他们自身监管的学习目标来进行预训练。微调可以让这些模型适应例如文本分类、感觉分析和问题问答等任务。转移学习在这个过程中起到一个关键的作用，通过从一个领域学习知识到另一个领域。尽管这些方法很高效，但是预训练模型需要大量的计算资源，带来了关于效率和环境影响的问题。

self-supervised learning objectives：自监督学习目标

sentiment analysis：情感分析

transfer learning：迁移学习

by leveraging knowledge from one domain to another：通过将知识从一个领域迁移到另一个领域

相关推荐
沐苏瑶17 小时前
Java 搜索型数据结构全解：二叉搜索树、Map/Set 体系与哈希表
java·数据结构·算法
ZoeJoy818 小时前
算法筑基（二）：搜索算法——从线性查找到图搜索，精准定位数据
算法·哈希算法·图搜索算法
Alicx.18 小时前
dfs由易到难
算法·蓝桥杯·宽度优先
_日拱一卒18 小时前
LeetCode：找到字符串中的所有字母异位词
算法·leetcode
云泽80819 小时前
深入 AVL 树：原理剖析、旋转算法与性能评估
数据结构·c++·算法
Wilber的技术分享20 小时前
【LeetCode高频手撕题 2】面试中常见的手撕算法题（小红书）
笔记·算法·leetcode·面试
邪神与厨二病20 小时前
Problem L. ZZUPC
c++·数学·算法·前缀和
梯度下降中21 小时前
LoRA原理精讲
人工智能·算法·机器学习
IronMurphy21 小时前
【算法三十一】46. 全排列
算法·leetcode·职场和发展
czlczl2002092521 小时前
力扣1911. 最大交替子序列和
算法·leetcode·动态规划
热门推荐
012026年3月AI领域大事件：DeepSeek引领开源风暴02GitHub 镜像站点03围棋-html版本04纯 HTML/CSS/JS 实现的高颜值登录页，还会眨眼睛！少女心爆棚！05班级宠物园部署指南06小黑课堂计算机二级WPSoffice题库软件下载安装教程（2026年3月最新版）07“wsl --install -d Ubuntu-22.04”下载慢，中国地区离线安装 Ubuntu 22.04 WSL方法（亲测2025年5月6日）08中国象棋-html版本09UV安装并设置国内源10OpenClaw 使用和管理 MCP 完全指南