Given a string S that contains only lowercase alphabets and no special characters except spaces, the task is to find lexicographically adjacent pairs of characters and concatenate the number of pairs of each word in the string.
Examples:
Input: S = “hello world”
Output: 21
Explanation: Input string contains two words “hello” and “world”, In word ‘hello’, ‘e’ & ‘l’ and ‘l’ & ‘o’ are in lexicographical order so the pair count for “hello” is 2. In word “world” only ‘o’ & ‘r’ are in lexical order so pair count for “world” is 1. On concatenating both result we get 21 as output.Input: S = “venom vest”
Output: 22
Explanation: Input string contains two words “venom” and “vest”, In word “venom”, ‘e’ & ‘n’ and ‘n’ & ‘o’ are in lexicographical order so the pair count for “venom” is 2. In word “vest”, ‘e’ & ‘s’ and ‘s’ & ‘t’ are in lexical order so pair count for “vest” is 2. On concatenating both result we get 22 as output.Input: S = “abcdefghijklmn mno”
Output: 132
Explanation: Input string contains two words, In first word “abcdefghijklmn”, every single adjacent character follows the lexical order thus there are total 13 pairs and for second word “mno” there are 2 pairs.On concatenating both result we get 132 as output.
Approach: To solve the problem follow the below idea:
The approach is to initially find the number of pairs in every word and then use that pair count for concatenating so this can be done in the below steps:
Steps to follow to solve the problem:
- Initialize a vector of string to extract words from the input string and then initialize the int vector of size n ( the size of the string vector ) to keep the count of pairs in each word.
- Use istringstream to extract words from the input string and store every word into a string vector.
- Iterate over string vector and for every single iteration, perform the operation mentioned below:
- Take the current word and store it in a temp string and iterate over the temp string and check whether the ASCII values of two adjacent characters follow the lexical order or not. If Yes, then take the pair count value and increment it.
- Store the pair count in an integer vector.
- After this initialize an integer variable for the final answer with the first value of the integer vector and then iterate over the vector values for concatenating.
Below is the implementation for the above approach:
// C++ code to implement the approach. #include <bits/stdc++.h> using namespace std;
// Function to concatenate the required // count of lexicographically adjacent // characters. int concatPairs(string s)
{ vector<string> ans;
istringstream s1(s);
// Creating a stream of words
// separated by space
string word;
while (s1 >> word) {
ans.push_back(word);
}
int n = ans.size();
vector< int > values(n);
for ( int i = 0; i < n; i++) {
string temp = ans[i];
int pair = 0;
// Counting number of pairs
for ( int i = 1; i < temp.size(); i++) {
if (temp[i - 1] - 0 < temp[i] - 0) {
pair++;
}
}
values[i] = pair;
}
int finalAns = values[0];
// Constructing final ans with
// number of pairs
for ( int i = 1; i < n; i++) {
finalAns *= 10;
finalAns += values[i];
}
return finalAns;
} // Driver's code int main()
{ string s = "abcdefghijklmn mno" ;
// Function call.
int finalAns = concatPairs(s);
// Printing final output.
cout << finalAns;
return 0;
} |
// Java code to implement the approach. import java.io.*;
import java.util.*;
class GFG {
// Function to concatenate the required
// count of lexicographically adjacent
// characters.
public static int concatPairs(String s)
{
s += " " ;
ArrayList<String> ans = new ArrayList<String>();
int sz = s.length();
// Creating a stream of words
// separated by space
String word = "" ;
for ( int i = 0 ; i < sz; i++) {
if (s.charAt(i) == ' ' ) {
ans.add(word);
word = "" ;
}
else
word += s.charAt(i);
}
int n = ans.size();
ArrayList<Integer> values
= new ArrayList<Integer>();
for ( int i = 0 ; i < n; i++) {
String temp = ans.get(i);
int pair = 0 ;
// Counting number of pairs
for ( int j = 1 ; j < temp.length(); j++) {
if (temp.charAt(j - 1 ) - 0
< temp.charAt(j) - 0 ) {
pair++;
}
}
values.add(pair);
}
int finalAns = values.get( 0 );
// Constructing final ans with
// number of pairs
for ( int i = 1 ; i < n; i++) {
finalAns *= 10 ;
finalAns += values.get(i);
}
return finalAns;
}
// Driver's code
public static void main(String[] args)
{
String s = "abcdefghijklmn mno" ;
// Function call.
int finalAns = concatPairs(s);
// Printing final output.
System.out.print(finalAns);
}
} // This code is contributed by Rohit Pradhan |
# Function to concatenate the required # count of lexicographically adjacent # characters. def concatPairs(s: str ) - > int :
ans = []
# Creating a stream of words separated by space
for word in s.split():
ans.append(word)
n = len (ans)
values = [ 0 ] * n
for i in range (n):
temp = ans[i]
pair = 0
# Counting number of pairs
for j in range ( 1 , len (temp)):
if ord (temp[j - 1 ]) < ord (temp[j]):
pair + = 1
values[i] = pair
finalAns = values[ 0 ]
# Constructing final ans with number of pairs
for i in range ( 1 , n):
finalAns * = 10
finalAns + = values[i]
return finalAns
# Driver's code if __name__ = = '__main__' :
s = "abcdefghijklmn mno"
# Function call
finalAns = concatPairs(s)
# Printing final output
print (finalAns)
|
// C# code to implement the approach using System;
using System.Collections.Generic;
public class GFG {
// Function to concatenate the required count of
// lexicographically adjacent characters.
public static int concatPairs( string s)
{
s += " " ;
List< string > ans = new List< string >();
int sz = s.Length;
// Creating a stream of words separated by space
string word = "" ;
for ( int i = 0; i < sz; i++) {
if (s[i] == ' ' ) {
ans.Add(word);
word = "" ;
}
else
word += s[i];
}
int n = ans.Count;
List< int > values = new List< int >();
for ( int i = 0; i < n; i++) {
string temp = ans[i];
int pair = 0;
// Counting number of pairs
for ( int j = 1; j < temp.Length; j++) {
if (temp[j - 1] - 0 < temp[j] - 0) {
pair++;
}
}
values.Add(pair);
}
int finalAns = values[0];
// Constructing final ans with number of pairs
for ( int i = 1; i < n; i++) {
finalAns *= 10;
finalAns += values[i];
}
return finalAns;
}
static public void Main()
{
// Code
string s = "abcdefghijklmn mno" ;
// Function call.
int finalAns = concatPairs(s);
// Printing final output.
Console.Write(finalAns);
}
} // This code is contributed by sankar. |
// JavaScript code to implement the approach. // Function to concatenate the required count of // lexicographically adjacent characters. function concatPairs(s) {
s += " " ;
let ans = [];
let sz = s.length;
let word = "" ;
// Creating an array of words separated by space
for (let i = 0; i < sz; i++) {
if (s[i] === " " ) {
ans.push(word);
word = "" ;
}
else
word += s[i];
}
let n = ans.length;
let values = [];
for (let i = 0; i < n; i++) {
let temp = ans[i];
let pair = 0;
// Counting number of pairs
for (let j = 1; j < temp.length; j++) {
if (temp.charCodeAt(j - 1) < temp.charCodeAt(j)) {
pair++;
}
}
values.push(pair);
}
let finalAns = values[0];
// Constructing final ans with number of pairs
for (let i = 1; i < n; i++) {
finalAns *= 10;
finalAns += values[i];
}
return finalAns;
} let s = "abcdefghijklmn mno" ;
// Function call. let finalAns = concatPairs(s); // Printing final output. console.log(finalAns); // This code is contributed by karthik. |
132
Time Complexity: O(3N) //First N for iterating over input string for extracting words + Second N for processing every word to find pair + Third N for generating unique code.
Auxiliary Space: O(2N)//First N for storing words in string vector + Second N for storing pair counts in an integer vector