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

ZZNUOJ(C/C++)基础练习1061——1070(详解版)

article 2025/2/7 4:23:21

1061 : 顺序输出各位数字

C语言版

C++版

1062 : 最大公约数

C++

1063 : 最大公约与最小公倍

C++

1064 : 加密字符

C++

1065 : 统计数字字符的个数

C++

1066 : 字符分类统计

C++

1067 : 有问题的里程表

C++

1068 : 进制转换

C++

C++（容器stack）

1069 : 向Z同学学习

C++

1070 : 小汽车的位置

C++

代码逻辑解释

收藏加关注，观看不迷路

1061 : 顺序输出各位数字

题目描述

输入一个整数，从高位开始逐位分割并输出各位数字。

输入

输入一个正整数n,n是int型数据

输出

依次输出各位上的数字，每一个数字后面有一个空格，输出占一行。例如，输入 12345 ，输出 1 2 3 4 5

样例输入
12345
样例输出
1 2 3 4 5

C语言版

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

int main()
{
    int n, arr[100], i = 0, j;  // 定义变量
    // n: 输入的整数
    // arr: 用于存储分离出来的每一位数字，数组大小为100
    // i: 用于记录分离出的数字个数，初始化为0
    // j: 用于循环遍历数组

    scanf("%d", &n);  // 从标准输入读取一个整数 n

    // 使用 while 循环分离每一位数字，逆序存储
    while (n != 0)
    {
        arr[i++] = n % 10;  // 取出 n 的最后一位数字，存储到数组 arr 中，并将 i 加 1
        n /= 10;            // 去掉 n 的最后一位数字
    }

    // 使用 for 循环按从高位到低位的顺序输出每一位数字
    for (j = i - 1; j >= 0; j--)
    {
        printf("%d ", arr[j]);  // 逆序输出数组 arr 中的每一位数字
    }

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

C++版

#include<bits/stdc++.h>
using namespace std;

int main()
{
    string line;  // 定义一个字符串变量 line，用于存储输入的整行
    getline(cin, line);  // 使用 std::getline 读取整行输入

    // 使用 range-based for 循环遍历字符串，并输出每个字符
    for (char ch : line)
    {
        cout << ch << " ";  // 输出每个字符，字符之间用空格分隔
    }

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

码二

#include <bits/stdc++.h>
using namespace std;

int main() {
    char ch;
    int i = 0;
    vector<char> str(21); // 定义一个大小为21的vector，足够存储20个字符和一个换行符
    while (scanf("%c", &ch) == 1 && ch != '\n') { // 检查scanf的返回值，并确保ch不等于换行符
        if (i < 20) { // 限制输入字符数量不超过20
            str[i++] = ch;
        }
    }
    str[i] = '\0'; // 在字符串末尾添加空字符，确保字符串正确终止

    // 输出vector中的字符
    for (int j = 0; j < i; ++j) { // 只输出实际存储的字符
        printf("%c ", str[j]);
    }
    printf("\n"); // 输出换行符，确保输出格式正确

    return 0;
}

1062 : 最大公约数

题目描述

输入两个正整数，输出其最大公约数。

输入

输入两个正整数m和n，数据之间用空格隔开。

输出

输出一个整数，表示m和n的最大公约数。

样例输入
4 6
样例输出
2
坑点：C++使用cin 和cout输入输出时，OJ 过不了，换成scanf和printf就过了

C

#include<stdio.h>
int main()
{
    int m, n, r; // 定义三个整数变量，用于存储输入的两个数和余数
    scanf("%d%d", &m, &n); // 从标准输入读取两个整数，分别存储到变量 m 和 n 中

    // 如果 m 大于 n，交换它们的值，确保 m <= n
    if(m > n)
    {
        int mid = m; // 使用中间变量 mid 来暂存 m 的值
        m = n;       // 将 n 的值赋给 m
        n = mid;     // 将 mid（原 m 的值）赋给 n
    }

    // 使用欧几里得算法计算最大公约数
    while(r = n % m, r != 0) // 在每次循环中，计算 n 除以 m 的余数 r，并检查 r 是否为 0
    {
        n = m; // 如果 r 不为 0，将 m 的值赋给 n
        m = r; // 将余数 r 赋给 m
    }

    printf("%d\n", m); // 最终，m 的值即为最大公约数，输出结果
    return 0; // 程序正常结束，返回 0
}

C++

#include <iostream>
#include <algorithm> // 包含算法库，用于使用 swap 函数
using namespace std;

int main() {
    ios::sync_with_stdio(false); // 关闭 C++ 和 C 标准输入输出之间的同步，提高输入输出效率
    cin.tie(nullptr);            // 解绑 cin 和 cout，进一步提高效率

    int m, n, r; // 定义三个整数变量，用于存储输入的两个数和余数
    scanf("%d%d", &m, &n);       // 使用 scanf 从标准输入读取两个整数，分别存储到变量 m 和 n 中

    // 如果 m 大于 n，交换它们的值，确保 m <= n
    if (m > n) swap(m, n);       // 使用标准库中的 swap 函数交换 m 和 n 的值

    // 使用欧几里得算法计算最大公约数
    while (r = n % m, r != 0) {  // 在每次循环中，计算 n 除以 m 的余数 r，并检查 r 是否为 0
        n = m;                   // 如果 r 不为 0，将 m 的值赋给 n
        m = r;                   // 将余数 r 赋给 m
    }

    printf("%d\n", m);           // 最终，m 的值即为最大公约数，使用 printf 输出结果
    return 0;                    // 程序正常结束，返回 0
}

1063 : 最大公约与最小公倍

题目描述

输入两个正整数，输出其最大公约数和最小公倍数。

输入

输入两个正整数n和m（n,m<=1000000)。输入保证最终结果在int范围内。

输出

输出两个整数，用空格隔开。表示m和n的最大公约数和最小公倍数。

样例输入
4 6
样例输出
2 12
注意：要用 long long定义变量，防止溢出

C

#include<stdio.h>

int main() {
    long long mid1, m, n, r; // 定义变量，m 和 n 用于存储输入的两个整数，r 用于存储余数，mid1 用于存储两数的乘积

    // 从标准输入读取两个整数 m 和 n
    scanf("%lld%lld", &m, &n);

    // 计算两个数的乘积，用于后续计算最小公倍数
    mid1 = m * n;

    // 如果 m 大于 n，交换它们的值，确保 m <= n
    if (m > n) {
        int mid = m; // 使用中间变量 mid 来暂存 m 的值
        m = n;       // 将 n 的值赋给 m
        n = mid;     // 将 mid（原 m 的值）赋给 n
    }

    // 使用欧几里得算法计算最大公约数
    while (r = n % m, r != 0) { // 在每次循环中，计算 n 除以 m 的余数 r，并检查 r 是否为 0
        n = m;                  // 如果 r 不为 0，将 m 的值赋给 n
        m = r;                  // 将余数 r 赋给 m
    }

    // 输出最大公约数和最小公倍数
    // 最小公倍数 = 两数乘积 / 最大公约数
    printf("%lld %lld\n", m, mid1 / m);

    return 0; // 程序正常结束，返回 0
}

C++

#include<iostream> // 包含输入输出流库
#include<algorithm> // 包含算法库，用于使用 swap 函数
using namespace std; // 使用标准命名空间

int main() {
    ios::sync_with_stdio(false); // 关闭 C++ 和 C 标准输入输出之间的同步，提高输入输出效率
    cin.tie(nullptr);            // 解绑 cin 和 cout，进一步提高效率

    long long mid1, m, n, r; // 定义变量，m 和 n 用于存储输入的两个整数，r 用于存储余数，mid1 用于存储两数的乘积

    // 使用 scanf 从标准输入读取两个整数，分别存储到变量 m 和 n 中
    scanf("%lld%lld", &m, &n);

    // 计算两个数的乘积，用于后续计算最小公倍数
    mid1 = m * n;

    // 如果 m 大于 n，交换它们的值，确保 m <= n
    if (m > n) swap(m, n); // 使用标准库中的 swap 函数交换 m 和 n 的值

    // 使用欧几里得算法计算最大公约数
    while (r = n % m, r != 0) { // 在每次循环中，计算 n 除以 m 的余数 r，并检查 r 是否为 0
        n = m;                  // 如果 r 不为 0，将 m 的值赋给 n
        m = r;                  // 将余数 r 赋给 m
    }

    // 输出最大公约数和最小公倍数
    // 最小公倍数 = 两数乘积 / 最大公约数
    printf("%lld %lld\n", m, mid1 / m);

    return 0; // 程序正常结束，返回 0
}

1064 : 加密字符

题目描述

从键盘输入一批字符，以@结束，按要求加密并输出。

输入

从键盘输入一批字符，占一行，以@结束。

输出

输出占一行
加密规则:
1）、所有字母均转换为小写。
2）、若是字母'a'到'y'，则转化为下一个字母，若是'z'，则转化为'a'。
3）、其它字符，保持不变。

样例输入

Kyh520@

样例输出

lzi520

C

#include<stdio.h>

int main()
{
    char ch, str[100000]; // 定义字符变量 ch 用于读取输入字符，str 用于存储处理后的结果，长度为 100000
    int i = 0;            // 定义索引变量 i，用于记录当前存储位置

    // 循环读取字符，直到遇到 '@' 为止
    while(scanf("%c", &ch), ch != '@')
    {
        // 如果是小写字母
        if(ch >= 'a' && ch <= 'z')
        {
            // 如果是 'z'，转换为 'a'
            if(ch == 'z')
            {
                str[i++] = 'a';
            }
            else
            {
                // 否则，转换为下一个字母
                str[i++] = ch + 1;
            }       
        }   
        // 如果是大写字母
        else if(ch >= 'A' && ch <= 'Z')
        {
            // 如果是 'Z'，转换为 'a'
            if(ch == 'Z')
            {
                str[i++] = 'a';
            }
            else
            {
                // 否则，转换为对应的小写字母的下一个字母
                str[i++] = ch + 33;
            }
        }
        // 如果是其他字符，直接存储
        else
        {
            str[i++] = ch;
        }
    }

    // 在字符串末尾添加空字符，确保字符串正确终止
    str[i] = '\0';

    // 输出处理后的字符串
    printf("%s\n", str);

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

C++

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

int main()
{
    ios::sync_with_stdio(false); // 关闭 C++ 和 C 标准输入输出之间的同步，提高输入输出效率

    char ch, str[100000]; // 定义字符变量 ch 用于读取输入字符，str 用于存储处理后的结果，假设输入长度不超过 100000
    int i = 0;            // 定义索引变量 i，用于记录当前存储位置

    // 循环读取字符，直到遇到 '@' 为止
    while(scanf("%c", &ch), ch != '@')
    {
        // 如果是小写字母
        if(ch >= 'a' && ch <= 'z')
        {
            // 如果是 'z'，转换为 'a'
            if(ch == 'z')
            {
                str[i++] = 'a';
            }
            else
            {
                // 否则，转换为下一个字母
                str[i++] = ch + 1;
            }       
        }   
        // 如果是大写字母
        else if(ch >= 'A' && ch <= 'Z')
        {
            // 如果是 'Z'，转换为 'a'
            if(ch == 'Z')
            {
                str[i++] = 'a';
            }
            else
            {
                // 否则，转换为对应的小写字母的下一个字母
                str[i++] = ch + 33; // 大写字母转换为小写字母后加1
            }
        }
        // 如果是其他字符，直接存储
        else
        {
            str[i++] = ch;
        }
    }

    // 在字符串末尾添加空字符，确保字符串正确终止
    str[i] = '\0';

    // 输出处理后的字符串
    printf("%s\n", str);

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

1065 : 统计数字字符的个数

题目描述

输入一行字符，以回车符作为输入结束的标志。统计其中数字字符的个数。

输入

多个字符，以回车符结束，回车符不作为有效字符。

输出

输出一个整数，表示数字字符的个数。

样例输入

12abrt12@2013

样例输出
8

C

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

int main()
{
    char ch; // 定义字符变量 ch，用于逐个读取输入的字符
    int num = 0; // 定义变量 num，用于统计数字字符的数量，初始值为 0

    // 循环读取字符，直到遇到换行符 '\n' 为止
    while(scanf("%c", &ch), ch != '\n')
    {
        // 如果字符是数字字符（'0' 到 '9'）
        if(ch >= '0' && ch <= '9')
        {
            num++; // 数字字符计数加 1
        }
    }

    // 输出统计到的数字字符的数量
    printf("%d\n", num);

    return 0; // 程序正常结束，返回 0
}

C++

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

int main()
{
    char ch; // 定义字符变量 ch，用于逐个读取输入的字符
    int num = 0; // 定义变量 num，用于统计数字字符的数量，初始值为 0

    // 循环读取字符，直到遇到换行符 '\n' 为止
    while(scanf("%c", &ch), ch != '\n')
    {
        // 如果字符是数字字符（'0' 到 '9'）
        if(ch >= '0' && ch <= '9')
        {
            num++; // 数字字符计数加 1
        }
    }

    // 输出统计到的数字字符的数量
    printf("%d\n", num);

    return 0; // 程序正常结束，返回 0
}

1066 : 字符分类统计

题目描述

输入一行字符，以回车符作为输入结束的标志。统计其中英文字母、数字字符和其他字符的个数。

输入

多个字符，以回车符结束，回车符不作为有效字符。有效字符个数不超过100。

输出

输出分3行，格式见输出样例。

样例输入

Abse 4+5*3=?

样例输出
letter:4
digit:3
other:5

C

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

int main()
{
    char ch; // 定义字符变量 ch，用于逐个读取输入的字符
    int letter = 0, digit = 0, other = 0; // 定义三个变量，分别用于统计字母、数字和其他字符的数量

    // 循环读取字符，直到遇到换行符 '\n' 为止
    while(scanf("%c", &ch), ch != '\n')
    {
        // 如果字符是数字字符（'0' 到 '9'）
        if(ch >= '0' && ch <= '9')
        {
            digit++; // 数字字符计数加 1
        }
        // 如果字符是字母（小写或大写）
        else if(ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z')
        {
            letter++; // 字母字符计数加 1
        }
        // 如果字符既不是数字也不是字母
        else
        {
            other++; // 其他字符计数加 1
        }
    }

    // 输出统计结果
    printf("letter:%d\ndigit:%d\nother:%d\n", letter, digit, other);

    return 0; // 程序正常结束，返回 0
}

C++

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

int main()
{
    ios::sync_with_stdio(false); // 关闭 C++ 和 C 标准输入输出之间的同步，提高输入输出效率
    char ch; // 定义字符变量 ch，用于逐个读取输入的字符
    int letter = 0, digit = 0, other = 0; // 定义三个变量，分别用于统计字母、数字和其他字符的数量

    // 循环读取字符，直到遇到换行符 '\n' 为止
    while(scanf("%c", &ch), ch != '\n')
    {
        // 如果字符是数字字符（'0' 到 '9'）
        if(ch >= '0' && ch <= '9')
        {
            digit++; // 数字字符计数加 1
        }
        // 如果字符是字母（小写或大写）
        else if(ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z')
        {
            letter++; // 字母字符计数加 1
        }
        // 如果字符既不是数字也不是字母
        else
        {
            other++; // 其他字符计数加 1
        }
    }

    // 输出统计结果
    printf("letter:%d\ndigit:%d\nother:%d\n", letter, digit, other);

    return 0; // 程序正常结束，返回 0
}

1067 : 有问题的里程表

题目描述

某辆汽车有一个里程表，该里程表可以显示一个整数，为该车走过的公里数。然而这个里程表有个毛病：它总是从3变到5，而跳过数字4，里程表所有位（个位、十位、百位等）上的数字都是如此。例如，如果里程表显示339,汽车走过1公里之后，该里程表显示350。

输入

输入一个整数num，表示里程表显示的数值，1 < num < 1000，且一定不含整数4。

输出

输出一个整数，为该汽车实际行驶的公里数。例如，如果该里程表显示55，则实际走过的公里数是40。

样例输入

106

样例输出
86
此题本质：进制转换（10 进制转为9进制）

C

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

int main()
{
    int num, mid = 1, res = 0; // 定义变量
    // num 用于存储输入的数字
    // mid 用于表示当前位的权重，初始化为 1
    // res 用于存储转换后的结果，初始化为 0

    scanf("%d", &num); // 从标准输入读取一个整数，存储到变量 num 中

    // 循环处理 num 的每一位，直到 num 为 0
    while(num != 0)
    {
        // 处理当前位的数字（从最低位开始）
        if(num % 10 < 4) // 如果当前位的数字小于 4
        {
            res += (num % 10) * mid; // 直接将当前位的数字乘以权重 mid，加到结果 res 中
        }
        else // 如果当前位的数字大于等于 4
        {
            res += (num % 10 - 1) * mid; // 将当前位的数字减 1 后乘以权重 mid，加到结果 res 中
        }
        num /= 10; // 去掉 num 的最低位，处理下一位
        mid *= 9; // 更新权重 mid，每次乘以 9
    }

    printf("%d\n", res); // 输出转换后的结果
    return 0; // 程序正常结束，返回 0
}

C++

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

int main()
{
    ios::sync_with_stdio(false); // 关闭 C++ 和 C 标准输入输出之间的同步，提高输入输出效率
    int num, mid = 1, res = 0; // 定义变量
    // num 用于存储输入的数字
    // mid 用于表示当前位的权重，初始化为 1
    // res 用于存储转换后的结果，初始化为 0

    scanf("%d", &num); // 从标准输入读取一个整数，存储到变量 num 中

    // 循环处理 num 的每一位，直到 num 为 0
    while(num != 0)
    {
        // 处理当前位的数字（从最低位开始）
        if(num % 10 < 4) // 如果当前位的数字小于 4
        {
            res += (num % 10) * mid; // 直接将当前位的数字乘以权重 mid，加到结果 res 中
        }
        else // 如果当前位的数字大于等于 4
        {
            res += (num % 10 - 1) * mid; // 将当前位的数字减 1 后乘以权重 mid，加到结果 res 中
        }
        num /= 10; // 去掉 num 的最低位，处理下一位
        mid *= 9; // 更新权重 mid，每次乘以 9
    }

    printf("%d\n", res); // 输出转换后的结果
    return 0; // 程序正常结束，返回 0
}

1068 : 进制转换

题目描述

将一个二进制数，转换为对应的十进制数。

输入

输入一个二进制数，以回车结束。该二进制数为正数，长度不超过31。

输出

输出一个整数，为该二进制数对应的十进制数。

样例输入

100000000001

样例输出
2049

C

#include<stdio.h> // 包含标准输入输出库
#include<string.h> // 包含字符串处理库，用于使用 strlen 函数

int main()
{
    char arr1[100]; // 定义字符数组 arr1，用于存储输入的二进制数
    gets(arr1); // 从标准输入读取一行字符串，存储到 arr1 中

    int sz = strlen(arr1); // 计算输入字符串的长度
    int res = 0; // 定义变量 res，用于存储转换后的十进制数
    int mid = 1; // 定义变量 mid，用于表示当前位的权重（2 的幂次），初始化为 1

    // 从字符串的末尾开始，逐位处理二进制数
    for(int i = sz - 1; i >= 0; i--)
    {
        res += (arr1[i] - '0') * mid; // 将当前位的数字（0 或 1）乘以权重 mid，加到结果 res 中
        mid *= 2; // 更新权重 mid，每次乘以 2
    }

    printf("%d\n", res); // 输出转换后的十进制数
    return 0; // 程序正常结束，返回 0
}

C++

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

int main()
{
    ios::sync_with_stdio(false); // 关闭C++和C标准输入输出之间的同步，提高输入输出效率
    string arr1; // 定义一个字符串变量arr1，用于存储输入的二进制数
    getline(cin, arr1); // 使用getline从标准输入读取一行字符串，存储到arr1中

    int sz = arr1.length(); // 计算输入字符串的长度
    int res = 0; // 定义变量res，用于存储转换后的十进制数
    int mid = 1; // 定义变量mid，用于表示当前位的权重（2的幂次），初始化为1

    // 从字符串的末尾开始，逐位处理二进制数
    for(int i = sz - 1; i >= 0; i--)
    {
        res += (arr1[i] - '0') * mid; // 将当前位的数字（'0'或'1'）转换为整数，并乘以权重mid，加到结果res中
        mid *= 2; // 更新权重mid，每次乘以2
    }

    printf("%d\n", res); // 输出转换后的十进制数
    return 0; // 程序正常结束，返回0
}

C++（容器stack）

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

int main()
{
    ios::sync_with_stdio(false); // 关闭C++和C标准输入输出之间的同步，提高输入输出效率
    stack<char> str; // 定义一个字符栈str，用于存储输入的二进制数
    char ch; // 定义字符变量ch，用于逐个读取输入的字符
    int res = 0; // 定义变量res，用于存储转换后的十进制数
    int mid = 1; // 定义变量mid，用于表示当前位的权重（2的幂次），初始化为1

    // 循环读取字符，直到遇到换行符'\n'为止
    while(scanf("%c", &ch), ch != '\n')
    {
        str.push(ch); // 将读取的字符推入栈中
    }

    // 逐个弹出栈中的字符，进行转换
    while(!str.empty())
    {
        res += (str.top() - '0') * mid; // 将栈顶字符转换为整数，并乘以权重mid，加到结果res中
        str.pop(); // 弹出栈顶字符
        mid *= 2; // 更新权重mid，每次乘以2
    }

    printf("%d\n", res); // 输出转换后的十进制数
    return 0; // 程序正常结束，返回0
}

1069 : 向Z同学学习

题目描述

Z同学为了实现暑假去云南旅游的梦想，决定以后每天只消费1元，每花k元就可以再得到1元，一开始Z同学有M元，问最多可以坚持多少天。

输入

输入2个整数M, k，(2 <= k <= M <= 1000)。

输出

输出一个整数，表示M元可以消费的天数。

样例输入

4 3

样例输出
5

C

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

int main()
{
    int M, k, day = 0; // 定义变量
    // M：Z同学初始拥有的钱数
    // k：每消费k元可以额外获得1元的条件
    // day：记录Z同学可以坚持的总天数，初始化为0

    scanf("%d%d", &M, &k);

    // 循环处理，直到Z同学的钱数M为0
    while(M != 0)
    {
        // 如果Z同学的钱数M大于等于k
        if(M >= k)
        {
            day += k; 
            M = M - k + 1; // Z同学消费了k元后，额外获得1元，剩余的钱数为M-k+1
        }
        else
        {
            day += M; // Z同学的钱数M小于k，只能坚持M天
            M = 0; // Z同学的钱数M为0，结束循环
        }
    }

    printf("%d\n", day); // 输出Z同学可以坚持的总天数
    return 0; // 程序正常结束，返回0
}

C++

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

int main()
{
    ios::sync_with_stdio(false); // 关闭C++和C标准输入输出之间的同步，提高输入输出效率
    int M, k, day = 0; // 定义变量M（Z同学初始拥有的钱数）、k（每消费k元可以额外获得1元的条件）和day（Z同学可以坚持的总天数）
    scanf("%d%d", &M, &k); 
    // 循环处理，直到Z同学的钱数M为0
    while(M != 0)
    {
        // 如果Z同学的钱数M大于等于k
        if(M >= k)
        {
            day += k;
            M = M - k + 1; // Z同学消费了k元后，额外获得1元，剩余的钱数为M-k+1
        }
        else
        {
            day += M;
            M = 0; // Z同学的钱数M为0，结束循环
        }
    }

    printf("%d\n", day); // 输出Z同学可以坚持的总天数
    return 0; // 程序正常结束，返回0
}

1070 : 小汽车的位置

题目描述

有一辆智能小车，最初（时间为0)的位置为(0,0)，我们想知道它最后的位置。小车以每小时10公里的速度向北移动（以北为y轴正向，以东为x轴正向）。小车会受到一系列依照时间戳记排序的命令，1表示“向左转”，2表示“向右转”，3表“停止”。每个命令的前面有一个时间戳记，所以我们知道该命令是何时发出的。最后一个命令一定是“停止”。我们另外假设，这辆小车非常灵活，它可以在瞬间转弯。
以下列输入为例。小车在时间为5的时候收到一个“向左转”的命令1，在时间10收到一个“向右转”的命令2，在时间15收到一个“停止”的命令3。那么在最后时间15的时候，小车的位置将在（-50,100）。程序只要求输出小车最后的位置，第一个整数是x坐标，第二个整数是y坐标。

输入

输入包含多个命令，每个命令由整数time和command组成，表示在时刻time发出命令command。command的取值范围1~3，含义如上所述。

输出

输出占一行，包含两个整数，表示小车的最终位置。两个整数之间由空格隔开。

样例输入

5 1
10 2
15 3

样例输出
-50 100
注意：由题可知小车初始方向为北

C

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

int main()
{
    int time, time0 = 0, time1, command, x = 0, y = 0; // 定义变量
    // time：当前时间段的长度
    // time0：上一个命令的时间戳
    // time1：当前命令的时间戳
    // command：当前命令
    // x：小车的x坐标
    // y：小车的y坐标
    int flag = 1; // 定义方向标志，1表示向北，2表示向东，3表示向南，4表示向西

    // 无限循环，直到接收到停止命令
    while(1)
    {
        scanf("%d%d", &time1, &command); // 读取当前命令的时间戳和命令类型
        time = time1 - time0; // 计算上一个命令的有效时间长度
        time0 = time1; // 更新上一个命令的时间戳，为下次循环做准备

        // 根据当前方向标志更新小车的位置
        if(flag == 1) // 向北移动
        {
            y += 10 * time; // y坐标增加
        }   
        else if(flag == 2) // 向东移动
        {
            x += 10 * time; // x坐标增加
        }
        else if(flag == 3) // 向南移动
        {
            y -= 10 * time; // y坐标减少
        }
        else // 向西移动
        {
            x -= 10 * time; // x坐标减少
        }

        // 处理命令
        if(command == 3) // 停止命令
        {
            break; // 退出循环
        }
        else if(command == 1) // 向左转
        {
            flag--; // 方向标志减1
        }
        else // 向右转
        {
            flag++; // 方向标志加1
        }

        // 处理方向标志越界
        if(flag == 0) flag = 4; // 如果方向标志为0，调整为4（向西）
        if(flag == 5) flag = 1; // 如果方向标志为5，调整为1（向北）
    }

    printf("%d %d", x, y); // 输出小车的最终位置
    return 0; // 程序正常结束，返回0
}

C++

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

int main()
{
    ios::sync_with_stdio(false); // 关闭C++和C标准输入输出之间的同步，提高输入输出效率
    int time, time0 = 0, time1, command, x = 0, y = 0; // 定义变量
    // time：当前时间段的长度
    // time0：上一个命令的时间戳
    // time1：当前命令的时间戳
    // command：当前命令
    // x：小车的x坐标
    // y：小车的y坐标
    int flag = 1; // 定义方向标志，1表示向北，2表示向东，3表示向南，4表示向西

    // 无限循环，直到接收到停止命令
    while(1)
    {
        scanf("%d%d", &time1, &command); // 读取当前命令的时间戳和命令类型
        time = time1 - time0; // 计算当前时间段的长度
        time0 = time1; // 更新上一个命令的时间戳

        // 根据当前方向标志更新小车的位置
        if(flag == 1) // 向北移动
        {
            y += 10 * time; // y坐标增加
        }   
        else if(flag == 2) // 向东移动
        {
            x += 10 * time; // x坐标增加
        }
        else if(flag == 3) // 向南移动
        {
            y -= 10 * time; // y坐标减少
        }
        else // 向西移动
        {
            x -= 10 * time; // x坐标减少
        }

        // 处理命令
        if(command == 3) // 停止命令
        {
            break; // 退出循环
        }
        else if(command == 1) // 向左转
        {
            flag--; // 方向标志减1
        }
        else // 向右转
        {
            flag++; // 方向标志加1
        }

        // 处理方向标志越界
        if(flag == 0) flag = 4; // 如果方向标志为0，调整为4（向西）
        if(flag == 5) flag = 1; // 如果方向标志为5，调整为1（向北）
    }

    printf("%d %d", x, y); // 输出小车的最终位置
    return 0; // 程序正常结束，返回0
}

代码逻辑解释

变量定义：

time：当前时间段的长度。

time0：上一个命令的时间戳，初始化为0。

time1：当前命令的时间戳。

command：当前命令。

x 和 y：小车的x和y坐标，初始位置为(0,0)。

flag：方向标志，1表示向北，2表示向东，3表示向南，4表示向西。

输入命令：

使用scanf读取每个命令的时间戳time1和命令类型command。

计算时间段：

time = time1 - time0：计算上个命令的有效时间长度。

更新time0为当前时间戳time1。

更新位置：

根据当前方向标志flag，更新小车的x和y坐标。

速度为每小时10公里，因此每单位时间移动10单位距离。

处理命令：

如果命令为3（停止），退出循环。

如果命令为1（向左转），方向标志flag减1。

如果命令为2（向右转），方向标志flag加1。

处理方向标志越界：

如果flag为0，0是由1减1得到的，1为北向，减一为左转，北向左转为西向，所以调整为4（向西）。

如果flag为5，0是由4加1得到的，4为西向，加一为右转，西向右转为北向，所以调整为1（向北）。