151. Reverse Words in a String

 

Reversing Words in a String Using JavaScript

Introduction

Reversing the order of words in a string is a common problem in programming, often encountered in coding interviews and competitive programming. It involves manipulating strings and arrays to achieve the desired result efficiently. In this blog post, we'll explore how to reverse the words in a string using JavaScript. We'll break down the approach, understand the logic, and analyze the complexity of our solution.

Problem Statement

Given a string s, reverse the order of words in the string. A word is defined as a sequence of non-space characters. The words in s will be separated by at least one space.

Intuition

To reverse the order of words in a string, we need to:

  1. Split the string into individual words.

  2. Remove any extra spaces that may exist between the words.

  3. Reverse the order of the words.

  4. Join the words back into a single string.

By breaking the problem down into these steps, we can effectively reverse the order of words in any given string.

Approach

  1. Trim the String:

    • Use the trim() method to remove any leading and trailing whitespace from the string s.

  2. Split into Words:

    • Use the split(" ") method to split the trimmed string into an array of words based on spaces.

  3. Filter Out Empty Strings:

    • Use the filter((e) => e !== '') method to remove any empty strings that may result from consecutive spaces.

  4. Reverse the Array:

    • Use the reverse() method to reverse the order of the elements in the array.

  5. Join Back into a String:

    • Use the join(" ") method to join the elements of the reversed array back into a single string, with each word separated by a space.

Example Code

Here's the complete JavaScript code for reversing the words in a string:

javascript
var reverseWords = function(s) {
    return s.trim()
    .split(" ")
    .filter((e) => e !== '')
    .reverse()
    .join(" ");
};

How It Works

Let's walk through an example to understand how the code works:

javascript
console.log(reverseWords("  hello world  ")); // Output: "world hello"
console.log(reverseWords("a good   example")); // Output: "example good a"

  1. Trim: Removes extra spaces at the beginning and end of the string.

  2. Split: Converts the string into an array of words.

  3. Filter: Removes any empty strings from the array.

  4. Reverse: Reverses the order of the words in the array.

  5. Join: Joins the words back into a single string, with each word separated by a single space.

Complexity Analysis

Time Complexity: O(n)

  • The time complexity is O(n), where n is the length of the input string s. This is because each method (trim(), split(), filter(), reverse(), and join()) processes each character or word once.

Space Complexity: O(n)

  • The space complexity is O(n) because we create an array to hold the words from the input string and then produce a new string as the output, both of which require space proportional to the length of the input string.

Conclusion

This solution efficiently reverses the order of words in a string by leveraging JavaScript's built-in string and array methods. The approach ensures that the solution is both time-efficient and space-efficient, making it suitable for a wide range of input sizes.

Feel free to try out this solution in your projects or coding challenges. If you have any questions or suggestions, feel free to leave a comment. Happy coding!

Leetcode Solution Link : Reverse Words in a String - LeetCode

Comments

Post a Comment

Popular posts from this blog

3Sum Closest: O(n²) Two-Pointer Magic šŸš€ leetcode: 16

Three Sum Closest - LeetCode Solution In this blog post, we'll dive into the Three Sum Closest problem, a popular coding challenge on LeetCode. We'll explore the intuition behind the solution, discuss the approach, analyze the complexity, and provide a detailed explanation of the code. Additionally, I'll share my LeetCode solution link for further reference. Problem Statement Given an integer array nums of length n and an integer target , find three integers in nums such that the sum is closest to target . Return the sum of the three integers. You may assume that each input would have exactly one solution. Intuition The problem requires finding three numbers in the array whose sum is as close as possible to the target. To efficiently find such a triplet, we can use a combination of sorting and the two-pointer technique . Sorting : First, sort the array. This allows us to use the two-po...
Read more

Kadane's Algorithm: Maximum Subarray Problem - LeetCode(53) Solution

Maximum Subarray Problem - LeetCode Solution Maximum Subarray Problem - LeetCode Solution Problem Statement Given an integer array nums , find the contiguous subarray (containing at least one number) that has the largest sum and return its sum. Intuition The problem requires finding the contiguous subarray with the maximum sum. A brute force approach would involve checking all subarrays, but this would be inefficient. Instead, we use Kadane's Algorithm , which efficiently finds the maximum sum subarray in O(n) time. Approach Initialize two variables: total (running sum) and maxi (maximum sum encountered so far). Iterate through the array: Add the current element to total . Update maxi with the maximum of maxi and total . If total becomes negative, reset it to zero. Return maxi as the maximum sub...
Read more

14. Longest Common Prefix

  Finding the Longest Common Prefix in JavaScript When working with arrays of strings, a common problem is finding the longest common prefix among these strings. The longest common prefix is the initial portion of all strings in the array that is identical. This is a frequent problem on coding platforms like LeetCode, and it's essential to understand how to tackle it efficiently. In this blog post, we'll dive into the intuition, approach, and complexity of finding the longest common prefix in JavaScript. Intuition The intuition behind finding the longest common prefix is simple. By sorting the array of strings lexicographically (alphabetically), we can bring the smallest and largest strings to the beginning and end of the array. The common prefix between the first and last string in this sorted array will give us the longest common prefix for the entire array. This approach leverages the natural order of strings to simplify our task. Approach Sort the Array : First, we sort the...
Read more