From df538cd5f85bcdd5f839f362d5f60542b0026f70 Mon Sep 17 00:00:00 2001 From: Adrian Turcan Date: Wed, 14 Jun 2023 11:26:28 -0700 Subject: [PATCH 1/2] Added my files to the repository --- src/main/java/StringManipulation.java | 48 ++++++++++++++++++++--- src/test/java/StringManipulationTest.java | 42 ++++++++++++++------ 2 files changed, 73 insertions(+), 17 deletions(-) mode change 100644 => 100755 src/test/java/StringManipulationTest.java diff --git a/src/main/java/StringManipulation.java b/src/main/java/StringManipulation.java index 4deb6f1..de3c46f 100644 --- a/src/main/java/StringManipulation.java +++ b/src/main/java/StringManipulation.java @@ -1,32 +1,68 @@ +import java.io.*; +import java.util.StringTokenizer; + + public class StringManipulation implements StringManipulationInterface { + private String myString; @Override public String getString() { - return null; + return myString; } @Override public void setString(String string) { + myString = string; } @Override public int count() { - return 0; + if(myString == null){ + return 0; + } else { + StringTokenizer tokens = new StringTokenizer(myString); + return tokens.countTokens(); + } } @Override public String removeNthCharacter(int n, boolean maintainSpacing) { + + /* + String str=myString.toString(); + String resultStr=""; + //loop execute till the length of the string + for (int i=0;i64 && str.charAt(i)<=122) + { + + resultStr=resultStr+str.charAt(i); + } + } + return resultStr; + */ return null; } @Override - public String[] getSubStrings(int startWord, int endWord) { - return null; + public String[] getSubStrings(int startWord, int endWord){ + /* String [] words = myString.split("\\s+"); + String [] words = myString.split(" "); + for(String word : words) { + System.out.println(word); + } */ + + return null; } @Override - public String restoreString(int[] indices) { - return null; + public String restoreString(int[] indices){ + StringBuilder res = new StringBuilder(myString); + for(int i =0; i < indices.length; ++i) + res.setCharAt(indices[i],myString.charAt(i)); + return res.toString(); } diff --git a/src/test/java/StringManipulationTest.java b/src/test/java/StringManipulationTest.java old mode 100644 new mode 100755 index 6692c2c..70935b1 --- a/src/test/java/StringManipulationTest.java +++ b/src/test/java/StringManipulationTest.java @@ -28,17 +28,20 @@ public void testCount1() { @Test public void testCount2() { - fail("Not yet implemented"); + manipulatedstring.setString("Mystring has total of 6 words!"); + int length2 = manipulatedstring.count(); + assertEquals(6, length2); } @Test public void testCount3() { - fail("Not yet implemented"); + assertFalse(manipulatedstring.toString() == null, "String is null"); } @Test public void testCount4() { - fail("Not yet implemented"); + manipulatedstring.setString("This is Adrian's assertTrue condition"); + assertTrue(manipulatedstring.count() == 5); } @Test @@ -89,19 +92,28 @@ public void testGeSubStrings1() { @Test public void testGeSubStrings2() { - fail("Not yet implemented"); + assertFalse(manipulatedstring.toString() == null, "String is null"); } @Test public void testGeSubStrings3() { - fail("Not yet implemented"); + manipulatedstring.setString(" This is a space string"); + String [] sStr = manipulatedstring.getSubStrings(4,5); + assertEquals(sStr[0], "space"); + assertEquals(sStr[1], "string"); } @Test public void testGeSubStrings4() { - fail("Not yet implemented"); + manipulatedstring.setString("This"); + String [] sStr = manipulatedstring.getSubStrings(0,1); + assertFalse(manipulatedstring.toString().length()==1, "String is too small"); } @Test public void testGeSubStrings5() { - fail("Not yet implemented"); + manipulatedstring.setString("This is a long 3tring with more words!"); + String [] sStr = manipulatedstring.getSubStrings(2, 6); + + assertEquals(sStr[2], "3tring"); + assertTrue(sStr[3] == "with"); } @Test public void testGeSubStrings6() { @@ -121,28 +133,36 @@ public void testRestoreString1() @Test public void testRestoreString2() { - fail("Not yet implemented"); + manipulatedstring.setString("Tes2t"); + int [] array; + array=new int[]{0,1,2,4,3}; + String restoreString = manipulatedstring.restoreString(array); + assertEquals(restoreString, "Test2"); } @Test public void testRestoreString3() { - fail("Not yet implemented"); + assertFalse(manipulatedstring.toString() == "", "String is null"); } @Test public void testRestoreString4() { - fail("Not yet implemented"); + manipulatedstring.setString("longword"); + int [] array2; + array2 = new int[]{0,1,2}; + String restoreString2 = manipulatedstring.restoreString(array2); + assertEquals(restoreString2,"longword"); } @Test public void testRestoreString5() { - fail("Not yet implemented"); + assertNotNull(manipulatedstring); } From 41b4e1a6c89884bb4f17cd818495ab1e24bb9cca Mon Sep 17 00:00:00 2001 From: Adrian Turcan Date: Wed, 14 Jun 2023 23:44:15 -0700 Subject: [PATCH 2/2] Made modifications based on what my reviewer suggested --- src/main/java/StringManipulation.java | 69 +++++++++++++++++------ src/test/java/StringManipulationTest.java | 38 ++++++++++--- 2 files changed, 81 insertions(+), 26 deletions(-) diff --git a/src/main/java/StringManipulation.java b/src/main/java/StringManipulation.java index de3c46f..f8c630f 100644 --- a/src/main/java/StringManipulation.java +++ b/src/main/java/StringManipulation.java @@ -28,33 +28,66 @@ public int count() { @Override public String removeNthCharacter(int n, boolean maintainSpacing) { - /* - String str=myString.toString(); - String resultStr=""; - //loop execute till the length of the string - for (int i=0;i getString().length()){ + throw new IndexOutOfBoundsException("n cannot have greater length than the current string"); + } else if (n < 1) { + throw new IllegalArgumentException("n can't be <= 0"); + } + String strng = getString(); - if (str.charAt(i)>64 && str.charAt(i)<=122) - { - resultStr=resultStr+str.charAt(i); + if(!maintainSpacing) { + int j = 0; + char arr[] = new char[getString().length() - (getString().length() / n)]; + for (int i = 1; i <= getString().length(); i++) { + if ((i % n) != 0) { + arr[j] = strng.charAt(i - 1); + j++; + } + } + return String.copyValueOf(arr); + } else { + char arr[] = new char[getString().length()]; + int j = 0; + for(int i = 1; i <= getString().length(); i++){ + if((i % n) == 0){ + arr[i-1] = ' '; + } else { + arr[i-1] = strng.charAt(i-1); + } } + return String.copyValueOf(arr); } - return resultStr; - */ - return null; } @Override public String[] getSubStrings(int startWord, int endWord){ - /* String [] words = myString.split("\\s+"); - String [] words = myString.split(" "); - for(String word : words) { - System.out.println(word); - } */ + if(myString == null) { + throw new NullPointerException("String is null."); + } else if(startWord > endWord){ + throw new IllegalArgumentException("startWord can't be > endWord."); + } else if(startWord <= 0){ + throw new IllegalArgumentException("startWord cannot <= 0"); + } else if(endWord <= 0){ + throw new IllegalArgumentException("endWord cannot be <= to 0."); + } + + //here we are handling the exception for endWord># of words in string + String[] words = myString.split("\\s+"); + if(endWord > words.length){ + throw new IndexOutOfBoundsException("endWord is greater than the length of string."); + } + + int s = endWord - startWord + 1; + String[] result = new String[s]; + int index = 0; + + for (int i = startWord-1; i < endWord; i++) { + result[index] = words[i]; + index++; + } - return null; + return result; } @Override diff --git a/src/test/java/StringManipulationTest.java b/src/test/java/StringManipulationTest.java index 70935b1..ac5b9b6 100755 --- a/src/test/java/StringManipulationTest.java +++ b/src/test/java/StringManipulationTest.java @@ -58,27 +58,38 @@ public void testRemoveNthCharacter2() { @Test public void testRemoveNthCharacter3() { - fail("Not yet implemented"); + manipulatedstring.setString("I'd b3tt3r put s0me d161ts in this 5tr1n6, right?"); + assertEquals("I' bttr uts0e 16tsinths trn6 rgh?", manipulatedstring.removeNthCharacter(3, false)); + }; } @Test - public void testRemoveNthCharacter4() { - fail("Not yet implemented"); + public void testRemoveNthCharacter4(){ + + manipulatedstring.setString("Hi there") + assertThrows(IllegalArgumentException.class, ()-> + manipulatedstring.removeNthCharacter(0, false)); } @Test public void testRemoveNthCharacter5() { - fail("Not yet implemented"); + manipulatedstring.setString(null); + assertThrows(NullPointerException.class, ()-> + manipulatedstring.removeNthCharacter(4, false)); } @Test public void testRemoveNthCharacter6() { - fail("Not yet implemented"); + String s = "this does have only four char word"; + manipulatedstring.setString(s); + assertEquals("thisdoeshaveonlyfourcharword", manipulatedstring.removeNthCharacter(5, false)); } @Test public void testRemoveNthCharacter7() { fail("Not yet implemented"); + manipulatedstring.setString("this will have only four char word"); + assertEquals("this ill hve ony fou charword", manipulatedstring.removeNthCharacter(6,false)); } @Test @@ -117,7 +128,11 @@ public void testGeSubStrings5() { } @Test public void testGeSubStrings6() { - fail("Not yet implemented"); + manipulatedstring.setString(" one m1x o0ff w00rds is trash"); + String [] words = manipulatedstring.getSubStrings(1,3); + + assertEquals("one", words[0]); + assertEquals("is", words[1]); } @Test @@ -144,7 +159,10 @@ public void testRestoreString2() @Test public void testRestoreString3() { - assertFalse(manipulatedstring.toString() == "", "String is null"); + + manipulatedstring.setString(" This is an unlikely string"); + int arr[] = new int[]{1,0,5,7,20,12,10,23,18,3,2,4,6,19,8,9,22,11,21,13,14,15,16,17}; + assertEquals("This is an unlikely string ", manipulatedstring.restoreString(arr)); } @@ -162,7 +180,11 @@ public void testRestoreString4() @Test public void testRestoreString5() { - assertNotNull(manipulatedstring); + manipulatedstring.setString("aRT"); + int [] array; + array=new int[]{1,0,2}; + String restoreString = manipulatedstring.restoreString(array); + assertEquals(restoreString, "RaT"); }