Complex Number Multiplication

Complex Number Multiplication - Problem

A complex number can be represented as a string on the form "real+imaginaryi" where:

real is the real part and is an integer in the range [-100, 100]
imaginary is the imaginary part and is an integer in the range [-100, 100]
i² == -1

Given two complex numbers num1 and num2 as strings, return a string of the complex number that represents their multiplication.

Input & Output

Example 1 — Basic Multiplication

$ Input: num1 = "1+1i", num2 = "1+1i"

› Output: "0+2i"

💡 Note: Using formula (a+bi)(c+di) = (ac-bd) + (ad+bc)i: (1+1i)(1+1i) = (1×1 - 1×1) + (1×1 + 1×1)i = 0 + 2i

Example 2 — With Negative Components

$ Input: num1 = "1+1i", num2 = "1-1i"

› Output: "2+0i"

💡 Note: (1+1i)(1-1i) = (1×1 - 1×(-1)) + (1×(-1) + 1×1)i = (1+1) + (-1+1)i = 2+0i

Example 3 — Both Parts Negative

$ Input: num1 = "1-1i", num2 = "1-1i"

› Output: "0-2i"

💡 Note: (1-1i)(1-1i) = (1×1 - (-1)×(-1)) + (1×(-1) + (-1)×1)i = (1-1) + (-1-1)i = 0-2i

Constraints

num1 and num2 are valid complex numbers in the form "a+bi" or "a-bi"
a and b are integers in the range [-100, 100]
The output format should match the input format

Visualization

Tap to expand

Asked in

f Facebook 15 G Google 12 a Amazon 8

The key insight is to parse complex numbers into their real and imaginary components, then apply the standard multiplication formula: (a+bi)(c+di) = (ac-bd) + (ad+bc)i. Best approach uses regex for robust parsing. Time: O(n), Space: O(1)

Common Approaches

✓ Parse and Apply Formula

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

Extract real and imaginary parts from both strings, then apply the complex multiplication formula: (a+bi)(c+di) = (ac-bd) + (ad+bc)i. Handle the string parsing carefully to account for positive and negative signs.

Regex-Based Parsing

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

Instead of manual string manipulation, use regex patterns to extract the real and imaginary parts more reliably. This approach handles edge cases like negative numbers more elegantly.

Parse and Apply Formula — Algorithm Steps

Step 1: Parse num1 to extract real part a and imaginary part b
Step 2: Parse num2 to extract real part c and imaginary part d
Step 3: Calculate real part of result: ac - bd
Step 4: Calculate imaginary part of result: ad + bc
Step 5: Format result as "real+imaginaryi"

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Input

Extract real and imaginary parts from both strings

Apply Formula

Use (a+bi)(c+di) = (ac-bd) + (ad+bc)i

Format Result

Combine into final string format

Code -

solution.c — C

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

struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

struct TreeNode* solution(int* preorder, int preorderSize, int* inorder, int inorderSize) {
    if (preorderSize == 0 || inorderSize == 0) return NULL;
    
    struct TreeNode* root = malloc(sizeof(struct TreeNode));
    root->val = preorder[0];
    root->left = NULL;
    root->right = NULL;
    
    int rootIdx = 0;
    for (int i = 0; i < inorderSize; i++) {
        if (inorder[i] == preorder[0]) {
            rootIdx = i;
            break;
        }
    }
    
    root->left = solution(preorder + 1, rootIdx, inorder, rootIdx);
    root->right = solution(preorder + rootIdx + 1, preorderSize - rootIdx - 1, 
                          inorder + rootIdx + 1, inorderSize - rootIdx - 1);
    
    return root;
}

void printTreeArray(struct TreeNode* root) {
    if (!root) {
        printf("[]\n");
        return;
    }
    
    struct TreeNode* queue[1000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    int result[1000];
    int isNull[1000];
    int resultSize = 0;
    
    while (front < rear) {
        struct TreeNode* node = queue[front++];
        if (node) {
            result[resultSize] = node->val;
            isNull[resultSize] = 0;
            resultSize++;
            queue[rear++] = node->left;
            queue[rear++] = node->right;
        } else {
            isNull[resultSize] = 1;
            resultSize++;
        }
    }
    
    // Remove trailing nulls
    while (resultSize > 0 && isNull[resultSize - 1]) {
        resultSize--;
    }
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        if (isNull[i]) {
            printf("null");
        } else {
            printf("%d", result[i]);
        }
        if (i < resultSize - 1) printf(",");
    }
    printf("]\n");
}

int main() {
    char line[1000];
    int preorder[1000], inorder[1000];
    int preorderSize = 0, inorderSize = 0;
    
    // Read preorder
    fgets(line, sizeof(line), stdin);
    char* start = strchr(line, '[');
    char* end = strchr(line, ']');
    if (start && end && start < end) {
        start++;
        *end = '\0';
        if (strlen(start) > 0) {
            char* token = strtok(start, ",");
            while (token) {
                preorder[preorderSize++] = atoi(token);
                token = strtok(NULL, ",");
            }
        }
    }
    
    // Read inorder
    fgets(line, sizeof(line), stdin);
    start = strchr(line, '[');
    end = strchr(line, ']');
    if (start && end && start < end) {
        start++;
        *end = '\0';
        if (strlen(start) > 0) {
            char* token = strtok(start, ",");
            while (token) {
                inorder[inorderSize++] = atoi(token);
                token = strtok(NULL, ",");
            }
        }
    }
    
    struct TreeNode* result = solution(preorder, preorderSize, inorder, inorderSize);
    printTreeArray(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Linear time to parse both input strings where n is total length

✓ Linear Growth

Space Complexity

O(1)

Only storing parsed integer values, no extra data structures

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

856 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Parse and Apply Formula — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler