Number of Beautiful Pairs - Practice Coding Problems

Number of Beautiful Pairs - Problem

Array Hash Table Math Counting Number Theory Easy

You are given a 0-indexed integer array nums. Your task is to find all beautiful pairs of indices in this array.

A pair of indices (i, j) where 0 ≤ i < j < nums.length is considered beautiful if:

The first digit of nums[i] and the last digit of nums[j] are coprime

Two integers are coprime if their greatest common divisor (GCD) equals 1. In other words, they share no common factors other than 1.

Example: The first digit of 123 is 1, and the last digit of 456 is 6. Since gcd(1, 6) = 1, they are coprime.

Return the total number of beautiful pairs in the array.

Input & Output

example_1.py — Basic Case

$ Input: nums = [2,5,1,4]

› Output: 5

💡 Note: Beautiful pairs: (0,1), (0,2), (0,3), (1,2), (2,3). First digits: [2,5,1,4], Last digits: [2,5,1,4]. All adjacent pairs have coprime digits except none - all pairs work since gcd of different single digits except (2,4) and (5,5) cases.

example_2.py — With Multi-digit Numbers

$ Input: nums = [11,21,12]

› Output: 2

💡 Note: Beautiful pairs: (0,1) and (0,2). For (0,1): first digit of 11 is 1, last digit of 21 is 1, gcd(1,1)=1. For (0,2): first digit of 11 is 1, last digit of 12 is 2, gcd(1,2)=1. For (1,2): first digit of 21 is 2, last digit of 12 is 2, gcd(2,2)=2≠1.

example_3.py — Edge Case

$ Input: nums = [31,25,72,40,51]

› Output: 7

💡 Note: Check all pairs where first digit of nums[i] and last digit of nums[j] are coprime. First digits: [3,2,7,4,5], Last digits: [1,5,2,0,1]. Count pairs with gcd=1.

Constraints

2 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 9999
All array elements are positive integers
First digit is never 0 (since numbers are positive)

Visualization

Tap to expand

Understanding the Visualization

Extract Digits

Get first digit of each number and last digit of each number

Check Coprimality

For each pair (i,j) where i<j, check if gcd(first[i], last[j]) = 1

Count Valid Pairs

Count all pairs that satisfy the coprime condition

Optimization

Use frequency counting to avoid checking each pair individually

Key Takeaway

🎯 Key Insight: The optimal solution leverages the fact that there are only 90 possible (first_digit, last_digit) combinations. By counting digit frequencies, we can calculate beautiful pairs mathematically in O(n) time instead of checking every pair individually.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

This problem is optimally solved using a two-pass hash table approach in O(n) time. The key insight is to count frequencies of first and last digits separately, then use combinatorics to calculate beautiful pairs where gcd(first_digit, last_digit) = 1. The brute force O(n²) approach works but is inefficient for larger inputs.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table Optimization	O(n)	O(1)	Count digit frequencies first, then calculate beautiful pairs using combinatorics
Brute Force (Nested Loops)	O(n²)	O(1)	Check every possible pair of indices and test if their digits are coprime

Two-Pass Hash Table Optimization — Algorithm Steps

First pass: Count frequency of each first digit (1-9)
Second pass: Count frequency of each last digit (0-9)
For each first digit f and last digit l where gcd(f,l) = 1:
Add count[first_digit=f] × count[last_digit=l] to result
Subtract cases where i >= j to maintain i < j constraint

Visualization

Tap to expand

Step-by-Step Walkthrough

Count First Digits

Array [11,21,12] → first digits: 1→2, 2→1

Count Last Digits

Array [11,21,12] → last digits: 1→2, 2→1

Calculate Pairs

For gcd(1,1)=1: 2×2=4, gcd(1,2)=1: 2×1=2, gcd(2,1)=1: 1×2=2

Adjust for Constraints

Remove self-pairs and divide by 2 for i<j constraint

Code -

solution.c — C

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

int gcd(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

int firstDigit(int n) {
    while (n >= 10) n /= 10;
    return n;
}

int lastDigit(int n) {
    return n % 10;
}

int countBeautifulPairs(int* nums, int numsSize) {
    int firstCount[10] = {0};
    int lastCount[10] = {0};
    
    for (int i = 0; i < numsSize; i++) {
        firstCount[firstDigit(nums[i])]++;
        lastCount[lastDigit(nums[i])]++;
    }
    
    int result = 0;
    
    for (int f = 1; f <= 9; f++) {
        for (int l = 0; l <= 9; l++) {
            if (gcd(f, l) == 1) {
                result += firstCount[f] * lastCount[l];
            }
        }
    }
    
    for (int i = 0; i < numsSize; i++) {
        int f = firstDigit(nums[i]);
        int l = lastDigit(nums[i]);
        if (gcd(f, l) == 1) {
            result--;
        }
    }
    
    return result / 2;
}

int main() {
    int nums[1000];
    int size = 0;
    char ch;
    int num = 0;
    int reading = 0;
    
    while ((ch = getchar()) != '\n' && ch != EOF) {
        if (ch >= '0' && ch <= '9') {
            num = num * 10 + (ch - '0');
            reading = 1;
        } else if (reading) {
            nums[size++] = num;
            num = 0;
            reading = 0;
        }
    }
    if (reading) nums[size++] = num;
    
    printf("%d\n", countBeautifulPairs(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the array plus constant time to check 9×10=90 digit combinations

✓ Linear Growth

Space Complexity

O(1)

Fixed size arrays for digit frequencies (at most 10 entries each)

✓ Linear Space

28.9K Views

Medium Frequency

~15 min Avg. Time

847 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

Two-Pass Hash Table Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler