# 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)

My Personal Notes arrow_drop_up
Recommended Articles
Page :