Given a string containing n numbers of words. The task is to swap the corner words of the string and reverses all the middle characters of the string.
Input: "Hello this is the GFG user" Output: "user GFG eth si siht Hello" Input: "Hello Bye" Output: "Bye Hello"
Methods:
- Using the concept of ASCII values
- Using the split() method
Method 1: Using the concept of ASCII values
We handle the position of space between the words using ASCII values. The ASCII value of space is 32.
- Create two string variables and two pointers lets name as index and index1
- Iterate the first loop using the index address variable till the first space and store all the characters in a string variable named First.
- Iterate another loop from reverse order using the index1 address variable till the first space and store all the characters in another string variable name as last.
- Now, we have the address variables index1 and index that both point to the next starting and ending position of the middle characters of the given string.
- Using both pointers store all the characters in reverse order in a third-string variable named as middle.
- Print the last string then the middle string then the first string.
Example:
// Java Program to Swap Corner Words and Reverse Middle // Characters // Importing utility classes import java.util.*;
// Importing input output classes import java.io.*;
// Main class public class GFG {
// Method 1
// To swap corners words
static void swap(String m, int length)
{
// Declaring string variables to
// store the first and last characters
String first = "" ;
String last = "" ;
// Creating first address variable
// Initially initializing with zero
int index = 0 ;
for (index = 0 ; index < length; ++index) {
// Checking the space
if (m.charAt(index) == 32 ) {
break ;
}
// Storing the last word in the last variable
last += m.charAt(index);
}
// Now creating second address variable
// Initially initializing with zero
int index1 = 0 ;
for (index1 = length - 1 ; index1 >= 0 ; --index1) {
if (m.charAt(index1) == 32 ) {
break ;
}
// Storing the First word of the given string
first = m.charAt(index1) + first;
}
String middle = "" ;
for ( int i = index1 - 1 ; i > index; --i) {
if (m.charAt(i) == 32 ) {
middle += " " ;
}
else {
// Storing all the middle words
middle += m.charAt(i);
}
}
// Print and display all the string variables
System.out.print(first + " " + middle + " " + last);
}
// Method 2
// Main driver method
public static void main(String[] args)
{
// Given custom input string
String m = "Hello this is the GFG" ;
// Calculating string length using length() method
// and storing it in a variable
int length = m.length();
// Calling the method 1 to swap the words
// for our custom input string
swap(m, length);
}
} |
GFG eht si siht Hello
Time Complexity: O(n) where n is the length of the string
Auxiliary Space: O(1)
Method 2: Using the split() method
The string split() method breaks a given string around matches of the given regular expression.
Illustration:
Input : 016-78967 Processing : Regular Expression Output : {"016", "78967"}
Procedure:
- Store all the words in an array using split() method.
- Swap the last and first element of the array.
- Iterate the loop from the second position to the last second position.
- Store all the characters in the reverse order name as the middle variable.
- Print the first element of the array then the middle variable then the last element of the array.
Example:
// Java Program to Swap Corner Words and Reverse Middle // Characters // Importing utility classes // Importing input output classes import java.io.*;
import java.util.*;
// Main class public class GFG {
// Method 1
// To swap the words in a string
static void swap(String m, int length)
{
// Storing the words in the array
String msg[] = m.split( " " );
// Now swap the position of the first and the last
// character in the string array
String temp = msg[ 0 ];
msg[ 0 ] = msg[msg.length - 1 ];
msg[msg.length - 1 ] = temp;
// Declaring and initializing string for
// middle string empty middle string
String mid = "" ;
for ( int i = msg.length - 2 ; i >= 1 ; --i) {
String temp_s = msg[i];
// Now storing the middle words in reverse order
for ( int j = temp_s.length() - 1 ; j >= 0 ; --j) {
mid += temp_s.charAt(j);
}
mid += " " ;
}
// Lastly print the swapped and reversed words
System.out.print(msg[ 0 ] + " " + mid + " "
+ msg[msg.length - 1 ]);
}
// Method 2
// Main driver method
public static void main(String[] args)
{
// Custom input string
String m = "Hello this is the GFG" ;
// Calculating length using length() method and
// storing it
int length = m.length();
// Calling the method 1 over custom input string to
// get swapped corner words with reverse middle
// characters
swap(m, length);
}
} |
GFG eht si siht Hello
Time Complexity: O(n) where n is the length of the string
Auxiliary Space: O(n) where n is the length of the string