Global and Local Inversions - Practice Coding Problems

Global and Local Inversions - Problem

Array Math Medium

You are given an integer array nums of length n which represents a permutation of all integers in the range [0, n-1].

Understanding inversions:

Global inversion: A pair of indices (i, j) where 0 ≤ i < j < n and nums[i] > nums[j]
Local inversion: An index i where 0 ≤ i < n-1 and nums[i] > nums[i+1]

Your task is to determine if the number of global inversions equals the number of local inversions.

Key insight: Every local inversion is also a global inversion! The question becomes: are there any global inversions that are NOT local inversions?

Return true if global inversions equal local inversions, false otherwise.

Input & Output

example_1.py — Basic Case

$ Input: [1, 0, 2]

› Output: true

💡 Note: Global inversions: (0,1) since 1 > 0. Local inversions: (0,1) since nums[0] > nums[1]. Count: 1 = 1, so return true. Also note: |1-0|=1, |0-1|=1, |2-2|=0, all ≤ 1.

example_2.py — False Case

$ Input: [1, 2, 0]

› Output: false

💡 Note: Global inversions: (0,2) and (1,2) since 1>0 and 2>0, total=2. Local inversions: (1,2) since 2>0, total=1. Since 2 ≠ 1, return false. Also note: |0-2|=2 > 1.

example_3.py — Already Sorted

$ Input: [0, 1, 2, 3]

› Output: true

💡 Note: Already sorted array has 0 global inversions and 0 local inversions. 0 = 0, so return true. All elements are exactly in their ideal positions.

Visualization

Tap to expand

Understanding the Visualization

Identify the Problem

We need to check if global inversions (any two elements out of order) equal local inversions (adjacent elements out of order)

Key Mathematical Insight

Every local inversion is automatically a global inversion. So they're equal only if there are no 'far apart' global inversions

Position-Based Check

Check if each element nums[i] is within 1 position of its ideal location i. If |nums[i] - i| ≤ 1 for all i, then global equals local

Efficient Solution

Single pass through array checking position differences gives O(n) solution instead of O(n²) counting

Key Takeaway

🎯 Key Insight: Since every local inversion is automatically a global inversion, they're equal only when there are no "far apart" global inversions - which happens precisely when each element is at most 1 position away from its ideal sorted location.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We check all pairs (i,j) where i < j, which gives us n(n-1)/2 comparisons

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for counters

✓ Linear Space

Constraints

n == nums.length
1 ≤ n ≤ 10⁵
0 ≤ nums[i] < n
nums is a permutation of [0, 1, 2, ..., n - 1]

Asked in

G Google 25 f Facebook 18 a Amazon 15 ⊞ Microsoft 12

The optimal solution uses the key mathematical insight that global inversions equal local inversions if and only if each element is at most 1 position away from its ideal sorted position. This reduces the problem from O(n²) counting to a simple O(n) position check: abs(nums[i] - i) ≤ 1 for all i.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Count Both Types)	O(n²)	O(1)	Count global and local inversions separately and compare
Optimal Mathematical Insight	O(n)	O(1)	Check if any element is more than 1 position away from its ideal position

Brute Force (Count Both Types) — Algorithm Steps

Initialize counters for global and local inversions
For each pair (i,j) where i < j, if nums[i] > nums[j], increment global counter
For each adjacent pair (i, i+1), if nums[i] > nums[i+1], increment local counter
Return true if both counters are equal

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Global Inversions

Check all pairs (i,j) where i < j

Count Local Inversions

Check all adjacent pairs

Compare Counts

Return true if counts are equal

Code -

solution.c — C

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

bool isIdealPermutation(int* nums, int n) {
    int globalInversions = 0;
    int localInversions = 0;
    
    // Count global inversions
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (nums[i] > nums[j]) {
                globalInversions++;
            }
        }
    }
    
    // Count local inversions
    for (int i = 0; i < n - 1; i++) {
        if (nums[i] > nums[i + 1]) {
            localInversions++;
        }
    }
    
    return globalInversions == localInversions;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int nums[100];
    int n = 0;
    char* token = strtok(input, "[],\n");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%s\n", isIdealPermutation(nums, n) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We check all pairs (i,j) where i < j, which gives us n(n-1)/2 comparisons

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for counters

✓ Linear Space

Constraints

n == nums.length
1 ≤ n ≤ 10⁵
0 ≤ nums[i] < n
nums is a permutation of [0, 1, 2, ..., n - 1]

27.2K Views

Medium Frequency

~15 min Avg. Time

1.2K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Count Both Types) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler