Related Articles

# Find the string present at the middle of a lexicographically increasing sequence of strings from S to T

• Difficulty Level : Hard
• Last Updated : 27 Sep, 2021

Given two strings S and T, S being lexicographically greater than T, the task is to generate a lexicographically increasing sequence of strings starting from S to T ( both inclusive ) and print the string that is present at the middle of the sequence.
Note: There will always be an odd number of strings in the lexicographically increasing sequence.

Example:

Input: N = 2, S = “az”, T = “bf”
Output: “bc”
Explanation: The lexicographically increasing sequence of strings is “az”, “ba”, “bb”, “bc”, “bd”, “be”, “bf”. The string at the middle is “bc”.

Input: S = “afogk”, T = “asdji”
Output: “alvuw”

Approach: Follow the steps below to solve the problem:

• Every string can be represented in base 26 in terms of integers between [0, 26).
• If the strings represented two integers L and R, then the result will be (L + R)/2 which will be the middle number.
• Using the similar concept, the strings can be represented in terms of base 26 numbers
• Strings such as “az” can be represented as (0 25)26, “bf” can be represented as (1 5)26; and “” can be represented as ()26
• After converting the strings to their respective base 26 numbers, obtain their bitwise summation.
• Add the bits iterating from right to left and carry over the remainder to the next position.
• The addition of (0 25)26 and (1 5)26 will be (2 4)26.
• Take the middle of every position’s value and print the corresponding character. If the position is odd, then shift the next position by 26 characters.

Illustration:

S = “afogk”, T = “asdji”

• 26 base representation of S = [0, 5, 14, 6, 10]
• 26 base representation of T = [0, 18, 3, 9, 8]
• Addition of strings S and T = [0, 23, 17, 15, 18]
• Middle string representation of (S + T)/2 = [0, 11, 21, 20, 22]
• So each character in string will be the a[i] th character from ‘a’ in 0 based – indexing

Below is the implementation of the above approach:

## C++

 `// C++ Program for the above approach` `#include ``using` `namespace` `std;` `// Function to print the string at``// the middle of lexicographically``// increasing sequence of strings from S to T``int` `printMiddleString(string S, string T, ``int` `N)``{``    ``// Stores the base 26 digits after addition``    ``vector<``int``> a1(N + 1);` `    ``for` `(``int` `i = 0; i < N; i++) {``        ``a1[i + 1] = S[i] - ``'a'` `+ T[i] - ``'a'``;``    ``}` `    ``// Iterete from right to left``    ``// and add carry to next position``    ``for` `(``int` `i = N; i >= 1; i--) {``        ``a1[i - 1] += a1[i] / 26;``        ``a1[i] %= 26;``    ``}` `    ``// Reduce the number to find the middle``    ``// string by dividing each position by 2``    ``for` `(``int` `i = 0; i <= N; i++) {` `        ``// If current value is odd,``        ``// carry 26 to the next index value``        ``if` `(a1[i] & 1) {` `            ``if` `(i + 1 <= N) {``                ``a1[i + 1] += 26;``            ``}``        ``}` `        ``a1[i] /= 2;``    ``}` `    ``for` `(``int` `i = 1; i <= N; i++) {``        ``cout << ``char``(a1[i] + ``'a'``);``    ``}``    ``return` `0;``}` `// Driver Code``int` `main()``{``    ``int` `N = 5;``    ``string S = ``"afogk"``;``    ``string T = ``"asdji"``;``    ``printMiddleString(S, T, N);``}`

## Java

 `// Java Program for the above approach``import` `java.util.*;` `class` `GFG {` `    ``// Function to print the string at``    ``// the middle of lexicographically``    ``// increasing sequence of strings from S to T``    ``static` `void` `printMiddleString(String S, String T, ``int` `N)``    ``{``        ``// Stores the base 26 digits after addition``        ``int``[] a1 = ``new` `int``[N + ``1``];` `        ``for` `(``int` `i = ``0``; i < N; i++) {``            ``a1[i + ``1``] = (``int``)S.charAt(i) - ``97``                        ``+ (``int``)T.charAt(i) - ``97``;``        ``}` `        ``// Iterete from right to left``        ``// and add carry to next position``        ``for` `(``int` `i = N; i >= ``1``; i--) {``            ``a1[i - ``1``] += (``int``)a1[i] / ``26``;``            ``a1[i] %= ``26``;``        ``}` `        ``// Reduce the number to find the middle``        ``// string by dividing each position by 2``        ``for` `(``int` `i = ``0``; i <= N; i++) {` `            ``// If current value is odd,``            ``// carry 26 to the next index value``            ``if` `((a1[i] & ``1``) != ``0``) {` `                ``if` `(i + ``1` `<= N) {``                    ``a1[i + ``1``] += ``26``;``                ``}``            ``}` `            ``a1[i] = (``int``)a1[i] / ``2``;``        ``}` `        ``for` `(``int` `i = ``1``; i <= N; i++) {``            ``System.out.print((``char``)(a1[i] + ``97``));``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `N = ``5``;``        ``String S = ``"afogk"``;``        ``String T = ``"asdji"``;``        ``printMiddleString(S, T, N);``    ``}``}` `// This code is contributed by ukasp.`

## Python3

 `# Python Program for the above approach` `# Function to print the string at``# the middle of lexicographically``# increasing sequence of strings from S to T``def` `printMiddleString(S, T, N):``  ` `  ``# Stores the base 26 digits after addition``  ``a1 ``=` `[``0``] ``*` `(N ``+` `1``);` `  ``for` `i ``in` `range``(N):``    ``a1[i ``+` `1``] ``=` `ord``(S[i]) ``-` `ord``(``"a"``) ``+` `ord``(T[i]) ``-` `ord``(``"a"``);``  `  `  ``# Iterete from right to left``  ``# and add carry to next position``  ``for` `i ``in` `range``(N, ``1``, ``-``1``):``    ``a1[i ``-` `1``] ``+``=` `a1[i] ``/``/` `26``;``    ``a1[i] ``%``=` `26``;``  `  `  ``# Reduce the number to find the middle``  ``# string by dividing each position by 2``  ``for` `i ``in` `range``(N``+``1``):``    ``# If current value is odd,``    ``# carry 26 to the next index value``    ``if` `(a1[i] & ``1``):``      ``if` `(i ``+` `1` `<``=` `N):``        ``a1[i ``+` `1``] ``+``=` `26``;``  ` `    ``a1[i] ``=` `a1[i] ``/``/` `2``;``  ` `  ``for` `i ``in` `range``(``1``, N ``+` `1``):``    ``print``(``chr``(a1[i] ``+` `ord``(``"a"``)), end``=``"");``  ` `  ``return` `0``;` `# Driver Code``N ``=` `5``;``S ``=` `"afogk"``;``T ``=` `"asdji"``;``printMiddleString(S, T, N);` `# This code is contributed by gfgking`

## C#

 `// C# Program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Function to print the string at``// the middle of lexicographically``// increasing sequence of strings from S to T``static` `void` `printMiddleString(``string` `S, ``string` `T, ``int` `N)``{``    ``// Stores the base 26 digits after addition``    ``int` `[]a1 = ``new` `int``[N + 1];` `    ``for` `(``int` `i = 0; i < N; i++) {``        ``a1[i + 1] = (``int``)S[i] - 97 + (``int``)T[i] - 97;``    ``}` `    ``// Iterete from right to left``    ``// and add carry to next position``    ``for` `(``int` `i = N; i >= 1; i--) {``        ``a1[i - 1] += (``int``)a1[i] / 26;``        ``a1[i] %= 26;``    ``}` `    ``// Reduce the number to find the middle``    ``// string by dividing each position by 2``    ``for` `(``int` `i = 0; i <= N; i++) {` `        ``// If current value is odd,``        ``// carry 26 to the next index value``        ``if` `((a1[i] & 1)!=0) {` `            ``if` `(i + 1 <= N) {``                ``a1[i + 1] += 26;``            ``}``        ``}` `        ``a1[i] = (``int``)a1[i]/2;``    ``}` `    ``for` `(``int` `i = 1; i <= N; i++) {``        ``Console.Write(Convert.ToChar(a1[i] + ``'a'``));``    ``}``    ` `}` `// Driver Code``public` `static` `void` `Main()``{``    ``int` `N = 5;``    ``string` `S = ``"afogk"``;``    ``string` `T = ``"asdji"``;``    ``printMiddleString(S, T, N);``}``}` `// This code is contributed by ipg2016107.`

## Javascript

 ``

Output:
`alvuw`

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up