Печать последовательности чисел через рекурсию

Question

Я хочу напечатать следующую последовательность чисел 0 1 2 3 4 5 4 3 2 1 0, используя рекурсию

То, что я до сих пор пробовал, дает следующую последовательность 0 1 2 3 4 5. Чего я не могу понять, так это как распечатать оставшуюся последовательность.

Как мне добиться желаемого результата?

Код

class Main {
  public static void foo(int num) {
    if (num == 0) {
      System.out.print(num + " ");
      return;
    }

    foo(num - 1);

    System.out.print(num + " ");
  }

  public static void main(String[] args) {
    Main.foo(5);
  }
}

Answer 1

НЕТ необходимости использовать iteration номер

     public static void print(int num) {
        if (num >= 5) {
            System.out.print(num + " ");
            return;
        }
        System.out.print(num + " ");
        print(num + 1);
        System.out.print(num + " ");
    }

    public static void main(String[] args) {
        print(0);
    }

, вывод

0 1 2 3 4 5 4 3 2 1 0

Answer 2

Вот возможный способ сделать это. Во многих случаях с рекурсией вы можете обнаружить, что введение «вспомогательного» метода, который вызывает исходный метод, может помочь вам достичь того, чего вы хотите, когда оригинал с одним аргументом num может затруднить:

public class Main
{
    public static void foo(int num) {
        helper(num, 0);
    }

    private static void helper(int num, int count) {
        if (count == num) {
            System.out.print(count + " ");
        } else {
            System.out.print(count + " ");
            helper(num, count + 1);
            System.out.print(count + " ");
        }
    }

    public static void main(String[] args) {
        Main.foo(5);
    }
}

Answer 3

Чтобы ответить только на ваш вопрос, вы можете сделать это следующим образом.

Назовите его

foo(0);

И метод

public static void foo(int a) {
         if (a > 5) {
             return;
         } 
         prints 0 thru 5 ascending    
         System.out.println(a);
         // once 5 is printed, don't print it again)
         if (a == 5) {
             return;
         }
         // bump a by 1
         foo(a+1);
         // A the calls to foo return the older versions of
         // the variable `a` reappear from the stack.  But 5
         // was skipped.  So it's just
         //printing 4 thru 0 descending
         System.out.println(a);
    }

Answer 4

Одним из решений может быть следующее:

public class Main {
       public static void main (String[] args) {
          Main.foo(5, 5);
      }

      public static void foo(int num, int th) {
        if (num == 0) {
          System.out.print(num + " ");
          return;
        }
        if ( num == 1) {
          System.out.print(th + " ");
          System.out.print((th - num) + " ");
          return;
        }
        System.out.print(( th - num) + " ");
        foo(num - 1, th);
        System.out.print((th - num) + " ");
    }
  }

Вот ссылка IDEONE https://ideone.com/9U44NX

Answer 5

Не совсем чисто, но выполняет свою работу:

public static void main(String[] args) {
    printPattern(5);
}

public static void printPattern(int stop) {
    printPattern(0, stop, 1, false);
}

public static void printPattern(int n, int stop, int dir, boolean turnedAround) {
    System.out.println(n);

    if (n == stop) {
        if (turnedAround)
            return;

        printPattern(n - dir, 0, -dir, true);
    } else
        printPattern(n + dir, stop, dir, turnedAround);
}

Answer 6

public static void recursion(int lo, int current, int hi){
        if(current != hi){
            System.out.printf("%d ", current);
            recursion(lo, current+1, hi);
        }
        System.out.printf("%d%c", current, current == lo ? '\n' : ' ');
    }

Этот метод может распечатать строку чисел, как у вас. Требуется начальная точка (lo), текущая позиция в списке (текущая) и максимальное число (hi).

Рекурсивный базовый случай (когда мы больше не хотим использовать рекурсию) - это когда current == hi. Распечатаем номер, потом возвращаемся.

Все остальные значения печатают текущий, рекурсивный, а затем печатают снова после завершения рекурсии.

Это решение имеет дополнительное преимущество - печатать пробел после каждого символа, кроме последнего номера. Без пробела:)

Первоначальный вызов этого метода будет выглядеть следующим образом:

recursion(0, 0, 5); //prints 0 -> 5 -> 0
recursion(0, 5, 5); //prints 5 -> 0
recursion(0, 1, 5); //prints 1 -> 5 -> 0
recursion(0, 6, 5); //counts up forever and eventually crashes

Некоторый полезный метод, упрощающий вызов для общих целей, можно сделать примерно так:

public static void countUpFromZeroDownToZero(int max){
    recursion(0, 0, max);
}

public static void countFromXToYToX(int lo, int hi){
    recursion(lo, lo, hi);
}