Output interi in ordine negativo, aumenta ogni volta il numero intero massimo


44

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
Nota a margine : questo è A004736 nell'OEIS. Inoltre, il primo esempio (con le nuove righe) è un output non valido, come specificato nelle regole.

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

Grazie @Emigna, ho usato il suo algoritmo per calcolare questi casi di test.

Vincitore

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


The output must be a full number ...Intendi l'intera sequenza o solo le diverse sottostringhe (1, 2-1, 3-1 ...)? Il tuo primo esempio non sembra corrispondere a questa affermazione.
Steenbergh,

1
Se l'output deve essere un singolo numero, come può essere "array"?
smls

Questo array sarebbe accettabile come output? [1, 21, 321, 4321, 54321, 654321] Che ne dici di questo? [1,2,1,3,2,1,4,3,2,1,5,4,3,2,1,6,5,4,3,2,1] Oppure stai solo parlando di array con un singolo elemento, come [121321432154321654321]?
smls

1
Sono confuso sul formato di output. Puoi fornire esempi di ciò che è accettabile? Matrice di numeri? Stringa con numeri separati da spazi?
Luis Mendo,

1
Il tuo regex consente l'output di mickey321211mouse. Davvero le \Dparti non hanno motivo di essere lì
edc65

Risposte:


13

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.


Congratulazioni, questo codice ha il minor numero di codice!
devRicher,

19

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

13

JavaScript (ES6), 37 byte

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

dimostrazione

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"

Non sembra funzionare per n> 9
edc65

@ edc65 Hai ragione, ovviamente. Non so perché pensavo fosse giusto fermarsi alle 9.
Arnauld,

12

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)

gif


Ne ho ottenuti alcuni cambiando il ciclo in a) fine implicitamente eb) unendo le linee come va (piuttosto che alla fine)òy$jpkgJ
nmjcman101

@ nmjcman101 Grazie per avermi aiutato a salvare 2 byte!
Kritixi Lithos,

Questo è abbastanza ben giocato. Mi sono distrutto il cervello per 20 minuti buoni e non riesco a pensare a niente di più corto. :)
DJMcMayhem

@DJMcMayhem È perché ho avuto un grande aiuto :)
Kritixi Lithos

L'ho fatto! È possibile ottenere fino a 16 byte. Se si incolla arg, quindi si duplica / decrementa verso l'alto, si rimuove la H. Quindi, se si utilizza l'operatore di decremento sul proprio À, non si avrà lo 0 in alto in modo da poter rimuovere la x. Quindi APPARENTAMENTE a òchiuderà a in ­ñmodo da poter rimuovere il secondo ­ñ(che è il byte salvato). Link perché non aveva senso
nmjcman101

11

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)


È stato davvero veloce.
devRicher,

@devRicher Cosa posso dire, stavo aspettando che qualcosa fosse pubblicato: P
Alfie Goodacre,

2
Non c'è mai motivo di usare un ciclo while nel golf in codice C #, un for-loop funzionerà sempre anche se non meglio. In questo caso, puoi includere l'assegnazione di j=1nel ciclo for e salvare un punto e virgola. Puoi anche dichiarare jinsieme a i, per salvare il file int. Il i++può anche essere spostato j=isull'assegnazione, salvando un byte. Dovresti anche essere in grado di sostituire il i<=ncon i<nse lo fai j=++iinvece e inizi ia 0.
VisualMelon,

@VisualMelon lo ha modificato, salvato 3 byte! Dichiarare gli interi insieme in realtà non ha fatto alcuna differenza per il conteggio dei byte, ma rende i loop un po 'più belli
Alfie Goodacre,

@AlfieGoodacre se li dichiarate insieme nel ciclo for, quindi risparmierete altri 2 byte for(int i=0,j;i<n;);) Inoltre non è necessario il {}ciclo around interno.
VisualMelon

8

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


8

Perl, 21 byte

Utilizza -Esenza costi aggiuntivi.

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

uso

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

7

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

Personalmente sono molto deluso dal fatto che jk_hC.:Ssia più lungo, ma un bel lavoro!
FryAmTheEggman,

7

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:

Esecuzione del programma

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.


@devRicher Sembra ragionevole. Grazie!
TheBikingViking


7

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.


5

Lingua GameMaker, 65 byte

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

5

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

Quindi sta analizzando il codice al contrario?
devRicher,

è la composizione delle funzioni, ho dato la spiegazione nell'ordine in cui le funzioni sono effettivamente valutate
Marin

1
Ecco l'albero di analisi, per i curiosi: tryapl.org/…
marinus

5

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


5

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!


1
Io non sono sicuro che ci sia una soluzione più breve, ma ho dimostrato me sbagliato prima. In ogni caso, ecco un link Provalo online per la tua risposta.
Sherlock9

1
Il codice ha R♂R♂RΣεjlo stesso numero di byte, ma potrebbe essere più semplice scrivere una spiegazione per.
Sherlock9

@ Sherlock9 la tua strada è un po 'più elegante, ho aggiunto il link e una spiegazione che ho dimenticato di aggiungere ieri per provare a spiegarlo un po' di più.
Pellicano verde acqua

4

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

4

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

4

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.


4

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!


Penso che tu possa fare (j=i++)invece di (j=i)rimuovere l'ultimo i++(non testato).
Erik the Outgolfer,

Ecco una versione ricorsiva più breve: i,j;f(n){j=++i;while(j)printf("%d",j--);i-n?f(n):0;}(52 byte)
Steadybox

@Steadybox Se lo desideri, puoi aggiungerlo come risposta personale, ma grazie!
cat

@cat Ok, grazie, l'ho appena fatto. Non ero sicuro che avrei dovuto poiché ho modificato solo la tua soluzione.
Steadybox,

4

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)


Funziona con k, n + 2 ma non con k + 2, n, grazie comunque per l'idea :)
Sygmei

Il codice che stai segnando dovrebbe essere il primo. Inoltre, dovresti usare Python 2 e poi usare `i`invece di str(i). E puoi usare "".join(...)invece di "".join([...]), e range(1,k,-1)per rimuovere il [...][::-1].
mbomb007,

Inoltre, n>0può essere n. E intendevo range(n,0,-1). E usare n and f(n-1)+...)or"".
mbomb007,

1
62 byte . In realtà, questo potrebbe avvicinarsi troppo a questa risposta .
mbomb007,

Sì, questo si sta avvicinando molto, ho visto che dopo aver fatto la mia seconda versione :(
Sygmei

3

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


3

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"

1
È semplicemente brutto. :)
Greg Martin,

3

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.


3

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.


Questo produce 101se l'ingresso è 0. if((n=scan())>0)for(i in 1:n)cat(i:1,sep="")fa il trucco.
Frédéric,

Dannazione, si supponeva un input diverso da zero :(
JAD

if(n<-scan())dovrebbe essere sufficiente.
Giuseppe,

3

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

not split up by anything, non pensare che il secondo sia permesso.
JAD

2
@JarkoDubbeldam Lo eliminerò fino a quando OP non chiarirà
Luis Mendo il

1
@Jarko L'OP chiarito. La soluzione attuale è conforme alle specifiche
Luis Mendo,

3

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!


Benvenuti in PPCG! Hai già letto la pagina del tour e le meta domande più interessanti? Ti consiglio di, sono utili! Inoltre, avvolgi il tuo codice nella formattazione del codice! Hai letto l'aiuto per la formattazione? Dovresti anche spiegare come funziona il tuo codice, se puoi!
DevRicher,

@muddyfish Ho appena aggiunto la spiegazione
Milihhard il

Ho usato un'app mobile. Puoi vedere lo schermo del risultato.
Milihhard,

No, va bene. Ma nel link, l'output è in ascii e non in decimale, quindi non vedi davvero l'output
Milihhard,

@muddyfish Il tuo permalink è un po 'confuso. C'è un 0x06 invisibile nell'input, seguito dalla cifra decimale 6 .
Dennis,

3

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

2
Utilizzare a mapper salvare 6 byte:lambda n:n and f(n-1)+"".join(map(str,range(n,0,-1)))or""
Jonathan Allan il

2

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.


Conto 34. Un byte più corto con postincremento.
Tito

33 byte:while($i++<$argv[1])echo$s=$i.$s;
circa il

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.