String formada con el carácter central de cada substring derecha seguido de la izquierda secuencialmente

Dada una string str de longitud N , la tarea es descifrarla utilizando un conjunto determinado de reglas de descifrado e imprimir la string descifrada. 
Las reglas de descifrado son las siguientes: 
 

• Comience con el carácter central de la string str e imprímalo.
• Atraviese repetidamente la substring derecha e imprima su carácter central.
• Repita el mismo procedimiento para la substring izquierda también.

Ejemplos: 
 

Input: N = 4, str = "abcd" 
Output: bcda
Explanation:
              abcd  ------ b
              / \
             a   cd ------ c
            /     \
           a       d ----- d
          /
         a --------------- a
Hence, the final string is "bcda".

Input: N = 6, str = "gyuitp"
Output: utpigy
Explanation:
            gyuitp ------- u
             / \
           gy  itp ------- t
          /    /\
         gy   i  p ------ p
         /   /
        gy  i ----------- i
        /
       gy --------------- g
       \
        y  -------------- y
Hence, the final string is "utpigy".

Enfoque: 
La idea principal es utilizar la recursividad . Continúe dividiendo toda la string en substrings izquierda y derecha e imprima el elemento central de cada una de esas substrings, hasta que la string quede con un solo carácter y no se pueda dividir más.
Los pasos detallados para este enfoque son los siguientes: 
 

• Inicialice start = 0, end = N -1, indicando el primer y último carácter de la string.
• Imprime el carácter en el medio de la string, es decir mid = (start + end) / 2.
• Atraviese recursivamente su substring derecha (inicio = medio +1, final) seguido de su substring izquierda (inicio, medio – 1).
• Repita los pasos anteriores para cada substring atravesada. Continúe hasta que se atraviese toda la string e imprima la string dada.

A continuación se muestra la implementación del enfoque anterior: 
 

// C++ implementation of
// the above approach
 
#include <iostream>
using namespace std;
 
// Function to decrypt and
// print the new string
void decrypt(string Str,
             int Start, int End)
{
    // If the whole string
    // has been traversed
    if (Start > End) {
        return;
    }
 
    // To calculate middle
    // index of the string
    int mid = (Start + End) >> 1;
 
    // Print the character
    // at middle index
    cout << Str[mid];
 
    // Recursively call
    // for right-substring
    decrypt(Str, mid + 1, End);
 
    // Recursive call
    // for left-substring
    decrypt(Str, Start, mid - 1);
}
 
// Driver Code
int main()
{
 
    int N = 4;
    string Str = "abcd";
    decrypt(Str, 0, N - 1);
    cout << "\n";
 
    N = 6;
    Str = "gyuitp";
    decrypt(Str, 0, N - 1);
 
    return 0;
}

// Java implementation of
// the above approach
class GFG{
 
// Function to decrypt and
// print the new String
static void decrypt(String Str,
            int Start, int End)
{
    // If the whole String
    // has been traversed
    if (Start > End)
    {
        return;
    }
 
    // To calculate middle
    // index of the String
    int mid = (Start + End) >> 1;
 
    // Print the character
    // at middle index
    System.out.print(Str.charAt(mid));
 
    // Recursively call
    // for right-subString
    decrypt(Str, mid + 1, End);
 
    // Recursive call
    // for left-subString
    decrypt(Str, Start, mid - 1);
}
 
// Driver Code
public static void main(String[] args)
{
    int N = 4;
    String Str = "abcd";
    decrypt(Str, 0, N - 1);
    System.out.print("\n");
 
    N = 6;
    Str = "gyuitp";
    decrypt(Str, 0, N - 1);
}
}
 
// This code is contributed by sapnasingh4991

# Python3 implementation of
# the above approach
 
# Function to decrypt and
# print the new string
def decrypt(Str, Start, End):
 
    # If the whole string
    # has been traversed
    if (Start > End):
        return;
     
    # To calculate middle
    # index of the string
    mid = (Start + End) >> 1;
 
    # Print the character
    # at middle index
    print(Str[mid], end = "");
 
    # Recursively call
    # for right-substring
    decrypt(Str, mid + 1, End);
 
    # Recursive call
    # for left-substring
    decrypt(Str, Start, mid - 1);
 
# Driver Code
N = 4;
Str = "abcd";
decrypt(Str, 0, N - 1);
print();
 
N = 6;
Str = "gyuitp";
decrypt(Str, 0, N - 1);
 
# This code is contributed by Code_Mech

// C# implementation of
// the above approach
using System;
class GFG{
 
// Function to decrypt and
// print the new String
static void decrypt(String Str,
            int Start, int End)
{
    // If the whole String
    // has been traversed
    if (Start > End)
    {
        return;
    }
 
    // To calculate middle
    // index of the String
    int mid = (Start + End) >> 1;
 
    // Print the character
    // at middle index
    Console.Write(Str[mid]);
 
    // Recursively call
    // for right-subString
    decrypt(Str, mid + 1, End);
 
    // Recursive call
    // for left-subString
    decrypt(Str, Start, mid - 1);
}
 
// Driver Code
public static void Main()
{
    int N = 4;
    String Str = "abcd";
    decrypt(Str, 0, N - 1);
    Console.Write("\n");
 
    N = 6;
    Str = "gyuitp";
    decrypt(Str, 0, N - 1);
}
}
 
// This code is contributed by Code_Mech

<script>
 
// Javascript program for the above approach
 
// Function to decrypt and
// print the new String
function decrypt(Str, Start, End)
{
 
    // If the whole String
    // has been traversed
    if (Start > End)
    {
        return;
    }
 
    // To calculate middle
    // index of the String
    let mid = (Start + End) >> 1;
 
    // Print the character
    // at middle index
    document.write(Str[mid]);
 
    // Recursively call
    // for right-subString
    decrypt(Str, mid + 1, End);
 
    // Recursive call
    // for left-subString
    decrypt(Str, Start, mid - 1);
}
 
 
// Driver Code
    let N = 4;
    let Str = "abcd";
    decrypt(Str, 0, N - 1);
    document.write("<br/>");
 
    N = 6;
    Str = "gyuitp";
    decrypt(Str, 0, N - 1);
 
// This code is contributed by sanjoy_62.
</script>

bcda
utpigy

Complejidad temporal: O(N) 
Espacio auxiliar: O(1)