Vì vậy, bạn muốn tránh vòng lặp?
Ở đây bạn có nó:
public static String repeat(String s, int times) {
if (times <= 0) return "";
else return s + repeat(s, times-1);
}
(tất nhiên tôi biết điều này là xấu và không hiệu quả, nhưng nó không có vòng lặp :-p)
Bạn muốn nó đơn giản và đẹp hơn? sử dụng jython:
s * 3
Chỉnh sửa : hãy tối ưu hóa nó một chút :-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 : Tôi đã thực hiện một điểm chuẩn nhanh và bẩn cho 4 lựa chọn thay thế chính, nhưng tôi không có thời gian để chạy nó nhiều lần để lấy phương tiện và vẽ thời gian cho một số đầu vào ... Vì vậy, đây là mã nếu có ai muốn để thử nó:
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();
}
}
Phải có 2 đối số, đầu tiên là số lần lặp (mỗi hàm chạy với số lần lặp lại arg từ 1..n) và lần thứ hai là chuỗi lặp lại.
Cho đến nay, việc kiểm tra nhanh thời gian chạy với các đầu vào khác nhau để lại thứ hạng như thế này (tốt hơn đến tệ hơn):
- Lặp lại StringBuilder bổ sung (1x).
- Các đệ trình log2 nối ghép đệ quy (~ 3x).
- Đệ trình tuyến tính nối đệ quy (~ 30x).
- Lặp lại tuyến tính nối tuyến tính (~ 45x).
Tôi sẽ không bao giờ đoán rằng hàm đệ quy nhanh hơn forvòng lặp: -o
Hãy vui vẻ (ctional xD).