<सभी भाषाओं> में गोल्फ के लिए टिप्स

Question

इस पोस्ट का उद्देश्य उन सभी गोल्फिंग युक्तियों को इकट्ठा करना है जो आसानी <all languages>से एक विशिष्ट के बजाय लागू किए जा सकते हैं ।

केवल उत्तर देते हैं कि इसका तर्क अधिकांश भाषाओं पर लागू किया जा सकता है

कृपया, प्रति उत्तर एक टिप

Comments

"मेजरिटी" किस मैट्रिक द्वारा?

— काउंटरक्लेविस

@leftaroundabout इसी शब्द के मीट्रिक द्वारा

— ajax333221

समस्या यह है कि बहुत सी अनौपचारिक प्रतिमानों वाली कई भाषाएं (अक्सर अल्पकालिक) प्रायोगिक होती हैं, जिनके लिए विशिष्ट प्रोग्रामिंग अभिव्यक्ति का कोई मतलब नहीं होता है। इसलिए " सभी भाषाओं के बहुमत " को पूरा करना लगभग असंभव है। आपको इसे किसी तरह से प्रतिबंधित करना चाहिए, उदाहरण के लिए "नियमित रूप से कोडगुल्फ़ पर उपयोग की जाने वाली अधिकांश भाषाएं"। फिलहाल, जवाब काफी हद तक "दूरस्थ सी-व्युत्पन्न भाषाओं के बहुमत" की तरह दिखते हैं, लेकिन जो सभी लिखित कोड के विशाल बहुमत में लिखे गए हैं, उनमें से अधिकांश भाषाएं नहीं हैं ।

— को बंद करना

बायीं ओर, मुझे लगता है कि हम सभी जानते हैं कि वे मोटे तौर पर क्या मतलब है। यह ज्यादातर भाषा-स्वतंत्र अनुकूलन के बारे में है, यानी न केवल ब्रेनफक में उपयोगी है, बल्कि शायद पायथन, सी, जावा और फोरट्रान एक बार में। सामान्य विचार जो आप कई भाषाओं में लागू कर सकते हैं जो समान रूप से काम करते हैं। मुझे नहीं लगता कि सुझावों में सटीक और विशिष्ट होने की आवश्यकता है और सीडब्ल्यू प्रश्न। यह दूसरों को गोल्फ में मदद करने के बारे में है, न कि उन्हें पेशाब करने के बारे में।

— जॉय

उम्मीद है कि कोई भी एक भाषा नहीं बनाता है <all languages>...

— mbomb007

Answer 1

मर्ज करें लूप्स

आप आमतौर पर दो परिणामी छोरों, या दो नेस्टेड छोरों को एक में विलय कर सकते हैं।

इससे पहले:

for (i=0; i<a; i++) foo();
for (i=0; i<b; i++) bar();

उपरांत:

for (i=0; i<a+b; i++) i<a?foo():bar();

Comments

बदसूरत छोरों अभी भी समान नहीं हैं। @ गफ्फी सही है।

— koD

@kaoD, दोनों मामलों fooमें aसमय कहलाता है, काल barकहलाता bहै। ऐसा इसलिए है क्योंकि "बाद में", लूप a+bबार चलता है, पहला aकॉल foo, अगले वाले कॉल करते हैं bar।

— बदसूरत

मैं इसे फिर से देख रहा हूं (बहुत बाद में), और मैं अब अपने प्रश्न को नहीं समझता हूं। मैं शायद पहले ternary आपरेशन समझ में नहीं आया? जिस तरह से मैं इसे अब देखता हूं, यह समझ में आता है।

— गफ्फि

वाह, मैंने बहुत देर रात को पढ़ा। आप सही हे!

— काओ जूल

बहुत समान: for(y=0;y<Y;++y)for(x=0;x<X;++x)अक्सर बन सकता है for(i=0;i<X*Y;++i)के साथ xद्वारा बदल दिया i%Xऔर yके द्वारा बदल दिया i/X।

— लिन

Answer 2

केवल स्पष्ट उल्लेख करने के लिए:

एल्गोरिथ्म की अपनी पसंद पर सवाल उठाएं और पूरी तरह से कुछ नया करने की कोशिश करें।

जब गोल्फिंग (विशेष रूप से कठिन समस्याएं जो लंबे कार्यक्रमों में परिणाम देती हैं) तो सभी अक्सर आप अन्य मौलिक विकल्पों की कोशिश किए बिना आपके द्वारा चुने गए पथ पर चिपक सकते हैं। बेशक, आप एक समय में या समग्र विचार के एक भाग में एक या कुछ लाइनें माइक्रो-गोल्फ कर सकते हैं, लेकिन अक्सर पूरी तरह से अलग समाधान की कोशिश नहीं करते हैं।

यह हेटिंग 495 (कपरेकर) में विशेष रूप से ध्यान देने योग्य था जहां वास्तविक एल्गोरिथ्म से भटकना और पैटर्न की तलाश में आप एक ही परिणाम प्राप्त करने के लिए आवेदन कर सकते हैं कई भाषाओं में छोटा था (बस नहीं जे)।

नकारात्मक पक्ष यह है कि आप संभवतः एक ही चीज को आधा दर्जन बार हल करते हैं। लेकिन यह वास्तव में HQ9 + को छोड़कर सभी भाषाओं में काम करता है (जहां हैलो वर्ल्ड को आउटपुट करने का दूसरा तरीका ढूंढना थोड़ा व्यर्थ होगा)।

Comments

+1 गोल्फिंग के लिए अच्छा होने के अलावा, यह कई वास्तविक दुनिया की परिस्थितियों में किसी भी प्रोग्रामर के लिए अच्छा व्यायाम है!

— गफी

Answer 3

परीक्षण-संचालित विकास का उपयोग करें

यदि कोड को विभिन्न इनपुट्स को संभालना है, तो व्यापक परीक्षण लिखें और उन सभी को बहुत तेज़ी से चलाना आसान बना दें। यह आपको एक समय में एक बच्चे के कदम को जोखिम भरा बनाने की कोशिश करने की अनुमति देता है। गोल्फ तो विकृत इरादे के साथ refactoring की तरह हो जाता है।

Comments

मैं इस विधि के एक स्पिनऑफ का उपयोग करता हूं। चूंकि समस्याएं स्वयं आमतौर पर सरल होती हैं, इसलिए मैं एक कार्यक्रम लिखता हूं जो काम करता है। आमतौर पर यह "आसानी से गोल्फ" है, ताकि यह रसीला हो, लेकिन नएपन आदि हैं। मैं इस फाइल को एक नए स्थान पर कॉपी करता हूं और इसे गोल्फ करता हूं, हर अब और फिर यह जांचता हूं कि प्रोग्राम कुछ चुने हुए इनपुट के लिए समान मान लौटाते हैं। अगर मैं कभी भी एक टूटे हुए कार्यक्रम के साथ मुझे छोड़ने की गलती करता हूं, तो जो मैंने बदला है उसकी कोई याद नहीं है और मेरे गोल्फ के टुकड़े की कोई समझ नहीं है, मेरे पास संदर्भ स्रोत के रूप में सहेजे गए कुछ "विनिर्देश" हैं।

— शियोना

मुझे यह विधि पसंद है, जो एक कारण है कि मैं सभी समस्याओं के लिए व्यापक परीक्षण सूट शामिल करता हूं जो मैं लिखता हूं।

— जॉय

@ रबडकॉक अपने आप को न दोहराएं सिद्धांत अक्सर सख्ती से पालन किया जाता है।

— जोनाथन फ्रीच

Answer 4

तार्किक बयानों को कम करने की कोशिश करें

उदाहरण के लिए यदि Aऔर Bबूलियन्स और कुछ हद तक नंबर की तरह व्यवहार करता है अपनी भाषा बूलियन्स कर रहे हैं, A and (not B)और A>Bबराबर हैं। उदाहरण के लिए पायथन में

if A and not B:
    foo()

के समान है:

if A>B:
    foo()

Comments

मैंने ऐसा कभी नहीं सोचा था।

— cjfaure

B>A or foo()इसे व्यक्त करने का एक और भी छोटा तरीका होगा, यह सुनिश्चित करने के लिए बूलियन अभिव्यक्तियों के आलसी मूल्यांकन का लाभ उठाएं कि यह केवल चीजों की गणना करता है जब इसे करने की आवश्यकता होती है।

— स्कगर

@ सागर: सही है, लेकिन यह इस टिप की बात नहीं है। (हालांकि यह एक मूल्यवान स्वतंत्र टिप है।)

— Wrzlprmft

@ सागर, अगर हम जो B>A or fooचाहते हैं वह मूल्यांकन नहीं करेंगे । (दाएं?)fooB==A

— msh210

इसके अलावा, यदि आपके पास लंबे समय से imbricated स्थितियां हैं (5/6 मापदंडों के साथ कहें), तो आप इसके लिए सबसे छोटी बूलियन अभिव्यक्ति को खोजने के लिए एक ट्रुथ टेबल और कर्णघट मानचित्र का उपयोग कर सकते हैं

— काटनेंको

Answer 5

आपके पास पहले से मौजूद मानों का उपयोग करके वैरिएबल को आरम्भ करें।

इसके बजाय x=1, ऐसी चीज़ की तलाश करने की कोशिश करें जो पहले से ही बराबर हो। 1.
उदाहरण के लिए, एक फ़ंक्शन का रिटर्न मान: printf("..");x=0;-> x=!printf("..");। यह 0 के साथ सबसे आसान है, क्योंकि आप हमेशा नकारात्मक कर सकते हैं, या जब आपको सभी की आवश्यकता होती है सही सत्य मूल्य (और अगर यह 1 या 19 है तो परवाह नहीं करें)।

Comments

C में आप मुख्य रूप से 1 से argc का उपयोग कर सकते हैं। देखें: codegolf.stackexchange.com/questions/1034/reinvent-the-for-loop/…

— std''OrgnlDave

@ std''OrgnlDave, True, लेकिन यह प्रश्न सभी भाषाओं के लिए सामान्य है।

— ugoren

Answer 6

एकल का उपयोग करें ~के लिए x+1औरx-1

यह ट्रिक उन भाषाओं पर लागू होती है, जिनमें एक यूनिक बिटवाइज़ निगेटिव ऑपरेटर ~और एक यूरीरी रेग्युलर नेगेटिव ऑपरेटर होते हैं -।

यदि आपका प्रोग्राम, संयोग से, अभिव्यक्ति शामिल है -x-1, तो आप इसे ~xबाइट्स को बचाने के लिए बदल सकते हैं । यह सब अक्सर नहीं होता है, लेकिन देखो कि क्या होता है अगर हम नकारात्मक ( -) दोनों भाव: x+1बराबर होते हैं -~x! इसी तरह, x-1बराबर ~-x। (सोचें कि किस तरह से टिल्ड पॉइंट्स: राइट है +, लेफ्ट है -।)

यह उपयोगी है, क्योंकि सभी भाषाओं में मैं सोच सकता हूं कि इन ऑपरेटरों के पास है, वे अधिकांश ऑपरेटरों की तुलना में उच्च वरीयता रखते हैं। यह आपको कोष्ठक पर सहेजने की अनुमति देता है। देखें कि हम यहां चार बाइट कैसे बचाते हैं:

(x+1)*(y-1)     ==>    -~x*~-y

Answer 7

व्हॉट्सएप निचोड़ें

अपनी भाषा में व्हाट्सएप के नियमों को जानें। कुछ विराम चिह्नों, या अन्य वर्णों को किसी भी आसपास के व्हाट्सएप की आवश्यकता नहीं हो सकती है। इस बॉर्न शेल फ़ंक्शन पर विचार करें :

f () { echo a; echo b; }

बॉर्न शेल में, ();मेटाकाट्रैक्टर्स होते हैं, और आसपास के व्हाट्सएप की आवश्यकता नहीं होती है। हालांकि, {}शब्द हैं और व्हॉट्सएप की जरूरत है जब तक कि वे मेटाचैकर्स के बगल में न हों। हम अगले 4 स्थानों को दूर से गोल्फ कर सकते हैं ();, लेकिन बीच {और के बीच का स्थान रखना चाहिए echo।

f(){ echo a;echo b;}

में कॉमन लिस्प और PicoLisp , ()अक्षरों से परे हैं। दो संख्याओं का औसत ज्ञात करने के लिए इस कोड पर विचार करें:

(/ (+ a b) 2)

हम 2 स्थानों को दूर गोल्फ कर सकते हैं।

(/(+ a b)2)

---

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

#!ruby -an
i=$F.map &:to_i
puts"#{i.reduce &:+} #{i.reduce &:*}"

प्रत्येक &को अपने से पहले एक स्थान की आवश्यकता होती है। रूबी में, का i=$F.map &:to_iअर्थ है i=$F.map(&:to_i)जहां &एक ब्लॉक पैरामीटर गुजरता है। लेकिन, i=$F.map&:to_iइसका मतलब है कि बाइनरी ऑपरेटर i=$F.map.&(:to_i)कहां &है।

पेरल या रूबी जैसी भाषाओं में यह विचित्रता होती है, जो अस्पष्ट विराम चिह्नों का उपयोग करती है। यदि संदेह है, तो व्हाट्सएप नियमों का परीक्षण करने के लिए एक REPL का उपयोग करें या छोटे कार्यक्रम लिखें।

Comments

"{" और "प्रतिध्वनि" के बीच एक स्थान होने की आवश्यकता क्यों है, लेकिन "" के बीच नहीं; और "गूंज"?

— रयान

मैंने ओपनबीएसडी श (1) के लिए मैनुअल से शर्तों का उपयोग किया, जो कहता है कि "{" एक आरक्षित शब्द है और ";" एक मेटा-कैरेक्टर है। इस वजह से, "{इको" एक शब्द है लेकिन, "इको" दो शब्द हैं। अन्य नियमावली इसे अलग तरह से समझा सकती है। इसके अलावा, Z शेल zsh के अलग-अलग नियम हैं।

— kernigh

Answer 8

कई बार उपयोग किए जाने पर नए नाम असाइन करें

x = SomeLongFunctionName
x(somedata)
x(somemoredata)
etc

Comments

यदि हम पर्याप्त कॉल का उपयोग करते हैं तो ही x।

— एलिप्सज़िलोन

Answer 9

एकल पत्र चर नाम

आपके पास उनमें से 52 हैं; उन सब का उपयोग करें! विभिन्न दृष्टिकोणों की कोशिश करने और लंबाई की तुलना करने से डरो मत। भाषा और उपलब्ध विशिष्ट शॉर्टकट / पुस्तकालय कार्यों को जानें।

Comments

गैर-संवेदनशील भाषाओं के लिए 26। :-)

— गफ्फि

अक्सर $और _पहचानकर्ता के रूप में इस्तेमाल किया जा सकता है।

— ग्रिफिन

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

— हमार

यदि आप यूनिकोड के बजाय बाइट्स की गिनती कर रहे हैं, तो विस्तारित एससीआई का उपयोग एक और तरीका हो सकता है, अगर आपको उनकी आवश्यकता हो तो एक और ~ 120 पहचानकर्ताओं को निचोड़ने के लिए (यह नहीं कि गोल्फ स्क्रिप्ट के लिए आपको 26 से अधिक की आवश्यकता होनी चाहिए)

— स्क्रैपर

@T-SQL में एक मान्य चर नाम है, इसके बजाय इसका उपयोग करें @a।

— ब्रैड

Answer 10

सशर्त ऑपरेटर का उपयोग करें।

एक सशर्त संचालक

bool ? condition_true : condition_false

एक IF स्टेटमेंट की तुलना में अधिक लाभदायक, वर्ण वार है ।

if(a>b){r=a;}else{r=b;}

के रूप में लिखा जा सकता है

r=a>b?a:b;

Comments

ऐसी भाषाएं जिनके पास टर्नरी नहीं है, a&&b||cइसके बजाय उपयोग कर सकते हैं । थोड़ा लंबा है, लेकिन अभी भी एक से कम है if।

— माइकल कोहल

फिर, कुछ विकल्प (VBA के मन में आते हैं) का उपयोग नहीं कर सकते, लेकिन दोनों अभी भी अच्छे सुझाव हैं। :-)

— गफ्फी

Gaffi: VBA है Iff, हालांकि यह एक फ़ंक्शन है, इसलिए सभी तर्कों के मूल्यांकन के अधीन है।

— जॉय

त्रिगुट का उपयोग में है, तो बयान भी बहुत उपयोगी हो सकताif(a ? b : c)

— Jojodmo

@MichaelKohl ध्यान दें कि जब a&&b||cवापसी cहो aसकती है, अगर सही bहै तो गलत है, थोड़ा किनारे का मामला है, लेकिन हमें यह नहीं भूलना चाहिए कि ^ ^

— कटेन्को

Answer 11

अपने कोड का स्पष्टीकरण लिखें

एक स्पष्टीकरण लिखना आपको अपने कोड के प्रत्येक भाग को फिर से देखने और एक निश्चित मार्ग को स्पष्ट रूप से लिखने में अपने विचार और विकल्प बनाने के लिए मजबूर करता है। ऐसा करने पर, आप पा सकते हैं कि विभिन्न दृष्टिकोण संभव हैं जो कुछ बाइट्स को बचा सकते हैं, या कि आपने अवचेतन रूप से बनाई गई धारणाएं जो जरूरी नहीं रखती हैं।

यह टिप एल्गोरिथम की आपकी पसंद पर सवाल उठाने और पूरी तरह से कुछ नया करने की कोशिश करने के समान है ; हालाँकि, मैंने पाया है कि वास्तव में प्रत्येक भाग को काम करने के तरीके को लिखने का कदम कभी-कभी विकल्पों के बारे में जागरूक होने के लिए महत्वपूर्ण होता है।

एक बोनस के रूप में, स्पष्टीकरण सहित उत्तर अन्य उपयोगकर्ताओं के लिए अधिक दिलचस्प हैं और इसलिए उनके उत्थान की संभावना अधिक है।

Answer 12

अपने कैरेक्टर काउंट को डबल चेक करें

एक नो-ब्रेनर की तरह लगता है, लेकिन सावधान रहने से आप वास्तव में कुछ भी नहीं करके कुछ पात्रों को "बचाने" में सक्षम हो सकते हैं!

यदि आप विंडोज का उपयोग कर रहे हैं, तो आप रिटर्न के \r\nबदले सिर्फ इनपुट कर सकते हैं \rया \nजब आप रिटर्न मारते हैं - प्रति पंक्ति एक अतिरिक्त बाइट जोड़ते हैं! नियंत्रण वर्णों को केवल दो बार चेक करें कि आप ऐसा नहीं कर रहे हैं।

नोटपैड ++ में आप \r\nकेवल \rजाकर सभी लाइन एंडिंग को बदल सकते हैं Edit > EOL Conversion > UNIX/OSX Format।

यह भी सुनिश्चित करें कि आप अपने चरित्र गणना में किसी भी अनुगामी व्हाट्सएप को शामिल नहीं करते हैं! आपके कोड में नीचे की पंक्ति में फ़ीड भी असंगत है, इसलिए इसे भी गिनने की आवश्यकता नहीं होगी।

Comments

मुझे नहीं लगता कि मैंने कभी ऐसा मामला देखा है जहां यह वास्तव में गिना गया हो ...

— याकूब

मुझे सिर्फ यही समस्या है (इसलिए मैं इसे जोड़ रहा हूं)।

— सीन लाथम

Answer 13

प्रश्न को ध्यान से पढ़ें

कोड गोल्फिंग सवाल को समझने के लिए जितना है (जो पूछा गया है और जो नहीं पूछा गया है, भले ही यह किसी अन्य सेटिंग में निहित हो) कोड उत्पादन के रूप में यह (कि) केवल संतुष्ट हो सकता है जो पूछा गया है।

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

Comments

मुझे लगता है कि यहां एक बेहतर शीर्षक "गैर-जरूरी किनारे के मामलों को संभालना नहीं होगा"। वाक्यांश "लूपहोल्स खोजने का प्रयास करें" नियमों को कुछ कृत्रिम पुनर्व्याख्या के माध्यम से निर्दिष्ट करने से बचने के तरीकों को ध्यान में लाता है, जबकि आप जो पेशकश कर रहे हैं वह केवल आपके समाधान को लागू न करने के लिए अच्छी सलाह है।

— जोनाथन वान माट्रे

हाँ, लेकिन नियमों का एक कृत्रिम पुनर्व्याख्या कोड गोल्फ के रूप में अच्छी तरह से है! (0 चार समाधान, आदि)

— टोबिया

हालांकि यह एक अलग जवाब होना चाहिए। उदाहरण के बीच, एक मूलभूत अंतर है, एक समाधान को लागू करना जो केवल किलों के लिए काम करता है क्योंकि ओपी को फ्लोट समर्थन की आवश्यकता नहीं थी, और एक उत्तर जो पाठ "किसी भी प्राइम 100 से अधिक" को प्रिंट करता है, क्योंकि "आपने यह नहीं कहा था" एक वास्तविक अभाज्य संख्या हो ”।

— जोनाथन वान मैट्रे

मुझे लगता है कि कुछ ओपी में "परिवर्तन के अधीन परीक्षण के मामले शामिल हैं; आपका कोड परिवर्तन के बाद भी काम करना चाहिए" नोटिस, और वास्तव में उन्हें बदल दें यदि वे टेस्टेस को केवल एक उत्तर को हार्ड-कोडिंग करते देखते हैं।

— आउटगॉल्फ

Answer 14

0 और किसी भी 2 ^एन -1 के बीच संख्याओं की जांच के लिए बिटवाइज़ ऑपरेशंस का उपयोग करें

थोड़ा किनारे का मामला हो सकता है, लेकिन यह कभी-कभी काम आ सकता है। यह इस तथ्य पर निर्भर करता है कि सभी संख्याएँ जो m = 2 ⁿ -1 पर लागू होती हैं उनमें सबसे दाहिने n बिट्स 1 पर सेट होते हैं।

तो, 7 ₁₀ == 00000111 ₂ , 15 ₁₀ == 00001111 ₂ , 31 ₁₀ == 00011111 ₂ और इतने पर।

चाल है x&~m। जब भी 0 और (समावेशी) के बीच नहीं है , और गलत है तो xयह सच हो जाएगा । यह अगले सबसे छोटी समकक्ष अभिव्यक्ति से 6 बाइट्स बचाता है: लेकिन स्पष्ट रूप से केवल तभी काम करता है जब 2 ^एन -1 को संतुष्ट करता है ।mx>=0&&x<=mm

Answer 15

नए चर के बजाय फ़ंक्शन पैरामीटर का पुन: उपयोग करें

Comments

उदाहरण के लिए, C में, आपका मुख्य कार्य हमेशा प्रोग्राम को दिए गए तर्कों की संख्या को पार कर जाता है (जो कि 1 है - प्रोग्राम का नाम - 'डिफ़ॉल्ट' द्वारा) इसलिए आपके साथ main(i){...अब 1 के मान के साथ एक चर है, जिसमें बिना कोई असाइनमेंट करें। वहाँ 2 बचाया ..

— ग्रिफिन

मुझे लगता है कि यह सी के लिए काफी विशिष्ट है। स्क्रिप्ट भाषाओं को घोषणाओं की आवश्यकता नहीं है, और अधिकांश संकलित भाषाओं में एक चर को परिभाषित करना एक पैरामीटर को परिभाषित करने से अधिक लंबा नहीं है।

— ugoren

जावा में जब एक फ़ंक्शन के अंदर एक सरणी की आवश्यकता होती है जिसमें एक ही प्रकार का एक पैरामीटर होता है तो आप उस पैरामीटर को अंतिम रूप देकर कुछ बाइट्स को बचा सकते हैं और इसे एक वैरग पैरामीटर बना सकते हैं; (एक वाक्य में सबसे लंबे शब्द को खोजने के लिए एक फ़ंक्शन पर कुछ बाइट्स से दाढ़ी बनाने के लिए इस्तेमाल किया गया)

— MasterX244

Answer 16

एक अंक बचाने की तुलना में अधिक / कम:

//use:
if(n>9){A}else{B}
//instead of:
if(n<10){B}else{A}

बस से कोड स्वैप करने के लिए याद ifकरने के लिए elseऔर वे बिल्कुल वही बात करते हैं (या असमानता की तरफ स्विच) होगा!

नोट: यह 10 की किसी भी शक्ति और उनके नकारात्मक के साथ लागू किया जा सकता है:...-100, -10, 10, 100...

(स्रोत लिंक)

Comments

मुझे यकीन नहीं है कि मैं इस बात को समझता हूं। इससे क्या घटता है?

— गफी

@ गफ्फी आप एक पात्र को बचाते हैं और वे ठीक वैसा ही करते हैं

— ajax333221

बनाम क्या विकल्प? क्षमा करें, बाधा बनने की कोशिश नहीं कर रहा है, मुझे अभी नहीं मिला है। (newb, here, जाहिरा तौर पर ...)

— Gaffi

ओह समझा। 9 से 10, 99 से 100, आदि किसी भी पूर्णांक संक्रमण पर काम करता है। खेद है कि मुझे इतना लंबा समय लगा! (मैं केवल पूर्णांक कहता हूं, क्योंकि मैं n = 9.5 के साथ एक समस्या देख सकता हूं ...)

— गफी

इसके अलावा कुछ भाषाओं में (यदि समर्थित है) यदि आपकी संख्या बड़ी / छोटी है तो वैज्ञानिक संकेतन वास्तव में आपको इसके बजाय कुछ if(n>99999)if(n<1e5)

— चार्ट

Answer 17

> = और <= के बजाय> और <का उपयोग करें

हार्ड-कोडित पूर्णांक मानों के खिलाफ जांच करते समय, उपयोग करें >और <इसके बजाय >=और <=जहां संभव हो। उदाहरण के लिए, उपयोग करना

if(x>24&&x<51)

क्या उपयोग करने की तुलना में 2 बाइट्स कम है

if(x>=25&&x<=50)

Comments

संबंधित: यदि आप सुनिश्चित हैं कि एक परिणाम नकारात्मक नहीं हो सकता है, तो आप शून्य-चेक ​​के बजाय (या मिरर किए गए चेक के लिए) के <1बजाय उपयोग कर सकते हैं । ==0>0!=0

— केविन क्रूज़सेन

क्या आपको xपूर्णांक होने के बारे में एक नोट नहीं जोड़ना चाहिए ?

— जकार्इ

Answer 18

समयपूर्व लूप टूटने से बचें

अगर बूलियन जांच के 1 या अधिक उदाहरणों की जांच के लिए लूप के माध्यम से चल रहा है, तो पहले वास्तविक मूल्य पर लूप से बाहर निकलने के लिए अधिक कुशल प्रोग्राम बना सकता है। हालांकि, सभी पुनरावृत्तियों के माध्यम से ब्रेक और लूपिंग को हटाने से कम कोड की अनुमति मिलती है।

int main() {
bool m = false;
int n = 1000;
for (int i = 0; i < n; i++) {
if (i >= 100) {
m = true;
break; // remove this line
}
} 
return 0;
}

Comments

तुम भी सरल बना सकते हैं ifदूर बयान इन मामलों में: m|=i>=100। (और तुम भी सरल बना सकते हैं i>=100करने के लिए i>99इस मामले में लेकिन यह है कि यहां बहुत प्रासंगिक नहीं है)

— मारीनस

Answer 19

के -बजाय का उपयोग करें!=

संख्यात्मक तुलना के लिए:

यदि बराबर बी, a-bपरिणाम में है 0, जो मिथ्या है। 0सत्य के अलावा और कुछ भी नहीं है; इसलिए
अगर बूलियन संदर्भ में उपयोग किया जाता है, तो a-b<=>a!=b

यदि आप इसका उपयोग if/elseटर्नरी ऑपरेटर के साथ या इसके साथ करते हैं, तो यह आपको समानता के लिए एक बाइट भी बचा सकता है:
a==b?c:d<=>a-b?d:c

Answer 20

लंबी सरणियों के लिए स्प्लिट स्ट्रिंग्स

अधिकांश भाषाओं में स्ट्रिंग को किसी प्रकार के टोकन के चारों ओर एक सरणी में विभाजित करने का एक तरीका है। यह अनिवार्य रूप से एक सरणी शाब्दिक से छोटा होगा, जब लंबाई एक भाषा-निर्भर सीमा तक पहुंच जाती है, क्योंकि प्रति स्ट्रिंग अतिरिक्त ओवरहेड कम से कम दो स्ट्रिंग सीमांकक के बजाय एक-चार टोकन की एक प्रति होगी।

जैसे कि गोल्फस्क्रिप्ट में

["Foo""Bar""Baz""Quux"]  # 23 chars

हो जाता है

"Foo
Bar
Baz
Quux"n/  # 20 chars

कुछ भाषाओं के लिए, दहलीज एक स्ट्रिंग जितनी कम है। जैसे जावा में,

new String[]{"Foo"}  // 19 chars

हो जाता है

"Foo".split("~")  // 16 chars

Comments

उल्लेखनीय अपवाद रूबी है, जो एक सरणी-ऑफ-स्ट्रिंग्स शाब्दिक प्रदान करता है जो स्वचालित रूप से दो बाइट्स की लागत पर रिक्त स्थान पर विभाजित करता है %w{Foo Bar Baz Quux}:।

— मार्टिन एंडर

पर्ल कुछ ऐसा ही प्रदान करता है: qw(Foo Bar Baz Quux)तार की एक सूची बन जाती है।

— बेनगोल्डबर्ग

Answer 21

समझें कि अन्य लोगों ने क्या किया

मज़ेदार होने के अलावा, यदि आप अन्य लोगों के कोड की जांच करते हैं, तो आप कभी-कभी एक अच्छा एल्गोरिथ्म खोज सकते हैं जिसके बारे में आपने नहीं सोचा था, या एक चाल (कभी-कभी एक स्पष्ट) जिसे आप अनदेखा करते हैं।

कभी-कभी एक मौजूदा उत्तर होता है कि आप किसी अन्य भाषा में अनुवाद कर सकते हैं, और दूसरी भाषा की अच्छाइयों से लाभ उठा सकते हैं।

Answer 22

अपने ऑपरेटर की मिसाल को जानें

जब भी आप कई अभिव्यक्तियों को जोड़ते हैं, तो अपनी भाषा के लिए ऑपरेटर पूर्वता तालिका की जांच करें कि क्या आप कोष्ठक को बचाने के लिए सामान को फिर से व्यवस्थित कर सकते हैं।

उदाहरण:

• सभी भाषाओं में जो मुझे पता है, बिटकॉइन ऑपरेटरों की बूलियन ऑपरेटरों की तुलना में एक उच्च मिसाल है: (a&b)&&cकोई कोष्ठक की आवश्यकता नहीं है: a&b&&cबस के रूप (a*b)+cमें नहीं करता है।
• a+(b<<c)के रूप में फिर से लिखा जा सकता है a+b*2**c।
  इस उदाहरण के लिए कुछ भी नहीं बचा है, लेकिन यह cएक छोटा पूर्णांक शाब्दिक है (<14)।
• बिटवाइज़ संचालन सबसे अंकगणितीय आपरेशनों की तुलना में कम पूर्वता है, इसलिए यदि अपनी भाषा परोक्ष बूलियन डाले int करने के लिए, आप पर एक बाइट बचा सकता है a<b&&c<dके साथ a<b&c<d(जब तक आप शॉर्ट सर्किट मूल्यांकन की जरूरत है)

Answer 23

छोरों के लिए छोटा

यदि आपके पास अपने for-loop के अंदर Xस्टेटमेंट हैं , तो आप 3 बाइट्स को बचाने के लिए दूसरे अर्धविराम के बाद for-loop के अंदर स्टेटमेंट ले जा सकते हैं । (अल्पविराम का उपयोग करके बयानों को अलग करें ){}X-1()for(blah;blah;HERE),

के बजाय

for(int i=0;i<9;){s+=s.length();println(i++);}

आप एक स्टेटमेंट को फॉर-लूप के (ब्रेसिज़ में ले जा सकते हैं )जबकि दूसरे को बाहर छोड़ सकते हैं

for(int i=0;i<9;println(i++))s+=s.length();

और 3 बाइट्स सहेजें (@ETHProductions के लिए 1 और बाइट धन्यवाद)

---

सीधे शब्दों में कहें,

के बजाय

for(blah;blah;){blah 1;blah 2;...;blah X}

चारों ओर बयानों को स्थानांतरित करें ताकि आप इसे समाप्त कर सकें

for(blah;blah;blah 2,...,blah X)blah 1;

और 3 बाइट्स बचाएं

Comments

@ETHproductions एक टिप गोल्फ के लिए धन्यवाद :)

— क्रिक्सी लिथोस

और अगर forअंतिम कथन है, तो ;वैकल्पिक हो जाता है

— एलिप्सज़िलन

Answer 24

एकल का उपयोग करें ~के लिए a-b-1औरa+b+1

के संबंध में @Lynn के सुझावों के अलावा x+1→ -~x; और x-1→~-x , आप गोल्फ भी कर सकते हैं a-b-1और a+b+1।

a-b-1    // 5 bytes
a+~b     // 4 bytes

a+b+1    // 5 bytes
a-~b     // 4 bytes

यह एक टिप की तरह लग सकता है जिसे आप अक्सर उपयोग नहीं करेंगे, थोड़े की तरह उपयोग ~xकरने की -x-1तरह यह अक्सर नहीं होता है, लेकिन मैंने इसे एक उपयोगी टिप के रूप में देखने के लिए पर्याप्त बार उपयोग किया है। विशेष रूप से सरणी-अनुक्रमण के साथ आप कुछ मामलों में इन का उपयोग कर सकते हैं।

Answer 25

संपीड़ित या / और धारियाँ

जब मैं और (या ors, इस मामले में सिर्फ 'किसी' के साथ 'सब' स्थानापन्न) में जंजीरों की एक लंबी लकीर निचोड़ने की कोशिश कर रहा हूँ के साथ आया है सरल चाल।

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

if a>0 and a<10 and a+b==4 and a+3<1:

हो जाता है

if all([a>0,a<10,a+b==4,a+3<1]):

Comments

यह एक अच्छा है, मुझे यह कोशिश करनी होगी!

— स्टोकैस्टिक

किन भाषाओं में all(array-of-Booleans)अंतर्निहित है?

— पीटर टेलर

रूबी के पास है। [a>0,a<10,a+b==4,a+3<1].all?

— kernigh

हालाँकि अगर यह पायथन होता तो आप कुछ इस तरह का प्रयोग कर रहे होतेif 10>a>0 and a+b==4>1>a+3:

— Sp3000

@PeterTaylor Haskell के पास बहुत

— गर्व

Answer 26

आवश्यक प्रदर्शन प्रदान करने के लिए संकलक पर भरोसा करें।

यह जानना सुनिश्चित करें कि कौन से ऑप्टिमाइज़ेशन की गारंटी कंपाइलर द्वारा और किस ऑप्टिमाइज़ेशन स्तर पर दी गई है, और उन्हें उदारतापूर्वक उपयोग करें। और यहां तक ​​कि अगर प्रदर्शन एक चिंता की आवश्यकता नहीं है , तो आप अभी भी अनुकूलन पर परीक्षण कर सकते हैं, और उसके बाद केवल एक वर्ण को छूट दे सकते हैं क्योंकि आपका कोड अभी भी तकनीकी रूप से संकलक के बिना वैध है।

2 ^ n की गणना करने के लिए निम्नलिखित हास्केल फ़ंक्शन पर विचार करें (इस तथ्य को अनदेखा करते हुए कि हास्केल में पहले से ही एक अंतर्निर्मित एक्सप्रेशन ऑपरेटर या तीन हैं) (23 वर्ण):

p 0=1;p x=p(x-1)+p(x-1)

समस्या यह है - यह बहुत धीमी गति से है, यह घातीय समय में चलता है। यह आपके कोड को अस्थिर कर सकता है या प्रश्न द्वारा दिए गए किसी भी प्रदर्शन की कमी को विफल कर सकता है। बार-बार होने वाले फ़ंक्शन कॉल (25 वर्ण) से बचने के लिए आपको एक अस्थायी चर या तुरंत उपयोग किए गए फंक्शन शाब्दिक का उपयोग करने के लिए लुभाया जा सकता है:

p 0=1;p x=(\y->y+y)$p$x-1

लेकिन संकलक पहले से ही ऐसा कर सकता है कि आपके लिए, आपको केवल -Oसंकलक ध्वज के रूप में सेट करने की आवश्यकता है ! मैन्युअल रूप से सामान्य सबटेक्शन्स को समाप्त करने के लिए प्रति साइट कुछ अतिरिक्त वर्ण खर्च करने के बजाय, बस कंपाइलर से कहें कि वह आपके लिए पूरे कार्यक्रम में एक वर्ण या दो के कुल के लिए बुनियादी अनुकूलन करें।

Comments

@ETHproductions हां, माफ करना, मैंने किया

— जॉन ड्वोरक

सिर्फ पहला उदाहरण नहीं होना चाहिए p(x-1)*2?

— Cycece

Answer 27

शायद कुछ स्पष्ट लेकिन ...

ऑपरेटर रिटर्न मान का उपयोग करें

ध्यान रखें कि असाइनमेंट ऑपरेटर एक मान लौटाता है!

उदाहरण के लिए, यदि आप y को x में जोड़ना चाहते हैं और फिर जांचें कि क्या x कुछ से अधिक है, तो आप कर सकते हैं

if(25<x+=y)

के बजाय

x+=y;if(x>25)

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

strlen(s=trim(s))

बजाय

s=trim(s);strlen(s)

Comments

आप किस भाषा में कॉल के अंदर असाइनमेंट कर सकते हैं ? या यह कि एक कीवर्ड arg है?

— बिल्ली

मुझे लगता है कि असाइनमेंट कम से कम C, C ++, C #, और Java में असाइन किए गए वेरिएबल के नए मान (उनके एक्सप्रेशन वैल्यू के रूप में) हैं। a = (b=c)+1;सेट करता bहै c, और फिर सेट करता aहै b+1।

— लिन

@Lynn कोशिश करो a=1+b=c। और आप अपनी सूची में PHP और जावास्क्रिप्ट जोड़ सकते हैं।

— टाइटस

रूबी यह सबसे अच्छा करती है। यह देता है =ऑपरेटर सही से बाईं तरफ के एक उच्च पूर्वता, तो 1+x=2वैध है और करने के लिए मूल्यांकन करता है3

— Cyoce

@Cyoce afaik it´s उस तरह से सभी भाषाओं में जहां एक असाइनमेंट एक अभिव्यक्ति है।

— टाइटस

Answer 28

भाषा संस्करण / संकलक / पर्यावरण quirks / नई सुविधाओं का उपयोग करें

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

Answer 29

यदि संभव हो तो / या का उपयोग करके जाँच करें कि एकाधिक / नेस्टेड को मिलाएं।

अर्थात:

if (a && (b || c)) {

}

के बजाय:

if (a) {
    if (b) {
        //Do Stuff
    } elseif (c) {
        //Do same stuff
    }
}

Comments

इसके अलावा, &अधिक वर्णों को हटाने के लिए बिट्टी कंडीशंस ( , |) का उपयोग करें।

— फ़ूजएक्सएक्स

हालाँकि कुछ मामलों में 1 वर्ण को हटाने के &बजाय बिटवाइज़ का उपयोग करने से &&यह ऑपरेटर की प्राथमिकता को गड़बड़ा देता है और आपको इसे काम करने के लिए कोष्ठक लगाना पड़ेगा। समझदारी से इसका उपयोग करें।

— डॉलर अक्षय

Answer 30

अपने चर को इनिशियलाइज़ करने के बेहतर तरीके खोजें

कुछ अन्य उत्तर पहले से ही इसका उल्लेख करने के करीब आए, लेकिन कई (सख्ती से टाइप की गई) भाषाओं में, यह xखाली स्ट्रिंग के रूप में आरंभ करने के लिए छोटा है :

x:=""

या xखाली रूण (चार) जैसे:

x:=''

से

var x string

तथा

var x rune

Preexisting मूल्यों का उपयोग स्पष्ट रूप से पसंद किया जाता है, लेकिन इतना आसान नहीं है।