Given a sentence S and a string B having distinct characters, find a string by joining the words of S according to given conditions:-
- Choose a word from S if
- It has at least length(B)/2 characters from string B or
- Having at least one character from string B and lexicographically sorted in increasing order.
- The string formed should be lexicographically largest string.
Examples:
Input: S = “peek geek suv”, B = “ekps”
Output: suvpeekgeek
Explanation: “suv” has one character from B and sorted in increasing order.
Whereas “peek” and “geek” has length(B)/2 characters.
Input: S = “peek fit and run”, B = “ekta”
Output: peekfit
Naive Approach: The task can be solved by storing both the word of string S and the string B in a set and comparing if they are equal but this would require more than one set, which requires extra time and space.
Time Complexity: O(N * logN) where N is the total number of characters in S
Auxiliary Space: O(N)
Efficient approach: The better approach is to use a map. Following the steps mentioned below:
- Store the frequency of characters of B in an unordered map and compare with strings of array S.
- If two characters exist in a word of string S then add it to the output string.
- If only one character is present then check if it is sorted in lexicographically increasing order.
- If yes then add it to the output string.
- Arrange the output string in lexicographically largest permutation.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
bool isosrted(string s)
{
for ( int i = 0; i < s.size() - 1; i++) {
if (s[i] > s[i + 1])
return false ;
}
return true ;
}
string choosestr(string s, string b, int n)
{
unordered_map< char , int > m;
set<string, greater<string> > ss;
for ( int i = 0; b[i]; i++) {
m[b[i]]++;
}
int g = b.size() / 2;
int c = 0;
string k = "" , p;
stringstream sg(s);
while (sg >> p) {
c = 0;
for ( int j = 0; j < p.size(); j++) {
if (m[p[j]])
c++;
if (c == g)
break ;
}
if ((c == 1 and isosrted(p)) or c == g)
ss.insert(p);
}
for ( auto i : ss) {
k += i;
}
return k;
}
int main()
{
string S = "peek fit and run" ;
string B = "ekta" ;
int N = sizeof (S) / sizeof (S[0]);
cout << choosestr(S, B, N);
return 0;
}
|
Java
import java.util.*;
public class Main {
public static boolean isSorted(String s) {
for ( int i = 0 ; i < s.length() - 1 ; i++) {
if (s.charAt(i) > s.charAt(i + 1 )) {
return false ;
}
}
return true ;
}
public static String chooseStr(String s, String b) {
Map<Character, Integer> m = new HashMap<>();
Set<String> ss = new TreeSet<>(Collections.reverseOrder());
for ( int i = 0 ; i < b.length(); i++) {
m.put(b.charAt(i), m.getOrDefault(b.charAt(i), 0 ) + 1 );
}
int g = b.length() / 2 ;
int c = 0 ;
String k = "" , p;
String[] split = s.split( " " );
for ( int i = 0 ; i < split.length; i++) {
c = 0 ;
p = split[i];
for ( int j = 0 ; j < p.length(); j++) {
if (m.containsKey(p.charAt(j))) {
c++;
}
if (c == g) {
break ;
}
}
if ((c == 1 && isSorted(p)) || c == g) {
ss.add(p);
}
}
for (String i : ss) {
k += i + " " ;
}
return k;
}
public static void main(String[] args) {
String s = "peek fit and run" ;
String b = "ekta" ;
System.out.println(chooseStr(s, b));
}
}
|
Python3
def isosrted(s):
for i in range ( len (s) - 1 ):
if (s[i] > s[i + 1 ]):
return False
return True
def choosestr(s, b, n):
m = {};
ss = set ({})
for i in range ( len (b)):
if (b[i] in m):
m[b[i]] + = 1
else :
m[b[i]] = 1
g = len (b) / / 2
c = 0
k = "";
arr = s.split( " " );
for p in arr:
c = 0
for j in range ( len (p)):
if (p[j] in m):
c + = 1
if (c = = g):
break
if ((c = = 1 and isosrted(p)) or c = = g):
ss.add(p)
ans = []
for i in ss:
ans.append(i)
ans.sort()
ans.reverse()
for i in ans:
k + = i
return k
if __name__ = = '__main__' :
S = "peek fit and run"
B = "ekta"
N = len (S)
print (choosestr(S, B, N))
|
Javascript
<script>
const isosrted = (s) => {
for (let i = 0; i < s.length - 1; i++) {
if (s[i] > s[i + 1])
return false ;
}
return true ;
}
const choosestr = (s, b, n) => {
let m = {};
let ss = new Set();
for (let i = 0; i < b.length; i++) {
if (b[i] in m) m[b[i]]++;
else m[b[i]] = 1;
}
let g = parseInt(b.length / 2);
let c = 0;
let k = "" ;
let p = s.split( " " );
for (let i in p) {
c = 0;
for (let j = 0; j < p[i].length; j++) {
if (p[i][j] in m)
c++;
if (c == g)
break ;
}
if ((c == 1 && isosrted(p[i])) || c == g) {
ss.add(p[i]);
}
}
for (let i of ss) {
k += i;
}
return k;
}
let S = "peek fit and run" ;
let B = "ekta" ;
let N = S.length;
document.write(choosestr(S, B, N));
</script>
|
C#
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace GFG
{
class Program
{
static void Main( string [] args)
{
string S = "peek fit and run" ;
string B = "ekta" ;
int N = S.Length;
Console.WriteLine(ChooseStr(S, B, N));
Console.ReadLine();
}
private static string ChooseStr( string s, string b, int n)
{
Dictionary< char , int > m = new Dictionary< char , int >();
SortedSet< string > ss = new SortedSet< string >(Comparer< string >.Create((x, y) => y.CompareTo(x)));
foreach ( char c in b)
{
if (m.ContainsKey(c))
{
m++;
}
else
{
m = 1;
}
}
int g = b.Length / 2;
int cnt = 0;
string k = "" ;
string [] words = s.Split( ' ' );
foreach ( string p in words)
{
cnt = 0;
foreach ( char c in p)
{
if (m.ContainsKey(c))
{
cnt++;
}
if (cnt == g)
{
break ;
}
}
if ((cnt == 1 && Isosorted(p)) || cnt == g)
{
ss.Add(p);
}
}
foreach ( string i in ss)
{
k += i;
}
return k;
}
private static bool Isosorted( string s)
{
for ( int i = 0; i < s.Length - 1; i++)
{
if (s[i] > s[i + 1])
{
return false ;
}
}
return true ;
}
}
}
|
Time Complexity: O(N)
Auxiliary Space: O(N)
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!
Last Updated :
16 Feb, 2023
Like Article
Save Article