जावा में गोल्फिंग के लिए टिप्स


86

क्या जावा में उपयोग किए जा सकने वाले कोई उपयोगी शॉर्टकट हैं?

जैसा कि नीचे दिखाया गया है, importपहले से ही एक कार्यक्रम में कम से कम 17 अक्षर जोड़ता है।

import java.io.*;

मैं समझता हूं कि सरल समाधान किसी अन्य भाषा का उपयोग करना होगा, लेकिन यह जावा कार्यक्रमों को छोटा करने के लिए एक वास्तविक चुनौती प्रतीत होती है।


युक्तियां जावा के लिए विशिष्ट होनी चाहिए: यदि वे अधिकांश सी-लाइक भाषाओं पर लागू होती हैं, तो वे सुझावों की अधिक सामान्य सूची में होती हैं


9
packageछोड़ दिया जा सकता है।
19'12

एक जवाब में, क्या मैं यह मानकर आयात नहीं कर सकता कि वे वहां हैं?
फैब्रिकियो

1
@Fabricio तब तक नहीं जब तक कि ओपी निर्दिष्ट नहीं करता।
nyuszika7h

32
गोल्फिंग जावा के बारे में सबसे अच्छी टिप: इसका उपयोग न करें। ;)
kirbyfan64sos

4
"मुझे जावा में गोल्फ करना है" सौभाग्य
sagiksp

जवाबों:


85
  • सबसे हाल ही में संभव जावा का उपयोग करें। जावा 8 आपको लैम्ब्डा एक्सप्रेशन का उपयोग करने देता है, इसलिए यदि आपको कार्यात्मक वस्तुओं की तरह कुछ भी चाहिए तो इसका उपयोग करें ।

  • उन चीजों के लिए छोटे कार्यों को परिभाषित करें जिनका आप बहुत उपयोग करते हैं। उदाहरण के लिए, आपके पास एक सौ कॉल करने के लिए exampleClassInstance.doSomething(someParameter), एक नए फ़ंक्शन को परिभाषित करने void d(ParameterType p){exampleClassInstance.doSomething(p)}और अपने आप को कुछ वर्णों को बचाने के लिए इसका उपयोग करने के लिए है।

  • यदि आप किसी विशेष लंबे वर्ग के नाम का एक से अधिक बार उपयोग कर रहे हैं, जैसे

    MyEventHandlerProxyQueueExecutorServiceCollectionAccessManagerFactory

    इसके बजाय एक नए वर्ग को परिभाषित करें:

    class X extends MyEventHandlerProxyQueueExecutorServiceCollectionAccessManagerFactory{}

    यदि आप केवल उस वर्ग के एक विशेष तरीके का उपयोग कर रहे हैं (लेकिन फिर भी उसे तुरंत करने की आवश्यकता है), तो आप उसी समय नई कक्षा के अंदर एक संक्षिप्त संस्करण को परिभाषित कर सकते हैं।

  • जहां संभव हो, चीजों को छोटा करने के लिए फ़ंक्शन प्रकार पैरामीटर का उपयोग करें:

    <T>void p(T o){System.out.println(o);}
  • के for(;;)बजाय का उपयोग करें while(true)

  • जब तक बिल्कुल आवश्यक न हो, एक्सेस मॉडिफायर का उपयोग न करें।

  • finalकिसी भी चीज के लिए उपयोग न करें ।

  • forलूप के बाद कभी ब्लॉक न करें (लेकिन एक फ़ॉरच लूप for(x:y)अलग है)। अतिरिक्त स्टेटमेंट को स्टेटमेंट के अंदर forही रखा जाना चाहिए , जैसे for(int i=0;i<m;a(i),b(++i))c(i);

  • इनलाइन असाइनमेंट, इंक्रीमेंट, इंस्टेंटेशन का उपयोग करें। जहाँ उपयुक्त हो, अनाम इनलाइन कक्षाओं का उपयोग करें। यदि संभव हो तो इसके बजाय लंबोदा का उपयोग करें। नेस्ट फ़ंक्शन कॉल करता है। कुछ कार्यों के लिए उनके अभिभावक वस्तु लौटने के लिए गारंटी दी जाती है, इन लोगों को वास्तव में भी कर रहे हैं मतलब एक साथ श्रृंखलित किया जाना है।

  • आपका mainतरीका throws Exceptionएस, उन्हें नहीं पकड़ता है।

  • Errorसे छोटा है Exception। यदि किसी कारण से आपको वास्तवthrow में स्टैक अप संदेशों की आवश्यकता होती है , तो ए का उपयोग करें Error, भले ही यह पूरी तरह से सामान्य स्थिति हो।

  • यदि कुछ स्थिति में तत्काल समाप्ति की आवश्यकता होती है, तो int a=1/0;इसके बजाय throw null;या का उपयोग करें System.exit(0);। रन समय में, यह एक फेंकता है ArithmeticException। यदि आपके पास पहले से ही अपने कोड में एक संख्यात्मक चर है, तो इसके बजाय इसका उपयोग करें। (यदि आपके पास पहले से है import static java.lang.System.*;, तो साथ जाएं exit(0);।)

  • लागू करने के बजाय इंटरफेस, जैसे List<E>, एक तत्काल (या नहीं-तो-तत्काल, यदि कोई ऐसा करने का कोई फायदा है) का विस्तार करें, तो बच्चा वर्ग, जैसे AbstractList<E>, जो अधिकांश विधियों के डिफ़ॉल्ट कार्यान्वयन प्रदान करता है, और केवल कार्यान्वयन की आवश्यकता होती है कुछ प्रमुख टुकड़े।

  • अपने कोड को लॉन्गहैंड में पहले लिखें, नए अंक, इंडेंटेशन और पूर्ण चर नामों के साथ। एक बार जब आपके पास काम करने का कोड आ जाता है, तो आप नामों को छोटा कर सकते हैं, घोषणाओं को आगे बढ़ा सकते हैं, और शॉर्टकट तरीके जोड़ सकते हैं। इसे शुरू करने के लिए लंबे समय तक लिखने से, आप अपने आप को एक पूरे के रूप में कार्यक्रम को सरल बनाने का अधिक अवसर देते हैं।

  • वैकल्पिक ऑप्टिमाइज़ेशन की तुलना कोड के एक टुकड़े से करें, क्योंकि सबसे इष्टतम रणनीति कोड में बहुत छोटे बदलाव के साथ नाटकीय रूप से बदल सकती है। उदाहरण के लिए:

    • यदि आपके पास केवल दो कॉल तक हैं Arrays.sort(a), तो इसका सबसे प्रभावी तरीका यह है कि इसे पूरी तरह से योग्य नाम के साथ कॉल करें java.util.Arrays.sort(a)
    • तीन या अधिक कॉल के साथ, यह शॉर्टकट विधि जोड़ने के बजाय अधिक कुशल है void s(int[]a){java.util.Arrays.sort(a);}। यह अभी भी इस मामले में पूरी तरह से योग्य नाम का उपयोग करना चाहिए। (यदि आपको एक से अधिक अधिभार की आवश्यकता है, तो आप शायद इसे गलत कर रहे हैं।)
    • हालांकि, यदि आपके कोड को किसी बिंदु पर एक सरणी की प्रतिलिपि बनाने की आवश्यकता है (आमतौर पर forआसानी से सुलभ पुस्तकालय पद्धति की अनुपस्थिति में, गोल्फ में एक शॉर्ट लूप के साथ किया जाता है ), तो आप Arrays.copyOfकार्य करने के लिए लाभ उठा सकते हैं । जब एक से अधिक तरीकों का उपयोग किया जाता है, और 3 या अधिक कॉल होते हैं, तो import static java.util.Arrays.*;करना उन तरीकों को संदर्भित करने का सबसे कुशल तरीका है। उसके बाद, यदि आपके पास 8 से अधिक अलग-अलग कॉल हैं, तो sortक्या आपको इसके लिए एक शॉर्टकट विधि का उपयोग करना चाहिए, और केवल 5 या अधिक कॉल के लिए एक शॉर्टकट वारंट है copyOf

    कोड पर इस तरह के विश्लेषण करने का एकमात्र वास्तविक तरीका वास्तव में कोड की प्रतियों पर संभावित संशोधन करना है, और फिर परिणामों की तुलना करना है।

  • someTypeValue.toString();सिर्फ एपेंड करने के बजाय, पद्धति का उपयोग करने से बचें someTypeValue+""

  • यदि आपको विंडोज़ की आवश्यकता है, तो स्विंग का उपयोग न करें, AWT का उपयोग करें (जब तक कि आपको वास्तव में स्विंग से कुछ की आवश्यकता न हो)। तुलना import javax.swing.*;और import java.awt.*;। साथ ही, स्विंग में घटकों एक है Jउनके नाम (के लिए prepended JFrame, JLabel, आदि), लेकिन AWT में घटकों नहीं है ( Frame, Label, आदि)


43

के interfaceबजाय का उपयोग करें class

जावा 8 में, स्थिर तरीकों को इंटरफेस में जोड़ा गया था। इंटरफेस में, डिफ़ॉल्ट रूप से सभी तरीके सार्वजनिक हैं। इसके फलस्वरूप

class A{public static void main(String[]a){}}

अब छोटा किया जा सकता है

interface A{static void main(String[]a){}}

जो स्पष्ट रूप से कम है।

उदाहरण के लिए, मैंने हैलो, वर्ल्ड में इस फीचर का इस्तेमाल किया ! चुनौती।


8
मुझे नहीं पता था कि! +1, अच्छी चाल
HyperNeutrino

हाँ, कम बॉयलर!
कैलक्यूलेटरफलाइन

3
मुझे आंशिक रूप से असहमत होना पड़ता है (साथ ही, मैंने आपको "हैलो, वर्ल्ड!" चैलेंज में हरा दिया , उस तकनीक का उपयोग करके)।
ओलिवियर ग्रेगोइरे

37

Varargs के साथ आप एक पैरामीटर को उसी प्रकार की एक सरणी में "कास्ट" कर सकते हैं:

void f(String...x){
    x=x[0].split("someregex");
    // some code using the array
}

के बजाय

void f(String s){
    String[]x=s.split("someregex");
    // some code using the array
}

31

एक साथ स्थिर आयात :

import static java.lang.System.out;
// even shorter (thanks to Johannes Kuhn):
import static java.lang.System.*;

आप बाद में कुछ बॉयलरप्लेट बचा सकते हैं, लेकिन आपको भुगतान प्राप्त करने के लिए कई इनवोकेशन की आवश्यकता होती है:

public static void main (String[] args) {
    out.println ("foo");    
    out.println ("bar");    
    out.println ("baz");    
}

8
: हे। तुम यह केर सकते हो?! और यह सब समय मैंने सोचा कि यह असंभव था Java!
जस्टिन

12
आप भी उपयोग कर सकते हैं import static java.lang.System.*
जोहान्स कुह्न

1
मुझे पता है कि यह एक पुराना उत्तर है, लेकिन जावा 10 में अब आप ऐसा कर सकते हैं, var o=System.out;जिसका भुगतान करने से पहले केवल दो बार उपयोग करने की आवश्यकता है
ल्यूक स्टीवंस

@LukeStevens: ठीक है, हो सकता है कि आपको Java10 के साथ कुछ और सुधार मिलें, और Java10 के आसपास एक अलग उत्तर दें?
उपयोगकर्ता अनजान

1
@LukeStevens var o=System.out.printlnकाम करेगा?
मिल्कीवेय 90

25

तर्क को mainबुलाया नहीं जाना है args, और आप कुछ व्हाट्सएप काट सकते हैं:

public static void main(String[]a){}

ठीक ही करेंगे।


1
यदि मुख्य कार्यक्रम में पूर्ण कार्यक्रम लिखने के लिए स्पष्ट रूप से राज्य नहीं है, तो क्या उत्तर को शामिल करने की आवश्यकता है? मैं जवाब के रूप में लंबोदर भाव का उपयोग कर रहा हूं।
मकोतोसन

3
@Makotosan नहीं वे नहीं; लैम्ब्डा आमतौर पर ठीक होते हैं।
डेनियरो

21

यदि आपको कभी बूलियन अभिव्यक्तियों का उपयोग करना है trueया false, उन्हें क्रमशः 1>0और साथ में बदलें 1<0

उदाहरण के लिए:

boolean found=false;
for(i=0; i<10; i++) if(a[i]==42) found=true;

इस रैखिक खोज उदाहरण को कम किया जा सकता है

boolean f=1<0;
for(i=0;i<10;)if(a[i++]==42)f=1>0;

11
यदि आपको बहुत अधिक आवश्यकता हो true/false, तो बस जोड़ें boolean t=1>0,f=1<0;। फिर इसके बजाय 1>0, उपयोग tऔर उपयोग प्रति दो वर्ण बचाओ। पेऑफ 1>0मेथड 10 उपयोग में आता है।
Geobits

24
@Geobits: boolean t=1>0,f=!t;- एक चार छोटी!
बोबेल

6
उदाहरण वास्तव में अच्छा नहीं है। इस मामले में और कई (!) दूसरों को आप वैसे भी true/ falseसीधे उपयोग करने से बच सकते हैं : f|=a[i++]==42;काफी बचाता है।
इंगो बुर्क

@ IngoBürk सच। जब मैं यह लिख रहा था तो मैं ज्यादातर पुस्तकालय कार्यों के बारे में सोच रहा था जो उपयोग करता है boolean, लेकिन चूंकि मैं लेखन के समय किसी भी उदाहरण के साथ नहीं आ सका (मैं आमतौर पर जावा में कोड नहीं करता) मैंने सिर्फ एक सरल उदाहरण लिखा था।
ace_HongKongIndependence

1
@ जीबिट्स भी जावा से परिचित नहीं हैं, लेकिन क्या आप सिर्फ 1 को परिभाषित कर सकते हैं और टी और टी का उपयोग कर सकते हैं (फिर से मुझे जावा नहीं पता, बस जिज्ञासु)
अल्बर्ट रेनशॉ

20

यदि आप किसी विधि का बहुत उपयोग करने जा रहे हैं, तो इसके निवासी वर्ग को एक चर में असाइन करें। उदाहरण के लिए, System.outएक चर को असाइन करें:

java.io.PrintStream o=System.out;
//now I can call o.print() or o.println() to the same effect as System.out.println()

इसके लिए भी Integer.parseInt():

Integer i=1;
i.parseInt("some string");

यह लगभग निश्चित रूप से "चर से स्थिर विधि तक पहुँचने" के बारे में एक विचारधारा को ट्रिगर करेगा


((Integer)1).parseInt("1")काम भी करता है।
मैजिक ऑक्टोपस Urn

5
@carusocomputing new Integer("1")और भी छोटी है। लेकिन जस्टिन को अपने जवाब से क्या मतलब है कि आप स्थिर कॉल के लिए आपके पास पहले से मौजूद चर का पुन: उपयोग कर सकते हैं। जैसा कि मैं इस जवाब के तल पर समझाता हूं।
केविन क्रूज़सेन

19

बयानों import static java.lang.System.*को सहेजने के लिए तकनीक का उपयोग करने के बजाय println(), मैंने पाया है कि पात्रों को बचाने के लिए निम्न विधि को परिभाषित करना अधिक प्रभावी है:

static<T>void p(T p){
    System.out.println(p);
}

इसका कारण यह है कि इसके p(myString)बजाय इसे लागू किया जा सकता है out.println(myString)जिसके पास बहुत तेज और अधिक नाटकीय चरित्र अदायगी है।


19

यह स्पष्ट लग सकता है, लेकिन कुछ Mathकार्यों के लिए छोटे विकल्प हैं :

a=Math.max(b,c);
a=b>c?b:c;

a=Math.min(b,c);
a=b<c?b:c;

a=Math.abs(b);
a=b<0?-b:b;

a=Math.round(b);
a=(int)(b+.5);          // watch for precision loss if it matters

14

यदि आपको जरूरत है Integer.MAX_VALUE(2147483647), का उपयोग करें -1>>>1Integer.MIN_VALUE(-2147483648) बेहतर लिखा है 1<<31


14

यदि आपको किसी तर्क (या किसी अन्य स्ट्रिंग) से किसी संख्या को हथियाने की आवश्यकता है , तो आमतौर पर आपको कुछ ऐसा दिखाई देता है:

public static void main(String[]a){
    int n=Integer.valueOf(a[0]);
    ...
}

कई बार, आप नहीं है की जरूरत है एक Integer। बड़ी संख्या में चुनौतियों का उपयोग नहीं करते। चूंकि Shortऔर Byteदोनों एक से अनबॉक्स करेंगे int, valueOf()इसके बजाय अधिक उपयुक्त का उपयोग करें और युगल बाइट को बचाएं।

अपने वास्तविक चर को एक के रूप में रखें int, हालाँकि, क्योंकि यह दोनों से छोटा है byteऔर short:

int n=Byte.valueOf(a[0]);

यदि आपको कई संख्याओं के लिए ऐसा करने की आवश्यकता है, तो आप इस विधि के साथ संयोजन कर सकते हैं :

Byte b=1;
int n=b.valueOf(a[0]),m=b.valueOf(a[1])...

9
int n=new Byte(a[0]);तीन छोटे है। यदि संख्या अधिक हो सकती है, तो उपयोग करें long n=new Long(a[0]), यह अभी भी intज्यादातर मामलों में एस से बेहतर है ।
यपनीपैन

14

उपयोग न करें public class। मुख्य विधि को सार्वजनिक करने की आवश्यकता है, लेकिन इसका वर्ग नहीं करता है। यह कोड काम करता है:

class S{public static void main(String[]a){System.out.println("works");}}

आप सार्वजनिक वर्ग नहीं java Sहोने के बावजूद भी दौड़ सकते हैं class S। ( अपडेट: जब मैंने इस टिप को लिखा था, तो मैं जावा 7 का उपयोग कर रहा था। जावा 8 में, आपकी मुख्य विधि एक इंटरफेस में होनी चाहिए । जावा 5 या 6 में, आपका मुख्य तरीका एक एनम में होना चाहिए ।)

बहुत से जावा प्रोग्रामर यह नहीं जानते हैं! गैर-सार्वजनिक वर्ग में मुख्य के बारे में एक स्टैक ओवरफ्लो प्रश्न के लगभग आधे उत्तर गलत तरीके से दावा करते हैं कि मुख्य विधि एक सार्वजनिक वर्ग में होनी चाहिए। अब आप बेहतर जानते हैं। हटाएँ publicमें public classऔर 7 वर्ण सहेजें।


1
जब तक आप 1.8 से पहले जावा को लक्षित नहीं कर रहे हैं, तब तक निर्माण interface s{static void main(String[]...कम है। यदि आपके पास एक अनिवार्य स्रोत फ़ाइल और मुख्य विधि होनी चाहिए। क्योंकि Java 1.8 इंटरफ़ेस में, सभी विधियाँ सार्वजनिक हैं, इसलिए आप संशोधक को विधि पर छोड़ सकते हैं।
डगलस हेल्ड

मैंने हाल ही में जावा का उपयोग नहीं किया है, इसलिए मेरा उत्तर पुराना हो रहा है। मैं भूल गया कि इंटरफेस में 8 तरीके हो सकते हैं। 8
kernigh

मैंने इसे प्रोग्रामिंग से नहीं सीखा; मैंने इसे गोल्फिंग से सीखा
डगलस हेल्ड

14

कुछ छोटे कोड-गोल्फ टिप्स

अलग-अलग उत्तरों के लिए ये युक्तियां थोड़ी बहुत छोटी थीं, इसलिए मैं इस उत्तर का उपयोग बहुत छोटे कोडगॉर्फ़िंग युक्तियों के लिए करूँगा, जो मुझे मिला या साथ आया, और अन्य युक्तियों में अभी तक उल्लेख नहीं किया गया है:

स्ट्रिंग के अंतिम चरित्र को हटाना:

// 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में मेरा यह जवाब


आमतौर पर आपके अंतिम बिंदु के लिए, आप स्थैतिक सदस्यों को गैर-स्थैतिक संदर्भ से वस्तु के उदाहरण के रूप में एक्सेस / इनवॉइस कर सकते हैं।
प्रहार

1
मुझे आपकी छत की नोक समझ में नहीं आती। आप छत क्यों लेना चाहेंगे positive integers? इसके अलावा, मुझे यकीन नहीं है कि अगर छत कार्यान्वयन कार्य करता है
जोनाथन फ्रीच

1
since Java automatically floors on integers; मुझे लगता है कि उचित शब्द ट्रंकेशन है , न कि फर्श
जोनाथन फ्रेच

1
एक अन्य पैलिंड्रोम रणनीतिString t="";for(int i=s.length();--i>=0;t+=s.charAt(i));return s.equals(t);
रॉबर्टो ग्राहम

1
@RobertoGraham मैंने वास्तव में गलत चुनौती से अपने मूल कोड की नकल की .. बस s.equals(new StringBuffer(s).reverse()+"")काफी है।
केविन क्रूज़सेन

11

गोल्फ के लिए जिसे इनपुट की आवश्यकता नहीं है, आप स्थैतिक ब्लॉक का उपयोग कर सकते हैं, और इसे बिना किसी मुख्य विधि के ठीक ठीक चला सकते हैं, बस इसे जावा 6 के साथ संकलित करें।

public class StaticExample{
    static {
        //do stuff
    }
}

1
क्या आपने इसे संकलित करने और चलाने का प्रयास किया? यह ब्लॉक तब चलाया जाता है जब क्लास लोडर द्वारा क्लास लोड हो जाती है। लेकिन क्लास लोडर तब तक कुछ भी लोड नहीं करेगा जब तक कि उसे क्लास के बारे में पता न हो।
क्रंचर

@ क्रंचर आप javaकमांड लाइन / एक मैनिफ़ेस्ट फ़ाइल में बता सकते हैं कि कौन सी क्लास को लोड करना है।
AJMansfield

6
@ क्रंचर, इसने जावा 6 के साथ काम किया। जावा 7 ने इसके काम करने के तरीके को बदल दिया।
पीटर टेलर

1
अंत में एक अपवाद फेंकता है, लेकिन यह काम करता है! यहां तक ​​कि जावा 7 में
16

2
@JopVernooij यदि आप अपने चेहरे पर एक अपवाद नहीं रखना चाहते हैं, तो आप system.exit () कर सकते हैं, लेकिन आप पात्रों को बेकार कर देंगे, कोई भी गोल्फ चुनौती कभी भी आपको अपवादों से बचने के लिए नहीं कहती;)
Fabinout

11

हम सभी बिटव्यू एक्सोर के बारे में जानते हैं (^ ) के , लेकिन यह एक तार्किक एक्सर भी है।

तो (a||b)&&!(a&&b)बस बन जाता हैa^b

अब हम xor का उपयोग कर सकते हैं।

इसके अतिरिक्त , ऑपरेटर |और & भी काम करते हैं , बस याद रखें कि ऑपरेटर की पूर्ववर्ती स्थिति बदल जाती है।


5
जब तक आप पूर्वता को याद करते हैं, तब तक आप उपयोग कर सकते हैं & और |भी। यह उपयोगी हो सकता है यदि आपकी स्थिति पहले से ही कोष्ठक में है, या यदि आप पहले से ही बूलियन्स के साथ काम कर रहे हैं।
Geobits

1
यदि आपको निम्न (बहुत) कम वरीयता की आवश्यकता है, तो आप xor के !=बजाय ^, और ==xnor के लिए उपयोग कर सकते हैं
Cyoce

11

आप का उपयोग करने की जरूरत नहीं है Character.toLowerCase(char c)। इसके बजाय उपयोग करें (c|32)Character.toUpperCase(char c)उपयोग के बजाय (c&~32)। यह केवल ASCII अक्षरों के साथ काम करता है।


c|~32-1 में परिणाम होगा ... बेहतर का उपयोग करने के लिए c-32
feersum

5
@ फैर्सम यदि आप एक ऊपरी केस लेटर को अपर केस बनाना चाहते हैं तो यह काम नहीं करेगा।
TheNumberOne

11

स्ट्रिंग को संख्या में बदलें

एक स्ट्रिंग को संख्यात्मक मान में बदलने के कई तरीके हैं:

String s = "12";

ABC.parseABC :

Short.parseShort(s); // 20 bytes
Integer.parseInt(s); // 20 bytes
Long.parseLong(s);   // 18 bytes

ABC.valueOf :

Short.valueOf(s);    // 17 bytes
Integer.valueOf(s);  // 19 bytes
Long.valueOf(s);     // 16 bytes

ABC.decode :

// Note: does not work for numeric values with leading zeros,
// since these will be converted to octal numbers instead
Short.decode(s);     // 16 bytes
Integer.decode(s);   // 18 bytes
Long.decode(s);      // 15 bytes

नई एबीसी :

new Short(s);        // 13 bytes
new Integer(s);      // 15 bytes
new Long(s);         // 12 bytes

इसलिए, कोड-गोल्फिंग के लिए, स्ट्रिंग को संख्यात्मक मान में कनवर्ट करते समय कंस्ट्रक्टर का उपयोग करना सबसे अच्छा है।

वही लागू होता है Double; Float; और Byte


यह हमेशा लागू नहीं होता है जब आप ऑब्जेक्ट के रूप में पहले से ही मौजूद आदिम का फिर से उपयोग कर सकते हैं।
उदाहरण के लिए, मान लें कि हमारे पास निम्नलिखित कोड हैं:

// NOTE: Pretty bad example, because changing the short to int would probably be shorter..
//       but it's just an example to get the point across

short f(short i,String s){
  short r=new Short(s);  // 21 bytes
  ... // Do something with both shorts
}

आप .decodeऑब्जेक्ट के रूप में पैरामीटर को फिर से उपयोग करके छोटे कंस्ट्रक्टर के बजाय उपयोग कर सकते हैं :

short f(Short i,String s){   // Note the short parameter has changed to Short here
  short r=i.decode(s);   // 20 bytes
  ... // Do something with both shorts
}

10

उपयोग न करें Random!

सामान्य तौर पर, अगर आपको यादृच्छिक संख्याओं की आवश्यकता है , तो इसकेRandom बारे में जाने का एक भयानक तरीका है *। Math.random()इसके बजाय उपयोग करने के लिए बेहतर है । उपयोग करने के लिए Random, आपको यह करने की आवश्यकता है (मान लें कि हमें इसकी आवश्यकता है int):

import java.util.*;
Random r=new Random();
a=r.nextInt(9);
b=r.nextInt(9);

इसकी तुलना करें:

a=(int)(Math.random()*9);
b=(int)(Math.random()*9);

तथा:

int r(int m){return(int)(Math.random()*m);}
a=r(9);
b=r(9);

पहला तरीका 41+15nवर्ण लेता है ( nकॉल की संख्या है)। दूसरा 25nवर्ण है, और तीसरा है 43+7n

इसलिए, यदि आपको केवल एक या दो बार इसकी आवश्यकता है, तो इनलाइन Math.random()विधि का उपयोग करें । तीन या अधिक कॉल के लिए, आप एक फ़ंक्शन का उपयोग करके सहेजेंगे। या तो पहले अक्षर के उपयोग से कोई बचाता है Random


आप पहले से ही उपयोग कर रहे हैं Math.random()के लिए double, चार का उपयोग करता है पर कि याद है, यह अभी भी एक बचत में इसे बाहर खींच रहा है:

double r(){return Math.random();}

33 वर्णों के लिए, आप प्रत्येक कॉल पर 10 सहेजेंगे r()


अपडेट करें

यदि आपको एक पूर्णांक की आवश्यकता है और कास्टिंग पर बचत करना चाहते हैं, तो उसे मत डालें! यदि आप एक असाइनमेंट के बजाय एक ऑपरेशन करते हैं, तो जावा ऑटो-कास्ट। की तुलना करें:

a=(int)(Math.random()*9);
a=9;a*=Math.random();

* जब तक कि आपको पूर्वानुमानित परिणामों के लिए PRNG को बीज न देना पड़े। फिर, मुझे इसके आस-पास ज्यादा रास्ता दिखाई नहीं देता।


2
Random#nextGaussianहालांकि के बारे में मत भूलना ।
जस्टिन

@Quincunx सच है, एक अच्छा सामान्य वितरण प्राप्त करने के लिए गणित करने से आपको जो भी बचत होती है वह आपको खो देती है। मैं केवल उस अपवाद के रूप में उल्लेख करूंगा जो नियम को सिद्ध करता है;)
ज्योबिट्स

ध्यान दें कि (int)(Math.random()*9)बहुत छोटा मोडुलो पूर्वाग्रह है, क्योंकि Math.random()2 53 संभावित मान लौटाता है , और 2 53 9 का एक गुणक नहीं है। प्रत्येक संख्या की संभावना 1/9 प्लस या माइनस 5 / (9 * 2 ** 53) के भीतर है, एक त्रुटि इतनी छोटी है, यह लगभग 1/9 है।
कर्निग

@kernigh राइट, मैं 9सिर्फ एक उदाहरण के रूप में उपयोग कर रहा था , यह कुछ भी हो सकता है। मुझे अपेक्षाकृत यकीन है कि nextInt()(या किसी अन्य Randomविधि) में जावा के PRNG के काम करने के तरीके के साथ-साथ एक छोटा सा पूर्वाग्रह भी है।
जियोबिट्स

1
जब आप एक यादृच्छिक बूलियन चाहते हैं तो इससे संबंधित कुछ: इसके बजाय new java.util.Random().nextBoolean()आप उपयोग कर सकते हैं Math.random()<.5
केविन क्रूजसेन 14

7

मुझे नहीं पता कि आप इस 'शुद्ध' जावा पर विचार करेंगे, लेकिन प्रसंस्करण आपको थोड़े प्रारंभिक सेटअप (स्वचालित रूप से पूर्ण) के साथ प्रोग्राम बनाने की अनुमति देता है।

कंसोल आउटपुट के लिए, आपके पास कुछ सरल हो सकता है:

println("hi"); //done

चित्रमय आउटपुट के लिए, थोड़ा और अधिक:

void setup() {
  size(640,480);
}
void draw() {
  fill(255,0,0); //color used to fill shapes
  rect(50,50,25,25); //25x25 pixel square at x=50,y=50
}

1
+1 उत्कृष्ट संसाधन! मैं इसके साथ खेलना सुनिश्चित करूँगा।
रोब

क्या यह ठीक होगा यदि मैंने अन्य लोगों के उत्तर इस एक के साथ जोड़ दिए? या कि एक समुदाय विकि के उद्देश्य को पराजित करता है?
रोब

2
वैसे, आपको कॉल करने की भी आवश्यकता नहीं है size; यह 100 बाय 100 पिक्सेल वर्ग में डिफ़ॉल्ट होगा। अधिकांश OSes में, इसके चारों ओर का फ्रेम लगभग दो गुना बड़ा होगा, जिसमें वर्ग केंद्रित होगा और शेष क्षेत्र डेस्कटॉप से ​​ली गई सामग्री से भरा होगा।
AJMansfield

1
ग्राफिकल आउटपुट के लिए, यदि आपको एनीमेशन की आवश्यकता नहीं है, तो आप बस बाहर सब कुछ लिख सकते हैं setup()और draw()"स्थिर मोड" का उपयोग कर सकते हैं । आप 6-अंकीय हेक्स रंगों का भी उपयोग कर सकते हैं और दुभाषिया उन्हें बदल देगा, जो कभी-कभी भुगतान करता है ( #FF8000< 255,128,0), और यदि आप greyscale का उपयोग कर रहे हैं तो केवल एक संख्या को निर्दिष्ट करने की आवश्यकता है ( 255< 255,255,255)
quat

7

छोटा लौट रहा है

आप एक बाइट द्वारा स्ट्रिंग्स के विवरण को छोटा कर सकते हैं:

return "something";

सेवा

return"something";

और, यदि आप कोष्ठक के साथ अपना वापसी कथन शुरू करते हैं, तो आप उनके साथ भी ऐसा कर सकते हैं:

return (1+taxRate)*value;

सेवा

return(1+taxRate)*value;

मुझे लगता है कि उद्धरण को पैरेंटहिल्स की तरह माना जाता है? मैंने वास्तव में AppleScript के माध्यम से इसे उठाया, मजेदार रूप से पर्याप्त, और सोचा कि यह उल्लेख के लायक हो सकता है।


1
समान संख्या संकेतों पर लागू होता है, जैसे कि return-n;इसके बजाय return -n;या के return~n;बजाय return ~n;। साथ ही डबल कोट्स के बजाय सिंगल:return'A';
केविन क्रूज़सेन

1
मूल रूप से, किसी भी चीज़ के लिए काम करता है जो पहचानकर्ता (यानी गैर-अक्षर और गैर-अंक) का हिस्सा नहीं हो सकता है।
पाओलो एबरमन

7

वैज्ञानिक संकेतन का उपयोग करने से डरो मत

यदि आप युगल, या फ़्लोट्स के साथ काम कर रहे हैं, तो आप संख्याओं के लिए वैज्ञानिक संकेतन का उपयोग कर सकते हैं। इसलिए लिखने के बजाय double a=1000आप इसे double a=1e31 बाइट बचाने के लिए बदल सकते हैं ।


7

के intबजाय का उपयोग करने का प्रयास करेंboolean

कुछ मामलों में मैंने पाया है कि यह एक विधि से पूर्णांक मान को लौटाने के लिए कम है जो सामान्य रूप से एक बूलियन लौटाएगा, इसी तरह सी कार्यक्रमों में भी किया जा सकता है।

बल्ले intसे राइट 4 बाइट से छोटा है boolean। हर बार जब आप return 0इसके बजाय लिखते हैं return 1<0, तो आप एक अतिरिक्त 2 बाइट्स और एक ही return 1 ओवर के लिए बचाते हैं return 1>0

यहाँ नुकसान यह है कि हर बार जब आप एक बूलियन के रूप में सीधे रिटर्न मूल्य का उपयोग करना चाहते हैं, तो इसकी कीमत 2 बाइट्स ( if(p(n))v। if(p(n)>0)) होती है। यह बूलियन अंकगणित के उपयोग के लिए बनाया जा सकता है। एक वंचित परिदृश्य को देखते हुए जहाँ आप लिखना चाहते हैं

void a(int[]t){t[0]+=p(n)?10:0;}

आप इसके बजाय लिख सकते हैं

void a(int[]t){t[0]+=p(n)*10;}

2 बाइट्स बचाने के लिए।


6
मैं बहुत अक्सर ऐसा करते हैं जब गोल्फ, लेकिन ध्यान रखें कि आम सहमति है कि है 0और 1झूठी / जावा में सच गठन नहीं है (और JLS उन्हें उस तरह से या तो विचार नहीं करता है)। इसलिए यदि गोल्फ विशेष रूप से सच्चाई / झूठ बोल रहा है, तो आपको इसे बुलबुल करने की आवश्यकता है (और, दुर्भाग्य से, इसे एक booleanफ़ंक्शन बनाएं , इस पर और भी बाइट्स फेंकना)।
Geobits

2
t[0]+=p(n):10?0;क्या यह भी मान्य है?
दुरुकयहन

@dorukayhan नहीं, इसका मतलब है t[0]+=p(n)?10:0;। (मैंने इसे संपादित किया।)
पाओलो एबरमन

6

यदि आप कक्षा के बजाय एनम का उपयोग करते हैं , तो आप एक वर्ण को बचाते हैं।

enum NoClass {
    F, G, H;    
    public static void main (String[] args) {

    }
}

लेकिन आपको इस उदाहरण में कम से कम एक enum उदाहरण (F, G, H) का परिचय देना होगा, जिसे स्वयं भुगतान करना होगा।


2
लगता है कि आप किसी भी उदाहरण की जरूरत नहीं है। मैंने enum M{;public static void main(String[]a){...}कोई समस्या नहीं की।
डैनी

3
@ डैनी लेकिन फिर यह किसी भी पात्र को नहीं बचाती है। class M{के रूप में बिल्कुल वैसी ही लंबाई है enum M{;। उस स्थिति में, मैं इसके साथ जाऊँगा classक्योंकि यह प्रेटियर (IMO) है
जस्टिन

1
कम से कम मेरे बाद enum{बिना काम किए ;; इसकी एकमात्र आईडीई कराह रही है कि एक त्रुटि है बट्टे संकलक इसे स्वीकार करता है
मास्टरएक्स 244

@ masterX244 क्या संकलक / संस्करण? मेरा एक तंत्र-मंत्र फेंकता है और वह ऐसा नहीं करेगा।
ज्योबिट्स

मेरे लिए java 1.7 पर काम किया (s दिखाई दिया, एक अद्यतन के साथ आगे के कारण की जांच करने के लिए
ned।

5

जब आपके पास एक विधि होती है जो booleanया तो वापस आनी चाहिए Boolean:

// Return true if the (non-negative) input is dividable by 5
boolean c(int i){return i%5<1;}

आप 1 बाइट बचाने के लिए boolean/ Booleanवापसी प्रकार बदल सकते हैं Object:

Object c(int i){return i%5<1;}

इसके अलावा, जैसा कि आपने देखा होगा, आप बाइट को बचाने के <1बजाय चेक का उपयोग कर सकते हैं ==0। हालांकि यह जावा-विशिष्ट के बजाय एक सामान्य कोड-गोल्फ टिप है।
यह ज्यादातर तब उपयोग किया जाता है जब पूर्णांक ऋणात्मक नहीं हो सकता है, जैसे लंबाई की जाँच करना:

a.length<1

के बजाय

a.length==0

1
अच्छी टिप! आप "उदाहरण के लिए, यदि यह नकारात्मक नहीं हो सकता है" अनुभाग में इसे उदाहरण के लिए एक और उदाहरण जोड़ना चाहते हैं, क्योंकि वर्तमान के साथ c(-21)रिटर्न true
जियोबिट्स

स्पष्ट किया। इसके अलावा, आप के c(-20)बजाय मतलब नहीं है -21? -21 % 5 = 4और -20 % 5 = 0
केविन क्रूज़सेन

1
नहीं, मेरा मतलब था -21-21 % 5 != 4जावा में, जो मेरी बात है। पांच फ़ंक्शन द्वारा विभाज्य सही ढंग से काम करेगा यदि मापांक हमेशा गैर-नकारात्मक लौटा हो, लेकिन ऐसा नहीं है। इस उदाहरण को देखें स्निपेट
भूतकाल

@Geobits आह, उदाहरण के लिए धन्यवाद। मैं लगभग कभी भी ऋणात्मक संख्याओं का उपयोग नहीं करता हूं %, इसलिए मैं भूल गया कि जावा मापांक के बजाय शेष रिटर्न देता है, इसलिए अंतर ..
केविन क्रूज़सेन

5

जावा में कैसे आकर्षित करें ...

यहां सबसे छोटा संभव जीयूआई पेंट बॉयलर-प्लेट है:

import java.awt.*;
static void main(String[]x){
    new Frame(){
        public void paint(Graphics g){
            // Draw your stuff here.
        }    
    }.show();
}

111 बाइट्स के लिए गोल्फ:

import java.awt.*;static void main(String[]x){new Frame(){public void paint(Graphics g){/*CodeHere*/}}.show();}

5

StringBuilderएस से बचें

एक Stringबहुत कम बाइट लेने के लिए सामान लागू करना ।

// s is a StringBuilder
s.append("Hello, World!");

// S is a String
S+="Hello, World!";

यदि आपको एक स्ट्रिंग को उल्टा करना है और इसे तुरंत प्रिंट करना है, तो ए का उपयोग करें StringBuffer

System.out.print(new StringBuilder("Hello, World!").reverse());
System.out.print(new StringBuffer("Hello, World!").reverse()); // Note that you can omit toString() when printing a non-String object

यदि आपको एक स्ट्रिंग को उल्टा करना है और फिर इसे प्रिंट करने के अलावा कुछ और करना है, तो forप्रत्येक लूप का उपयोग करें ।

String b=new StringBuffer("Hello, World!").reverse().toString();
String B="";for(String c:"Hello, World!".split(""))B=c+B;

3
एक फॉरेस्ट लूप StringBufferतार को उलटने के लिए कम है । String b="";for(char c:"Hello, World!".toCharArray()){b=c+b;}
प्रहार

1
{}यदि आप उस विधि का उपयोग करने जा रहे हैं, तो आपको उस फ़ॉरेस्ट लूप से भी हटा देना चाहिए ।
भूतकाल

1
के String s:"".split("")बजाय का उपयोग कर 2 बाइट बचाओ char c:"".toCharArray()
चार्ली

यदि आप पहले से java.util.stream.Streamही आयात कर चुके हैं , और यदि आपको परिणाम के लिए एक और कॉल की श्रृंखला करने की आवश्यकता है (जैसे B.chartAt(42)) या यदि आपको परिणाम को किसी फ़ंक्शन (जैसे f(B)) को पास करने की आवश्यकता है , तो उपयोग for(:)करना समान है Stream.of("Hello, World!".split("")).reduce("",(a,b)->b+a)
चार्ली

प्रत्येक के साथ आपके उदाहरण में दोनों पंक्तियाँ गोल्फ हो सकती हैं। सबसे पहले एक बन सकते हैं: String b=new StringBuffer("Hello, World!").reverse()+"";( .toStringसाथ बदल दिया +""), और आपके दूसरी पंक्ति बन सकता है: String B="";for(String c:"Hello, World!".split(""))B=c+B;( charकरने के लिए Stringऔर .toCharArray()करने के लिए .split(""))।
केविन क्रूज़सेन

5

जावा 10 का उपयोग करें var

यदि आप किसी विशिष्ट प्रकार के एकल चर को परिभाषित करते हैं, तो उपयोग करें var

उदाहरण

var i=0;                        // int
var l=0L;                       // long
var s="";                       // String
var a=new int[]{1,2,3};         // int[]
var i=java.math.BigInteger.ONE; // BigInteger
var m=new java.util.HashMap();  // HashMap
var i=3+"abc".length()          // int
var a="a b c".split(" ");       // String[]
for(var a:"a b c".split(" "))   // String

निम्नलिखित में से किसी भी उदाहरण में प्रयोग करने योग्य नहीं है

var कई उदाहरणों में इस्तेमाल नहीं किया जा सकता है

var i=1,j=2;           // only one variable is accepted at a time
var a={1,2,3};         // arrays must be explicitly declared
var f=a->a+" ";        // can't know what type a is.
var f=String::replace; // method references aren't properly implied (weirdly, though)

आरई यह विधि संदर्भों के साथ काम क्यों नहीं करता है, ध्यान दें कि केवल हस्ताक्षर के एक छोटे सेट के लिए मानक कार्यात्मक इंटरफेस हैं (और तरीकों को अपवादों की जांच कर सकते हैं)।
जकोब


4

ज्यादातर मामलों में, आपका प्रोग्राम एकल-थ्रेडेड होगा, यानी इसमें केवल एक ही धागा होगा। returnजब आप तुरंत बाहर निकलते हैं तो आप मुख्य विधि से आईएनजी द्वारा इस तथ्य का फायदा उठा सकते हैं।

static void main(String[]a){if(condition)return;}

इसे प्रोग्राम को "ठीक से" समाप्त करने के लिए तुलना करें:

static void main(String[]a){if(condition)System.exit(0);}

या इसकी ओर इशारा करते हुए null:

static void main(String[]a){if(condition)throw null;}

या 0 से विभाजित:

static void main(String[]a){if(condition)int A=1/0;}

4

कभी-कभी, एक एकल-लूप कथन बदली जा सकती है। निम्नलिखित कोड पर विचार करें:

int m(int x){int i=1;for(;x%++i==0;);return i;}

यह एक सरल फॉर-लूप है जो इस प्रश्न का हल है

चूंकि हम जानते हैं कि iस्टैकऑवरफ्लो त्रुटियों का कारण बनने के लिए पर्याप्त नहीं होगा, हम बदले के लिए फॉर-लूप को बदल सकते हैं:

int m(int x,int i){return x%++i>0?i:m(x,i);}

हम वापसी बयान में एक टर्नरी ऑपरेटर का उपयोग करके लूप का अनुकरण कर सकते हैं।

यह कमी बल्कि विशिष्ट है, लेकिन मैं अधिक स्थितियों की कल्पना कर सकता हूं जहां यह काम आएगा।


4

...पैरामीटर के रूप में (varags) का उपयोग करना

कुछ मामलों में यह ढीले लोगों के बजाय एक पैरामीटर के रूप में एक जावा varargs का उपयोग करने के लिए कम है।
उदाहरण के लिए:

// Example input/output: 5, 4, 3 -> 60000
int calculateVolumeInLiters(int width, int height, int depth){
  return width * height * depth * 1000;
}

इस के लिए सबसे अधिक गोल्फ होगा:

int c(int w,int h,int d){return w*h*d*1000;} // 44 bytes

लेकिन इसके लिए एक अतिरिक्त बाइट का सहारा लिया जा सकता है:

int c(int...a){return a[0]*a[1]*a[2]*1000;}  // 43 bytes

ध्यान दें कि सभी तीन पूर्णांक केवल विधि में एक बार ही एक्सेस किए जाते हैं। जबसेint यह बहुत ही कम है, इसलिए यह तभी फायदेमंद होता है जब आप प्रत्येक को केवल एक बार विधि के अंदर उपयोग करते हैं, और उनमें से तीन या अधिक पैरामीटर के रूप में होते हैं।

लंबे मापदंडों के साथ यह आमतौर पर अधिक उपयोगी होता है। उदाहरण के लिए, यह इस चुनौती के लिए मेरा मूल जवाब था (इनपुट स्ट्रिंग में इनपुट कैरेक्टर की गणना):

// Example input/output: tttggloyoi, t -> 3

int c(String a,char b){return a.replaceAll("[^"+b+"]","").length();} // 68 bytes

और मुझे इस पर गोल्फ करने की सलाह दी गई थी:

int c(String a,char b){return a.split(b+"").length-1;}               // 54 bytes

लेकिन मैंने इसका उपयोग करके इसे समाप्त कर दिया ...:

int c(String...a){return a[0].split(a[1]).length-1;}                 // 52 bytes

नोट: यदि प्रश्न / चुनौती एक लचीले इनपुट के लिए पूछते हैं, तो ...निश्चित रूप से छोटा किया जा सकता है []। यदि प्रश्न / चुनौती विशेष रूप से पूछते हैं, तो आइए बताते हैं, तीन Stringआदानों और Stringतीन मानों वाले ऐरे को नापसंद करते हैं, जिनका उपयोग आप String...इसके बजाय कर सकते हैं String a,String b,String c


2
क्या आप String[]varargs का उपयोग करने के बजाय उपयोग नहीं कर सकते हैं ? (1 और बाइट बचाता है)
क्रिति लिथोस

@KritiiLithos हम्म .. अच्छी बात है। लेकिन यह मुख्य रूप से इस बात पर निर्भर करता है कि चुनौती के लिए इनपुट कितना लचीला है। यदि किसी भी इनपुट प्रारूप की अनुमति है, तो इससे कम वास्तव में छोटा होगा। मैं इसे इस युक्तियों में जोड़ूंगा, धन्यवाद।
केविन क्रूज़सेन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.