Рекурсивная функция в Java - N вложенные циклы с изменением indicies

Question

Рекурсивная функция в Java - N вложенные циклы с изменением indicies

Подобный этому: там какой-либо путь состоит в том, чтобы сделать вложенные циклы n-уровня в Java?

Я хочу создать рекурсивную функцию, которая генерирует вложенные циклы N, где indicies зависят от глубины цикла. Так в основном я хочу сделать это рекурсивно:

// N = 3, so we want three nested loops

for(int i1 = 0; i1 < max; i1++){
    for(int i2 = i1+1; i2 < max; i2++){
        for(int i3 = i2+1; i3 < max; i3++){
            int value1 = getValue(i1);
            int value2 = getValue(i2);
            int value3 = getValue(i3);
            doSomethingWithTheValues( ... );
        }
    }
}

Я посмотрел на ответы в другом вопросе и попытался изменить ответ (oel.neely), но без удачи. Мое предположение - то, что этому только нужна маленькая модификация, но прямо сейчас, я просто смущаю меня!

1

java recursion nested-loops

задан Community 23 May 2017 в 12:13

1 ответ

Другие вопросы по тегам:

java recursion nested-loops

Похожие вопросы:

score 2 · Accepted Answer

Просто, абстрактный класс используется для моделирования наследования, такого как наследование автомобиля от транспортного средства. Как правило, часть реализации или определение класса также наследуются.

Интерфейс используется для моделирования типов, которые могут иметь сходное подмножество поведения, но не являются необходимыми отношениями. Например, я могу иметь интерфейс IValidate, который имеет метод Validate, и это может быть реализовано автомобилем, студентом, учетной записью или и т.д. для проверки данных, которые они держат. Эти типы не могут/не должны действительно моделироваться как отношения

Интерфейс также широко используется в языке, который не поддерживает множественное наследование как обходной путь. Другие применения включают разделение зависимостей и предоставление служб в COM и WCF.

-121--3815132-

Его C #, но он должен быть легко преобразован в Java:

class ImmutableStack<T>
{
    public readonly T Head;
    public readonly ImmutableStack<T> Tail;

    public ImmutableStack(T head, ImmutableStack<T> tail)
    {
        this.Head = head;
        this.Tail = tail;
    }

    public static ImmutableStack<T> Cons(T head, ImmutableStack<T> tail)
    {
        return new ImmutableStack<T>(head, tail);
    }

    public static ImmutableStack<T> Reverse(ImmutableStack<T> s)
    {
        ImmutableStack<T> res = null;
        while (s != null)
        {
            res = Cons(s.Head, res);
            s = s.Tail;
        }
        return res;
    }
}

class Program
{
    static void AwesomeRecursion(int toDepth, int start, int max, ImmutableStack<int> indices)
    {
        if (toDepth < 0)
        {
            throw new ArgumentException("toDepth should be >= 0");
        }
        else if (toDepth == 0)
        {
            Console.Write("indices: ");
            indices = ImmutableStack<int>.Reverse(indices);
            while (indices != null)
            {
                Console.Write("{0}, ", indices.Head);
                indices = indices.Tail;
            }
            Console.WriteLine();
        }
        else
        {
            for (int i = start; i < max; i++)
            {
                AwesomeRecursion(toDepth - 1, i + 1, max, ImmutableStack<int>.Cons(i, indices));
            }
        }
    }


    static void Main(string[] args)
    {
        AwesomeRecursion(4, 1, 10, null);
        Console.WriteLine("Done");
        Console.ReadKey(true);
    }
}

Мы сохраняем индексы в неизменяемом стеке, так как он делает обратное отслеживание намного проще, чем изменяемые стеки или очереди.