सूची और सरणियाँ, भाग द्वारा भाग

Question

इस चुनौती में, आपको चार अलग-अलग लेकिन कुछ संबंधित कार्य मिलेंगे जिन्हें एक विशिष्ट तरीके से हल किया जाना चाहिए। सबसे पहले, मैं कार्यों की व्याख्या करूँगा, फिर एक स्पष्टीकरण का अनुसरण करता है कि आपको इसे कैसे हल करना चाहिए।

सभी चार कार्यों के लिए आपका कोड इनपुट के रूप में दो सकारात्मक पूर्णांक लेना चाहिए:, n,mजहां n<m। सभी कार्यों को एक ही भाषा में हल किया जाना चाहिए। मेट्रिसेस का ओरिएंटेशन वैकल्पिक है (n-by-m की व्याख्या "एन रो, एम कॉलम", या "एन कॉलम, एम रो") के रूप में की जा सकती है।

कार्य 1:

तत्वों से मिलकर एक वेक्टर / सूची बनाएं (और आउटपुट / प्रिंट करें) n, n+1 ... m-1, m:। इसलिए, n=4, m=9आपको आउटपुट चाहिए 4,5,6,7,8,9:।

कार्य 2:

एक मैट्रिक्स / सरणी / सूचियों की सूची (या आउटपुट / प्रिंट) बनाएं (या समतुल्य) इस तरह देख रहे हैं:

n,   n+1, ... m-1, m
n+1, n+2, ... m-1, m+1
...
n+m, n+m+1, ... 2*m-1, 2*m

आपके लिए n=4, m=9आउटपुट होना चाहिए:

4, 5, 6, 7, 8, 9
5, 6, 7, 8, 9, 10
...
13, 14, 15, 16, 17, 18

कार्य 3:

बनाएँ (और आउटपुट / प्रिंट) एक एन-बाय-एम गुणा तालिका (किसी भी उपयुक्त प्रारूप पर)। इसके लिए उदाहरण n=4, m=9:

1   2   3  4
2   4   6  8
3   6   9  12
4   8  12  16
5  10  15  20
6  12  18  24
7  14  21  28
8  16  24  32
9  18  27  36

कार्य 4:

डुप्लिकेट मानों को रखते हुए, कार्य 3 से गुणन तालिका में तत्वों से मिलकर वेक्टर / सूची को प्रिंट करें, आरोही क्रम में क्रमबद्ध करें। इसके लिए n=4, m=9, आपको आउटपुट: चाहिए 1, 2, 2, 3, 3, 4, 4, 4, 5, 6, 6, 6, 7, 8, 8, 8, 9, 9, 10, 12, 12, 12, 14, 15, 16, 16, 18, 18, 20, 21, 24, 24, 27, 28, 32, 36।

चुनौती:

अब, उपरोक्त सभी कार्य काफी तुच्छ हैं। यहां वास्तविक चुनौती यह है कि टास्क 2 के लिए कोड को टास्क 1 के लिए कोड से शुरू होना चाहिए, टास्क 3 के लिए कोड को टास्क 2 के लिए कोड से शुरू होना चाहिए और टास्क 4 के लिए कोड से टास्क 3 के लिए शुरू करना होगा।

इसे और अधिक स्पष्ट करने के लिए:

मान लीजिए कि टास्क 1 का कोड है (ऑक्टेव में काम करता है):

@(n,m)(n:m)

तब टास्क 2 के लिए आपका कोड (ऑक्टेव में काम करता है) हो सकता है:

@(n,m)(n:m)+(0:m)'

टास्क 3 के लिए कोड होना चाहिए (ऑक्टेव में काम नहीं करता):

@(n,m)(n:m)+(0:m)'"Code_for_task_3"

और अंत में, टास्क 4 के लिए कोड होना चाहिए (ऑक्टेव में काम नहीं करता है):

@(n,m)(n:m)+(0:m)'"Code_for_task_3""Code_for_task_4"

---

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा में टास्क 4 के लिए सबसे छोटे कोड के साथ सबमिशन जीत जाता है। हमेशा की तरह: स्पष्टीकरण अत्यधिक प्रोत्साहित किया जाता है।

Comments

बस स्पष्ट होने के लिए, मैं यह अनुमान लगाने जा रहा हूं कि यह चुनौती की भावना के खिलाफ है, लेकिन क्या एसटीडीआरआर के साथ अगले कार्य के कोड को पुनर्निर्देशित करना शुरू करने की अनुमति है >2;ताकि पिछले कार्य के कोड को अनिवार्य रूप से नो-ऑप प्रदान किया जाए?

— AdmBorkBork

@AdmBorkBork, PPCG पर "चुनौती की भावना" जैसी कोई चीज नहीं है: पी हां, यह ठीक है ।

— स्टिव ग्रिफ़िन

क्या गुणन तालिका को अच्छी तरह से गद्देदार करने की आवश्यकता है?

— हाइपरनेत्रिनो

@ हिपरनेत्रो, नहीं।

— स्टिव ग्रिफिन

जब आप "सकारात्मक पूर्णांक" कहते हैं, तो क्या आपका मतलब है 0<n<mया 0<=n<m?

— मूल्य इंक

Answer 1

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

कार्य 1

r

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

टास्क २

r+þ0r$}

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

टास्क 3

r+þ0r$}
×þ

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

टास्क 4

r+þ0r$}
×þFṢ

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

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

कार्य 1

rहै dyadic रेंज परमाणु और वास्तव में क्या काम के लिए पूछता है।

टास्क २

एक डाइएडिक श्रृंखला जो तीन डायडिक लिंक से शुरू होती है, एक कांटा है ; सबसे बाहरी लिंक का पहले मूल्यांकन किया जाता है, फिर मध्य लिंक को परिणामों के साथ दोनों पक्षों के तर्क के रूप में कहा जाता है।

• rपहले जैसा व्यवहार करता है, [n,…, m] पैदावार ।

• 0r$} एक क्विकलिंक (या क्विकक्विकलिंक है, यदि आप करेंगे)।

  क्विक $(मोनाडिच चेन) लिंक 0(उपज 0 ) और r(डाइएडिक रेंज) का उपभोग करता है और उन्हें एक मॉनेडिक श्रृंखला में बदल देता है। जब तर्क k के साथ कहा जाता है , तो यह [0, ..., k] का उत्पादन करेगा ।

  क्विक }(दायां तर्क) क्विकलिंक द्वारा बनाया गया लेता है $और इसे एक डाइएडिक लिंक में बदल देता है, जो सही तर्क के 0r$साथ कहता 0r$}है।

  0r$}बाएं तर्क n और दाएं तर्क m के साथ बुलाया जाएगा , इसलिए 0r$तर्क m और पैदावार से संबद्ध है [0,…, m] ।

• +þएक और क्विकलिंक है। þ(तालिका) +प्रत्येक तत्व के लिए उसके बाएं तर्क में और उसके सही तर्क में किसी भी तत्व को कॉल करेगा , प्रत्येक सही तर्क के लिए परिणामों को एक पंक्ति में समूहित करेगा।

  +þवांछित तालिका की उपज, बाएं तर्क [n,…, m] और सही तर्क [0,…, m] के साथ कहा जाएगा ।

टास्क 3

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

पहले की तरह, þ(तालिका) ×प्रत्येक तत्व के लिए उसके बाएं तर्क में और उसके सही तर्क में किसी भी तत्व को बुलाएगा , प्रत्येक सही तर्क के लिए परिणामों को एक पंक्ति में समूहित करेगा।

चूंकि दोनों तर्क ×þपूर्णांक हैं, इसलिए þउन्हें श्रेणियों में तब्दील किया जाता है, तर्कों को n और m में बदलकर [1,…, n] और [1,…, m] ।

टास्क 4

×þपहले की तरह काम करता है। निम्नलिखित लिंक विवादास्पद हैं , जिससे उन्हें सबसे ऊपर रखा जाता है , अर्थात, उन्हें पिछले वाले के ऊपर लगाया जाता है।

