Collatz Sequence - Problem

The Collatz sequence (also known as the 3n+1 problem) is a mathematical sequence defined by the following rules:

Starting with any positive integer n:

If n is even, divide it by 2
If n is odd, multiply by 3 and add 1
Repeat until you reach 1

Given a positive integer, generate and return the complete Collatz sequence as an array of integers, including the starting number and ending with 1.

Input & Output

Example 1 — Starting with 13

$ Input: n = 13

› Output: [13, 40, 20, 10, 5, 16, 8, 4, 2, 1]

💡 Note: 13 is odd → 3×13+1=40, 40 is even → 40÷2=20, 20→10→5 (odd)→16→8→4→2→1

Example 2 — Starting with 6

$ Input: n = 6

› Output: [6, 3, 10, 5, 16, 8, 4, 2, 1]

💡 Note: 6→3 (odd)→10→5→16→8→4→2→1, taking 9 steps total

Example 3 — Edge Case with 1

$ Input: n = 1

› Output: [1]

💡 Note: Starting with 1 immediately satisfies the stopping condition

Constraints

1 ≤ n ≤ 10⁶
The sequence will always eventually reach 1 (Collatz conjecture)

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The Collatz sequence follows simple rules: divide even numbers by 2, multiply odd numbers by 3 and add 1. The iterative approach is optimal since we must calculate each step in sequence. Time: O(k), Space: O(k) where k is the unpredictable sequence length.

Common Approaches

✓ Iterative Simulation

⏱️ Time: O(k) Space: O(k)

Follow the Collatz sequence rules iteratively: if the current number is even, divide by 2; if odd, multiply by 3 and add 1. Continue until reaching 1, storing each step in an array.

Optimized Implementation

⏱️ Time: O(k) Space: O(k)

Uses the same iterative approach but with optimized integer operations and pre-allocated array capacity to reduce memory reallocations during sequence generation.

Iterative Simulation — Algorithm Steps

Initialize result array with starting number
While current number is not 1, apply Collatz rules
Add each new number to result array
Return complete sequence

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with n=13, add to sequence

Apply Rules

13 is odd → 3×13+1=40, then 40→20→10→5→16→8→4→2→1

Result

Complete sequence: [13,40,20,10,5,16,8,4,2,1]

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int* solution(int n, int* returnSize) {
    int* sequence = malloc(1000 * sizeof(int));
    int size = 0;
    sequence[size++] = n;
    int current = n;
    
    while (current != 1) {
        if (current % 2 == 0) {
            current = current / 2;
        } else {
            current = current * 3 + 1;
        }
        sequence[size++] = current;
    }
    
    *returnSize = size;
    return sequence;
}

int main() {
    int n;
    scanf("%d", &n);
    
    int returnSize;
    int* result = solution(n, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k)

Where k is the length of the Collatz sequence, which varies unpredictably

✓ Linear Growth

Space Complexity

O(k)

Array stores all k numbers in the sequence

✓ Linear Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Collatz Sequence - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Iterative Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler