(D卷,200分)- 数字排列（Java & JS & Python & C)

题目描述
小明负责公司年会，想出一个趣味游戏：

屏幕给出 1 ~ 9 中任意 4 个不重复的数字，大家以最快时间给出这几个数字可拼成的数字从小到大排列位于第 N 位置的数字，其中 N 为给出数字中最大的（如果不到这么多数字则给出最后一个即可）。

注意：

2 可以当作 5 来使用，5 也可以当作 2 来使用进行数字拼接，且屏幕不能同时给出 2 和 5；
6 可以当作 9 来使用，9 也可以当作 6 来使用进行数字拼接，且屏幕不能同时给出 6 和 9。
如给出：1，4，8，7，则可以拼接的数字为：

1，4，7，8，14，17，18，41，47，48，71，74，78，81，84，87，147，148，178 … (省略后面的数字)

那么第 N （即8）个的数字为 41。

输入描述
输入以逗号分隔的 4 个 int 类型整数的字符串。

输出描述
输出为这几个数字可拼成的数字从小大大排列位于第 N （N为输入数字中最大的数字）位置的数字，

如果输入的数字不在范围内或者有重复，则输出-1。

题目解析
这个问题要求我们从给定的四个数字中生成所有可能的组合，并按照从小到大的顺序排序，然后返回第 N 个数字（N 是给定数字中的最大值）。需要注意以下几点：

输入的有效性：

输入必须是 1 到 9 之间的四个不重复的整数。
如果输入包含 2 和 5、或 6 和 9，必须只保留其中一个。
数字拼接：

可用数字 2 和 5 互换，6 和 9 互换，因此在拼接时应考虑这些替换。
从给定的数字中生成所有可能的组合和排列。
输出：

若有效，输出第 N 个数字。如果生成的数字少于 N，则输出最后一个数字；如果输入无效，则输出 -1。
java算法源码

import java.util.*;

public class NumberCombination {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        
        // 解析输入
        String[] parts = input.split(",");
        if (parts.length != 4) {
            System.out.println(-1);
            return;
        }

        Set<Integer> uniqueNumbers = new HashSet<>();
        for (String part : parts) {
            try {
                int num = Integer.parseInt(part.trim());
                if (num < 1 || num > 9 || !uniqueNumbers.add(num)) {
                    System.out.println(-1);
                    return;
                }
            } catch (NumberFormatException e) {
                System.out.println(-1);
                return;
            }
        }

        // 检查是否同时存在 2 和 5 或 6 和 9
        if ((uniqueNumbers.contains(2) && uniqueNumbers.contains(5)) ||
            (uniqueNumbers.contains(6) && uniqueNumbers.contains(9))) {
            System.out.println(-1);
            return;
        }

        // 获取 N 的值
        int N = Collections.max(uniqueNumbers);
        
        // 生成可拼接的数字
        List<Integer> results = new ArrayList<>();
        generateCombinations(new ArrayList<>(uniqueNumbers), "", results);

        // 排序并获取第 N 个元素
        Collections.sort(results);
        if (N > results.size()) {
            System.out.println(results.get(results.size() - 1));
        } else {
            System.out.println(results.get(N - 1));
        }
    }

    private static void generateCombinations(List<Integer> numbers, String current, List<Integer> results) {
        if (!current.isEmpty()) {
            results.add(Integer.parseInt(current));
        }

        for (int i = 0; i < numbers.size(); i++) {
            List<Integer> remaining = new ArrayList<>(numbers);
            remaining.remove(i);
            generateCombinations(remaining, current + numbers.get(i), results);
        }
    }
}

javascript算法源码

function generateCombinations(numbers, current, results) {
    if (current) {
        results.push(parseInt(current));
    }

    for (let i = 0; i < numbers.length; i++) {
        let remaining = numbers.slice();
        remaining.splice(i, 1);
        generateCombinations(remaining, current + numbers[i], results);
    }
}

