Smallest String With A Given Numeric Value

Smallest String With A Given Numeric Value - Problem

String Greedy Medium

Imagine you're creating a password system where each letter has a specific weight - 'a' weighs 1, 'b' weighs 2, 'c' weighs 3, and so on up to 'z' which weighs 26.

Your challenge is to create the lexicographically smallest (alphabetically first) string that meets two exact requirements:

It must be exactly n characters long
The total weight of all characters must equal exactly k

Example: If n=3 and k=27, you need a 3-character string with total weight 27. The answer is "aaz" because:

a(1) + a(1) + z(26) = 28... wait, that's too much!
a(1) + a(1) + y(25) = 27 ✓

But wait! We want the smallest lexicographically, so we should put the heaviest letters at the end to keep the beginning as small as possible.

Input & Output

example_1.py — Basic Case

$ Input: n = 3, k = 27

› Output: "aay"

💡 Note: We need 3 characters with sum 27. Start with 'aaa' (sum=3), then we need 24 more. Replace the last 'a' with 'y' (adds 24), giving us 'aay' with sum 1+1+25=27.

example_2.py — Minimum Case

$ Input: n = 5, k = 73

› Output: "aaszz"

💡 Note: Start with 'aaaaa' (sum=5), need 68 more. Work backwards: replace last with 'z' (+25, remaining=43), second-last with 'z' (+25, remaining=18), third-last with 's' (+18, remaining=0).

example_3.py — All Same Characters

$ Input: n = 1, k = 26

› Output: "z"

💡 Note: Single character with maximum value 26 is 'z'.

Constraints

1 ≤ n ≤ 10⁵
n ≤ k ≤ 26 × n
k is always achievable (guaranteed valid input)

Visualization

Tap to expand

Understanding the Visualization

Start with Smallest Coins

Begin with all 1-cent coins (all 'a' characters) - this gives the neatest receipt start

Work from the End

Replace coins from the end of the receipt with larger denominations

Use Largest Possible

At each position, use the largest coin that doesn't exceed remaining amount

Perfect Change

Continue until you have exact change with the neatest possible receipt

Key Takeaway

🎯 Key Insight: To get the lexicographically smallest string, always start with the smallest characters and place larger values as far right as possible!

Asked in

G Google 45 a Amazon 38 f Meta 29 ⊞ Microsoft 22

The optimal solution uses a greedy approach: initialize with all 'a' characters (lexicographically smallest), then work backwards placing the largest possible characters at the end. This ensures the result is lexicographically minimal while meeting the sum requirement in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Construction (Optimal)	O(n)	O(1)	Start with all 'a's, then greedily place largest possible characters from the end
Brute Force (Generate All Combinations)	O(26^n)	O(n)	Generate all possible strings of length n and find the lexicographically smallest one with sum k

Greedy Construction (Optimal) — Algorithm Steps

Initialize result array with n 'a' characters (sum = n)
Calculate remaining value needed: remaining = k - n
Start from the last position and work backwards
For each position, place the largest possible character (up to 'z')
Update remaining value and continue until remaining becomes 0

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with all 'a' characters, calculate remaining sum needed

Work Backwards

From the last position, place the largest possible character

Update Remaining

Subtract the added value and move to next position

Complete

Continue until remaining sum becomes zero

Code -

solution.c — C

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

char* getSmallestString(int n, int k) {
    // Allocate memory for result string
    char* result = (char*)malloc((n + 1) * sizeof(char));
    
    // Start with all 'a's (minimum possible)
    for (int i = 0; i < n; i++) {
        result[i] = 'a';
    }
    result[n] = '\0';
    
    int remaining = k - n; // Extra value we need to add
    
    // Work backwards to place largest characters at the end
    int i = n - 1;
    while (remaining > 0 && i >= 0) {
        // Maximum we can add to current position is 25 (to make it 'z')
        int addValue = remaining < 25 ? remaining : 25;
        // Convert 'a' + addValue to the corresponding character
        result[i] = 'a' + addValue;
        remaining -= addValue;
        i--;
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, doing constant work at each position

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables, output string doesn't count as extra space

✓ Linear Space

67.2K Views

Medium Frequency

~15 min Avg. Time

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

Greedy Construction (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler