Este desafío está relacionado con algunas de las características del lenguaje MATL, como parte del evento Idioma del mes de mayo de 2018 . Reto asociado: Portapapeles de funciones: copia .

Introducción

El portapapeles de funciones de MATL almacena ("copia") las entradas a las cuatro llamadas más recientes a las funciones normales de toma de entrada. Las funciones normales son el tipo más común de funciones en MATL. La toma de entrada significa que la función toma al menos una entrada. El contenido del portapapeles almacenado se puede insertar en la pila ("pegar").

Este desafío tomará el contenido del portapapeles como entrada. Se supondrá que todas las funciones que han producido ese estado del portapapeles tomaron uno o más enteros positivos como entradas. Por lo tanto, el estado del portapapeles se puede representar mediante una lista de listas de números. (Para obtener más información sobre cómo se llena el portapapeles, consulte el desafío relacionado; pero eso no es necesario para el actual).

Interpretando el contenido del portapapeles

Ejemplo 1

La primera lista interna se refiere a la llamada de función más reciente , y así sucesivamente, por lo tanto, el estado del portapapeles

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

indica que la última llamada a la función se llevó dos entradas, es decir 11, 28; la penúltima llamada tomó entradas 12, 16; etc. (Este estado del portapapeles es producido por el código en el primer ejemplo del desafío relacionado).

Ejemplo 2

Si no ha habido suficientes llamadas a funciones , algunas listas internas finales en el portapapeles estarán vacías:

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

(Esto es producido por un programa que simplemente agrega 7y 5).

Ejemplo 3

Las llamadas a funciones pueden tener cualquier cantidad de entradas , pero siempre al menos 1(las funciones que no toman entradas no cambian el estado del portapapeles). Entonces lo siguiente también es posible.

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

Accediendo al contenido del portapapeles

El contenido del portapapeles de funciones se inserta en la pila utilizando la función de MATL M(que, por cierto, no es una función normal, sino una función de portapapeles). Esta función toma un entero positivo como entrada y empuja algunos de los contenidos del portapapeles a la pila, de la siguiente manera. Con referencia al estado del portapapeles en el ejemplo 1:

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

1Mdevuelve todas las entradas a la llamada de función más reciente. Así, para el ejemplo considerado, da 11, 28.
Del mismo modo, 2M, 3My 4Mdevolver todas las entradas a la segunda, tercera y cuarta llamadas a funciones más recientes. Así 2Mda 12, 16; 3Mda 4; y 4Mda 5, 6.
Números más allá de las entradas individuales4 seleccionadas para llamadas de función que tomaron más de una entrada. Por lo tanto, devuelve la última entrada a la llamada más reciente . En nuestro caso esto da . devuelve la entrada individual anterior , que es . devuelve la última entrada de la penúltima llamada, es decir , y da . Ahora da . Observe cómo se omite la entrada porque era la única entrada en su llamada a la función. Por último, da .5M286M117M168M129M6410M5

Para el estado del portapapeles en el ejemplo 3:

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

1Mda 3. 2Mda 2, 40, 34. 3Mda 7, 8, 15.
4Mtiene un comportamiento indefinido (para los propósitos de este desafío), porque solo ha habido tres llamadas a funciones.
5Mda 34. 6Mda 40. 7Mda 2. 8Mda 15. 9Mda 8, 10Mda 7.
11M, 12M... también tienen un comportamiento indefinido .

El reto

Entrada :

el estado del portapapeles, como una lista de listas, o cualquier otro formato razonable;
un entero positivo n .

Salida : el resultado de llamar a la función Mcon n como entrada. La salida será uno o varios números con un separador inequívoco, o en cualquier formato razonable, como una lista o matriz.

Aclaraciones:

El estado del portapapeles consta de cuatro listas de números. Algunas de las listas finales pueden estar vacías, como en los ejemplos 2 y 3. Si lo prefiere, puede ingresar el portapapeles sin esas listas vacías finales. Entonces el ejemplo 3 se convertiría [[3], [2, 40, 34], [7, 8, 15]].
Todos los números en el portapapeles serán enteros positivos, posiblemente con más de un dígito.
Se garantiza que el número n es válido. Entonces, por ejemplo, 3 arriba, nno puede ser 4o 11.

Reglas adicionales:

La entrada y la salida se pueden tomar por cualquier medio razonable .
Se permiten programas o funciones, en cualquier lenguaje de programación . Las lagunas estándar están prohibidas .
El código más corto en bytes gana.

Casos de prueba

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

code-golf number array-manipulation Luis Mendo
fuente

¿Podemos tomar un n indexado 0 ?

Arnauld

3

@Arnauld Voy a decir que no, ya que esto se basa en el comportamiento real de MATL

Luis Mendo

3

Jalea , 8 bytes

ḊƇUẎ⁸;⁹ị

Pruébalo en línea!

Erik el Outgolfer
fuente

2

¿Te importa agregar una explicación?

LordColus

@LordColus ḊƇselecciona todos los no singletons, Uinvierte y Ẏaplana. Para la entrada [[11, 28], [12, 16], [4], []]esto se obtiene [16, 12, 28, 11], los valores de 5Mthrough 8M. Ahora anteponga la entrada original a esta lista ⁸;e indexe en la lista resultante por la otra entrada ⁹ị.

Lynn

@ LordColus Ah, lo siento, solo agrego explicaciones a pedido (porque ninja), pero estaba dormido. Lynn lo explicó más o menos, sin embargo, me gustaría agregar que eso Uno revierte el resultado ḊƇ, sino cada uno de sus elementos. Solo si de alguna manera pudiera reducir ḊƇUẎ⁸;...

Erik the Outgolfer

4

Haskell , 56 51 47 bytes

^{-5 -9 bytes gracias a Laikoni (coincidencia de patrón para asegurarse de longitud> 1 y usando do-notation sobre lista por comprensión)!}

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

Pruébalo en línea!

Punto libre, 58 55 bytes

^{-3 bytes gracias a Laikoni (moviendo ([]:)y reemplazando id)!}

Alternativamente, podríamos usar esta versión sin puntos

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

ბიმო
fuente

3

APL (Dyalog Unicode) , 17 bytes

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

Pruébalo en línea!

Erik el Outgolfer
fuente

3

JavaScript (Node.js) , 57 bytes

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

Pruébalo en línea!

Esta es una función anónima, curry. Ejecútalo con( function code )(clipboard)(n)

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

NinjaOsoMono
fuente

2

JavaScript (ES6), 72 bytes

Toma entrada en la sintaxis 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)

Pruébalo en línea!

Arnauld
fuente

2

Python 2 , 60 56 bytes

gracias a Jonathan Allan por -4 bytes.

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

Pruébalo en línea!

ovs
fuente

2

Java 8, 110 bytes

Una lambda (curry) que toma el estado del portapapeles como int[][]y el número como inty regresa into int[](puede devolverse un solo número a través de cualquier tipo).

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

Pruébalo en línea

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

Jakob
fuente

2

05AB1E , 12 bytes

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

Pruébalo en línea!

Explicación

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

Emigna
fuente

2

Casco , 12 bytes

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

Pruébalo en línea!

Explicación

Más o menos un puerto directo de la respuesta de 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]

ბიმო
fuente

2

R , 58 bytes

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

Pruébalo en línea!

Toma Mcomo un listde vectores c(); entonces, reemplazar [[con list(, [con c(y ]con )debería transformar los casos de prueba en casos de prueba R.

Para las entradas n<=4con "comportamiento indefinido", devoluciones NULLy para otras entradas no válidas, arroja un error "subíndice fuera de los límites".

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

Giuseppe
fuente

Probablemente podría salirse con el uso en [n]lugar de [[n]].

JAD

2

Stax , 12 14 13 bytes

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

Ejecutar y depurarlo

Explicación:

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≈\☼╣Δ@░ ‼

Desempaquetado:

{vsc{%vfr$r+@}

Este es un bloque, así que puedo deshacerme de él ]|u, pero no sé si esto es válido ya que está empacando un bloque.

wastl
fuente

2

J , 33 22 bytes

-11 bytes (1/3 más corto) gracias a la solución de FrownyFrog!

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

Pruébalo en línea!

Mi solución inicial:

J , 33 bytes

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

No estoy contento: estoy bastante seguro de que se puede jugar mucho más.

Explicación:

Una función diádica, tomando el estado del portapapeles como su argumento correcto, el argumento izquierdo es n

<:@[ reste 1 del argumento izquierdo

{ selecciona el i elemento th (calculado arriba) de la lista a su derecha

(...) la lista completa

# Copiar

] de la lista de estado del portapapeles

(1<#) las sublistas con longitud mayor que 1

|.&.> rotar cada sublista copiada

<"0@; raze and box - pone cada número en una caja separada

, agregar la nueva lista a la lista del estado del portapapeles

@] hace que todo el verbo en (...) sea monádico

Pruébalo en línea!

Galen Ivanov
fuente

@FrownyFrog Me gusta 0;más. ¡Gracias!

Galen Ivanov

Esa es completamente su solución, solo golf :)

FrownyFrog

2

V + coreutils , 53 45 43 42 40 bytes

^{-9 bytes gracias a DJMcMayhem (usando VGÇ /duna :,$g/^[^ ]*$/d, D@"dduna "aDÀddy !!otra vez:.! )!}

Mi primer intento en V (¡consejos bienvenidos!), El siguiente código está usando caracteres dentro de un círculo (por ejemplo, ⓞfor \xf) para facilitar la lectura:

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

Pruébalo en línea!

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

Explicación

La primera línea contiene n y las líneas siguientes contienen las entradas del portapapeles, cada entrada está separada por espacios si hubiera entradas múltiples:

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

ბიმო
fuente

1

Rojo , 91 bytes

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

Pruébalo en línea!

Galen Ivanov
fuente

1

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

Pruébalo en línea!

Toma la matriz como una lista de 4 pares de punteros de inicio / fin, luego n.

Descripción:

#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

LambdaBeta
fuente

Portapapeles de funciones: pegar

Introducción

Interpretando el contenido del portapapeles

Accediendo al contenido del portapapeles

El reto

Casos de prueba

Respuestas:

Jalea , 8 bytes

Haskell , 56 51 47 bytes

Punto libre, 58 55 bytes

APL (Dyalog Unicode) , 17 bytes

JavaScript (Node.js) , 57 bytes

Explicación

JavaScript (ES6), 72 bytes

Python 2 , 60 56 bytes

Java 8, 110 bytes

Sin golf

05AB1E , 12 bytes

Casco , 12 bytes

Explicación

R , 58 bytes

Stax , 12 14 13 bytes

Stax, 12 bytes

J , 33 22 bytes

Mi solución inicial:

J , 33 bytes

Explicación:

V + coreutils , 53 45 43 42 40 bytes

Hexdump

Explicación

Rojo , 91 bytes

C (gcc) , 176 bytes