Emite números enteros en orden negativo, aumenta el número entero máximo cada vez

44

Tarea principal

Su tarea es imprimir enteros en orden descendente, comenzando desde 1, y aumentando a medida que sigue presionando 1 nuevamente, hasta que se alcanza la entrada dada, luego, imprima el resto hasta que vuelva a presionar 1. Ejemplo con entrada 6:

1
21
321
4321
54321
654321
Without newlines (valid output):
121321432154321654321
Nota al margen : este es A004736 en el OEIS. Además, el primer ejemplo (con líneas nuevas) es una salida no válida, como se especifica en las reglas.

Entrada

Su código puede tomar cualquier tipo de entrada (gráfica, STDIN) en forma de número entero o número.

Salida

Su código debe generar la secuencia descrita anteriormente, hasta que se alcance el número de entrada, luego termine de emitir hasta que llegue a 1 nuevamente. La salida puede ser cualquier cosa, por lo tanto, números, cadenas, enteros o salida gráfica. Se requiere imprimir un solo número (no hay nuevas líneas si es una cadena). Su salida puede introducirse y presentarse con tantos caracteres como necesite (por ejemplo []).

Como hubo algunos malentendidos, aquí hay un patrón de expresiones regulares en el que puede probar sus salidas.

^(\D*(\d)+\D*)$

Reglas

  • La salida debe ser un número completo, no dividido por nada, ni siquiera por líneas nuevas.
  • El algoritmo no debe comprobar para la primera instancia de N que aparece en cualquier forma (por ejemplo, el 21en 121321), sino más bien para la primera instancia de N como el número real.
  • Se permite una nueva línea final.
  • El manejo de la entrada negativa es completamente su elección, los números negativos no son casos que deba probar.

Casos de prueba

Input: 6
Output: 121321432154321654321

Input: 1 Output: 1

Input: 26 Output: 121321432154321654321765432187654321987654321109876543211110987654321121110987654321131211109876543211413121110987654321151413121110987654321161514131211109876543211716151413121110987654321181716151413121110987654321191817161514131211109876543212019181716151413121110987654321212019181716151413121110987654321222120191817161514131211109876543212322212019181716151413121110987654321242322212019181716151413121110987654321252423222120191817161514131211109876543212625242322212019181716151413121110987654321

Input: 0 Output: 0, Empty, or Error

Input: 21 Output: 121321432154321654321765432187654321987654321109876543211110987654321121110987654321131211109876543211413121110987654321151413121110987654321161514131211109876543211716151413121110987654321181716151413121110987654321191817161514131211109876543212019181716151413121110987654321212019181716151413121110987654321

Gracias @Emigna, usé su algoritmo para calcular estos casos de prueba.

Ganador

¡El ganador ha sido elegido! ¡Fue la respuesta de ErikGolfer con 5 bytes impresionantes ! ¡Felicidades!

devRicher
fuente
The output must be a full number ...¿Te refieres a la secuencia completa, o solo a las diferentes subcadenas (1, 2-1, 3-1 ...)? Su primer ejemplo no parece coincidir con esta afirmación.
steenbergh
1
Si la salida tiene que ser un número único, ¿cómo puede ser "matrices"?
sonríe el
¿Esta matriz sería aceptable como salida? [1, 21, 321, 4321, 54321, 654321] ¿Que tal este? [1,2,1,3,2,1,4,3,2,1,5,4,3,2,1,6,5,4,3,2,1] ¿O solo estás hablando de matrices con un solo elemento, como [121321432154321654321]?
smls
1
Estoy confundido sobre el formato de salida. ¿Puedes dar ejemplos de lo que es aceptable? Matriz de números? Cadena con números separados por espacios?
Luis Mendo
1
Su expresión regular permite la salida de mickey321211mouse. Realmente las \Dpartes no tienen razón para estar allí
edc65

Respuestas:

13

Jalea , 5 bytes

RRUVV

Pruébalo en línea!

Fórmula no mía.

Sospecho que están pasando muchas cosas aquí ...

[RESPUESTA ACEPTADA] Le habría dado unas 5 repeticiones a Dennis, pero este no es Reputation Exchange. Dennis me mostró el VVcomportamiento. Para mi sorpresa, esto es más corto que 05AB1E.

Erik el Outgolfer
fuente
¡Felicitaciones, este código tiene la menor cantidad de código!
devRicher
19

