चुनौती:

पूर्णांक की गैर-रिक्त सूची की एक सूची को देखते हुए, निम्न फॉर्म के टुपल्स की एक सूची लौटाएं: पहली सूची के प्रत्येक तत्व के साथ शुरू होने वाली टुपल्स, उसके बाद की सूची के पहले तत्व के बाद, इसलिए ith टपल होना चाहिए [ith element of first list, first element of second list, ... , first element of last list]। उदाहरण के लिए:

[[1, 2, 3], [4, 5, 6], [7, 8, 9]] => [[1, 4, 7], [2, 4, 7], [3, 4, 7], ...

तो फार्म के tuples करते हैं [last element of first list, ith element of second list, first element of third list, ..., first element of last list], तो हमारे उदाहरण में यह होगा:

[[1, 2, 3], [4, 5, 6], [7, 8, 9]] =>  ..., [3, 4, 7], [3, 5, 7], [3, 6, 7], ...

शेष सूची के साथ जारी रखें, जब तक आप प्राप्त न करें [last element of first list, ..., last element of second to last list, ith element of last list]:

[[1, 2, 3], [4, 5, 6], [7, 8, 9]] => ..., [3, 6, 7], [3, 6, 8], [3, 6, 9]]

पूर्ण आउटपुट निम्नानुसार है:

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

अच्छे उपाय के लिए कुछ बॉयलरप्लेट:

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

उदाहरण:

[] => [[]] (or an error, thanks to ngn for correcting the output in this case)

[[1]] => [[1]]

[[1, 2], [3, 4], [5]] => [[1, 3, 5], [2, 3, 5], [2, 4, 5]]

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

[[1, 2, 3], [4, 5]] => [[1, 4], [2, 4], [3, 4], [3, 5]]

[[1, 2, 3], []] => unspecified behavior (can be an error)

[[3, 13, 6], [9, 2, 4], [5, 10, 8], [12, 1, 11], [7, 14]] => 
     [[3, 9, 5, 12, 7], [13, 9, 5, 12, 7], [6, 9, 5, 12, 7], [6, 2, 5, 12, 7], 
      [6, 4, 5, 12, 7], [6, 4, 10, 12, 7], [6, 4, 8, 12, 7], [6, 4, 8, 1, 7], 
      [6, 4, 8, 11, 7], [6, 4, 8, 11, 14]]  

[[16, 8, 4, 14, 6, 7, 10, 15], [11, 1, 12, 2, 19, 18, 9, 3], [13, 5, 17]] =>
    [[16, 11, 13], [8, 11, 13], [4, 11, 13], [14, 11, 13], [6, 11, 13], 
     [7, 11, 13], [10, 11, 13], [15, 11, 13], [15, 1, 13], [15, 12, 13], [15, 2, 13], 
     [15, 19, 13], [15, 18, 13], [15, 9, 13], [15, 3, 13], [15, 3, 5], [15, 3, 17]]

अगर किसी के पास बेहतर शीर्षक है, तो मुझे बताएं।

code-golf array-manipulation

— हुड
स्रोत

1

मेरी भावना है कि [] => []वास्तव में होना चाहिए, [] => [[]]लेकिन यह बताने के लिए शब्द क्यों नहीं मिल सकते हैं।

— ngn

1

@ngn आप सही हैं, ऐसा [[]]इसलिए होना चाहिए क्योंकि प्रत्येक (शून्य) सब्लिस्ट में से एक प्रविष्टि के साथ एक एकल खाली टपल है। संभवतः इसे सही ढंग से आउटपुट देने के लिए कार्यक्रमों की आवश्यकता के लिए बहुत कष्टप्रद है, इसलिए मैं कहूंगा कि यह आवश्यक नहीं है।

— हुड

1

हां [], कड़ाई से बोल रहा है, गैर-खाली सूचियों की एक खाली सूची है, लेकिन आउटपुट के बीच अस्पष्ट है []और [[]]अगर यह एक अनुमत इनपुट है। ("पहली सूची के प्रत्येक तत्व से शुरू होने वाली पहली सूची टुपल्स ..." - कोई पहली सूची नहीं है, इसलिए हम कर रहे हैं -> [])

— जोनाथन एलन

1