function getNthNumber(input) {
    let parts = input.split(',').map(part => part.trim());
    if (parts.length !== 4) return -1;

    let uniqueNumbers = new Set();
    for (let part of parts) {
        let num = parseInt(part);
        if (num < 1 || num > 9 || uniqueNumbers.has(num)) return -1;
        uniqueNumbers.add(num);
    }

    if ((uniqueNumbers.has(2) && uniqueNumbers.has(5)) ||
        (uniqueNumbers.has(6) && uniqueNumbers.has(9))) return -1;

    let numbers = Array.from(uniqueNumbers);
    let N = Math.max(...numbers);

    let results = [];
    generateCombinations(numbers, "", results);
    
    results.sort((a, b) => a - b);
    
    if (N > results.length) {
        return results[results.length - 1];
    } else {
        return results[N - 1];
    }
}

// Example usage
let input = "1, 4, 8, 7";
console.log(getNthNumber(input)); // Outputs the result

python算法源码

from itertools import permutations

def generate_combinations(numbers):
    results = set()
    for length in range(1, len(numbers) + 1):
        for combo in permutations(numbers, length):
            results.add(int(''.join(map(str, combo))))
    return sorted(results)

def get_nth_number(input_str):
    parts = [int(x.strip()) for x in input_str.split(',')]
    
    if len(parts) != 4:
        return -1
    
    unique_numbers = set(parts)
    if len(unique_numbers) != 4:
        return -1
    
    if (2 in unique_numbers and 5 in unique_numbers) or (6 in unique_numbers and 9 in unique_numbers):
        return -1

    numbers = list(unique_numbers)
    N = max(numbers)
    
    results = generate_combinations(numbers)
    
    if N > len(results):
        return results[-1]
    else:
        return results[N - 1]

# Example usage
input_str = "1, 4, 8, 7"
print(get_nth_number(input_str))  # Outputs the result

C算法源码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_DIGITS 4
#define MAX_RESULTS 10000

void generate_combinations(int *numbers, int size, int *results, int *result_count, int current, int depth) {
    if (depth > 0) {
        results[(*result_count)++] = current;
    }

    for (int i = 0; i < size; i++) {
        int new_depth = depth + 1;
        int new_current = current * 10 + numbers[i];
        generate_combinations(numbers, size, results, result_count, new_current, new_depth);
    }
}

int cmpfunc(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int get_nth_number(char *input) {
    int numbers[MAX_DIGITS];
    int count = 0;
    int num;
    char *token = strtok(input, ",");
    
    while (token != NULL) {
        if (sscanf(token, "%d", &num) != 1 || num < 1 || num > 9) {
            return -1;
        }
        numbers[count++] = num;
        token = strtok(NULL, ",");
    }
    
    if (count != 4) return -1;

    // Check for duplicate numbers
    for (int i = 0; i < count; i++) {
        for (int j = i + 1; j < count; j++) {
            if (numbers[i] == numbers[j]) return -1;
        }
    }
    
    // Check for forbidden pairs
    int contains2 = 0, contains5 = 0, contains6 = 0, contains9 = 0;
    for (int i = 0; i < count; i++) {
        if (numbers[i] == 2) contains2 = 1;
        if (numbers[i] == 5) contains5 = 1;
        if (numbers[i] == 6) contains6 = 1;
        if (numbers[i] == 9) contains9 = 1;
    }
    if ((contains2 && contains5) || (contains6 && contains9)) return -1;

    int results[MAX_RESULTS];
    int result_count = 0;
    generate_combinations(numbers, count, results, &result_count, 0, 0);

    qsort(results, result_count, sizeof(int), cmpfunc);

    int N = 0;
    for (int i = 0; i < count; i++) {
        if (numbers[i] > N) N = numbers[i];
    }

    if (N > result_count) {
        return results[result_count - 1];
    } else {
        return results[N - 1];
    }
}

// Example usage
int main() {
    char input[] = "1, 4, 8, 7";
    int result = get_nth_number(input);
    printf("%d\n", result);  // Outputs the result
    return 0;
}