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

Question

Clojure का उपयोग करके कोड गोल्फिंग के लिए आपके सुझाव क्या हैं?

इस सवाल का उद्देश्य क्लोजर के लिए विशिष्ट तकनीकों की एक सूची एकत्र करना है और सामान्य कोड-गोल्फ समस्याओं में इसका उपयोग किया जा सकता है।

Comments

हम्म .. क्या इस प्रकार के पोस्ट मेटा में नहीं होने चाहिए (मुझे यकीन है कि मेटा 5 साल पहले अस्तित्व में नहीं है)

— अल्बर्ट रेनशॉ

Answer 1

लैम्ब्डा के लिए रीडर सिंटैक्स का उपयोग करें।
इसलिए उपयोग करें

#(+ % %2 %3)

के बजाय

(fn [x y z] (+ x y z))

आप व्हॉट्सएप को कुछ समय के लिए खत्म कर सकते हैं:

#(if (< % 0) (- %) %)
#(if(< % 0)(- %)%)

Comments

वैसे #(+ % %2 %3)के बराबर है +।

— bfontaine

Answer 2

जहां आप व्हाट्सएप को हटा सकते हैं:

• एक स्ट्रिंग और कुछ के बीच:

  (println(+"Hello, World!"1))
  

• कोष्ठक और कुछ के बीच:

  (for[x(range 5)](* x x))
  

• बिल्डरों या वैरिएबल नामों के अलावा एक संख्या और सब कुछ के बीच:

  Allowed:
  (+ 1"Example")
  (map{1"-1"2"-2"}[1 2 3])
  
  Not allowed:
  (+1 2)
  

• के बीच @(परमाणुओं के लिए dereference) और कोष्ठक।

Comments

इसके अलावा deref रीडर मैक्रो से पहले@

— केवल

इसके अलावा कई बार आप सामान को फिर से व्यवस्थित करने letऔर कुछ स्थानों से छुटकारा पाने में सक्षम हो सकते हैं ।

— निकोइरन्ह

अनाम कार्यों में मापदंडों से पहले भी: #(+ 1(first%))=#(+ 1 (first %))

— bfontaine

Answer 3

स्ट्रिंग्स को वर्णों के अनुक्रम के रूप में माना जा सकता है

वर्णों को वर्णानुक्रम में क्रमबद्ध करने के लिए:

(sort "hello")
=> (\e \h \l \l \o)

Comments

स्ट्रिंग्स परिभाषा के अनुसार लगभग हर भाषा में वर्णों का एक क्रम है, लेकिन आप उन सभी में इस ट्रिक को लागू नहीं कर सकते हैं :-)

— mellamokb

या इसके बजाय, "अनुक्रम" का

— क्लोजर

Answer 4

के nth ... 0बजाय का उपयोग करेंfirst

संग्रह का पहला तत्व प्राप्त करने के लिए, बाइट का उपयोग करने (nth ... 0)से firstबचत होती है:

(first[2 3 4]): 14 bytes
(nth[2 3 4]0): 13 bytes (saves a byte!)

Comments

वही second(2 बाइट्स) के लिए चला जाता है

— यूरिल

इसके अलावा, आप वैक्टर को कार्यों के रूप में उपयोग कर सकते हैं, इसलिए ([2 3 4]1)तत्व को सूचकांक 1 में लौटाता है। उदाहरण के लिए इनपुट प्रारूप लचीला होने पर यह लाभकारी होना चाहिए।

— निकोनिराह

Answer 5

उपयोग कम करने के बजाय लागू करें

उदाहरण के लिए #(apply + %)एक बाइट से छोटा है #(reduce + %)।

Answer 6

यदि आपके पास पहले से ही है तो जाने से बचें

उदाहरण के लिए: के #(for[a[(sort %)]...)बजाय #(let[a(sort %)](for ...))।

के लिए भी एक :letनिर्माण है, लेकिन यह भी कोड गोल्फ के लिए क्रिया है।

Answer 7

का प्रयोग करें +और -के बजाय incऔरdec

यदि आप उपयोग कर रहे हैं inc/ decparens के साथ एक अभिव्यक्ति पर यह 1 बाइट बचाता है :

(inc(first[1 3 5]))
(+(first[1 3 5])1)

Answer 8

ifसमानता के लिए परीक्षण करते समय नक्शे के बजाय मानचित्र का उपयोग करें

;; if n=3 then A else B
(if (= 3 n) A B) ; (if(=3n)AB)
({3 A} n B)      ; ({3A}nB) -> -3 chars

;; if n=2 or n=3 then A else B
(if (#{2 3} n) A B) ; (if(#{23}n)AB)
({2 A 3 A} n B)     ; ({2A3A}nB) -> -4 chars

Answer 9

एकल-बाइट प्रतीक पर लंबे फ़ंक्शन नाम बांधें

उदाहरण के लिए आप उपयोग करने की आवश्यकता है partitionया frequenciesकई बार, यह उन्हें एक में एक सिंगल-बाइट प्रतीक करने के लिए बाध्य करने के लिए फायदेमंद साबित हो सकता letमैक्रो। तब फिर से यह इसके लायक नहीं हो सकता है यदि आपको letअन्यथा की आवश्यकता नहीं है, और फ़ंक्शन का नाम अपेक्षाकृत कम है।

Answer 10

नक्शे के बजाय का उपयोग करें

उदाहरण के लिए #(for[i %](Math/abs i)), mapसमतुल्य की तुलना में बहुत कम है ।