Faulty Sensor - Practice Coding Problems

Faulty Sensor - Problem

You're working as a quality assurance engineer for a high-tech laboratory where two identical sensors are used to collect critical experimental data simultaneously for redundancy and accuracy verification.

Each sensor produces an array of data points: sensor1[i] and sensor2[i] represent the i-th measurement from each sensor. However, these sensors have a known manufacturing defect that causes exactly one data point to be dropped during transmission.

When a data point is dropped:

All subsequent data points shift left by one position
The last position gets filled with a random value (guaranteed to be different from the dropped value)
For example: [1,2,3,4,5] with dropped value 3 becomes [1,2,4,5,7]

Your task: Determine which sensor (1 or 2) has the defect, or return -1 if it's impossible to determine or if both sensors are working correctly.

Input & Output

example_1.py — Basic Case

$ Input: sensor1 = [2,3,4,5], sensor2 = [2,1,3,4]

› Output: 1

💡 Note: Sensor1 is faulty. If we remove the first element (2) from sensor1, we get [3,4,5]. But sensor2 without the last element is [2,1,3]. These don't match. However, if we consider that sensor1 dropped element 1 that should have been at position 1, sensor1 becomes [2,1,4,5] which matches sensor2's first 3 elements [2,1,3]. Wait, let me reconsider... Actually, if sensor1 dropped the value that should be at position 1, sensor1 originally was [2,1,3,4,5], and after dropping 1, it became [2,3,4,5]. Sensor2 shows [2,1,3,4], so sensor1 is missing the 1.

example_2.py — Sensor2 Faulty

$ Input: sensor1 = [2,1,3,4], sensor2 = [2,3,4,5]

› Output: 2

💡 Note: Sensor2 is faulty. The original data should be [2,1,3,4,5]. Sensor2 dropped the element 1, causing [2,3,4,5] with the last element being a random value 5.

example_3.py — No Defect Detectable

$ Input: sensor1 = [1,2,3], sensor2 = [1,2,3]

› Output: -1

💡 Note: Both sensors show identical readings, so either both are working correctly or the defect cannot be determined from the given data.

Constraints

1 ≤ sensor1.length, sensor2.length ≤ 10⁵
1 ≤ sensor1[i], sensor2[i] ≤ 10⁹
sensor1.length == sensor2.length
At most one sensor has exactly one missing data point

Visualization

Tap to expand

Understanding the Visualization

Synchronize Playback

Start comparing both recordings frame by frame from the beginning

Detect Anomaly

Stop when you find the first frame that doesn't match between cameras

Test Hypotheses

Check if skipping one frame from either camera resolves all remaining differences

Key Takeaway

🎯 Key Insight: Once we find where the recordings diverge, we only need to test if one camera missed a single frame at that exact point

Asked in

G Google 28 a Amazon 22 f Meta 18 ⊞ Microsoft 15

The optimal solution uses a two-pointer approach to efficiently detect faulty sensors in O(n) time. First, compare elements until finding the first mismatch. Then test two scenarios: whether sensor1 or sensor2 dropped an element at that position. This elegant approach avoids the O(n²) brute force method by leveraging the key insight that only the first mismatch point matters for determining which sensor is faulty.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Positions)	O(n²)	O(n)	Test every possible drop position for both sensors
Two Pointers (Optimal)	O(n)	O(1)	Compare arrays with two pointers, test drop scenarios when mismatch found

Brute Force (Try All Positions) — Algorithm Steps

For each position i in sensor1, create a new array with element i removed
Check if this modified sensor1 matches sensor2
If match found, sensor1 is faulty
Repeat the same process for sensor2
If no matches found, return -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Test Position 0

Remove first element from sensor1, compare with sensor2

Test Position 1

Remove second element from sensor1, compare with sensor2

Continue Testing

Test each position until a match is found or all positions tried

Code -

solution.c — C

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

bool compareWithRemoved(int* arr, int n, int removeIndex, int* target, int targetLen) {
    int j = 0;
    for (int i = 0; i < n; i++) {
        if (i == removeIndex) continue;
        if (j >= targetLen || arr[i] != target[j]) return false;
        j++;
    }
    return j == targetLen;
}

int faultySensor(int* sensor1, int* sensor2, int n) {
    // Check if sensor1 is faulty
    for (int i = 0; i < n; i++) {
        if (compareWithRemoved(sensor1, n, i, sensor2, n-1)) {
            return 1;
        }
    }
    
    // Check if sensor2 is faulty
    for (int i = 0; i < n; i++) {
        if (compareWithRemoved(sensor2, n, i, sensor1, n-1)) {
            return 2;
        }
    }
    
    return -1;
}

int main() {
    int sensor1[1000], sensor2[1000];
    int n = 0;
    char line[10000];
    
    fgets(line, sizeof(line), stdin);
    char* token = strtok(line, " ");
    while (token != NULL) {
        sensor1[n++] = atoi(token);
        token = strtok(NULL, " ");
    }
    
    int m = 0;
    fgets(line, sizeof(line), stdin);
    token = strtok(line, " ");
    while (token != NULL) {
        sensor2[m++] = atoi(token);
        token = strtok(NULL, " ");
    }
    
    printf("%d\n", faultySensor(sensor1, sensor2, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the n positions, we create and compare arrays of size n

⚠ Quadratic Growth

Space Complexity

O(n)

Space needed to create temporary arrays for comparison

⚡ Linearithmic Space

42.3K Views

Medium Frequency

~15 min Avg. Time

1.5K 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 Positions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler