अपने अनंत लूप को छोटा करें
जब आपको एक अनंत लूप का उपयोग करना होता है, तो आप ए का उपयोग करने के बारे में सोच सकते हैं while, लेकिन इसके बजाय एक लेबल का उपयोग करना 2 बाइट से छोटा होता है:
while''do end
::a::goto a
जितना हो सके कम जगह का इस्तेमाल करें
आपके कोड से और भी अधिक रिक्त स्थान निकालने के लिए आप (एब) का उपयोग कर सकते हैं एक साधारण बात है। लुआ का चश्मा उन नामों के बारे में स्पष्ट है जो आप चर को देते हैं: उन्हें एक पत्र के साथ शुरू करना होगा। इसका मतलब है कि, कभी-कभी, आप संख्याओं और कार्यों / चर के बीच रिक्त स्थान पर छोड़ सकते हैं
x=0>1 and 0or 1print(x)
स्थान को हटाने की संभावना संख्या के बाद के अक्षर पर निर्भर करती है, यहां वह पत्र है जो आपको ऐसा करने की अनुमति नहीं देगा:
a,b,c,d,e,f -- They would be interpreted as hexadecimal
x -- only fail when after a 0, other number are fine
-- (0x indicates the following is an hexadecimal number)
इसका उपयोग करके, और ध्यान दें कि आप अपने चर को कैसे कॉल करते हैं, आप अपने अधिकांश स्रोत कोड को स्थान-मुक्त बना सकते हैं।
पहले से ही यहां एक उदाहरण उठा है, और इस सलाह का उपयोग करते हुए, यहां एक और बाइट है जिसे आप मुंडा सकते हैं :)।
print(a and-1 or-2)
print(a and-1or-2)
सही इनपुट विधि का उपयोग करें
यदि हम प्रत्येक प्रमुख प्रकार के इनपुट के लिए बॉयलरप्लेट और लागत को देखते हैं , तो यहां हमारे पास क्या है:
function f(x)x end
io.read()
arg[1]
इस पद्धति में से प्रत्येक हमें 1 इनपुट लेने की अनुमति देता है, जिसमें फ़ंक्शन सबसे भारी लागत के साथ होता है (लेकिन हमें इनपुट के रूप में एक टेबल लेने की अनुमति देता है)
अब हम देख सकते हैं कि यदि आप गोल्फ चाहते हैं तो कमांड-लाइन तर्क का उपयोग करना रास्ता है, लेकिन जागरूक रहें: यह और भी छोटा हो सकता है
arg[1]
...
...Lua में थोड़ा विशेष हैं, यह एक चर के पैक सामग्री से युक्त है arg, या एक variadic समारोह के मामले में पैक मानकों।
जब आपको एक से अधिक इनपुट प्राप्त करने होंगे, और उनमें से प्रत्येक का उपयोग करना होगा, तो उन्हें एक चर में सहेजना अच्छा हो सकता है। यहाँ चर में 2 इनपुट को बचाने के कुछ तरीके दिए गए हैं
a=arg[1]b=arg[2] -- highly un-efficient, costs 8 bytes by variable
a,b=unpack(arg) -- costs 15, but at least doesn't depends on the number of argument
a,b=... -- only costs 7
और यहां वे सबसे छोटी कॉल हैं जो आप चर के बिना कर सकते हैं:
... -- using a allow a gain of 1-2 bytes at each use
arg[2] -- using b allow a gain of 4-5 bytes at each use
उस बिंदु से जहां आपके पास 3 तर्क हैं, या जब आप 2 तर्कों का उपयोग करते हैं, तो दो बार उपयोग किए जाने के साथ, आप पहले से ही बाइट प्राप्त कर रहे हैं a,b=...! :)
लगभग कभी उपयोग नहीं अगर!
ऐसे मामलों के पास नहीं है जहाँ एक if / फारस / if कथन का उपयोग करने पर एक टर्नरी से कम खर्च होगा। इस तरह के एक बयान के लिए बॉयलरप्लेट वास्तव में भारी है:
-- exemple with dumb values
if 1>0then v=1 else v=0 end
v=1>0 and 1or 0
एक सरल उदाहरण के साथ, आप पहले से ही 12 बाइट्स बचाते हैं, जब आपको कुछ और काम करना होता है, तो यह अधिक से अधिक महत्वपूर्ण हो जाता है, इसलिए इसके बारे में पता होना चाहिए!
इसके अलावा, लुआ में ternaries विशेष हैं , वहाँ कुछ शर्त है कि वे कैसे काम करते हैं, रुचि रखने वालों के लिए, मैं इसे नीचे :
लुआ में टेरानरीज़ का रूप है <condition> and <case true: have to be a true value> or <case false: can be anything>
सबसे पहले, आइए देखें की सत्य तालिका or। A orको एक फ़ंक्शन के रूप में माना जा सकता है: यह हमेशा एक मान लौटाता है, यहाँ वह मान लौटाता है:
x | y ||x or y
------||-------
0 | 0 || y
0 | 1 || y
1 | 0 || x
1 | 1 || x
यही कारण है कि हमें अपनी त्रिगुट का निर्माण करने की अनुमति देता है।
andक्या हमें स्थिति का मूल्यांकन करने की अनुमति है, यह हमेशा वापस आ जाएगी yअगर x and yमूल्यांकन करता है सच करने के लिए।
इसके साथ समस्या यह है कि अगर हम चाहते हैं कि यह विफल हो जाए nilया falseजब हालत हो तो वापस लौटाया जाए false। उदाहरण के लिए, स्थिति हमेशा सही होने के बावजूद, निम्नलिखित 5 हमेशा वापस आ जाएंगे।
v = true and false or 5
यह समझने के लिए कि यह कैसे काम करता है (यह तब आपके लिए उपयोगी होगा जब आप उन्हें घोंसला बनाना चाहते हों) :)
-- let's use our dumb ternary
= true and false or 5
-- and statement will be evaluated first, leading to
= false or 5
-- and we saw how the or works
= 5