¿Entonces quieres evitar bucles?
Aqui lo tienes:
public static String repeat(String s, int times) {
if (times <= 0) return "";
else return s + repeat(s, times-1);
}
(por supuesto, sé que esto es feo e ineficiente, pero no tiene bucles :-p)
¿Quieres que sea más simple y bonito? usa jython:
s * 3
Editar : optimicemos un poco :-D
public static String repeat(String s, int times) {
if (times <= 0) return "";
else if (times % 2 == 0) return repeat(s+s, times/2);
else return s + repeat(s+s, times/2);
}
Edit2 : he hecho un punto de referencia rápido y sucio para las 4 alternativas principales, pero no tengo tiempo para ejecutarlo varias veces para obtener los medios y trazar los tiempos para varias entradas ... Así que aquí está el código si alguien quiere intentarlo:
public class Repeat {
public static void main(String[] args) {
int n = Integer.parseInt(args[0]);
String s = args[1];
int l = s.length();
long start, end;
start = System.currentTimeMillis();
for (int i = 0; i < n; i++) {
if(repeatLog2(s,i).length()!=i*l) throw new RuntimeException();
}
end = System.currentTimeMillis();
System.out.println("RecLog2Concat: " + (end-start) + "ms");
start = System.currentTimeMillis();
for (int i = 0; i < n; i++) {
if(repeatR(s,i).length()!=i*l) throw new RuntimeException();
}
end = System.currentTimeMillis();
System.out.println("RecLinConcat: " + (end-start) + "ms");
start = System.currentTimeMillis();
for (int i = 0; i < n; i++) {
if(repeatIc(s,i).length()!=i*l) throw new RuntimeException();
}
end = System.currentTimeMillis();
System.out.println("IterConcat: " + (end-start) + "ms");
start = System.currentTimeMillis();
for (int i = 0; i < n; i++) {
if(repeatSb(s,i).length()!=i*l) throw new RuntimeException();
}
end = System.currentTimeMillis();
System.out.println("IterStrB: " + (end-start) + "ms");
}
public static String repeatLog2(String s, int times) {
if (times <= 0) {
return "";
}
else if (times % 2 == 0) {
return repeatLog2(s+s, times/2);
}
else {
return s + repeatLog2(s+s, times/2);
}
}
public static String repeatR(String s, int times) {
if (times <= 0) {
return "";
}
else {
return s + repeatR(s, times-1);
}
}
public static String repeatIc(String s, int times) {
String tmp = "";
for (int i = 0; i < times; i++) {
tmp += s;
}
return tmp;
}
public static String repeatSb(String s, int n) {
final StringBuilder sb = new StringBuilder();
for(int i = 0; i < n; i++) {
sb.append(s);
}
return sb.toString();
}
}
Se necesitan 2 argumentos, el primero es el número de iteraciones (cada función se ejecuta con tiempos de repetición arg desde 1..n) y el segundo es la cadena para repetir.
Hasta ahora, una inspección rápida de los tiempos que se ejecutan con diferentes entradas deja el ranking algo así (de mejor a peor):
- StringBuilder iterativo anexar (1x).
- Invocaciones de log2 de concatenación recursiva (~ 3x).
- Invocaciones lineales de concatenación recursiva (~ 30x).
- Concatenación iterativa lineal (~ 45x).
Nunca adiviné que la función recursiva era más rápida que el forbucle: -o
Diviértete (ctional xD).