भूसी में गोल्फ के लिए युक्तियाँ

Question

हस्क पीपीसीजी उपयोगकर्ताओं लियो और ज़र्गब द्वारा बनाई गई एक काफी नई गोल्फ भाषा है । यह अधिक से अधिक प्रतिस्पर्धी होना शुरू हो गया है, अक्सर करीबी या यहां तक ​​कि पिटाई की जाने वाली भाषाओं जैसे कि जेली और 05.11 ई।

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

Comments

मैं कहूंगा कि नहीं यह है नई ...

— totallyhuman

@totallyhuman पहला हुस्क जवाब अभी भी नया नहीं है

— H.PWiz

Answer 1

विधेय से वापसी मूल्य का उपयोग करें

हस्क में, कुछ संपत्ति के लिए उनके इनपुट का परीक्षण करने वाले कार्य आमतौर पर सत्य मामलों में एक सार्थक परिणाम लौटाते हैं, क्योंकि कोई भी सकारात्मक पूर्णांक सत्य है।

उदाहरण:

≠  Numbers: Absolute difference
   Chars:   Absolute difference of code points
   Lists:   First Index where the differ

Comparisons <, >, ≤, ≥:

For strict comparisons:
Numbers,Chars:  max 0 (the appropriate difference¹)
Lists: The first index where the comparison between the two lists is true

For non-strict comparisons:
Numbers,Chars: max 0 (the appropriate difference + 1)
Lists: Either the result of the strict comparison or, if they are equal,
       the length of the list + 1

ṗ  Index into the list of prime numbers

V  The index of the first element for which the condition is true

€  The first index of that element/substring in the list

£  Works like €

&  Given two arguments of the same type will return the second argument if false,
   otherwise will return the first argument

|  Given two arguments of the same type will return the second argument if true,
   otherwise will return the first argument

¦  Return the quotient if divisibility holds

Λ,E,Ë  Will all return length+1 in truthy cases

Char predicates:
□,±,√,D,½  will each return the codepoint of its argument on truthy cases

¹ उपयुक्त अंतर का मतलब है वर्णों के लिए कोड बिंदुओं का अंतर। यह तर्क क्रम को भी संदर्भित करता है। यानी के लिए <x y, होगाx-y

Answer 2

ओवरफ्लोइंग लाइन लेबल का उपयोग करें

जैसा कि आप पहले से ही जानते हैं, [₀-₉]+|[₀-₉]वाक्यविन्यास के लिए एक अलग पंक्ति को कॉल करने के लिए regex है जो आप वर्तमान में हैं।

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

समारोह की मेज:

+----------+----------+
|Index     |Function  |
+----------+----------+
|1         |´ (argdup)|
+----------+----------+
|2         |` (flip)  |
+----------+----------+
|3         |m (map)   |
+----------+----------+
|4         |z (zip)   |
+----------+----------+
|5         |S (hook)  |
+----------+----------+

आपके कोड की पंक्तियों को उनके संबंधित 0-आधारित सूचकांकों के साथ ऊपर से नीचे तक लेबल किया गया है। यदि M <N , जहां M लेबल है और N आपके कोड की पंक्तियों की संख्या है, तो लेबल केवल M पर परिभाषित फ़ंक्शन का प्रतिनिधित्व करता है । यदि N function M <N * 6 है , तो यह सूचकांक ≤M ⌋ N index से ऊपर की तालिका से फ़ंक्शन का प्रतिनिधित्व करता है और इसके पहले तर्क के रूप में लाइन M mod N में फ़ंक्शन को परिभाषित किया गया है। यदि N * 6 , M , एक इंडेक्स एरर उठाया जाता है।

Answer 3

लैंबडास नए कार्यों से छोटा हो सकता है

जैसा कि आप शायद जानते हैं कि यदि आपके पास एक बहु-पंक्ति कार्यक्रम है, तो आप सदस्यता के साथ लाइनों का उल्लेख कर सकते हैं ₀…₉, उदाहरण के लिए

f
g

₁फ़ंक्शन का संदर्भ देगा g। अब यदि आप हमेशा फ़ंक्शन पर इनपुट लागू करते हैं g(और इसे कई बार उपयोग करते हैं); कुछ इस तरह:

f₁⁰[...]g₁⁰[...]
h

आपको एक लैम्ब्डा शुरू करना चाहिए क्योंकि यह आपको प्रत्येक अतिरिक्त उपयोग के लिए 1 बाइट बचाता है:

λf⁰[...]g⁰[...])h

---

रिवर्स सच भी हो सकता है

सेल्फ-रेफरेंशियल लैम्ब्डा ( φχψ) के मामले में , वह विशेष केस होता है, जहाँ आप इनपुट्स को पुनरावर्ती फ़ंक्शन पर सीधे लागू करते हैं, इन मामलों में आप ₀नए लैम्बडा को परिभाषित करने और उपयोग करने के बजाय सबस्क्रिप्ट का उपयोग करके बेहतर होते हैं ⁰।

Answer 4

का उपयोग करता है Γ

बिल्ट-इन का मुख्य उपयोग Γ, जिसे सूचियों या सूची डिकंस्ट्रक्शन पर मिलान करने वाले पैटर्न के रूप में जाना जाता है , एक सूची को सिर और पूंछ में विभाजित करना और उन पर एक बाइनरी फ़ंक्शन लागू करना है। यह हास्केल पैटर्न के मेल खाने वाले मुहावरे से मेल खाती है

f (x : xs) = <something>
f [] = <something else>

जहाँ <something>एक अभिव्यक्ति है x, xsऔर संभवतः f। 4 ओवरलोडिंग हैं Γ, जिनमें से प्रत्येक थोड़ा अलग तरीके से काम करता है।

list

पहला ओवरलोडिंग, listएक मान aऔर एक बाइनरी फ़ंक्शन लेता है f। यह एक नया फ़ंक्शन देता है जो सूची लेता है, aयदि यह खाली है, तो वापस आ जाता है fऔर अगर यह गैर- खाली है तो सिर और पूंछ पर कॉल करता है। उदाहरण के लिए, Γ_1€एक सूची लेता है, -1अगर यह खाली है, और यदि नहीं तो पूंछ में पहले तत्व की पहली घटना का सूचकांक।

listN

दूसरा ओवरलोडिंग, के listNसमान है list, सिवाय इसके कि aछोड़ दिया गया है और बदले प्रकार के डिफ़ॉल्ट मान का उपयोग किया जाता है। उदाहरण के लिए, Γ€के बराबर है Γ0€, क्योंकि डिफ़ॉल्ट संख्यात्मक मान है 0।

व्यवहार में, listNअधिक से अधिक बार उपयोग किया जाता है list, क्योंकि डिफ़ॉल्ट मान या तो अप्रासंगिक है या वास्तव में आपको क्या चाहिए। एक सामान्य पैटर्न है Γ~αβγ, जहां αβγतीन कार्य हैं; यह βपहले तत्व और γपूंछ पर लागू होता है , और परिणामों को जोड़ती है α। इस उत्तर में इसका उपयोग किया गया था । अन्य पैटर्न शामिल Γo:αलागू करने के लिए αकेवल पहला तत्व है, और Γ·:mαलागू करने के लिए αपहले को छोड़कर सभी तत्वों के लिए। इस उत्तर में उत्तरार्द्ध का उपयोग किया गया था ।

listF

तीसरा ओवरलोडिंग थोड़ा अधिक शामिल है। जैसे list, यह एक मान aऔर एक फ़ंक्शन लेता है f, और एक नया फ़ंक्शन देता है gजो एक सूची लेता है। हालांकि, यह समय fएक अतिरिक्त फ़ंक्शन तर्क लेता है, जो gस्वयं है, और इसे किसी भी मूल्य पर कॉल कर सकते हैं (सहित, लेकिन इनपुट सूची की पूंछ तक सीमित नहीं है)। इसका मतलब यह है कि सूचियों पर listFएक सामान्य पुनरावृत्ति योजना को लागू करता है। listFबहुत बार उपयोग नहीं किया जाता है, क्योंकि स्पष्ट उत्तर के साथ list/ listNआमतौर पर एक ही लंबाई या छोटी होती है, जैसा कि इस उत्तर में है ।

listNF

listNFइसके लिए listFक्या listNहै list: इनपुट aछोड़ा गया है, और बदले प्रकार के डिफ़ॉल्ट मान का उपयोग किया जाता है। दुर्लभ परिस्थितियों में, यह एक सही तह से कम हो सकता है, उदाहरण के लिए इस उत्तर में ।

के पुनरावर्ती संस्करणों के एक उदाहरण के रूप में Γ, फ़ंक्शन Γλ·:o⁰↔पहले, अंतिम, दूसरे, दूसरे से दूसरे, तीसरे, तीसरे-से-अंतिम, और इसी तरह के क्रम में एक सूची में फेरबदल करता है। इसे ऑनलाइन आज़माएं! फ़ंक्शन fस्पष्ट लंबोदर है λ·:o⁰↔, जिसका तर्क ⁰संपूर्ण फ़ंक्शन है। क्या fकरता है के साथ पूंछ को उल्टा है ↔, तो मुख्य समारोह के साथ पुनरावर्ती कॉल o⁰, और अंत में सिर के साथ वापस सौदा ·:। बेशक, Γ·:o₀↔एक बाइट कम है, लेकिन काम नहीं करता है अगर लाइन में इस फ़ंक्शन के अलावा कुछ और होता है।

Answer 5

संयोजकों को उच्च आदेश कार्यों पर लागू किया जा सकता है

मान लीजिए कि आपके पास पूर्णांक X की सूची है , और आप X के तत्वों की कुल संख्या को गिनना चाहते हैं जो लंबाई (X) से बड़ी हैं । एक विधेय को संतुष्ट करने वाले तत्वों को उच्च क्रम फ़ंक्शन के साथ किया जाता है #, लेकिन यहां विधेय ( लंबाई (X) से बड़ा होना ) X पर निर्भर करता है । समाधान Combinator लागू करने के लिए है Ṡकरने के लिए #और समारोह o>Lहै कि जाँच करता है कि एक सूची एक संख्या की तुलना में कम है। फ़ंक्शन में Ṡ#o>L, सूची X को पास की जाती है o>L, आंशिक रूप से लागू फ़ंक्शन को पास किया जाता है #, और X को #दूसरे तर्क के रूप में दिया जाता है।

सामान्य तौर पर, यदि αएक उच्च-क्रम फ़ंक्शन, βएक बाइनरी फ़ंक्शन और γएक अनियारी फ़ंक्शन है, Ṡαβतो हास्केल स्यूडोड के बराबर है

\x -> α (\y -> β x y) x

§αβγ के बराबर है

\x -> α (\y -> β x y) (γ x)

और ~αβγके बराबर है

\x y -> α (\z -> β x z) (γ y)

जब तक प्रकार मेल खाते हैं।

एक और ठोस उदाहरण के रूप में, §►δṁ≠Pएक सूची का क्रमपरिवर्तन पाता एक्स कि इसी के मूल्यों को पूर्ण मतभेद की राशि को अधिकतम एक्स ( δṁ≠पूर्ण अंतर का उपयोग कर दो सूचियों ज़िप और राशि लेता है)।

Answer 6

भूसी के डिफ़ॉल्ट मान

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

.------------------------------------.---------------.----------.-------.
|   Type (X and Y are placeholders)  | default (def) |    max   |  min  |
|------------------------------------|---------------|----------|-------|
|       Character (C)                |      ' '      | \1114111 | \NUL  |
|       Numbers   (N)                |       0       |   Inf    | -Inf  |
|       List of X (LX)               |      []       |  ∞ max   |   []  | *
|       Function :: X -> Y           | const (def Y) |   n/a    |  n/a  |
'------------------------------------'---------------'----------'-------'

_{* यहाँ corresponding इसी अधिकतम की एक अनंत सूची का प्रतिनिधित्व करना चाहिए (उदाहरण के लिए नीचे देखें)}

_{नोट: ट्यूपल्स (एक्स, वाई) के लिए यह प्रत्येक घटक के लिए मूल्यों का अलग-अलग उपयोग करेगा।}

---

जब उनका उपयोग किया जाता है

हालांकि मैक्सिमा और मिनिमा का उपयोग केवल ▲▼खाली सूचियों के लिए किया जाता है (उदाहरण के लिए husk -u "▼" "[]:LLN"अनंत सूची लौटाएगा Inf) कुछ स्थानों पर डिफ़ॉल्ट मानों का उपयोग किया जाता है:

• अपने आप को एक मूल्य प्रदान किए बिना खाली सूचियों पर तह करना ( Fऔर Ḟ)
• डिफ़ॉल्ट मान (साथ में Θ)
• जब पढ़ा ( r) विफल रहता है
• पहला / अंतिम तत्व प्राप्त करना (←→ ) या एक में अनुक्रमण करना ( !)
• पैटर्न मिलान (Γ ) खाली सूचियों पर
• खाली सूचियों का उपयोग करना ►या ◄करना