当前位置： 首页 > article >正文

ZZNUOJ(C/C++)基础练习1081——1090(详解版)

article 2025/2/10 3:19:01

目录

 1081 : n个数求和 （多实例测试）

C

C++

1082 : 敲7（多实例测试）

C

C++

1083 : 数值统计(多实例测试)

C

C++

 1084 : 计算两点间的距离（多实例测试）

C

C++ 

1085 : 求奇数的乘积（多实例测试）

C

C++

1086 : ASCII码排序（多实例测试）

C

C++

1087 : 获取出生日期（多实例测试)

C

C++

1088 : 手机短号 （多实例）

C

C++

1089 : 阶乘的最高位

C

C++

法二C（利用对数知识点）

1090 : 整数幂（多实例测试）

C

C++(使用快速幂算法)

 

 Alt + F4：在大多数窗口程序中，按下Alt + F4可以关闭当前窗口或程序。

“EOF”是“End of File”的缩写，意思是“文件结束”。它通常用于计算机编程和文件处理中，表示已经到达文件的最后一个字节，后面没有更多的数据了。

 1081 : n个数求和 （多实例测试）

题目描述

求n个整数的和。

输入

输入第一行是一个整数T，表示有T组测试实例；
每组输入包括两行：
第一行一个数n表示接下来会有n个整数；
第二行空格隔开的n个数。

输出

对于每组输入，在一行输出n个数的和（保证和不会超出int类型的范围）！

样例输入

2
3
1 2 3
4
-1 0 -19 22

样例输出

6
2

C

#include<stdio.h> // 包含标准输入输出库

// 定义一个函数solve，用于处理每组数据的求和操作
void solve()
{
    int n; // 定义变量n，表示每组数据中的整数个数
    scanf("%d", &n); // 从标准输入读取整数n

    int mid, sum = 0; // 定义变量mid用于临时存储每个整数，sum用于存储总和
    for (int i = 0; i < n; i++) // 循环n次，读取每个整数
    {
        scanf("%d", &mid); // 从标准输入读取一个整数mid
        sum += mid; // 将mid加到总和sum中
    }
    printf("%d\n", sum); // 输出总和sum
}

int main()
{
    int T = 1; // 定义变量T，表示测试用例的数量，默认值为1
    scanf("%d", &T); // 从标准输入读取测试用例的数量T

    while (T--) // 循环T次，每次循环T减1
    {
        solve(); // 调用solve函数，处理一组数据的求和操作
    }

    return 0; // 程序正常结束
}

C++

#include<iostream> // 包含C++标准输入输出流库
using namespace std; // 使用标准命名空间

// 定义一个函数solve，用于处理每组数据的求和操作
void solve()
{
    int n; // 定义变量n，表示每组数据中的整数个数
    scanf("%d", &n); // 从标准输入读取整数n

    int mid, sum = 0; // 定义变量mid用于临时存储每个整数，sum用于存储总和
    for (int i = 0; i < n; i++) // 循环n次，读取每个整数
    {
        scanf("%d", &mid); // 从标准输入读取一个整数mid
        sum += mid; // 将mid加到总和sum中
    }
    printf("%d\n", sum); // 输出总和sum
}

int main()
{
    int T = 1; // 定义变量T，表示测试用例的数量，默认值为1
    scanf("%d", &T); // 从标准输入读取测试用例的数量T

    while (T--) // 循环T次，每次循环T减1
    {
        solve(); // 调用solve函数，处理一组数据的求和操作
    }

    return 0; // 程序正常结束
}

1082 : 敲7（多实例测试）

题目描述

输出7和7的倍数，还有包含7的数字例如（17，27，37...70，71，72，73...）

输入

首先输入一个整数t，表示有t组数据。
然后有t行，每行一个整数N。(N不大于30000)

输出

对于每组数据 ，输出从小到大排列的不大于N的与7有关的数字。每组数据占一行，每个数字后面有一个空格；

样例输入

2
20
30

样例输出

7 14 17
7 14 17 21 27 28

C

#include<stdio.h> // 包含标准输入输出库

// 定义一个函数solve，用于处理每组数据
void solve()
{
    int n; // 定义变量n，表示输入的整数
    scanf("%d", &n); // 从标准输入读取整数n

    // 从7开始循环到n
    for (int i = 7; i <= n; i++)
    {
        // 如果i能被7整除
        if (i % 7 == 0)
        {
            printf("%d ", i); // 输出i
        }
        else
        {
            int mid = i; // 定义变量mid，用于存储当前数字i
            // 检查i的每一位是否包含数字7
            while (mid != 0)
            {
                if (mid % 10 == 7) // 如果当前位是7
                {
                    printf("%d ", i); // 输出i
                    break; // 退出循环
                }
                mid /= 10; // 去掉当前位，继续检查下一位
            }
        }
    }
    printf("\n"); // 输出换行符
}

int main()
{
    int T = 1; // 定义变量T，表示测试用例的数量，默认值为1
    scanf("%d", &T); // 从标准输入读取测试用例的数量T

    // 循环T次，每次调用solve函数处理一组数据
    while (T--)
    {
        solve();
    }

    return 0; // 程序正常结束
}

C++

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

// 定义一个函数，用于检查一个数字是否包含7
int containsSeven(int num)
{
    while (num != 0)
    {
        if (num % 10 == 7)
        {
            return 1; // 如果包含7，返回1
        }
        num /= 10; // 去掉当前位，继续检查下一位
    }
    return 0; // 如果不包含7，返回0
}

void solve()
{
    int n;
    scanf("%d", &n); // 从标准输入读取整数n

    // 从7开始循环到n
    for (int i = 7; i <= n; i++)
    {
        if (i % 7 == 0 || containsSeven(i)) // 如果i能被7整除或者包含7
        {
            printf("%d ", i); // 输出i
        }
    }
    printf("\n"); // 输出换行符
}

int main()
{
    int T = 1;
    scanf("%d", &T); // 从标准输入读取测试用例的数量T

    // 循环T次，每次调用solve函数处理一组数据
    while (T--)
    {
        solve();
    }

    return 0; // 程序正常结束
}

1083 : 数值统计(多实例测试)

题目描述

统计给定的n个数中，负数、零和正数的个数

输入

输入数据有多组，每组占一行，每行的第一个数是整数n（n<100），表示需要统计的数值的个数，然后是n个实数；如果n=0，则表示输入结束，该行不做处理。
 

输出

对于每组输入数据，输出一行a,b和c，分别表示给定的数据中负数、零和正数的个数。

样例输入

6 0 1 2 3 -1 0
5 1 2 3 4 0.5
0

样例输出

1 2 3
0 0 5

C

#include<stdio.h> // 包含标准输入输出库

// 定义一个函数solve，用于处理每组数据
void solve(int n)
{
    int small = 0, zero = 0, big = 0; // 定义变量small、zero和big，分别用于统计负数、零和正数的数量

    // 循环n次，读取每个浮点数
    for (int i = 0; i < n; i++)
    {
        double mid; // 定义变量mid，用于存储当前读取的浮点数
        scanf("%lf", &mid); // 从标准输入读取一个浮点数mid

        // 根据mid的值，更新相应的计数器
        if (mid > 0)
        {
            big++; // 如果mid是正数，big计数器加1
        }
        else if (mid == 0)
        {
            zero++; // 如果mid是零，zero计数器加1
        }
        else
        {
            small++; // 如果mid是负数，small计数器加1
        }
    }

    // 输出负数、零和正数的数量
    printf("%d %d %d\n", small, zero, big);
}

int main()
{
    int T = 1; // 定义变量T，表示测试用例的数量，默认值为1

    // 使用while循环读取输入，直到T为0
    while (scanf("%d", &T), T != 0)
    {
        solve(T); // 调用solve函数，处理一组数据
    }

    return 0; // 程序正常结束
}

C++

#include<iostream> // 包含C++标准输入输出流库
using namespace std; // 使用标准命名空间

// 定义一个函数solve，用于处理每组数据
void solve(int n)
{
    int small = 0, zero = 0, big = 0; // 定义变量small、zero和big，分别用于统计负数、零和正数的数量

    // 循环n次，读取每个浮点数
    for (int i = 0; i < n; i++)
    {
        double mid; // 定义变量mid，用于存储当前读取的浮点数
        scanf("%lf", &mid); // 从标准输入读取一个浮点数mid

        // 根据mid的值，更新相应的计数器
        if (mid > 0)
        {
            big++; // 如果mid是正数，big计数器加1
        }
        else if (mid == 0)
        {
            zero++; // 如果mid是零，zero计数器加1
        }
        else
        {
            small++; // 如果mid是负数，small计数器加1
        }
    }

    // 输出负数、零和正数的数量
    printf("%d %d %d\n", small, zero, big);
}

int main()
{
    int T = 1; // 定义变量T，表示测试用例的数量，默认值为1

    // 使用while循环读取输入，直到T为0
    while (scanf("%d", &T), T != 0)
    {
        solve(T); // 调用solve函数，处理一组数据
    }

    return 0; // 程序正常结束
}

 1084 : 计算两点间的距离（多实例测试）

题目描述

输入两点坐标（X1,Y1）,（X2,Y2）,计算并输出两点间的距离。

输入

输入数据有多组，每组占一行，由4个实数组成，分别表示x1,y1,x2,y2,数据之间用空格隔开。

输出

对于每组输入数据，输出一行，结果保留两位小数。

样例输入

0 0 0 1
0 1 1 0

样例输出

1.00
1.41

C

#include<stdio.h> // 包含标准输入输出库
#include<math.h>  // 包含数学库，用于计算平方根

int main()
{
    double x1, y1, x2, y2; // 定义四个变量，分别表示两个点的坐标 (x1, y1) 和 (x2, y2)

    // 使用while循环读取输入，直到输入结束（EOF）
    while (scanf("%lf %lf %lf %lf", &x1, &y1, &x2, &y2) != EOF)
    {
        // 计算两点之间的欧几里得距离
        // 公式：distance = sqrt((x2 - x1)^2 + (y2 - y1)^2)
        double distance = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));

        // 输出计算得到的距离，保留两位小数
        printf("%.2f\n", distance);
    }

    return 0; // 程序正常结束
}

C++ 

#include<iostream> // 包含C++标准输入输出流库
#include<algorithm> // 包含算法库（虽然在这段代码中未使用到）
#include<cmath> // 包含数学库，用于计算平方根
#include<iomanip> // 包含输入输出流格式化库，用于设置输出精度
using namespace std; // 使用标准命名空间

int main()
{
    double x1, y1, x2, y2; // 定义四个变量，分别表示两个点的坐标 (x1, y1) 和 (x2, y2)

    // 使用while循环读取输入，直到输入结束
    while (cin >> x1 >> y1 >> x2 >> y2)
    {
        // 计算两点之间的欧几里得距离
        // 公式：distance = sqrt((x2 - x1)^2 + (y2 - y1)^2)
        double distance = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));

        // 使用cout输出计算得到的距离，保留两位小数
        // setprecision(2) 设置小数点后保留2位
        // fixed 确保输出固定的小数点格式
        cout << setprecision(2) << fixed << distance << endl;
    }

    return 0; // 程序正常结束
}

1085 : 求奇数的乘积（多实例测试）

题目描述

给你n个整数，求他们中所有奇数的乘积

输入

输入数据包含多个测试实例，每个测试实例占一行，每行的第一个数为n，表示本组数据一共有n个，接着是n个整数，你可以假设每组数据必定至少存在一个奇数。

输出

输出每组数中的所有奇数的乘积，对于测试实例，输出一行。

样例输入

3 1 2 3
4 2 3 4 5

样例输出

3
15

注意：输入的n个整数中，可能有负数，要用mid%2 != 0来判断是否为奇数

C

#include<stdio.h>  // 包含标准输入输出库

