Find the Integer Added to Array I

Find the Integer Added to Array I - Problem

Array Easy

You are given two arrays of equal length, nums1 and nums2.

Each element in nums1 has been increased (or decreased in the case of negative) by an integer, represented by the variable 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 integer x.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: Each element in nums1 increased by 3: [2+3, 6+3, 3+3] = [5,9,6] = nums2

Example 2 — Negative Adjustment

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

› Output: -5

💡 Note: Each element in nums1 decreased by 5: [10-5, 6-5, 2-5] = [5,1,-3] = nums2

Example 3 — Zero Adjustment

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

› Output: 0

💡 Note: Arrays are already equal, so x = 0: [1+0, 1+0, 1+0, 1+0] = [1,1,1,1]

Constraints

1 ≤ nums1.length == nums2.length ≤ 1000
-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 since all elements are adjusted by the same value x, we can find x by simply calculating the difference between any corresponding pair: x = nums2[i] - nums1[i]. The optimal approach uses direct calculation in O(1) time and O(1) space.

Common Approaches

✓ Brute Force - Try All Possible Values

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

Generate possible x values by checking all differences, then verify each x by adding it to nums1 and comparing with nums2. This approach is inefficient but demonstrates the basic logic.

Direct Calculation

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

Since all elements in nums1 are increased by the same value x, we can find x by subtracting any corresponding pair: x = nums2[i] - nums1[i]. This works because the transformation is uniform across all elements.

Brute Force - Try All Possible Values — Algorithm Steps

Generate all possible x values from element differences
For each x, add it to all elements in nums1
Check if modified nums1 equals nums2

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate X Values

Calculate all possible x from element differences

Test Each X

Add x to nums1 and compare with nums2

Find Match

Return the x that makes arrays equal

Code -

solution.c — C

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

int* parseArray(const char* s, int* size) {
    *size = 0;
    if (strlen(s) <= 2) return NULL;
    
    // Count elements
    for (int i = 1; i < strlen(s) - 1; i++) {
        if (s[i] == ',' || (i == 1)) (*size)++;
    }
    
    int* arr = (int*)malloc(*size * sizeof(int));
    char* str = (char*)malloc(strlen(s));
    strcpy(str, s + 1);
    str[strlen(str) - 1] = '\0';
    
    char* token = strtok(str, ",");
    int i = 0;
    while (token != NULL && i < *size) {
        arr[i++] = atoi(token);
        token = strtok(NULL, ",");
    }
    
    free(str);
    return arr;
}

int arraysEqual(int* arr1, int* arr2, int size) {
    int count1[20001] = {0}; // Range adjustment for negative numbers
    int count2[20001] = {0};
    
    for (int i = 0; i < size; i++) {
        count1[arr1[i] + 10000]++; // Offset for negative numbers
        count2[arr2[i] + 10000]++;
    }
    
    for (int i = 0; i < 20001; i++) {
        if (count1[i] != count2[i]) return 0;
    }
    return 1;
}

int solution(int* nums1, int* nums2, int size) {
    // Try the difference from first pair
    int x = nums2[0] - nums1[0];
    
    int* modifiedNums1 = (int*)malloc(size * sizeof(int));
    for (int i = 0; i < size; i++) {
        modifiedNums1[i] = nums1[i] + x;
    }
    
    int result = x;
    if (!arraysEqual(modifiedNums1, nums2, size)) {
        result = 0;
    }
    
    free(modifiedNums1);
    return result;
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    int size1, size2;
    int* nums1 = parseArray(line1, &size1);
    int* nums2 = parseArray(line2, &size2);
    
    int result = solution(nums1, nums2, size1);
    printf("%d\n", result);
    
    free(nums1);
    free(nums2);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Outer loop tries n possible x values, inner loop verifies each in O(n) time

⚠ Quadratic Growth

Space Complexity

O(n)

Hash set stores up to n possible x values

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~5 min Avg. Time

892 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 Possible Values — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler