Compito principale

Il tuo compito è quello di stampare numeri interi in ordine decrescente, a partire da 1, e aumentando mentre continui a colpire di nuovo 1, fino a quando non viene raggiunto l'input dato, quindi, stampa il resto fino a quando non premi di nuovo 1. Esempio con input 6:

1
21
321
4321
54321
654321
Without newlines (valid output):
121321432154321654321

Ingresso

Il tuo codice può assumere qualsiasi tipo di input (grafico, STDIN) sotto forma di un numero intero o numero.

Produzione

Il codice dovrebbe generare la sequenza sopra descritta, fino al raggiungimento del numero di input, quindi terminare di produrre fino a raggiungere nuovamente 1. L'output può essere qualsiasi cosa, quindi numeri, stringhe, numeri interi o output grafico. È necessario stampare un singolo numero (nessuna nuova riga se è una stringa). L'output può essere inserito e prodotto con tutti i caratteri necessari (ad es [].).

Dato che ci sono stati dei malintesi, ecco un modello regex su cui puoi provare i tuoi output.

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

Regole

• L'output deve essere un numero intero, non diviso per nulla, nemmeno per le nuove righe.
• L'algoritmo non dovrebbe verificare la prima istanza di N che appare in alcun modo (ad es. 21In 121321), ma piuttosto la prima istanza di N come numero effettivo.
• È consentita una singola riga finale finale.
• La gestione degli input negativi è una tua scelta, i numeri negativi non sono casi che dovresti testare.

Casi test

Input: 6
Output: 121321432154321654321


Input: 1
Output: 1

Input: 26
Output: 121321432154321654321765432187654321987654321109876543211110987654321121110987654321131211109876543211413121110987654321151413121110987654321161514131211109876543211716151413121110987654321181716151413121110987654321191817161514131211109876543212019181716151413121110987654321212019181716151413121110987654321222120191817161514131211109876543212322212019181716151413121110987654321242322212019181716151413121110987654321252423222120191817161514131211109876543212625242322212019181716151413121110987654321

Input: 0
Output: 0, Empty, or Error

Input: 21
Output: 121321432154321654321765432187654321987654321109876543211110987654321121110987654321131211109876543211413121110987654321151413121110987654321161514131211109876543211716151413121110987654321181716151413121110987654321191817161514131211109876543212019181716151413121110987654321212019181716151413121110987654321

Vincitore

Il vincitore è stato scelto! Era la risposta di ErikGolfer con ben 5 byte! Congratulazioni!

Gelatina , 5 byte

RRUVV

Provalo online!

Formula non mia.

Ho il sospetto che ci sia troppo da fare qui ...

[RISPOSTA ACCETTATA] Avrei dato 5 rappresentanti a Dennis, ma non si tratta di scambio di reputazione. Dennis mi ha mostrato il VVcomportamento. Con mia sorpresa, questo è più corto di 05AB1E.

05AB1E , 6 byte

L€LíJJ

Provalo online!

Spiegazione

Esempio di input 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 byte

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

dimostrazione

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

console.log(f(6))

Metodo alternativo per n <10, 34 byte (non concorrenti)

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

In JavaScript, le stringhe sono immutabili. Pertanto, è impossibile modificare il contenuto dell'ennesimo carattere di una stringa sassegnando un nuovo valore a s[N].

Tuttavia, l'espressione ++s[N]è valida e valuta come ci si aspetterebbe, anche se la stringa rimane invariata. Per esempio:

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

E per estensione:

s = "21"
++s[0] + s // equals "321"

V, 29 28 27 23 19 17 16 byte

8 byte salvati grazie a @DJMcMayhem

3 byte salvati grazie a @ nmjcman101

"apÀ­ñÄòy$jpkgJ

Personaggi nascosti:

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

C-x è Ctrl + x.

Provalo online! accetta input tramite argomenti della riga di comando

hexdump:

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

Spiegazione

"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

Ora sembra che:

1
2
...
n

continua ...

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

GIF (obsoleto)

(per arg 6)

C #, 72 69 65 byte

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

Se l'output può essere semplicemente restituito anziché essere scritto sulla console

C #, 71 68 64 byte

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

Grazie a @VisualMelon per aver salvato molti byte

Provatelo qui (Humourously le pause del compilatore on-line in qualsiasi numero sopra 420)

Bash puro, 34

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

Due livelli di espansione del tutore. Con l'input 6, il primo livello si espande a {1..1} {2..1} {3..1} {4..1} {5..1} {6..1}. Questo quindi si espande in 1 2 1 3 2 1 4 3 2 1 5 4 3 2 1 6 5 4 3 2 1, che viene confuso in una stringa con printf %s. evalsono richiesti ad entrambi i livelli di espansione - per il primo livello in modo che il $1parametro sia espanso per primo, e per il secondo livello in modo che si espanda dopo il primo livello.

Provalo online

Perl, 21 byte

Utilizza -Esenza costi aggiuntivi.

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

uso

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

Pyth, 7 byte

jks}R1S

Un programma che accetta l'input di un numero intero e stampa il risultato.

Provalo online!

Come funziona

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 byte

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

Ogni riga viene inserita separatamente nella barra di input. L'input viene prelevato da una casella di input.

Ecco una gif dell'esecuzione:

Come funziona

L'immissione 1implicitamente assegna aa 1e il InputBoxcomando associa una casella di input a a. Quindi, per ciascuno iin {1, 2, 3, ..., a}, l'elenco {i, i-1, i-2, ..., 1}viene creato utilizzando il Sequencecomando e ciascuno jin tale elenco viene convertito in una stringa utilizzando Text. Infine, Joinunisce tutti gli elenchi e Sumconcatena tutti gli elementi in un oggetto di testo, che viene visualizzato.

Python 2, 51 byte

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

Retina , 26 22 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

.+
$*

$`¶
1
$.%'
0?¶

Provalo online!

Spiegazione

.+
$*

Converti input in unario.

$`¶

In ogni posizione, inserire il prefisso fino a quel punto, nonché un avanzamento riga. Questo crea un intervallo unario da 2a n+1, un valore per riga.

1
$.%'

Sostituisci ciascuno 1con il numero di caratteri dopo averlo sulla stessa riga. Questo trasforma qualcosa del genere 11111in 43210.

0?¶

Rimuovere tutti i feed di linea e gli zeri che li precedono.

Lingua GameMaker, 65 byte

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

APL, 10 byte

∊⍕¨∘⌽∘⍳¨∘⍳

Per esempio:

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

Spiegazione:

• ⍳: ottieni i numeri da 1 a N.
• ⍳¨∘: per ognuno di questi, ottieni i numeri da 1 a N.
• ⌽∘: inverti quella lista
• ⍕¨∘: ottiene la rappresentazione dei caratteri di ciascun elemento (quindi non genera i numeri con spazi in mezzo)
• ∊: appiattisce l'array risultante

Python 2, 71 68 byte

Scommetto che una soluzione ricorsiva potrebbe essere più breve, ma ho difficoltà a formularla in una.

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

Provalo online

In realtà 8 byte

RR♂RΣRεj

Pubblicare una risposta per la prima volta in realtà, quindi probabilmente può essere giocato a golf.

Come funziona

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)

Provalo online!

Brachylog , 8 byte

yb@[rcw\

Provalo online!

Spiegazione

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 byte

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

Un lambda che restituisce una stringa.

( Provalo online. )

Spiegazione:

• 1..$_: Intervallo di numeri interi ... (1 2 3 4)
• [,] 1..$_: Riduci ("piega") sull'operatore virgola ... (1 2 3 4)
• [\,] 1..$_: Con risultati intermedi ( riduzione triangolare ) ...((1) (1 2) (1 2 3) (1 2 3 4))
• [\R,] 1..$_: Applicare inversione meta-operatore per la virgola ...((1) (2 1) (3 2 1) (4 3 2 1))
• [~] flat ...: Rimuove l'annidamento dell'elenco e piega l'operatore concat stringa ... 1213214321

Haskell, 35 byte

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

Esempio di utilizzo: f 6-> "121321432154321654321".

Per tutti i numeri xin 1 ... xun elenco x,x-1, ... ,1, trasforma i numeri in una stringa e concatenali in una singola stringa. Ancora una volta, concatena quelle stringhe in una singola stringa.

C89, 54 byte

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

56 -2 = 54 grazie a ErikGolfer!

Python 3, 87 92 83 74 byte

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

Risposta più breve usando la ricorsione:

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

Forse non il più breve ma è realizzato solo con la comprensione dell'elenco di Python!

(Modificato per aggiungere la funzione di stampa e rimuovere il \ n)

(Modificato per rimuovere la funzione di stampa e modificare n + 1, k + 1 in n, k + 2)

Pyth, 8 byte

jks_M._S

Spiegazione

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 byte

LR.sJJ

Provalo online!

Mathematica, 36 byte

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

Emette un sacco di avvertimenti che possono essere tranquillamente ignorati.

Spiegazione

Utilizzo dell'input 5come esempio:

Range@#

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

Range[...,1,-1]

Rangeè elencabile in modo che possiamo fornirgli un elenco per tutti i suoi argomenti e passerà automaticamente su quell'argomento. Quindi questo ci dà un sacco di elenchi invertiti:

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

Il prossimo:

(""<>...)

Ciò unisce l'elenco nidificato con la stringa vuota. Poiché l'elenco nidificato in realtà non contiene stringhe, non può davvero unire i valori (che è dove vengono generati gli avvisi), ma ""<>ha l'effetto collaterale di appiattire l'elenco. Quindi questo ci dà

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

Ora arriva la bella funzionalità di Mathematica che Mapnon si preoccupa della struttura su cui sta mappando. Normalmente lo applichi a un elenco, ma funziona con qualsiasi testa. f /@ h[a, b, c]ti dà semplicemente h[f[a], f[b], f[c]]. Nel nostro caso, la testa è StringJoine i valori sono i numeri interi.

ToString/@...

Quindi questo trasforma semplicemente gli interi in stringhe. A quel punto StringJoin[...]sa cosa fare con loro e li unisce tutti in un'unica stringa:

"121321432154321"

GolfScript , 14 byte

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

Provalo online!

Metodo usuale ovviamente, ma questo è GolfScript.

Spiegazione per questo codice VAST :

~,{),{)}%-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

Si noti che l'output è come un singolo numero. Trailing \n.

R, 38 33 44 byte

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

Riceve input su STDIN e esegue il loop da 1 a n, creando la sequenza da i a 1 per ogni passaggio e stampandola.

Edit: sostituito seq(i,1)dal i:1risparmio di 5 byte e mostrando il motivo per cui non dovrei a golf durante le riunioni.

MATL , 14 11 byte

:"@:P]v!VXz

Provalo online!

Spiegazione

:      % 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 byte

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

Spiegazione

>           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

Provalo online!

Python , 63 57 59 byte

Una soluzione ricorsiva che funziona in Python 2 e 3. Probabilmente questo può essere ulteriormente approfondito. Suggerimenti di golf benvenuti! Provalo online!

Modifica: -6 byte grazie a Jonathan Allan. +2 byte grazie a mbomb007 per aver segnalato un problema con la mia risposta.

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 byte

Ho salvato un byte perché ho sbagliato il conto, grazie Tito! E un altro!

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

Esegui dalla riga di comando con -r.

Risposta piuttosto semplice, passa da 1 attraverso il nostro input n, virando il numero all'inizio della stringa e stampandolo.

CJam, 13 byte

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

interprete