int main() {
    int n;  // 用于存储每组数据的整数个数
    // 使用 while 循环读取多组数据，直到输入结束（EOF）
    while(scanf("%d", &n) != EOF) {
        long long mul = 1;  // 初始化乘积为1，用于存储奇数的乘积
        int mid;  // 用于临时存储每个输入的整数
        // 循环读取 n 个整数
        for(int i = 0; i < n; i++) {
            scanf("%d", &mid);  // 读取一个整数到 mid
            // 判断 mid 是否为奇数
            if(mid % 2 != 0) {
                mul *= mid;  // 如果是奇数，将其乘到 mul 中
            }
        }
        printf("%lld\n", mul);  // 输出当前组奇数的乘积
    }
    return 0;  // 程序正常结束
}

C++

#include<iostream>  // 包含C++标准输入输出流库
using namespace std; // 使用标准命名空间，避免每次调用标准库功能时都要写std::

int main() {
    int n; // 用于存储每组数据的整数个数
    // 使用 while 循环读取多组数据，直到输入结束（EOF）
    while(scanf("%d", &n) != EOF) {
        long long mul = 1; // 初始化乘积为1，用于存储奇数的乘积
        int mid; // 用于临时存储每个输入的整数
        // 循环读取 n 个整数
        for(int i = 0; i < n; i++) {
            scanf("%d", &mid); // 读取一个整数到 mid
            // 判断 mid 是否为奇数
            if(mid % 2 != 0) {
                mul *= mid; // 如果是奇数，将其乘到 mul 中
            }
        }
        printf("%lld\n", mul); // 输出当前组奇数的乘积
    }
    return 0; // 程序正常结束
}

1086 : ASCII码排序（多实例测试）

题目描述

输入三个字符后，按各字符的ASCII码从小到大的顺序输出这三个字符。

输入

输入数据有多组，每组占一行，有三个字符组成，之间无空格。

输出

对于每组输入数据，输出一行，字符中间用一个空格分开。

样例输入

qwe
asd
zxc

样例输出

e q w
a d s
c x z

C

了解指针：踏入编程绮梦，探寻指针隐匿的奥妙踪迹-CSDN博客

#include<stdio.h>  // 包含标准输入输出库

// 函数声明，用于对三个字符进行排序
void solve(char *a, char *b, char *c) {
    char mid;  // 用于临时存储字符
    // 比较 a 和 b，如果 a > b，则交换它们
    if(*a > *b) {
        mid = *a;
        *a = *b;
        *b = mid;
    }
    // 比较 a 和 c，如果 a > c，则交换它们
    if(*a > *c) {
        mid = *a;
        *a = *c;
        *c = mid;
    }
    // 比较 b 和 c，如果 b > c，则交换它们
    if(*b > *c) {
        mid = *b;
        *b = *c;
        *c = mid;
    }
}

int main() {
    char ch1, ch2, ch3;  // 定义三个字符变量
    // 使用 while 循环读取输入，直到输入结束（EOF）
    while(scanf("%c%c%c", &ch1, &ch2, &ch3) != EOF) {
        solve(&ch1, &ch2, &ch3);  // 调用 solve 函数对三个字符进行排序
        printf("%c %c %c\n", ch1, ch2, ch3);  // 输出排序后的结果
        getchar();  // 读取换行符，避免影响下一次输入
    }
    return 0;  // 程序正常结束
}

C++

了解C++的引用：漫步 C++ 之途，领略引用的独特风姿-CSDN博客

#include<iostream>  // 包含标准输入输出流库
using namespace std; // 使用标准命名空间，避免每次调用标准库功能时都要写std::

// 函数声明，用于对三个字符进行排序
void solve(char &a, char &b, char &c) {
    char mid;  // 用于临时存储字符
    // 比较 a 和 b，如果 a > b，则交换它们
    if(a > b) {
        mid = a;
        a = b;
        b = mid;
    }
    // 比较 a 和 c，如果 a > c，则交换它们
    if(a > c) {
        mid = a;
        a = c;
        c = mid;
    }
    // 比较 b 和 c，如果 b > c，则交换它们
    if(b > c) {
        mid = b;
        b = c;
        c = mid;
    }
}

int main() {
    char ch1, ch2, ch3;  // 定义三个字符变量
    // 使用 while 循环读取输入，直到输入结束（EOF）
    while(scanf("%c%c%c", &ch1, &ch2, &ch3) != EOF) {
        solve(ch1, ch2, ch3);  // 调用 solve 函数对三个字符进行排序
        printf("%c %c %c\n", ch1, ch2, ch3);  // 输出排序后的结果
        getchar();  // 读取换行符，避免影响下一次输入
    }
    return 0;  // 程序正常结束
}

1087 : 获取出生日期（多实例测试)

题目描述

输入某人的18位身份证号，输出其出生日期。

输入

多实例测试。首先输入一个整数n，表示测试实例的个数，然后是n行，每行是一个18位身份证号。

输出

对于输入的每个身份证号，输出一行，即其对应的出生日期，输出格式为：yyyy-mm-dd。

样例输入

3
410106199411178657
410104198202095479
410122197911218097

样例输出

1994-11-17
1982-02-09
1979-11-21

了解“输入跳过”：步入 C/C++ 天地，浅探输入跳过的奇妙诀窍-CSDN博客

C

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

// 定义一个函数 solve，用于处理每个身份证号并输出出生日期
void solve() {
    int year, month, day;  // 定义三个变量，分别存储年、月、日
    // 使用 scanf 读取输入的身份证号，并提取出生日期部分
    // %*6d：跳过前6个字符（身份证号的前6位是地址码）
    // %4d：读取接下来的4个字符作为年份
    // %2d：读取接下来的2个字符作为月份
    // %2d：读取接下来的2个字符作为日期
    // %*4d：跳过最后4个字符（身份证号的后4位是顺序码和校验码）
    scanf("%*6d%4d%2d%2d%*4d", &year, &month, &day);
    // 使用 printf 输出格式化的日期，格式为 yyyy-mm-dd
    printf("%04d-%02d-%02d\n", year, month, day);
}

int main() {
    int T;  // 定义变量 T，表示测试实例的个数
    // 读取测试实例的个数
    scanf("%d", &T);
    // 使用 while 循环处理每个测试实例
    while(T--) {
        solve();  // 调用 solve 函数处理每个身份证号
    }
    return 0;  // 程序正常结束
}

C++

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

void solve() {
    char year[5], month[3], day[3];  // 分别存储年、月、日，多留一个位置用于存储字符串结束符 '\0'
    
    // 跳过前6个字符（身份证号的前6位是地址码）
    cin.ignore(6);
    
    // 读取接下来的4个字符作为年份
    cin.get(year, 5);
    
    // 读取接下来的2个字符作为月份
    cin.get(month, 3);
    
    // 读取接下来的2个字符作为日期
    cin.get(day, 3);
    
    // 跳过最后4个字符（身份证号的后4位是顺序码和校验码）
    cin.ignore(4);
    
    // 跳过换行符，确保下一次读取时不会受到影响
    cin.ignore();
    
    // 输出格式化的日期，格式为 yyyy-mm-dd
    cout << year << "-" << month << "-" << day << endl;
}

int main() {
    int T;  // 测试实例的个数
    cin >> T;  // 读取测试实例的个数
    cin.ignore();  // 清理缓冲区，跳过换行符

    while (T--) {
        solve();  // 处理每个测试实例
    }
    return 0;
}

1088 : 手机短号 （多实例）

题目描述

大家都知道，手机号是一个11位长的数字串，同时，作为学生，还可以申请加入校园网，如果加入成功，你将另外拥有一个短号。假设所有的短号都是是 6+手机号的后5位，比如号码为13512345678的手机，对应的短号就是645678。
现在，如果给你一个11位长的手机号码，你能找出对应的短号吗？

输入

输入数据的第一行是一个N(N <= 200)，表示有N组输入数据，接下来的N行每一行为一个11位的手机号码。

输出

输出应包括N行，每行包括一个对应的短号，输出应与输入的顺序一致。

样例输入

2
13512345678
13787600321

样例输出

645678
600321

C

#include<stdio.h>  // 包含标准输入输出库

// 定义一个函数 solve，用于处理输入的手机号码并输出对应的短号
void solve()
{
    int res; // 定义一个整型变量 res，用于存储手机号码的后5位数字
    // 使用 scanf 读取输入
    // %*6d：跳过输入的前6位数字（不存储）
    // %5d：读取接下来的5位数字，存储到变量 res 中
    // %*c：跳过一个字符（通常是换行符）
    scanf("%*6d%5d%*c",&res);
    // 输出结果
    // 6%05d：输出数字时，前面固定为6，后面数字占5位，不足部分用0补齐
    printf("6%05d\n",res);
}

// 主函数
int main()
{
    int T; // 定义一个整型变量 T，用于存储测试用例的数量
    // 读取测试用例数量
    scanf("%d",&T);
    // 清除缓冲区中的换行符
    getchar();
    // 循环处理每个测试用例
    while(T--)
    {
        solve(); // 调用 solve 函数处理每个测试用例
    }
    return 0; // 程序正常结束
}

C++

#include <iostream>  // 包含输入输出流库
using namespace std; // 使用标准命名空间

// 定义一个函数 solve，用于处理输入的手机号码并输出对应的短号
void solve() {
    char res[6]; // 定义一个字符数组 res，用于存储手机号码的后5位数字（加上一个空字符'\0'）

    // 使用 cin.ignore(6) 跳过输入的前6位数字
    cin.ignore(6);
    // 使用 cin.get(res, 6) 读取接下来的5位数字，存储到字符数组 res 中
    cin.get(res, 6);
    // 再次使用 cin.ignore() 跳过换行符
    cin.ignore();

    // 输出结果
    // 输出数字6，然后输出字符数组 res 中的内容
    cout << "6" << res << endl;
}

// 主函数
int main() {
    int T;  // 定义一个整型变量 T，用于存储测试实例的个数
    // 读取测试实例的个数
    cin >> T;
    // 清理缓冲区，跳过换行符
    cin.ignore();

    // 循环处理每个测试实例
    while (T--) {
        solve();  // 调用 solve 函数处理每个测试实例
    }
    return 0; // 程序正常结束
}

1089 : 阶乘的最高位

题目描述

输入一个正整数n。输出n!的最高位上的数字。

输入

输入一个正整数n（n不超过1000）。

输出

输出n!的最高位上的数字。

样例输入

1000

样例输出

4

思路：当两个数相乘时，对于特别大的一个数，去掉后几位，不影响两数相乘结果的最高位

C

#include<stdio.h>  // 包含标准输入输出库

int main()
{
    int n;  // 定义一个整型变量 n，用于存储输入的正整数
    // 从用户输入读取正整数 n
    scanf("%d", &n);

    long long mid = 1;  // 定义一个长整型变量 mid，用于存储中间结果，初始值为1

    // 循环计算 n 的阶乘
    for(int i = 1; i <= n; i++)
    {
        // 如果 mid 大于 1e8（即10^8），为了避免溢出，将 mid 除以 10000
        // 这样可以减少 mid 的大小，同时保留其最高位的数字
        if(mid > 1e8)
        {
            mid /= 10000;
        }
        // 将 mid 乘以 i，逐步计算阶乘
        mid *= i;
    }

    // 去掉 mid 的末尾零，直到 mid 只剩下最高位数字
    while(mid > 9)
    {
        mid /= 10;
    }

    // 输出 n! 的最高位数字
    printf("%d\n", mid);

    return 0;  // 程序正常结束
}

C++

#include <iostream>  // 包含标准输入输出流库
using namespace std;  // 使用标准命名空间

int main()
{
    int n;  
    
    scanf("%d", &n);

    long long mid = 1;  // 定义一个长整型变量 mid，用于存储中间结果，初始值为1

    // 循环计算 n 的阶乘
    for(int i = 1; i <= n; i++)
    {
        // 如果 mid 大于 1e8（即10^8），为了避免溢出，将 mid 除以 10000
        // 这样可以减少 mid 的大小，同时保留其最高位数字
        if(mid > 1e8)
        {
            mid /= 10000;
        }
        // 将 mid 乘以 i，逐步计算阶乘
        mid *= i;
    }

    // 去掉 mid 的末尾零，直到 mid 只剩下最高位数字
    while(mid > 9)
    {
        mid /= 10;
    }

    // 输出 n! 的最高位数字
    printf("%d\n", mid);

    return 0;  // 程序正常结束
}

