Jadi, Anda ingin menghindari loop?
Di sini Anda memilikinya:
public static String repeat(String s, int times) {
if (times <= 0) return "";
else return s + repeat(s, times-1);
}
(tentu saja saya tahu ini jelek dan tidak efisien, tetapi tidak memiliki loop :-p)
Anda ingin itu lebih sederhana dan lebih cantik? gunakan jython:
s * 3
Sunting : mari optimalkan sedikit :-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);
}
Sunting2 : Saya telah melakukan patokan cepat dan kotor untuk 4 alternatif utama, tapi saya tidak punya waktu untuk menjalankannya beberapa kali untuk mendapatkan cara dan merencanakan waktu untuk beberapa input ... Jadi, inilah kode jika ada yang mau untuk mencobanya:
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();
}
}
Dibutuhkan 2 argumen, yang pertama adalah jumlah iterasi (setiap fungsi dijalankan dengan waktu pengulangan arg dari 1..n) dan yang kedua adalah string untuk diulang.
Sejauh ini, inspeksi cepat terhadap waktu yang berjalan dengan input yang berbeda meninggalkan peringkat seperti ini (lebih baik menjadi lebih buruk):
- Tambahkan StringBuilder berulang (1x).
- Doakan concatenation log2 rekursif (~ 3x).
- Penggambaran linear rekursif linear (~ 30x).
- Rangkaian gabungan berulang (~ 45x).
Saya tidak akan pernah menduga bahwa fungsi rekursif lebih cepat daripada forloop: -o
Bersenang-senang (xD opsional).