होलीजस 2019: सेमरश से भागना (भाग 1)

सेंट पीटर्सबर्ग में 24-25 मई को आयोजित होलीजेड जावास्क्रिप्ट डेवलपर्स के लिए नियमित सम्मेलन में, हमारी कंपनी के बूथ ने सभी को नए कार्यों की पेशकश की। इस बार उनमें से 3 थे! बदले में टास्क दिए गए थे, और प्रत्येक बाद के समाधान के लिए प्रतीक चिन्ह (JS Brave> JS Adept> JS Master) पर भरोसा किया गया था, जो रुकने के लिए नहीं एक अच्छी प्रेरणा के रूप में कार्य करता था। कुल मिलाकर, हमने लगभग 900 उत्तर एकत्र किए हैं और सबसे लोकप्रिय और अद्वितीय समाधानों के विश्लेषण को साझा करने की जल्दी में हैं।

प्रस्तावित परीक्षण भाषा की बुनियादी "सुविधाओं" की बहादुरी और समझ से उम्मीद करते हैं, और ECMAScript 2019 की नई विशेषताओं के बारे में जागरूकता (वास्तव में, बाद आवश्यक नहीं है)। यह महत्वपूर्ण है कि ये कार्य साक्षात्कार के लिए नहीं हैं, व्यावहारिक नहीं हैं, और केवल मजाक करने के उद्देश्य से सोचा जाता है।

कार्य 1 ~ उलटी गिनती अभिव्यक्ति

क्या भाव लौटाएगा? किसी भी एक वर्ण को पुनर्व्यवस्थित करें

1. अभिव्यक्ति 2 लौट आए
2. अभिव्यक्ति 1 लौट आया

+(_ => [,,~1])().length 

अतिरिक्त रूप से : क्या क्रमपरिवर्तन द्वारा 0 प्राप्त करना संभव है?

क्या भाव लौटाएगा?

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

अभिव्यक्ति 2 लौटती है

एक त्वरित फिक्स लौटे सरणी में तत्वों की संख्या को कम करने के लिए लगता है। ऐसा करने के लिए, बस एक अल्पविराम बाहर फेंकें:

 [,~1].length // 2 

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

यदि कोई तत्व किसी सरणी के अंत में बनाया गया है, तो वह तत्व एरे की लंबाई में योगदान नहीं करता है।

अर्थात्, यदि खाली तत्व सरणी के अंत में है, तो इसे अनदेखा कर दिया जाता है:

 [,10,] // [empty, 10] 

इस प्रकार, सही अभिव्यक्ति इस तरह दिखाई देती है:

 +(_ => [,~1,])().length // 2 

क्या इस अल्पविराम से छुटकारा पाने का एक और विकल्प है? या पर चलाई।

अभिव्यक्ति 1 लौटती है

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

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

किसी फ़ंक्शन से लंबाई के लिए , सरणी से नहीं, आपको इसे कोष्ठक के माध्यम से कॉल करने से रोकने की आवश्यकता है। यह स्पष्ट हो जाता है कि इनमें से एक कोष्ठक क्रमचय के लिए एक दावेदार है। और कुछ विकल्प दिमाग में आते हैं:

 +((_ => [,,~1])).length // 1 +(_ => ([,,~1])).length // 1 

शायद कुछ और भी है? या अगले स्तर पर।

अभिव्यक्ति 0 लौटती है

अतिरिक्त कार्य में, क्रमपरिवर्तन की संख्या सीमित नहीं है। लेकिन हम न्यूनतम इशारे करके इसे पूरा करने की कोशिश कर सकते हैं।

फ़ंक्शन ऑब्जेक्ट से लंबाई के साथ पिछले अनुभव को विकसित करना, आप जल्दी से एक समाधान पर आ सकते हैं:

 +(() => [,_,~1]).length // 0 

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

ठीक है, लेकिन क्या हमारे तर्क में इसके अलावा (+) और बिटवाइज़ NOT (~) ऑपरेटरों की अनदेखी को रोकने का समय हो सकता है? ऐसा लगता है कि इस समस्या में अंकगणित हमारे हाथों में खेल सकता है। शुरुआत में फ़्लिपिंग से बचने के लिए, यहाँ मूल अभिव्यक्ति है:

 +(_ => [,,~1])().length 

शुरू करने के लिए, हम ~ 1 की गणना करते हैं। X का बिट वाइज नहीं लौटेगा - (x + 1) । यानी ~ 1 = -2 । और हमारे पास अभिव्यक्ति में एक अतिरिक्त ऑपरेटर भी है, जो कि जैसा था, संकेत देता है कि कहीं और आपको 2 और खोजने की आवश्यकता है और सब कुछ काम करेगा।

सबसे हाल ही में, हमें याद है कि इसके आकार पर एक सरणी में अंतिम खाली तत्व के "गैर-प्रभाव" को याद किया गया है, जिसका अर्थ है कि हमारा ड्यूस कहीं न कहीं है:

 [,,].length // 2 

और यह सब बहुत सफलतापूर्वक जुड़ता है: हमें सरणी ~ 1 से तत्व मिलता है, इसकी लंबाई 2 तक कम हो जाती है, और इसे अभिव्यक्ति की शुरुआत के अलावा हमारे लिए पहले ऑपरेंड के रूप में जोड़ते हैं:

 ~1+(_ => [,,])().length // 0 

इस प्रकार, हमने पहले से ही दो क्रमपरिवर्तन में लक्ष्य प्राप्त कर लिया है!

लेकिन क्या होगा अगर यह एकमात्र विकल्प नहीं है? थोड़ा ड्रम रोल ...

 +(_ => [,,~1.])(),length // 0 

इसमें दो क्रमपरिवर्तन की भी आवश्यकता होती है: एक के बाद एक बिंदु (यह संभव है, क्योंकि संख्यात्मक प्रकार केवल संख्या है ) और लंबाई से पहले आने वाला है । यह बकवास लगता है, लेकिन "कभी-कभी" काम करता है। कभी-कभी क्यों?

इस मामले में, अल्पविराम ऑपरेटर के माध्यम से अभिव्यक्ति को दो अभिव्यक्तियों में विभाजित किया गया है और परिणाम दूसरे की गणना मूल्य होगा। लेकिन दूसरी अभिव्यक्ति सिर्फ लंबाई है ! तथ्य यह है कि यहां हम एक वैश्विक संदर्भ में एक चर के मूल्य तक पहुंच रहे हैं। यदि रनटाइम ब्राउज़र है, तो window.length । और विंडो ऑब्जेक्ट की लंबाई संपत्ति है जो पृष्ठ पर फ़्रेम की संख्या लौटाती है। यदि हमारा दस्तावेज़ खाली है, तो लंबाई 0. वापस हो जाएगी। हां, एक धारणा के साथ एक विकल्प ... इसलिए, हमें पिछले एक पर ध्यान दें।

और यहां कुछ और दिलचस्प विकल्प खोजे गए हैं (पहले से ही एक अलग संख्या में क्रमपरिवर्तन):

 (_ => [,,].length+~1)() // 0 +(~([,,].len_gth) >= 1) // 0 ~(_ => 1)()+[,,].length // 0 ~(_ => 1)().length,+[,] // 0 ~[,,]+(_ => 1()).length // 0 

कोई टिप्पणी नहीं कर रहे हैं। क्या किसी को कुछ और भी मजेदार लगता है?

प्रेरणा

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

एवल कॉम्बिनेटरिक्स

सभी संभावित उत्तरों पर विचार नहीं किया गया था, लेकिन कुछ भी याद नहीं करने के लिए, हम वास्तविक जावास्क्रिप्ट की ओर मुड़ते हैं! यदि उन्हें स्वयं खोजने की कोशिश करना दिलचस्प है, तो ऊपर पर्याप्त सुझाव दिए गए थे, और फिर आगे नहीं पढ़ना बेहतर है।



इसलिए, हमारे पास 23 वर्णों की एक अभिव्यक्ति है, जिसके स्ट्रिंग रिकॉर्ड में हम क्रमपरिवर्तन करेंगे। कुल मिलाकर, हमें अभिव्यक्ति के मूल रिकॉर्ड में n * (n - 1) = 506 क्रमांकन करने की आवश्यकता है ताकि सभी वेरिएंट को एक अनुमत प्रतीक के साथ प्राप्त किया जा सके (जैसा कि समस्या 1 और 2 की शर्तों के अनुसार आवश्यक है)।

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

 const combine = (expr, cond) => { let res = {}; let indices = [...Array(expr.length).keys()]; indices.forEach(i => indices.forEach(j => { if (i !== j) { let perm = replace(expr, i, j); try { let val = eval(perm); if (cond(val)) { (res[val] = res[val] || []).push(perm); } } catch (e) { /* do nothing */ } } })); return res; } 

जहाँ अभिव्यक्ति के उत्तीर्ण स्ट्रिंग से प्रतिस्थापित फ़ंक्शन, i से स्थिति j में चरित्र को पुनर्व्यवस्थित करने के साथ एक नया स्ट्रिंग लौटाता है। और अब, बहुत डर के बिना, हम करेंगे:

 console.dir(combine('+(_ => [,,~1])().length', val => typeof val === 'number' && !isNaN(val))); 

नतीजतन, हमें समाधान के सेट मिले:

 { "1": [ "+(_ => [,,~1]()).length", "+((_ => [,,~1])).length", "+(_ =>( [,,~1])).length", "+(_ => ([,,~1])).length" ], "2": [ "+(_ => [,~1,])().length" ] "3": [/* ... */] "-4": [/* ... */] } 

3 और -4 के समाधान हमारे लिए रुचि नहीं रखते हैं, दो के लिए हमने एकमात्र समाधान पाया, और यूनिट के लिए [, ~ 1] () के साथ एक दिलचस्प नया मामला है। TypeError क्यों नहीं : bla-bla कोई फंक्शन नहीं है ? और सब कुछ सरल है: इस अभिव्यक्ति में वाक्यविन्यास पार्सर के लिए कोई त्रुटि नहीं है, और रनटाइम में यह बस निष्पादित नहीं करता है, क्योंकि फ़ंक्शन को नहीं कहा जाता है।

जैसा कि आप देख सकते हैं, एक क्रमचय में शून्य के लिए समस्या को हल करना असंभव है। क्या हम दो में कोशिश कर सकते हैं? इस तरह की एक विस्तृत खोज के द्वारा समस्या का समाधान, इस मामले में हमारे पास स्ट्रिंग की लंबाई की जटिलता हे (n ^ 4) होगी और "मूल्यांकन" इतनी बार पीछा और दंडित किया जाएगा, लेकिन जिज्ञासा प्रबल होती है। दिए गए कंबाइन फ़ंक्शन को स्वतंत्र रूप से परिष्कृत करना या एक बेहतर गणना लिखना मुश्किल नहीं है जो किसी विशेष अभिव्यक्ति की विशेषताओं को ध्यान में रखता है।

 console.dir(combine2('+(_ => [,,~1])().length', val => val === 0)); 

अंत में, शून्य के लिए समाधानों का समूह होगा:

 { "0": [ "+(_ => [,~.1])(),length", "+(_ => [,~1.])(),length", "~1+(_ => [,,])().length" ] } 

यह उत्सुक है कि तर्क में हमने यूनिट के बाद डॉट को फिर से व्यवस्थित किया, लेकिन यह भूल गए कि यूनिट के सामने डॉट भी संभव है: शून्य से हटाए गए के साथ रिकॉर्ड 0.1 ।

यदि आप प्रत्येक में दो वर्णों के सभी संभव क्रमांकन करते हैं, तो आप पा सकते हैं कि 3 से लेकर 4 तक के मानों के लिए बहुत सारे उत्तर हैं:

 { "3": 198, "2": 35, "1": 150, "0": 3, "-1": 129, "-2": 118, "-3": 15, "-4": 64 } 

इस प्रकार, दो क्रमपरिवर्तन पर उलटी गिनती अभिव्यक्ति समाधान पथ एक पर 3 से 0 तक प्रस्तावित पथ से अधिक लंबा हो सकता है।

यह होल्जस 2019 में हमारे कार्यों के विश्लेषण का पहला हिस्सा था, और जल्द ही दूसरा दिखाई देना चाहिए, जहां हम दूसरे और तीसरे परीक्षणों के समाधान पर विचार करेंगे। हम संपर्क में रहेंगे!