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

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

Ganador

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

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.

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

JavaScript (ES6), 37 bytes

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

Manifestación

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

console.log(f(6))

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"

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)

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)

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

Perl, 21 bytes

Usos -Esin costo adicional.

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

Uso

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

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

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:

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.

Python 2, 51 bytes

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

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.

GameMaker Language, 65 bytes

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

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

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

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!

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

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

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.

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!

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)

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

05AB1E , 6 bytes

LR.sJJ

Pruébalo en línea!

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"

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.

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.

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

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!

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

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.

CJam, 13 bytes

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

Interprete