Shortest and Lexicographically Smallest Beautiful String

Shortest and Lexicographically Smallest Beautiful String - Problem

You are given a binary string s and a positive integer k.

A substring of s is beautiful if the number of 1s in it is exactly k.

Let len be the length of the shortest beautiful substring.

Return the lexicographically smallest beautiful substring of string s with length equal to len.

If s doesn't contain a beautiful substring, return an empty string.

A string a is lexicographically larger than a string b (of the same length) if in the first position where a and b differ, a has a character strictly larger than the corresponding character in b.

Input & Output

Example 1 — Basic Case

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

› Output: "11"

💡 Note: The beautiful substrings with exactly 2 ones are: "1001" (length 4), "0011" (length 4), "0110" (length 4), and "11" (length 2). The shortest length is 2, so return "11".

Example 2 — No Beautiful Substring

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

› Output: ""

💡 Note: The string contains only zeros, so no substring can have exactly 1 one. Return empty string.

Example 3 — Multiple Same Length

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

› Output: "1"

💡 Note: Beautiful substrings with k=1: "1" at position 1 (length 1), "1" at position 3 (length 1), "01" at positions 0-1 (length 2), "10" at positions 1-2 (length 2), "01" at positions 2-3 (length 2). Shortest length is 1, so return "1".

Constraints

1 ≤ s.length ≤ 100
1 ≤ k ≤ s.length
s consists only of '0' and '1'.

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8 A Apple 6

The key insight is to use a sliding window approach in two passes: first find the minimum length of beautiful substrings, then find the lexicographically smallest among those with minimum length. Best approach uses sliding window with Time: O(n²), Space: O(n).

Common Approaches

✓ Brute Force - Check All Substrings

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

Generate all possible substrings, count 1s in each, and among those with exactly k ones, find the shortest and lexicographically smallest.

Sliding Window Optimization

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

First pass finds the minimum length of beautiful substrings, then second pass finds the lexicographically smallest among those with minimum length.

Brute Force - Check All Substrings — Algorithm Steps

Generate all possible substrings
Count 1s in each substring
Track shortest length with k ones
Among shortest, find lexicographically smallest

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Check all possible starting and ending positions

Count Ones

Count 1s in each substring

Track Best

Keep shortest and lexicographically smallest

Code -

solution.c — C

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

char* solution(char* s, int k) {
    int n = strlen(s);
    int minLen = INT_MAX;
    char* result = (char*)malloc(1000 * sizeof(char));
    result[0] = '\0';
    
    for (int i = 0; i < n; i++) {
        int ones = 0;
        for (int j = i; j < n; j++) {
            if (s[j] == '1') {
                ones++;
            }
            
            if (ones == k) {
                int currentLen = j - i + 1;
                char* substring = (char*)malloc((currentLen + 1) * sizeof(char));
                strncpy(substring, s + i, currentLen);
                substring[currentLen] = '\0';
                
                if (currentLen < minLen || (currentLen == minLen && strcmp(substring, result) < 0)) {
                    minLen = currentLen;
                    strcpy(result, substring);
                }
                free(substring);
                break;
            } else if (ones > k) {
                break;
            }
        }
    }
    
    return result;
}

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    int k;
    scanf("%d", &k);
    
    char* result = solution(s, k);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: start position × end position × character counting

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables to track best result

✓ Linear Space

23.4K Views

Medium Frequency

~18 min Avg. Time

890 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 - Check All Substrings — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler