饿了么2025/03/07实习笔试真题解析

第一题 小红的字符串

小红拿到了一个01串s。她将进行恰好一次以下操作:

选择下标i,j(i≠j)，交换si和sj。

小红想知道，不同的操作方案，最终能生成多少不 同的字符串?

输入描述

一个仅由'0'和"1'构成的字符串。字符串长度不小于2,不大于200000。

输出描述

一个整数，代表最终的方案数。

示例1

输入

1 1 0 0

输出

5

说明

共有以下5种不同字符串:

交换第一个和第二个字符，形成1100

交换第二个和第三个字符，形成1010

交换第二个和第四个字符，形成1001

交换第一个和第三个字符，形成0110

交换第一个和第四个字符，形成0101

思路：

在遍历字符串时，可以动态统计 '0' 和 '1' 的数量，并计算交换后生成的不同字符串方案数：

1. 初始化 c0 = 0 和 c1 = 0，表示当前已遍历的字符中 '0' 和 '1' 的数量。
2. 初始化 res = 1，表示原始字符串本身也是一种方案。
3. 遍历字符串中的每一个字符：如果当前字符是 '0'：将当前字符与之前所有 '1' 交换，生成新的字符串，方案数增加 c1。更新 c0，表示当前 '0' 的数量增加。如果当前字符是 '1'：将当前字符与之前所有 '0' 交换，生成新的字符串，方案数增加 c0。更新 c1，表示当前 '1' 的数量增加。
4. 最终输出 res，即不同字符串的方案数。

Java

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        // 初始化计数器，用于统计字符 '0' 的数量
        int c0 = 0;
        // 初始化计数器，用于统计字符 '1' 的数量
        int c1 = 0;
        // 初始化结果变量，初始值为 1（表示原始字符串本身也是一种方案）
        int res = 1;
        // 遍历字符串 s 中的每一个字符
        for (int i = 0; i < s.length(); i++) {
            // 获取当前索引位置的字符
            char ch = s.charAt(i);
            if (ch == '0') {  // 如果当前字符是 '0'
                // 将当前字符与之前所有 '1' 交换，生成新的字符串，方案数增加 c1
                res += c1;
                // 更新 '0' 的计数器
                c0++;
            } else {  // 如果当前字符是 '1'
                // 将当前字符与之前所有 '0' 交换，生成新的字符串，方案数增加 c0
                res += c0;
                // 更新 '1' 的计数器
                c1++;
            }
        }
        // 输出最终的方案数
        System.out.println(res);
    }
}

Python3

s = input()  # 读取输入的字符串s

c0 = 0  # 初始化计数器，用于统计字符'0'的数量
c1 = 0  # 初始化计数器，用于统计字符'1'的数量
res = 1  # 初始化结果变量，初始值为1（表示原始字符串本身也是一种方案）

# 遍历字符串s中的每一个字符
for i, ch in enumerate(s):
    if ch == "0":  # 如果当前字符是'0'
        res += c1  # 将当前字符与之前所有'1'交换，生成新的字符串，方案数增加c1
        c0 += 1  # 更新'0'的计数器
    else:  # 如果当前字符是'1'
        res += c0  # 将当前字符与之前所有'0'交换，生成新的字符串，方案数增加c0
        c1 += 1  # 更新'1'的计数器

print(res)  # 输出最终的方案数

C++

#include <iostream>
#include <string>
using namespace std;
int main() {
    string s;
    cin >> s;
    // 初始化计数器，用于统计字符 '0' 的数量
    int c0 = 0;
    // 初始化计数器，用于统计字符 '1' 的数量
    int c1 = 0;
    // 初始化结果变量，初始值为 1（表示原始字符串本身也是一种方案）
    int res = 1;
    // 遍历字符串 s 中的每一个字符
    for (int i = 0; i < s.length(); i++) {
        // 获取当前索引位置的字符
        char ch = s[i];
        if (ch == '0') {  // 如果当前字符是 '0'
            // 将当前字符与之前所有 '1' 交换，生成新的字符串，方案数增加 c1
            res += c1;
            // 更新 '0' 的计数器
            c0++;
        } else {  // 如果当前字符是 '1'
            // 将当前字符与之前所有 '0' 交换，生成新的字符串，方案数增加 c0
            res += c0;
            // 更新 '1' 的计数器
            c1++;
        }
    }
    // 输出最终的方案数
    cout << res << endl;
    return 0;
}

C语言

#include <stdio.h>
#include <string.h>
#define MAX_LEN 200000
int main() {
    char s[MAX_LEN+1];
    scanf("%s", s);
    // 初始化计数器，用于统计字符 '0' 的数量
    int c0 = 0;
    // 初始化计数器，用于统计字符 '1' 的数量
    int c1 = 0;
    // 初始化结果变量，初始值为 1（表示原始字符串本身也是一种方案）
    int res = 1;
    // 计算字符串的长度
    int len = strlen(s);
    // 遍历字符串 s 中的每一个字符
    for (int i = 0; i < len; i++) {
        // 获取当前索引位置的字符
        char ch = s[i];
        if (ch == '0') {  // 如果当前字符是 '0'
            // 将当前字符与之前所有 '1' 交换，生成新的字符串，方案数增加 c1
            res += c1;
            // 更新 '0' 的计数器
            c0++;
        } else {  // 如果当前字符是 '1'
            // 将当前字符与之前所有 '0' 交换，生成新的字符串，方案数增加 c0
            res += c0;
            // 更新 '1' 的计数器
            c1++;
        }
    }
    // 输出最终的方案数
    printf("%d\n", res);
    return 0;
}

JsNode

const readline = require('readline');
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});
rl.question('', (s) => {
    // 初始化计数器，用于统计字符 '0' 的数量
    let c0 = 0;
    // 初始化计数器，用于统计字符 '1' 的数量
    let c1 = 0;
    // 初始化结果变量，初始值为 1（表示原始字符串本身也是一种方案）
    let res = 1;
    // 遍历字符串 s 中的每一个字符
    for (let i = 0; i < s.length; i++) {
        const ch = s[i];
        if (ch === '0') {  // 如果当前字符是 '0'
            // 将当前字符与之前所有 '1' 交换，生成新的字符串，方案数增加 c1
            res += c1;
            // 更新 '0' 的计数器
            c0++;
        } else {  // 如果当前字符是 '1'
            // 将当前字符与之前所有 '0' 交换，生成新的字符串，方案数增加 c0
            res += c0;
            // 更新 '1' 的计数器
            c1++;
        }
    }
    // 输出最终的方案数
    console.log(res);
    // 关闭 readline 接口
    rl.close();
});

Go 

package main
import (
    "bufio"
    "fmt"
    "os"
)
func main() {
    scanner := bufio.NewScanner(os.Stdin)
    scanner.Scan()
    s := scanner.Text()
    // 初始化计数器，用于统计字符 '0' 的数量
    c0 := 0
    // 初始化计数器，用于统计字符 '1' 的数量
    c1 := 0
    // 初始化结果变量，初始值为 1（表示原始字符串本身也是一种方案）
    res := 1

    // 遍历字符串 s 中的每一个字符
    for _, ch := range s {
        if ch == '0' {  // 如果当前字符是 '0'
            // 将当前字符与之前所有 '1' 交换，生成新的字符串，方案数增加 c1
            res += c1
            // 更新 '0' 的计数器
            c0++
        } else {  // 如果当前字符是 '1'
            // 将当前字符与之前所有 '0' 交换，生成新的字符串，方案数增加 c0
            res += c0
            // 更新 '1' 的计数器
            c1++
        }
    }

    // 输出最终的方案数
    fmt.Println(res)
}