निष्पादित करने के बाद ×þ, Fपरिणामी 2D सरणी को समतल करता है, और Ṣपरिणामी 1D सरणी को सॉर्ट करता है।

Answer 2

05AB1E , 18 17 बाइट्स

कार्य 1

Ÿ

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

टास्क २

Ÿ²FD>})

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

टास्क 3

Ÿ²FD>})v¹LN*})¦

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

टास्क 4

Ÿ²FD>})v¹LN*})¦˜{

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

स्पष्टीकरण

कार्य 1

Ÿ     # range[n ... m]

टास्क २

Ÿ        # range[n ... m]
 ²F      # m times do:
   D     # duplicate
    >    # increment
     }   # end loop
      )  # wrap in list

टास्क 3

v          # for each list in result of Task 2 do
 ¹L        # push range[1 ... n]
   N*      # multiply by index
     }     # end loop
      )    # wrap in list
       ¦   # discard first element

टास्क 4

˜          # flatten the result from Task 3
 {         # sort

Answer 3

MATL , 18 17 बाइट्स

कार्य 1

&:

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

टास्क २

&:O2G:h!+

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

टास्क 3

&:O2G:h!+:7M!*

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

टास्क 4

&:O2G:h!+:7M!*1eS

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

व्याख्या

कार्य 1

&:    % Binary range [n n+1 ... m] from implicit inputs n, m

टास्क २

      % ... Stack contains [n n+1 ... m]
O     % Push 0
2G    % Push second input, m
:     % Unary range: gives [1 2 ... m]
h     % Concatenate horizontally: gives [0 1 2 ... m]
!     % Transpose into a column vector
+     % Add with broadcast

टास्क 3

      % ... Stack contains matrix from task 2
:     % Unary range. For matrix input it uses its (1,1) entry. So this gives [1 2 ... n]
7M    % Push [1 2 ... m] again
!     % Transpose into a column vector
*     % Multiply with broadcast

टास्क 4

      % ... Stack contains matrix from task 3
1e    % Linearize into a row vector
S     % Sort

Answer 4

मैथेमेटिका, 84 77 बाइट्स

संपादित करें: 7 बाइट बचाने के लिए मार्टिन एंडर का धन्यवाद।

कार्य 1:

{n,m}n~Range~m

Functionतर्कों के साथ शुद्ध nऔर mजो आउटपुट n~Range~m, के infix रूप Range[n,m]।

कार्य 2:

{n,m}n~Range~m~Table~(m+1)//0~Range~m+#&

n~Range~m~Table~(m+1)m+1पंक्तियों के साथ एक 2 डी सरणी बनाता है , जहां प्रत्येक पंक्ति पिछले कार्य का आउटपुट है। फिर //0~Range~m+#&समारोह के पोस्टफ़िक्स अनुप्रयोग है 0~Range~m+#&जो प्रभावी रूप से कहते हैं 0, पहली पंक्ति के लिए 1दूसरी पंक्ति के लिए, और इतने पर करने के लिए mके लिए m+1मई के पंक्ति।

कार्य 3:

{n,m}n~Range~m~Table~(m+1)//0~Range~m+#&//1##&~Array~{n,m}&

यह 1##&~Array~{n,m}&पिछले कार्य के आउटपुट में निरंतर कार्य करता है।

कार्य 4:

{n,m}n~Range~m~Table~(m+1)//0~Range~m+#&//1##&~Array~{n,m}&//Flatten//Sort

Flattens और Sorts गुणा तालिका।

Answer 5

पायथन, 183 बाइट्स

टास्क 1, 29 बाइट्स

r=range
a=lambda n,m:r(n,m+1)

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

टास्क 2, 84 बाइट्स

r=range
a=lambda n,m:r(n,m+1)
s=lambda n,m:[[w+i for w in r(n,m)] for i in a(0,m+1)]

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

टास्क 3, 137 बाइट्स

r=range
a=lambda n,m:r(n,m+1)
s=lambda n,m:[[w+i for w in r(n,m)] for i in a(0,m+1)]
d=lambda n,m:[[w*i for w in a(1,n)] for i in a(1,m)]

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

टास्क 4, 183 167 बाइट्स

r=range
a=lambda n,m:r(n,m+1)
s=lambda n,m:[[w+i for w in r(n,m)] for i in a(0,m+1)]
d=lambda n,m:[[w*i for w in a(1,n)] for i in a(1,m)]
f=lambda(z):sorted(sum(z,[]))

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

स्पष्टीकरण:

कार्य 1:

सरल पर्याप्त है, यह एक उत्पन्न nकरने के लिए mका उपयोग कर सूची अजगर के अंतर्निहित rangeकार्य करते हैं।

कार्य 2:

हर नंबर के लिए 0करने के लिए m+1, इसमें से एक सूची के प्रत्येक आइटम के लिए उस नंबर कहते हैं nकरने के लिए m।

कार्य 3:

से प्रत्येक संख्या के 1लिए m, यह उस संख्या को एक सूची से प्रत्येक संख्या में गुणा करता 1है n।

कार्य 4:

यह पायथन के अंतर्निहित sortedफ़ंक्शन का उपयोग करता है जो एक सूची को कम से कम सबसे बड़ी से अलग करता है। फ़ंक्शन में सूची बोध का उपयोग सूची को समतल करने के लिए किया जाता है। यह कार्य 3 द्वारा दी गई सूची के प्रत्येक आइटम में प्रत्येक आइटम की एक सूची बनाता है।

• @Math_junkie को बहुत सारे बाइट्स धन्यवाद से बचाया।
• सहेजे गए 16 बाइट्स @ThisGuy की बदौलत

@Math_junkie को बहुत सारे बाइट्स धन्यवाद से बचाया।

Comments

क्या आप अनाम फ़ंक्शंस का उपयोग नहीं कर सकते हैं या लैम्बडा वास्तव में छोटे नहीं हैं? (मेरी गिनती से ऐसा लगता है कि वे हैं)

— कोल

क्या यह आम तौर पर पायथन के लिए स्वीकार्य है? उदाहरण के लिए, कार्य 2 के लिए कोड, इनपुट और आउटपुट के साथ एक पूर्ण कार्यक्रम नहीं है, और यह फ़ंक्शन या फ़ंक्शन की परिभाषा भी नहीं है।

— ngenisis

@ क्या मुझे गैर-अनाम कार्यों का उपयोग करना था ताकि मैं बाद के कोड में उनका उपयोग कर सकूं।

— कॉमरेड स्पार्कलपनी

@ngenisis मुझे लगता है कि यह ठीक है, क्योंकि ओपी ने कहा कि टास्क 2 के लिए कोड को टास्क 1 के लिए कोड से शुरू होना चाहिए, और टास्क 2 के लिए कोड def s(n,m):return [[w+i for w in r(n,m)] for i in a(0,m+1)], एक पूर्ण फ़ंक्शन है जब टास्क 1 के लिए कोड परिभाषित किया गया है।

— कॉमरेड स्पार्कलपनी

आप अपनी a=lambda n,m:...प्रत्येक फ़ंक्शन परिभाषा के लिए कुछ ऐसा कर सकते हैं । बेनामी फ़ंक्शन हमेशा अजगर में कम होते हैं

— गणित नशेड़ी

Answer 6

PHP 7, 200 बाइट्स

पिछले आउटपुट को साफ़ करने के लिए आउटपुट बफ़र का उपयोग करता है।

कार्य 1

[,$n,$m]=$argv;ob_start();eval($s='echo join(" ",$v?:range($n+$i,$m+$i)),"
";');

$sबाद में पुन: उपयोग करने के लिए कोड सहेजता है । $vचर पिछले कार्य के लिए है।

टास्क २

[,$n,$m]=$argv;ob_start();eval($s='echo join(" ",$v?:range($n+$i,$m+$i)),"
";');for(;++$i<=$m;)eval($s);

शेष लाइनों को प्रिंट करता है।

टास्क 3

[,$n,$m]=$argv;ob_start();eval($s='echo join(" ",$v?:range($n+$i,$m+$i)),"
";');for(;++$i<=$m;)eval($s);for(($c=ob_clean)();++$j<=$m;print"
")for(;++$$j<=$n;sort($v))echo$v[]=$j*$$j,' ';

आउटपुट बफ़र को साफ़ करता है और संख्याओं को सहेजते हुए गुणन तालिका को प्रिंट करता है $v।

टास्क 4

[,$n,$m]=$argv;ob_start();eval($s='echo join(" ",$v?:range($n+$i,$m+$i)),"
";');for(;++$i<=$m;)eval($s);for(($c=ob_clean)();++$j<=$m;print"
")for(;++$$j<=$n;sort($v))echo$v[]=$j*$$j,' ';$c();eval($s);

आउटपुट बफ़र को फिर से साफ़ करता है और प्रिंट करता है $v।

Answer 7

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

कार्य 1

param($n,$m)$n..$m

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

..निर्मित रेंज ऑपरेटर का उपयोग करता है । निहित प्रभाव के लिए डिफ़ॉल्ट व्यवहार Write-Outputतत्वों के बीच एक नई रेखा सम्मिलित करता है, इसीलिए आउटपुट के रूप में नई रेखा अलग दिखाई देती है।

---

टास्क २

param($n,$m)$n..$m>2;0..$m|%{$i=$_;($n..$m|%{$_+$i})-join','}

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

एसटीडीआरआर के साथ पहले कार्य को पूरा करता है >2;, फिर से लूप 0करता है $m, प्रत्येक पुनरावृति सेटिंग $iसे पहले से लूपिंग को फिर से लूप $nकरने $mऔर प्रत्येक संख्या को बढ़ाने के लिए $i। वे -joinकॉमा के साथ एक साथ एड होते हैं , अन्यथा यह एक अस्पष्ट विशाल लंबे एक-तत्व-प्रति-पंक्ति आउटपुट होगा।

---

टास्क 3

param($n,$m)$n..$m>2;0..$m|%{$i=$_;($n..$m|%{$_+$i})-join','}>2;(1..$m|%{$i=$_;(1..$n|%{$_*$i})-join' '})

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

>2;पिछले STDERR को डंप करने के लिए समान चीज़ । फिर हम बस डबल पाश से 1करने के लिए $mतो 1करने के लिए $n, सहायक की स्थापना $iके रास्ते, गुणा मूल्यों, और -joinएक स्थान के साथ यह सारणीबद्ध बनाने के लिए। इनकैप्सुलेटिंग परेंस पर ध्यान दें - वे अगले कार्य पर आएंगे - लेकिन यहाँ वे यह सुनिश्चित करते हैं कि आउटपुट को पाइपलाइन पर रखा जाए (जो पहले से ही ऐसा होगा, इसलिए वे बेमानी हैं)।

---

टास्क 4

param($n,$m)$n..$m>2;0..$m|%{$i=$_;($n..$m|%{$_+$i})-join','}>2;(1..$m|%{$i=$_;(1..$n|%{$_*$i})-join' '})-split' '|%{+$_}|sort

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

अहा! अंत में कुछ अतिरेक। चूँकि पिछले कार्य में पार्न्स हैं, हम -splitबिना किसी चिंता के व्हाट्सएप पर एक-एक कर सभी को एक पूर्णांक तक ले जा सकते हैं |%{+$_}, और फिर |sort। आउटपुट फिर से अलग हो गया है।

---

मुझे लगता है कि कार्यों के बीच अतिरेक को बेहतर तरीके से लाभ उठाने के कुछ तरीके हैं - फिर भी इसे कुछ गोल्फिंग।

Answer 8

ES2016-ish, 401 384 वर्ण

यहाँ पहली कोशिश है। मुझे यकीन है कि यह थोड़ा सा गाढ़ा हो सकता है, लेकिन यह बहुत कम है। तीर कार्य FTW! (वे निहितार्थ विवरणों से प्यार करें।) टेम्प्लेट स्ट्रिंग्स के साथ नए और बेहतर!

कार्य 1

var a=Array,l=console.log,f=(n,m)=>a.from(a(1+m-n),(w,i)=>n+i),z=(n,m)=>l(f(n,m).join`, `)

z(n,m)लॉग आउटपुट के लिए कॉल करें । (मैं बाद में गोल्फ के लिए कंसोल.लॉग अलियासिंग कर रहा हूं।)

टास्क २

दूसरी कविता ... पहले पर फैलती है।

var a=Array,l=console.log,f=(n,m)=>a.from(a(1+m-n),(w,i)=>n+i),z=(n,m)=>l(f(n,m).join`, `),p,o,g=(n,m)=>{p=n,o=m;return [...a(m+1).keys()].map((d)=>f(d+p,d+o))},y=(n,m)=>l(g(n,m).join`\n`

अब बुलाओ y(n,m)। सुंदर, नहीं?

टास्क 3

मौजूदा कार्यक्षमता के अधिकांश को बायपास करना होगा <sadface /> ।

var a=Array,l=console.log,f=(n,m)=>a.from(a(1+m-n),(w,i)=>n+i),z=(n,m)=>l(f(n,m).join`, `),p,o,g=(n,m)=>{p=n,o=m;return [...a(m+1).keys()].map((d)=>f(d+p,d+o))},y=(n,m)=>l(g(n,m).join`\n`,h=(n,m)=>[...a(m).keys()].map((d)=>(d+1)*n).join`\t`,i=(n,m)=>[...a(n).keys()].map((d)=>h((d+1),m)),v=(n,m)=>i(n,m).join`\n`

अब विधि का नाम है v । उसी तरह बुलाओ।

टास्क 4

और अब हम फिर से उपयोग कर सकते हैं।

var a=Array,l=console.log,f=(n,m)=>a.from(a(1+m-n),(w,i)=>n+i),z=(n,m)=>l(f(n,m).join`, `),p,o,g=(n,m)=>{p=n,o=m;return [...a(m+1).keys()].map((d)=>f(d+p,d+o))},y=(n,m)=>l(g(n,m).join`\n`,h=(n,m)=>[...a(m).keys()].map((d)=>(d+1)*n).join`\t`,i=(n,m)=>[...a(n).keys()].map((d)=>h((d+1),m)),v=(n,m)=>i(n,m).join`\n`,t=(n,m)=>l(v(n,m).match(/\d+/g).sort((a,b)=>+a>+b||+(a===b)*2-1).join(`, `)

uमेरे तरीके के लिए छोड़ना पड़ा , तो यह है t। Bummed कि मुझे उस तरह के फंक्शन में लगाना पड़ा, क्योंकि String.matchरिटर्न वैल्यूज़ ... स्ट्रिंग्स।

Answer 9

रूबी, 121 103 बाइट्स

रूबी में सब कुछ को छोड़कर truthy है nilऔर falseजिसका अर्थ है कि कार्य शून्य पर एक अच्छी तरह से रखा के साथ पिछले इनपुट की अनदेखी करने के लिए स्थापित किया जा सकता है and/ &&।

कार्य 1

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

n,m=$*.map &:to_i
p [*n..m]

टास्क २

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

n,m=$*.map &:to_i
p [*n..m]&&(0..m).map{|i|[*n+i..m+i]}

टास्क 3

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

n,m=$*.map &:to_i
p [*n..m]&&(0..m).map{|i|[*n+i..m+i]}&&(1..m).map{|i|(1..n).map{|j|i*j}}

टास्क 4

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

n,m=$*.map &:to_i
p [*n..m]&&(0..m).map{|i|[*n+i..m+i]}&&(1..m).map{|i|(1..n).map{|j|i*j}}.flatten.sort