西邮移动应用开发实验室2025年二面题解

第一题

Description

这天，迅风在欣赏某地的美景时，灵感大作，在上午及下午分别写下了两篇文章，而且迅风很喜欢数文章的字数。

具体地，如果迅风在下午写下的文章的字数之和严格大于他在上午写下的文章的字数之和，则认定他的灵感随着时间的推移越积越多。

现在给出迅风所写的四篇文章的字数，请你回答他的灵感是否随着时间的推移越积越多。

Input

共一行，包含四个正整数 a,b,c,d分别表示迅风在上午写下的两篇文章的字数及他在下午写下的两篇文章的字数。

Output

答案共一行，若迅风的灵感随着时间的推移越积越多，则输出 Yes；否则，输出 No。

Sample 1

Input	Output
`3 2 4 5`	`Yes`

Sample 2

Input	Output
`3 3 4 2`	`No`

数据范围

对于 100%100% 的数据，1≤a,b,c,d≤1001≤a ,b ,c ,d≤100。

思路

下午两数之和如果大于下午两数之和，输出Yes，反之为No

代码

复制代码

#include <iostream>
using namespace std;
int main()
{
    int a,b,c,d;
    cin >> a >> b >> c >> d;
    if(a + b < c + d){
        cout << "Yes" << endl;
    }
    else{
        cout << "No" << endl;
    }

    return 0;
}

第二题

Description

小紫和小蓝是一对双胞胎，但是在游乐场里走散了。然而她们有超能力。

当她们分开一段时间后，可以感应对方的位置，让二人重聚------然而如果距离太远，那么感应也无可奈何。

具体地：

小紫在分离时间 ≥t1 分钟时开启感应，如果她和小蓝距离不超过 d1d1，那么可以感应到小蓝的位置。
小蓝在分离时间 ≥t2分钟时开启感应，如果她和小紫距离不超过 d2d2，那么可以感应到小紫的位置。

当双胞胎的一个人能感应到另一个人的位置，就可以行动使得两人重聚。

现在小紫和小蓝已经分离了 t 分钟，当前距离为 d。她们都在原地等候。

请判断至少还需要几分钟，才能让双胞胎中的一个人感应到另一个人的位置？

Input

输入共有一行六个正整数 t,d,t1,d1,t2,d2，含义如题目描述所示。

Output

输出一行一个整数，表示至少还需要等几分钟。特别地，如果无论等待多久都无法感应到，输出 −1−1。

Sample 1

Input	Output
`7 2 10 8 12 15`	`3`

Sample 2

Input	Output
`11 8 12 19 10 8`	`0`

Sample 3

Input	Output
`100 100 10 7 12 99`	`-1`

数据范围

对于全体数据，保证 1≤t,d,t1,d1,t2,d2≤100

思路

主要分为两步：

判断两个人谁能感应到，并获取他们对应的时间
求出更小的哪一个并输出

代码

复制代码

#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
    int t,d,t1,d1,t2,d2;
    cin >> t >> d >> t1 >> d1 >> t2 >> d2;
    //用min1、min2表示两个人如果能感应到，它们的时间分别是多少
    int min1 = 0x3f3f3f3f, min2 = 0x3f3f3f3f;
    if(d1 >= d){
        min1 = t1 - t;
        if(min1 < 0){
            min1 = 0;
        }
    }
    if(d2 >= d){
        min2 = t2 - t;
        if(min1 < 0){
            min2 = 0;
        }
    }
    if(min1 == 0x3f3f3f3f && min2 == 0x3f3f3f3f){
        cout << "-1" << endl;
    }
    else{
        cout << min(min1, min2) << endl;
    }
    

    return 0;
}

第三题

Description

一个正整数，正读和反读都相同的数为回文数，例如 22,131,2442,37073,6,⋯。所有的 11 位数都是回文数。

现给出一个正整数 n，求出 [1，n] 中的回文数的个数。

Input

一个整数 n。

Output

一个整数，即 1∼n 中全部回文数的个数。

Sample 1

Input	Output
`24`	`11`

数据范围

1≤n≤10^4

思路

枚举1~n所有的数字，一一的判断是否是回文数，使用一个计数器统计结果并输出

代码

复制代码

#include <iostream>
using namespace std;
int ret, n;
//判断是否为回文数
bool Is_Reverse(int x)
{
    int re_num = 0, tmp = x;
    while(x){
    re_num *= 10; 
    re_num += x % 10;
    x /= 10;
    }
    return tmp == re_num;
}
int main()
{
    cin >> n;
    for(int i = 1; i<= n;i++){
        if(Is_Reverse(i)){
            ret++;
        }
    }
    cout << ret << endl;
    
    
    return 0;
}

第四题

Description

人比人，气死人；鱼比鱼，难死鱼。小鱼最近参加了一个"比可爱"比赛，比的是每只鱼的可爱程度。参赛的鱼被从左到右排成一排，头都朝向左边，然后每只鱼会得到一个整数数值，表示这只鱼的可爱程度，很显然整数越大，表示这只鱼越可爱，而且任意两只鱼的可爱程度可能一样。由于所有的鱼头都朝向左边，所以每只鱼只能看见在它左边的鱼的可爱程度，它们心里都在计算，在自己的眼力范围内有多少只鱼不如自己可爱呢。请你帮这些可爱但是鱼脑不够用的小鱼们计算一下。

Input

第一行输入一个正整数 n，表示鱼的数目。

第二行内输入 n 个正整数，用空格间隔，依次表示从左到右每只小鱼的可爱程度 a[i]。

Output

一行，输出 n 个整数，用空格间隔，依次表示每只小鱼眼中有多少只鱼不如自己可爱。

Sample 1

Input	Output
`6 4 3 0 5 1 2`	`0 0 0 3 1 2`

数据范围

对于 100%的数据，1≤n ≤100，0≤ai≤10。

思路

两层循环，外层循环遍历所有鱼，假设当前外层循环遍历到第x只，那么内层循环遍历从1~x-1只鱼，对于每一条鱼判断是否没有第x只鱼可爱，如果没有，计数器加一，内层循环结束则输出计数器结果

代码

复制代码

#include <iostream>
using namespace std;
int a[200];
int main()
{
    int n; cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }
    for (int i = 1; i <= n; i++) {
        int cnt = 0;
        for (int j = 1; j <= i; j++) {
            if (a[j] < a[i]) {
            cnt++;
            }
        }
        cout << cnt << ' ';
    }
}

第五题

Description

一个 n个元素的整数数组，如果数组两个连续元素之间差的绝对值包括了 [1,n−1]之间的所有整数，则称之符合"欢乐的跳"，如数组 {1,4,2,3}符合"欢乐的跳"，因为差的绝对值分别为：3,2,1。

给定一个数组，你的任务是判断该数组是否符合"欢乐的跳"。

Input

每组测试数据第一行以一个整数 n(1≤n≤1000)开始，接下来 n个空格隔开的在 [−108,108] 之间的整数。

Output

对于每组测试数据，输出一行若该数组符合"欢乐的跳"则输出 Jolly，否则输出 Not jolly。

Sample 1

Input	Output
`4 1 4 2 3`	`Jolly`

Sample 2

Input	Output
`5 1 4 2 -1 6`	`Not jolly`

数据范围

1≤n≤1000

思路

分为两步：

输入所有值，并将相邻两数之差的绝对值放在一个数组中
判断该数组中是否是[1,n-1]中的所有数即就是将该数组排序，一一比较，有不同则输出"Not jolly", 反之则为"Jolly"

代码

复制代码

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1e5 + 10;
int a[N];
int jump[N];
int main()
{
    int n; cin >> n;
    for (int i = 1; i <= n; i++) {
    cin >> a[i];
    }
    for (int i = 1; i < n; i++){
        jump[i] = abs(a[i] - a[i + 1]);
    }
    sort(jump + 1, jump + n );
    for (int i = 1; i <= n - 1;i++){
        if (jump[i] != i){
            cout << "Not jolly" << endl;
            return 0;
        }
    }
    cout << "Jolly" << endl;
    return 0;
}

第六题

Description

在一个旧式的火车站旁边有一座桥，其桥面可以绕河中心的桥墩水平旋转。一个车站的职工发现桥的长度最多能容纳两节车厢，如果将桥旋转 180 度，则可以把相邻两节车厢的位置交换，用这种方法可以重新排列车厢的顺序。于是他就负责用这座桥将进站的车厢按车厢号从小到大排列。他退休后，火车站决定将这一工作自动化，其中一项重要的工作是编一个程序，输入初始的车厢顺序，计算最少用多少步就能将车厢排序。

Input

共两行。

第一行是车厢总数 N(≤10000)。

第二行是 N个不同的数表示初始的车厢顺序。（注：实际上数据中并不都在同一行，有可能分行输入）

Output

一个整数，最少的旋转次数。

Sample 1

Input	Output
`4 4 3 2 1`	`6`

思路

从题目中交换的描述我们就可以看出这是一个考察冒泡排序的题目，思路就是记录冒泡排序交换了多少次

代码

复制代码

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1e5 + 10;
int a[N];
int jump[N];
int main()
{
    int n; cin >> n;
    for (int i = 1; i <= n; i++) {
    cin >> a[i];
    }
    for (int i = 1; i < n; i++){
        jump[i] = abs(a[i] - a[i + 1]);
    }
    sort(jump + 1, jump + n );
    for (int i = 1; i <= n - 1;i++){
        if (jump[i] != i){
            cout << "Not jolly" << endl;
            return 0;
        }
    }
    cout << "Jolly" << endl;
    return 0;
}

第七题

Description

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

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

Input

一个单词，其中只可能出现小写字母，并且长度小于 100。

Output

共两行，第一行是一个字符串，假设输入的单词是 Lucky Word，那么输出 Lucky Word，否则输出 No Answer；

第二行是一个整数，如果输入的单词是 Lucky Word，输出 maxn−minn的值，否则输出 0。

Sample 1

Input	Output
`error`	`Lucky Word 2`

Sample 2

Input	Output
`olympic`	`No Answer 0`

思路

分为两步：

读入字符串，统计最大字符数与最小字符数
完成判断素数函数并进行判断输出

代码

复制代码

#include <iostream>
#include <unordered_map>
using namespace std;
string s;
int maxn = -1, minn = 200;
unordered_map<char, int> mp;
bool judge(int n)
{
    if(n <= 1) return 0;
    for (int i = 2; i < n; i++)
    {
        if (n % i == 0) return 0;
    }
    return 1;
}
int main()
{
    cin >> s;
    for (auto e : s){
        mp[e]++;
    }
    for (auto e : mp){
        maxn = max(maxn, e.second);
    }
    for (auto e : mp){
        minn = min(minn, e.second);
    }
    if (judge(maxn - minn)){
        cout << "Lucky Word" << endl << maxn - minn;
    }
    else{
        cout << "No Answer" << endl << 0;
    }
    return 0;
}

第八题

Description

给定一行句子，每个词之间用空格隔开，要么是全小写英文单词，要么是全大写英文单词，要么是自然数。

要求将这些单词倒序输出。而且对于每个单词，如果是小写词，应当转为大写；如果是大写词，应当转为小写；如果是自然数，应该倒转输出。

举一个例子：

复制代码

we choose TO go 2 the 123 moon

Plain text

程序应当输出：

复制代码

MOON 321 THE 2 GO to CHOOSE WE

Input

仅一行，即需要反转的句子。

Output

仅一行，表示程序对句子的处理结果。

Sample 1

Input	Output
`we choose TO go 2 the 123 moon`	`MOON 321 THE 2 GO to CHOOSE WE`

思路

按照字符串将一个个的单词读入字符串类型的数组中

反序输出得到逆序
对于每一个对象，输出前先考虑它是哪一种类型的，针对不同的类型进行不同的操作

代码

复制代码

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1010;
string a[N];
void Re_Num(string& s)
{
    reverse(s.begin(), s.end());
}
int main()
{
    int i = 1;
    while (cin >> a[i]) {
        i++;
    };
    for (int j = i-1; j >= 1; j--) {
        if (isalpha(a[j][0])) {
            if (a[j][0] >= 'a' && a[j][0] <= 'z') {
                for (auto e : a[j]) {
                    printf("%c", toupper(e));
                }cout << ' ';
            }
            else {
                for (auto e : a[j]) {
                    printf("%c", tolower(e));
                }cout << ' ';
            }
        }
        else {
            Re_Num(a[j]);
            cout << a[j] << ' ';
        }
    }
    return 0;
}

复制代码

结语

这就是西安邮电大学2025年移动应用开发实验室所有二面题目的题解啦！