Skip to content
Related Articles

Related Articles

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)




My Personal Notes arrow_drop_up
Recommended Articles
Page :