Double a Number Represented as a Linked List

Double a Number Represented as a Linked List - Problem

Imagine you have a giant number so large that it can't fit in a regular integer variable - maybe it has hundreds of digits! This number is stored as a linked list, where each node contains a single digit, and the digits are arranged from most significant to least significant (left to right).

Your task is to double this enormous number and return the result as a linked list in the same format. The input is guaranteed to represent a non-negative integer without leading zeros.

Example: If the linked list represents 123, after doubling it should represent 246.

Think of it like using an old-fashioned calculator that can only display one digit at a time, but you need to double a number that's way too big for any calculator!

Input & Output

example_1.py — Basic Doubling

$ Input: head = [1,8,9]

› Output: [3,7,8]

💡 Note: The number 189 doubled is 378. Each digit is stored in a separate node: 1→8→9 becomes 3→7→8

example_2.py — Single Digit

$ Input: head = [9]

› Output: [1,8]

💡 Note: The number 9 doubled is 18. Since the result has two digits, we need two nodes: 9 becomes 1→8

example_3.py — Multiple Carries

$ Input: head = [9,9,9]

› Output: [1,9,9,8]

💡 Note: The number 999 doubled is 1998. Multiple carries propagate: 9×2=18, carry 1; 9×2+1=19, carry 1; 9×2+1=19, carry 1; final carry becomes new head

Constraints

The number of nodes in the list is in the range [1, 10⁴]
0 ≤ Node.val ≤ 9
The input represents a valid number without leading zeros
The linked list represents a non-negative integer

Visualization

Tap to expand

Asked in

a Amazon 45 G Google 32 ⊞ Microsoft 28 f Meta 15

The optimal approach uses a single-pass traversal with carry lookahead. First check if the most significant digit ≥ 5 to determine if a new head is needed. Then traverse once, doubling each digit and using the key insight: if the next digit ≥ 5, it will generate a carry when doubled, so add 1 to the current result. This achieves O(n) time and O(1) space complexity.

Common Approaches

✓ Math

⏱️ Time: N/A Space: N/A

Single Pass with Carry Lookahead (Optimal)

⏱️ Time: O(n) Space: O(1)

The most elegant solution: first check if the most significant digit will generate a carry when doubled. If so, prepend a '1'. Then traverse once, doubling each digit and handling carries from the previous digit.

Stack-Based Digit Processing

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

Push all digits onto a stack to reverse their order, then pop and process each digit from least to most significant, handling carry propagation naturally.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int* solution(int* digits, int size, int* resultSize) {
    if (size == 0) {
        *resultSize = 0;
        return NULL;
    }
    
    int* result = (int*)malloc(sizeof(int) * (size + 1)); // At most one extra digit
    int carry = 0;
    int count = 0;
    
    // Process from right to left
    for (int i = size - 1; i >= 0; i--) {
        int doubled = digits[i] * 2 + carry;
        result[count++] = doubled % 10;
        carry = doubled / 10;
    }
    
    // Add any remaining carry
    while (carry > 0) {
        result[count++] = carry % 10;
        carry /= 10;
    }
    
    // Reverse to get correct order (most significant first)
    for (int i = 0; i < count / 2; i++) {
        int temp = result[i];
        result[i] = result[count - 1 - i];
        result[count - 1 - i] = temp;
    }
    
    *resultSize = count;
    return result;
}

int main() {
    char inputLine[10000];
    fgets(inputLine, sizeof(inputLine), stdin);
    
    // Remove newline
    inputLine[strcspn(inputLine, "\n")] = 0;
    
    // Parse input - handle both array format [1,2,3] and comma format 1,2,3
    char* line = inputLine;
    if (line[0] == '[' && line[strlen(line)-1] == ']') {
        line[strlen(line)-1] = '\0';
        line++;
    }
    
    int digits[10000];
    int size = 0;
    
    if (strlen(line) > 0) {
        char* token = strtok(line, ",");
        while (token != NULL) {
            // Skip whitespace
            while (*token == ' ' || *token == '\t') token++;
            if (*token != '\0') {
                digits[size++] = atoi(token);
            }
            token = strtok(NULL, ",");
        }
    }
    
    int resultSize;
    int* result = solution(digits, size, &resultSize);
    
    if (resultSize == 0) {
        printf("\n");
    } else {
        for (int i = 0; i < resultSize; i++) {
            if (i > 0) printf(",");
            printf("%d", result[i]);
        }
        printf("\n");
        free(result);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

28.4K Views

Medium-High Frequency

~15 min Avg. Time

847 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