目录

题目

思路和解题方法

c++ 代码

Java 版本

Python 版本

---

题目

思路和解题方法

c++ 代码

#include <iostream>
#include <vector>
#include <string>
#include <cstring>
#include <sstream>

using namespace std;

class Main {
public:
    static const int N = 2e5 + 10; // 定义一个常量N，用于可能的大数组大小
    int a[N]; // 一个整型数组，但在这个代码片段中并未使用到
    bool state[10][7] = { ... }; // 初始化一个布尔型二维数组，表示0-9每个数字在七段数码管上对应的点亮状态，共7段

    // 解决问题的函数
    void solve() {
        long long res = 1; // 初始化结果为1，用于累积计数
        for (int i = 1; i <= 18; i++) { // 处理18组七段码输入
            string next; // 用于存储当前输入的七段码字符串
            getline(cin, next); // 读取一行输入
            int cnt = 0; // 计数器，记录当前输入匹配的数字个数
            for (int j = 0; j <= 9; j++) { // 遍历0-9每一个数字
                int k;
                for (k = 0; k < next.length(); k++) { // 比较七段码
                    if (next[k] == '1' && !state[j][k]) { // 如果输入为1但对应数字的该段不应亮，则不匹配
                        break;
                    }
                }
                if (k == next.length()) { // 如果所有段都匹配上了
                    cnt++; // 匹配的数字计数增加
                }
            }
            res = res * cnt; // 更新累积结果，表示所有可能组合的数量
        }
        cout << res << endl; // 输出所有可能的组合数
    }

    // 主函数入口，尽管通常命名为main而非Main::main
    void main() {
        int t = 1; // 假设进行一次测试
        for (int zu = 1; zu <= t; zu++) { // 循环执行测试次数
            solve(); // 调用solve函数处理问题
        }
    }
};

int main() {
    Main program; // 实例化Main类
    program.main(); // 调用类中的main函数开始执行
    return 0; // 程序正常结束
}

Java 版本

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

public class Main {
    // 定义静态变量zu、n、m、k（其中n、m、k未在本代码中使用）
    static int zu;
    static int n, m, k;

    public static void main(String[] args) {
        int t = 1; // 测试用例数量
        for (zu = 1; zu <= t; zu++) solve(); // 对于每一个测试用例，调用solve方法
        out.flush(); // 输出最终结果
    }

    // 状态矩阵，表示每个数字（0-9）在7段数码管上的显示状态
    static boolean state[][] = {
            // ... 省略数组内容 ...
    };

    // 数字对应的7段码字符串数组
    static String a[] = {
            // ... 省略数组内容 ...
    };

    // 解决问题的核心方法
    static void solve() {
        long res = 1; // 初始化结果为1，用于累乘
        for (int i = 1; i <= 18; i++) { // 遍历所有可能的7段码组合
            String next = a[i]; // 获取当前组合的7段码字符串
            int cnt = 0; // 计数器，记录能显示的数字个数
            for (int j = 0; j <= 9; j++) { // 遍历0-9数字
                int k;
                for (k = 0; k < next.length(); k++) { // 检查当前数字能否由当前7段码显示
                    if (next.charAt(k) == '1' && !state[j][k]) break; // 如果7段码应亮但数字对应段不亮，则跳出
                }
                if (k == next.length()) cnt++; // 所有需要的段都亮起，则计数器加一
            }
            res = res * cnt; // 累乘结果
        }
        System.out.println(res); // 输出最终结果
    }

    // 快速读取输入的工具类
    static FastReader in = new FastReader();
    static PrintWriter out = new PrintWriter(System.out);

    // 快速读取类
    static class FastReader {
        static BufferedReader br;
        static StringTokenizer st;

        FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return st.nextToken();
        }

        // 辅助方法，用于读取不同类型的输入
        int nextInt() { return Integer.parseInt(next()); }
        double nextDouble() { return Double.parseDouble(next()); }
        long nextLong() { return Long.parseLong(next()); }
    }
}

Python 版本

# 初始化变量
zu = 0  # 可能用于记录测试用例的序号，但在当前循环中未变更，默认为0
n, m = 0, 0  # 这两个变量未在后续代码中使用，似乎是预留变量
k = 0  # 用于循环中的临时计数器

# 定义状态矩阵，表示0-9这10个数字在7段显示器上各段的点亮情况
# 状态矩阵的每一行对应一个数字，每一列对应显示器的一段，True表示该段应点亮，False表示不点亮
state = [
    [True, True, True, True, True, True, False],  # 数字0的段码
    [False, True, True, False, False, False, False],  # 数字1的段码
    # ... 其他数字的段码依此类推
    [True, True, True, True, False, True, True]  # 数字9的段码
]

# 定义可能的数字显示字符串列表，每个字符串代表某种显示状态下各段的点亮情况
# '1' 表示该段点亮，'0' 表示熄灭
a = [
    "",  # 空字符串，可能用于占位或特殊处理
    "0000011",  # 字符串代表的段码
    # ... 其他字符串代表的段码依此类推
    "1101010"  # 最后一个字符串的段码
]

# 解决函数，计算所有给定显示字符串能表示的合法数字组合数量
def solve():
    global zu, n, m, k  # 引入全局变量
    
    # 初始化结果为1，用于累乘计算所有可能的组合数
    res = 1
    # 遍历除空字符串外的所有可能显示字符串
    for i in range(1, 19):
        next_str = a[i]  # 当前考虑的显示字符串
        cnt = 0  # 初始化计数器，记录与当前字符串匹配的数字数量
        
        # 针对每个0-9的数字，检查其显示状态是否能与当前字符串匹配
        for j in range(10):
            k = 0  # 重置段计数器
            # 遍历当前字符串的每一位
            while k < len(next_str):
                # 如果字符串指明该段应亮且数字的段码表示该段不应亮，则不匹配
                if next_str[k] == '1' and not state[j][k]:
                    break
                k += 1  # 指向下一段
            # 如果所有需要亮的段都匹配上了
            if k == len(next_str):
                cnt += 1  # 匹配的数字数量加一
        
        # 将当前字符串能匹配的数字数量累乘到总结果中
        res *= cnt
    
    # 输出所有可能的组合数量
    print(res)

# 主程序，即使zu未改变，也执行一次solve函数
t = 1  # 测试用例次数
for zu in range(1, t + 1):  # 即使t为1，也会执行一次循环
    solve()  # 调用解决函数

觉得有用的话可以点点赞，支持一下。

如果愿意的话关注一下。会对你有更多的帮助。

每天都会不定时更新哦  >人<  。