Ce défi est lié à certaines des fonctionnalités du langage MATL, dans le cadre de l' événement Langue du mois de mai 2018 . Défi associé: Fonction presse-papiers: copie .

introduction

Le presse-papiers des fonctions de MATL stocke ("copie") les entrées des quatre derniers appels aux fonctions normales de prise d'entrée. Les fonctions normales sont le type de fonctions le plus courant dans MATL. La prise d'entrée signifie que la fonction prend au moins une entrée. Le contenu du presse-papiers stocké peut être poussé sur la pile ("collé").

Ce défi prendra le contenu du presse-papiers en entrée. On supposera que toutes les fonctions qui ont produit cet état du presse-papiers ont pris un ou plusieurs entiers positifs comme entrées. Ainsi, l'état du presse-papiers peut être représenté par une liste de listes de nombres. (Pour plus d'informations sur la façon dont le presse-papiers est réellement rempli, consultez le défi associé; mais ce n'est pas nécessaire pour le présent).

Interprétation du contenu du presse-papiers

Exemple 1

La première liste interne fait référence à l' appel de fonction le plus récent , et ainsi de suite. Ainsi, l'état du presse-papiers

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

indique que le dernier appel de fonction a deux entrées, à savoir 11, 28; le deuxième dernier appel a pris des entrées 12, 16; etc. (Cet état du presse-papiers est produit par le code dans le premier exemple du défi associé).

Exemple 2

S'il n'y a pas eu suffisamment d'appels de fonction , certaines listes internes de fin dans le presse-papiers seront vides:

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

(Ceci est produit par un programme qui ajoute simplement 7et 5).

Exemple 3

Les appels de fonction peuvent avoir un nombre quelconque d'entrées , mais toujours au moins 1(les fonctions ne prenant aucune entrée ne modifient pas l'état du presse-papiers). Donc, ce qui suit est également possible.

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

Accéder au contenu du presse-papiers

Le contenu du presse-papiers de fonction est poussé sur la pile en utilisant la fonction de MATL M(qui, soit dit en passant, n'est pas une fonction normale, mais une fonction de presse-papier). Cette fonction prend un entier positif en entrée et pousse une partie du contenu du presse-papiers dans la pile, comme suit. En référence à l'état du presse-papiers dans l'exemple 1:

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

• 1Mrenvoie toutes les entrées à l'appel de fonction le plus récent. Ainsi, pour l'exemple considéré, il donne 11, 28.
• De même, 2M, 3Met 4Mretourner toutes les entrées à la deuxième, troisième et quatrième appels de fonctions les plus récentes. Alors 2Mdonne 12, 16; 3Mdonne 4; et 4Mdonne 5, 6.
• Les nombres au-delà de 4sélectionner des entrées individuelles pour faire fonctionner les appels qui ont pris plus d'une entrée. Renvoie donc 5Mla dernière entrée à l' appel le plus récent . Dans notre cas, cela donne 28. 6Mrenvoie l' entrée individuelle précédente , qui est 11. 7Mrenvoie la dernière entrée de l'avant-dernier appel, c'est-à-dire 16, et 8Mdonne 12. Maintenant, 9Mdonne 6. Notez comment l'entrée 4est ignorée car c'était la seule entrée dans son appel de fonction. Enfin, 10Mdonne 5.

Pour l'état du presse-papiers dans l'exemple 3:

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

• 1Mdonne 3. 2Mdonne 2, 40, 34. 3Mdonne 7, 8, 15.
• 4Ma un comportement indéfini (pour les besoins de ce défi), car il n'y a eu que trois appels de fonction.
• 5Mdonne 34. 6Mdonne 40. 7Mdonne 2. 8Mdonne 15. 9Mdonne 8, 10Mdonne 7.
• 11M, 12M... ont aussi un comportement non défini .

Le défi

Entrée :

• l'état du presse-papiers, sous forme de liste de listes, ou tout autre format raisonnable;
• un entier positif n .

Sortie : résultat de l'appel de la fonction Mavec n en entrée. La sortie sera un ou plusieurs nombres avec un séparateur sans ambiguïté, ou dans un format raisonnable tel qu'une liste ou un tableau.

Précisions:

• L'état du presse-papiers se compose de quatre listes de nombres. Certaines listes de fin peuvent être vides, comme dans les exemples 2 et 3. Si vous préférez, vous pouvez saisir le presse-papiers sans ces listes vides de fin. Ainsi, l'exemple 3 deviendrait [[3], [2, 40, 34], [7, 8, 15]].
• Tous les nombres dans le presse-papiers seront des entiers positifs, éventuellement avec plus d'un chiffre.
• Le nombre n est garanti d'être valide. Ainsi, par exemple 3 ci-dessus, nne peut pas être 4ou 11.

Règles supplémentaires:

• L'entrée et la sortie peuvent être prises par tout moyen raisonnable .

• Les programmes ou fonctions sont autorisés, dans n'importe quel langage de programmation . Les failles standard sont interdites .

• Le code le plus court en octets gagne.

Cas de 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

Gelée , 8 octets

ḊƇUẎ⁸;⁹ị

Essayez-le en ligne!

Haskell , 56 51 47 octets

^{-5 -9 octets grâce à Laikoni (mise en correspondance des motifs pour assurer une longueur> 1 et utilisation de do-notation sur la compréhension de la liste)!}

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

Essayez-le en ligne!

Pointfree, 58 55 octets

^{-3 octets grâce à Laikoni (déplacement ([]:)et remplacement id)!}

Alternativement, nous pourrions utiliser cette version sans point

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

APL (Dyalog Unicode) , 17 octets

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

Essayez-le en ligne!

JavaScript (Node.js) , 57 octets

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

Essayez-le en ligne!

Il s'agit d'une fonction anonyme et curry. Exécutez-le avec( function code )(clipboard)(n)

Explication

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 octets

Prend une entrée dans la syntaxe de 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)

Essayez-le en ligne!

Python 2 , 60 56 octets

merci à Jonathan Allan pour -4 octets.

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

Essayez-le en ligne!

Java 8, 110 octets

Un lambda (au curry) prenant l'état du presse-papiers en tant que int[][]et le nombre en tant que intet retournant intou int[](un seul numéro peut être renvoyé par l'un ou l'autre type).

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

Essayez-le en ligne

Non golfé

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 octets

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

Essayez-le en ligne!

Explication

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

Husk , 12 octets

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

Essayez-le en ligne!

Explication

À peu près un port direct de la réponse 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 octets

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

Essayez-le en ligne!

Prend Mcomme un listdes vecteurs c(); donc le remplacement [[par list(, [par c(et ]par )devrait transformer les cas de test en cas de test R.

Pour les entrées n<=4avec "comportement indéfini", renvoie NULLet pour les autres entrées non valides, jette une erreur "indice hors limites".

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 octets

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

Exécuter et déboguer

Explication:

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 octets

Å{b≈\☼╣Δ@░ ‼

Déballé:

{vsc{%vfr$r+@}

Ceci est un bloc, donc je peux m'en débarrasser ]|u, mais je ne sais pas si cela est valide car il contient un bloc.

J , 33 22 octets

-11 octets (1/3 plus court) grâce à la solution de FrownyFrog!

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

Essayez-le en ligne!

Ma première solution:

J , 33 octets

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

Pas content - je suis à peu près sûr qu'il peut être joué beaucoup plus loin.

Explication:

Une fonction dyadique, prenant l'état du presse-papiers comme argument de rigth, l'argument de gauche est n

<:@[ soustraire 1 de l'argument de gauche

{sélectionne le ie élément (calculé ci-dessus) dans la liste à sa droite

(...) la liste complète

# copie

] dans la liste des états du presse-papiers

(1<#) les sous-listes de longueur supérieure à 1

|.&.> faire pivoter chaque sous-liste copiée

<"0@; raze and box - met chaque numéro dans une boîte séparée

, ajouter la nouvelle liste à la liste des états du presse-papiers

@] rend le verbe entier en (...) monadique

Essayez-le en ligne!

V + coreutils , 53 45 43 42 40 octets

^{-9 octets grâce à DJMcMayhem (en utilisant VGÇ /dplus :,$g/^[^ ]*$/d,D@"dd encore "aDÀddet !!encore :.!)!}

Ma toute première tentative de V (conseils bienvenus!), Le code ci-dessous utilise des caractères encerclés (par exemple.ⓞ pour \xf) pour plus de lisibilité:

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

Essayez-le en ligne!

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

Explication

La première ligne contient n et les lignes ci-dessous contiennent les entrées du presse-papiers, chaque entrée est séparée par des espaces s'il y avait plusieurs entrées:

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

Rouge , 91 octets

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

Essayez-le en ligne!

C (gcc) , 176 octets

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

Essayez-le en ligne!

Prend le tableau comme une liste de 4 paires de pointeurs de début / fin, puis n.

La description:

#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