Reverse individual words

Last Updated : 13 Apr, 2024

Given string str, we need to print the reverse of individual words.

Examples:

Input : Hello World

Output : olleH dlroW

Input : Geeks for Geeks

Output : skeeG rof skeeG

Method 1 (Simple): Generate all words separated by space. One by one reverse word and print them separated by space.

Method 2 (Space Efficient): We use a stack to push all words before space. As soon as we encounter a space, we empty the stack.

Implementation:

C++

// C++ program to reverse individual words in a given
// string using STL list

#include <bits/stdc++.h>
using namespace std;

// reverses individual words of a string
void reverseWords(string str)
{
    stack<char> st;

    // Traverse given string and push all characters
    // to stack until we see a space.
    for (int i = 0; i < str.length(); ++i) {
        if (str[i] != ' ')
            st.push(str[i]);

        // When we see a space, we print contents
        // of stack.
        else {
            while (st.empty() == false) {
                cout << st.top();
                st.pop();
            }
            cout << " ";
        }
    }

    // Since there may not be space after
    // last word.
    while (st.empty() == false) {
        cout << st.top();
        st.pop();
    }
}

// Driver program to test function
int main()
{
    string str = "Geeks for Geeks";
    reverseWords(str);
    return 0;
}

Java

// Java program to reverse individual
// words in a given string using STL list
import java.io.*;
import java.util.*;

class GFG {

    // reverses individual words of a string
    static void reverseWords(String str)
    {
        Stack<Character> st = new Stack<Character>();

        // Traverse given string and push all
        // characters to stack until we see a space.
        for (int i = 0; i < str.length(); ++i) {
            if (str.charAt(i) != ' ')
                st.push(str.charAt(i));

            // When we see a space, we print
            // contents of stack.
            else {
                while (st.empty() == false) {
                    System.out.print(st.pop());
                }
                System.out.print(" ");
            }
        }

        // Since there may not be space after
        // last word.
        while (st.empty() == false) {
            System.out.print(st.pop());
        }
    }

    // Driver program to test above function
    public static void main(String[] args)
    {
        String str = "Geeks for Geeks";
        reverseWords(str);
    }
}

Python3

# Python3 program to reverse individual words
# in a given string using STL list

# reverses individual words of a string


def reverseWords(string):
    st = list()

    # Traverse given string and push all characters
    # to stack until we see a space.
    for i in range(len(string)):
        if string[i] != " ":
            st.append(string[i])

        # When we see a space, we print
        # contents of stack.
        else:
            while len(st) > 0:
                print(st[-1], end="")
                st.pop()
            print(end=" ")

    # Since there may not be space after
    # last word.
    while len(st) > 0:
        print(st[-1], end="")
        st.pop()


# Driver Code
if __name__ == "__main__":
    string = "Geeks for Geeks"
    reverseWords(string)

# This code is contributed by
# sanjeev2552

// C# program to reverse individual
// words in a given string using STL list
using System;
using System.Collections.Generic;

class GFG
{

// reverses individual words
// of a string
public static void reverseWords(string str)
{
    Stack<char> st = new Stack<char>();

    // Traverse given string and push
    // all characters to stack until
    // we see a space.
    for (int i = 0; i < str.Length; ++i)
    {
        if (str[i] != ' ')
        {
            st.Push(str[i]);
        }

        // When we see a space, we
        // print contents of stack.
        else
        {
            while (st.Count > 0)
            {
                Console.Write(st.Pop());

            }
            Console.Write(" ");
        }
    }

    // Since there may not be
    // space after last word.
    while (st.Count > 0)
    {
        Console.Write(st.Pop());

    }
}

// Driver Code
public static void Main(string[] args)
{
    string str = "Geeks for Geeks";
    reverseWords(str);
}
}

// This code is contributed
// by Shrikant13

JavaScript

// JS program to reverse individual words in a given
// string using STL list


// reverses individual words of a string
function reverseWords(str) {
    let st = [];

    // Traverse given string and push all characters
    // to stack until we see a space.
    for (let i = 0; i < str.length; ++i) {
        if (str[i] != ' ')
            st.unshift(str[i]);

        // When we see a space, we print contents
        // of stack.
        else {
            while (st.length != 0) {
                process.stdout.write(st[0]);
                st.shift();
            }
            //Add space after word is reversed.
            process.stdout.write(' ');
        }
    }

    // Since there may not be space after
    // last word.
    while (st.length != 0) {
        process.stdout.write(st[0]);
        st.shift();
    }
}

// Driver program to test function
let str = "Geeks for Geeks";
reverseWords(str);

// This code is contributed by adityamaharshi21

Output

skeeG rof skeeG

Time Complexity: O(n), where n is the length of the string
Auxiliary Space: O(n), where n is the length of the string

Python | Reverse each word in a sentence

Using stringstream in C++ :

Implementation:

C++

#include <bits/stdc++.h>
using namespace std;

void printWords(string str)
{
    // word variable to store word
    string word;

    // making a string stream
    stringstream iss(str);

    // Read and print each word.
    while (iss >> word) {
        reverse(word.begin(), word.end());
        cout << word << " ";
    }
}

// Driver code
int main()
{
    string s = "GeeksforGeeks is good to learn";
    printWords(s);
    return 0;
}
// This code is contributed by Nikhil Rawat

Java

import java.io.*;
import java.lang.*;
import java.util.*;

class Main {
    public static void printWords(String str)
    {
        // word variable to store word
        String word;

        // making a string stream
        StringTokenizer iss = new StringTokenizer(str);

        // Read and print each word.
        while (iss.hasMoreTokens()) {
            word = iss.nextToken();
            System.out.print(
                new StringBuilder(word).reverse().toString()
                + " ");
        }
    }

    public static void main(String[] args)
        throws java.lang.Exception
    {
        String s = "GeeksforGeeks is good to learn";
        printWords(s);
    }
}

// Contributed by rishabmalhdijo

using System;
using System.Linq;
using System.Collections.Generic;
using System.Text;
using System.IO;

public class GFG {
    static void printWords(string str)
    {
        // word variable to store word
        string word;

        // making a string stream
        using(var iss = new StringReader(str))
        {
            string line;
            while ((line = iss.ReadLine()) != null) {
                // Read and print each word.
                foreach(string w in line.Split(' '))
                {
                    word
                        = new string(w.Reverse().ToArray());
                    Console.Write(word + " ");
                }
            }
        }
    }

    // Driver code
    static void Main()
    {
        string s = "GeeksforGeeks is good to learn";
        printWords(s);
    }
}
// ksam24000

Javascript

function printWords(str) {

    // word variable to store word
    let word;
    
    // making a string stream
    let lines = str.split("\n");
    for (let i = 0; i < lines.length; i++) {
        let words = lines[i].split(" ");
        
        for (let j = 0; j < words.length; j++) {
            word = words[j].split("").reverse().join("");
            process.stdout.write(word + " ");
        }
    }
}

// Driver Code
let s = "GeeksforGeeks is good to learn";
printWords(s);

Python3

def print_words(s):
    # word variable to store word
    word = ""

    # making a string stream
    iss = s.split()

    # Read and print each word.
    for i in iss:
        word = i[::-1]
        print(word, end=" ")


# Driver code
if __name__ == '__main__':
    s = "GeeksforGeeks is good to learn"
    print_words(s)

Output

skeeGrofskeeG si doog ot nrael

Time complexity : O(n)

Auxiliary Space : O(n)

Using Java 8 Streams:

Implementation:

C++

#include <bits/stdc++.h>
using namespace std;

int main() {
string str = "Welcome to GFG";
    string result = "";

    // Splitting the string based on space
    istringstream ss(str);
    vector<string> words;
    do {
        string word;
        ss >> word;
        words.push_back(word);
    } while (ss);

    // Reverse each part and then join
    for (int i = 0; i < words.size() - 1; i++) {
        reverse(words[i].begin(), words[i].end());
        result += words[i] + ' ';
    }
    reverse(words.back().begin(), words.back().end());
    result += words.back();

    cout << result << endl;
    return 0;
}
//This code is contributed by Shivam Tiwari

Java

import java.util.Arrays;
import java.util.stream.Collectors;

// This code is contributed by Mayank Sharma
public class reverseIndividual {

    public static void main(String[] args) {

        String str = "Welcome to GFG";
        
        // Splitting the string based on space and reverse each part
        // and then join
        String result = Arrays.asList(str.split(" "))
                .stream()
                .map(s -> new StringBuilder(s).reverse())
                .collect(Collectors.joining(" "));

        System.out.println(result);

    }

}

using System;
using System.Linq;

