Shortest and Lexicographically Smallest Beautiful String

Shortest and Lexicographically Smallest Beautiful String - Problem

Find the Shortest Beautiful Substring

You're given a binary string s containing only '0's and '1's, and a positive integer k. Your task is to find a special substring called a "beautiful substring".

A substring is beautiful if it contains exactly k ones ('1's). Among all beautiful substrings, you need to:
1. Find the minimum length of any beautiful substring
2. Among all beautiful substrings with this minimum length, return the lexicographically smallest one

If no beautiful substring exists, return an empty string.

Example: For s = "100110" and k = 2, the beautiful substrings are "10011", "00110", "0011", "011". The shortest length is 3, and "011" is lexicographically smallest among length-3 beautiful substrings.

Input & Output

example_1.py — Basic Case

$ Input: s = "100110", k = 2

› Output: "11"

💡 Note: Beautiful substrings with exactly 2 ones: "1001" (length 4), "0011" (length 4), "11" (length 2). The shortest length is 2, and "11" is the only substring of length 2.

example_2.py — Multiple Same Length

$ Input: s = "1011", k = 2

› Output: "01"

💡 Note: Beautiful substrings: "10" (length 2), "01" (length 2), "11" (length 2), "101" (length 3), "011" (length 3), "1011" (length 4). Among length-2 substrings, "01" is lexicographically smallest.

example_3.py — No Solution

$ Input: s = "000", k = 1

› Output: ""

💡 Note: The string contains no 1's, so no beautiful substring with exactly 1 one can be formed.

Constraints

1 ≤ s.length ≤ 100
1 ≤ k ≤ s.length
s consists only of '0' and '1'
The number of 1's in s is at least k for a solution to exist

Visualization

Tap to expand

Understanding the Visualization

Identify Pearl Positions

Mark all positions containing pearls (1's) in the binary string

Start Collection

Begin collecting from each pearl position, extending the net until you have k pearls

Measure and Compare

For each valid collection, measure its length and lexicographic value

Select the Best

Choose the shortest collection, and if tied, the lexicographically smallest

Key Takeaway

🎯 Key Insight: By starting our search only from positions containing '1' and using a sliding window approach, we efficiently find the shortest beautiful substring while ensuring lexicographic minimality.

Asked in

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

The optimal approach uses a sliding window technique with an optimization: only start windows from positions containing '1' since starting with '0' would never be lexicographically smaller. This reduces time complexity to O(n²) while ensuring we find the shortest and lexicographically smallest beautiful substring efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Sliding Window	O(n²)	O(n)	Use sliding window technique to find beautiful substrings efficiently

Optimized Sliding Window — Algorithm Steps

Use two pointers (left and right) to maintain a sliding window
Expand the right pointer and count ones until we have k ones
When we have k ones, try to shrink from left while keeping k ones
For each valid window, compare with current best result
Continue until we've processed the entire string

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from first '1'

Begin only from positions with '1' for lexicographic advantage

Expand window

Extend right boundary until we have k ones

Record beautiful substring

When count reaches k, compare with current best

Move to next position

Continue from next '1' position

Code -

solution.c — C

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

char result[1001];

char* shortestBeautifulSubstring(char* s, int k) {
    int n = strlen(s);
    int minLen = INT_MAX;
    result[0] = '\0';
    
    // Try each starting position
    for (int i = 0; i < n; i++) {
        if (s[i] == '0') continue; // Skip starting with 0
        
        int onesCount = 0;
        // Expand window from position i
        for (int j = i; j < n; j++) {
            if (s[j] == '1') {
                onesCount++;
            }
            
            // Found a beautiful substring
            if (onesCount == k) {
                int currentLen = j - i + 1;
                char currentSubstring[1001];
                strncpy(currentSubstring, s + i, currentLen);
                currentSubstring[currentLen] = '\0';
                
                // Update result if better
                if (currentLen < minLen || 
                    (currentLen == minLen && strcmp(currentSubstring, result) < 0)) {
                    minLen = currentLen;
                    strcpy(result, currentSubstring);
                }
                break;
            }
        }
    }
    
    return result;
}

int main() {
    char s[1001];
    int k;
    scanf("%s %d", s, &k);
    printf("%s\n", shortestBeautifulSubstring(s, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we might check O(n) starting positions, each taking O(n) time

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing the result string

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~18 min Avg. Time

856 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

Optimized Sliding Window — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler