repeatSeparator java challenge

public String repeatSeparator(String word, String sep, int count) {
  StringBuilder sb = new StringBuilder(word.length()*count+Math.min(count-1,0)*sep.length());
  String sw=sep+word;
  for (int c=0;c<count;c++){
     sb.append(word);
     word=sw;
  }
  return sb.toString();
}

Lol, yes, I completely forgot the sep length for theStringBuilder constructor. But, nevermind, it doesn't need it anyway. ;)

public String repeatSeparator(String word, String sep, int count) {
 StringBuilder sb = new StringBuilder();
 StringBuilder sb2 = sb.append(word);
 if (count > 0) {
  for (int i = 0; i < count - 1; i++) {

   sb2.append(sep + word);
  }
  return sb2.toString();
 } else {

  return word;
 }

}

Select allOpen in new window

how to fix my approach to resolve only 1 test that is failing?

public String repeatSeparator(String word, String sep, int count) {
StringBuilder sb=new StringBuilder(word.length()*count);
StringBuilder sb2=sb.append(word);
if(count>0){
for(int i=0;i<count-1;i++){

sb2.append(sep+word);
}
return sb2.toString();
}
else if(count==1){
return word;
}
else{
word;
}
  
}


 // if(count==1){return word;}
  //StringBuilder sb = new StringBuilder(word.length()*count);
 // for (int c=0;c<count;c++){sb.append(word+sep);}
//  return sb.toString().substring(0,sb.toString().length()-sep.length());

Select allOpen in new window

above gives below error

Compile problems:


Error:      word;
      ^^^^
Syntax error, insert "AssignmentOperator ArrayInitializer" to complete Expression


see Example Code to help with compile problems

not sure why.

please advise

public String repeatSeparator(String word, String sep, int count) {
 StringBuilder sb = new StringBuilder();
 StringBuilder sb2 = sb.append(word);
 if (count > 1) {
  for (int i = 0; i < count - 1; i++) {

   sb2.append(sep + word);
  }
  return sb2.toString();
 } else if(count == 1){

  return word;
 }


else{

  return "";
 }
}

Select allOpen in new window

i fixed as above and passing all tests

public String repeatSeparator(String word, String sep, int count) {
StringBuilder sb=new StringBuilder(word.length()*count);
StringBuilder sb2=sb.append(word);
if(count>0){
for(int i=0;i<count-1;i++){

sb2.append(sep+word);
}
return sb2.toString();
}
else if(count==1){
return word;
}
else{
return "";
}
  
}


 // if(count==1){return word;}
  //StringBuilder sb = new StringBuilder(word.length()*count);
 // for (int c=0;c<count;c++){sb.append(word+sep);}
//  return sb.toString().substring(0,sb.toString().length()-sep.length());

                    

Select allOpen in new window

 forgot to put return before word which gave compilation errror which i fixed now

public String repeatSeparator(String word, String sep, int count) {

  if( count>0 ){ return word+sep+repeatSeparator(word,sep,count-1); }
    if( count==1 ){ return word; }
  return "";
}

if i change order fails lot of tests.

how to find order.
[
more generic to specific or
rule is more specific to more generic

public String repeatSeparator(String word, String sep, int count) {
  if( count==1 ){ return word; }
  if( count>0 ){ return word+sep+repeatSeparator(word,sep,count-1); }
  
  return "";
}

Select allOpen in new window

seems rule more specific to more generic like specific guys need to be satisfied then generic people always happy

When count is 1, both count==1 and count>0 are true.
What do you think should happen in that case?
When both conditions are true, the return that happens first prevents the second return from happening, so order matters.

When only one of the conditions is true, then the order would not matter.
Can you think of a way to modify the conditions so that they are never both true?

When count is 1, both count==1 and count>0 are true.
What do you think should happen in that case?
When both conditions are true, the return that happens first prevents the second return from happening, so order matters.

i agree.

i will remember this in my mind..never let normal course of flow obstruct second return from happening

I'm not sure how you decide what is "normal", but if you want the second return to happen, then you should not obstruct it from happening, when you don't want it to happen, then you should obstruct it from happening.

If the guard conditions were mutually exclusive, like if( count==1 ) and if( count>1 ) then you could choose to put them in any order without affecting which return happens.  
(the order could still affect which conditions were tested, which could matter to you if one of the test conditions was very complicated or had side effects)
On the other hand, if you fix the order of the returns, then you could have more freedom in choosing the guard conditions since the second guard condition would not need to decide a case that had already been caught by the first.

If the guard conditions were mutually exclusive, like if( count==1 ) and if( count>1 ) then you could choose to put them in any order without affecting which return happens.  

i agree on this