法二C（利用对数知识点）

#include <stdio.h>  // 包含标准输入输出库
#include <math.h>   // 包含数学库，用于调用 log10 和 pow 函数

int main() 
{
    int n;
    scanf("%d", &n); 

    double logSum = 0.0;  // 用于存储对数和

    // 计算 log10(n!)
    for (int i = 1; i <= n; i++)
    {
        logSum += log10(i);  // 累加每个 i 的对数值
    }

    // 提取最高位数字
    double small = logSum - floor(logSum);  // 提取小数部分
    int res = pow(10, small);               // 计算最高位数字

    printf("%d\n", res);  // 输出结果
    return 0;  // 程序正常结束
}

1090 : 整数幂（多实例测试）

题目描述

求A^B的最后三位数表示的整数（1<=A,B<=1000）

输入

n个测试实例，每个实例给出两个正整数A,B

输出

输出A^B的最后三位（没有前导0）

样例输入

2
2 3
12 6

样例输出

8
984

C

#include<stdio.h>

void solve()
{
    int a, b; // 定义变量 a 和 b
    scanf("%d%d", &a, &b); // 输入 a 和 b

    int mid = 1; // 初始化结果变量 mid
    for (int i = 0; i < b; i++) // 循环 b 次
    {
        mid = (mid * a) % 1000; // 每次乘法后直接对 1000 取模
    }

    printf("%d\n", mid); 
}

int main()
{
    int n; // 定义变量 n，表示测试用例数量
    scanf("%d", &n); // 输入测试用例数量
    while (n--) // 对每个测试用例调用 solve 函数
    {
        solve();
    }
    return 0;
}

 

C++(使用快速幂算法)

#include <iostream>
using namespace std;

// 快速幂算法，计算 (base^exp) % mod
int quickPow(int base, int exp, int mod) {
    int result = 1; // 初始化结果为1
    base %= mod; // 先对底数取模，避免溢出

    while (exp > 0) {
        if (exp & 1) { // 如果当前位为1
            result = (result * base) % mod; // 将当前底数乘到结果中
        }
        base = (base * base) % mod; // 底数平方，并取模
        exp >>= 1; // 指数右移一位
    }

    return result;
}

void solve() {
    int a, b;
    cin >> a >> b; // 输入 a 和 b

    int result = quickPow(a, b, 1000); // 计算 A^B % 1000
    cout << result << endl; // 输出结果
}

int main() {
    int n;
    cin >> n; // 输入测试用例数量
    while (n--) {
        solve(); // 处理每个测试用例
    }
    return 0;
}


http://www.kler.cn/a/538718.html

相关文章：

  • Oracle迁移到MySQL
  • 利用UNIAPP实现短视频上下滑动播放功能
  • DeepSeek介绍，以及本地部署和API使用
  • NodeList 对象
  • BiGRU双向门控循环单元多变量多步预测，光伏功率预测（Matlab完整源码和数据)
  • 国产化创新 守护开放边界网络安全
  • k8s中pod常见状态解析
  • go结构体和json相互转换、序列化和反序列化
  • 2025年日祭
  • Linux strace命令介绍
  • 音频知识基础
  • 神经网络常见激活函数 5-PReLU函数
  • 阿里云专有云网络架构学习
  • 金三银四Java面试题及答案整理（2025年最新版，持续更新）
  • Java进阶面试八股文
  • DeepSeek使用技巧大全（含本地部署教程）
  • Vue 3 部分新特性解析
  • 【Unity】从父对象中获取子对象组件的方式
  • RNN-day1-NLP基础
  • 大模型推理——MLA实现方案
  • 寒假集训思维训练1题解
  • node 程序占用处理方法与后台运行方法
  • Qt 支持的动画格式对比，Lottie/APNG/GIF/WEBP
  • 已经安装了Visual C++ 2015-2022 Redistributable，但运行程序时，提示找不到VCRUNIME140_1D.dll
  • 通过多层混合MTL结构提升股票市场预测的准确性，R²最高为0.98
  • 【Java基础】序列化、反序列化和不可变类