Questa sfida è legata ad alcune delle funzionalità del linguaggio MATL, nell'ambito dell'evento Lingua del mese di maggio 2018 . Sfida associata: Appunti di funzione: copia .

introduzione

Gli appunti delle funzioni di MATL memorizzano (" copiano ") gli input delle quattro chiamate più recenti alle normali funzioni di input. Le funzioni normali sono il tipo più comune di funzioni in MATL. Input-taking significa che la funzione accetta almeno un input. I contenuti degli appunti memorizzati possono essere inseriti nello stack ("incollati").

Questa sfida prenderà il contenuto degli appunti come input. Si supporrà che tutte le funzioni che hanno prodotto quello stato degli appunti abbiano preso uno o più numeri interi positivi come input. Quindi lo stato degli Appunti può essere rappresentato da un elenco di elenchi di numeri. (Per ulteriori informazioni su come vengono effettivamente riempiti gli Appunti, consultare la relativa sfida; ma non è necessario per quello attuale).

Interpretazione del contenuto degli appunti

Esempio 1

Il primo elenco interno fa riferimento alla più recente chiamata di funzione e così via, quindi lo stato degli Appunti

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

indica che l'ultima chiamata di funzione ha due ingressi, vale a dire 11, 28; la penultima chiamata ha avuto ingressi 12, 16; ecc. (Questo stato degli appunti è prodotto dal codice nel primo esempio della sfida correlata).

Esempio 2

Se non ci sono state abbastanza chiamate di funzione , alcuni elenchi interni finali negli appunti saranno vuoti:

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

(Questo è prodotto da un programma che aggiunge semplicemente 7e 5).

Esempio 3

Le chiamate di funzione possono avere un numero qualsiasi di ingressi , ma almeno 1(le funzioni che non accettano ingressi non cambiano lo stato degli Appunti). Quindi è anche possibile quanto segue.

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

Accesso al contenuto degli appunti

Il contenuto degli Appunti di funzione viene inserito nello stack usando la funzione MATL M(che, a proposito, non è una funzione normale, ma una funzione di Appunti). Questa funzione accetta un intero positivo come input e inserisce parte del contenuto degli appunti nello stack, come segue. Con riferimento allo stato degli appunti nell'esempio 1:

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

• 1Mrestituisce tutti gli input alla chiamata di funzione più recente. Così, per l'esempio considerato, dà 11, 28.
• Analogamente, 2M, 3Me 4Mrestituire tutti gli ingressi alla seconda, terza e quarta chiamate di funzione più recenti. Così 2Mdà 12, 16; 3Mdà 4; e 4Mdà 5, 6.
• I numeri oltre a 4selezionare i singoli input per far funzionare le chiamate che hanno richiesto più di un input. Quindi 5Mrestituisce l' ultimo input alla chiamata più recente . Nel nostro caso questo dà 28. 6Mrestituisce l' input individuale precedente , che è 11. 7Mrestituisce l'ultimo input della penultima chiamata, ovvero 16, e 8Mrestituisce 12. Ora 9Mdà 6. Nota come 4viene ignorato l' input perché era l' unico input nella sua chiamata di funzione. Infine, 10Mdà 5.

Per lo stato degli appunti nell'esempio 3:

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

• 1Mdà 3. 2Mdà 2, 40, 34. 3Mdà 7, 8, 15.
• 4Mha un comportamento indefinito (ai fini di questa sfida), perché ci sono state solo tre chiamate di funzione.
• 5Mdà 34. 6Mdà 40. 7Mdà 2. 8Mdà 15. 9Mdà 8, 10Mdà 7.
• 11M, 12M, ... hanno anche un comportamento indefinito .

La sfida

Input :

• lo stato degli appunti, come un elenco di elenchi o qualsiasi altro formato ragionevole;
• un numero intero positivo n .

Output : il risultato della funzione di chiamata Mcon n come input. L'output sarà uno o più numeri con un separatore non ambiguo, o in qualsiasi formato ragionevole come un elenco o un array.

chiarimenti:

• Lo stato degli Appunti è composto da quattro elenchi di numeri. Alcuni degli elenchi finali possono essere vuoti, come negli esempi 2 e 3. Se si preferisce, è possibile inserire gli Appunti senza quegli elenchi vuoti finali. Quindi l'esempio 3 diventerebbe [[3], [2, 40, 34], [7, 8, 15]].
• Tutti i numeri negli Appunti saranno numeri interi positivi, possibilmente con più di una cifra.
• Il numero n è garantito per essere valido. Quindi, per esempio 3 sopra, nnon può essere 4o 11.

Regole aggiuntive:

• Input e output possono essere presi con qualsiasi mezzo ragionevole .

• Programmi o funzioni sono consentiti, in qualsiasi linguaggio di programmazione . Sono vietate le scappatoie standard .

• Vince il codice più breve in byte.

Casi test

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

Gelatina , 8 byte

ḊƇUẎ⁸;⁹ị

Provalo online!

Haskell , 56 51 47 byte

^{-5 -9 byte grazie a Laikoni (corrispondenza del modello per garantire lunghezza> 1 e utilizzo di do-notazione per la comprensione dell'elenco)!}

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

Provalo online!

Pointfree, 58 55 byte

^{-3 byte grazie a Laikoni (spostamento ([]:)e sostituzione id)!}

In alternativa potremmo usare questa versione senza punti

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

APL (Dyalog Unicode) , 17 byte

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

Provalo online!

JavaScript (Node.js) , 57 byte

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

Provalo online!

Questa è una funzione anonima, al curry. Eseguilo con( function code )(clipboard)(n)

Spiegazione

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

Accetta input nella sintassi del curry (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)

Provalo online!

Python 2 , 60 56 byte

grazie a Jonathan Allan per -4 byte.

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

Provalo online!

Java 8, 110 byte

Un lambda (al curry) che prende lo stato degli appunti come int[][]e il numero come inte che ritorna into int[](un singolo numero può essere restituito attraverso entrambi i tipi).

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

Provalo 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 byte

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

Provalo online!

Spiegazione

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

Buccia , 12 byte

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

Provalo online!

Spiegazione

Praticamente un porto diretto della risposta di Haskell:

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

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

Provalo online!

Prende Mcome uno listdei vettori c(); quindi la sostituzione [[con list(, [con c(e ]con )dovrebbe trasformare i casi di test in casi di test R.

Per input n<=4con "comportamento indefinito", restituisce NULLe per altri input non validi, genera un errore "pedice fuori limite".

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 byte

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

Esegui ed esegui il debug

Spiegazione:

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 byte

Å{b≈\☼╣Δ@░ ‼

Unpacked:

{vsc{%vfr$r+@}

Questo è un blocco, quindi posso liberarmene ]|u, ma non so se sia valido in quanto è un pacchetto di blocchi.

J , 33 22 byte

-11 byte (1/3 in meno) grazie alla soluzione FrownyFrog!

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

Provalo online!

La mia soluzione iniziale:

J , 33 byte

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

Non contento - Sono abbastanza sicuro che possa essere giocato a golf molto più lontano.

Spiegazione:

Una funzione diadica, che considera lo stato degli appunti come argomento rigoroso, l'argomento sinistro è n

<:@[ sottrarre 1 dall'argomento sinistro

{seleziona l' ielemento th (calcolato sopra) dall'elenco alla sua destra

(...) l'intero elenco

# copia

] dall'elenco degli stati degli Appunti

(1<#) le liste secondarie con lunghezza maggiore di 1

|.&.> ruota ciascun elenco secondario copiato

<"0@; raze and box - mette ogni numero in una casella separata

, aggiungere il nuovo elenco all'elenco degli stati degli Appunti

@] rende l'intero verbo in (...) monadico

Provalo online!

V + coreutils , 53 45 43 42 40 byte

^{-9 byte grazie a DJMcMayhem (usando VGÇ /dsopra :,$g/^[^ ]*$/d, D@"ddsopra "aDÀdde !!oltre :.!)!}

Il mio primo tentativo in V (suggerimenti benvenuti!), Il codice seguente utilizza caratteri cerchiati (ad es. ⓞPer \xf) per leggibilità:

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

Provalo 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

Spiegazione

La prima riga contiene n e le righe sottostanti contengono le voci degli Appunti, ogni voce è separata da spazi se c'erano più input:

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

Rosso , 91 byte

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

Provalo online!

C (gcc) , 176 byte

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

Provalo online!

Prende l'array come un elenco di 4 coppie di puntatori inizio / fine, quindi n.

Descrizione:

#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