Kth Distinct String in an Array - Practice Coding Problems

Kth Distinct String in an Array - Problem

Imagine you're organizing a library catalog where you need to find the kth unique book title that appears exactly once in your collection.

A distinct string is a string that appears exactly once in an array. Given an array of strings arr and an integer k, your task is to return the kth distinct string present in the array, maintaining the original order of appearance.

Key Points:

Strings are considered in the order they appear in the array
Only count strings that appear exactly once
If there are fewer than k distinct strings, return an empty string ""

Example: In ["apple", "banana", "apple", "cherry", "date"], the distinct strings are ["banana", "cherry", "date"] in that order.

Input & Output

example_1.py — Basic Case

$ Input: arr = ["d","b","c","b","c","a"], k = 2

› Output: "a"

💡 Note: The distinct strings are "d" and "a". "d" appears first (1st distinct), and "a" appears second (2nd distinct), so we return "a".

example_2.py — Not Enough Distinct

$ Input: arr = ["aaa","aa","a"], k = 1

› Output: "aaa"

💡 Note: All strings are distinct (each appears exactly once), so the 1st distinct string is "aaa".

example_3.py — No Distinct Strings

$ Input: arr = ["a","b","a"], k = 3

› Output: ""

💡 Note: Only "b" is distinct (appears once), but we need the 3rd distinct string. Since there's only 1 distinct string, return empty string.

Constraints

1 ≤ arr.length ≤ 1000
1 ≤ k ≤ arr.length
1 ≤ arr[i].length ≤ 5
arr[i] consists of lowercase English letters only

Visualization

Tap to expand

Understanding the Visualization

Catalog All Books

Walk through shelf and create a catalog noting how many copies of each title exist

Identify Unique Titles

Go through shelf again, marking titles that appear exactly once

Find Kth Unique

Count unique titles in order until reaching the kth one

Key Takeaway

🎯 Key Insight: We need to count frequencies first because a string's uniqueness depends on its total occurrences across the entire array.

Asked in

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

The optimal approach uses a two-pass hash table solution: first pass builds a frequency map of all strings, second pass iterates through the array to find the kth string with frequency 1. Time complexity is O(n) and space complexity is O(n). The key insight is that we must count all frequencies before identifying distinct elements.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	For each string, scan the entire array to count its occurrences
Two-Pass Hash Table	O(n)	O(n)	First pass counts frequencies, second pass finds kth distinct string

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each string in the array
For each string, count its total occurrences by scanning the entire array
If the count is exactly 1, increment the distinct counter
When distinct counter equals k, return the current string
If we finish without finding k distinct strings, return empty string

Visualization

Tap to expand

Step-by-Step Walkthrough

Check first string

Scan entire array counting occurrences of first string

Check second string

Scan entire array counting occurrences of second string

Continue until kth distinct

Repeat process until we find the kth string that appears exactly once

Code -

solution.c — C

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

char* kthDistinct(char** arr, int arrSize, int k) {
    int distinctCount = 0;
    
    for (int i = 0; i < arrSize; i++) {
        // Count occurrences of current string
        int count = 0;
        for (int j = 0; j < arrSize; j++) {
            if (strcmp(arr[j], arr[i]) == 0) {
                count++;
            }
        }
        
        // If string appears exactly once
        if (count == 1) {
            distinctCount++;
            if (distinctCount == k) {
                char* result = malloc(strlen(arr[i]) + 1);
                strcpy(result, arr[i]);
                return result;
            }
        }
    }
    
    char* empty = malloc(1);
    empty[0] = '\0';
    return empty;
}

int main() {
    char* arr[] = {"a", "b", "a"};
    int k = 1;
    printf("%s\n", kthDistinct(arr, 3, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n elements, we scan all n elements to count occurrences

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for counting, no additional data structures

✓ Linear Space

18.6K Views

Medium Frequency

~15 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 (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler