Find the Integer Added to Array II

Find the Integer Added to Array II - Problem

You are given two integer arrays nums1 and nums2. From nums1, two elements have been removed, and all other elements have been increased (or decreased) by an integer x.

As a result, nums1 becomes equal to nums2. Two arrays are considered equal when they contain the same integers with the same frequencies.

Return the minimum possible integer x that achieves this equivalence.

Input & Output

Example 1 — Basic Case

$ Input: nums1 = [4,6,4,1,2], nums2 = [5,3,1]

› Output: -1

💡 Note: Remove elements 4 and 2 from nums1 to get [6,4,1]. Then add x = -1 to each element: [6-1, 4-1, 1-1] = [5,3,0]. Wait, let me recalculate. Remove 4 and 6: [4,1,2]. Add x=1: [5,2,3]. Actually, remove the first 4 and the 2: [6,4,1]. Add x=-1: [5,3,0]. Let me try remove 6 and 2: [4,4,1]. This needs to match [5,3,1], so x=1 gives [5,5,2]. Remove 4 and 1: [4,6,2], add x=-1 gives [3,5,1]. Remove elements at indices that make [6,4,1] → add x=-1 → [5,3,0]. Actually remove elements 4,6 to get remaining [4,1,2] which with x=1 becomes [5,2,3]. The answer should be calculated by trying different removal combinations.

Example 2 — Remove Different Elements

$ Input: nums1 = [3,5,1,3], nums2 = [2,4]

› Output: -1

💡 Note: Remove 2 elements from [3,5,1,3] to get an array of size 2. Remove 3 and 1: remaining [5,3], add x=-1: [4,2]. Sort both: [2,4] = [2,4] ✓

Example 3 — Minimum Removal

$ Input: nums1 = [1,2], nums2 = []

› Output: 0

💡 Note: Remove both elements from nums1 to get empty array, which matches empty nums2. No transformation needed, so x = 0

Constraints

3 ≤ nums1.length ≤ 200
nums1.length - 2 = nums2.length
-1000 ≤ nums1[i], nums2[i] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that after sorting both arrays, we only need to try three strategic removal combinations: removing the first two elements, the first and last elements, or the last two elements from nums1. This reduces the problem from O(n³) brute force to O(n log n) optimal solution. Best approach is Three-Case Enumeration. Time: O(n log n), Space: O(1)

Common Approaches

✓ Brute Force - Try All Combinations

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

Generate all possible combinations of removing 2 elements from nums1, then for each combination, try to find if there exists an x that makes the remaining elements equal to nums2.

Sort First Optimization

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

After sorting both arrays, we observe that we only need to try removing 0, 1, or 2 elements from the beginning of nums1 to match nums2. This reduces our search space significantly.

Three-Case Enumeration

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

Since we need to remove exactly 2 elements and find minimum x, we only need to consider three strategic removal combinations from the sorted array. This gives us the optimal solution in O(n log n) time.

Brute Force - Try All Combinations — Algorithm Steps

Step 1: Generate all combinations of removing 2 elements from nums1
Step 2: For each combination, calculate potential x values
Step 3: Check if the transformation works and track minimum x

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible ways to remove 2 elements

Calculate X

For each combination, find the required transformation value

Verify & Track Min

Check if transformation works and keep minimum x

Code -

solution.c — C

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

static int nums1[1000], nums2[1000];
static int remaining[1000], transformed[1000], sorted2[1000];

int solution(int nums1Size, int nums2Size) {
    int minX = INT_MAX;
    
    // Try all combinations of removing 2 elements
    for (int i = 0; i < nums1Size; i++) {
        for (int j = i + 1; j < nums1Size; j++) {
            // Create remaining array after removing elements at i and j
            int remainingSize = 0;
            
            for (int k = 0; k < nums1Size; k++) {
                if (k != i && k != j) {
                    remaining[remainingSize++] = nums1[k];
                }
            }
            
            // Check if we can find x to make remaining equal to nums2
            if (remainingSize == nums2Size) {
                if (nums2Size == 0) {
                    if (0 < minX) {
                        minX = 0;
                    }
                } else {
                    // Sort both arrays to find the correct x
                    for (int k = 0; k < remainingSize; k++) {
                        transformed[k] = remaining[k];
                    }
                    for (int k = 0; k < nums2Size; k++) {
                        sorted2[k] = nums2[k];
                    }
                    
                    // Sort remaining array
                    for (int a = 0; a < remainingSize - 1; a++) {
                        for (int b = a + 1; b < remainingSize; b++) {
                            if (transformed[a] > transformed[b]) {
                                int temp = transformed[a];
                                transformed[a] = transformed[b];
                                transformed[b] = temp;
                            }
                        }
                    }
                    
                    // Sort nums2 array
                    for (int a = 0; a < nums2Size - 1; a++) {
                        for (int b = a + 1; b < nums2Size; b++) {
                            if (sorted2[a] > sorted2[b]) {
                                int temp = sorted2[a];
                                sorted2[a] = sorted2[b];
                                sorted2[b] = temp;
                            }
                        }
                    }
                    
                    int x = sorted2[0] - transformed[0];
                    
                    // Transform remaining array with x
                    for (int k = 0; k < remainingSize; k++) {
                        transformed[k] = remaining[k] + x;
                    }
                    
                    // Sort transformed array
                    for (int a = 0; a < remainingSize - 1; a++) {
                        for (int b = a + 1; b < remainingSize; b++) {
                            if (transformed[a] > transformed[b]) {
                                int temp = transformed[a];
                                transformed[a] = transformed[b];
                                transformed[b] = temp;
                            }
                        }
                    }
                    
                    int equal = 1;
                    for (int k = 0; k < remainingSize; k++) {
                        if (transformed[k] != sorted2[k]) {
                            equal = 0;
                            break;
                        }
                    }
                    
                    if (equal && x < minX) {
                        minX = x;
                    }
                }
            }
        }
    }
    
    return minX == INT_MAX ? 0 : minX;
}

int parseArray(const char* str, int* arr) {
    int size = 0;
    const char* p = str;
    
    // Skip to '['
    while (*p && *p != '[') p++;
    if (!*p) return 0;
    p++; // skip '['
    
    // Handle empty array
    while (*p == ' ') p++;
    if (*p == ']') return 0;
    
    // Parse numbers
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        int num = 0;
        int negative = 0;
        if (*p == '-') {
            negative = 1;
            p++;
        }
        
        while (*p >= '0' && *p <= '9') {
            num = num * 10 + (*p - '0');
            p++;
        }
        
        if (negative) num = -num;
        arr[size++] = num;
    }
    
    return size;
}

int main() {
    char line[10000];
    
    fgets(line, sizeof(line), stdin);
    int nums1Size = parseArray(line, nums1);
    
    fgets(line, sizeof(line), stdin);
    int nums2Size = parseArray(line, nums2);
    
    int result = solution(nums1Size, nums2Size);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) combinations to remove 2 elements, O(n) to verify each combination

⚠ Quadratic Growth

Space Complexity

O(n)

Extra space for storing temporary arrays and frequency maps

⚡ Linearithmic Space

8.4K Views

Medium Frequency

~18 min Avg. Time

156 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

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler