# Lexicographically smallest string possible by performing K operations on a given string

• Difficulty Level : Medium
• Last Updated : 22 Apr, 2021

Given a string S of size N and a positive integer K, the task is to perform atmost K operations on string S to make it lexicographically smallest possible. In one operation, swap S[i] and S[j] and then change S[i] to any character, given 1 â‰¤ i < j â‰¤ N.

Examples:

Input: S = “geek”, K = 5
Output: aaaa
Explanation:
In 1st operation: take i = 1 and j = 4, swap S[1] and S[4] and then change S[1] to ‘a’. Modified string = “aeeg”.
In 2nd operation: take i = 2 and j=4, swap S[2] and S[4] and then change S[2] to ‘a’. Modified string = “aaee”.
In 3rd operation: take i = 3 and j = 4, swap S[3] and S[4] and then change S[3] to ‘a’. Modified string = “aaae”.
In 4th operation: take i = 3 and j = 4, swap S[3] and S[4] and then change S[3] to ‘a’. Modified string = “aaaa”.

Input: S = “geeksforgeeks”, K = 6
Output: aaaaaaeegeeks
Explanation: After 6 operations, lexicographically smallest string will be “aaaaaaeegeeks”.

Approach: For Kâ‰¥N, the lexicographically smallest possible string will be ‘a’ repeated N times, since, in N operations, all the characters of S can be changed to ‘a’. For all other cases, the idea is to iterate the string S using variable i, find a suitable j for which S[j]>S[i], and then convert S[j] to S[i] and S[i] to ‘a’. Continue this process while K>0.

Follow the steps below to solve the problem:

• If K â‰¥ N, convert every character of string S to ‘a’ and print the string, S.
• Otherwise:

Below is the implementation of the above approach:

## C++

 `// C++ program to implement the above approach``#include ``using` `namespace` `std;` `// Function to find the lexicographically``// smallest possible string by performing``// K operations on string S``void` `smallestlexicographicstring(string s, ``int` `k)``{` `    ``// Store the size of string, s``    ``int` `n = s.size();` `    ``// Check if k>=n, if true, convert``    ``// every character to 'a'``    ``if` `(k >= n) {``        ``for` `(``int` `i = 0; i < n; i++) {``            ``s[i] = ``'a'``;``        ``}``        ``cout << s;``        ``return``;``    ``}` `    ``// Iterate in range[0, n - 1] using i``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// When k reaches 0, break the loop``        ``if` `(k == 0) {``            ``break``;``        ``}` `        ``// If current character is 'a',``        ``// continue``        ``if` `(s[i] == ``'a'``)``            ``continue``;` `        ``// Otherwise, iterate in the``        ``// range [i + 1, n - 1] using j``        ``for` `(``int` `j = i + 1; j < n; j++) {` `            ``// Check if s[j] > s[i]``            ``if` `(s[j] > s[i]) {` `                ``// If true, set s[j] = s[i]``                ``// and break out of the loop``                ``s[j] = s[i];``                ``break``;``            ``}` `            ``// Check if j reaches the last index``            ``else` `if` `(j == n - 1)``                ``s[j] = s[i];``        ``}` `        ``// Update S[i]``        ``s[i] = ``'a'``;` `        ``// Decrement k by 1``        ``k--;``    ``}` `    ``// Print string``    ``cout << s;``}` `// Driver Code``int` `main()``{` `    ``// Given String, s``    ``string s = ``"geeksforgeeks"``;` `    ``// Given k``    ``int` `k = 6;` `    ``// Function Call``    ``smallestlexicographicstring(s, k);` `    ``return` `0;``}`

## Java

 `// Java program to implement the above approach``public` `class` `GFG``{``  ` `    ``// Function to find the lexicographically``    ``// smallest possible string by performing``    ``// K operations on string S``    ``static` `void` `smallestlexicographicstring(``char``[] s, ``int` `k)``    ``{``       ` `        ``// Store the size of string, s``        ``int` `n = s.length;``       ` `        ``// Check if k>=n, if true, convert``        ``// every character to 'a'``        ``if` `(k >= n)``        ``{``            ``for` `(``int` `i = ``0``; i < n; i++)``            ``{``                ``s[i] = ``'a'``;``            ``}``            ``System.out.print(s);``            ``return``;``        ``}``       ` `        ``// Iterate in range[0, n - 1] using i``        ``for` `(``int` `i = ``0``; i < n; i++)``        ``{``       ` `            ``// When k reaches 0, break the loop``            ``if` `(k == ``0``)``            ``{``                ``break``;``            ``}``       ` `            ``// If current character is 'a',``            ``// continue``            ``if` `(s[i] == ``'a'``)``                ``continue``;``       ` `            ``// Otherwise, iterate in the``            ``// range [i + 1, n - 1] using j``            ``for` `(``int` `j = i + ``1``; j < n; j++)``            ``{``       ` `                ``// Check if s[j] > s[i]``                ``if` `(s[j] > s[i])``                ``{``       ` `                    ``// If true, set s[j] = s[i]``                    ``// and break out of the loop``                    ``s[j] = s[i];``                    ``break``;``                ``}``       ` `                ``// Check if j reaches the last index``                ``else` `if` `(j == n - ``1``)``                    ``s[j] = s[i];``            ``}``       ` `            ``// Update S[i]``            ``s[i] = ``'a'``;``       ` `            ``// Decrement k by 1``            ``k--;``        ``}``       ` `        ``// Print string``        ``System.out.print(s);``    ``}``    ` `  ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``      ` `        ``// Given String, s``        ``char``[] s = (``"geeksforgeeks"``).toCharArray();``       ` `        ``// Given k``        ``int` `k = ``6``;``       ` `        ``// Function Call``        ``smallestlexicographicstring(s, k);``    ``}``}` `// This code is contributed by divyesh072019.`

## Python3

 `# Python3 program to implement the above approach` `# Function to find the lexicographically``# smallest possible string by performing``# K operations on string S``def` `smallestlexicographicstring(s, k):` `    ``# Store the size of string, s``    ``n ``=` `len``(s)` `    ``# Check if k>=n, if true, convert``    ``# every character to 'a'``    ``if` `(k >``=` `n):``        ``for` `i ``in` `range``(n):``        ` `            ``s[i] ``=` `'a'``;``        ` `        ``print``(s, end ``=` `'')``        ``return``;``    `  `    ``# Iterate in range[0, n - 1] using i``    ``for` `i ``in` `range``(n):` `        ``# When k reaches 0, break the loop``        ``if` `(k ``=``=` `0``):``            ``break``;``        ` `        ``# If current character is 'a',``        ``# continue``        ``if` `(s[i] ``=``=` `'a'``):``            ``continue``;` `        ``# Otherwise, iterate in the``        ``# range [i + 1, n - 1] using j``        ``for` `j ``in` `range``(i ``+` `1``, n):` `            ``# Check if s[j] > s[i]``            ``if` `(s[j] > s[i]):` `                ``# If true, set s[j] = s[i]``                ``# and break out of the loop``                ``s[j] ``=` `s[i];``                ``break``;``        `  `            ``# Check if j reaches the last index``            ``elif` `(j ``=``=` `n ``-` `1``):``                ``s[j] ``=` `s[i];``    `  `        ``# Update S[i]``        ``s[i] ``=` `'a'``;` `        ``# Decrement k by 1``        ``k ``-``=` `1` `    ``# Print string``    ``print``('``'.join(s), end = '``');`  `# Driver Code``if` `__name__``=``=``'__main__'``:` `    ``# Given String, s``    ``s ``=` `list``(``"geeksforgeeks"``);` `    ``# Given k``    ``k ``=` `6``;` `    ``# Function Call``    ``smallestlexicographicstring(s, k);``    ` `    ``# This code is contributed by rutvik_56.`

## C#

 `// C# program to implement the above approach``using` `System;``using` `System.Collections.Generic;``class` `GFG``{``    ` `    ``// Function to find the lexicographically``    ``// smallest possible string by performing``    ``// K operations on string S``    ``static` `void` `smallestlexicographicstring(``char``[] s, ``int` `k)``    ``{``      ` `        ``// Store the size of string, s``        ``int` `n = s.Length;``      ` `        ``// Check if k>=n, if true, convert``        ``// every character to 'a'``        ``if` `(k >= n)``        ``{``            ``for` `(``int` `i = 0; i < n; i++)``            ``{``                ``s[i] = ``'a'``;``            ``}``            ``Console.Write(s);``            ``return``;``        ``}``      ` `        ``// Iterate in range[0, n - 1] using i``        ``for` `(``int` `i = 0; i < n; i++)``        ``{``      ` `            ``// When k reaches 0, break the loop``            ``if` `(k == 0)``            ``{``                ``break``;``            ``}``      ` `            ``// If current character is 'a',``            ``// continue``            ``if` `(s[i] == ``'a'``)``                ``continue``;``      ` `            ``// Otherwise, iterate in the``            ``// range [i + 1, n - 1] using j``            ``for` `(``int` `j = i + 1; j < n; j++)``            ``{``      ` `                ``// Check if s[j] > s[i]``                ``if` `(s[j] > s[i])``                ``{``      ` `                    ``// If true, set s[j] = s[i]``                    ``// and break out of the loop``                    ``s[j] = s[i];``                    ``break``;``                ``}``      ` `                ``// Check if j reaches the last index``                ``else` `if` `(j == n - 1)``                    ``s[j] = s[i];``            ``}``      ` `            ``// Update S[i]``            ``s[i] = ``'a'``;``      ` `            ``// Decrement k by 1``            ``k--;``        ``}``      ` `        ``// Print string``        ``Console.Write(s);``    ``}` `  ``// Driver code``  ``static` `void` `Main()``  ``{``    ` `    ``// Given String, s``    ``char``[] s = (``"geeksforgeeks"``).ToCharArray();``  ` `    ``// Given k``    ``int` `k = 6;``  ` `    ``// Function Call``    ``smallestlexicographicstring(s, k);``  ``}``}` `// This code is contributed by divyeshrabadiya07.`

## Javascript

 ``

Output:

`aaaaaaeegeeks`

Time complexity: O(N2)
Auxiliary space: O(1)

My Personal Notes arrow_drop_up