Skip to content
Related Articles

Related Articles

Improve Article
Lexicographically smallest string of length N and sum K
  • Difficulty Level : Medium
  • Last Updated : 14 May, 2021

Given two integers N and K. The task is to print the lexicographically smallest string of length N consisting of lower-case English alphabates such that the sum of the characters of the string equals to K where ‘a’ = 1, ‘b’ = 2, ‘c’ = 3, ….. and ‘z’ = 26.
Examples: 
 

Input: N = 5, K = 42 
Output: aaamz 
“aaany”, “babmx”, “aablz” etc. are also valid strings 
but “aaamz” is the lexicographically smallest.
Input: N = 3, K = 25 
Output: aaw 
 

 

Approach: 
 

  • Initialize char array of size N and fill all the element by ‘a’.
  • Start traversing from the end of the array and replace the elements of the array by ‘z’ if K ≥ 26 or replace it by the character having ASCII value (K + 97 – 1).
  • At the same time decrease the value of K by replaced element value i.e. for a = 1, b = 2, c = 3, …, z = 26.
  • Also, note that we are subtracting previous element value i.e. (total ‘a’) before current element and adding the same before the end of for loop.
  • Check for K < 0 condition and break the for loop.
  • Return the new string formed by the elements of the char array as the answer.

Below is the implementation of the above approach: 
 



C++




// C++ implementation of the approach
#include<bits/stdc++.h>
using namespace std;
 
// Function to return the lexicographically
// smallest string of length n that
// satisfies the given condition
string lexo_small(int n, int k)
{
    string arr = "";
 
    for(int i = 0; i < n; i++)
        arr += 'a';
 
    // Iteration from the last position
    // in the array
    for (int i = n - 1; i >= 0; i--)
    {
        k -= i;
 
        // If k is a positive integer
        if (k >= 0)
        {
 
            // 'z' needs to be inserted
            if (k >= 26)
            {
                arr[i] = 'z';
                k -= 26;
            }
 
            // Add the required character
            else
            {
                char c= (char)(k + 97 - 1);
                arr[i] = c;
                k -= arr[i] - 'a' + 1;
            }
        }
 
        else
            break;
 
        k += i;
    }
    return arr;
}
 
// Driver code
int main()
{
    int n = 5, k = 42;
 
    string arr = lexo_small(n, k);
 
    cout << arr;
}
 
// This code is contributed by Mohit Kumar
Java



// Java implementation of the approach
import java.util.Arrays;
 
public class Main {
 
    // Function to return the lexicographically
    // smallest string of length n that
    // satisfies the given condition
    public static char[] lexo_small(int n, int k)
    {
        char arr[] = new char[n];
 
        Arrays.fill(arr, 'a');
 
        // Iteration from the last position
        // in the array
        for (int i = n - 1; i >= 0; i--) {
 
            k -= i;
 
            // If k is a positive integer
            if (k >= 0) {
 
                // 'z' needs to be inserted
                if (k >= 26) {
                    arr[i] = 'z';
                    k -= 26;
                }
 
                // Add the required character
                else {
                    arr[i] = (char)(k + 97 - 1);
                    k -= arr[i] - 'a' + 1;
                }
            }
 
            else
                break;
 
            k += i;
        }
 
        return arr;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int n = 5, k = 42;
 
        char arr[] = lexo_small(n, k);
 
        System.out.print(new String(arr));
    }
}
Python3



# Python implementation of the approach
 
# Function to return the lexicographically
# smallest string of length n that
# satisfies the given condition
def lexo_small(n, k):
 
    arr = "";
 
    for i in range(n):
        arr += 'a';
 
    # Iteration from the last position
    # in the array
    for i in range(n-1,-1,-1):
        k -= i;
 
        # If k is a positive integer
        if (k >= 0):
 
            # 'z' needs to be inserted
            if (k >= 26):
                arr = arr[:i] + 'z' + arr[i+1:];
                k -= 26;
         
            # Add the required character
            else:
                c= (k + 97 - 1);
                arr = arr[:i] + chr(c) + arr[i+1:];
                k -= ord(arr[i]) - ord('a') + 1;
 
        else:
            break;
 
        k += i;
    return arr;
 
# Driver code
if __name__ == '__main__':
    n = 5; k = 42;
 
    arr = lexo_small(n, k);
 
    print(arr);
 
# This code contributed by PrinciRaj1992
C#



// C# implementation of the approach
using System;
 
