Diese Herausforderung steht im Zusammenhang mit einigen Funktionen der MATL-Sprache im Rahmen des Events Sprache des Monats im Mai 2018 . Assoziierte Herausforderung: Funktion Zwischenablage: Kopieren .

Einführung

Die Funktions-Zwischenablage von MATL speichert ("kopiert") die Eingaben zu den vier letzten Aufrufen für normale Eingabeaufnahmefunktionen. Normale Funktionen sind der häufigste Funktionstyp in MATL. Eingabeaufnahme bedeutet, dass die Funktion mindestens eine Eingabe aufnimmt. Der gespeicherte Inhalt der Zwischenablage kann auf den Stapel geschoben ("eingefügt") werden.

Bei dieser Abfrage wird der Inhalt der Zwischenablage als Eingabe verwendet. Es wird angenommen, dass alle Funktionen, die diesen Zwischenablagezustand erzeugt haben, eine oder mehrere positive Ganzzahlen als Eingaben verwendeten. So kann der Zustand der Zwischenablage durch eine Liste von Nummernlisten dargestellt werden. (Weitere Informationen darüber, wie die Zwischenablage tatsächlich gefüllt ist, finden Sie in der entsprechenden Aufforderung. Dies ist jedoch für die aktuelle nicht erforderlich.)

Interpretation des Inhalts der Zwischenablage

Beispiel 1

Die erste innere Liste bezieht sich auf den letzten Funktionsaufruf und so weiter, also auf den Zustand der Zwischenablage

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

zeigt an, dass der letzte Funktionsaufruf zwei Eingänge hat, nämlich 11, 28; vorletzten Anruf hat Eingänge 12, 16; usw. (Dieser Zwischenablagezustand wird durch den Code im ersten Beispiel der zugehörigen Abfrage erzeugt.)

Beispiel 2

Wenn es nicht genügend Funktionsaufrufe gegeben hat , sind einige nachgestellte innere Listen in der Zwischenablage leer:

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

(Dies wird von einem Programm erzeugt, das einfach 7und hinzufügt. 5)

Beispiel 3

Funktionsaufrufe können eine beliebige Anzahl von Eingaben haben , mindestens jedoch 1(Funktionen, die keine Eingaben annehmen, ändern den Status der Zwischenablage nicht). So ist auch folgendes möglich.

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

Zugriff auf den Inhalt der Zwischenablage

Der Inhalt der Funktions-Zwischenablage wird mit der Funktion von MATL M(die übrigens keine normale Funktion, sondern eine Zwischenablage-Funktion ist) auf den Stapel verschoben . Diese Funktion verwendet eine positive Ganzzahl als Eingabe und verschiebt einen Teil des Inhalts der Zwischenablage wie folgt auf den Stapel. In Bezug auf den Status der Zwischenablage in Beispiel 1:

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

• 1MGibt alle Eingaben zum letzten Funktionsaufruf zurück. Also, für das in Betracht gezogenen Beispiel, gibt es 11, 28.
• In ähnlicher Weise 2M, 3Mund das 4MRück alle Eingaben an den zweiten, dritten und vierten letzten Funktionsaufrufe. So 2Mgibt 12, 16; 3Mgibt 4; und 4Mgibt 5, 6.
• Zahlen jenseits 4ausgewählter einzelner Eingänge für Funktionsaufrufe, die mehr als einen Eingang belegt haben. So 5Mgibt die letzte Eingabe in den letzten solchen Anruf. In unserem Fall gibt dies 28. 6Mgibt die vorhergehende individuelle Eingabe zurück 11. 7Mgibt die letzte Eingabe des vorletzten Aufrufs zurück, das heißt 16, und 8Mgibt 12. Nun 9Mgibt 6. Beachten Sie, wie Eingaben 4übersprungen werden, da dies die einzige Eingabe in ihrem Funktionsaufruf war. Zuletzt 10Mgibt 5.

Für den Zwischenablage-Status in Beispiel 3:

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

• 1Mgibt 3. 2Mgibt 2, 40, 34. 3Mgibt 7, 8, 15.
• 4Mhat undefiniertes Verhalten (für die Zwecke dieser Herausforderung), da es nur drei Funktionsaufrufe gab.
• 5Mgibt 34. 6Mgibt 40. 7Mgibt 2. 8Mgibt 15. 9Mgibt 8, 10Mgibt 7.
• 11M, 12M, ... haben auch nicht definiertes Verhalten .

Die Herausforderung

Eingabe :

• den Zustand der Zwischenablage als eine Liste von Listen oder ein anderes vernünftiges Format;
• eine positive ganze Zahl n .

Ausgabe : Das Ergebnis des Aufrufs der Funktion Mmit n als Eingabe. Die Ausgabe erfolgt in einer oder mehreren Zahlen mit einem eindeutigen Trennzeichen oder in einem angemessenen Format wie einer Liste oder einem Array.

Klarstellungen:

• Der Status der Zwischenablage besteht aus vier Nummernlisten. Einige der nachfolgenden Listen sind möglicherweise leer, wie in den Beispielen 2 und 3. Bei Bedarf können Sie die Zwischenablage auch ohne die nachfolgenden leeren Listen eingeben. So würde Beispiel 3 werden [[3], [2, 40, 34], [7, 8, 15]].
• Alle Zahlen in der Zwischenablage sind positive Ganzzahlen, möglicherweise mit mehr als einer Ziffer.
• Die Nummer n ist garantiert gültig. So kann zum Beispiel 3 oben nnicht 4oder sein 11.

Zusätzliche Regeln:

• Eingabe und Ausgabe können mit jedem vernünftigen Mittel erfolgen .

• Programme oder Funktionen sind in jeder Programmiersprache zulässig . Standardlücken sind verboten .

• Kürzester Code in Bytes gewinnt.

Testfälle

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

Gelee , 8 Bytes

ḊƇUẎ⁸;⁹ị

Probieren Sie es online!

Haskell , 56 51 47 Bytes

^{-5 -9 Bytes dank Laikoni ( Musterübereinstimmung , um Länge> 1 zu gewährleisten und do-Notation über Listenverständnis zu verwenden)!}

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

Probieren Sie es online!

Punktfrei, 58 55 Bytes

^{-3 Bytes dank Laikoni (verschieben ([]:)und ersetzen id)!}

Alternativ könnten wir diese pointfree Version verwenden

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

APL (Dyalog Unicode) , 17 Byte

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

Probieren Sie es online!

JavaScript (Node.js) , 57 Byte

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

Probieren Sie es online!

Dies ist eine anonyme Curry-Funktion. Führen Sie es mit( function code )(clipboard)(n)

Erläuterung

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]
}

JavaScript (ES6), 72 Byte

Übernimmt Eingaben in der Currying-Syntax (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)

Probieren Sie es online!

Python 2 , 60 56 Bytes

Danke an Jonathan Allan für -4 Bytes.

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

Probieren Sie es online!

Java 8, 110 Bytes

Ein Lambda (Curry), das den Status der Zwischenablage als int[][]und die Nummer als intund zurückgibt intoder int[](eine einzelne Nummer kann durch einen der beiden Typen zurückgegeben werden).

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];}}

Probieren Sie es online

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];
        }
    }

05AB1E , 12 Bytes

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

Probieren Sie es online!

Erläuterung

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

Schale , 12 Bytes

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

Probieren Sie es online!

Erläuterung

Ziemlich direkter Hafen der Haskell-Antwort:

!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]

R , 58 Bytes

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

Probieren Sie es online!

Nimmt Mals listVektoren c(); Wenn Sie also [[mit list(, [mit c(und ]mit ersetzen , )sollten Sie die Testfälle in R-Testfälle umwandeln.

Gibt für Eingaben n<=4mit "undefiniertem Verhalten" NULLund für andere ungültige Eingaben einen "Index außerhalb der Grenzen" -Fehler aus.

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

Stax , 12 14 13 Bytes

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

Führen Sie es aus und debuggen Sie es

Erläuterung:

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

Stax, 12 Bytes

Å{b≈\☼╣Δ@░ ‼

Unverpackt:

{vsc{%vfr$r+@}

Dies ist ein Block, also kann ich den loswerden ]|u, aber ich weiß nicht, ob dies gültig ist, da es einen Block packt.

J , 33 22 Bytes

-11 Bytes (1/3 kürzer) dank der FrownyFrog-Lösung!

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

Probieren Sie es online!

Meine anfängliche Lösung:

J , 33 Bytes

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

Nicht glücklich - ich bin mir ziemlich sicher, dass es viel weiter golfen werden kann.

Erläuterung:

Eine dyadische Funktion, deren rechtes Argument der Zustand der Zwischenablage ist. Das linke Argument ist n

<:@[ subtrahiere 1 vom linken Argument

{Wählt das i(oben berechnete) th-Element aus der Liste auf der rechten Seite aus

(...) die gesamte Liste

# Kopieren

] aus der Liste der Zwischenablage Zustand

(1<#) die Unterlisten mit einer Länge größer als 1

|.&.> Drehe jede kopierte Unterliste

<"0@; raze and box - fügt jede Nummer in ein separates Feld ein

, Hängt die neue Liste an die Liste des Zwischenablagezustands an

@] macht das gesamte Verb in (...) monadisch

Probieren Sie es online!

V + Coreutils , 53 45 43 42 40 Bytes

^{-9 Bytes dank DJMcMayhem (mit VGÇ /dmehr als :,$g/^[^ ]*$/d, D@"ddüber "aDÀddund !!über :.!)!}

Mein allererster Versuch bei V (Tipps erwünscht!), Der folgende Code verwendet zur besseren Lesbarkeit eingekreiste Zeichen (zB ⓞfür \xf):

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

Probieren Sie es online!

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

Erläuterung

Die erste Zeile enthält n und die folgenden Zeilen enthalten die Einträge der Zwischenablage. Bei mehreren Eingaben wird jeder Eintrag durch Leerzeichen getrennt:

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

Rot , 91 Bytes

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

Probieren Sie es online!

C (gcc) , 176 Bytes

#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*_);}}

Probieren Sie es online!

Nimmt das Array als eine Liste von 4 Start / Ende-Zeigerpaaren, dann n.

Beschreibung:

#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