Find Smallest Letter Greater Than Target

Find Smallest Letter Greater Than Target - Problem

You are given an array of characters letters that is sorted in non-decreasing order, and a character target. There are at least two different characters in letters.

Return the smallest character in letters that is lexicographically greater than target. If such a character does not exist, return the first character in letters.

Input & Output

Example 1 — Basic Case

$ Input: letters = ["c","f","j"], target = "a"

› Output: c

💡 Note: The smallest character greater than 'a' is 'c'

Example 2 — Target in Middle

$ Input: letters = ["c","f","j"], target = "c"

› Output: f

💡 Note: The smallest character greater than 'c' is 'f'

Example 3 — Wrap Around

$ Input: letters = ["c","f","j"], target = "z"

› Output: c

💡 Note: No character greater than 'z', so return first character 'c'

Constraints

2 ≤ letters.length ≤ 10⁴
letters[i] is a lowercase English letter
letters is sorted in non-decreasing order
letters contains at least two different characters
target is a lowercase English letter

Visualization

Tap to expand

Asked in

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

The key insight is to use binary search on the sorted array to find the leftmost position where a character is greater than target. Best approach is binary search with Time: O(log n), Space: O(1)

Common Approaches

✓ Math

⏱️ Time: N/A Space: N/A

Binary Search

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

Since the array is sorted, we can use binary search to find the smallest character greater than target. We search for the leftmost position where letters[i] > target.

Linear Search

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

Check each character from left to right until we find one that is lexicographically greater than the target. If no such character exists, return the first character.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

char nextGreatestLetter(char* letters, int lettersSize, char target) {
    int left = 0, right = lettersSize - 1;
    
    // If target is greater than or equal to the last character, wrap around
    if (target >= letters[lettersSize - 1]) {
        return letters[0];
    }
    
    // Binary search for the smallest character greater than target
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (letters[mid] > target) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    
    return letters[left];
}

int main() {
    char input[1000];
    char letters[10000];
    int lettersSize = 0;
    char target;
    
    // Read the array line
    fgets(input, sizeof(input), stdin);
    
    // Parse the array manually
    char* ptr = input;
    while (*ptr && *ptr != '[') ptr++; // Find opening bracket
    if (*ptr) ptr++; // Skip opening bracket
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '"') {
            ptr++; // Skip opening quote
            if (*ptr && *ptr != '"') {
                letters[lettersSize++] = *ptr;
                ptr++; // Skip the character
            }
            if (*ptr == '"') ptr++; // Skip closing quote
        } else {
            ptr++;
        }
    }
    
    // Read target character
    fgets(input, sizeof(input), stdin);
    target = input[0]; // First character of the line
    
    char result = nextGreatestLetter(letters, lettersSize, target);
    printf("%c\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

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