class GFG
{
 
    // Function to return the lexicographically
    // smallest string of length n that
    // satisfies the given condition
    public static char[] lexo_small(int n, int k)
    {
        char []arr = new char[n];
        int i;
         
        for(i = 0; i < n; i++)
            arr[i] = 'a' ;
 
        // Iteration from the last position
        // in the array
        for (i = n - 1; i >= 0; i--)
        {
            k -= i;
 
            // If k is a positive integer
            if (k >= 0)
            {
 
                // 'z' needs to be inserted
                if (k >= 26)
                {
                    arr[i] = 'z';
                    k -= 26;
                }
 
                // Add the required character
                else
                {
                    arr[i] = (char)(k + 97 - 1);
                    k -= arr[i] - 'a' + 1;
                }
            }
 
            else
                break;
 
            k += i;
        }
        return arr;
    }
 
    // Driver code
    public static void Main()
    {
        int n = 5, k = 42;
 
        char []arr = lexo_small(n, k);
 
        Console.WriteLine(new string(arr));
    }
}
 
// This code is contributed by AnkitRai01
Javascript



<script>
 
// javascript implementation of the approach
 
 
// Function to return the lexicographically
// smallest string of length n that
// satisfies the given condition
function lexo_small(n , k)
{
    var arr = Array.from({length: n}, (_, i) => 'a');
 
    // Iteration from the last position
    // in the array
    for (var i = n - 1; i >= 0; i--) {
 
        k -= i;
 
        // If k is a positive integer
        if (k >= 0) {
 
            // 'z' needs to be inserted
            if (k >= 26) {
                arr[i] = 'z';
                k -= 26;
            }
 
            // Add the required character
            else {
                arr[i] = String.fromCharCode(k + 97 - 1);
                k -= arr[i] - 'a' + 1;
            }
        }
 
        else
            break;
 
        k += i;
    }
 
    return arr;
}
 
// Driver code
var n = 5, k = 42;
 
var arr = lexo_small(n, k);
 
document.write(arr.join(''));
 
// This code contributed by shikhasingrajput
</script>
Output: 
aaamz
 
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.
In case you wish to attend live classes with industry experts, please refer DSA Live Classes



My Personal Notes
arrow_drop_up
Previous
Pointers and References in C++
Next

Reverse the given string in the range [L, R]
Recommended Articles
Page :
Lexicographically smallest permutation of a string that can be reduced to length K by removing K-length prefixes from palindromic substrings of length 2K
11, Nov 20
Lexicographically smallest K-length subsequence from a given string
17, Feb 21
Lexicographically smallest string of maximum length made up of first K alphabets that does not contain any repeating substring
13, May 21
Lexicographically Smallest Permutation of length N such that for exactly K indices, a[i] > a[i] + 1
29, Nov 18
Lexicographically smallest K-length substring containing maximum number of vowels
05, Jun 20
Lexicographically smallest string formed by appending a character from first K characters of a string | Set 2
06, Aug 19
Lexicographically smallest string formed by appending a character from the first K characters of a given string
20, Jul 18
Lexicographically smallest and largest anagrams of a string containing another string as its substring
10, Sep 20
Lexicographically smallest string whose hamming distance from given string is exactly K
17, Oct 17
Lexicographically smallest string possible by performing K operations on a given string
24, Jan 21
Lexicographically smallest permutation of a string that contains all substrings of another string
16, Sep 20
Lexicographically smallest string after M operations
02, Jul 20
Find lexicographically smallest string in at most one swaps
10, Apr 20
K-th lexicographically smallest unique substring of a given string
01, Nov 18
Frequency of lexicographically Kth smallest character in the a string
10, Feb 21
Lexicographically smallest string possible by inserting given character
02, Dec 20
Queries to answer the X-th smallest sub-string lexicographically
30, Apr 19
Lexicographically smallest permutation of a string with given subsequences
26, Sep 18
Lexicographically smallest string which is not a subsequence of given string
17, Jun 21
Lexicographically smallest string obtained after concatenating array
28, Apr 18
Lexicographically smallest string formed by removing at most one character
13, Nov 18
Lexicographically smallest string formed by removing duplicates
03, Nov 20
Swap all occurrences of two characters to get lexicographically smallest string
18, Jul 19
Lexicographically smallest string which differs from given strings at exactly K indices
20, Jun 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Rohan_Kansara
@Rohan_Kansara
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox