Find the lexicographically smallest string which satisfies the given condition
Last Updated :
08 Dec, 2022
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}
Output: abacad
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 <iostream>
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 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
# 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# 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
// PHP implementation of the above approach
// Function to return the required string
function 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 || $A[0] != 1)
{
$S = "-1";
return $S;
}
$S .= $ch;
$ch++;
// Check one by one all element of given prefix array
for ($i = 1; $i < $N; $i++)
{
$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
$arr = array( 1, 1, 2, 3, 3 );
$n = sizeof($arr);
echo(smallestString($n, $arr));
// This code is contributed by Code_Mech
?>
<script>
// Javascript implementation of the approach
// Function to return the required string
function smallestString(N, A)
{
// First character will always be 'a'
let ch = 'a';
// To store the resultant string
let 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 = String.fromCharCode(ch.charCodeAt(0) + 1);
// Check one by one all element of
// given prefix array
for(let i = 1; i < N; i++)
{
let 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 = String.fromCharCode(
ch.charCodeAt(0) + 1);
}
}
// Return the resultant string
return S;
}
// Driver code
let arr = [ 1, 1, 2, 3, 3 ];
let n = arr.length;
document.write(smallestString(n, arr));
// This code is contributed by souravmahato348
</script>
Time Complexity: O(n)
Auxiliary Space: O(1)
Similar Reads
Lexicographically smallest character from an array that satisfies the given conditions
Given a character array, str[] consisting of N lowercase alphabets, and an integer array, arr[] consisting of numbers in the range [0, N - 1]. Following are the operations that will be performed in the problem: Traverse the character array str[] from left to right.For every ith index, store the smal
15+ min read
Find lexicographical smallest string by performing the given operations N times
Given a string S of N characters, the task is to find the smallest lexicographical string after performing each of the following operations N times in any order: Remove the 1st character of S and insert it into a stack X.Remove the top of stack X and append it to the end of another string Y which is
8 min read
Find lexicographically smallest string in at most one swaps
Given a string str of length N. The task is to find out the lexicographically smallest string when at most only one swap is allowed. That is, two indices 1 <= i, j <= n can be chosen and swapped. This operation can be performed at most one time. Examples: Input: str = "string" Output: gtrins E
14 min read
Lexicographically smallest string with given string as prefix
Given an array arr[] consisting of N strings and a string S if size M, the task is to find the lexicographically smallest string consisting of the string S as the prefix. If there doesn't exist any string starting with prefix S then print "-1". Examples: Input: arr[] = {"apple", "appe", "apl", "aapl
6 min read
Lexicographically smallest string which is not a subsequence of given string
Given a string S, the task is to find the string which is lexicographically smallest and not a subsequence of the given string S. Examples: Input: S = "abcdefghijklmnopqrstuvwxyz"Output: aaExplanation:String "aa" is the lexicographically smallest string which is not present in the given string as a
5 min read
Find Lexicographically smallest String with Prefix Reversal
Given a string str of length N. You have to choose a non-zero integer K (K <= N), such that in one operation you can take the prefix of the string of length K and append the reverse of it to itself, the task is to find the lexicographically smallest string you can get. Examples: Input: str = "bvd
5 min read
Find Mth lexicographically smallest Binary String with no two adjacent 1
Given two integers N and M, the task is to find the Mth lexicographically smallest binary string (have only characters 1 and 0) of length N where there cannot be two consecutive 1s. Examples: Input: N = 2, M = 3.Output: 10Explanation: The only strings that can be made of size 2 are ["00", "01", "10"
6 min read
Build lexicographically smallest String from two given Strings
Given two strings X and Y of lowercase letters, of length N and M respectively, the task is to build another string Z by performing two types of operations: Choose any character from the string X, remove it from X, and add it to the end of Z.Choose any character from the string Y, remove it from Y,
6 min read
K-th lexicographically smallest unique substring of a given string
Given a string S. The task is to print the K-th lexicographically the smallest one among the different substrings of s.A substring of s is a string obtained by taking out a non-empty contiguous part in s. For example, if s = ababc, a, bab and ababc are substrings of s, while ac, z, and an empty stri
5 min read
Queries to answer the X-th smallest sub-string lexicographically
Given a string str and Q queries. Every query consists of a number X, the task is to print the Xth lexicographically smallest sub-string of the given string str. Examples: Input: str = "geek", q[] = {1, 5, 10} Output: e ek k "e", "e", "ee", "eek", "ek", "g", "ge", "gee", "geek" and "k" are all the p
5 min read