कुछ छोटे कोड-गोल्फ टिप्स
अलग-अलग उत्तरों के लिए ये युक्तियां थोड़ी बहुत छोटी थीं, इसलिए मैं इस उत्तर का उपयोग बहुत छोटे कोडगॉर्फ़िंग युक्तियों के लिए करूँगा, जो मुझे मिला या साथ आया, और अन्य युक्तियों में अभी तक उल्लेख नहीं किया गया है:
स्ट्रिंग के अंतिम चरित्र को हटाना:
// I used to do something like this:
s.substring(0,s.length()-1) // 27 bytes
// But this is shorter:
s.replaceAll(".$","") // 21 bytes
कुछ मामलों में आप जानते हैं कि अंतिम चरित्र पहले से क्या है, और आप यह भी जानते हैं कि यह चरित्र केवल एक बार स्ट्रिंग में होता है। उस स्थिति में आप .split
इसके बजाय उपयोग कर सकते हैं :
// As example: "100%" to "100"
s.split("%")[0] // 15 bytes
एन्कोडिंग शॉर्टकट:
// When you want to get the UTF-8 bytes I used to do this:
s.getBytes("UTF-8"); // 20 bytes
// But you can also use "UTF8" for the same result:
s.getBytes("UTF8"); // 19 bytes
सभी एन्कोडिंग में java.nio
एपीआई में उपयोग किया जाने वाला एक विहित नाम है, साथ ही साथ java.io
और java.lang
एपीआई में उपयोग किया जाने वाला विहित नाम है । यहां जावा में सभी समर्थित एन्कोडिंग की पूरी सूची है। इसलिए हमेशा दो का कम से कम उपयोग करें; दूसरा आमतौर पर छोटा होता है (जैसे UTF-8
बनाम utf8
, Windows-1252
बनाम Cp1252
, आदि), लेकिन हमेशा ( UTF-16BE
बनाम UnicodeBigUnmarked
) नहीं।
रैंडम बूलियन:
// You could do something like this:
new java.util.Random().nextBoolean() // 36 bytes
// But as mentioned before in @Geobits' answer, Math.random() doesn't require an import:
Math.random()<.5 // 16 bytes
अभाज्य संख्या:
Primes की जाँच करने या सभी primes प्राप्त करने के लिए बहुत सारे अलग-अलग तरीके हैं, लेकिन @ सारा का जवाब यहाँ सबसे छोटा है। यहाँ संदर्भ के रूप में एक कॉपी-पेस्ट है:
// Check if n is a prime:
n->{int i=1;for(;n%++i%n>0;);return n==i;}
// Which can easily be modified to loop through primes:
v->{for(int n=2,i;;){for(i=1;n%++i%n>0;);if(n++==i)/*do something with prime `i` here*/;}}
नोट: आमतौर पर आप इसे अन्य मौजूदा छोरों के साथ मर्ज कर सकते हैं जो इस बात पर निर्भर करता है कि आप इसका उपयोग कैसे करना चाहते हैं, इसलिए आपको एक अलग विधि की आवश्यकता नहीं होगी। उदाहरण के लिए इस जवाब में बहुत सारे बाइट्स को बचाया ।
Math.floor / Math.ceil के बजाय पूर्णांक कटौती:
यदि आप पॉजिटिव डबल्स / फ्लोट्स का उपयोग कर रहे हैं और आप floor
उन्हें चाहते हैं, तो इसका उपयोग न करें Math.floor
बल्कि (int)
इसके बजाय एक- एंकल का उपयोग करें (क्योंकि जावा पूर्णांक पर ट्रंकट करता है):
double d = 54.99;
int n=(int)Math.floor(d); // 25 bytes
int m=(int)d; // 13 bytes
// Outputs 54 for both
उसी चाल को नकारात्मक डबल्स / फ्लोट्स पर लागू किया जा सकता है जो आप ceil
इसके बजाय चाहते हैं :
double d = -54.99;
int n=(int)Math.ceil(d); // 24 bytes
int m=(int)d; // 13 bytes
// Outputs -54 for both
उपयोग &1
%2
कोष्ठक से छुटकारा पाने के बजाय :
क्योंकि ऑपरेटर पूर्वता की &
डिफ़ॉल्ट अंकगणितीय ऑपरेटर की तरह से कम है */+-
और %
, आप कुछ मामलों में कोष्टक से छुटकारा मिल सकता है।
// So instead of this:
(i+j)%2 // 7 bytes
// Use this:
i+j&1 // 5 bytes
ध्यान दें कि यह वास्तव में बूलियन-जांच में मदद नहीं करता है, क्योंकि तब आपको अभी भी कोष्ठक की आवश्यकता होगी, वे बस थोड़ा स्थानांतरित हो गए हैं:
(i+j)%2<1 // 9 bytes
(i+j&1)<1 // 9 bytes
BigIntegers और स्थिर विधि कॉल के लिए वैरिएबल बनाना:
BigIntegers का उपयोग करते समय, इसे केवल एक बार बनाएं जिसे आप फिर से उपयोग कर सकते हैं। आपको बता दें कि, BigInteger के लिए स्थिर फ़ील्ड हैं ZERO
, ONE
और TEN
। इसलिए जब आप केवल उन तीनों का उपयोग करते हैं, तो आपको इसकी आवश्यकता नहीं है import
लेकिन java.Math.BigInteger
सीधे उपयोग कर सकते हैं ।
// So instead of this:
import java.math.BigInteger.*;
BigInteger a=BigInteger.ONE,b=BigInteger.ZERO; // 76 bytes
// or this:
java.math.BigInteger a=java.math.BigInteger.ONE,b=a.ZERO; // 57 bytes
// Use this:
java.math.BigInteger t=null,a=t.ONE,b=t.ZERO; // 45 bytes
नोट: आपको इसका उपयोग करना है =null
इसलिए उपयोग करने के t
लिए प्रारंभिक है t.
।
कभी-कभी आप बाइट बचाने के लिए एक और बनाने के लिए कई बिगइंटर जोड़ सकते हैं। तो चलिए 1,10,12
बताते हैं कि आप किसी कारणवश BigIntegers रखना चाहते हैं :
// So instead of this:
BigInteger t=null,a=t.ONE,b=t.TEN,c=new BigInteger(12); // 55 bytes
// Use this:
BigInteger t=null,a=t.ONE,b=t.TEN,c=b.add(a).add(a); // 52 bytes
जैसा कि टिप्पणियों में सही ढंग से बताया गया है, BigInteger t=null;
स्टैटिक मेथड कॉल्स के लिए ट्रिक का उपयोग अन्य वर्गों के साथ भी किया जा सकता है।
उदाहरण के लिए, २०११ के इस जवाब से यह पता लगाया जा सकता है:
// 173 bytes:
import java.util.*;class g{public static void main(String[]p){String[]a=p[0].split(""),b=p[1].split("");Arrays.sort(a);Arrays.sort(b);System.out.print(Arrays.equals(a,b));}}
// 163 bytes
class g{public static void main(String[]p){java.util.Arrays x=null;String[]a=p[0].split(""),b=p[1].split("");x.sort(a);x.sort(b);System.out.print(x.equals(a,b));}}
getBytes()
के बजाय toCharArray()
जब आप एक स्ट्रिंग के पात्रों पर लूप करना चाहते हैं, तो आप आमतौर पर ऐसा करेंगे:
for(char c:s.toCharArray()) // 27 bytes
// or this:
for(String c:s.split("")) // 25 bytes
पात्रों पर लूपिंग उन्हें प्रिंट करते समय, या उन्हें स्ट्रिंग में जोड़कर, या कुछ इसी तरह से उपयोगी हो सकता है।
हालांकि, यदि आप केवल कुछ यूनिकोड-संख्या गणनाओं के लिए चार्ट का उपयोग करते हैं, तो आप के char
साथ बदल सकते हैं int
, और आप के toCharArray()
साथ बदल सकते हैं getBytes()
:
for(int c:s.getBytes()) // 23 bytes
या जावा 8+ में भी छोटा:
s.chars().forEach(c->...) // 22 bytes
जावा 10+ में प्रिंट करने के लिए चरित्र पर 22 बाइट्स में भी किया जा सकता है:
for(var c:s.split("")) // 22 bytes
एक से यादृच्छिक आइटम List
:
List l=...;
// When we have an `import java.util.*;` in our code, shuffling is shortest:
return l.get(new Random().nextInt(l.size())); // 45 bytes
return l.get((int)(Math.random()*l.size())); // 44 bytes
Collections.shuffle(l);return l.get(0); // 39 bytes
// When we don't have an `import java.util.*` in our code, `Math.random` is shortest:
return l.get(new java.util.Random().nextInt(l.size())); // 55 bytes
return l.get((int)(Math.random()*l.size())); // 44 bytes
java.util.Collections.shuffle(l);return l.get(0); // 49 bytes
जाँच करें कि क्या स्ट्रिंग में अग्रणी / अनुगामी स्थान हैं
String s=...;
// I used to use a regex like this:
s.matches(" .*|.* ") // 20 bytes
// But this is shorter:
!s.trim().equals(s) // 19 bytes
// And this is even shorter due to a nice feature of String#trim:
s!=s.trim() // 11 bytes
यह क्यों काम करता है, जब !=
स्ट्रिंग्स पर जावा में मूल्य के बजाय संदर्भ की जांच करनी है? क्योंकि String#trim
" इस स्ट्रिंग की एक प्रतिलिपि को हटाकर श्वेत स्थान की अग्रणी और अनुगामी के साथ या इस स्ट्रिंग को वापस ले लिया जाएगा यदि इसमें कोई अग्रणी या उबलता हुआ सफ़ेद स्थान नहीं है । " मैंने इसका उपयोग किया है, किसी ने मुझे इस उत्तर में, मेरे इस सुझाव के बाद ।
विलोमपद:
यह जांचने के लिए कि क्या स्ट्रिंग एक पैलिंड्रोम है (स्ट्रिंग्स के दोनों और विषम लंबाई को ध्यान में रखते हुए), यह सबसे छोटा है ( .contains
यहाँ काम करता है क्योंकि हम जानते हैं कि स्ट्रिंग ही और इसका उलटा रूप दोनों समान लंबाई के हैं):
String s=...;
s.contains(new StringBuffer(s).reverse()) // 41 bytes
.contains(...)
यहां @assylias की टिप्पणी के.equals(...+"")
लिए धन्यवाद के बजाय ।
या तो 0 है, या दोनों 0 हैं?
मुझे लगता है कि सबसे पहले से ही यह पता है: यदि आप चेक करना चाहते हैं कि a
या तो b
शून्य है या बाइट बचाने के लिए गुणा करें:
a==0|b==0 // 9 bytes
a*b==0 // 6 bytes
और यदि आप यह जाँचना चाहते हैं कि क्या दोनों शून्य हैं a
और b
आप बिटवाइज़-या का उपयोग कर सकते हैं, या उन्हें एक साथ जोड़ सकते हैं यदि वे हमेशा सकारात्मक हों:
a==0&b==0 // 9 bytes
(a|b)==0 // 8 bytes (if either `a`, `b` or both can be negative)
a+b<1 // 5 bytes (this only works if neither `a` nor `b` can be negative)
यहां तक कि = 1, विषम = -1; या ठीक इसके विपरीत
// even = 1; odd = -1:
n%2<1?1:-1 // 10 bytes
1-n%2*2 // 7 bytes
// even = -1; odd = 1:
n%2<1?-1:1 // 10 bytes
n%2*2-1 // 7 bytes
मैं इसे जोड़ने का कारण इस उत्तरk+(k%2<1?1:-1)
में देखने के बाद था :
k+(k%2<1?1:-1) // 14 bytes
// This would already have been shorter:
k%2<1?k+1:k-1 // 13 bytes
// But it can also be:
k%2*-2-~k // 9 bytes
n
पूर्ण कार्यक्रम में लूप समय
यदि हमारे पास एक चुनौती है जहां एक पूर्ण कार्यक्रम अनिवार्य है, और हमें एक विशिष्ट राशि को लूप करने की आवश्यकता है, तो हम निम्नलिखित कर सकते हैं:
// instead of:
interface M{static void main(String[]a){for(int n=50;n-->0;)/*do something*/}} // 78 bytes
// we could do:
interface M{static void main(String[]a){for(M m:new M[50])/*do something*/}} // 76 bytes
जब हम इस सीमा को इनपुट के रूप में लेना चाहते हैं तो वही लागू होता है:
interface M{static void main(String[]a){for(int n=new Byte(a[0]);n-->0;)/*do something*/}} // 90 bytes
interface M{static void main(String[]a){for(M m:new M[new Byte(a[0])])/*do something*/}} // 88 bytes
इस टिप्पणी में @JackAmmo को श्रेय ।
वापसी करते समय ट्राइ-कैच (अपवाद ई) के बजाय प्रयास करें और इसका उपयोग कब करें
यदि आप उपयोग नहीं कर सकते हैं throws Exception
लेकिन catch
लौटने से पहले इसके साथ कुछ करना और करना है, तो आप finally
इसके बजाय उपयोग कर सकते हैं :
try{...}catch(Exception e){return ...;} // 33 bytes
try{...}finally{return ...;} // 22 bytes
उदाहरण के लिए कि कब उपयोग करना है try-catch
, मैं इस जवाब का उल्लेख कर सकता हूं (अप्रत्यक्ष गोल्फ का श्रेय @KamilDrakari को जाता है )। इस चुनौती में हमें NxM मैट्रिक्स पर तिरछे लूप करना होता है, इसलिए हमें यह निर्धारित करना होगा कि कॉलम की मात्रा या पंक्तियों की मात्रा हमारे लूप में अधिकतम के रूप में सबसे कम है (जो बाइट के मामले में काफी महंगा है:) i<Math.min(a.length,a[0].length)
। तो, बस पकड़ने का ArrayIndexOutOfBoundsException
उपयोग catch-finally
इस जांच से कम है, और इस प्रकार बाइट्स बचाता है:
int[] a = ...;
int r=0,i=0;for(;i<Math.min(a.length,a[0].length);)r=...i++...;return r; // 66 bytes
int r=0,i=0;try{for(;;)r=...i++...;}finally{return r;} // 48 bytes
नोट: यह केवल return r;
अंत में के कारण काम किया । मुझे पहली सेल को संशोधित करने का सुझाव दिया गया है, जैसे @KamilDrakari ने बाइट्स बचाने के लिए अपने C # उत्तर में किया। हालांकि, जावा में इसका मतलब है कि मुझे इसे m->{try{for(int i=1;;m[0][0]=f(m[0][0],m[i][i++]));}catch(Exception e){}}
(73 बाइट्स) में बदलना होगा , वास्तव में अगर मैं इस्तेमाल कर सकता हूं तो घटने के बजाय बाइट की गिनती बढ़ाएं finally
।
Math.pow (2, एन)
जब आप 2 की शक्ति चाहते हैं, तो एक बिट-वार दृष्टिकोण बहुत छोटा होता है:
(int)Math.pow(2,n) // 16 bytes
(1<<n) // 6 bytes
कोष्ठक का उपयोग करने के बजाय बिट-वार और तार्किक जांच का संयोजन
मैं अब तक है कि यह अच्छी तरह से जाना जाता है लगता है &
और |
के बजाय इस्तेमाल किया जा सकता &&
और ||
जावा (बुलियन) तार्किक जाँच में। कुछ मामलों में, आप अभी भी त्रुटियों को रोकने के &&
बजाय उपयोग करना चाहते &
हैं, जैसे कि index >= 0 && array[index].doSomething
। यदि इसे यहां पर &&
बदल दिया &
जाएगा, तो यह अभी भी उस हिस्से का मूल्यांकन करेगा जहां यह सरणी में सूचकांक का उपयोग करता है, जिससे ArrayIndexOutOfBoundsException
ए का उपयोग होता है, इसलिए &&
इस मामले में इसके बजाय इसका उपयोग किया जाता है &
।
अब तक जावा में &&
/ ||
बनाम &
/ की मूल बातें |
।
जब आप जांचना चाहते हैं (A or B) and C
, तो सबसे छोटा इस तरह से बिट-बुद्धिमान ऑपरेटरों का उपयोग करने के लिए लग सकता है:
(A|B)&C // 7 bytes
हालांकि, क्योंकि बिट-वार ऑपरेटरों के पास तार्किक जांच के लिए ऑपरेटर की प्राथमिकता होती है , आप यहां एक बाइट को बचाने के लिए दोनों को जोड़ सकते हैं:
A|B&&C // 6 bytes
के n+=...-n
बजाय का उपयोग करें(long)...
जब आपके पास लंबोदर में आउटपुट और आउटपुट दोनों होते हैं, उदाहरण के लिए, उपयोग करने के दौरान Math.pow
, आप बाइट का उपयोग करके सहेज सकते n+=...-n
हैं (long)...
।
उदाहरण के लिए:
n->(long)Math.pow(10,n) // 23 bytes
n->n+=Math.pow(10,n)-n // 22 bytes
इस में एक बाइट बचाया मेरा यह जवाब है, और संयोजन के द्वारा भी दो बाइट्स -n-1
करने +~n
में मेरा यह जवाब ।
package
छोड़ दिया जा सकता है।