public class ReverseIndividual
{
    public static void Main(string[] args)
    {
        string str = "Welcome to GFG";

        // Splitting the string based on space and reverse each part
        // and then join
        string result = string.Join(" ", str.Split(' ')
            .Select(word => new string(word.Reverse().ToArray())));

        Console.WriteLine(result);
    }
}

Javascript

function reverseIndividualWords(str) {
    // Split the string based on space
    const words = str.split(' ');

    // Reverse each word and join them back with space
    const reversedWords = words.map(word => word.split('').reverse().join(''));

    // Join the reversed words to form the final result
    const result = reversedWords.join(' ');

    return result;
}

const str = 'Welcome to GFG';
const reversedStr = reverseIndividualWords(str);
console.log(reversedStr);

Python3

# python code

import re

def reverseIndividual(str):
    words = re.findall(r'\b\w+\b', str)
    result = " ".join(word[::-1] for word in words)
    return result

str = "Welcome to GFG"
print(reverseIndividual(str))

#code by ksam24000

Output

emocleW ot GFG

Time complexity : O(n)

Auxiliary Space: O(n)

Way 3: Using StringBuffer Class.

Approach:

O(n) First, convert the string object into a StringBuffer object.
By using the reverse method of the StringBuffer class reverse the string.
Now, store the reverse sequence in a String array.
Run a loop that will create a new String by using these reverse words
Finally, return the new string.

Implementation:

C++

#include <algorithm>
#include <iostream>
#include <sstream>
#include <string>

std::string makeReverse(std::string str)
{
    std::reverse(str.begin(), str.end());
    std::istringstream iss(str);
    std::string word;
    std::string reverse;
    while (iss >> word) {
        reverse = word + " " + reverse;
    }
    return reverse;
}

int main()
{
    std::string str = "Geeks for Geeks";
    std::cout << makeReverse(str) << std::endl;
    return 0;
}

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    static String makeReverse(String str)
    {
        StringBuffer s = new StringBuffer(str);
        str = s.reverse().toString();
        String[] rev = str.split(" ");
        StringBuffer reverse = new StringBuffer();
        for (int i = rev.length - 1; i >= 0; i--) {
            reverse.append(rev[i]).append(" ");
        }
        return reverse.toString();
    }
    public static void main(String[] args)
    {
        String str = "Geeks for Geeks";
        System.out.println(makeReverse(str));
    }
}

// This code is contributed by Adarsh Kumar

using System;

class GFG {
    static string MakeReverse(string str)
    {
        char[] charArray = str.ToCharArray();
        Array.Reverse(charArray);
        str = new string(charArray);
        string[] rev = str.Split(' ');
        Array.Reverse(rev);
        return string.Join(" ", rev);
    }

    public static void Main()
    {
        string str = "Geeks for Geeks";
        Console.WriteLine(MakeReverse(str));
    }
}

Javascript

// Javascript code addition

function makeReverse(string) {
// Reversing the string
string = string.split("").reverse().join("");
// Splitting the string by space
let rev = string.split(" ");
// Reversing the list of words
rev = rev.reverse();
// Joining the words to form a new string
let reversedString = rev.join(" ");
return reversedString;
}

// Driver code
let string = "Geeks for Geeks";
console.log(makeReverse(string));

// The code is contributed by Nidhi goel.

Python3

# Function to make the reverse of the string
def make_reverse(string: str) -> str:
    # Reversing the string
    string = string[::-1]
    # Splitting the string by space
    rev = string.split(" ")
    # Reversing the list of words
    rev = rev[::-1]
    # Joining the words to form a new string
    reversed_string = " ".join(rev)
    return reversed_string


# Driver code
if __name__ == "__main__":
    string = "Geeks for Geeks"
    print(make_reverse(string))

# This code is contributed by Shivam Tiwari

Output

skeeG rof skeeG

Time complexity : O(n)

Auxiliary Space : O(n)

Way 4 :

Approach: To store the reversed string instead of just printing

Steps:

Create an empty stack to hold characters from the input string. Create two empty strings: ‘rev’ (for the reversed string) and ‘temp’ (for temporary storage).
Iterate through each character in the input string.
If the current character is a letter (an alphabet character) Add it to the ‘temp’ string to form a word .
If the current character is a space Append a space to the ‘rev’ string to separate words. Append the content of ‘temp’ (a word) to ‘rev’. Clear ‘temp’ to prepare for the next word.
After processing all characters. If ‘temp’ is not empty then add the content of ‘temp’ to the beginning of the ‘rev’ string.
Finally, return the ‘rev’ string.

C++

#include <iostream>
#include <stack>

class Reverse {
public:
    // function to reverse the individual words
    std::string reverse(std::string str) {
        // create a stack to access the string from end
        std::stack<char> s;

        // push all the characters of the stack
        for (int i = 0; i < str.length(); i++)
            s.push(str[i]);

        // rev string to store the required output
        std::string rev = "";
        std::string temp = "";

        // till the stack becomes empty
        while (!s.empty()) {
            // if top of the stack is a letter,
            // then append it to temp;
            if (isalpha(s.top()))
                temp += s.top();
            // if it is a space, then append space to rev
            // and also temp to rev
            else {
                rev = " " + temp + rev;
                // make the temp empty
                temp = "";
            }
            s.pop();
        }
        // if temp is not empty, add temp to rev at the front
        if (!temp.empty())
            rev = temp + rev;

        // return the output string
        return rev;
    }
};

int main() {
    std::string str = "Geeks for Geeks";

    Reverse obj;
    std::cout << obj.reverse(str) << std::endl;
    
    return 0;
}

// Siddhesh

Java

// Java program to reverse the individual words

import java.util.Stack;

public class Reverse {

    // function to reverse the individual words
    String reverse(String str)
    {
        // create a stack to access the string from end
        Stack<Character> s = new Stack<>();

        // push all the characters of the stack
        for (int i = 0; i < str.length(); i++)
            s.push(str.charAt(i));

        // rev string to store the required output
        String rev = "";
        String temp = "";

        // till the stack becomes empty
        while (!s.isEmpty()) {
            // if top of the stack is a letter,
            // then append it to temp;
            if (Character.isLetter(s.peek()))
                temp = temp + s.pop();
            // if it is a space, the append space to rev
            // and also temp to rev
            else {
                rev = " " + temp + rev;
                // make the temp empty
                temp = "";
                s.pop();
            }
        }
        // if temp is not empty, add temp to rev at the
        // front
        if (temp != "")
            rev = temp + rev;

        // return the output string
        return rev;
    }

    public static void main(String[] args)
    {
        String str = "Geeks for Geeks";

        Reverse obj = new Reverse();
        System.out.println(obj.reverse(str));
    }
}

using System;
using System.Collections.Generic;

class Reverse
{
    // Renamed the method to ReverseWords
    public string ReverseWords(string str)
    {
        // create a stack to access the string from end
        Stack<char> stack = new Stack<char>();

        // push all the characters onto the stack
        for (int i = 0; i < str.Length; i++)
        {
            stack.Push(str[i]);
        }

        // rev string to store the required output
        string rev = "";
        string temp = "";

        // until the stack becomes empty
        while (stack.Count > 0)
        {
            // if the top of the stack is a letter,
            // then append it to temp;
            if (char.IsLetter(stack.Peek()))
            {
                temp += stack.Pop();
            }
            // if it is a space, then append space to rev
            // and also temp to rev
            else
            {
                rev = " " + temp + rev;
                // make the temp empty
                temp = "";
                stack.Pop();
            }
        }
        // if temp is not empty, add temp to rev at the front
        if (!string.IsNullOrEmpty(temp))
        {
            rev = temp + rev;
        }

        // return the output string
        return rev;
    }
}

class Program
{
    static void Main()
    {
        string str = "Geeks for Geeks";

        Reverse obj = new Reverse();
        Console.WriteLine(obj.ReverseWords(str));

        // Pause execution to see the result
        Console.ReadLine();
    }
}
// contributed Siddhesh

Javascript

class Reverse {
    // function to reverse the individual words
    reverse(str) {
        // create an array (stack) to access the string from end
        const stack = [];

        // push all the characters onto the stack
        for (let i = 0; i < str.length; i++) {
            stack.push(str.charAt(i));
        }

        // rev string to store the required output
        let rev = '';
        let temp = '';

        // until the stack becomes empty
        while (stack.length > 0) {
            // if top of the stack is a letter,
            // then append it to temp;
            if (/[a-zA-Z]/.test(stack[stack.length - 1])) {
                temp += stack.pop();
            }
            // if it is a space, then append space to rev
            // and also temp to rev
            else {
                rev = ' ' + temp + rev;
                // make the temp empty
                temp = '';
                stack.pop();
            }
        }
        // if temp is not empty, add temp to rev at the front
        if (temp !== '') {
            rev = temp + rev;
        }

        // return the output string
        return rev;
    }
}

// Testing the Reverse class
const str = 'Geeks for Geeks';
const obj = new Reverse();
console.log(obj.reverse(str));

Python3

class Reverse:

    # function to reverse the individual words
    def reverse(self, string):
        # create a stack to access the string from end
        stack = []

        # push all the characters of the string onto the stack
        for i in range(len(string)):
            stack.append(string[i])

        # rev string to store the required output
        rev = ""
        temp = ""

        # till the stack becomes empty
        while len(stack) > 0:
            # if top of the stack is a letter, then append it to temp
            if stack[-1].isalpha():
                temp = temp + stack.pop()
            # if it is a space, append space to rev and also temp to rev
            else:
                rev = " " + temp + rev
                # make the temp empty
                temp = ""
                stack.pop()

        # if temp is not empty, add temp to rev at the front
        if temp != "":
            rev = temp + rev

        # return the output string
        return rev


# main driver function
if __name__ == '__main__':
    str = "Geeks for Geeks"

    obj = Reverse()
    print(obj.reverse(str))

Output

skeeG rof skeeG

Time Complexity : O(N)

Auxiliary Space : O(N) for using stack .

Way 5 : Using Split and iterator

Implementation:

C++

#include <algorithm>
#include <iostream>
#include <sstream>

class ReverseSentence {
public:
    // Function to reverse each word in a sentence
    static std::string
    revSentence(const std::string& sentence)
    {
        // Split the string into words
        std::istringstream iss(sentence);
        std::string word;
        std::ostringstream reverseSentence;

        while (iss >> word) {
            // Reverse each word and append to the result
            std::reverse(word.begin(), word.end());
            reverseSentence << word << " ";
        }

        // Remove the trailing space and return the result
        return reverseSentence.str().substr(
            0, reverseSentence.str().size() - 1);
    }
};

int main()
{
    std::string input = "geeks quiz practice code";
    std::cout << ReverseSentence::revSentence(input)
              << std::endl;
    return 0;
}

Java

public class ReverseSentence {
    public static String revSentence(String sentence) {
        // Split the string into words
        String[] words = sentence.split(" ");
        StringBuilder reverseSentence = new StringBuilder();

        // Reverse each word and append to the result
        for (String word : words) {
            reverseSentence.append(new StringBuilder(word).reverse().toString()).append(" ");
        }

        // Remove the trailing space and return the result
        return reverseSentence.toString().trim();
    }

    public static void main(String[] args) {
        String input = "geeks quiz practice code";
        System.out.println(revSentence(input));
    }
}
// Contributed by siddhesh

using System;
using System.Text;

public class ReverseSentence {
    // Function to reverse each word in a sentence
    public static string RevSentence(string sentence)
    {
        // Split the string into words
        string[] words = sentence.Split(' ');
        StringBuilder reverseSentence = new StringBuilder();

        // Reverse each word and append to the result
        foreach(string word in words)
        {
            char[] charArray = word.ToCharArray();
            Array.Reverse(charArray);
            reverseSentence.Append(new string(charArray))
                .Append(" ");
        }

        // Remove the trailing space and return the result
        return reverseSentence.ToString().Trim();
    }

    public static void Main()
    {
        string input = "geeks quiz practice code";
        Console.WriteLine(RevSentence(input));
    }
}

Javascript

class ReverseSentence {
    // Function to reverse each word in a sentence
    static revSentence(sentence) {
        // Split the string into words
        const words = sentence.split(' ');

        // Reverse each word and join them back
        const reversedWords = words.map(word => word.split('').reverse().join(''));

        // Join the reversed words into a sentence
        const reversedSentence = reversedWords.join(' ');

        return reversedSentence;
    }
}

const input = "geeks quiz practice code";
console.log(ReverseSentence.revSentence(input));

Python3

def rev_sentence(sentence):

    # first split the string into words
    words = sentence.split(' ')
    reverse_sentence = ""
    for i in words:
        reverse_sentence += i[::-1]+' '
    # then reverse the split string list and join using space

    # finally return the joined string
    return reverse_sentence


if __name__ == "__main__":
    input = 'geeks quiz practice code'
    print(rev_sentence(input))

Output

skeeg ziuq ecitcarp edoc

Time Complexity: O(n)

Auxiliary Space:: O(n)

Method: Using join and split functions

Implementation:

C++

#include <iostream>
#include <vector>
#include <sstream> // Required for std::stringstream

using namespace std;

// Function to reverse words in a string
string reverseWords(string s) {
    stringstream ss(s); // Create a string stream from input string
    string word;
    vector<string> words;

    // Splitting the string into words
    while (ss >> word) {
        // Reversing each word
        string reversedWord = "";
        for (int i = word.length() - 1; i >= 0; i--) {
            reversedWord += word[i];
        }
        // Storing reversed word
        words.push_back(reversedWord);
    }

    // Joining the reversed words back into a string
    string result = "";
    for (int i = 0; i < words.size(); i++) {
        result += words[i];
        if (i != words.size() - 1) {
            result += " ";
        }
    }

    return result;
}

int main() {
    string s = "Geeks for Geeks";

    // Reversing words in the string
    string reversedString = reverseWords(s);

    // Printing the reversed string
    cout << reversedString << endl;

    return 0;
}
//this code is contributed by Adarsh.

Java

import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

public class ReverseWords {
    // Function to reverse words in a string
    static String reverseWords(String s) {
        StringTokenizer tokenizer = new StringTokenizer(s);
        List<String> words = new ArrayList<>();

        // Splitting the string into words
        while (tokenizer.hasMoreTokens()) {
            String word = tokenizer.nextToken();
            // Reversing each word
            StringBuilder reversedWord = new StringBuilder();
            for (int i = word.length() - 1; i >= 0; i--) {
                reversedWord.append(word.charAt(i));
            }
            // Storing reversed word
            words.add(reversedWord.toString());
        }

        // Joining the reversed words back into a string
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < words.size(); i++) {
            result.append(words.get(i));
            if (i != words.size() - 1) {
                result.append(" ");
            }
        }

        return result.toString();
    }

    public static void main(String[] args) {
        String s = "Geeks for Geeks";

        // Reversing words in the string
        String reversedString = reverseWords(s);

        // Printing the reversed string
        System.out.println(reversedString);
    }
}

using System;
using System.Collections.Generic;
using System.Text;

class Program {
    // Function to reverse words in a string
    static string ReverseWords(string s)
    {
        string[] words
            = s.Split(' '); // Split the string into words
        StringBuilder result = new StringBuilder();

        foreach(string word in words)
        {
            // Reverse each word and append to result
            char[] charArray = word.ToCharArray();
            Array.Reverse(charArray);
            result.Append(new string(charArray));
            result.Append(" ");
        }

        // Remove trailing space and return the result
        return result.ToString().Trim();
    }

    static void Main(string[] args)
    {
        string s = "Geeks for Geeks";

        // Reversing words in the string
        string reversedString = ReverseWords(s);

        // Printing the reversed string
        Console.WriteLine(reversedString);
    }
}

Javascript

let s = "Geeks for Geeks";
let words = s.split(' ');

for (let i = 0; i < words.length; i++) {
    // Reversing each word
    words[i] = words[i].split('').reverse().join('');
}

// Joining the words back into a string
let reversedString = words.join(' ');

console.log(reversedString);

Python3

# Python code to reverse words

s = " Geeks for Geeks"
l = []
# splitting the string
s = s.split()
for i in s:
    # reversing each word
    l.append(i[::-1])
# printing string using join

# function after reversing the
# words


print(" ".join(l))

Output

skeeG rof skeeG

Time Complexity: O(n)

Auxiliary Space: O(n)

Suggest improvement

How to Reverse a Stack using Recursion

How to Reverse a String using Stack

Share your thoughts in the comments

Stack implementation in different language

Some questions related to Stack implementation

Easy problems on Stack

Intermediate problems on Stack

Hard problems on Stack

Stack implementation in different language

Some questions related to Stack implementation

Easy problems on Stack

Intermediate problems on Stack

Hard problems on Stack

Reverse individual words

Using stringstream in C++ :

Implementation:

Using Java 8 Streams:

Way 3: Using StringBuffer Class.

Way 4 :

Way 5 : Using Split and iterator

Method: Using join and split functions

Implementation:

Please Login to comment...

Similar Reads

What kind of Experience do you want to share?