如何在Java中获得所有具有重复项的组合（递归）？

我需要找到一种方法从这样的组合中删除重复项：

输入：3和2，其中3是范围（从1到3），2是每个组合的长度

输出：

{1,1}{1,2}{1,3}{2,2}{2,3,1}{3,2}{3,3}

预期输出：

{1,1}{1,2}{1,3}{2,2}{2,3}{3,3}

所以我们从

{1,1}->{1,2}->{1,3}->

开始，但是

{2,1}

是

{1,2}

的重复，所以我们忽略它，以此类推

这是我的密码：

import java.util.Scanner;

public class Main {
    private static int[] result;
    private static int n;

    private static void printArray() {
        String str = "( ";
        for (int number : result) {
            str += number + " ";
        }
        System.out.print(str + ") ");
    }

    private static void gen(int index) {
        if (index == result.length) {
            printArray();
            return;
        }
        for (int i = 1; i <= n; i++) {
            result[index] = i;
            gen(index + 1);
        }
    }

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.print("From 1 to: ");
        n = input.nextInt();
        System.out.print("Length: ");
        int k = input.nextInt();

        result = new int[k];

        gen(0);
    }
}

import java.util.Scanner；
公共班机{
私有静态int[]结果；
私有静态int n；
私有静态void printary（）{
字符串str=“（”；
for（整数：结果）{
str+=number+“”；
}
系统输出打印（str+”）；
}
专用静态void gen（int索引）{
如果（索引==结果长度）{
printArray（）；
返回；
}
对于（int i=1；i您可以将最后使用的最大值传递到
gen
：

private static void gen(int index, int minI) {
    if (index == result.length) {
        printArray();
        return;
    }
    for (int i = minI; i <= n; i++) {
        result[index] = i;
        gen(index + 1, i);
    }
}

private static void gen（int index，int minI）{
如果（索引==结果长度）{
printArray（）；
返回；
}
对于（int i=minI；i您可以将最后使用的最大值传递到
gen
：

private static void gen(int index, int minI) {
    if (index == result.length) {
        printArray();
        return;
    }
    for (int i = minI; i <= n; i++) {
        result[index] = i;
        gen(index + 1, i);
    }
}

private static void gen（int index，int minI）{
如果（索引==结果长度）{
printArray（）；
返回；
}
对于（inti=minI；i），您要查找的是单词组合学意义上的组合。很多代码已经存在，为什么不为每个条目创建一个散列呢？散列函数应该处理像{1,2}和{2,1}这样的情况您还将克服搜索重复项的困难，因为哈希函数将确保它将重复项打印或存储在某处。您可以将此{1,2}项映射到一个POJO，您的哈希函数应获取一个POJO并返回哈希，同时告知重复项（使用匹配2个OBJ的静态函数）Hash可以是字符串连接或add函数，因为u只能有1、2、3作为输入，所以不会出现{1,4}和{2,3}的情况获得相等。你要寻找的是单词组合学意义上的组合。很多代码已经存在，为什么不为每个条目创建一个散列呢？散列函数应该处理像{1,2}和{2,1}这样的情况您还将克服搜索重复项的困难，因为哈希函数将确保它将重复项打印或存储在某处。您可以将此{1,2}项映射到一个POJO，您的哈希函数应获取一个POJO并返回哈希，同时告知重复项（使用匹配2个OBJ的静态函数）散列可以是字符串连接或add函数，因为u只能有1、2、3作为输入，所以不会出现{1、4}和{2、3}相等的情况。