Recursive method to print a descending then ascending integer sequence From a programming assignment:




  Write a method writeSequence that accepts an integer n as a
  parameter and prints a symmetric sequence of n numbers with
  descending integers ending in 1 followed by ascending integers
  beginning with 1, as in the table below:

Call                        Output

writeSequence(1);             1
writeSequence(2);            1 1
writeSequence(3);           2 1 2
writeSequence(4);          2 1 1 2
writeSequence(5);         3 2 1 2 3
writeSequence(6);        3 2 1 1 2 3
writeSequence(7);       4 3 2 1 2 3 4
writeSequence(8);      4 3 2 1 1 2 3 4
writeSequence(9);     5 4 3 2 1 2 3 4 5
writeSequence(10);   5 4 3 2 1 1 2 3 4 5

  
  Notice that for odd numbers the sequence has a single 1 in the middle
  while for even values it has two 1s in the middle.
  
  Your method should throw an IllegalArgumentException if passed a
  value less than 1. A client using this method would have to call
  println to complete the line of output.


I wrote code that is pretty ugly, but produces the correct output. I've put this up to see if anyone had a more efficient recursive algorithm and to put the example up. There are not many hits about more complex recursive methods in Java when searching.



public static void writeSequence(int n) {

    if( n &lt; 1 )
        throw new IllegalArgumentException();

    if( n == 1 ) {
        System.out.print("1");

    } else if( n == 2 ) {
        System.out.print("1 1");

    } else if( n % 2 == 0 ){
        System.out.print((n / 2) + " ");
        writeSequence(n - 2);
        System.out.print(" " + (n / 2));

    } else if( n % 2 == 1 ) {
        System.out.print(((n + 1) / 2) + " ");
        writeSequence((n - 2));
        System.out.print(" " + ((n + 1) / 2));
    }       
}
Assuming you can use a helper function, you could do this:

  public static void writeSequence(int n) {
    if (n &lt; 1) throw new IllegalArgumentException();
    writeSequenceHelper(n);
  }

  public static void writeSequenceHelper(int n) {
    if (n &lt;= 0) return;
    int m = (n+1) / 2;
    System.out.print(m + " ");
    writeSequenceHelper(n - 2);
    System.out.print(m + " ");
  }


If you can't use a helper function like this to workaround the strange IllegalArgumentException requirement, you could do this (which is similar to your solution, but a little more succinct):

  public static void writeSequence2(int n) {
    if (n &lt; 1) throw new IllegalArgumentException();
    if (n == 1) {
      System.out.print("1");
    } else if (n == 2) {
      System.out.print("1 1");
    } else {
      int m = (n+1) / 2;
      System.out.print(m + " ");
      writeSequence2(n - 2);
      System.out.print(" " + m);
    }
  }