prefixAgain java challenge

Here is your code, reworked, btw :

public boolean prefixAgain(String str, int n) {
  String strNew = str.substring(0, n);
 int len = str.length();
 String strLaterHalf = str.substring(1, len);
 if (strLaterHalf.contains(strNew)) {

  return true;
 } else {
  return false;
 }
}

Select all Open in new window

My preference would be for return str.substring(1).contains(str.substring(0,n));

Which is what I put in my first comment.

Presumably that's why you changed n to 1 in gudii9's code, so that it would be consistent with yours, even though that change was not necessary in order to pass the tests.

Well I felt that using the 1 would help in seeing the fundamental mechanics of moving that pointer - rather than bringing n into it again, as it tends to "overload" n's use case, whereas if gudii asks "why is there a 1 there", then potential ambiguity can be avoided.

I am also unsure whether the question really intends to avoid overlapping or not, so 1 seemed better.

We seem to share the intuition that substring(1) is somehow a more fundamental interpretation of the problem statement than substring(n).
Yet we see that other intuitions are possible, and we lack the evidence to say that one is correct and one is incorrect.
Other challenges on the codingbat site seem to have similar ambiguities, and the tests similarly seem to fail to resolve the ambiguity, which may suggest the lack of resolution is deliberate.

which may suggest the lack of resolution is deliberate.

Pleased you qualified that statement with the word "may". Because I would have thought that the very worst place for demonstrating ambiguity, is in a teaching/learning environment. This, imho, is even worse when there are no hints or visible caveats telling the user that they should be cautious in drawing conclusions about the overall definitiveness of obtaining a "passed all tests" result.

This weakness has shown itself up several times in these challenges, and to me leaves the door wide-open to the criticism that "a little knowledge is a dangerous thing". I wouldn't want these people to churn out programmers for coding my driverless car or fbw aircraft, nor any number of other criticial procedures where a proper understanding of the task was essential, rather than just the quick-and-dirty fingers of trigger-happy hackers. Perhaps CB has a retinue of lawyers ready behind the scenes somewhere.

public boolean prefixAgain(String str, int n) {

String strNew=str.substring(0,n);
int len=str.length();
String strLaterHalf=str.substring(n, len);
if( strLaterHalf.contains(strNew)){

return true;
}

else{
return false;
}
  
}

//

Select all Open in new window

i see mistake i did is added -1 unnecessarily. above passing all tests

public class PrefixAgainEx {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("Values is-->"+prefixAgain("abXYabc", 3));
	}

	
	public static boolean prefixAgain(String str, int n) {

		String strNew=str.substring(0,n);
		System.out.println("strNew is-->"+strNew);
		int len=str.length();
		String strLaterHalf=str.substring(n, len);
		System.out.println("strLaterHalf is-->"+strLaterHalf);
		if( strLaterHalf.contains(strNew)){

		return true;
		}

		else{
		return false;
		}
		  
		}

}

Select all Open in new window

above give below correctr result
strNew is-->abX
strLaterHalf is-->Yabc
Values is-->false

public class PrefixAgainEx {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("Values is-->"+prefixAgain("aaa", 2));
	}

	
	public static boolean prefixAgain(String str, int n) {

		String strNew=str.substring(0,n);
		System.out.println("strNew is-->"+strNew);
		int len=str.length();
		String strLaterHalf=str.substring(n, len);
		System.out.println("strLaterHalf is-->"+strLaterHalf);
		if( strLaterHalf.contains(strNew)){

		return true;
		}

		else{
		return false;
		}
		  
		}

}

Select all Open in new window

above passed the test of  prefixAgain("aaa", 2));
      }


My preference would be for return str.substring(1).contains(str.substring(0,n));



I wonder why we choose 1 in above solution why not 2 or 3?? just to be safer side that n is always there 1 or more??

return str.substring(2).contains(str.substring(0,n)); is clearly wrong in this case:
Expected      Run
prefixAgain("aa", 1) → true      false

package simple.servlet;
public class PrefixAgainEx {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("Values is-->"+prefixAgain("aa", 1));
	}

	
	public static boolean prefixAgain(String str, int n) {

		String strNew=str.substring(0,n);
		System.out.println("strNew is-->"+strNew);
		int len=str.length();
		String strLaterHalf=str.substring(n, len);
		System.out.println("strLaterHalf is-->"+strLaterHalf);
		if( strLaterHalf.contains(strNew)){

		return true;
		}

		else{
		return false;
		}
		  
		}

}

Select all Open in new window

i got result as true when i run same as expected
strNew is-->a
strLaterHalf is-->a
Values is-->true

public boolean prefixAgain(String str, int n) {

return str.substring(2).contains(str.substring(0,n));
}

above failed two test cases as you mentioned

Expected      Run            
prefixAgain("abXYabc", 1) → true      true      OK         
prefixAgain("abXYabc", 2) → true      true      OK         
prefixAgain("abXYabc", 3) → false      false      OK         
prefixAgain("xyzxyxyxy", 2) → true      true      OK         
prefixAgain("xyzxyxyxy", 3) → false      false      OK         
prefixAgain("Hi12345Hi6789Hi10", 1) → true      true      OK         
prefixAgain("Hi12345Hi6789Hi10", 2) → true      true      OK         
prefixAgain("Hi12345Hi6789Hi10", 3) → true      true      OK         
prefixAgain("Hi12345Hi6789Hi10", 4) → false      false      OK         
prefixAgain("a", 1) → false      Exception:java.lang.StringIndexOutOfBoundsException: String index out of range: -1 (line number:3)      X         
prefixAgain("aa", 1) → true      false      X         
prefixAgain("ab", 1) → false      false      OK         
other tests
OK         

public boolean prefixAgain(String str, int n) {

return str.substring(1).contains(str.substring(0,n));
}

Select all Open in new window

above passed all tests

Expected      Run            
prefixAgain("abXYabc", 1) → true      true      OK         
prefixAgain("abXYabc", 2) → true      true      OK         
prefixAgain("abXYabc", 3) → false      false      OK         
prefixAgain("xyzxyxyxy", 2) → true      true      OK         
prefixAgain("xyzxyxyxy", 3) → false      false      OK         
prefixAgain("Hi12345Hi6789Hi10", 1) → true      true      OK         
prefixAgain("Hi12345Hi6789Hi10", 2) → true      true      OK         
prefixAgain("Hi12345Hi6789Hi10", 3) → true      true      OK         
prefixAgain("Hi12345Hi6789Hi10", 4) → false      false      OK         
prefixAgain("a", 1) → false      false      OK         
prefixAgain("aa", 1) → true      true      OK         
prefixAgain("ab", 1) → false      false      OK         
other tests
OK