चुनौती 5 को समायोजित करें: परिवहन डॉक पर प्रस्तुत करें!

9

<< पिछला अगला >>

PPCG समुदाय के लिए धन्यवाद, सांता अपने सभी उपहारों का फिर से निर्माण करने में कामयाब रहा है और विधानसभा लाइन के बाद, प्रस्तुत अब परिवहन डॉक में ले जाने के लिए तैयार हैं!

सांता का प्रत्येक परिवहन डॉक केवल वर्तमान आकारों की एक सीमा रखता है क्योंकि परिवहन स्लीघ एक विशिष्ट आकार (किसी भी लाइटर और यह बेकार होगा, किसी भी भारी और बेपहियों की गाड़ी को लोड को संभालने में सक्षम नहीं होगा) के लिए विशेष हैं। इस प्रकार, आपको उसे अपने उपहार लेने में मदद करने और उन्हें सही परिवहन डॉक में सॉर्ट करने की आवश्यकता है।

चुनौती

एक सूची और परिवहन डॉक श्रेणियों को देखते हुए, सही क्रम में प्रस्तुतियाँ व्यवस्थित करें।

आइए इसे उदाहरण के लिए लें: प्रस्तुत हैं [5, 3, 8, 6, 2, 7]और डॉक पर्वतमाला हैं [[1, 5] and [6, 10]]।

प्रस्तुत करता है 5, 3और 2पहली गोदी और प्रस्तुत 8में जाता है 6, और 7दूसरी गोदी में जाता है। इसे इस प्रकार दिखाया जा सकता है [[5, 3, 2], [8, 6, 7]]। यह सूची इनपुट से क्रमबद्ध होने के करीब होगी, लेकिन stablyइसका अर्थ है कि प्रत्येक डॉक के भीतर, प्रस्तुत करने का क्रम इनपुट के क्रम के समान होना चाहिए (अन्यथा आप पूरी सूची को क्रमबद्ध कर सकते हैं)।

इस मामले के लिए आपका अंतिम आउटपुट [5, 3, 2, 8, 6, 7](एक फ्लैट सूची के रूप में) होगा।

स्वरूपण विनिर्देशों

आपको पूर्णांक की एक फ्लैट सूची और किसी भी उचित प्रारूप में श्रेणियों की सूची के रूप में इनपुट दिया जाएगा (उदाहरण के लिए, उपरोक्त मामले के लिए सीमा के रूप [[1, 5], [6, 10]]में [1, 5, 6, 10], या [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]) दिया जा सकता है । आपका आउटपुट किसी भी उचित प्रारूप में पूर्णांकों की एक फ्लैट सूची होनी चाहिए।

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

नियम

  • स्टैंडर्ड लोफॉल्स लागू होते हैं
  • ये है कोड गोल्फ, इसलिए बाइट्स में सबसे छोटा जवाब जीत जाता है
  • कोई उत्तर स्वीकार नहीं किया जाएगा
  • आप मान सकते हैं कि कोई खाली पर्वतमाला नहीं होगी ( [7, 4]अमान्य होगी क्योंकि श्रेणियां ऊपर जाती हैं)

परीक्षण के मामलों

[1, 2, 3, 4, 5, 6, 7] ; [[1, 3], [4, 7]] => [1, 2, 3, 4, 5, 6, 7]
[1, 2, 3, 4, 5, 6, 7] ; [[4, 7], [1, 3]] => [4, 5, 6, 7, 1, 2, 3]
[7, 3, 5, 4, 6, 1, 2] ; [[1, 3], [4, 5], [6, 7]] => [3, 1, 2, 5, 4, 7, 6]
[4, 7, 6, 3, 5, 2, 1] ; [[1, 4], [5, 7]] => [4, 3, 2, 1, 7, 6, 5]
[1, 1, 3, 3, 6, 4, 7] ; [[1, 4], [6, 7]] => [1, 1, 3, 3, 4, 6, 7]

नोट: मैंने इस चुनौती श्रंखला के लिए Advent of Code से प्रेरणा ली । मेरा इस साइट से कोई जुड़ाव नहीं है

आप यहां पहली चुनौती के 'लिंक्ड' सेक्शन को देखकर श्रृंखला की सभी चुनौतियों की सूची देख सकते हैं ।

code-golf  array-manipulation  sorting 
— HyperNeutrino
स्रोत
हमेशा सिर्फ 2 लंड?
— LiefdeWen
क्या सीमाएं ओवरलैप हो सकती हैं?
— RamenChef
@LiefdeWen तीसरा परीक्षण मामला देखें।
— श्री एक्सकोडर
क्या गोदी जोड़ी हमेशा {छोटी, बड़ी} होगी
— लाइपडेन 15
@RamenChef नहीं ..
— हाइपरनेट्रिनो

जवाबों:

4

जेली , 4 बाइट्स

fЀẎ

इसे ऑनलाइन आज़माएं!

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

— आउटगोल्फ को एरिक करें
स्रोत
याय यही जेली समाधान है जिसकी मुझे उम्मीद थी: DDD
— HyperNeutrino
@ HyperNeutrino Hehe अपेक्षित समाधान सबसे छोटा नहीं है। जिस तरह से 05ab1e का बाहरी उत्पाद काम करता है, उसे देखकर मुझे लगा कि fþFजेली में भी 3 बाइट्स काम करती हैं । श्रेय अदनान को जाता है ।
— श्री Xcoder
@ Mr.Xcoder या तो आप या अदनान को यह पोस्ट करना चाहिए।
— E:१g पर आउटगोलर
@ Mr.Xcoder मैं थोड़ा इंतजार करूंगा और देखूंगा: P लेकिन यह काफी अलग दिखता है, अगर मैं इसे पोस्ट करता हूं, तो मैं एक और उत्तर दूंगा।
— 18
4

गणितज्ञ, 39 बाइट्स

x##&@@Cases[x,#|##&@@Range@##]&@@@#&


मार्टिन से जंगवान मिन -4 बाइट्स से -22 बाइट्स

इसे ऑनलाइन आज़माएं!

— J42161217
स्रोत
आप Rangeकेवल इनपुट के रूप में विस्तारित सीमाओं को ले कर पूरी चीज़ से छुटकारा पा सकते हैं ।
— मार्टिन एंडर
3

अजगर , 5 बाइट्स

s@Rvz

यहाँ कोशिश करो!

अजगर , 10 बाइट्स

s.gx}LkQ1E

यहाँ कोशिश करो!

वे कैसे काम करते हैं

s @ Rvz | पूरा कार्यक्रम।

  आर | सही नक्शा ...
 @ | ... चौराहे का उपयोग करना।
   vz | दूसरे के साथ पहले इनपुट का।
s | एक स्तर से समतल करें।

s.gx} LkQ1E | पूरा कार्यक्रम।

 .जी ई | आइटम को दूसरे इनपुट में समूह द्वारा ...
    } LkQ | पहले इनपुट पर मैप करें, और जांचें कि क्या वर्तमान आइटम सूची में है।
   x 1 | पहले सत्य तत्व का सूचकांक लें।
s | समतल।

रेंज में सभी पूर्णांकों के साथ, पहले डॉक लेता है, और फिर एक नई लाइन पर प्रस्तुत करता है।

— श्री एक्सकोडर
स्रोत
3

05AB1E , 3 बाइट्स

δØ

इसे ऑनलाइन आज़माएं! ( मुझे पता है, -1 बाइट देने के लिए अदनान का धन्यवाद δ)

यह काम किस प्रकार करता है

˜Ã˜ | पूरा कार्यक्रम।

δ | अगले आदेश को डबल-वेक्टराइज़ करें (बाहरी उत्पाद की तरह कुछ)।
 Ã | सूची चौराहा। चूंकि यह एक रंग है, पहला इनपुट स्वचालित रूप से है
     | लापता तर्क को भरने के लिए उपयोग किया जाता है (जहाँ तक मुझे पता है)।
  ˜ | समतल।
— श्री एक्सकोडर
स्रोत
ठीक है, €Ã˜काम करने के लिए प्रतीत नहीं होता है।
— को आउटगॉल्फ को एरिक करें
नहीं, वहाँ नहीं है। BTW कारण €Ã˜विफल हो जाता है क्योंकि Ãदो तर्क लेता है, और €एक तर्क के साथ एक फ़ंक्शन की उम्मीद करता है, इसलिए यह [[]]बदले में लौटता है (मुझे लगता है कि यह एक बग है), इसलिए फिर ˜समतल हो जाएगा, लौट रहा है []। ε, हालांकि, अलग तरह से काम करता है। शीर्ष आइटम के प्रत्येक तत्व के लिए, यह एक नया स्टैक बनाता है और फिर प्रत्येक नए स्टैक के शीर्ष को लौटाता है, इसलिए जब किसी फ़ंक्शन के लिए इसमें पर्याप्त आइटम नहीं होते हैं, तो इसके बजाय एक अंतर्निहित इनपुट लेता है।
— आउटगॉल्फ
मैंने अभी तक इसका परीक्षण नहीं किया है, लेकिन δØआप क्या देख रहे हैं?
— अदनान
@ Mr.Xcoder मुझे नहीं लगता है कि वास्तव में डायडिक मैप पाइथ के पास है, यह बाहरी उत्पाद या कुछ और की तरह व्यवहार करता है।
— आउटगोल्फर
3

रेटिना , 37 36 बाइट्स

O$`(\d+)(?=.*¶(.*)\[.*\b\1\b)
$2
G1`

इसे ऑनलाइन आज़माएं! पहली पंक्ति पर प्रस्तुत सूची और दूसरी पंक्ति पर श्रेणियों की सूची के रूप में इनपुट लेता है; लिंक में वांछित मामलों में परीक्षण मामलों को विभाजित करने के लिए एक हेडर शामिल है। संपादित करें: @MartinEnder के लिए 1 बाइट धन्यवाद सहेजा गया। स्पष्टीकरण: पहला चरण प्रस्तुत से मेल खाता है और मिलान गोदी को पाता है। प्रस्तुत पंक्तियों को लाइन की शुरुआत से स्थानापन्न करके सॉर्ट किया जाता है [, इस प्रकार डॉक द्वारा प्रस्तुत किया जाता है। दूसरा चरण तब डॉक हटाता है।

— नील
स्रोत
2

सूची , 3 बाइट्स

f₱Ẏ

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

च Ẏ ₱ | पूरा कार्यक्रम।

 ₱ | सही तर्क पर नक्शा।
च | सूची चौराहे का उपयोग करना, गिनती गुणा करना।
  Ẏ | कसने (1 स्तर से समतल)।
— श्री एक्सकोडर
स्रोत
1
: डी एनलिस्ट को नहीं भुलाया गया: डी वास्तव में यह थोड़े था, सिर्फ समुदाय द्वारा नहीं, बल्कि मेरे द्वारा :(: P
— HyperNeutrino
2

एपीएल + विन, 29 बाइट्स

(,⍉<\p←n∘.≤∊¯1↑¨⎕)/(×/⍴p)⍴n←⎕

पूर्णांक और श्रेणी दोनों के लिए स्क्रीन इनपुट के लिए संकेत। एक फ्लैट सूची और एक नेस्टेड वेक्टर के रूप में पर्वतमाला के रूप में पूर्णांक, उदाहरण के लिए केस 3:

(1 3) (4 5) (6 7)

स्पष्टीकरण:

(×/⍴p)⍴n←⎕ prompt for screen input of integers and replicate by the number of ranges 

∊¯1↑¨⎕ prompt for screen input of ranges and select the top of each

p←n∘.≤ create a boolean matrix using outer product with less than the top of each range

,⍉<\ identify the first range which each element fits in and ravel into a partition vector

(.....)/.... use the partition vector to select the elements in each range in order
— ग्राहम
स्रोत
2

सी ++, 127 बाइट्स

बिंदु के जोड़े द्वारा दर्शाए गए दो सरणियों के रूप में इनपुट लें [start, end)।

#import<algorithm>
[](int*A,int*x,int*B,int*y){for(;B!=y;B+=2)A=std::stable_partition(A,x,[&](int a){return a>=*B&&a<=B[1];});}

इसे ऑनलाइन आज़माएं!

— कोलेरा सु
स्रोत
ठीक है, C ++ में हर चीज के लिए एक अंतर्निहित है ... या क्या यह है? / यह देखते हुए कि इनपुट पर्वतमाला में 0 नहीं हैं, अशक्त-समाप्त सरणी बी का उपयोग करके कुछ बाइट्स को नीचे करना संभव है, हालांकि इसे धोखा माना जा सकता है। / दुर्भाग्य से [&](int a)->int{a=a>=इसके बजाय [&](int a){return a>=किसी भी बाइट नहीं बचा है। / कम से कम TIO पर #import<algorithm>हो सकता है #import<regex>। मैंने पाया कि इस पृष्ठ में सूचीबद्ध सभी हेडर ("मैनुअल बाइनरी सर्च") के बाद और यह सबसे छोटा है। / इसके अलावा, मेरी ओर से +1।
— user202729
2

जे, 15 बाइट्स

[/:[:I.e.&>"0 1

इनपुट को बाएं तर्क के रूप में और दायरों को सही तर्क के रूप में लेता है। पर्वतमाला पूर्ण श्रेणियों की बॉक्सिंग सूची हैं।

पहली श्रेणी के लिए उदाहरण:

   NB. This produces the range
   (1 2 3 ; 4 5 6 7)
┌─────┬───────┐
│1 2 3│4 5 6 7│
└─────┴───────┘

इसे ऑनलाइन आज़माएं!

व्याख्या

[/:[:I.e.&>”0 1
          >”0 1  Pair each element on the left with each range on the right
       e.        Is the element in the range?
     I.          Indices of ones
[/:              Sort the elements by this array
— गोभी
स्रोत
2

जे , 26 24 बाइट्स

2 बाइट्स कोल के लिए धन्यवाद

[:;]<@#~1=-&1 0"1@[I."1]

यह काम किस प्रकार करता है:

बायां तर्क पर्वतमाला धारण करता है।

-&1 0"1@[ प्रत्येक श्रेणी की निचली सीमा को 1 से घटाता है

I."1] जाँच जिसमें सीमा प्रत्येक वर्तमान में फिट होती है

1= क्या यह सही सीमा में है

]<@#~ उन प्रतियों और बक्सों को प्रस्तुत करता है जो वर्तमान सीमा में हैं

; - रेज़ (अनबॉक्सिंग)

इसे ऑनलाइन आज़माएं!

— गैलेन इवानोव
स्रोत
1
मुझे पूरा यकीन है कि इनपुट के अभिन्न होने के बाद से आप शून्य को नहीं हटा सकते हैं (जैसे कि यह परीक्षण मामले में विफल रहता है (0 4,:_3 _1) f _2 _1 0 1 2)
— कोल
@cole हम्म, मैंने इन मामलों की पूरी तरह से उपेक्षा की थी। मुझे उनके बारे में सोचने की आवश्यकता होगी।
— गैलन इवानोव
1
हाँ, मुझे लगता है कि सबसे आसान तरीका शायद बॉक्स होगा और फिर उखेड़ना होगा। इस तरह 24 बाइट्स।
— कोल
@cole धन्यवाद! यह न केवल छोटा है, बल्कि आसानी से 0.
— गैलन इवानोव
2

आर , 113 48 55 41 बाइट्स

पिछले संस्करण ने ऑब्जेक्ट को सही ढंग से सॉर्ट नहीं किया था जब डॉक बढ़ते क्रम में नहीं थे।

function(P,D)for(d in D)cat(P[P%in%d],"")

इसे ऑनलाइन आज़माएं!

ले जाता है Dपर्वतमाला की वैक्टर की एक सूची के रूप में, यानी, list(4:7,1:3)होगा [[4, 7], [1, 3]]।

संभवत: अनुभवहीन उत्तर मुझे युगों पहले आ जाना चाहिए था; प्रिंट करने के लिए प्रिंट।

— ग्यूसेप
स्रोत
2

जाप , 6 बाइट्स

ñ@VbøX

कोशिश करो

व्याख्या

सरणी U(प्रस्तुत) और 2d-array V(पूर्ण श्रेणी) का अंतर्निहित इनपुट । सॉर्ट ( ñ) एक फ़ंक्शन ( @) के माध्यम से उन्हें पारित करने से प्रस्तुत करता है , जिसमें पहले तत्व ( b) में V( øवर्तमान वर्तमान X) ( ) शामिल हैं।

— झबरा
स्रोत
1

पायथन 2, 97 85 बाइट्स

l,d=input()
k=lambda i,j=0:-~j*(d[j][0]<=i<=d[j][1])or k(i,j+1)
print sorted(l,key=k)

-11 बाइट्स ओव्स से

श्री एक्सकोडर से -1 बाइट

इसे ऑनलाइन आज़माएं!

कुंजी के रूप में एक पुनरावर्ती लंबोदा का उपयोग करके सूची को सॉर्ट करता है। नीचे जल्द ही आ रहा स्पष्टीकरण ।

स्पष्टीकरण:

l,d=input()             # l is the lsit of presents, d is the list of ranges
k=lambda i,j=0:-~j*(d[j][0]<=i<=d[j][1])or k(i,j+1)# recursive lambda to sort with
k=lambda i,j=0:                                    # i is the present
                                                   # j is the index in the list of ranges
               -~j*(d[j][0]<=i<=d[j][1])           # return the index of the list of
                                                   # ranges(plus one) if the present is
                                                   # in the range
                                        or k(i,j+1)# if the present is not in the range,
                                                   # try the next range
print sorted(i,key=k)   # print the list of presents sorted by the lambda
— pizzapants184
स्रोत
1

पॉवरशेल , 37 बाइट्स

param($a,$b)$b|%{$i=$_;$a|?{$_-in$i}}

इसे ऑनलाइन आज़माएं!

$aप्रस्तुत के शाब्दिक सरणी के $bरूप में और सरणियों के एक सरणी के रूप में लेता है , जिनमें से प्रत्येक पूर्ण सीमा (जैसे, के @(1,2,3,4,5)बजाय @(1,5)) हैं। हम फिर से प्रत्येक आइटम पर लूप $bकरते हैं |%{...}। अंदर, हमें $iवर्तमान आइटम होने के लिए एक सहायक स्थापित करने की आवश्यकता है , फिर इसके Where-Objectखिलाफ एक खंड का उपयोग करें$a केवल उन वस्तुओं को बाहर निकालने के लिए-in जो वर्तमान $bसरणी हैं।

उन्हें पाइपलाइन पर छोड़ दिया गया है और आउटपुट निहित है। Write-Outputसरणी तत्वों के बीच एक नई पंक्ति सम्मिलित करने के डिफ़ॉल्ट व्यवहार के बाद से , यही हमें मिलता है। यहाँ एक थोड़ा घुमा हुआ संस्करण है जो -joinएक नई रेखा के बजाय अल्पविराम के माध्यम से एक साथ एड है, बस अंतर दिखाने के लिए।

— AdmBorkBork
स्रोत
1

विंडोज बैच (CMD), 90 79 बाइट्स

set/pX=||exit
set/pY=
for %%n in (%*)do if %X% LEQ %%n if %%n LEQ %Y% %%n
%0 %*

LF एंड-ऑफ-लाइन प्रारूप का उपयोग करें। प्रत्येक अंत-पंक्ति वर्ण को 1 बाइट के रूप में गिना जा सकता है।

कोई TIO (क्योंकि TIO लिनक्स का उपयोग करता है)

कमांड लाइन आर्गुमेंट्स और लिस्ट्स से लिस्ट लें stdin।

उदाहरण के लिए, यदि प्रोग्राम चलाया जाता है (मान लें कि फ़ाइल का नाम है r1.cmd)

r1 7 3 5 4 6 1 2

और stdinइनपुट के साथ

1
3
4
5
6
7

, कार्यक्रम stderrप्रारूप के साथ उत्पादन होगा

'3' is not recognized as an internal or external command,
operable program or batch file.
'1' is not recognized as an internal or external command,
operable program or batch file.
'2' is not recognized as an internal or external command,
operable program or batch file.
'5' is not recognized as an internal or external command,
operable program or batch file.
'4' is not recognized as an internal or external command,
operable program or batch file.
'7' is not recognized as an internal or external command,
operable program or batch file.
'6' is not recognized as an internal or external command,
operable program or batch file.

(आउटपुट अनुक्रम से मेल खाती है 3 1 2 5 4 7 6)

स्पष्टीकरण:

set /p X=       Prompt for variable X (min range)
   ||exit       If failed (end of file), exit - similar to short-circuit of logical OR
set /p Y=       Prompt for variable Y
for %%n in (%*)do     For each number %%n in all command-line arguments
   if %X% LEQ %%n     If X <= n
      if %%n LEQ %Y%  and n <= Y
         %%n          run command named "n", which lead to an error.

%0 %*           Call itself, process other ranges

Ungolfed कोड (इंटरैक्शन सक्षम होने पर यदि trueतर्क 1 के रूप में पास किया जाता है, तो सूची के लिए प्रॉम्प्ट से stdin, gotoस्टैक ओवरफ़्लो से बचने के लिए उपयोग करें - वास्तव में मैंने बस एक स्क्रिप्ट चलाने की कोशिश की है जो 70000 से अधिक बार खुद को कॉल करता है बिना किसी समस्या को देखे, इसलिए मुझे लगता है कि बहुत सुरक्षित होना चाहिए):

@echo off

set INTERACTIVE=%1

if "%INTERACTIVE%" == "true" (
    set rangeMinPrompt=Enter range min: 
    set rangeMaxPrompt=Enter range max: 
    set listPrompt=Enter list: 
) else (
    set rangeMinPrompt=
    set rangeMaxPrompt=
    set listPrompt=
)


set /p list=%listPrompt%

:loop_label

set /p rangeMin=%rangeMinPrompt%&& set /p rangeMax=%rangeMaxPrompt%|| exit /b

for %%n in (%list%) do (
    if %rangeMin% LEQ %%n (
        if %%n LEQ %rangeMax% (
            echo %%n
        )
    )
)

goto :loop_label
— user202729
स्रोत
आप कमांड-लाइन तर्क और उपयोग प्रस्तुत करने की आवश्यकता के द्वारा अधिक बाइट्स बचा सकते हैं (%*)। ऐसा करने के बाद, आप %0 %*प्रत्येक श्रेणी को संसाधित करने के बाद स्क्रिप्ट को पुनरारंभ करने के लिए उपयोग कर सकते हैं । (मैं वास्तव में एक बड़ी बाइट गिनती के साथ समाप्त हुआ क्योंकि मैंने आपके इंटरेक्टिव संस्करण का उपयोग अच्छे स्पर्श के साथ किया &&, exit/bऔर echoमेरे शुरुआती बिंदु के रूप में।)
— नील
@ नील अच्छा, धन्यवाद! मैंने मूल रूप से उपयोग करने की कोशिश की %1लेकिन उद्धरण "अंतरिक्ष को विभाजक के रूप में काम नहीं कर रहे हैं, इसलिए मैंने उपयोग करना समाप्त कर दिया set /p।
— user202729
अरे वाह, वहाँ भी है $~1...
— user202729
1

वोल्फ्राम भाषा (गणितज्ञ) , 34 बाइट्स

r#~SortBy~{#&@@@r~Position~#&}&

इसे ऑनलाइन आज़माएं!

है Functionऑपरेटर।

यह एक अनाम करी फ़ंक्शन है जिसे पहले (विस्तारित) डॉक श्रेणियों की सूची के साथ और फिर प्रस्तुत सूची के साथ कहा जाना चाहिए। उदाहरण के लिए, यदि आप इस कार्य को असाइन करते हैं f:

f[ {{4,5,6,7},{1,2,3}} ][ {1,2,3,4,5,6,7} ]

डॉक पर्वतमाला की सूची में मूल्य के पहले-स्तर की स्थिति के आधार पर प्रस्तुत की गई सूची। SortByसॉर्ट को स्थिर बनाने के लिए हमें फ़ंक्शन को एक सूची में लपेटने की आवश्यकता है ।

— मार्टिन एंडर
स्रोत
1

जूलिया 0.6 , 31 30 बाइट्स

p%d=vcat((∩(p,x)for x=d)...)

इसे ऑनलाइन आज़माएं!

%ऑपरेटर को पुनर्परिभाषित करता है और आदेश को बनाए रखने ∩()वाले डॉक पर सेट चौराहे को मैप करता dहै, पहली अशुद्धता, प्रस्तुत करने की सूची p। परिणामी नेस्टेड सरणी समतल के vcatमाध्यम से कई तर्कों के लिए विस्तारित इनपुट के साथ ...।

संपादित करें, -1 बाइट: के बजाय समझ की सूची map()।

— Lukes
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.