From 21b5adef5f2811c884814c0cf397021359005ff4 Mon Sep 17 00:00:00 2001 From: suchib Date: Fri, 22 Sep 2023 21:58:00 +0530 Subject: [PATCH 01/20] return a string of the words in reverse order concatenated by a single space. Input: s = "the sky is blue" Output: "blue is sky the" --- .../strings/ReverseWordInString.java | 38 +++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 src/main/java/com/thealgorithms/strings/ReverseWordInString.java diff --git a/src/main/java/com/thealgorithms/strings/ReverseWordInString.java b/src/main/java/com/thealgorithms/strings/ReverseWordInString.java new file mode 100644 index 000000000000..f869eab9dfd6 --- /dev/null +++ b/src/main/java/com/thealgorithms/strings/ReverseWordInString.java @@ -0,0 +1,38 @@ +package com.thealgorithms.strings; + +public class ReverseWordInString { + + public static void main(String[] args) { + + System.out.println(reverseWords("the sky is blue")); + } + + public static String reverseWords(String s) { + + s = s.trim(); + + String res = ""; + int start = 0; + int end; + + while (start < s.length()) { + while (s.charAt(start) == ' ') { + start++; + } + end = start + 1; + + while (end < s.length() && (s.charAt(end) != ' ')) { + end++; + } + + String sub = s.substring(start, end); + start = end; + if (res.isEmpty()) { + res = sub; + } else { + res = sub + " " + res; + } + } + return res; + } +} From 5658b7f1088449699223948d7ed3a6ad4c5635bf Mon Sep 17 00:00:00 2001 From: suchib Date: Fri, 22 Sep 2023 22:03:58 +0530 Subject: [PATCH 02/20] return a string of the words in reverse order concatenated by a single space. Input: s = "the sky is blue" Output: "blue is sky the" --- .../com/thealgorithms/strings/ReverseWordInString.java | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/main/java/com/thealgorithms/strings/ReverseWordInString.java b/src/main/java/com/thealgorithms/strings/ReverseWordInString.java index f869eab9dfd6..27ef8f4898b1 100644 --- a/src/main/java/com/thealgorithms/strings/ReverseWordInString.java +++ b/src/main/java/com/thealgorithms/strings/ReverseWordInString.java @@ -1,5 +1,15 @@ package com.thealgorithms.strings; + +/** + Given an input string s, reverse the order of the words. + A word is defined as a sequence of non-space characters. + The words in s will be separated by at least one space. + Return a string of the words in reverse order concatenated by a single space. + Note that s may contain leading or trailing spaces or multiple spaces between two words. + The returned string should only have a single space separating the words.Do not include any extra spaces + */ + public class ReverseWordInString { public static void main(String[] args) { From 4ac4044a3b87094c00b757d76bece7189e89e486 Mon Sep 17 00:00:00 2001 From: suchib Date: Sun, 1 Oct 2023 01:25:10 +0530 Subject: [PATCH 03/20] space reduce --- src/main/java/com/thealgorithms/strings/ReverseWordInString.java | 1 - 1 file changed, 1 deletion(-) diff --git a/src/main/java/com/thealgorithms/strings/ReverseWordInString.java b/src/main/java/com/thealgorithms/strings/ReverseWordInString.java index 27ef8f4898b1..a0beb69d3ac9 100644 --- a/src/main/java/com/thealgorithms/strings/ReverseWordInString.java +++ b/src/main/java/com/thealgorithms/strings/ReverseWordInString.java @@ -1,6 +1,5 @@ package com.thealgorithms.strings; - /** Given an input string s, reverse the order of the words. A word is defined as a sequence of non-space characters. From 781d0f086170415562209cbcc193123b5f9bcee1 Mon Sep 17 00:00:00 2001 From: suchib Date: Sun, 1 Oct 2023 13:19:11 +0530 Subject: [PATCH 04/20] removed main method --- .../java/com/thealgorithms/strings/ReverseWordInString.java | 6 ------ 1 file changed, 6 deletions(-) diff --git a/src/main/java/com/thealgorithms/strings/ReverseWordInString.java b/src/main/java/com/thealgorithms/strings/ReverseWordInString.java index a0beb69d3ac9..87e882b2d497 100644 --- a/src/main/java/com/thealgorithms/strings/ReverseWordInString.java +++ b/src/main/java/com/thealgorithms/strings/ReverseWordInString.java @@ -11,15 +11,9 @@ public class ReverseWordInString { - public static void main(String[] args) { - - System.out.println(reverseWords("the sky is blue")); - } - public static String reverseWords(String s) { s = s.trim(); - String res = ""; int start = 0; int end; From 9f04fbdb75afc26351178853a85fb0b85a4a0af4 Mon Sep 17 00:00:00 2001 From: suchib Date: Sun, 1 Oct 2023 13:36:16 +0530 Subject: [PATCH 05/20] added test cases --- .../strings/ReverseWordInStringTest.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 src/test/java/com/thealgorithms/strings/ReverseWordInStringTest.java diff --git a/src/test/java/com/thealgorithms/strings/ReverseWordInStringTest.java b/src/test/java/com/thealgorithms/strings/ReverseWordInStringTest.java new file mode 100644 index 000000000000..c623407838f3 --- /dev/null +++ b/src/test/java/com/thealgorithms/strings/ReverseWordInStringTest.java @@ -0,0 +1,14 @@ +package com.thealgorithms.strings; + +import static org.junit.jupiter.api.Assertions.assertEquals; + + +import org.junit.jupiter.api.Test; + +public class ReverseWordInStringTest { + + @Test + public void testCorrectReverseWordsInTheString() { + assertEquals("blue is Sky", ReverseWordInString.reverseWords("Sky is blue")); + } +} From 73c67789b3f3425cd395a863317841bf414a1e66 Mon Sep 17 00:00:00 2001 From: suchib Date: Sun, 1 Oct 2023 15:22:37 +0530 Subject: [PATCH 06/20] formatting fix --- .../java/com/thealgorithms/strings/ReverseWordInStringTest.java | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/test/java/com/thealgorithms/strings/ReverseWordInStringTest.java b/src/test/java/com/thealgorithms/strings/ReverseWordInStringTest.java index c623407838f3..909fb7caf292 100644 --- a/src/test/java/com/thealgorithms/strings/ReverseWordInStringTest.java +++ b/src/test/java/com/thealgorithms/strings/ReverseWordInStringTest.java @@ -1,8 +1,6 @@ package com.thealgorithms.strings; import static org.junit.jupiter.api.Assertions.assertEquals; - - import org.junit.jupiter.api.Test; public class ReverseWordInStringTest { From 5e84c5f6d41c950ca7bf515e445b637e5ac6ce33 Mon Sep 17 00:00:00 2001 From: suchib Date: Sun, 1 Oct 2023 16:14:13 +0530 Subject: [PATCH 07/20] formatting fix --- .../java/com/thealgorithms/strings/ReverseWordInStringTest.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/test/java/com/thealgorithms/strings/ReverseWordInStringTest.java b/src/test/java/com/thealgorithms/strings/ReverseWordInStringTest.java index 909fb7caf292..abb587760fa9 100644 --- a/src/test/java/com/thealgorithms/strings/ReverseWordInStringTest.java +++ b/src/test/java/com/thealgorithms/strings/ReverseWordInStringTest.java @@ -1,6 +1,7 @@ package com.thealgorithms.strings; import static org.junit.jupiter.api.Assertions.assertEquals; + import org.junit.jupiter.api.Test; public class ReverseWordInStringTest { From 614a8996c9967a382fe13965a5c8636b92c3f2bc Mon Sep 17 00:00:00 2001 From: suchib Date: Mon, 2 Oct 2023 09:04:03 +0530 Subject: [PATCH 08/20] worked on pr reviews --- .../strings/ReverseWordInString.java | 41 ------------------ .../strings/ReverseWordsInString.java | 43 +++++++++++++++++++ .../strings/ReverseWordInStringTest.java | 7 ++- 3 files changed, 49 insertions(+), 42 deletions(-) delete mode 100644 src/main/java/com/thealgorithms/strings/ReverseWordInString.java create mode 100644 src/main/java/com/thealgorithms/strings/ReverseWordsInString.java diff --git a/src/main/java/com/thealgorithms/strings/ReverseWordInString.java b/src/main/java/com/thealgorithms/strings/ReverseWordInString.java deleted file mode 100644 index 87e882b2d497..000000000000 --- a/src/main/java/com/thealgorithms/strings/ReverseWordInString.java +++ /dev/null @@ -1,41 +0,0 @@ -package com.thealgorithms.strings; - -/** - Given an input string s, reverse the order of the words. - A word is defined as a sequence of non-space characters. - The words in s will be separated by at least one space. - Return a string of the words in reverse order concatenated by a single space. - Note that s may contain leading or trailing spaces or multiple spaces between two words. - The returned string should only have a single space separating the words.Do not include any extra spaces - */ - -public class ReverseWordInString { - - public static String reverseWords(String s) { - - s = s.trim(); - String res = ""; - int start = 0; - int end; - - while (start < s.length()) { - while (s.charAt(start) == ' ') { - start++; - } - end = start + 1; - - while (end < s.length() && (s.charAt(end) != ' ')) { - end++; - } - - String sub = s.substring(start, end); - start = end; - if (res.isEmpty()) { - res = sub; - } else { - res = sub + " " + res; - } - } - return res; - } -} diff --git a/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java b/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java new file mode 100644 index 000000000000..ea447136f1c8 --- /dev/null +++ b/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java @@ -0,0 +1,43 @@ +package com.thealgorithms.strings; + +/** + * Given an input string s, reverse the order of the words. + * A word is defined as a sequence of non-space characters. + * The words in s will be separated by at least one space. + * Return a string of the words in reverse order concatenated by a single space. + * Note that s may contain leading or trailing spaces or multiple spaces between two words. + * The returned string should only have a single space separating the words.Do not include any extra spaces + */ + +public final class ReverseWordsInString { + + public static String reverseWordsInString(String s) { + + s = s.replaceAll("\\s+"," ").trim(); + StringBuilder res = new StringBuilder(); + int start = 0; + int end; + + while (start < s.length()) { + while (s.charAt(start) == ' ') { + start++; + } + end = start + 1; + + while (end < s.length() && (s.charAt(end) != ' ')) { + end++; + } + + String sub = s.substring(start, end); + start = end; + + if (res.length() > 0) { + res.insert(0, " "); + res.insert(0, sub); + } else { + res.append(sub); + } + } + return res.toString(); + } +} diff --git a/src/test/java/com/thealgorithms/strings/ReverseWordInStringTest.java b/src/test/java/com/thealgorithms/strings/ReverseWordInStringTest.java index abb587760fa9..7f78ac4786c5 100644 --- a/src/test/java/com/thealgorithms/strings/ReverseWordInStringTest.java +++ b/src/test/java/com/thealgorithms/strings/ReverseWordInStringTest.java @@ -8,6 +8,11 @@ public class ReverseWordInStringTest { @Test public void testCorrectReverseWordsInTheString() { - assertEquals("blue is Sky", ReverseWordInString.reverseWords("Sky is blue")); + assertEquals("blue is Sky", ReverseWordsInString.reverseWordsInString("Sky is blue")); + } + + @Test + public void testReverseWordsInStringForEmpty() { + assertEquals("", ReverseWordsInString.reverseWordsInString("")); } } From 5ee6cf0cf8e981d8264460f0bf0235557ad15cee Mon Sep 17 00:00:00 2001 From: suchib Date: Mon, 2 Oct 2023 09:06:46 +0530 Subject: [PATCH 09/20] formatting fix --- .../java/com/thealgorithms/strings/ReverseWordsInString.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java b/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java index ea447136f1c8..d753d030b29e 100644 --- a/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java +++ b/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java @@ -13,7 +13,7 @@ public final class ReverseWordsInString { public static String reverseWordsInString(String s) { - s = s.replaceAll("\\s+"," ").trim(); + s = s.replaceAll("\\s+", " ").trim(); StringBuilder res = new StringBuilder(); int start = 0; int end; From e8cce5dd9473e9c395b9e0eed92195a76bbfe76e Mon Sep 17 00:00:00 2001 From: suchib Date: Mon, 2 Oct 2023 10:13:06 +0530 Subject: [PATCH 10/20] private constructor added --- .../java/com/thealgorithms/strings/ReverseWordsInString.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java b/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java index d753d030b29e..7d5901bef5b0 100644 --- a/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java +++ b/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java @@ -11,6 +11,9 @@ public final class ReverseWordsInString { + private ReverseWordsInString() { + } + public static String reverseWordsInString(String s) { s = s.replaceAll("\\s+", " ").trim(); From 43191a7cc2a1728f05733e61488bd2fbba132198 Mon Sep 17 00:00:00 2001 From: suchib Date: Mon, 2 Oct 2023 12:35:13 +0530 Subject: [PATCH 11/20] added test case for when string contains white space --- .../com/thealgorithms/strings/ReverseWordInStringTest.java | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/test/java/com/thealgorithms/strings/ReverseWordInStringTest.java b/src/test/java/com/thealgorithms/strings/ReverseWordInStringTest.java index 7f78ac4786c5..5a019ee9477f 100644 --- a/src/test/java/com/thealgorithms/strings/ReverseWordInStringTest.java +++ b/src/test/java/com/thealgorithms/strings/ReverseWordInStringTest.java @@ -11,6 +11,11 @@ public void testCorrectReverseWordsInTheString() { assertEquals("blue is Sky", ReverseWordsInString.reverseWordsInString("Sky is blue")); } + @Test + public void testCorrectReverseWordsInTheStringWithWhiteSpace() { + assertEquals("blue is Sky", ReverseWordsInString.reverseWordsInString("Sky \n is \n \n blue")); + } + @Test public void testReverseWordsInStringForEmpty() { assertEquals("", ReverseWordsInString.reverseWordsInString("")); From 9182386540b10eaf7735b030b721fa2c9073bcf4 Mon Sep 17 00:00:00 2001 From: suchib Date: Mon, 2 Oct 2023 12:58:15 +0530 Subject: [PATCH 12/20] simplified method --- .../strings/ReverseWordsInString.java | 24 ++++++++++++------- 1 file changed, 15 insertions(+), 9 deletions(-) diff --git a/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java b/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java index 7d5901bef5b0..187444b74b4d 100644 --- a/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java +++ b/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java @@ -19,19 +19,12 @@ public static String reverseWordsInString(String s) { s = s.replaceAll("\\s+", " ").trim(); StringBuilder res = new StringBuilder(); int start = 0; - int end; + int end = 0; while (start < s.length()) { - while (s.charAt(start) == ' ') { - start++; - } - end = start + 1; - while (end < s.length() && (s.charAt(end) != ' ')) { - end++; - } + String sub = findNextWord(s, start, end); - String sub = s.substring(start, end); start = end; if (res.length() > 0) { @@ -43,4 +36,17 @@ public static String reverseWordsInString(String s) { } return res.toString(); } + + private static String findNextWord(String s, int start, int end) { + while (s.charAt(start) == ' ') { + start++; + } + end = start + 1; + + while (end < s.length() && (s.charAt(end) != ' ')) { + end++; + } + + return s.substring(start, end); + } } From 72fc5f1ba90710f3225ee70abf04d53f59e81f89 Mon Sep 17 00:00:00 2001 From: suchib Date: Tue, 3 Oct 2023 21:01:38 +0530 Subject: [PATCH 13/20] fix issue --- .../strings/ReverseWordsInString.java | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java b/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java index 187444b74b4d..a4d207e5b1ce 100644 --- a/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java +++ b/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java @@ -23,21 +23,25 @@ public static String reverseWordsInString(String s) { while (start < s.length()) { - String sub = findNextWord(s, start, end); + Integer[] arr = findNextWord(s, start, end); + + end = arr[1]; + + String word = s.substring(start, end); start = end; if (res.length() > 0) { res.insert(0, " "); - res.insert(0, sub); + res.insert(0, word); } else { - res.append(sub); + res.append(word); } } return res.toString(); } - private static String findNextWord(String s, int start, int end) { + private static Integer[] findNextWord(String s, int start, int end) { while (s.charAt(start) == ' ') { start++; } @@ -47,6 +51,6 @@ private static String findNextWord(String s, int start, int end) { end++; } - return s.substring(start, end); + return new Integer[]{start, end}; } } From f7d4ee481bdab938f35b87918c8235cc16a0a1c8 Mon Sep 17 00:00:00 2001 From: suchib Date: Tue, 3 Oct 2023 21:03:54 +0530 Subject: [PATCH 14/20] formatting issues fix --- .../java/com/thealgorithms/strings/ReverseWordsInString.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java b/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java index a4d207e5b1ce..982c03a12bf8 100644 --- a/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java +++ b/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java @@ -51,6 +51,6 @@ private static Integer[] findNextWord(String s, int start, int end) { end++; } - return new Integer[]{start, end}; + return new Integer[] {start, end}; } } From b38b34732fb8ae139971fd0f390715f6ad5203a7 Mon Sep 17 00:00:00 2001 From: suchib Date: Tue, 3 Oct 2023 21:16:20 +0530 Subject: [PATCH 15/20] fixed issue --- .../java/com/thealgorithms/strings/ReverseWordsInString.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java b/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java index 982c03a12bf8..6c0ef0fe5203 100644 --- a/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java +++ b/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java @@ -24,7 +24,7 @@ public static String reverseWordsInString(String s) { while (start < s.length()) { Integer[] arr = findNextWord(s, start, end); - + start = arr[0]; end = arr[1]; String word = s.substring(start, end); From c7b5adc5f886a8d6b144da1e03489862ca19a993 Mon Sep 17 00:00:00 2001 From: suchib Date: Thu, 5 Oct 2023 17:00:51 +0530 Subject: [PATCH 16/20] code refactor --- .../strings/ReverseWordsInString.java | 45 +++---------------- ...est.java => ReverseWordsInStringTest.java} | 2 +- 2 files changed, 8 insertions(+), 39 deletions(-) rename src/test/java/com/thealgorithms/strings/{ReverseWordInStringTest.java => ReverseWordsInStringTest.java} (94%) diff --git a/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java b/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java index 6c0ef0fe5203..bfc7ae287d83 100644 --- a/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java +++ b/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java @@ -1,5 +1,8 @@ package com.thealgorithms.strings; +import java.util.Arrays; +import java.util.Collections; + /** * Given an input string s, reverse the order of the words. * A word is defined as a sequence of non-space characters. @@ -14,43 +17,9 @@ public final class ReverseWordsInString { private ReverseWordsInString() { } - public static String reverseWordsInString(String s) { - - s = s.replaceAll("\\s+", " ").trim(); - StringBuilder res = new StringBuilder(); - int start = 0; - int end = 0; - - while (start < s.length()) { - - Integer[] arr = findNextWord(s, start, end); - start = arr[0]; - end = arr[1]; - - String word = s.substring(start, end); - - start = end; - - if (res.length() > 0) { - res.insert(0, " "); - res.insert(0, word); - } else { - res.append(word); - } - } - return res.toString(); - } - - private static Integer[] findNextWord(String s, int start, int end) { - while (s.charAt(start) == ' ') { - start++; - } - end = start + 1; - - while (end < s.length() && (s.charAt(end) != ' ')) { - end++; - } - - return new Integer[] {start, end}; + public static String reverseWordsInString(final String s) { + var words = s.trim().split("\\s+"); + Collections.reverse(Arrays.asList(words)); + return String.join(" ", words); } } diff --git a/src/test/java/com/thealgorithms/strings/ReverseWordInStringTest.java b/src/test/java/com/thealgorithms/strings/ReverseWordsInStringTest.java similarity index 94% rename from src/test/java/com/thealgorithms/strings/ReverseWordInStringTest.java rename to src/test/java/com/thealgorithms/strings/ReverseWordsInStringTest.java index 5a019ee9477f..9fab4d6ed2ed 100644 --- a/src/test/java/com/thealgorithms/strings/ReverseWordInStringTest.java +++ b/src/test/java/com/thealgorithms/strings/ReverseWordsInStringTest.java @@ -4,7 +4,7 @@ import org.junit.jupiter.api.Test; -public class ReverseWordInStringTest { +public class ReverseWordsInStringTest { @Test public void testCorrectReverseWordsInTheString() { From 6a406f550ca25193e11a21178eda2809d2bf8018 Mon Sep 17 00:00:00 2001 From: suchib Date: Fri, 6 Oct 2023 11:27:05 +0530 Subject: [PATCH 17/20] documented method --- .../strings/ReverseWordsInString.java | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java b/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java index bfc7ae287d83..f261a9b1541f 100644 --- a/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java +++ b/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java @@ -3,20 +3,19 @@ import java.util.Arrays; import java.util.Collections; -/** - * Given an input string s, reverse the order of the words. - * A word is defined as a sequence of non-space characters. - * The words in s will be separated by at least one space. - * Return a string of the words in reverse order concatenated by a single space. - * Note that s may contain leading or trailing spaces or multiple spaces between two words. - * The returned string should only have a single space separating the words.Do not include any extra spaces - */ public final class ReverseWordsInString { private ReverseWordsInString() { } + /** + * Reverse word in the string + * + * @param s contains sentence + @return Reverse word of {@code s} + */ + public static String reverseWordsInString(final String s) { var words = s.trim().split("\\s+"); Collections.reverse(Arrays.asList(words)); From bec0c45d8279fd29fb434f84c8cc00ae20d926ed Mon Sep 17 00:00:00 2001 From: suchib Date: Fri, 6 Oct 2023 16:15:16 +0530 Subject: [PATCH 18/20] worked on pr comments --- .../com/thealgorithms/strings/ReverseWordsInString.java | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java b/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java index f261a9b1541f..4a3ec034875c 100644 --- a/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java +++ b/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java @@ -3,17 +3,15 @@ import java.util.Arrays; import java.util.Collections; - public final class ReverseWordsInString { private ReverseWordsInString() { } /** - * Reverse word in the string - * - * @param s contains sentence - @return Reverse word of {@code s} + * @brief Reverses words in the input string + * @param s the input string + * @return A string created by reversing the order of the words in{@code s} */ public static String reverseWordsInString(final String s) { From 4ee75ab679ec67001b5e1e8755ee3dbff2e8f0ac Mon Sep 17 00:00:00 2001 From: Piotr Idzik <65706193+vil02@users.noreply.github.com> Date: Fri, 6 Oct 2023 20:01:28 +0200 Subject: [PATCH 19/20] docs: add missing space --- .../java/com/thealgorithms/strings/ReverseWordsInString.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java b/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java index 4a3ec034875c..5f9d27b4e9e2 100644 --- a/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java +++ b/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java @@ -11,7 +11,7 @@ private ReverseWordsInString() { /** * @brief Reverses words in the input string * @param s the input string - * @return A string created by reversing the order of the words in{@code s} + * @return A string created by reversing the order of the words in {@code s} */ public static String reverseWordsInString(final String s) { From 6bdd7d913c7b539a72290bfe7dc36df99f59e343 Mon Sep 17 00:00:00 2001 From: vil02 Date: Fri, 6 Oct 2023 20:09:34 +0200 Subject: [PATCH 20/20] tests: express as `ParameterizedTest` --- .../strings/ReverseWordsInStringTest.java | 25 ++++++++----------- 1 file changed, 11 insertions(+), 14 deletions(-) diff --git a/src/test/java/com/thealgorithms/strings/ReverseWordsInStringTest.java b/src/test/java/com/thealgorithms/strings/ReverseWordsInStringTest.java index 9fab4d6ed2ed..44e397459349 100644 --- a/src/test/java/com/thealgorithms/strings/ReverseWordsInStringTest.java +++ b/src/test/java/com/thealgorithms/strings/ReverseWordsInStringTest.java @@ -1,23 +1,20 @@ package com.thealgorithms.strings; -import static org.junit.jupiter.api.Assertions.assertEquals; - +import java.util.stream.Stream; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; public class ReverseWordsInStringTest { - - @Test - public void testCorrectReverseWordsInTheString() { - assertEquals("blue is Sky", ReverseWordsInString.reverseWordsInString("Sky is blue")); - } - - @Test - public void testCorrectReverseWordsInTheStringWithWhiteSpace() { - assertEquals("blue is Sky", ReverseWordsInString.reverseWordsInString("Sky \n is \n \n blue")); + @ParameterizedTest + @MethodSource("inputStream") + void numberTests(String expected, String input) { + Assertions.assertEquals(expected, ReverseWordsInString.reverseWordsInString(input)); } - @Test - public void testReverseWordsInStringForEmpty() { - assertEquals("", ReverseWordsInString.reverseWordsInString("")); + private static Stream inputStream() { + return Stream.of(Arguments.of("blue is Sky", "Sky is blue"), Arguments.of("blue is Sky", "Sky \n is \t \n blue "), Arguments.of("", ""), Arguments.of("", " "), Arguments.of("", "\t")); } }