Print Numbers from 1 to N
Last Updated: June 7, 2026
Understanding the Problem
Counting from 1 up to a target underlies generating row numbers, filling a range of indices, and producing a sequence to iterate over.
Given a positive integer n, return a list that starts at 1 and ends at n, with every integer in between. If n is 5, the answer is [1, 2, 3, 4, 5]. If n is 1, the answer is just [1].
A plain loop or recursion can do the counting. Both produce the same array.
Key Constraints:
1 <= n <= 1000→nis always at least 1, so you never have to return an empty array. The values stay small, so a plainintholds every element without any overflow concern.- The result is in increasing order → The numbers must run from
1tonfrom left to right. Whatever method you use, the first value added has to be1and the last has to ben.
Approach 1: For Loop
Intuition
Start a counter at 1, add it to the result, then move the counter up by one and repeat. When the counter passes n, every number has been added and the loop ends.
The detail to get right is the loop boundary. The counter has to reach n itself, so the condition is i <= n rather than i < n. Using i < n would stop one number short and leave n out of the result.
Algorithm
- Create an empty list to hold the result.
- Start a counter
iat1. - While
iis less than or equal ton, addito the list and increaseiby one. - Return the filled list.
Example Walkthrough
Input:
The loop starts with i = 1 and adds 1 to the list. It then adds 2, 3, and 4 on the next passes. When i reaches 5, the condition i <= 5 is still true, so 5 is added. After that i becomes 6, the condition fails, and the loop stops. The list now holds every number from 1 to 5:
Code
- Time Complexity: O(n). The loop runs once for each number from 1 to
n, doing constant work each time. - Space Complexity: O(n). The result list grows to hold
nintegers. No other extra storage is used.
The same counting can be expressed through repeated function calls instead of a loop.
Approach 2: Recursion
Intuition
Recursion breaks the problem into one number plus a smaller version of the same task. To list the numbers from 1 to n, first list the numbers from 1 to n - 1, then add n at the end. That smaller list follows the same rule, so it lists 1 to n - 2 first and adds n - 1, and so on.
A helper carries the current value down the chain and appends it as it goes, keeping the numbers in increasing order. The base case stops the chain: once the current value passes n, there is nothing left to add, so the recursion returns.
Algorithm
- Create an empty list to hold the result.
- Define a helper that takes the current value
i. - If
iis greater thann, stop, since every number has been added. - Otherwise add
ito the list, then call the helper withi + 1. - Start the helper at
1and return the filled list.
Example Walkthrough
Input:
The helper starts at i = 1, adds 1, and calls itself with 2. That call adds 2 and calls itself with 3. The next call adds 3 and calls itself with 4. Since 4 is greater than n, that call stops without adding anything, and the chain unwinds. The numbers were added in the order 1, 2, 3, so the result is in increasing order:
Code
- Time Complexity: O(n). The helper makes one call for each number from 1 to
n, doing constant work in each call. - Space Complexity: O(n). The result list holds
nintegers, and the chain of recursive calls adds up tonframes on the call stack at its deepest point.