Skip to content
Related Articles

Related Articles

Improve Article

Lexicographically largest string with sum of characters equal to N

  • Last Updated : 06 May, 2021

Given a positive integer N, the task is to find the lexicographically largest string consisting of lower-case English alphabets such that the sum of the characters of the string equals N where ‘a’ = 1, ‘b’ = 2, ‘c’ = 3, ….. , and ‘z’ = 26.

Examples:

Input: N = 30
Output: zd
Explanation:
The lexicographically largest string formed is “zd” whose sum of position of characters is (26 + 4) = 30(= N).

Input: N = 14
Output: n

Approach: To make lexicographically the largest string, the idea is to print the character z, N/26 number of times and then the character at (N%26 + 1)th position in the English alphabets. Follow the steps below to solve the problem:



  • Initialize a string, say ans, that stores the required lexicographically largest string.
  • Iterate until N is at least 26 and perform the following steps:
    • Add the character z to the string ans.
    • Decrement the value of N by 26.
  • Add the value of char(N + ‘a’) to the string ans.
  • After completing the above steps, print the value of ans as the resultant string.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to construct the
// lexicographically largest string
// having sum of characters as N
string getString(int N)
{
   
    // Stores the resulting string
    string ans = "";
 
    // Iterate until N is at least 26
    while (N >= 26) {
 
        // Append 'z' to the string ans
        ans += 'z';
 
        // Decrement N by 26
        N -= 26;
    }
 
    // Append character at index (N + 'a')
    ans += char(N + 'a' - 1);
 
    // Return the resultant string
    return ans;
}
 
// Driver Code
int main()
{
    int N = 30;
    cout << getString(N);
 
    return 0;
}

Java




// java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
 
public class GFG {
 
    // Function to construct the
    // lexicographically largest string
    // having sum of characters as N
    static String getString(int N)
    {
 
        // Stores the resulting string
        String ans = "";
 
        // Iterate until N is at least 26
        while (N >= 26) {
 
            // Append 'z' to the string ans
            ans += 'z';
 
            // Decrement N by 26
            N -= 26;
        }
 
        // Append character at index (N + 'a')
        ans += (char)(N + 'a' - 1);
 
        // Return the resultant string
        return ans;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
 
        int N = 30;
        System.out.print(getString(N));
    }
}
 
// This code is contributed by Kingash.

Python3




# Python3 program for the above approach
 
# Function to construct the
# lexicographically largest string
# having sum of characters as N
def getString(N):
   
    # Stores the resulting string
    ans = ""
 
    # Iterate until N is at least 26
    while (N >= 26):
 
        # Append 'z' to the string ans
        ans += 'z'
 
        # Decrement N by 26
        N -= 26
 
    # Append  character at index (N + 'a')
    ans += chr(N + ord('a') - 1)
 
    # Return the resultant string
    return ans
 
# Driver Code
if __name__ == '__main__':
    N = 30
    print(getString(N))
 
# This code is contributed by mohit kumar 29.

C#




// C# program for the above approach
using System;
 
public class GFG {
 
    // Function to construct the
    // lexicographically largest string
    // having sum of characters as N
    static string getString(int N)
    {
 
        // Stores the resulting string
        string ans = "";
 
        // Iterate until N is at least 26
        while (N >= 26) {
 
            // Append 'z' to the string ans
            ans += 'z';
 
            // Decrement N by 26
            N -= 26;
        }
 
        // Append character at index (N + 'a')
        ans += (char)(N + 'a' - 1);
 
        // Return the resultant string
        return ans;
    }
 
    // Driver Code
    public static void Main(string[] args)
    {
 
        int N = 30;
        Console.WriteLine(getString(N));
    }
}
 
// This code is contributed by ukasp.

Javascript




<script>
    // Javascript program for the above approach
 
// Function to construct the
// lexicographically largest string
// having sum of characters as N
function getString(N){
 
    // Stores the resulting string
    let ans = ""
 
    // Iterate until N is at least 26
    while (N >= 26){
 
        // Append 'z' to the string ans
        ans += 'z'
 
        // Decrement N by 26
        N -= 26
    }
    // Append character at index (N + 'a')
    ans += String.fromCharCode(N + 'a'.charCodeAt(0) - 1)
 
    // Return the resultant string
    return ans
}
 
// Driver Code
    let N = 30
    document.write(getString(N))
 
// This code is contributed by Saurabh Jaiswal
</script>
Output: 
zd

 

Time Complexity: O(N)
Auxiliary Space: O(N)

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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :