# Find the lexicographically smallest string which satisfies the given condition

Given an array, arr[] of N integers, where arr[i] represents the number of distinct characters in the prefix of length (i + 1) of a string S. The task is to find the lexicographically smallest string (if any exists) that satisfies the given prefix array. The string should be of lowercase English alphabets [a-z]. If no such string exists then print -1

Examples:

Input: arr[] = {1, 1, 2, 3}
Output: aabc
prefix[0] has 1 distinct character
prefix[1] has 1 distinct character
prefix[2] has 2 distinct characters
prefix[3] has 3 distinct characters
And the string is the smallest possible.

Input: arr[] = {1, 2, 2, 3, 3, 4}

Input: arr[] = {1, 1, 3, 3}
Output: -1

Approach: The first character of every string will always be ‘a’. Since we have to find the lexicographically smallest string. Therefore, if the number of different characters in the prefix of length i and i + 1 is same, then (i+1)th character will be ‘a’ otherwise it will be a different character from all characters in length i and it will be one greater than the greatest character in the prefix of length i

For example, if prefix array is {1, 2, 2, 3, 4} then the first character will be ‘a’, the second character will be ‘b’ since number of different character is 2 (it can also be ‘c’ or ‘d’, etc but we have to take lexicographically smallest). Third character will be either ‘a’ or ‘b’ but we take ‘a’ since “aba” is smaller than “abb”
Similarly, fourth and fifth character will be ‘c’ and ‘d’ respectively. Therefore, the resultant string that satisfies the given prefix array will be “abacd”.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach` `#include ` `using` `namespace` `std;`   `// Function to return the required string` `string smallestString(``int` `N, ``int` `A[])` `{` `    ``// First character will always be 'a'` `    ``char` `ch = ``'a'``;`   `    ``// To store the resultant string` `    ``string S = ``""``;`   `    ``// Since length of the string should be` `    ``// greater than 0 and first element` `    ``// of array should be 1` `    ``if` `(N < 1 || A[0] != 1) {` `        ``S = ``"-1"``;` `        ``return` `S;` `    ``}`   `    ``S += ch;` `    ``ch++;`   `    ``// Check one by one all element of given prefix array` `    ``for` `(``int` `i = 1; i < N; i++) {` `        ``int` `diff = A[i] - A[i - 1];`   `        ``// If the difference between any two` `        ``// consecutive elements of the prefix array` `        ``// is greater than 1 then there will be no such` `        ``// string possible that satisfies the given array` `        ``// Also, string cannot have more than` `        ``// 26 distinct characters` `        ``if` `(diff > 1 || diff < 0 || A[i] > 26) {` `            ``S = ``"-1"``;` `            ``return` `S;` `        ``}`   `        ``// If difference is 0 then the (i + 1)th character` `        ``// will be same as the ith character` `        ``else` `if` `(diff == 0)` `            ``S += ``'a'``;`   `        ``// If difference is 1 then the (i + 1)th character` `        ``// will be different from the ith character` `        ``else` `{` `            ``S += ch;` `            ``ch++;` `        ``}` `    ``}`   `    ``// Return the resultant string` `    ``return` `S;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `arr[] = { 1, 1, 2, 3, 3 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``cout << smallestString(n, arr);`   `    ``return` `0;` `}`

## Java

 `// Java implementation of the above approach ` `import` `java.io.*;`   `public` `class` `GFG ` `{ ` `    `  `    ``// Function to return the required string ` `    ``static` `String smallestString(``int` `N, ``int` `[]A) ` `    ``{ ` `        ``// First character will always be 'a' ` `        ``char` `ch = ``'a'``; ` `    `  `        ``// To store the resultant string ` `        ``String S = ``""``; ` `    `  `        ``// Since length of the string should be ` `        ``// greater than 0 and first element ` `        ``// of array should be 1 ` `        ``if` `(N < ``1` `|| A[``0``] != ``1``) ` `        ``{ ` `            ``S = ``"-1"``; ` `            ``return` `S; ` `        ``} ` `    `  `        ``S += ch; ` `        ``ch++; ` `    `  `        ``// Check one by one all element of given prefix array ` `        ``for` `(``int` `i = ``1``; i < N; i++) ` `        ``{ ` `            ``int` `diff = A[i] - A[i - ``1``]; ` `    `  `            ``// If the difference between any two ` `            ``// consecutive elements of the prefix array ` `            ``// is greater than 1 then there will be no such ` `            ``// string possible that satisfies the given array ` `            ``// Also, string cannot have more than ` `            ``// 26 distinct characters ` `            ``if` `(diff > ``1` `|| diff < ``0` `|| A[i] > ``26``) ` `            ``{ ` `                ``S = ``"-1"``; ` `                ``return` `S; ` `            ``} ` `    `  `            ``// If difference is 0 then the (i + 1)th character ` `            ``// will be same as the ith character ` `            ``else` `if` `(diff == ``0``) ` `                ``S += ``'a'``; ` `    `  `            ``// If difference is 1 then the (i + 1)th character ` `            ``// will be different from the ith character ` `            ``else` `            ``{ ` `                ``S += ch; ` `                ``ch++; ` `            ``} ` `        ``} ` `    `  `        ``// Return the resultant string ` `        ``return` `S; ` `    ``} ` `    `  `    ``// Driver code ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``int` `[]arr = { ``1``, ``1``, ``2``, ``3``, ``3` `}; ` `        ``int` `n = arr.length; ` `        ``System.out.println(smallestString(n, arr)); ` `    ``} ` `} `   `// This code is contributed by Ryuga`

## Python3

 `# Function to return the required string` `def` `smallestString(N, A):` `    `  `    ``# First character will always be 'a'` `    ``ch ``=` `'a'`   `    ``# To store the resultant string` `    ``S ``=` `""`   `    ``# Since length of the string should be` `    ``# greater than 0 and first element` `    ``# of array should be 1` `    ``if` `(N < ``1` `or` `A[``0``] !``=` `1``):` `        ``S ``=` `"-1"` `        ``return` `S`   `    ``S ``+``=` `str``(ch)` `    ``ch ``=` `chr``(``ord``(ch) ``+` `1``)`   `    ``# Check one by one all element of ` `    ``# given prefix array` `    ``for` `i ``in` `range``(``1``, N):` `        ``diff ``=` `A[i] ``-` `A[i ``-` `1``]`   `        ``# If the difference between any two` `        ``# consecutive elements of the prefix ` `        ``# array is greater than 1 then there ` `        ``# will be no such string possible that ` `        ``# satisfies the given array. ` `        ``# Also, string cannot have more than` `        ``# 26 distinct characters` `        ``if` `(diff > ``1` `or` `diff < ``0` `or` `A[i] > ``26``):` `            ``S ``=` `"-1"` `            ``return` `S`   `        ``# If difference is 0 then the ` `        ``# (i + 1)th character will be ` `        ``# same as the ith character` `        ``elif` `(diff ``=``=` `0``):` `            ``S ``+``=` `'a'`   `        ``# If difference is 1 then the ` `        ``# (i + 1)th character will be ` `        ``# different from the ith character` `        ``else``:` `            ``S ``+``=` `ch` `            ``ch ``=` `chr``(``ord``(ch) ``+` `1``)`   `    ``# Return the resultant string` `    ``return` `S`   `# Driver code` `arr ``=` `[``1``, ``1``, ``2``, ``3``, ``3``]` `n ``=` `len``(arr)` `print``(smallestString(n, arr))`   `# This code is contributed ` `# by mohit kumar`

## C#

 `// C# implementation of the approach` `using` `System;`   `class` `GFG` `{` `    `  `// Function to return the required string` `static` `string` `smallestString(``int` `N, ``int` `[]A)` `{` `    ``// First character will always be 'a'` `    ``char` `ch = ``'a'``;`   `    ``// To store the resultant string` `    ``string` `S = ``""``;`   `    ``// Since length of the string should be` `    ``// greater than 0 and first element` `    ``// of array should be 1` `    ``if` `(N < 1 || A[0] != 1) ` `    ``{` `        ``S = ``"-1"``;` `        ``return` `S;` `    ``}`   `    ``S += ch;` `    ``ch++;`   `    ``// Check one by one all element of given prefix array` `    ``for` `(``int` `i = 1; i < N; i++)` `    ``{` `        ``int` `diff = A[i] - A[i - 1];`   `        ``// If the difference between any two` `        ``// consecutive elements of the prefix array` `        ``// is greater than 1 then there will be no such` `        ``// string possible that satisfies the given array` `        ``// Also, string cannot have more than` `        ``// 26 distinct characters` `        ``if` `(diff > 1 || diff < 0 || A[i] > 26) ` `        ``{` `            ``S = ``"-1"``;` `            ``return` `S;` `        ``}`   `        ``// If difference is 0 then the (i + 1)th character` `        ``// will be same as the ith character` `        ``else` `if` `(diff == 0)` `            ``S += ``'a'``;`   `        ``// If difference is 1 then the (i + 1)th character` `        ``// will be different from the ith character` `        ``else` `        ``{` `            ``S += ch;` `            ``ch++;` `        ``}` `    ``}`   `    ``// Return the resultant string` `    ``return` `S;` `}`   `// Driver code` `static` `void` `Main()` `{` `    ``int` `[]arr = { 1, 1, 2, 3, 3 };` `    ``int` `n = arr.Length;` `    ``Console.WriteLine(smallestString(n, arr));` `}` `}`   `// This code is contributed by mits`

## PHP

 ` 1 || ``\$diff` `< 0 || ``\$A``[``\$i``] > 26) ` `        ``{ ` `            ``\$S` `= ``"-1"``; ` `            ``return` `\$S``; ` `        ``} `   `        ``// If difference is 0 then the (i + 1)th character ` `        ``// will be same as the ith character ` `        ``else` `if` `(``\$diff` `== 0) ` `            ``\$S` `.= ``'a'``; `   `        ``// If difference is 1 then the (i + 1)th character ` `        ``// will be different from the ith character ` `        ``else` `        ``{ ` `            ``\$S` `.= ``\$ch``; ` `            ``\$ch``++; ` `        ``} ` `    ``} `   `    ``// Return the resultant string ` `    ``return` `\$S``; ` `} `   `// Driver code ` `\$arr` `= ``array``( 1, 1, 2, 3, 3 ); ` `\$n` `= sizeof(``\$arr``); ` `echo``(smallestString(``\$n``, ``\$arr``)); `   `// This code is contributed by Code_Mech` `?>`

## Javascript

 ``

Output

`aabca`

Time Complexity: O(n)
Auxiliary Space: O(1)

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next