रैकेट / स्कीम में गोल्फ के लिए टिप्स

Question

रैकेट / स्कीम में गोल्फिंग के लिए आपके पास क्या सामान्य सुझाव हैं ? मैं उन विचारों की तलाश कर रहा हूं जो सामान्य तौर पर रैकेट / स्कीम के लिए कम से कम कुछ हद तक विशिष्ट कोड गोल्फ समस्याओं पर लागू हो सकते हैं (उदाहरण के लिए "टिप्पणियां हटाएं" एक उत्तर नहीं है)।

---

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

Answer 1

भाव 'x, `x, ,x, एक ,@xस्वचालित रूप से करने के लिए विस्तार (quote x), (quasiquote x), (unquote x), और (unquote-splicing x), क्रमशः। यह विशुद्ध रूप से एक वाक्यात्मक परिवर्तन है, और इसे कहीं भी लागू किया जा सकता है। यह एक-चर कार्यों के लिए एक सुविधाजनक संकेतन देता है:

; Defining a function:
(define ,x (+ x x))
; Calling a function:
(display ,2)

जिसका विस्तार होता है

; Defining a function:
(define (unquote x) (+ x x))
; Calling a function:
(display (unquote 2))

मुझे यकीन नहीं है कि सिंटैक्टिक कीवर्ड जैसे कि quoteया quasiquoteएक बाध्य चर के साथ छायांकन के लिए शब्दार्थ क्या है , हालांकि उपरोक्त कोड की तरह मैंने जिन व्याख्याताओं पर काम किया है, उन पर काम किया है, और unquote-splicingआदर्श से कम है क्योंकि इसमें दो-वर्ण का संक्षिप्त नाम है, लेकिन unquoteएक अक्षर संक्षिप्त नाम के साथ एक सहायक वाक्यविन्यास है और इसलिए इस हैक के लिए आदर्श है।

Answer 2

में रैकेट , λऔर lambdaगुमनाम कार्यों के निर्माण के लिए पर्याय बन गया कीवर्ड हैं, लेकिन λ2 बाइट्स जहां है lambda6 है।

में योजना , ऐसी कोई कीवर्ड है λऔर आप के साथ समस्या आ रही lambda।

Answer 3

~aसंख्याओं और प्रतीकों को तारों में बदलने के लिए उपयोग करें ।

Answer 4

रैकेट का उपयोग करते समय , λकुछ बाइट्स को शेव करने के लिए वैरिएबल को बांधें । में योजना , lambdaजब तक कि एक चार या अधिक चरों बाध्यकारी है, इस चाल लागू नहीं करता है।

उदाहरण: एक चर 2 बाइट्स को बचाता है let/define

(define n 55)(* n n) ; 20 bytes

(let([n 55])(* n n)) ; 20 bytes

((λ(n)(* n n))55) ; 18 bytes

Comments

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

— माइकल व्हीकल्स

मुझे यकीन नहीं है कि योजना मंडलियों में इस्तेमाल की जाने वाली विशिष्ट शब्दावली के साथ आपकी राय क्या है । मैं आपको आश्वासन दे सकता हूं कि दोनों तरीके एक वैचारिक दायरे के लिए बाध्यकारी हैं, और letअक्सर के संदर्भ में लागू किया जाता है lambda।

— विन्नी

Answer 5

में रैकेट , requireरूपों कई तर्क हो सकता है।

(require net/url net/uri-codec)

से छोटा है

(require net/url)(require net/uri-codec)

मुझे स्कीम के बारे में ज्यादा जानकारी नहीं है , लेकिन इसमें requireबिलिन नहीं है।

Answer 6

छोटे समानार्थी शब्दों का प्रयोग करें

रैकेट में कई प्रक्रियाएँ होती हैं जिनमें अधिकतर-समतुल्य छोटे संस्करण होते हैं। (वे आमतौर पर समतुल्य नहीं होते हैं: उदाहरण के लिए, (car (cons 1 2))काम करता है जहां (first (cons 1 2))विफल रहता है। लेकिन आप प्रतिस्थापन कर सकते हैं यदि आप जानते हैं कि वे आपके मामले में समानार्थक हैं।)

यह सूची शायद अधूरी है: मैं शायद उन चीजों के बारे में नहीं जानता जो अभी तक इस सूची में जा सकती हैं।

• (= a b)इसके बजाय (equal? a b)जब संख्या की तुलना।
• '(1 2)के बजाय (list 1 2)।
• car, cadr, cdrके लिए first, second, और rest।
• null? के बजाय empty?
• moduloइसके बजाय remainderजब मापांक सकारात्मक होता है।
• floorइसके बजाय truncateजब इसका तर्क सकारात्मक हो।

Answer 7

अनावश्यक स्थानों को छोड़ दें

इसे एक "तुच्छ" टिप माना जा सकता है, लेकिन इसे कहीं बाहर इंगित करना होगा।

जब भी आप सामान्य लोगों द्वारा लिखे गए रैकेट कोड को पढ़ते हैं (उदाहरण के लिए रैकेट प्रलेखन में ) इसमें सभी रिक्त स्थान होंगे: उदाहरण के लिए, उदाहरण के लिए

(append (list 1 2) (list 3 4) (list 5 6) (list 7 8))

वास्तव में, के बाद से (और )चर नाम का हिस्सा नहीं हो सकता है, हम उन्हें भर के सभी स्थानों को हटा और न कोई अस्पष्टता खो सकते हैं (और, अधिक महत्वपूर्ण, अभी भी मान्य कोड प्राप्त)। तो इसके बजाय उपरोक्त अभिव्यक्ति हो सकती है:

(append(list 1 2)(list 3 4)(list 5 6)(list 7 8))

Answer 8

निम्नलिखित टिप्स रैकेट के लिए हैं :

डिफ़ॉल्ट तर्क

विशेष रूप से लंबे फ़ंक्शन नामों के लिए उपनाम बनाने के लिए विशेष रूप से उपयोगी है जो अक्सर उपयोग किए जाते हैं।

मान लें कि गोल्फ आपको एक फ़ंक्शन लिखने की अनुमति देता है जो तर्क का उपभोग करता है, और मान लें कि आपको reverseबहुत उपयोग करने की आवश्यकता है । आप कुछ इस तरह से शुरू करेंगे:

(λ(x) ... reverse ... reverse ... reverse ...

आप इसके बजाय एक छोटे नाम के साथ एक अतिरिक्त तर्क में ले सकते हैं reverse, और इसके डिफ़ॉल्ट मान को reverseनिम्न पर सेट कर सकते हैं :

(λ(x[r reverse]) ... r ... r ... r ...

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

match

यह एक छोटी सी पोस्ट में संक्षेप में रखने के लिए थोड़ा कठिन है, इसलिए इस एक के लिए रैकेट डॉक्स पर पढ़ें । संक्षेप में, matchआप तत्वों और तत्वों के अनुक्रमों को एक सूची से एक निश्चित क्रम में निकालने की अनुमति देते हैं, और quasiquote सिंटैक्स आपको एक साथ कटे हुए सूची को वापस सिलाई करने देता है:

(match (range 10)
 [`(,xs ... 3 ,ys ... 6 ,zs ...)
  `(,@(map f xs) 3 ,@(map f ys) 6 ,@(map f sz))]
 ...

यह आपको नियमित अभिव्यक्तियों के साथ काम करने और परिणामी समूहों पर अतिरिक्त गणना करने का एक आसान तरीका देता है,

नामांकित let

नाम सिंटैक्स यहाँ देखें ।let proc-id ...

यह आपको पुनरावर्ती कार्यों को लिखने की अनुमति देता है जिन्हें defineआपके द्वारा परिभाषित किए जाने के तुरंत बाद फ़ंक्शन के बिना या वास्तव में कॉल किया जाता है।

कुछ इस तरह:

(define (fib i)
  (if (< i 2) i
      (+ (fib (- i 1)) (fib (- i 2)))))
(fib 10)

इसे छोटा किया जा सकता है:

(let fib {[i 10]}
  (if (< i 2) i
      (+ (fib (- i 1)) (fib (- i 2)))))

यह अंतिम मूर्खतापूर्ण है, लेकिन मैं अब तक कहीं भी इस छोटी सी चाल का उपयोग करने में सक्षम नहीं हुआ हूं:
(apply map list matrix)एक स्थानान्तरण लेता है matrix, जहां matrixकुछ आयताकार सूची की सूची है, जैसे '((1 2 3) (a b c))।
मुझे पता है अगर यह उपयोगी साबित होता है।

Answer 9

जैसा कि विनी ने बताया , #!आमतौर पर इसके बजाय #langचार बाइट की बचत की जा सकती है ।

#lang racket ;12 bytes
#!racket ;8 bytes