Swap Corner Words and Reverse Middle Characters in Java

Swapping corner words and reversing middle characters in Java exemplify a creative approach to string manipulation, a fundamental programming aspect. The task involves altering the positions of the first and last words in a string while inverting the order of the characters nestled between them.

Example 1:

Input: "Java programming language tutorial"

Output: "tutorial egaugnal gnimmargorp Java"

Example 2:

Input: "Data structures and algorithms"

Output: "algorithms dna serutcurts Data"

Example 3:

Input: "Machine learning is fascinating"

Output: "fascinating si gninrael Machine"

Approach: Using ASCII values

The Java code for swapping corner words and reversing a string's middle characters leverages Java's string manipulation capabilities, not ASCII values. It utilizes character traversal and string concatenation to effect changes, showcasing a straightforward approach over low-level ASCII manipulations for text processing. The method underscores the efficiency of using built-in string functions for common string operations.

Algorithm:

Step 1: Input a string inputString and calculate its length stringLength.

Step 2: Initialize two empty strings, firstWord and lastWord, for the corner words.

Step 3: Use a loop to identify lastWord by traversing from the start until the first space is encountered.

Step 4: Use another loop to identify firstWord by traversing from the end backwards until the first space is encountered from that end.

Step 5: Initialize an empty string middleReversed for the reversed middle section.

Step 6: Reverse the middle section (excluding the first and last words) by traversing it backward and appending each character to middleReversed. Include spaces as they are encountered.

Step 7: Concatenate firstWord, middleReversed, and lastWord with spaces between them to form the final String.

Implementation:

Filename: StringSwapper.java

// Importing necessary standard libraries
import java.util.*;
import java.io.*;

// Definition of the class named StringSwapper
public class StringSwapper {

    // Static method to swap corner words and reverse the middle section of a string
    static void swapCornersAndReverseMiddle(String inputString, int stringLength)
    {
        // Initialize a variable to store the first word
        String firstWord = "";
        // Initialize a variable to store the last word
        String lastWord = "";

        // Variable to track the start index of the String
        int startIdx = 0;

        // Loop to find and store the last word
        for (startIdx = 0; startIdx < stringLength; ++startIdx) {
            // Check for space to identify the end of the last word
            if (inputString.charAt(startIdx) == ' ') {
                break; // Exit loop once space is found
            }
            // Append character to lastWord until a space is found
            lastWord += inputString.charAt(startIdx);
        }

        // Variable to track the end index of the String
        int endIdx = 0;

        // Loop to find and store the first word in reverse order
        for (endIdx = stringLength - 1; endIdx >= 0; --endIdx) {
            // Check for space to identify the start of the first word
            if (inputString.charAt(endIdx) == ' ') {
                break; // Exit loop once space is found
            }
            // Prepend character to firstWord to reverse the order
            firstWord = inputString.charAt(endIdx) + firstWord;
        }

        // Initialize a variable to store the reversed middle section
        String middleReversed = "";
        // Loop to reverse the middle section, excluding the first and last word
        for (int i = endIdx - 1; i > startIdx; --i) {
            // Check for space
            if (inputString.charAt(i) == ' ') {
                middleReversed += " "; // Add space to middleReversed
            }
            else {
                // Reverse the characters by adding them to middleReversed
                middleReversed += inputString.charAt(i);
            }
        }

        // Print the final String with swapped corner words and reversed middle section
        System.out.println("Swapped and Reversed String: " + firstWord + " " + middleReversed + " " + lastWord);
    }

    // Main driver method
    public static void main(String[] args)
    {
        // Define a sample input string to be manipulated
        String sampleInput = "Java programming language tutorial";
        // Calculate and store the length of the input string
        int inputLength = sampleInput.length();
        // Call the method to perform the swap and reverse operation
        swapCornersAndReverseMiddle(sampleInput, inputLength);
    }
}

Output:

Swapped and Reversed String: tutorial egaugnal gnimmargorp Java

Time Complexity:

O(n): Linear, due to operations that scale with the input string's length.

Auxiliary Space:

O(1): Considered constant, focusing on the algorithm's inherent logic rather than the space for processed data.

Approach: Using the split() method

The approach used in the split() method from the String class for manipulating a given string by swapping its corner words and reversing the characters in the middle section.

Algorithm:

Step 1: Define a method performSwapAndReverse that takes a string input and its length size as parameters.

Step 2: Split input into an array of words and Store the first word in a temporary variable temp.

Step 3: Swap the first and last words in the array and Reassign the last word to temp.

Step 4: Initialize an empty string reversedMiddle.

Step 5: For each word from the second to the second-last, reverse it and append it to reversedMiddle.

Step 6: Print the modified String: swapped first and last words with reversedMiddle in between.

Step 7: In the main method, define a sample input string exampleInput. Calculate the length of exampleInput and store it in inputSize.

Step 8: Call performSwapAndReverse with exampleInput and inputSize.

Implementation:

Filename: StringManipulation.java

// Import standard libraries for input/output operations and utility functions.
import java.io.*;
import java.util.*;

// Declare the class for string manipulation.
public class StringManipulation {

    // Define a method to swap the first and last words of the input string and reverse its middle section.
    static void performSwapAndReverse(String input, int size) {
        // Split the input string into an array of words.
        String words[] = input.split(" ");
        // Store the first word in a temporary variable.
        String temp = words[0];
        // Swap the first word with the last word in the array.
        words[0] = words[words.length - 1];
        // Place the originally first word at the last position.
        words[words.length - 1] = temp;

        // Initialize an empty string to build the reversed middle section.
        String reversedMiddle = "";

        // Iterate backwards through the array from the second last to the second word.
        for (int i = words.length - 2; i >= 1; --i) {
            // Store the current word in a variable.
            String currentWord = words[i];

            // Reverse the current word by iterating through its characters backwards.
            for (int j = currentWord.length() - 1; j >= 0; --j) {
                // Append each character to the reversedMiddle String.
                reversedMiddle += currentWord.charAt(j);
            }
            // Append a space after each reversed word in the middle section.
            reversedMiddle += " ";
        }

        // Print the modified String with swapped corner words and the reversed middle section.
        // Trim is used to remove the trailing space for formatting.
        System.out.println("Modified String: " + words[0] + " " + reversedMiddle.trim() + " " + words[words.length - 1]);
    }

    // The main method where the program execution begins.
    public static void main(String[] args) {
        // Define the input string to be manipulated.
        String exampleInput = "Swap and reverse example in Java";
        // Calculate and store the length of the input string.
        int inputSize = exampleInput.length();
        // Call the performSwapAndReverse method with the input string and its size.
        performSwapAndReverse(exampleInput, inputSize);
    }
}

Output:

Modified String: Java ni elpmaxe esrever dna Swap

Time Complexity: The time complexity of the above code is O(n). The code's time complexity is linear due to the need to split the String and reverse the middle characters, which depends on the input string's length.

Auxiliary Space: The code has the auxiliary space of O(n). The auxiliary space is linear, driven by the storage needed for the array of words from the split operation and the String for the reversed middle section.

Next TopicKadane's Algorithm in Java

← prev next →