फंक्शन क्लिपबोर्ड: पेस्ट

Question

यह चुनौती मई के 2018 लैंग्वेज ऑफ द मंथ इवेंट के हिस्से के रूप में MATL भाषा की कुछ विशेषताओं से संबंधित है । एसोसिएटेड चैलेंज: फंक्शन क्लिपबोर्ड: कॉपी ।

---

परिचय

MATL के फ़ंक्शन क्लिपबोर्ड स्टोर ("प्रतियां") चार सबसे हाल की कॉलों को सामान्य, इनपुट-लेने वाले कार्यों के लिए इनपुट। MATL में सामान्य कार्य सबसे सामान्य प्रकार के कार्य हैं। इनपुट-लेने का अर्थ है कि फ़ंक्शन कम से कम एक इनपुट लेता है। संग्रहीत क्लिपबोर्ड सामग्री को स्टैक ("चिपकाया") पर धकेल दिया जा सकता है।

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

क्लिपबोर्ड सामग्री की व्याख्या करना

उदाहरण 1

पहले आंतरिक सूची को संदर्भित करता है सबसे हाल ही में समारोह कॉल, और इतने पर, इस प्रकार क्लिपबोर्ड राज्य

[[11, 28], [12, 16], [4], [5, 6]]

इंगित करता है कि पिछले समारोह कॉल दो आदानों ले लिया है, अर्थात् 11, 28; दूसरी आखिरी कॉल आदानों ले लिया 12, 16; आदि (यह क्लिपबोर्ड राज्य संबंधित चुनौती के पहले उदाहरण में कोड द्वारा निर्मित है)।

उदाहरण 2

यदि पर्याप्त फ़ंक्शन कॉल नहीं हुए हैं , तो क्लिपबोर्ड में कुछ अनुगामी आंतरिक सूचियां खाली होंगी:

[[7, 5], [], [], []]

(यह एक कार्यक्रम है कि बस कहते हैं 7और 5) द्वारा निर्मित है ।

उदाहरण 3

फ़ंक्शन कॉल में किसी भी संख्या में इनपुट हो सकते हैं , लेकिन हमेशा कम से कम 1(बिना इनपुट के कार्य करने से क्लिपबोर्ड स्थिति में परिवर्तन नहीं होता है)। तो निम्नलिखित भी संभव है।

[[3], [2, 40, 34], [7, 8, 15], []]

क्लिपबोर्ड सामग्री तक पहुँचना

फ़ंक्शन क्लिपबोर्ड की सामग्री MATL फ़ंक्शन का उपयोग करके स्टैक पर धकेल दी जाती है M(जो, वैसे, एक सामान्य फ़ंक्शन नहीं है, लेकिन क्लिपबोर्ड फ़ंक्शन है)। यह फ़ंक्शन इनपुट के रूप में एक सकारात्मक पूर्णांक लेता है, और कुछ क्लिपबोर्ड सामग्री को स्टैक पर निम्नानुसार धकेलता है। उदाहरण 1 में क्लिपबोर्ड स्थिति के संदर्भ में:

[[11, 28], [12, 16], [4], [5, 6]]

• 1Mसबसे हाल ही में फ़ंक्शन कॉल के लिए सभी इनपुट लौटाता है । तो माना जाता है उदाहरण के लिए, यह देता है 11, 28।
• इसी तरह, 2M, 3Mऔर 4Mदूसरे के लिए सभी आदानों वापसी, तीसरे और चौथे सबसे हाल ही में फ़ंक्शन कॉल। तो 2Mदेता है 12, 16; 3Mदेता है 4; और 4Mदेता है 5, 6।
• परे नंबर 4का चयन व्यक्तिगत आदानों फ़ंक्शन कॉल कि ले लिया करने के लिए एक से अधिक इनपुट। इसलिए पिछले इनपुट को सबसे हालिया कॉल पर 5Mलौटाता है । हमारे मामले में यह देता है । पूर्ववर्ती व्यक्तिगत इनपुट लौटाता है , जो है । दूसरे-आखिरी कॉल का अंतिम इनपुट, जो है , और देता है । अब, देता है । ध्यान दें कि इनपुट कैसे छोड़ दिया जाता है क्योंकि यह अपने फ़ंक्शन कॉल में एकमात्र इनपुट था । अंत में, देता है ।286M117M168M129M6410M5

उदाहरण 3 में क्लिपबोर्ड स्थिति के लिए:

[[3], [2, 40, 34], [7, 8, 15], []]

• 1Mदेता है 3। 2Mदेता है 2, 40, 34। 3Mदेता है 7, 8, 15।
• 4Mहै अपरिभाषित व्यवहार क्योंकि वहाँ केवल तीन फ़ंक्शन कॉल किया गया है, (इस चुनौती के प्रयोजनों के लिए)।
• 5Mदेता है 34। 6Mदेता है 40। 7Mदेता है 2। 8Mदेता है 15। 9Mदेता है 8, 10Mदेता है 7।
• 11M, 12M... का भी अपरिभाषित व्यवहार है ।

चुनौती

इनपुट :

• क्लिपबोर्ड राज्य, सूचियों की सूची या किसी अन्य उचित प्रारूप के रूप में;
• एक धनात्मक पूर्णांक n ।

आउटपुट : इनपुट के रूप में n केM साथ कॉलिंग फ़ंक्शन का परिणाम । आउटपुट एक अस्पष्ट विभाजक के साथ एक या कई संख्याओं में, या किसी सूची या सरणी जैसे किसी भी उचित प्रारूप में होगा।

स्पष्टीकरण:

• क्लिपबोर्ड स्थिति में संख्याओं की चार सूचियाँ होती हैं। अनुगामी सूचियों में से कुछ रिक्त हो सकती हैं, उदाहरण 2 और 3 में। यदि पसंद किया जाता है, तो आप खाली सूचियों को अनुगामी किए बिना क्लिपबोर्ड पर इनपुट कर सकते हैं। तो उदाहरण 3 बन जाएगा [[3], [2, 40, 34], [7, 8, 15]]।
• क्लिपबोर्ड के सभी नंबर सकारात्मक पूर्णांक होंगे, संभवतः एक से अधिक अंकों के साथ।
• संख्या n मान्य होने की गारंटी है। उदाहरण के लिए 3 ऊपर, nहो सकता है 4या नहीं 11।

अतिरिक्त नियम:

• इनपुट और आउटपुट किसी भी उचित माध्यम से लिया जा सकता है ।

• प्रोग्राम या फ़ंक्शंस की अनुमति है, किसी भी प्रोग्रामिंग भाषा में । मानक खामियों को मना किया जाता है ।

• बाइट्स में सबसे छोटा कोड जीतता है।

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

Clipboard state
Number
Output(s)

[[11, 28], [12, 16], [4], []]
2
12, 16

[[11, 28], [12, 16], [4], []]
5
28

[[7, 144], [12], [4, 8], [3, 4, 6]]
1
7, 144

[[7, 144], [12], [4, 8], [3, 4, 6]]
10
4

[[30], [40], [50, 60], [70, 80, 90]]
2
40

[[30], [40], [50, 60], [80, 90]]
7
90

[[15], [30], [2, 3, 5], [4, 5, 10]]
3
2, 3, 5

[[15], [30], [2, 3, 5], [4, 5, 10]]
7
2

Comments

क्या हम 0-अनुक्रमित n ले सकते हैं ?

— Arnauld

@Arnauld मैं नहीं कहने जा रहा हूं, क्योंकि यह MATL के वास्तविक व्यवहार पर आधारित है

— लुइस

Answer 1

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

ḊƇUẎ⁸;⁹ị

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

Comments

क्या आप एक स्पष्टीकरण जोड़ना बुरा मानते हैं?

— लॉर्डकोलस

@ लॉर्डकोलस ḊƇसभी गैर-सिंगलटन, Uरिवर्स और फ्लैटन का चयन करें Ẏ। इनपुट के लिए [[11, 28], [12, 16], [4], []]यह मिलता है [16, 12, 28, 11], के 5Mमाध्यम से 8M। अब इस सूची में मूल इनपुट ⁸;और दूसरे इनपुट द्वारा परिणामी सूची में अनुक्रमित करें ⁹ị।

— लिन

@LordColus आह, क्षमा करें, मैं केवल अनुरोध पर स्पष्टीकरण जोड़ता हूं (क्योंकि निंजा), लेकिन मैं सो रहा था। लिन ने बहुत समझाया, हालाँकि मैं यह जोड़ना चाहूंगा कि Uइसका परिणाम उल्टा नहीं है ḊƇ, बल्कि इसके प्रत्येक तत्व का है। केवल तभी, जब मैं किसी तरह कम कर सकता था ḊƇUẎ⁸;...

— एरिक आउटगॉल्फ

Answer 2

हास्केल , 56 51 47 बाइट्स

^{-5 -9 बाइट्स लाईकोनी के लिए धन्यवाद (पैटर्न की लंबाई सुनिश्चित करने के लिए मैच> 1 और doसूची-समझ से अधिक उपयोग )!}

c!n=([]:c++do l@(_:_:_)<-c;reverse$pure<$>l)!!n

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

पॉइंटफ्री, 58 55 बाइट्स

^{-3 बाइट्स लाईकोनी की बदौलत (चलती ([]:)और बदली id)!}

वैकल्पिक रूप से हम इस पॉइंटफ्री संस्करण का उपयोग कर सकते हैं

(!!).(([]:)<>map pure.(>>=reverse).filter((1<).length))।

Answer 3

एपीएल (डायलॉग यूनिकोड) , 17 बाइट्स

{⍺⊃⍵⍪∊⊖¨⍵⌿⍨1<≢¨⍵}

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

Answer 4

जावास्क्रिप्ट (Node.js) , 57 बाइट्स

a=>n=>a.map(e=>e[1]&&a.push(...[...e].reverse()))&&a[n-1]

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

यह एक अनाम, करी फ़ंक्शन है। इसके साथ चलाओ( function code )(clipboard)(n)

व्याख्या

a=>n=>{
    // The strategy is to append the individual clipboard inputs to the end of a,
    // after the function calls (lists). We then return a[n-1] to offset JavaScript's
    // zero indexing.
    a.map(e=>{
        e[1]&& // if this list has more than one element...
            a.push(...[...e].reverse()) // add each element to a, in reverse order.
            // reverse() modifies the original array, so we have to use [...e] to "clone" e
    })
    return a[n-1]
}

Answer 5

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

करी सिंटैक्स में इनपुट लेता है (clipboard)(n)।

a=>m=>a[m-1]||(g=r=>(r=r|a[k][1]&&a[k].pop())?--m<5?r:g(1):g(!++k))(k=0)

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

Answer 6

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

-4 बाइट्स के लिए जोनाथन एलन को धन्यवाद ।

lambda l,n:(l+sum([b[::-1]for b in l if b[1:]],[]))[n-1]

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

Answer 7

जावा 8, 110 बाइट्स

एक लैम्ब्डा (घुला हुआ) क्लिपबोर्ड स्थिति को एक int[][]और संख्या के रूप में ले जा रहा है intऔर लौट रहा है intया int[](एक ही संख्या को किसी भी प्रकार के माध्यम से वापस किया जा सकता है)।

s->n->{if(--n<4)return s[n];else{int i=0,l;for(n-=4;(l=s[i].length)<=n|l<2;i++)n-=l>1?l:0;return s[i][l+~n];}}

यह ऑनलाइन की कोशिश करो

Ungolfed

s ->
    n -> {
        if (--n < 4)
            return s[n];
        else {
            int i = 0, l;
            for (
                n -= 4;
                (l = s[i].length) <= n | l < 2;
                i++
            )
                n -= l > 1 ? l : 0;
            return s[i][l + ~n];
        }
    }

Answer 8

05AB1E , 12 बाइट्स

Díʒg<Ā}˜«s<è

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

व्याख्या

D              # duplicate input list
 í             # reverse each
  ʒg<Ā}        # filter, keep only elements that are longer than 1
       ˜       # flatten
        «      # append to original list
         s<    # decrement the second input
           è   # get the element in the list at that index

Answer 9

भूसी , 12 बाइट्स

!S+(m;ṁ↔f(¬ε

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

व्याख्या

बहुत ज्यादा हास्केल उत्तर का एक सीधा बंदरगाह:

!S+(m;ṁ↔f(¬ε  -- example inputs: [[1],[2,3],[4],[5,6,7],[]] 7
 S+           -- concatenate itself with itself modified by
        f(    -- | filter
           ε  -- | | length 1
          ¬   -- | | not
              -- | : [[2,3],[5,6,7],[]]
      ṁ       -- | map and flatten
       ↔      -- | | reverse
              -- | : [3,2,7,6,5]
              -- | map
              -- | | pure
              -- | : [[3],[2],[7],[6],[5]]
              -- : [[1],[2,3],[4],[5,6,7],[],[3],[2],[7],[6],[5]]
!             -- index into it: [2]

Answer 10

आर , 58 बाइट्स

function(M,n)c(M,unlist(lapply(M[lengths(M)>1],rev)))[[n]]

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

वैक्टर के Mरूप में लेता है ; जगह इतनी के साथ , के साथ और साथ आर परीक्षण मामलों में परीक्षण मामलों को बदलने चाहिए।listc()[[list([c(])

n<=4"अपरिभाषित व्यवहार" के साथ इनपुट के लिए , रिटर्न NULLऔर अन्य अमान्य इनपुट के लिए, "सीमा से बाहर" त्रुटि फेंकता है।

function(M,n)
                                        [[n]]	# take the nth element of
c(M,                                   )	# M concatenated with:
    unlist(                           )		# the individual elements of
           lapply(               ,rev)		# in-place reversals of
                  M[lengths(M)>1]		# elements of M with length > 1

Comments

शायद के [n]बजाय का उपयोग कर के साथ दूर हो सकता है [[n]]।

— JAD

Answer 11

स्टैक्स , 12 14 13 बाइट्स

àJ├∙ε╝F▀ÿi☻Ia

इसे चलाएं और डीबग करें

स्पष्टीकरण:

vsc{%vfr$r+@]|u Full program, unpacked, implicit input
vs              Decrement the number and get the list
  c{  f         Copy and filter:
    %v            Length not equal to 1?
       r$r      Reverse, flatten, and reverse again
          +     Concat orig array and and modified array
           @]|u Index, wrap into array, uneval

स्टैक्स, 12 बाइट्स

Å{b≈\☼╣Δ@░ ‼

पैक नहीं किया गया:

{vsc{%vfr$r+@}

यह एक ब्लॉक है, इसलिए मैं इससे छुटकारा पा सकता हूं ]|u, लेकिन मुझे नहीं पता कि क्या यह वैध है क्योंकि यह ब्लॉक पैक कर रहा है।

Answer 12

जे , 33 22 बाइट्स

-11 बाइट्स (1/3 छोटा) FrownyFrog के समाधान के लिए धन्यवाद!

{0;],|.&.>;/@;@#~1<#&>

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

मेरा प्रारंभिक समाधान:

जे , 33 बाइट्स

<:@[{(,[:<"0@;[:|.&.>(1<#)&>#])@]

खुश नहीं - मुझे पूरा यकीन है कि इसे और आगे बढ़ाया जा सकता है।

स्पष्टीकरण:

एक डाइएडिक फ़ंक्शन, क्लिपबोर्ड स्थिति को अपने कठोर तर्क के रूप में ले रहा है, बाएं तर्क है n

<:@[ बाएं तर्क से 1 घटाएं

{iइसके दाईं ओर सूची से वें तत्व (ऊपर परिकलित) का चयन करता है

(...) पूरी सूची

# प्रतिलिपि

] क्लिपबोर्ड राज्य की सूची से

(1<#) 1 से अधिक लंबाई वाले उपले

|.&.> प्रत्येक कॉपी किए गए सबलिस्ट को घुमाएं

<"0@; raze and box - प्रत्येक संख्या को एक अलग बॉक्स में रखता है

, क्लिपबोर्ड राज्य की सूची में नई सूची जोड़ें

@] संपूर्ण क्रिया को (...) एकादशी बनाता है

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

Comments

@FrownyFrog मुझे 0;सबसे ज्यादा पसंद है। धन्यवाद!

— गेलन इवानोव

यह पूरी तरह से आपका समाधान है, बस गोल्फ :)

— FrownyFrog

Answer 13

वी + कोर्यूटिल्स , 53 45 43 42 40 बाइट्स

^{-9 बाइट्स DJMcMayhem ( VGÇ /dओवर :,$g/^[^ ]*$/d, D@"ddओवर "aDÀddऔर !!ओवर का उपयोग करके :.!) के लिए धन्यवाद !}

V पर मेरा पहला प्रयास (टिप्स का स्वागत है!), नीचे दिया गया कोड पठनीयता के ⓞलिए परिचालित वर्णों (उदाहरण के लिए \xf) का उपयोग कर रहा है:

jäGⓞVGÇ /d
ⓞò!!tr \  \\n|tac
jòHD@"ddjdG

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

Hexdump

00000000: 6ae4 470f 5647 c720 2f64 0a0f f221 2174  j.G.VG. /d...!!t
00000010: 7220 5c20 205c 5c6e 7c74 6163 0a6a f248  r \  \\n|tac.j.H
00000020: 4440 2264 646a 6447                      D@"ddjdG

व्याख्या

पहली पंक्ति में n सम्‍मिलित है और नीचे की पंक्तियों में क्लिपबोर्ड की प्रविष्टियाँ सम्‍मिलित हैं, प्रत्येक प्रविष्टि को रिक्त स्थान से अलग किया जाता है यदि एकाधिक इनपुट थे:

j                        " move to the beginning of the clipboard entries
 äG                      " duplicate the clipboard
   ⓞ                    " <C-o> move cursor to the beginning of the 2nd copy
     VG                  " select everything from cursor to the end of buffer and ..
       Ç /d              " .. delete every line that doesn't contain a space

ⓞ                       " <C-o> move cursor to the beginning of the 2nd copy (now without single arguments)
  ò                   ò  " do the following until the end of buffer
   !!                    "   on the current line execute the shell command
     tr \  \\n           "   replace spaces with newlines
              |tac⮠     "   and reverse the lines
                    j    "   move to next line

H                        " go to the beginning of buffer (where n is)
 D                       " delete n (stores it in register ")
  @"                     " that many times ..
    dd                   " .. remove the line
      j                  " move cursor to next line
       dG                " delete everything from here to the end of buffer

Answer 14

लाल , 91 बाइट्स

func[b n][a: copy[]foreach c b[if 1 < length? c[append a reverse copy c]]pick append b a n]

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

Answer 15

सी (जीसीसी) , 176 बाइट्स

#define p printf("%d ",
int*_,i;f(x,n)int**x;{if(n<5){for(_=x[2*n-2];_-x[2*n-1];++_)p*_);}else{n-=4;for(i=0;i<8;i+=2)if(n&&x[i]+1-x[i+1])for(_=x[i+1];_-x[i]&&n;--_,--n);p*_);}}

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

सरणी को 4 स्टार्ट / एंड पॉइंटर जोड़े की सूची के रूप में लेता है, फिर एन।

विवरण:

#define p printf("%d ",  // This gives us the short-hand for printing
int*_,                   // This defines _ as a pointer to int
i;                       // This defines i as an integer
f(x,n)int**x;{           // This defines f as a function taking int **x and int n
                         // NOTE: x is {start, end, start, end, start, end, start, end}
if (n<5) {               // This is for the 1-4 case
  for(_=x[2*n-2];        // Loop _ from the 'end pointer' 
  _-x[2*n-1];++_)        // Until the 'start pointer'
  p*_);                  // Using the short-hand, print *_
}else{                   // This is for the 5+ case
  n-=4;                  // Cut n to improve indexing
  for(i=0;i<8;i+=2)      // Loop over each 'start pointer index'
    for(_=x[i+1];        // Loop _ from the 'end pointer'
        _-x[i]&&n;       // Until the 'start pointer' or n becomes 0
        --_,--n);        // Decreasing n each time
  p*_);}}                // _ now points to the 'correct' index, so print it