Sum of Natural Numbers in Python: 3 Methods Explained

The sum of the first n natural numbers has three implementations in Python, each with a different time complexity and a different lesson about the language.

What Are Natural Numbers?

Natural numbers are the positive integers used for counting: 1, 2, 3, 4, 5, and so on. The smallest natural number is 1. Some textbooks count from 0, but for this problem (and most placement coding questions), the sequence starts at 1.

The problem statement is straightforward:

• Input: a positive integer n.
• Output: the sum 1 + 2 + 3 + … + n.
• Worked example: if n = 5, the output is 15.

This is one of the first programs in almost every placement-prep list of basic Python programs. It tests whether a candidate understands loops, recursion, and (if the interviewer presses) mathematical optimisation.

The Gauss Formula: O(1) Approach

There is a mathematical shortcut that skips the loop entirely. The sum of 1 through n equals n multiplied by (n+1), then divided by 2. The Python implementation is one line:

def sum_gauss(n):
    return n * (n + 1) // 2

# Verify the classic result
print(sum_gauss(100))  # 5050
print(sum_gauss(10))   # 55
print(sum_gauss(5))    # 15

Verify: for n = 100, the formula gives 100 * 101 // 2 = 5050. For n = 10, it gives 55. These match the expected values.

The formula runs in O(1) time. It performs one multiplication, one addition, and one floor division, regardless of how large n is. A loop that iterates from 1 to n runs in O(n) time. For large n, the formula returns in constant time while the loop must iterate through every integer from 1 to n.

In placement coding rounds at Tier-2 and Tier-3 colleges across India, the interviewer’s standard follow-up after a loop solution is: “Can you do it in constant time?” The Gauss formula is the answer. Candidates who offer it without being prompted stand out in the shortlisting process.

Method 1: Using sum() with range()

Python’s built-in sum() function accepts any iterable. Pairing it with range(1, n+1) gives the most readable solution:

n = int(input("Enter n: "))
if n < 1:
    print("Enter a positive integer")
else:
    total = sum(range(1, n + 1))
    print(total)

range(1, n+1) generates integers from 1 up to and including n. The stop argument of range is exclusive, so the +1 is necessary to include n itself.

Internally, Python’s sum() iterates the range object in compiled C rather than Python bytecode, which is slightly faster than an equivalent for loop. The time complexity is still O(n) since every number from 1 to n must be visited. But the code is shorter, and shorter code means fewer typos under interview pressure.

This pattern extends naturally to related problems. If you need the sum of an array rather than a sequence from 1 to n, the approach is the same with a list argument; see the sum of array elements in Python article for that variant.

Method 2: Using a While Loop

The while loop version is more explicit. It’s closer to the mental model of “start at 1, keep adding until you reach n”:

n = int(input("Enter n: "))
if n < 1:
    print("Enter a positive integer")
else:
    total = 0
    current = 1
    while current <= n:
        total += current
        current += 1
    print(total)

Step by step for n = 5:

• Start: total = 0, current = 1
• Iteration 1: total = 1, current = 2
• Iteration 2: total = 3, current = 3
• Iteration 3: total = 6, current = 4
• Iteration 4: total = 10, current = 5
• Iteration 5: total = 15, current = 6 (loop exits)

The loop runs in O(n) time. It works for any positive n without hitting language-level limits. The while loop is also the right choice when the condition inside the loop body needs to change mid-run (for example, summing only even numbers up to n), since sum(range(...)) handles that scenario less cleanly.

The same accumulator pattern appears in a calculator program in Python, where you add or subtract based on user input across multiple iterations.

Method 3: Using Recursion

The recursive approach defines the sum in terms of a smaller version of the same problem: the sum of 1 through n is n plus the sum of 1 through (n-1). The base case stops the recursion when n reaches 1:

def recur_sum(n):
    if n <= 1:
        return n
    return n + recur_sum(n - 1)

n = int(input("Enter n: "))
if n < 1:
    print("Enter a positive integer")
else:
    print(recur_sum(n))

For n = 5, the call stack unfolds as:

• recur_sum(5) returns 5 + recur_sum(4)
• recur_sum(4) returns 4 + recur_sum(3)
• recur_sum(3) returns 3 + recur_sum(2)
• recur_sum(2) returns 2 + recur_sum(1)
• recur_sum(1) returns 1 (base case)
• Result: 1 + 2 + 3 + 4 + 5 = 15

The critical limitation: Python’s default recursion limit is 1,000 frames. Calling recur_sum with n above roughly 900 raises RecursionError: maximum recursion depth exceeded. You can raise the limit with sys.setrecursionlimit(), but this is a workaround, not a solution. For any n above a few hundred, use the Gauss formula or a loop.

Recursion is worth learning because it demonstrates elegant problem decomposition. It is, however, the wrong tool for this specific problem at any production scale.

Which Method Should You Use?

Method	Time complexity	Safe for large n	Placement round verdict
Gauss formula	O(1)	Yes	Best: show you know the maths
sum(range(1, n+1))	O(n)	Yes	Good default
While loop	O(n)	Yes	Fine, more verbose
Recursion	O(n)	No (n under ~900)	Risky unless the interviewer asks for it

For most Tier-2 and Tier-3 college placement coding rounds, sum(range(1, n+1)) solves the problem clearly. Adding the Gauss formula as an O(1) alternative, either in the same solution or as a follow-up when pressed, shows awareness of time complexity. That distinction separates candidates in competitive shortlisting rounds where two otherwise identical submissions differ only in their interviewer conversation.

Understanding the recursion depth limit is separately useful. It comes up again in tree traversal and graph DFS implementations, where the same RecursionError can surface on deep data structures.

The three approaches here cover the same ground that shows up in a broader set of loop and arithmetic problems in Python. If you want to take that Python foundation into applied AI work rather than just placement prep, TinkerLLM starts at ₹299. The sum(range(...)) iteration pattern that powers token counting and the recursion intuition behind agent planning both trace back to exactly these fundamentals.