Thursday, October 2, 2025
HomeData Modelling & AICreate a new string by alternately combining the characters of two halves...

Create a new string by alternately combining the characters of two halves of the string in reverse

Given a string s, create a new string such that it contains the characters of the two halves of the string s combined alternately in reverse order. 

Examples: 

Input : s = carbohydrates
Output : hsoebtraarcdy

Input : s = sunshine
Output : sennuish

Explanation: 

Example 1: Two halves of the string carbohydrate are carboh and ydrates. As they needed to be added in reverse alternately, start with h from first half then s from second half followed by o from first half, e from second half and so on. The string p comes out to be hsoebtraarcdy. If one of the string is completely finished then simply add the remaining characters of the other string in reverse order. 

Example 2: The two halves of the string are suns and hine. String sennuish is the desired string p.

Algorithm:

  • Define a method named “solve” of void return type which takes string “s” as an input parameter.
  •  Create three int variables named “l”, “x”, and “y” and initialize them with a length of the string, half the length of the string,              and the length of the string respectively.
  • Define an empty string variable “p” to store the final output string.
  •  Start a while loop, and iterate until variable “x” is greater than 0 and variable “y” is greater than l/2.
    • get the character at index (x-1) and add it to string “p”. Then, decrement the value of “x”.
    •  Again, get the character at index (y-1) and add it to string “p”. Then, decrement the value of “y”.
  •  If “y” is greater than l/2, then get the character at index (y-1) and add it to string “p”.
  •  Then, decrement the value of “y”.
  • Finally, print the string “p”.
     

Implementation:

C++




// C++ program for creating a string
// by alternately combining the
// characters of two halves
// in reverse
#include <bits/stdc++.h>
using namespace std;
 
// Function performing calculations
void solve(string s)
{
    int l = s.length();
    int x = l / 2;
    int y = l;
     
    // Calculating the two halves
    // of string s as first and
    // second. The final string p
    string p = "";
    while (x > 0 && y > l / 2) {
         
        // It joins the characters to
        // final string in reverse order
        p += s[x - 1];
        x--;
         
        // It joins the characters to
        // final string in reverse order
        p += s[y - 1];
        y--;
    }
     
    if (y > l / 2) {
        p += s[y - 1];
        y--;
    }
     
    cout << p;
}
 
// Driver code
int main()
{
    string s = "sunshine";
     
    // Calling function
    solve(s);
    return 0;
}


Java




// Java program for creating a string
// by alternately combining the
// characters of two halves
// in reverse
import java.io.*;
 
class GFG {
 
    // Function performing calculations
    public static void solve(String s)
    {
        int l = s.length();
        int x = l / 2;
        int y = l;
 
        // Calculating the two halves of
        // string s as first and second
        // The final string p
        String p = "";
        while (x > 0 && y > l / 2) {
 
            // It joins the characters to
            // final string in reverse order
            char ch = s.charAt(x - 1);
            p += ch;
            x--;
 
            // It joins the characters to
            // final string in reverse order
            ch = s.charAt(y - 1);
            p += ch;
            y--;
        }
 
        if (y > l / 2) {
            char ch = s.charAt(y - 1);
            p += ch;
            y--;
        }
        System.out.println(p);
    }
 
    // Driver method
    public static void main(String args[])
    {
        String s = "sunshine";
 
        // Calling function
        solve(s);
    }
}


Python3




# Python 3 program for creating a string
# by alternately combining the
# characters of two halves
# in reverse
 
# Function performing calculations
def solve(s) :
    l = len(s)
    x = l // 2
    y = l
      
    # Calculating the two halves
    # of string s as first and
    # second. The final string p
    p = ""
    while (x > 0 and y > l / 2) :
 
        # It joins the characters to
        # final string in reverse order
        p =  p + s[x - 1]
        x = x - 1
          
        # It joins the characters to
        # final string in reverse order
        p = p + s[y - 1]
        y = y - 1
     
      
    if (y > l // 2) :
        p = p + s[y - 1]
        y = y - 1
     
    print (p)
 
# Driver code
s = "sunshine"
 
# Calling function
solve(s)
 
 
# This code is contributed by Nikita Tiwari


C#




// C# program for creating a string
// by alternately combining the
// characters of two halves
// in reverse
using System;
 
class GFG {
     
    // Function performing calculations
    public static void solve(string s)
    {
        int l = s.Length;
        int x = l / 2;
        int y = l;
     
        // Calculating the two halves of
        // string s as first and second
        // The final string p
        string p = "";
        while (x > 0 && y > l / 2) {
         
            // It joins the characters to
            // final string in reverse order
            char ch = s[x - 1];
            p += ch;
            x--;
             
            // It joins the characters to
            // final string in reverse order
            ch = s[y - 1];
            p += ch;
            y--;
        }
         
        if (y > l / 2)
        {
            char ch = s[x - 1];
            p += ch;
            y--;
        }
        Console.WriteLine(p);
    }
     
    // Driver method
    public static void Main()
    {
        string s = "sunshine";
         
        // Calling function
        solve(s);
    }
}
// This code is contributed by vt_m.


PHP




<?php
// Python 3 program for creating a string
// by alternately combining the
// characters of two halves in reverse
 
// Function performing calculations
function solve($s)
{
    $l = strlen($s);
    $x = $l / 2;
    $y = $l;
     
    // Calculating the two halves
    // of string s as first and
    // second. The final string p
    $p = "";
    while ($x > 0 && $y > $l / 2)
    {
         
        // It joins the characters to
        // final string in reverse order
        $p = $p.$s[$x - 1];
        $x--;
         
        // It joins the characters to
        // final string in reverse order
        $p = $p.$s[$y - 1];
        $y--;
    }
     
    if ($y > $l / 2)
    {
        $p = $p.$s[$y - 1];
        $y--;
    }
     
    echo $p;
}
 
// Driver code
$s = "sunshine";
     
// Calling function
solve($s);
 
// This code is contributed
// by ChitraNayal
?>


Javascript




<script>
 
// JavaScript program for creating a string
// by alternately combining the
// characters of two halves
// in reverse
 
    // Function performing calculations
    function solve( s) {
        var l = s.length;
        var x = l / 2;
        var y = l;
 
        // Calculating the two halves of
        // string s as first and second
        // The final string p
        var p = "";
        while (x > 0 && y > l / 2) {
 
            // It joins the characters to
            // final string in reverse order
            var ch = s.charAt(x - 1);
            p += ch;
            x--;
 
            // It joins the characters to
            // final string in reverse order
            ch = s.charAt(y - 1);
            p += ch;
            y--;
        }
 
        if (y > l / 2) {
            var ch = s.charAt(x - 1);
            p += ch;
            y--;
        }
        document.write(p);
    }
 
    // Driver method
     
        var s = "sunshine";
 
        // Calling function
        solve(s);
 
 
// This code is contributed by todaysgaurav
 
</script>


Output

sennuish

Time complexity: O(n) where n is the length of the string
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 neveropen!

Dominic
Dominichttp://wardslaus.com
infosec,malicious & dos attacks generator, boot rom exploit philanthropist , wild hacker , game developer,
RELATED ARTICLES

Most Popular

Dominic
32331 POSTS0 COMMENTS
Milvus
85 POSTS0 COMMENTS
Nango Kala
6703 POSTS0 COMMENTS
Nicole Veronica
11867 POSTS0 COMMENTS
Nokonwaba Nkukhwana
11927 POSTS0 COMMENTS
Shaida Kate Naidoo
6818 POSTS0 COMMENTS
Ted Musemwa
7079 POSTS0 COMMENTS
Thapelo Manthata
6775 POSTS0 COMMENTS
Umr Jansen
6776 POSTS0 COMMENTS