# Lexicographically smallest String using all of the first K letters of alphabet and no two adjacent characters are same

• Last Updated : 22 Feb, 2022

Given two integers N and K, the task is to form a string of size N using the first K characters of the alphabet following the given conditions:

• No two adjacent characters of the string are the same.
• All of the K characters are present at least once in the string.

If no such string is possible, print -1.

Examples:

Input: N = 3, K = 2
Output: “aba”
Explanation: This is the lexicographically smallest string which follows the condition.
“aaa” is lexicographically smallest string of size 3, but this does not contain ‘b’.
So it is not a valid string according to the statement.
“aab” is also lexicographically smaller, but it violates the condition of two adjacent characters not being the same.

Input: N = 2, K = 3
Output: -1
Explanation: Have to choose first 3 characters, but a string of only 2 size should be formed.
So it is not possible to use all of the first 3 characters.

Approach: This is an implementation based problem. As known, if the starting characters of the alphabet are used at the starting of the string, then the string will be lexicographically smaller. Follow the steps mentioned below:

• if N < K or K = 1 and N > 1 then print ‘-1’ as forming a string that satisfies both the condition is not possible.
• Otherwise, if N = 2 then print “ab”.
• If N > 2 then add ‘a’ and ‘b’ in the resultant string alternatively until the remaining length is K-2. Then add the remaining characters except ‘a’ and ‘b’ in lexicographical order.
• The final string is the required string.

Below is the implementation of the above approach.

## C++

 `// C++ program to implement the approach``#include ``using` `namespace` `std;` `// Function to find the``// lexicographically smallest string``string findmin(``int` `N, ``int` `K)``{``    ``// If size of given string is``    ``// more than first K letters of``    ``// alphabet then print -1.``    ``// If K = 1 and N > 1 then it``    ``// violates the rule that``    ``// adjacent characters should be different``    ``if` `(N < K or (K == 1 and N > 1))``        ``return` `"-1"``;` `    ``// If N = 2 then print "ab"``    ``if` `(N == 2)``        ``return` `"ab"``;` `    ``string s;``    ``// Except "ab" add characters``    ``// in the string``    ``for` `(``int` `i = 2; i < K; i++) {``        ``s += ``char``(i + 97);``    ``}``    ``string a = ``"ab"``, b;``    ``int` `i = 0;``    ``while` `(i < N) {` `        ``// Add 'a' and 'b' alternatively``        ``b += a[i % 2];``        ``i++;` `        ``// If there are other characters``        ``// than 'a' and 'b'``        ``if` `(N - i == K - 2) {``            ``for` `(``int` `i = 0; i < s.size();``                 ``i++) {``                ``b += s[i];``            ``}``            ``break``;``        ``}``    ``}` `    ``// Desired string``    ``return` `b;``}` `// Driver code``int` `main()``{``    ``int` `N = 3, K = 2;` `    ``// Function call``    ``cout << findmin(N, K);``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.lang.*;``import` `java.util.*;` `class` `GFG {` `  ``// Function to find the``  ``// lexicographically smallest string``  ``static` `String findmin(``int` `N, ``int` `K)``  ``{``    ` `    ``// If size of given string is``    ``// more than first K letters of``    ``// alphabet then print -1.``    ``// If K = 1 and N > 1 then it``    ``// violates the rule that``    ``// adjacent characters should be different``    ``if` `(N < K || (K == ``1` `&& N > ``1``))``      ``return` `"-1"``;` `    ``// If N = 2 then print "ab"``    ``if` `(N == ``2``)``      ``return` `"ab"``;` `    ``String s = ``""``;``    ``// Except "ab" add characters``    ``// in the string``    ``for` `(``int` `i = ``2``; i < K; i++) {``      ``char` `ch = (``char``)(i + ``97``);``      ``s += ch;``    ``}``    ``String a = ``"ab"``, b = ``""``;``    ``int` `i = ``0``;``    ``while` `(i < N) {` `      ``// Add 'a' and 'b' alternatively``      ``b += a.charAt(i % ``2``);``      ``i++;` `      ``// If there are other characters``      ``// than 'a' and 'b'``      ``if` `(N - i == K - ``2``) {``        ``for` `(``int` `j = ``0``; j < s.length();j++) {``          ``b += s.charAt(j);``        ``}``        ``break``;``      ``}``    ``}` `    ``// Desired string``    ``return` `b;``  ``}` `  ``// Driver code``  ``public` `static` `void` `main (String[] args) {` `    ``int` `N = ``3``, K = ``2``;``    ``System.out.println(findmin(N, K));``  ``}``}` `// This code is contributed by hrithikgarg03188.`

## Python

 `# Python program to implement the approach` `# Function to find the``# lexicographically smallest string``def` `findmin(N, K):` `    ``# If size of given string is``    ``# more than first K letters of``    ``# alphabet then print -1.``    ``# If K = 1 and N > 1 then it``    ``# violates the rule that``    ``# adjacent characters should be different``    ``if` `(N < K ``or` `(K ``=``=` `1` `and` `N > ``1``)):``        ``return` `"-1"` `    ``# If N = 2 then print "ab"``    ``if` `(N ``=``=` `2``):``        ``return` `"ab"` `    ``s ``=` `""``    ``# Except "ab" add characters``    ``# in the string``    ``for` `i ``in` `range``(``2``, K):``        ``s ``+``=` `(i ``+` `97``)` `    ``a ``=` `"ab"``    ``b ``=` `""``    ``i ``=` `0``    ``while` `(i < N):` `        ``# Add 'a' and 'b' alternatively``        ``b ``+``=` `a[i ``%` `2``]``        ``i ``+``=` `1` `        ``# If there are other characters``        ``# than 'a' and 'b'``        ``if` `(N ``-` `i ``=``=` `K ``-` `2``):``            ``for` `j ``in` `range``(``len``(s)):``                ``b ``+``=` `s[i]``            ``break` `    ``# Desired string``    ``return` `b` `# Driver code``N ``=` `3``K ``=` `2` `# Function call``print``(findmin(N, K))` `# This code is contributed by Samim Hossain Mondal.`

## C#

 `// C# program to implement the approach``using` `System;``class` `GFG``{` `  ``// Function to find the``  ``// lexicographically smallest string``  ``static` `string` `findmin(``int` `N, ``int` `K)``  ``{` `    ``// If size of given string is``    ``// more than first K letters of``    ``// alphabet then print -1.``    ``// If K = 1 and N > 1 then it``    ``// violates the rule that``    ``// adjacent characters should be different``    ``if` `(N < K || (K == 1 && N > 1))``      ``return` `"-1"``;` `    ``// If N = 2 then print "ab"``    ``if` `(N == 2)``      ``return` `"ab"``;` `    ``string` `s = ``""``;` `    ``// Except "ab" add characters``    ``// in the string``    ``for` `(``int` `x = 2; x < K; x++) {``      ``s += (``char``)(x + 97);``    ``}``    ``string` `a = ``"ab"``, b = ``""``;``    ``int` `i = 0;``    ``while` `(i < N) {` `      ``// Add 'a' and 'b' alternatively``      ``b += a[i % 2];``      ``i++;` `      ``// If there are other characters``      ``// than 'a' and 'b'``      ``if` `(N - i == K - 2) {``        ``for` `(``int` `j = 0; j < s.Length;``             ``j++) {``          ``b += s[j];``        ``}``        ``break``;``      ``}``    ``}` `    ``// Desired string``    ``return` `b;``  ``}` `  ``// Driver code``  ``public` `static` `void` `Main()``  ``{``    ``int` `N = 3, K = 2;` `    ``// Function call``    ``Console.Write(findmin(N, K));``  ``}``}` `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output

`aba`

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

My Personal Notes arrow_drop_up