Print Numbers 1 to N and N to 1 (Recursive)
Last Updated: June 7, 2026
Understanding the Problem
The task asks for two runs joined together. First count up, 1, 2, ..., n, then count back down, n, ..., 2, 1. For n = 3 that produces [1, 2, 3, 3, 2, 1], where the value n appears twice in the middle, once as the end of the ascending run and once as the start of the descending run.
The exercise turns on the timing of work inside a recursive call. Work written before the call happens on the way down, while the argument is still increasing. Work written after the call happens on the way back up, as the calls unwind in reverse. Recording the current value in both places produces the ascending run and then the descending run from one function.
Key Constraints:
nis at least1, so both runs always contain at least one element. The smallest case,n = 1, returns[1, 1].- The recursion descends one value at a time and stops once the value passes
n, so it always terminates. - Each value is recorded exactly twice, once going down and once coming up, which is why the array length is
2 x n.
Approach 1: Recursion
Intuition
A helper function carries the current value i, starting at 1. Before it recurses, it records i, then calls itself with i + 1. After that call returns, it records i again. The first record builds the ascending half because values increase as the calls go deeper. The second builds the descending half because the calls return in reverse order, from the deepest value back to 1.
The base case is reaching a value greater than n. The function returns without recording anything, which is the turning point where the ascending run ends and the descending run begins.
Algorithm
- Create an empty list and define a helper that takes the current value
i. - If
iis greater thann, return without recording. This is the base case. - Record
i(the ascending half), then call the helper withi + 1. - After that call returns, record
iagain (the descending half). - Start the helper at
1and return the filled list.
Example Walkthrough
Input:
The helper starts at i = 1. It records 1, then calls i = 2, which records 2 and calls i = 3, which records 3 and calls i = 4. Since 4 is greater than n, that call returns at once without recording. The list so far is [1, 2, 3], the ascending run. Now the calls unwind. Back in i = 3, the line after the recursive call records 3, giving [1, 2, 3, 3]. Back in i = 2, it records 2, giving [1, 2, 3, 3, 2]. Back in i = 1, it records 1, giving [1, 2, 3, 3, 2, 1]. The values before the call built the climb, and the values after the call built the descent.
Code
- Time Complexity: O(n). There is one call per value from
1ton, and each call records two values in constant time. - Space Complexity: O(n). The result holds
2 x nvalues, and the call stack holds up tonpending frames at its deepest point.
Approach 2: Iterative Two Loops
Intuition
Without recursion, the two runs are just two loops. The first loop counts up from 1 to n and appends each value. The second loop counts down from n to 1 and appends each value. Joining them gives the same array. This makes the two halves explicit instead of relying on the order in which recursive calls execute and unwind.
Algorithm
- Create an empty list.
- For each
ifrom1up ton, appendi. This is the ascending run. - For each
ifromndown to1, appendi. This is the descending run. - Return the list.
Example Walkthrough
Input:
The first loop appends 1, 2, and 3, leaving the list as [1, 2, 3]. The second loop appends 3, 2, and 1, extending it to [1, 2, 3, 3, 2, 1]. The result is identical to the recursive version, with the up-loop matching the work done before the recursive call and the down-loop matching the work done after it.
Code
- Time Complexity: O(n). The two loops together run
2 x ntimes, doing constant work per step. - Space Complexity: O(n). The result holds
2 x nvalues, with no recursion to grow the stack.