Smallest String With A Given Numeric Value

Smallest String With A Given Numeric Value - Problem

String Greedy Medium

The numeric value of a lowercase character is defined as its position (1-indexed) in the alphabet, so the numeric value of a is 1, the numeric value of b is 2, the numeric value of c is 3, and so on.

The numeric value of a string consisting of lowercase characters is defined as the sum of its characters' numeric values. For example, the numeric value of the string "abe" is equal to 1 + 2 + 5 = 8.

You are given two integers n and k. Return the lexicographically smallest string with length equal to n and numeric value equal to k.

Note: A string x is lexicographically smaller than string y if x comes before y in dictionary order, that is, either x is a prefix of y, or if i is the first position such that x[i] != y[i], then x[i] comes before y[i] in alphabetic order.

Input & Output

Example 1 — Basic Case

$ Input: n = 3, k = 27

› Output: "aay"

💡 Note: Start with "aaa" (sum=3), need 24 more. Place 'y' (value 25) at position 2: "aay" has sum 1+1+25=27

Example 2 — Multiple Z's

$ Input: n = 5, k = 73

› Output: "aaszz"

💡 Note: Start with "aaaaa" (sum=5), need 68 more. Place two 'z's and one 's': "aaszz" has sum 1+1+19+26+26=73

Example 3 — All A's

$ Input: n = 4, k = 4

› Output: "aaaa"

💡 Note: Sum equals minimum possible (n), so all characters remain 'a'

Constraints

1 ≤ n ≤ 10⁵
n ≤ k ≤ 26 * n

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is to use a greedy approach: start with all 'a's (lexicographically smallest), then fill from right to left with the largest possible letters. Best approach is greedy with Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force - Generate All Combinations

⏱️ Time: O(26ⁿ) Space: O(n)

Try every possible combination of n characters, calculate their numeric sum, and keep track of the lexicographically smallest string that equals k. This involves generating 26^n combinations.

Greedy - Build from Right

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

Initialize string with n 'a's (minimum possible), then iterate from right to left, replacing each 'a' with the largest letter possible while maintaining the target sum k.

Brute Force - Generate All Combinations — Algorithm Steps

Generate all possible strings of length n
Calculate numeric value for each string
Filter strings with value = k
Return lexicographically smallest

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all possible strings of length n

Filter

Keep only strings with numeric value = k

Select

Return lexicographically smallest

Code -

solution.c — C

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

char* generateStrings(int length, char* current, int remainingSum, char* result) {
    if (length == 0) {
        if (remainingSum == 0) {
            strcpy(result, current);
            return result;
        }
        return NULL;
    }
    
    for (int charVal = 1; charVal <= 26; charVal++) {
        if (charVal <= remainingSum) {
            char ch = 'a' + charVal - 1;
            int len = strlen(current);
            current[len] = ch;
            current[len + 1] = '\0';
            
            if (generateStrings(length - 1, current, remainingSum - charVal, result)) {
                return result;
            }
            current[len] = '\0';
        }
    }
    return NULL;
}

char* solution(int n, int k) {
    char* result = (char*)malloc(n + 1);
    char* current = (char*)malloc(n + 1);
    current[0] = '\0';
    
    if (generateStrings(n, current, k, result)) {
        free(current);
        return result;
    }
    
    free(current);
    strcpy(result, "");
    return result;
}

int main() {
    int n, k;
    scanf("%d %d", &n, &k);
    char* result = solution(n, k);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(26ⁿ)

Generate all 26^n possible strings of length n

✓ Linear Growth

Space Complexity

O(n)

Space to store the current string being generated

⚡ Linearithmic Space

28.4K 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 - Generate All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler