कोटलिन गूढ़ व्यक्ति, वॉल्यूम। 2: पहेली का एक नया बैच

क्या आप अनुमान लगा सकते हैं कि ऐसा कोटलिन कोड कैसे व्यवहार करेगा? क्या यह संकलित करेगा कि आउटपुट क्या और क्यों करेगा?

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

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

हम भाषण की वीडियो रिकॉर्डिंग भी संलग्न करते हैं, अगर पाठ में कुछ अयोग्य प्रतीत होता है, तो आप उससे संपर्क भी कर सकते हैं।


पज़लर्स की पहली छमाही उन लोगों के उद्देश्य से है जो कोटलिन से बहुत परिचित नहीं हैं; दूसरी छमाही कट्टर Kotlin डेवलपर्स के लिए है। हम सब कुछ Kotlin 1.3 पर शुरू करेंगे, यहां तक ​​कि प्रगतिशील मोड सक्षम होने के साथ। पज़टलर स्रोत कोड GitHub पर हैं। जो भी नए विचारों के साथ आता है, पुल अनुरोध भेजते हैं।

चकाचक संख्या १

fun hello(): Boolean { println(print(″Hello″) == print(″World″) == return false) } hello() 

इससे पहले कि हम एक साधारण हैलो फ़ंक्शन है, यह कई प्रिंट चलाता है। और हम इस फ़ंक्शन को स्वयं लॉन्च करते हैं। एक सामान्य ओवरक्लॉकिंग प्रश्न: इसे क्या प्रिंट करना चाहिए?

क) हैलोवर्ल्ड
b) हैलोवर्ल्डफाल्से
ग) हैलोवर्ल्डट्रू
घ) संकलित नहीं

चकाचक संख्या २

 fun printInt(n: Int) { println(n) } printInt(-2_147_483_648.inc()) 

संकेत है कि आप अनुमान नहीं लगाते हैं: एक डरावनी संख्या वास्तव में सबसे कम संभव 32-बिट हस्ताक्षरित पूर्णांक है।

यहां सब कुछ सरल दिखता है। कोटलिन के पास इंक्रीमेंटिंग के लिए .inc () जैसे महान विस्तार कार्य हैं। हम इसे इंट पर कॉल कर सकते हैं, और हम परिणाम प्रिंट कर सकते हैं। क्या होगा?

a) -2147483647
b) -2147483649
c) 2147483647
d) उपरोक्त में से कोई नहीं

पीज़लर नंबर 3

 var x: UInt = 0u println(x--.toInt()) println(--x) 

कोटलिन में 1.3 नए शानदार फीचर आए। कोरुटिन के अंतिम संस्करण के अलावा, हम
अब अंत में अहस्ताक्षरित संख्याएँ हैं। यह आवश्यक है, खासकर यदि आप किसी तरह का नेटवर्क कोड लिख रहे हैं।

अब शाब्दिकों के लिए भी एक विशेष अक्षर u है, हम स्थिरांक को परिभाषित कर सकते हैं, उदाहरण के लिए, हम x को घटा सकते हैं और Int में बदल सकते हैं। मैं आपको याद दिलाता हूं कि इंट हमसे परिचित है।

क्या होगा?

a) -1 4294967294
b) 0 4294967294
c) 0 -2
घ) संकलित नहीं

4294967294 अधिकतम 32-बिट संख्या है जिसे प्राप्त किया जा सकता है।

चकाचक संख्या ४

 val cells = arrayOf(arrayOf(1, 1, 1), arrayOf(0, 1, 1), arrayOf(1, 0, 1)) var neighbors = cells[0][0] + cells[0][1] + cells[0][2] + cells[1][0] + cells[1][2] + cells[2][0] + cells[2][1] + cells[2][2] print(neighbors) 

हम इस मामले में वास्तविक कोड में भाग गए। हम कोडबोर्न में कोडिंग डोजो करते थे, इसे कोटलिन गेम ऑफ लाइफ पर एक साथ लागू किया। जैसा कि आप देख सकते हैं, कोटलिन पर बहु-स्तरीय सरणियों के साथ काम करना बहुत सुविधाजनक नहीं है।

गेम ऑफ लाइफ में, एल्गोरिथ्म का एक महत्वपूर्ण हिस्सा एक सेल के लिए पड़ोसियों की संख्या निर्धारित कर रहा है। आसपास के सभी छोटे पड़ोसी हैं, और यह इस बात पर निर्भर करता है कि कोशिका जीवित रहती है या मर जाती है। इस कोड में, आप लोगों को गिन सकते हैं और मान सकते हैं कि क्या होता है।

a) ६
b) ३
ग) २
घ) संकलित नहीं

चकाचक नंबर 5

 val x: Int? = 2 val y: Int = 3 val sum = x?:0 + y println(sum) 

इस गूढ़ व्यक्ति को कोटलिनकॉन्फ स्पीकर थॉमस नील ने चित्रित किया है।

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

क्या होगा?

a) ३
बी) ५
ग) २
घ) ०

पीज़लर नंबर 6

 data class Recipe (var name: String? = null, var hops: List<Hops> = emptyList() ) data class Hops(var kind: String? = null, var atMinute: Int = 0, var grams: Int = 0) fun beer(build: Recipe.() -> Unit) = Recipe().apply(build) fun Recipe.hops(build: Hops.() -> Unit) { hops += Hops().apply(build) } val recipe = beer { name = ″Simple IPA″ hops { name = ″Cascade″ grams = 100 atMinute = 15 } } 

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

हम पहले, आईपीए बनाते हैं, उबालने के 15 वें मिनट में कैस्केड नामक 100 ग्राम, और फिर इस नुस्खा को प्रिंट करते हैं। हमने क्या किया?

a) रेसिपी (नाम = साधारण IPA, हॉप्स = [हॉप्स (नाम = Cascade, atMinute = 15, gr = 100)]]
b) अवैध अतिक्रमण अपवाद
ग) संकलित नहीं
d) उपरोक्त में से कोई नहीं

पज्लर संख्या 7

 fun f(x: Boolean) { when (x) { x == true -> println(″$x TRUE″) x == false -> println(″$x FALSE″) } } f(true) f(false) 

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

इस मामले में, हमारे पास एक फ़ंक्शन च () है जो एक बूलियन लेता है और सही और गलत के आधार पर कुछ प्रिंट करता है।

क्या होगा?

क) सच्चा सच; झूठी झूठी
ख) सच सच; झूठी बात
ग) सच FALSE; झूठी झूठी
d) उपरोक्त में से कोई नहीं

पाजलर संख्या 8

 abstract class NullSafeLang { abstract val name: String val logo = name[0].toUpperCase() } class Kotlin : NullSafeLang() { override val name = ″Kotlin″ } print(Kotlin().logo) 

कोटलिन को "अशक्त सुरक्षित" भाषा के रूप में विपणन किया गया था। कल्पना करें कि हमारे पास एक सार वर्ग है, इसका कुछ नाम है, साथ ही एक संपत्ति भी है जो इस भाषा का लोगो लौटाती है: नाम का पहला अक्षर, बस मामले में, पूंजीकृत (अचानक इसे प्रारंभिक पूंजी बनाने के लिए भूल गया था)।

चूंकि भाषा शून्य सुरक्षित है, हम नाम बदल देंगे और शायद सही लोगो को प्राप्त करना चाहिए, जो एक अक्षर है। हमें वास्तव में क्या मिलता है?

a) के
बी) NullPointerException
ग) अवैध
घ) संकलित नहीं

पीज़लर नंबर 9

 val result = mutableListOf<() -> Unit>() var i = 0 for (j in 1..3) { i++ result += { print(″$i, $j; ″) } } result.forEach { it() } 

कुछ डरावनी बातों का एक परस्पर अनुवाद है। यदि यह आपको स्काला की याद दिलाता है, तो यह व्यर्थ नहीं है, क्योंकि यह वास्तव में दिखता है। एक सूची मेमना है, हम दो काउंटर लेते हैं - I और j, वेतन वृद्धि और फिर उनके साथ कुछ करते हैं। क्या होगा?

ए) 1 1; 2 2; ३ ३
बी) 1 3; 2 3; ३ ३
ग) 3 1; 3 2; ३ ३
d) उपरोक्त में से कोई नहीं

पज्लर संख्या १०

 fun foo(a:Boolean, b: Boolean) = print(″$a, $b″) val a = 1 val b = 2 val c = 3 val d = 4 foo(c < a, b > d) 

हमारे पास एक फ़ंक्शन फू है (), दो बूलियन लेता है, उन्हें प्रिंट करता है, सब कुछ सरल लगता है। और हमारे पास संख्याओं का एक गुच्छा है, यह देखना बाकी है कि कौन सा आंकड़ा दूसरे से बड़ा है, और यह तय करें कि कौन सा विकल्प सही है।

a) सत्य, सत्य
ख) झूठा, झूठा
ग) अशक्त, अशक्त
घ) संकलित नहीं

चकाचक नंबर 11

 data class Container(val name: String, private val items: List<Int>) : List<Int> by items val (name, items) = Container(″Kotlin″, listOf(1, 2, 3)) println(″Hello $name, $items″) 

कोटलिन में डेलीगेट एक बड़ी विशेषता है। वैसे, आंद्रेई ब्रेज़लव का कहना है कि यह एक ऐसी विशेषता है जिसे वह ख़ुशी से भाषा से हटा देगा, उसे अब यह पसंद नहीं है। अब, शायद, हम यह पता लगाएंगे कि क्यों! और उन्होंने यह भी कहा कि साथी वस्तुएं बदसूरत हैं।

लेकिन डेटा कक्षाएं निश्चित रूप से सुंदर हैं। हमारे पास एक डेटा क्लास कंटेनर है, यह अपने लिए एक नाम और आइटम लेता है। उसी समय, कंटेनर में, हम आइटम के प्रकार को लागू करते हैं, यह सूची है, और हम इसके सभी तरीकों को आइटम में सौंपते हैं।

फिर हम एक और शांत सुविधा का उपयोग करते हैं - विनाश। हम कंटेनर से नाम और आइटम तत्वों को "नष्ट" करते हैं और उन्हें स्क्रीन पर प्रदर्शित करते हैं। सब कुछ सरल और स्पष्ट लगता है। क्या होगा?

क) हैलो कोटलिन, [1, 2, 3]
बी) हैलो कोटलिन, 1
c) हैलो 1, 2
घ) हैलो कोटलीन, २

Pazzler संख्या 12

अगला गूढ़ व्यक्ति बहुत डरावना है। यह एक विनम्र व्यक्ति है जो किसी तरह कोटलिन के साथ जुड़ा हुआ है, इसलिए वह जानता है कि वह क्या लिख ​​रहा है।

 fun <T> Any?.asGeneric() = this as? T 42.asGeneric<Nothing>()!!!! val a = if (true) 87 println(a) 

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

खैर, अगर हम यह सुनिश्चित करना चाहते हैं कि हमने कुछ महत्वपूर्ण किया है, तो हम इसके बजाय कर सकते हैं !!! लिखो !!!!, कोटलिन संकलक आपको ऐसा करने की अनुमति देता है: यदि आप दो विस्मयादिबोधक बिंदु याद कर रहे हैं, तो कम से कम छब्बीस लिखें।

तब हम करते हैं अगर (सच), और फिर मैं खुद कुछ भी नहीं समझता ... चलो जो होता है उसे तुरंत चुनें।

a) 87
बी) कोटलिन
c) क्लासकैस्ट एक्ससेप्शन
घ) संकलित नहीं

Pazzler संख्या 13

हमारे पास एक बहुत ही दिलचस्प विशेषता है। आप निर्भरता इंजेक्शन का उपयोग कर सकते हैं, या आप इसके बिना कर सकते हैं, ऑब्जेक्ट के माध्यम से सिंगललेट बना सकते हैं और अपने प्रोग्राम को ठंडा कर सकते हैं। आपको कोइन, डैगर या कुछ और की आवश्यकता क्यों है? परीक्षण, हालांकि, मुश्किल होगा।

 open class A(val x: Any?) { override fun toString() = javaClass.simpleName } object B : A(C) object C : A(B) println(Bx) println(Cx) 

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

क) अशक्त; अशक्त
बी) सी; अशक्त
c) एक्ससेप्शनइन्सेन्टलाइज़ररूट
घ) संकलित नहीं

Pazzler azz14

संस्करण 1.3 ने कोटलिन में महान नए कोरटाइन्स जारी किए। मैंने लंबे समय से सोचा था कि कोरुटिन के बारे में एक गूढ़ व्यक्ति के साथ कैसे आना चाहिए, ताकि कोई इसे समझ सके। मुझे लगता है कि कुछ लोगों के लिए कोरटाइन के साथ कोई भी कोड एक गूढ़ व्यक्ति है।

1.3 में, कुछ फ़ंक्शन नाम बदल गए जो प्रयोगात्मक एपीआई में 1.2 में थे। उदाहरण के लिए, buildSequence () का नाम बदलकर केवल अनुक्रम () कर दिया गया है। यही है, हम उपज समारोह, अनंत छोरों के साथ उत्कृष्ट अनुक्रम बना सकते हैं, और फिर हम इस क्रम से कुछ पाने की कोशिश कर सकते हैं।

 package coroutines.yieldNoOne val x = sequence { var n = 0 while (true) yield(n++) } println(x.take(3)) 

उन्होंने कॉरआउट के साथ कहा कि सभी शांत आदिम जो अन्य भाषाओं में हैं, जैसे उपज, पुस्तकालय कार्यों के रूप में किया जा सकता है, क्योंकि उपज एक निलंबित कार्य है जिसे बाधित किया जा सकता है।

क्या होगा?

a) [1, 2, 3]
बी) [०, १, २]
ग) अनंत लूप
d) उपरोक्त में से कोई नहीं

Pazzler azz15

इस गूढ़ व्यक्ति को JetBrains के डेवलपर द्वारा भी वश में किया जाता है। ऐसा एक नारकीय कोड है:

 val whatAmI = {->}.fun Function<*>.(){}() println(whatAmI) 

जब मैंने पहली बार उसे देखा, कोटलिनकॉन्फ़ के दौरान, मैं सो नहीं सका, मैंने समझने की कोशिश की कि यह क्या था। कोटलिन में इस तरह के गूढ़ कोड को लिखा जा सकता है, इसलिए अगर किसी को लगता है कि स्कलाज़ डरावना था, तो कोटलिन में भी यह संभव है।

आइए अनुमान लगाते हैं:

a) कोटलिन.उपयोग
बी) कोटलिन
ग) संकलित नहीं
d) उपरोक्त में से कोई नहीं


. , Kotlin — . iOS- , , Kotlin !

Mobius, : Mobius 22-23 . Kotlin — «Coroutining Android Apps» . ( Android, iOS), — , 1 .

: , — 6 .