1).

Recursion is solving a problem through self-definition -- we
achieve this by breaking up a problem into a smaller version
of itself.

Recursive methods often do not have any type of loop

2).

A base case is when a problem can no longer be defined as a
recursive subproblem. It tends to be just a simple mapping.
For example, summing up all of the elements of an array may
have a base case of "if the array is empty, the sum is 0"

A recursive case is the part of a recursive function where we
define the solution using a subproblem of the same type.

A recursive method must have both; without a base case the
function would run forever. Without a recursive case, the
function would not be recursive.

3).

Conceptually, we can expect an array to have some number of
elements. A reasonable base case may be to just return the
largest possible value e.g. (2 ^ 31) - 1 for an `int`

4).

If start index is less than end index, then the minimum value
of an array is the minimum of:

array[start] and min(start + 1, end, array)

5).

mystery1(1)
+-> System.out.print(1)

"1"

mystery1(3)
+-> mystery(3 / 2); // 1
|   +-> System.out.print(1);
+-> System.out.print(", " + n);

"1, 3"

mystery1(17)
+-> mystery1 (17 / 2); // 8
|   +-> mystery1 (8 / 2); // 4
|   |   +-> mystery1 (4 / 2); // 2
|   |   |   +-> mystery1 (2 / 2); // 1
|   |   |   |   +-> System.out.print(1);
|   |   |   +-> System.out.print(", " + 2);
|   |   +-> System.out.print(", " + 4);
|   +-> System.out.print(", " + 8);
+-> System.out.println(", " + 17);

"1, 2, 4, 8, 17"

mystery1(30)
+-> mystery1 (30 / 2); // 15
|   +-> mystery1 (15 / 2); // 7
|   |   +-> mystery1 (7 / 2); // 3
|   |   |   +-> mystery1 (3 / 2); // 1
|   |   |   |   +-> System.out.print(1);
|   |   |   +-> System.out.print(", " + 3);
|   |   +-> System.out.print(", " + 7);
|   +-> System.out.print(", " + 15);
+-> System.out.print(", " + 30);

"1, 3, 7, 15, 30"

6).

If we swapped the order of the "println(line)" and the recursive
call to "reverse(input)", we wouldn't reverse the order at all.
We would print out our current line before processing the rest.
In a way, the modifications would just be a "while" loop in
disguise.

7).

public static void doubleReverse(String s) {

  // a reasonable base case could be:
  // if the string is empty, we should do nothing
  if (s.length() == 0) {
    return;
  }
  // we should doubleReverse the rest of the string
  doubleReverse(s.substring(1));
  // then we should print out the first character twice:
  System.out.print(s.charAt(0));
  System.out.print(s.charAt(0));
}

Alternatively:

public static void doubleReverse(String s) {
  if (s.length() > 1) {
    doubleReverse(s.substring(1));
    System.out.print(s.charAt(0));
    System.out.print(s.charAt(0));
  }
}