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

Question

Android के विकास के लिए आधिकारिक तौर पर कोटलिन के समर्थन की Google की हालिया घोषणा को देखते हुए , मैंने सोचा कि इस अपेक्षाकृत नई JVM भाषा के लिए कुछ भयानक गोल्फ सुझावों के लिए समुदाय को चुनना समय पर हो सकता है।

Kotlin में जेवीएम भाई-बहनों के बीच विशेषताओं का एक अनूठा संयोजन शामिल है जो इसे गोल्फ के लिए संभावित रूप से आकर्षक बनाता है:

• ऑपरेटर ओवरलोडिंग
• स्थानीय , इन्फिक्स और स्थैतिक विस्तार कार्य
• स्मार्ट कास्ट
• ग्रूवी-शैली प्रकार-सुरक्षित बिल्डरों
• उपनाम लिखें
• पर्वतमाला
• एक व्यापक कार्यात्मक संग्रह पैकेज
• पटकथा समर्थन

तो, मैं अपने कोटलिन कार्यक्रम के आखिरी कुछ बाइट्स को कैसे निचोड़ूं? प्रति उत्तर एक टिप, कृपया।

Comments

क्या एक गोल्फ भाषा में रुचि होगी जो कोटलिन के कुछ लंबे नामों को छोटा करती है, लेकिन बहुत अधिक अतिरिक्त (प्रारंभिक रूप से) नहीं जोड़ती है? मैं आम 1 पत्र बनाने की सोच रहा हूं, स्ट्रिंग चार मायने रखता हूं और केवल 1 उद्धरण चिह्न के साथ एकल अक्षर तार जोड़ रहा हूं?

— jrtapsell

* सामान्य कार्य

— Common'१

लगता है कि कोटलिन

— jrtapsell

मैंने अधिक कोटलिन समाधान प्रस्तुत करना शुरू करने की योजना बनाई है! मुझे तुम्हारी उस परियोजना को भी देखना होगा।

— टायलर मैकडोनेल

Answer 1

विस्तार कार्य

एक्सटेंशन फ़ंक्शंस वास्तव में बिल्ट इन विधियों के नाम को कम करने में मदद कर सकते हैं और उनमें से चेन एक उदाहरण हो सकता है:

fun String.c() = this.split("").groupingBy{it}.eachCount()

लेकिन यह केवल अगर मदद करता है:

ए) परिभाषा को रद्द करने के लिए कॉल पर्याप्त है

बी) कॉल दोहराया जाता है

विधियों के बजाय लंबोदर का उपयोग

लैम्ब्डा बाइट को बचाते हुए, वापसी कीवर्ड का उपयोग किए बिना वापस आ सकती है

KotlinGolfer

एक परियोजना जो मैंने यहां शुरू की है, जो बहुत कोटलीन कोड लेती है और परीक्षण और TIO लिंक के साथ स्वचालित रूप से पोस्ट देती है

Answer 2

के +बजाय का उपयोग करेंtoString

जैसा कि कोई उम्मीद कर सकता है, स्ट्रिंग कंसट्रक्शन के लिए ऑपरेटर को Stringओवरलोड करता है +, जैसे।

print("Hel" + "lo")

हालाँकि, डॉक्स की जाँच हमें बताती है कि यह स्वीकार करता है Any?, न कि केवल String। जैसा कि कहा गया:

दिए गए अन्य ऑब्जेक्ट के स्ट्रिंग प्रतिनिधित्व के साथ इस स्ट्रिंग को संक्षिप्त करके प्राप्त की गई एक स्ट्रिंग लौटाता है।

दूसरे शब्दों में, समतल करने से पहले दाहिने हाथ की तरफ String + anythingकॉल करना सुनिश्चित करता है .toString()। यह हमें छोटा it.toString()करने की अनुमति देता है ""+it, सबसे बड़ी 8 बाइट बचत सबसे अच्छी और 6 बाइट सबसे खराब।

---

के foldबजाय का उपयोग करेंjoinToString

उपरोक्त से संबंधित, यदि आप कॉल कर रहे हैं mapऔर फिर joinToString, आप foldइसके बजाय का उपयोग करके छोटा कर सकते हैं ।

list.map{it.repeat(3)}.joinToString("")
list.fold(""){a,v->a+v.repeat(3)}

Comments

टीआईएल गुना एक चीज है, अच्छा है

— क्विन

Answer 3

१.३ से शुरू होकर आप मुख्य रूप से मज़े में आर्गेज्म ( पूरी तरह से ) छोड़ सकते हैं , इस प्रकार १ (चरों (यानी लंबाई args:Array<String>) की शेविंग कर सकते हैं ।

Answer 4

इंटों में परिभाषित करना

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

इस सवाल के मेरे जवाब से उदाहरण :

फ़ंक्शन में चर को परिभाषित करना:

fun String.j()={var b=count{'-'==it}/2;var a=count{'/'==it};listOf(count{'o'==it}-a,a-b,b)}

चर को परिभाषित करने के रूप में:

fun String.j(b:Int=count{'-'==it}/2,a:Int=count{'/'==it})=listOf(count{'o'==it}-a,a-b,b)

क्योंकि var a=यह एक ही लंबाई है क्योंकि a:Int=यह उन्हें परिभाषित करने के लिए बाइट्स की समान संख्या होगी ( Intहालांकि यह केवल के लिए है ) क्योंकि मेरे पास अब केवल 1 पंक्ति है जिस फ़ंक्शन में मैं ड्रॉप कर सकता {}हूं और मैं एक भी ड्रॉप करता हूं ;(दूसरा है) से बदल दिया गया है ,)

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

Answer 5

toइन्फ़िक्स समारोह

वहाँ एक मानक इन्फ़िक्स समारोह नामित है toकि बनाता है Pairदो मानों का रों। यह आमतौर पर mapOf()परिभाषित करने के लिए उपयोग किया जाता है , Mapलेकिन यह संभावित रूप से Pair()निर्माणकर्ता की तुलना में बहुत कम हो सकता है ।

Pair(foo,bar)   //constructor
foo to bar      //best case 
(foo)to(bar)
((foo)to(bar))  //worst case

Answer 6

लंबोदर तर्कों में विनाशकारी

कहते हैं कि आप Pair<*,*>एक मेमने में एक स्वीकार करना चाहते हैं । आम तौर पर, इसे संभालना कष्टप्रद होगा। एक उदाहरण के रूप में, यहाँ एक लैम्ब्डा है जो एक लेता है Pairऔर जाँचता है कि क्या दो मान समान हैं:

{it.first==it.second}

यह लंबे समय से घुमावदार और अनाड़ी है। सौभाग्य से, कोटलिन आपको किसी भी विनाशकारी प्रकार (किसी भी प्रकार कि componentN()विधियों को लागू करता है, जैसे कि Pair, Tripleआदि) को लंबोदर के तर्क के रूप में नष्ट करने की अनुमति देता है । इसलिए, हम इसे निम्नलिखित तरीके से फिर से लिख सकते हैं:

{(a,b)->a==b}

यह F # जैसी किसी चीज़ में टपल से मिलते-जुलते पैटर्न जैसा दिखता है, और यह कई मामलों में है। लेकिन कोटलिन प्रकार की एक विस्तृत विविधता विनाशकारी समर्थन करती है ( MatchResultयह एक उपयोगी है।)

आप अधिक तर्क ले सकते हैं, हालांकि। कहते हैं कि आपके मेमने को Pairअतिरिक्त मूल्य लेना पड़ा । आप बस इस तरह लंबोदर हस्ताक्षर लिखेंगे:

(a,b),c->  // pair first
a,(b,c)->  // pair second