String lexicográficamente más grande con suma de caracteres igual a N

Dado un número entero positivo N , la tarea es encontrar la string lexicográficamente más grande que consiste en alfabetos ingleses en minúsculas tal que la suma de los caracteres de la string sea igual a N donde ‘a’ = 1 , ‘b’ = 2 , ‘c’ = 3 , ….. , y ‘z’ = 26 .

Ejemplos:

Entrada: N = 30
Salida: zd
Explicación:
La string formada lexicográficamente más grande es “zd” cuya suma de posición de caracteres es (26 + 4) = 30(= N).

Entrada: N = 14
Salida: n

Enfoque: Para hacer lexicográficamente la string más grande, la idea es imprimir el carácter z , N/26 número de veces y luego el carácter en (N%26 + 1) ^th posición en los alfabetos ingleses. Siga los pasos a continuación para resolver el problema:

• Inicialice una string , digamos ans , que almacene la string lexicográficamente más grande requerida.
• Iterar hasta que N sea al menos 26 y realizar los siguientes pasos:
  • Agregue el carácter z a la string ans .
  • Disminuya el valor de N en 26 .
• Agregue el valor de char(N + ‘a’) a la string ans .
• Después de completar los pasos anteriores, imprima el valor de ans como la string resultante.

// 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 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 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# 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.

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

zd

Complejidad temporal: O(N)
Espacio auxiliar: O(N)