@JonathanAllan मैं अब आश्वस्त हूं कि "सही" आउटपुट []होना चाहिए [[]]। उदाहरण के लिए, आउटपुट ट्यूपल्स की संख्या वह है sum(inner list lengths) - length of outer list + 1जो खाली स्थिति में देता है 1, जो कि लंबाई है, [[]]लेकिन लंबाई नहीं है []। हालांकि यह एक पांडित्य का मुद्दा है ...

— हुड

1

क्या हम मान सकते हैं कि सभी प्रविष्टियाँ अलग-अलग हैं? या, अधिक दृढ़ता से, 1. उदाहरण पर एक क्रमपरिवर्तन आपके उदाहरणों में पसंद है?

— xnor

5

जावास्क्रिप्ट (ईएस 6), 59 बाइट्स

सकारात्मक पूर्णांकों की सूचियों की सूची की अपेक्षा करता है ।

f=a=>[a.map(a=>a[0]),...a.some(a=>a[1]&&a.shift())?f(a):[]]

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

कैसे?

प्रत्येक पुनरावृत्ति पर:

हम प्रत्येक सूची के पहले तत्व से मिलकर एक नई सूची तैयार करते हैं।
हम कम से कम 2 तत्वों वाली पहली सूची के पहले तत्व को हटाते हैं, और प्रक्रिया को दोहराते हैं। या हम पुनरावृत्ति को रोकते हैं यदि ऐसी कोई सूची मौजूद नहीं है।

— Arnauld
स्रोत

1

वह a.someचाल कमाल की है!

— ETHproductions

1

@ETHproductions अब एक ऐसी चुनौती की तलाश कर रहे हैं जहाँ प्रयोग awe.someकरना बाइट्स की बर्बादी नहीं होगी ... :)

— अरनौल्ड

2

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

lambda M:[zip(*M)[l.pop(0)*0]for l in M+[[1,1]]for _ in l[1:]]

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

चास ब्राउन के पॉप विचार का उपयोग करना, जो अर्नुल्ड के JS प्रस्तुतिकरण से प्रेरित है ।

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

M=input()
for l in[[0,0]]+M:
 for x in l[1:]:l[0]=x;print zip(*M)[0]

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

वांछित मान रखने के लिए सूचियों के पहले तत्वों को म्यूट करता है। [[0,0]]+प्रारंभिक पहले मूल्यों मुद्रित करने के लिए एक बदसूरत हैक है।

— XNOR
स्रोत

2

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

ẈṚṪ×€PƊƤFQṚCịŒp

इसे ऑनलाइन आज़माएं! (पाद एक जेली प्रतिनिधित्व के बजाय वास्तविक लौटी सूची प्रदर्शित करता है)

कैसे?

आवश्यक बिंदुओं पर सूचियों के कार्टेशियन उत्पाद में अनुक्रमित ...

ẈṚṪ×€PƊƤFQṚCịŒp - Link: list of lists  e.g. [[6,8,4,9],[7,1,5],[3,2]]
Ẉ               - length of each            [4,3,2]
 Ṛ              - reverse                   [2,3,4]
       Ƥ        - for each prefix:             [2]      [2,3]      [2,3,4]
      Ɗ         -   last 3 links as a monad:
  Ṫ             -     tail (pop rightmost)     2        3          4
     P          -     product (of remaining)   1        2          6
    €           -     for €ach (range tail)    [1,2]    [1,2,3]    [1,2,3,4]   
   ×            -       multiply               [1,2]    [2,4,6]    [6,12,18,24]
        F       - flatten                   [1,2,2,4,6,6,12,18,24]
         Q      - de-duplicate              [1,2,4,6,12,18,24]
          Ṛ     - reverse                   [24,18,12,6,4,2,1]
           C    - complement (1-x)          [-23,-17,-11,-5,-3,-1,0]
             Œp - Cartesian product (of the input)
                -         -> [[6,7,3],[6,7,2],[6,1,3],[6,1,2],[6,5,3],[6,5,2],[8,7,3],[8,7,2],[8,1,3],[8,1,2],[8,5,3],[8,5,2],[4,7,3],[4,7,2],[4,1,3],[4,1,2],[4,5,3],[4,5,2],[9,7,3],[9,7,2],[9,1,3],[9,1,2],[9,5,3],[9,5,2]]
            ị   - index into (1-based & modular)
                -   indexes:      -23,                                            -17,                                            -11,                                             -5,             -3,             -1,     0
                -    values: [[6,7,3],                                        [8,7,3],                                        [4,7,3],                                        [9,7,3],        [9,1,3],        [9,5,3],[9,5,2]]
                -         -> [[6,7,3],[8,7,3],[4,7,3],[9,7,3],[9,1,3],[9,5,3],[9,5,2]]

ẈṚ’ṣ1T$¦ƬUṚị"€(14 बाइट्स) के साथ इनपुट के लिए विफल रहता है (गैर-अनुगामी) लंबाई एक सूची; लेकिन शायद ṣ1T$कुछ और के साथ बदला जा सकता है?

— जोनाथन एलन
स्रोत

2

K (ngn / k) , 40 21 19 18 बाइट्स

{x@'/:?|\+|!|#:'x}

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

@ H.PWiz के उत्तर से विचारों का उपयोग करता है

{ } तर्क के साथ कार्य करें x

#:' प्रत्येक की लंबाई

| उलटना

! उन सभी आयामों के लिए एक मैट्रिक्स में कॉलम के रूप में एक सरणी के लिए (सूचियों की सूची) के साथ tuples

| उलटना

+ पक्षांतरित

|\ अधिकतम चल रहा है

? अद्वितीय

x@'/: से संबंधित सूचियों में सूचकांकों के रूप में दाईं ओर प्रत्येक टपल का उपयोग करें x

— NGN
स्रोत

1

चारकोल , 33 बाइट्स

ＩＥ⊕ΣＥθ⊖ＬιＥθ§λ⌈⟦⁰⌊⟦⊖Ｌλ⁻ι∧μΣＥ…θμ⊖Ｌν

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｉ

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

Ｅ⊕ΣＥθ⊖Ｌι

सूचियों की लंबाई का योग लें और सूचियों की सूची की लंबाई घटाएं। फिर 0 से लूप तक यह मान समावेशी है।

Ｅθ§λ

प्रत्येक सूची में सूचियों और सूचकांक की सूची पर नक्शा।

⌈⟦⁰⌊⟦⊖Ｌλ

सूची में सूचकांक को 0 और अंतिम सूचकांक को दबाना। (समापन कोष्ठक निहित हैं।)

⁻ι∧μΣＥ…θμ⊖Ｌν

पहली सूची के बाद, बाहरी सूचियों से पिछली सभी सूचियों की बढ़ी हुई लंबाई घटाएँ। (यह पहली सूची के लिए काम नहीं करता है क्योंकि सूचियों की लंबाई खाली है और राशि एक संख्या नहीं है।)

— नील
स्रोत

1

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

f=lambda a:zip(*a)[:1]+(any(len(u)>1and u.pop(0)for u in a)and f(a)or[])

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

यह अरनॉल्ट के उत्कृष्ट जावास्क्रिप्ट एल्गोरिथ्म का पायथन पोर्ट है।

— चास ब्राउन
स्रोत

1

APL (Dyalog Classic) , 32 30 27 बाइट्स

1↓¨∪⊃{(⍵,¨⊃⍺),⍺,¨⍨⊢/⍵}/⌽0,⎕

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

पूरा कार्यक्रम, इनपुट कीबोर्ड से है ( ⎕)

इनपुट []आउटपुट के लिए [[]](उनके एपीएल समकक्ष हैं 0⍴⊂⍬और,⊂⍬ )

इनपुट में संख्याओं की विशिष्टता मान लेता है

— NGN
स्रोत

1

ऐसा नहीं है कि इससे आउटपुट पर कोई फर्क पड़ता है, लेकिन मुझे लगता है कि दूसरे टेस्ट के लिए इनपुट होना चाहिए,⊂,1

— H.PWiz

@ H.PWiz यह सही है, निश्चित है, चीयर्स

— ngn

1

जावास्क्रिप्ट (ईएस 6), 58 54 बाइट्स

h=(x,s)=>[x.map(y=>s|y?y[0]:s=y.shift()),...s?h(x):[]]

14+ के बाद मेरे कोड को नीचे गिराने के प्रयासों के दौरान (छोरों push, और concat) के सभी उदाहरणों को हटाते हुए , मैं @ अरनॉल्ड के उत्तर के समान एल्गोरिथ्म में आ गया। , यह देखते हुए कि यह कितना सुसंगत है!

सकारात्मक पूर्णांकों की सूची की एक सूची को स्वीकार करता है। इसे ऑनलाइन आज़माएं!

58 बाइट्स

1 और बाइट के लिए, के s = y.shift()साथ की जगह y.shift(s = 1)सभी पूर्णांक संभालना चाहिए (संभवतः, जैसा कि मैंने व्यक्तिगत रूप से इसका परीक्षण नहीं किया है)।

h=(x,s)=>[x.map(y=>!s/y[1]?s=y.shift():y[0]),...s?h(x):[]]

58 बाइट्स

मामूली फेरबदल के साथ बोनस संस्करण:

h=x=>[x.map(y=>s&&y[1]?y.shift(s=0):y[0],s=[]),...s||h(x)]

व्याख्या

कोड के प्रारंभिक संस्करणों ने प्रत्येक सरणी के पहले तत्वों के (सरणी के) एक क्लोन को संशोधित करने की कोशिश की, लेकिन उस सरणी को शुरू करने का अतिरिक्त कदम महंगा था ... जब तक मुझे एहसास नहीं हुआ कि प्रत्येक सरणी के पहले तत्वों पर मैपिंग लगभग था यदि मैं मूल सरणियों को परिवर्तित करता हूं तो "केवल" ऑपरेशन आवश्यक है।

किसी भी सरणी को स्थानांतरित कर दिया गया है (यानी छोटा) अभी तक जाँच करने के लिए बूलियन ध्वज का उपयोग करता है। सशर्त जाँच को यह मानकर आगे बढ़ाते हैं कि JS एक संख्या मान के साथ सरणियों को उस संख्या में एकमात्र तत्व के रूप में प्रस्तुत करता है, जबकि NaN के रूप में कई मानों के साथ सरणियों का समन्वय करता है।

var
h = (x, s) => 
    [
        x.map(y =>                 // map to first element of each array
            s|y                    // if s == 1 (i.e. an array has been shortened)
                                   // or the current array y has length == 1
                ? y[0]
                : s = y.shift()    // remove first element of y and set s to truthy
        ),
        ...s ? h(x) : []           // only concatenate a recurrence of the function if an array has had a value removed
    ]

— फालतूपन
स्रोत

1

APL (Dyalog) , 15 बाइट्स ( SBCS )

एक अनावश्यक बाइट को इंगित करने के लिए धन्यवाद ngn

{∪⌈\,⍉⍳≢¨⍵}⊃¨¨⊂

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

{∪⌈\,⍉⍳≢¨⍵}सूचियों को इनपुट में अनुक्रमित करने के लिए बनाता है। जैसे(1 2 3) (4 5 6) (7 8 9) -> (0 0 0) (1 0 0) (2 0 0) (2 1 0) (2 2 0) (2 2 1) (2 2 2)

≢¨⍵: इनपुट में प्रत्येक सूची की लंबाई

,⍉⍳यह इनपुट तक संख्याओं के सभी संयोजन बनाता है। जैसे2 3 -> (0 0) (1 0) (0 1) (1 1) (0 2) (1 2)

⌈\: अधिकतम के साथ स्कैन करें। उदाहरण के लिए उपरोक्त उदाहरण अब होगा(0 0) (1 0) (1 1) (1 1) (1 2) (1 2)

∪: डुप्लिकेट निकालें

⊃¨¨⊂ अनुक्रमण करता है, या तो तर्क की गहराई के प्रति जागरूक होना

— H.PWiz
स्रोत

बहुत बढ़िया जवाब! आपने मुझे लगभग आधे बाइट्स से हराया। अनावश्यक⊆ लगता है ।

— ngn

सही लिंक

— ngn

@ अच्छा, मुझे याद नहीं है कि मुझे क्या सोचने की वजह से ऐसा हुआ था। धन्यवाद!

— H.PWiz

0

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

f=lambda a,p=():a and[p+(q,)+zip(*a)[0][1:]for q in a[0][p>():]]+f(a[1:],p+(a[0][-1],))or[]

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

— चास ब्राउन
स्रोत

क्रमिक रूप से सूचियों की सूची में प्रविष्टियों के माध्यम से कदम से ट्यूपल्स

चुनौती:

उदाहरण:

जावास्क्रिप्ट (ईएस 6), 59 बाइट्स

कैसे?

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

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

कैसे?

K (ngn / k) , 40 21 19 18 बाइट्स

चारकोल , 33 बाइट्स

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

APL (Dyalog Classic) , 32 30 27 बाइट्स

जावास्क्रिप्ट (ईएस 6), 58 54 बाइट्स

58 बाइट्स

58 बाइट्स

व्याख्या

APL (Dyalog) , 15 बाइट्स ( SBCS )

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