05AB1E , 6 bytes

L€LíJJ

Pruébalo en línea!

Explicación

Ejemplo de entrada 4

L       # range [1 ... input]
        # STACK: [1,2,3,4]
 €L     # map: range
        # STACK: [[1],[1,2],[1,2,3],[1,2,3,4]]
   í    # reverse each
        # STACK: [[1],[2,1],[3,2,1],[4,3,2,1]]
    J   # join inner lists
        # STACK: ['1','21','321','4321']
     J  # join list
        # OUTPUT: 1213214321
Emigna
fuente
13

JavaScript (ES6), 37 bytes

f=(n,k=1)=>k>n?n--?f(n):'':f(n,k+1)+k

Manifestación

Método alternativo para n <10, 34 bytes (no competidor)

f=(n,s='1')=>--n?s+f(n,++s[0]+s):s

En JavaScript, las cadenas son inmutables. Por lo tanto, es imposible alterar el contenido del enésimo carácter de una cadena sasignando un nuevo valor a s[N].

Sin embargo, la expresión ++s[N]es válida y se evalúa como cabría esperar, incluso si la cadena permanece sin cambios. Por ejemplo:

++"1"[0] // equals 2

Y por extensión:

s = "21"
++s[0] + s // equals "321"
Arnauld
fuente
No parece funcionar para n> 9
edc65
@ edc65 Tienes razón, por supuesto. No sé por qué pensé que estaba bien parar a las 9.
Arnauld
12

V, 29 28 27 23 19 17 16 bytes

8 bytes guardados gracias a @DJMcMayhem

3 bytes guardados gracias a @ nmjcman101

"apÀ­ñÄòy$jpkgJ

Personajes ocultos:

"apÀ<C-x>ñÄ<C-x>òy$jpkgJ

C-x es Ctrl + x.

Pruébalo en línea! toma entrada a través de argumentos de línea de comandos

Hexdump:

0000000: 2261 70c0 adf1 c418 f279 246a 706b 674a  "ap......y$jpkgJ

Explicación

"ap            Paste the argument
À<C-x>         Argument minus 1 times (so that we exclude the 0)
ñ ... ò        Loop (for some weird reason the ò closes the ñ)
Ä<C-x>         paste current line above and decrement it

Ahora se ve así:

1
2
...
n

continuado...

ò             recursively do (until a breaking error)
y$             yank this line
  jp           paste it down
    kgJ        go up and join
              implicit ò end

GIF (obsoleto)

(para arg 6)

gif

Kritixi Lithos
fuente
Obtuve algunos cambiando su bucle a a) final implícito yb) unir las líneas a medida que avanza (en lugar de al final)òy$jpkgJ
nmjcman101
@ nmjcman101 ¡Gracias por ayudarme a ahorrar 2 bytes!
Kritixi Lithos
Esto está bastante bien golfizado. Llevo 20 minutos mordiéndome el cerebro y no se me ocurre nada más corto. :)
DJMcMayhem
@DJMcMayhem Es porque he tenido una gran ayuda :)
Kritixi Lithos
¡Lo hice! Puede bajar a 16 bytes. Si pega el argumento, y luego duplica / decrementa hacia arriba, puede eliminar la H. Luego, si usa el operador de disminución en su À, no tendrá el 0 en la parte superior para que pueda eliminar la x. Luego, aparentemente ò, a cerrará a ­ñpara que pueda eliminar el segundo ­ñ(que es el byte que guarda). Enlace porque eso no tenía sentido
nmjcman101
11

C #, 72 69 65 bytes

n=>{for(int i=0,j;i<n;)for(j=++i;j>0;)System.Console.Write(j--);}

Si la salida puede ser devuelta en lugar de ser escrita en la consola

C #, 71 68 64 bytes

n=>{var s="";for(int i=0,j;i<n;)for(j=++i;j>0;)s+=j--;return s;}

Gracias a @VisualMelon por guardar muchos bytes

Pruébelo aquí (humildemente, el compilador en línea se rompe en cualquier número superior a 420)

Alfie Goodacre
fuente
Eso fue realmente rápido.
devRicher
@devRicher ¿Qué puedo decir? Estaba esperando que se publicara algo: P
Alfie Goodacre
2
Nunca hay una razón para usar un ciclo while en el golf de código C #, un ciclo for siempre funcionará tan bien, si no mejor. En este caso, puede incluir la asignación de j=1en el ciclo for y guardar un punto y coma. También puede declarar jjunto con i, para guardar el int. El i++también se puede mover a la j=iasignación, el ahorro de un byte. También deberías poder reemplazar el i<=ncon i<nsi lo haces j=++iy comienzas ien 0.
VisualMelon
@VisualMelon lo editó, ¡guardó 3 bytes! La declaración de los enteros juntos en realidad no hizo ninguna diferencia a la cuenta de bytes pero hace que los bucles se ven un poco más agradable
Alfie Goodacre
@AlfieGoodacre si los declaras juntos en el bucle for, entonces guardarás 2 bytes más for(int i=0,j;i<n;);) Tampoco hay necesidad de {}rodear el bucle for interno.
VisualMelon
8

Puro golpe, 34

eval eval printf %s \\{{1..$1}..1}

Dos niveles de expansión de férulas. Con entrada 6, el primer nivel se expande a {1..1} {2..1} {3..1} {4..1} {5..1} {6..1}. Esto luego se expande a 1 2 1 3 2 1 4 3 2 1 5 4 3 2 1 6 5 4 3 2 1, que se junta con una sola cadena printf %s. evalSe requieren en ambos niveles de expansión: para el primer nivel para que el $1parámetro se expanda primero, y para el segundo nivel para que se expanda después del primer nivel.

Pruébalo en línea

Trauma digital
fuente
8

Perl, 21 bytes

Usos -Esin costo adicional.

say map$}=$_.$},1..<>

Uso

perl -E 'say map$}=$_.$},1..<>' <<< 6
121321432154321654321
Dom Hastings
fuente
7

Pyth, 7 bytes

jks}R1S

Un programa que toma la entrada de un número entero e imprime el resultado.

Pruébalo en línea!

Cómo funciona

jks}R1S   Program. Input: Q
jks}R1SQ  Implicit input fill
    R     Map
      SQ  over [1, 2, 3, 4, ..., Q] with i:
   } 1     Yield [i, i-1, i-2, i-3, ..., 1]
  s       Merge
jk        Join
          Implicitly print
TheBikingViking
fuente
Personalmente estoy muy decepcionado de que jk_hC.:Ssea ​​más largo, ¡pero buen trabajo!
FryAmTheEggman
7

GeoGebra , 67 bytes

1
InputBox[a]
Sum[Join[Sequence[Sequence[Text[j],j,i,1,-1],i,1,a]]]

Cada línea se ingresa por separado en la barra de entrada. La entrada se toma de un cuadro de entrada.

Aquí hay un gif de la ejecución:

Ejecución del programa

Cómo funciona

Al ingresar 1implícitamente se asigna aa 1, y el InputBoxcomando asocia un cuadro de entrada con a. Luego, para cada ien {1, 2, 3, ..., a}, la lista {i, i-1, i-2, ..., 1}se ha creado usando el Sequencemando, y cada uno jen esa lista se convierte en una cadena utilizando Text. Finalmente, Joincombina todas las listas y Sumconcatena todos los elementos en un objeto de texto, que se muestra.

TheBikingViking
fuente
@devRicher Eso parece razonable. ¡Gracias!
TheBikingViking
7

Python 2, 51 bytes

r=s=''
n=0
exec'n+=1;s=`n`+s;r+=s;'*input()
print r
Mitch Schwartz
fuente
7

Retina , 26 22 bytes

El recuento de bytes asume la codificación ISO 8859-1.

.+
$*

$`¶
1
$.%'
0?¶

Pruébalo en línea!

Explicación

.+
$*

Convierta la entrada a unario.


$`¶

En cada posición, inserte el prefijo hasta ese punto, así como un salto de línea. Esto crea un rango unario de 2a n+1, un valor por línea.

1
$.%'

Reemplace cada uno 1con el número de caracteres después de él en la misma línea. Esto convierte algo así 11111en 43210.

0?¶

Elimine todos los avances de línea y los ceros que los preceden.

Martin Ender
fuente
5

GameMaker Language, 65 bytes

b=""for(i=1;i<=argument0;i++){c=i while(j)b+=string(c--)}return b
Timtech
fuente
5

APL, 10 bytes

∊⍕¨∘⌽∘⍳¨∘⍳

P.ej:

      (∊⍕¨∘⌽∘⍳¨∘⍳)6
121321432154321654321

Explicación:

  • : obtenga los números del 1 al N.
  • ⍳¨∘: para cada uno de ellos, obtenga los números del 1 al N.
  • ⌽∘: invertir esa lista
  • ⍕¨∘: obtiene la representación de caracteres de cada elemento (para que no muestre los números con espacios intermedios)
  • : aplanar la matriz resultante
marinus
fuente
Entonces, ¿está analizando el código al revés?
devRicher
es la composición de funciones, di la explicación en el orden que las funciones son en realidad evaluados
marinus
1
Aquí está el árbol de análisis, para los curiosos: tryapl.org/…
marinus
5

Python 2, 71 68 bytes

Apuesto a que una solución recursiva podría ser más corta, pero estoy teniendo dificultades para formularla.

n=input()
i=0
o=""
while i<n:
    i+=1;j=i
    while j:o+=`j`;j-=1
print o

Pruébalo en línea

mbomb007
fuente
5

En realidad 8 bytes

RR♂RΣRεj

Publicar una respuesta por primera vez en realidad, por lo que probablemente pueda jugar golf

Cómo funciona

Program takes implicit input, implicit print at EOF
R           Takes the input and creates a range (1, input)   
                STACK = [1,2,..,n]
 R          Reverse the top stack item (our range)
                STACK = [n,..,2,1]
  ♂R        For each item in our range, create a range (1, rangeitem)
                STACK = [[1,2,..,n], .., [1,2], [1]]
    Σ       Stitch the items of the list together
                STACK = [n,..,1,2,3,1,2,1]
     R      Reverse the top stack item again (our answer)
                STACK = [1,2,1,3,2,1,..n]
      εj    Create an empty string and append each item from the list to it.
            (turns non string items into strings)

Pruébalo en línea!

Pelícano verde azulado
fuente
1
No estoy seguro de que no es una solución más corto, pero me he demostrado a mí mismo mal antes. En cualquier caso, aquí hay un enlace Pruébelo en línea para su respuesta.
Sherlock9
1
El código R♂R♂RΣεjtiene el mismo número de bytes, pero puede ser más fácil escribir una explicación.
Sherlock9
@ Sherlock9 tu camino es un poco más elegante, agregué el enlace y una explicación que olvidé agregar ayer para tratar de explicarlo un poco más.
Teal pelican
4

Brachylog , 8 bytes

yb@[rcw\

Pruébalo en línea!

Explicación

yb         The list [1, ..., Input]
  @[       Take a prefix of that list
    rc     Reverse it and concatenate into an integer
      w    Write to STDOUT
       \   Backtrack: try another prefix
Fatalizar
fuente
4

Perl 6 , 22 bytes

{[~] flat [\R,] 1..$_}

Una lambda que devuelve una cadena.

( Pruébelo en línea )

Explicación:

  • 1..$_: Rango de enteros ... (1 2 3 4)
  • [,] 1..$_: Reducir ("doblar") sobre el operador de coma ... (1 2 3 4)
  • [\,] 1..$_: Con resultados intermedios ( reducción triangular ) ...((1) (1 2) (1 2 3) (1 2 3 4))
  • [\R,] 1..$_: Aplicar el metaoperador de inversión a la coma ...((1) (2 1) (3 2 1) (4 3 2 1))
  • [~] flat ...: Eliminar el anidamiento de la lista y doblar sobre el operador de cadena concat 1213214321
smls
fuente
4

Haskell, 35 bytes

f x=[1..x]>>= \y->[y,y-1..1]>>=show

Ejemplo de uso: f 6-> "121321432154321654321".

Para todos los números xen 1 ... xuna lista x,x-1, ... ,1, convierta los números en una cadena y concatenelos en una sola cadena. Nuevamente, concatene esas cadenas en una sola cadena.

nimi
fuente
4

C89, 54 bytes

i,j;f(n){for(i=1;j<=n;j=i++)while(j)printf("%d",j--);}

56 -2 = 54 gracias a ErikGolfer!

gato
fuente
Creo que puedes hacer en (j=i++)lugar de (j=i)y eliminar el último i++(no probado).
Erik the Outgolfer
Aquí hay una versión recursiva más corta: i,j;f(n){j=++i;while(j)printf("%d",j--);i-n?f(n):0;}(52 bytes)
Steadybox
@Steadybox Puede agregar eso como su propia respuesta si lo desea, ¡pero gracias!
gato
@cat Ok, gracias, acabo de hacerlo. No estaba seguro de si debería hacerlo, ya que solo edité su solución.
Steadybox
4

Python 3, 87 92 83 74 bytes

lambda n:"".join(["".join([str(i)for i in range(1,k)][::-1])for k in range(1,n+2)])

Respuesta más corta usando recursividad:

f=lambda n:f(n-1)+"".join([str(i)for i in range(1,n+1)][::-1])if n>0else""

¡Quizás no sea el más corto, pero solo está hecho con la comprensión de la lista de Python!

(Editado para agregar la función de impresión y eliminar el \ n)

(Editado para eliminar la función de impresión y cambiar n + 1, k + 1 a n, k + 2)

Sygmei
fuente
Funciona con k, n + 2 pero no con k + 2, n, aunque gracias por la idea :)
Sygmei
El código que estás anotando debería ser el primero. Además, debe usar Python 2 y luego usar en `i`lugar de str(i). Y puede usar en "".join(...)lugar de "".join([...]), y range(1,k,-1)para eliminar el [...][::-1].
mbomb007
Además, n>0puede ser n. Y quise decir range(n,0,-1). Y uso n and f(n-1)+...)or"".
mbomb007
1
62 bytes . En realidad, esto puede estar acercándose demasiado a esta respuesta .
mbomb007
Sí, esto se está acercando bastante, lo vi después de hacer mi segunda versión :(
Sygmei
3

Pyth, 8 bytes

jks_M._S

Explicación

jks_M._SQ   Implicit input
       SQ   Get the range [1, 2, ..., N]
     ._     Get each prefix
   _M       Reverse each prefix
jks         Join everything as a string
Mnemotécnico
fuente
3

Mathematica, 36 bytes

ToString/@(""<>Range[Range@#,1,-1])&

Lanza un montón de advertencias que pueden ignorarse de forma segura.

Explicación

Usando la entrada 5como ejemplo:

Range@#

Crea un rango {1, 2, 3, 4, 5}.

Range[...,1,-1]

Rangees listable para que podamos darle una lista de cualquiera de sus argumentos y automáticamente pasará ese argumento. Entonces esto nos da un montón de listas invertidas:

{{1}, {2, 1}, {3, 2, 1}, {4, 3, 2, 1}, {5, 4, 3, 2, 1}}

Próximo:

(""<>...)

Esto une la lista anidada con la cadena vacía. Dado que la lista anidada no contiene ninguna cadena, en realidad no puede unir los valores (que es donde se generan las advertencias), pero ""<>tiene el efecto secundario de aplanar la lista. Entonces esto nos da

1 <> 2 <> 1 <> 3 <> 2 <> 1 <> 4 <> 3 <> 2 <> 1 <> 5 <> 4 <> 3 <> 2 <> 1

Ahora viene la hermosa característica de Mathematica que Mapno le importa la estructura sobre la que está mapeando. Normalmente lo aplica a una lista, pero funciona con cualquier cabeza. f /@ h[a, b, c]simplemente te da h[f[a], f[b], f[c]]. En nuestro caso, la cabeza es StringJoiny los valores son los enteros.

ToString/@...

Entonces esto simplemente convierte los enteros en cadenas. En ese momento StringJoin[...]sabe qué hacer con ellos y los une a todos en una sola cadena:

"121321432154321"
Martin Ender
fuente
1
Eso es simplemente desagradable. :)
Greg Martin
3

GolfScript , 14 bytes

~,{),{)}%-1%}%

Pruébalo en línea!

Método habitual, por supuesto, pero este es GolfScript.

Explicación de este extenso código:

~,{),{)}%-1%}% # Code
               # Initial stack.      ["n"]
~              # Eval ToS.           [n]
 ,             # ToS' lowered range. [[0..n)]
  {),{)}%-1%}  # Block. 1 argument.  [a]
   )           # Increment.          [a+1]
    ,          # Range.              [[0..a)]
     {)}       # Block. 1 argument.  [b]
      )        # Increment.          [b+1]
        %      # Map.                [[1..a]]
         -1    # Integer. -1         [[1..a] -1]
           %   # Each nth element.   [[a..1]]
             % # Map.                [[[1],[2,1],...,[n..1]]]
               # Implicit output.    121...n..1

Tenga en cuenta que la salida es como un solo número. Arrastrando \n.

Erik el Outgolfer
fuente
3

R, 38 33 44 bytes

if((n=scan())>0)for(i in 1:n)cat(i:1,sep="")

Toma entrada a STDIN y realiza un bucle de 1 a n, creando la secuencia i a 1 para cada paso e imprimiéndola.

Editar: reemplazado seq(i,1)por i:1guardar 5 bytes y mostrar por qué no debería jugar golf durante las reuniones.

JAD
fuente
Esto produce 101si la entrada es 0. if((n=scan())>0)for(i in 1:n)cat(i:1,sep="")Hace el truco.
Frédéric
Maldición, supuesta entrada distinta de cero :(
JAD
if(n<-scan())Debería ser suficiente.
Giuseppe
3

MATL , 14 11 bytes

:"@:P]v!VXz

Pruébalo en línea!

Explicación

:      % Input N implicitly. Push range [1 2 ...N]
"      % For each k in [1 2 ...N]
  @:   %   Push range [1 2 ... k]
  P    %   Reverse
]      % End
v!     % Concatenate all arrays horizontally
V      % Convert to string
Xz     % Remove spaces. Display implicitly
Luis Mendo
fuente
not split up by anything, no creas que el segundo está permitido.
JAD
2
@JarkoDubbeldam Lo borraré hasta que OP lo aclare
Luis Mendo
1
@Jarko El OP aclaró. La solución actual se ajusta a las especificaciones
Luis Mendo
3

brainfuck, 17 bytes

>,[>[+.>]+.[<]>-]

Explicación

>           keep the first cell at 0
 ,          input of the decimal number into the cell
  [>        start a conditionnal loop and go to the next cell
   [+.>]    while it don't find 0, increment each cells and output the value
    +.      increment the new cell and output
     [<]    go to the first cell
      >-]   decrement the second cell and restart

Pruébalo en línea!

Milihhard
fuente
Bienvenido a PPCG! ¿Ya leíste la página del recorrido y las meta preguntas más populares? Te aconsejo que lo hagas, ¡son útiles! Además, envuelva su código en formato de código. ¿Has leído la ayuda de formato? ¡También debe explicar cómo funciona su código, si puede!
devRicher
@muddyfish Acabo de agregar la explicación
Milihhard
He usado una aplicación móvil. Puedes ver la pantalla del resultado.
Milihhard
No, esta bien. Pero en el enlace, la salida está en ascii y no en decimal, por lo que realmente no se ve la salida
Milihhard
@muddyfish Tu enlace permanente es un poco confuso. Hay un 0x06 invisible en la entrada, seguido del dígito decimal 6 .
Dennis
3

Python , 63 57 59 bytes

Una solución recursiva que funciona tanto en Python 2 como en 3. Probablemente se pueda jugar más. Sugerencias de golf bienvenidas! Pruébalo en línea!

Editar: -6 bytes gracias a Jonathan Allan. +2 bytes gracias a mbomb007 por señalar un problema con mi respuesta.

f=lambda n:n and f(n-1)+"".join(map(str,range(n,0,-1)))or""

Ungolfing

def f(n):
    s = ""
    for i in range(n+1):
        m = map(str, range(n, 0, -1))
        s += "".join(m)
    return s
Sherlock9
fuente
2
Use a mappara guardar 6 bytes:lambda n:n and f(n-1)+"".join(map(str,range(n,0,-1)))or""
Jonathan Allan
2

PHP, 35 34 33 bytes

Salvé un byte porque conté mal, ¡gracias Titus! ¡Y otro!

while($i++<$argv[1])echo$s=$i.$s;

Ejecutar desde la línea de comando con -r.

Respuesta bastante simple, recorre desde 1 hasta nuestra entrada n, pegando el número al comienzo de la cadena e imprimiéndolo.

Xanderhall
fuente
Cuento 34. Un byte más corto con post-incremento.
Titus
33 bytes:while($i++<$argv[1])echo$s=$i.$s;
aross
1

CJam, 13 bytes

ri,:){,:)W%}%

Interprete

Erik el Outgolfer
fuente
Puede guardar 2 bytes:ri{),:)W%}%
Luis Mendo
@LuisMendo Neat, ¡gracias por eso!
Erik the Outgolfer