तो आप छोरों से बचना चाहते हैं?
यहां आप इसे रखते हैं:
public static String repeat(String s, int times) {
if (times <= 0) return "";
else return s + repeat(s, times-1);
}
(बेशक मुझे पता है कि यह बदसूरत और अक्षम है, लेकिन इसमें लूप नहीं है :-p)
आप इसे सरल और सुंदर चाहते हैं? अजगर का उपयोग करें:
s * 3
संपादित करें : चलो इसे थोड़ा सा अनुकूलित करें :-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 : मैंने 4 मुख्य विकल्पों के लिए एक त्वरित और गंदा बेंचमार्क किया है, लेकिन मेरे पास साधन प्राप्त करने के लिए इसे चलाने के लिए कई बार समय नहीं है और कई आदानों के लिए बार प्लॉट करना है ... इसलिए यदि कोई चाहता है तो यहां कोड है इसे करने की कोशिश:
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();
}
}
इसमें 2 तर्क दिए गए हैं, पहला पुनरावृत्तियों की संख्या है (प्रत्येक फ़ंक्शन 1..n से दोहराए गए समय arg के साथ चलता है) और दूसरा दोहराव के लिए स्ट्रिंग है।
अब तक, विभिन्न इनपुट्स के साथ चलने वाले समय का त्वरित निरीक्षण रैंकिंग को कुछ इस तरह से छोड़ता है (बेहतर से बदतर):
- Iterative StringBuilder परिशिष्ट (1x)।
- पुनरावर्ती संघटन log2 आह्वान (~ 3x)।
- पुनरावर्ती अवतरण रैखिक इनवोकेशन (~ 30x)।
- निष्क्रिय संघनन रेखीय (~ 45x)।
मैंने कभी अनुमान नहीं लगाया था कि पुनरावर्ती कार्य forलूप की तुलना में तेज था : -o
मज़े करो (ctional xD)।