Sfida:

Qui abbiamo i primi 100 elementi di una sequenza:

6,5,4,3,2,1,66,65,64,63,62,61,56,55,54,53,52,51,46,45,44,43,42,41,36,35,34,33,32,31,26,25,24,23,22,21,16,15,14,13,12,11,666,665,664,663,662,661,656,655,654,653,652,651,646,645,644,643,642,641,636,635,634,633,632,631,626,625,624,623,622,621,616,615,614,613,612,611,566,565,564,563,562,561,556,555,554,553,552,551,546,545,544,543,542,541,536,535,534,533,...

Come si forma questa sequenza? Per prima cosa abbiamo il numero nell'intervallo [6, 1](tutti i possibili valori di un singolo dado dal più alto al più basso). Abbiamo quindi i numeri [66..61, 56..51, 46..41, 36..31, 26..21, 16..11](tutti i possibili valori concattati di due dadi dal più alto al più basso). Ecc.
Questo è correlato alla sequenza OEIS A057436: contiene solo le cifre da 1 a 6 , ma con tutti i numeri con uguale quantità di cifre ordinate all'indietro nella sequenza.

La sfida è scegliere una di queste tre opzioni per la tua funzione / programma con la sequenza sopra:

1. Prendi un input $n$ e genera l' $n$ -esimo valore di questa sequenza, dove può essere indicizzato 0 o indicizzato 1.
2. Prendi un input $n$ e visualizza i primi $n$ o $n+1$ valori di questa sequenza.
3. Emette i valori dalla sequenza indefinitamente.

Naturalmente, è possibile utilizzare qualsiasi formato di output ragionevole. Potrebbe essere come stringhe / numeri interi / decimali / ecc .; potrebbe essere un elenco (infinito) / array / stream / etc .; potrebbe essere emesso con spazio / virgola / newline / altro delimitatore su STDOUT; ecc. ecc. Indica quale I / O e quale opzione stai utilizzando nella tua risposta!

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard con regole I / O predefinite , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Sono vietate le scappatoie predefinite .
• Se possibile, aggiungi un link con un test per il tuo codice (ad es. TIO ).
• Inoltre, si consiglia vivamente di aggiungere una spiegazione per la risposta.

Ecco alcuni casi di test più grandi se scegli l'opzione 1:

n         0-indexed output    1-indexed output

500       5624                5625
750       4526                4531
1000      3432                3433
9329      11111               11112
9330      666666              11111
9331      666665              666666
10000     663632              663633
100000    6131232             6131233

Gelatina , 5 byte

ḃ6ạ7V

Provalo online!

Valore n-1 indicizzato.

Perl 6 , 24 23 byte

-1 byte grazie a nwellnhof

{.put;.[]X~(6...1)}...*

Provalo online!

Emette la sequenza infinitamente separata da spazi / newline. Oppure, per qualche byte in più possiamo avere un elenco infinito pigro in cui possiamo invece indicizzare.

Perl 6 , 27 byte

{flat {@=.[]X~(6...1)}...*}

Provalo online!

Spiegazione:

{                         }    # Anonymous code block
 flat                          # Return the flattened
                      ...*       # Infinite sequence
      {              }             # Defined as
         .[]                       # The previous element arrayified
            X~                     # Each concatenated with
              (6...1)              # All of 6 to 1
       @=                          # Arrayified

Python 2 , 39 38 34 byte

f=lambda n:n and-n%6+1+f(~-n/6)*10

Provalo online!

Emette 1 numero indicizzato

R , 43 byte

p='';repeat cat(p<-sapply(p,paste0,6:1),'')

Provalo online!

Stampa la sequenza indefinitamente

• -9 grazie a @Kirill L.

Bash, 31 byte

f()(x+={6..1};eval echo $x;f);f

TIO

aggiornamento dai commenti, l'ennesimo valore 1-indicizzato, + strumenti GNU + perl, 64 byte, 7 byte salvati grazie a @manatwork

dc<<<6o$1p|perl -pe 's/(.)0/($1-1).6/e?redo:s/0//'|tr 1-6 654321

64 byte

MATL , 11 byte

`6:P!V@Z^DT

Emette i valori indefinitamente.

Provalo online!

Spiegazione

`      % Do...while
  6:   %   Push [1 2 3 4 5 6]
  P    %   Flip: gives [6 5 4 3 2 1]
  !    %   Transpose: turns the row vector into a column vector
  V    %   Convert the number in each row to the corresponding char
  @    %   Push current iteration index, starting from 1
  Z^   %   Cartesian power. Gives a matrix where each row is a Cartesian tuple
  D    %   Display immediately
  T    %   Push true. This is used as loop condition, to give an infinite loop
       % End (implicit)

Haskell, 38 34 byte

Un infinito elenco di numeri:

d=[6,5..1]
l=d++[10*m+n|m<-l,n<-d]

Provalo online!

Due soluzioni precedenti che forniscono infiniti elenchi di stringhe, ciascuno con 38 byte:

