From b0241450edc2f2d561f259c9251916d06908810f Mon Sep 17 00:00:00 2001 From: "tu.cuong.bat.tuc" Date: Mon, 24 May 2021 21:10:27 +0700 Subject: [PATCH 1/3] 24052021: update first code --- .gitignore | 1 + .project | 12 ++++++++++++ 2 files changed, 13 insertions(+) diff --git a/.gitignore b/.gitignore index 972f6a3d..dcc60f41 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,3 @@ /bin/ .idea +/build/ diff --git a/.project b/.project index 76b39aeb..304af316 100644 --- a/.project +++ b/.project @@ -5,7 +5,19 @@ + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.wst.common.project.facet.core.builder + + + + org.eclipse.wst.common.project.facet.core.nature + org.eclipse.jdt.core.javanature From 41cdf1a33adde1d4ed17e21c4749a1280227265a Mon Sep 17 00:00:00 2001 From: "tu.cuong.bat.tuc" Date: Mon, 24 May 2021 21:23:21 +0700 Subject: [PATCH 2/3] 25052021: commit two times --- .classpath | 7 +++ .settings/org.eclipse.jdt.core.prefs | 10 ++++ ....eclipse.wst.common.project.facet.core.xml | 4 ++ src/main/java/unitTest/ContainsDuplicate.java | 22 +++++++++ .../unitTest/ContainsDuplicateUnitTest.java | 32 +++++++++++++ .../java/unitTest/ReverseVowelsOfAString.java | 46 +++++++++++++++++++ .../ReverseVowelsOfAStringUnitTest.java | 45 ++++++++++++++++++ 7 files changed, 166 insertions(+) create mode 100644 .classpath create mode 100644 .settings/org.eclipse.jdt.core.prefs create mode 100644 .settings/org.eclipse.wst.common.project.facet.core.xml create mode 100644 src/main/java/unitTest/ContainsDuplicate.java create mode 100644 src/main/java/unitTest/ContainsDuplicateUnitTest.java create mode 100644 src/main/java/unitTest/ReverseVowelsOfAString.java create mode 100644 src/main/java/unitTest/ReverseVowelsOfAStringUnitTest.java diff --git a/.classpath b/.classpath new file mode 100644 index 00000000..2712ade5 --- /dev/null +++ b/.classpath @@ -0,0 +1,7 @@ + + + + + + + diff --git a/.settings/org.eclipse.jdt.core.prefs b/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 00000000..8b9e3c71 --- /dev/null +++ b/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,10 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=13 +org.eclipse.jdt.core.compiler.compliance=13 +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning +org.eclipse.jdt.core.compiler.release=enabled +org.eclipse.jdt.core.compiler.source=13 diff --git a/.settings/org.eclipse.wst.common.project.facet.core.xml b/.settings/org.eclipse.wst.common.project.facet.core.xml new file mode 100644 index 00000000..d37b85ff --- /dev/null +++ b/.settings/org.eclipse.wst.common.project.facet.core.xml @@ -0,0 +1,4 @@ + + + + diff --git a/src/main/java/unitTest/ContainsDuplicate.java b/src/main/java/unitTest/ContainsDuplicate.java new file mode 100644 index 00000000..10adbc68 --- /dev/null +++ b/src/main/java/unitTest/ContainsDuplicate.java @@ -0,0 +1,22 @@ +package unitTest; + +import java.util.HashMap; + +//Given an array of integers, find if the array contains any duplicates. Your function should return +//true if any value appears at least twice in the array, and it should return false if every element is distinct. + +class ContainsDuplicate { + public boolean containsDuplicate(int[] nums) { + HashMap map = new HashMap(); + for(int i: nums) { + if(map.containsKey(i)) { + return true; + } else { + map.put(i, 1); + } + } + + return false; + } +} + diff --git a/src/main/java/unitTest/ContainsDuplicateUnitTest.java b/src/main/java/unitTest/ContainsDuplicateUnitTest.java new file mode 100644 index 00000000..a365c5f6 --- /dev/null +++ b/src/main/java/unitTest/ContainsDuplicateUnitTest.java @@ -0,0 +1,32 @@ +package unitTest; + +import static org.junit.Assert.*; + +import org.junit.Test; + +public class ContainsDuplicateUnitTest { + + ContainsDuplicate cd = new ContainsDuplicate(); + + @Test + public void testNextDuplicate() { + int[] nums = {2,2,4,4}; + + assertTrue(cd.containsDuplicate(nums)); + } + + @Test + public void testDuplicate() { + int[] nums = {2,4,2,5,8,9}; + + assertTrue(cd.containsDuplicate(nums)); + } + + @Test + public void testNotDuplicate() { + int[] nums = {3,4,7,8,9}; + + assertFalse(cd.containsDuplicate(nums)); + } + +} \ No newline at end of file diff --git a/src/main/java/unitTest/ReverseVowelsOfAString.java b/src/main/java/unitTest/ReverseVowelsOfAString.java new file mode 100644 index 00000000..5989970b --- /dev/null +++ b/src/main/java/unitTest/ReverseVowelsOfAString.java @@ -0,0 +1,46 @@ +package unitTest; + +// Write a function that takes a string as input and reverse only the vowels of a string. + +// Example 1: +// Given s = "hello", return "holle". + +// Example 2: +// Given s = "leetcode", return "leotcede". + +// Note: +// The vowels does not include the letter "y". + +public class ReverseVowelsOfAString { + public String reverseVowels(String s) { + if(s == null || s.length() == 0) { + return s; + } + + String vowels = "aeiouAEIOU"; + + char[] chars = s.toCharArray(); + + int start = 0; + int end = s.length() - 1; + + while(start < end) { + while(start < end && !vowels.contains(chars[start] + "")) { + start++; + } + + while(start < end && !vowels.contains(chars[end] + "")) { + end--; + } + + char temp = chars[start]; + chars[start] = chars[end]; + chars[end] = temp; + + start++; + end--; + } + + return new String(chars); + } +} diff --git a/src/main/java/unitTest/ReverseVowelsOfAStringUnitTest.java b/src/main/java/unitTest/ReverseVowelsOfAStringUnitTest.java new file mode 100644 index 00000000..017e084f --- /dev/null +++ b/src/main/java/unitTest/ReverseVowelsOfAStringUnitTest.java @@ -0,0 +1,45 @@ +package unitTest; + +import static org.junit.Assert.*; + +import org.junit.Test; + +public class ReverseVowelsOfAStringUnitTest { + + ReverseVowelsOfAString rs = new ReverseVowelsOfAString(); + + @Test + public void testTrueReverseWords() { + String startString = "learn funix"; + String expectResults = "funix learn"; + + String actualRs = rs.reverseVowels(startString); + assertEquals(actualRs, rs.reverseVowels(startString)); + } + + @Test + public void testReverseWords() { + String startString = "learn FU"; + String expectResults = "fu learn"; + + assertNotEquals(expectResults, rs.reverseVowels(startString)); + } + + + @Test + public void testReverseWordsCase() { + String startString = "learn FU"; + String expectResults = "FU hghjkhg"; + + assertNotEquals(expectResults, rs.reverseVowels(startString)); + } + + @Test + public void testFalseReverseWords() { + String starString = "learn funix"; + String expectResults = "learn funix"; + + assertNotEquals(expectResults, rs.reverseVowels(starString)); + } + +} From b03dd3a3e4a8944e96f7a2e5482e59627a5168e3 Mon Sep 17 00:00:00 2001 From: "tu.cuong.bat.tuc" Date: Mon, 21 Jun 2021 22:54:23 +0700 Subject: [PATCH 3/3] SE00292x: update code 21062021 --- src/main/java/unitTest/ContainsDuplicate.java | 7 +- .../unitTest/ContainsDuplicateUnitTest.java | 5 +- .../java/unitTest/ReverseVowelsOfAString.java | 93 +++++++++++-------- .../ReverseVowelsOfAStringUnitTest.java | 20 ++-- 4 files changed, 73 insertions(+), 52 deletions(-) diff --git a/src/main/java/unitTest/ContainsDuplicate.java b/src/main/java/unitTest/ContainsDuplicate.java index 10adbc68..ce6be11c 100644 --- a/src/main/java/unitTest/ContainsDuplicate.java +++ b/src/main/java/unitTest/ContainsDuplicate.java @@ -2,8 +2,10 @@ import java.util.HashMap; -//Given an array of integers, find if the array contains any duplicates. Your function should return -//true if any value appears at least twice in the array, and it should return false if every element is distinct. +//Given an array of integers, find if the array contains any duplicates. +//Your function should return +//true if any value appears at least twice in the array, +//and it should return false if every element is distinct. class ContainsDuplicate { public boolean containsDuplicate(int[] nums) { @@ -19,4 +21,3 @@ public boolean containsDuplicate(int[] nums) { return false; } } - diff --git a/src/main/java/unitTest/ContainsDuplicateUnitTest.java b/src/main/java/unitTest/ContainsDuplicateUnitTest.java index a365c5f6..85c62fb4 100644 --- a/src/main/java/unitTest/ContainsDuplicateUnitTest.java +++ b/src/main/java/unitTest/ContainsDuplicateUnitTest.java @@ -7,7 +7,7 @@ public class ContainsDuplicateUnitTest { ContainsDuplicate cd = new ContainsDuplicate(); - + //Test case where the same elements in the array are contiguous @Test public void testNextDuplicate() { int[] nums = {2,2,4,4}; @@ -15,6 +15,8 @@ public void testNextDuplicate() { assertTrue(cd.containsDuplicate(nums)); } + //Test case where the positions of the same elements + //in the array are not contiguous @Test public void testDuplicate() { int[] nums = {2,4,2,5,8,9}; @@ -22,6 +24,7 @@ public void testDuplicate() { assertTrue(cd.containsDuplicate(nums)); } + //Test case all elements in the array are not the same @Test public void testNotDuplicate() { int[] nums = {3,4,7,8,9}; diff --git a/src/main/java/unitTest/ReverseVowelsOfAString.java b/src/main/java/unitTest/ReverseVowelsOfAString.java index 5989970b..53cf6241 100644 --- a/src/main/java/unitTest/ReverseVowelsOfAString.java +++ b/src/main/java/unitTest/ReverseVowelsOfAString.java @@ -1,46 +1,61 @@ package unitTest; -// Write a function that takes a string as input and reverse only the vowels of a string. -// Example 1: -// Given s = "hello", return "holle". -// Example 2: -// Given s = "leetcode", return "leotcede". +//Write a function that takes a string as input and reverse only the vowels of a string. -// Note: -// The vowels does not include the letter "y". +//Example 1: +//Given s = "hello", return "holle". +//Example 2: +//Given s = "leetcode", return "leotcede". + +//Note: +//The vowels does not include the letter "y". + +/** + * This is the class containing the function in the + * project used to apply the UnitTest technique. + * It's in the company's google directory + * @author DucNA-SE00292x + * + */ public class ReverseVowelsOfAString { - public String reverseVowels(String s) { - if(s == null || s.length() == 0) { - return s; - } - - String vowels = "aeiouAEIOU"; - - char[] chars = s.toCharArray(); - - int start = 0; - int end = s.length() - 1; - - while(start < end) { - while(start < end && !vowels.contains(chars[start] + "")) { - start++; - } - - while(start < end && !vowels.contains(chars[end] + "")) { - end--; - } - - char temp = chars[start]; - chars[start] = chars[end]; - chars[end] = temp; - - start++; - end--; - } - - return new String(chars); - } -} + /** + * Below is the vowel inversion function. + * @param s - This is a String input to method. + * @return s - This is return. + */ + public String reverseVowels(String s) { + if (s == null || s.length() == 0) { + return s; + } + + String vowels = "aeiouAEIOU"; + + char[] chars = s.toCharArray(); + + int start = 0; + int end = s.length() - 1; + + while (start < end) { + while (start < end && !vowels. + contains(chars[start] + "")) { + start++; + } + + while (start < end && !vowels. + contains(chars[end] + "")) { + end--; + } + + char temp = chars[start]; + chars[start] = chars[end]; + chars[end] = temp; + + start++; + end--; + } + return new String(chars); + } +} \ No newline at end of file diff --git a/src/main/java/unitTest/ReverseVowelsOfAStringUnitTest.java b/src/main/java/unitTest/ReverseVowelsOfAStringUnitTest.java index 017e084f..087df496 100644 --- a/src/main/java/unitTest/ReverseVowelsOfAStringUnitTest.java +++ b/src/main/java/unitTest/ReverseVowelsOfAStringUnitTest.java @@ -8,34 +8,36 @@ public class ReverseVowelsOfAStringUnitTest { ReverseVowelsOfAString rs = new ReverseVowelsOfAString(); + //True test case of the inverse function-1 @Test - public void testTrueReverseWords() { + public void testTrueReverseVowels1() { String startString = "learn funix"; - String expectResults = "funix learn"; String actualRs = rs.reverseVowels(startString); assertEquals(actualRs, rs.reverseVowels(startString)); } + //False test case of the inverse function-1 @Test - public void testReverseWords() { + public void testNotEqualsReverseVowels1() { String startString = "learn FU"; String expectResults = "fu learn"; assertNotEquals(expectResults, rs.reverseVowels(startString)); } - + //true test case of the inverse function-2 @Test - public void testReverseWordsCase() { - String startString = "learn FU"; - String expectResults = "FU hghjkhg"; + public void testTrueReverseVowels2() { + String startString = "lUarn Fe"; + String expectResults = "learn FU"; - assertNotEquals(expectResults, rs.reverseVowels(startString)); + assertEquals(expectResults, rs.reverseVowels(startString)); } + //False test case of the inverse function-2 @Test - public void testFalseReverseWords() { + public void testNotEqualsReverseWords2() { String starString = "learn funix"; String expectResults = "learn funix";