[1..]>>=sequence.(`replicate`"654321")

Provalo online!

do n<-[1..];mapM id$[1..n]>>["654321"]

Provalo online!

JavaScript (ES6), 26 byte

$n$

f=n=>n--&&[f(n/6|0)]+6-n%6

Provalo online!

Haskell , 28 byte

l=(+).(10*)<$>0:l<*>[6,5..1]

Provalo online!

Produce un elenco infinito di numeri l. Utilizzo <$>e <*>interruzione di un byte:

29 byte

l=[10*n+d|n<-0:l,d<-[6,5..1]]

Provalo online!

L'approccio è simile alla risposta Haskell Output All String all'Haskell stringa di input fissa "654321" e salta l'output della stringa vuota modificando la posizione in cui è stata anteposta.

30 byte

l=[n++[d]|n<-"":l,d<-"654321"]

Provalo online!

05AB1E , 10 byte

Emette la sequenza indefinitamente.

¸[6LRâJD»,

Provalo online!

Spiegazione

¸           # initialize the stack with a list containing the empty string
 [          # loop
  6L        # push [1 ... 6]
    R       # reverse
     â      # cartesian product
      J     # join each inner list
       D    # duplicate (saving a copy for next iteration)
        »,  # join on newline and print

Perl 5, 40 37 byte

-3 byte grazie a @Xcali

map{say}<"$_">while s//{6,5,4,3,2,1}/

37 byte

40 byte

Java (JDK) , 48 byte

String f(int n){return n-->0?f(n/6)+(6-n%6):"";}

Provalo online!

Ciò restituisce il 1-indicizzati n ^esimo elemento.

La ricorsione sembra battere la lambda iterativa.

Versione iterativa, 49 byte

n->{var r="";for(;n-->0;n/=6)r=6-n%6+r;return r;}

Provalo online!

Brachylog , 13 11 byte

Grazie a Fatalize per 2 byte

6~d{⟧₁∋}ᵐẉ⊥

Uscite indefinitamente. Provalo online!

$n$

Spiegazione

6~d           Start with a number, all of whose digits are 6's
              Brachylog considers these in the order 6, 66, 666, 6666...
   {   }ᵐ     Map this predicate to each of those digits:
    ⟧₁         1-based reverse range: [6,5,4,3,2,1]
      ∋        The output digit must be a number in that range
              Brachylog considers possible outputs in this order: 6, 5, 4, 3, 2, 1, 66, 65...
         ẉ    Write a possible output with newline
          ⊥   Force the predicate to fail and backtrack to the next possibility

C # (.NET Core) , 38 byte

int f(int n)=>n-->0?f(n/6)*10+6-n%6:0;

Provalo online!

Emette l'n-esimo valore (basato su 1).

Japt, 14 byte

Deve esserci una soluzione più breve usando i metodi di funzione e / o il prodotto cartesiano ma (per ora?) Il meglio che posso gestire è una porta della soluzione JS di Arnauld, quindi assicurati di votare anche lui.

©ß´Uz6)s+6-Uu6

Provalo o prova i termini0-1000

Wolfram Language (Mathematica) , 88 78 byte

(l=d=c=7-Range@6;While[Length@c<#,d=Flatten[(10#+l)&/@d];c=c~Join~d;];c[[#]])&

Provalo online!

risparmiato 4 + 6 byte grazie a @IanMiller

L'elenco è 1 indicizzato, genera l'ennesimo numero.

Mathematica, 56 byte

Flatten[FromDigits/@Tuples[7-Range@6,#]&/@Range@#][[#]]&

$\frac{6}{5}(6^n-1)$

Pip -l , 16 byte

x:YP6-,6W1PxCP:y

Emette la sequenza indefinitamente. Provalo online!

Spiegazione

La -lbandiera indica che gli elenchi vengono stampati con ciascun elemento sulla propria riga; se un elemento è esso stesso un elenco, i suoi elementi sono concatenati senza separatore. Ad esempio, l'elenco [1 [2 3] [4 [5 6]]]verrà stampato come

1
23
456

Con quello chiarito:

x:YP6-,6W1PxCP:y
      ,6          Range(6): [0 1 2 3 4 5]
    6-            Subtract each element from 6: [6 5 4 3 2 1]
  YP              Yank that value into the y variable, and also print it
x:                Assign that value also to x
        W1        While 1 (infinite loop):
           xCP:    Assign to x the cartesian product of x with
               y   the list [6 5 4 3 2 1]
          P        Print it

Dopo la prima iterazione del loop, xappare come [[6;6];[6;5];[6;4];...;[1;1]]; dopo la seconda iterazione [[[6;6];6];[[6;6];5];[[6;6];4];...;[[1;1];1]],; e così via. Non dobbiamo preoccuparci di appiattire le liste, perché -llo fa efficacemente per noi.

Carbone , 18 byte

ＮθＷθ«←Ｉ⊕﹪±θ⁶≔÷⊖θ⁶θ

Provalo online! Il collegamento è alla versione dettagliata del codice. 1-indicizzati. Spiegazione:

Ｎθ

Ingresso n

Ｗθ«

Ripeti fino a nzero.

←Ｉ⊕﹪±θ⁶

Ridurre il -nmodulo 6, quindi incrementare il risultato e l'output da destra a sinistra.

≔÷⊖θ⁶θ

Decremento ne numero intero lo dividono per 6.

Retina 0.8.2 , 36 byte

.+
$*_
+`(_*)\1{5}(_+)
$1$.2
T`7-1`d

Provalo online!Il link include casi di test. 1-indicizzati. Spiegazione:

.+
$*_

Converti in unario. (Retina 1 risparmierebbe 2 byte qui.)

+`(_*)\1{5}(_+)
$1$.2

Converti in base biiettiva 6 con ripetuti divmod. Si noti che l'uso di +significa che la cifra estratta è sempre un numero compreso tra 1 e 6 invece di 0 a 5 per la normale conversione di base 6. ((_{6})* è più veloce ma costa byte estraendo il quoziente.)

T`7-1`d

Trasponi le cifre in modo che i 6 vengano prima e gli ultimi 1. (Non ci sono 7 o 0 ma questo mi permette di usare il dcollegamento.

Cubix , 22 byte

Questo produrrà la sequenza indefinitamente. L'idea generale è che ha un numero base a cui viene aggiunto 6 - 1. Per ogni aggiunta, il risultato viene moltiplicato per 10, che viene spinto in fondo alla pila per essere usato più avanti nella sequenza. La base viene quindi estratta e inizia la base successiva.

..w.06+ONo*w;|uW!(pq;;

Provalo online!

    . .
    w .
0 6 + O N o * w
; | u W ! ( p q
    ; ;
    . .

Guardalo correre

C # (.NET Core) , stampa infinita, 181 180 88 byte.

string[] s=new string[]{" "},t;int i,j,k,l=1;while(true){j=l;t=new string[l=6*j];for(i=6;i>0;i--)for(k=(6-i)*j;k<l;)t[k]=i+s[k++%j];
for(k=0;k<l;)System.Console.Write(t[k++]);s=t;}

Purtroppo blocca repl.it invece di emettere correttamente nella versione infinita scritta (credo che sia un errore in repl.it, in quanto non viene emesso come il programma scorre come dovrebbe), quindi chiunque spera di testare ha bisogno di un computer. Se aggiungi una lettura all'inizio del ciclo, funziona anche in repl.it.

Uscite alla console, ovviamente.

Su qualsiasi sistema finito, molto probabilmente il codice finirà per bloccarsi con un errore di memoria esaurita.

Rielaborato il codice per usare la lambda di @dana.

int f(int n)=>n-->0?f(n/6)*10+6-n%6:0;for(int i=0;++i>0;)System.Console.Write(f(i)+" ");

Provalo online!

Forth (gforth) , 63 byte

: f recursive dup 6 < if 6 - abs 1 .r else 6 /mod 1- f f then ;

Provalo online!

0-indexed output enth value

Spiegazione

Se N è inferiore a 6, genera il valore assoluto di N - 6. Altrimenti, ottieni il quoziente e il resto della divisione di N per 6. Chiama la funzione ricorsivamente sul quoziente, quindi chiamala sul resto.

Spiegazione del codice

: f                 \ start a new word definition
  recursive         \ declare that this word is recursive so we can call it from itself
  dup 6 <           \ check if n is less than 6
  if                \ if it is:
    6 - abs 1 .r    \ subtract 6, get the absolute value, then print with no appended space
  else              \ else if it's greater than 6:
    6 /mod          \ get the quotient and remainder of dividing n by 6
    1-              \ subtract 1 from the quotient (because we're 0-indexed)
    f               \ call f on the result
    f               \ call f on the remainder (shortcut to format and print, it's always < 6)
  then              \ end the if/else
;                   \ end the word definition

APL (NARS), 27 caratteri, 54 byte

{0>⍵-←1:0⋄(6-6∣⍵)+10×∇⌊⍵÷6}

traslate la soluzione di dana /codegolf//a/179980 in APL ... test:

  f←{0>⍵-←1:0⋄(6-6∣⍵)+10×∇⌊⍵÷6}
  f 500
5625
  f¨750 1000 9329 9331 10000 100000
4531 3433 11112 666666 663633 6131233 
  f¨⍳9
6 5 4 3 2 1 66 65 64 

C #, stampa dall'inizio alla n, ??? byte

Ringraziamo @dana per l'espressione lambda.

int f(int n)=>n-->0?f(n/6)*10+6-n%6:0;for(int i=0;i<int.Parse(a[0]);)System.Console.Write(f(++i)+" ");

Operazione: eseguire con riga di comando 0 ° argomento uguale all'intero che si desidera contare. (Va notato che a[0]è un riferimento all'array args della riga di comando altrimenti non menzionato e non so come contarlo.)