Desafío:

Aquí tenemos los primeros 100 elementos de una secuencia:

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,...

¿Cómo se forma esta secuencia? Primero tenemos el número en el rango [6, 1](todos los valores posibles de un solo dado de mayor a menor). Luego tenemos los números [66..61, 56..51, 46..41, 36..31, 26..21, 16..11](todos los valores posibles de dos dados de mayor a menor). Etc.
Esto está relacionado con la secuencia OEIS A057436: contiene solo los dígitos del 1 al 6 , pero con todos los números con la misma cantidad de dígitos ordenados hacia atrás en la secuencia.

El desafío es elegir una de estas tres opciones para su función / programa con la secuencia anterior:

1. Tome una entrada y la salida de la -ésimo valor de esta secuencia, en donde puede ser 0-indexada o 1-indexado.$n$$n$
2. Tome una entrada y envíe los primeros valores o de esta secuencia.$n$$n$$n+1$
3. Salida de los valores de la secuencia indefinidamente.

Por supuesto, se puede usar cualquier formato de salida razonable. Podría ser como cadenas / enteros / decimales / etc .; podría ser como una lista (infinita) / array / stream / etc .; podría salir con espacio / coma / nueva línea / otro delimitador a STDOUT; etc. etc. ¡ Indique qué E / S y qué opción está utilizando en su respuesta!

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de código. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Las reglas estándar se aplican a su respuesta con las reglas de E / S predeterminadas , por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código (es decir, TIO ).
• Además, se recomienda agregar una explicación para su respuesta.

Aquí algunos casos de prueba más grandes si elige la opción 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

Jalea , 5 bytes

ḃ6ạ7V

Pruébalo en línea!

Enésimo valor indexado.

Perl 6 , 24 23 bytes

-1 byte gracias a nwellnhof

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

Pruébalo en línea!

Emite la secuencia infinitamente separada por espacios / líneas nuevas. O, para unos pocos bytes más, podemos tener una lista infinita perezosa en la que podemos indexar.

Perl 6 , 27 bytes

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

Pruébalo en línea!

Explicación:

{                         }    # 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 bytes

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

Pruébalo en línea!

Salidas 1 número indexado

R , 43 bytes

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

Pruébalo en línea!

Imprime la secuencia indefinidamente

• -9 gracias a @Kirill L.

Bash, 31 bytes

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

TIO

actualización de los comentarios, el enésimo valor 1 indexado, + herramientas GNU + perl, 64 bytes, 7 bytes guardados gracias a @manatwork

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

64 bytes

MATL , 11 bytes

`6:P!V@Z^DT

Emite los valores indefinidamente.

Pruébalo en línea!

Explicación

`      % 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 bytes

Una lista infinita de números:

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

Pruébalo en línea!

Dos soluciones anteriores que dan listas infinitas de cadenas, cada una con 38 bytes:

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

Pruébalo en línea!

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

Pruébalo en línea!

JavaScript (ES6), 26 bytes

$n$

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

Pruébalo en línea!

Haskell , 28 bytes

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

Pruébalo en línea!

Produce una lista infinita de números l. Usando <$>y <*>corta un byte:

29 bytes

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

Pruébalo en línea!

El enfoque es similar a la cadena de entrada fija de respuesta de Haskell Output All String "654321", y omite la salida de cadena vacía cambiando dónde está antepuesta.

30 bytes

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

Pruébalo en línea!

05AB1E , 10 bytes

Emite la secuencia indefinidamente.

¸[6LRâJD»,

Pruébalo en línea!

Explicación

¸           # 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 bytes

-3bytes gracias a @Xcali

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

37 bytes

40 bytes

Java (JDK) , 48 bytes

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

Pruébalo en línea!

Esto devuelve el 1-indexadas n ^º elemento.

La recursión parece vencer a la lambda iterativa.

Versión iterativa, 49 bytes.

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

Pruébalo en línea!

Brachylog , 13 11 bytes

Gracias a Fatalize por 2 bytes

6~d{⟧₁∋}ᵐẉ⊥

Salidas indefinidamente. Pruébalo en línea!

$n$

Explicación

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 bytes

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

Pruébalo en línea!

Emite el enésimo valor (basado en 1).

Japt, 14 bytes

Debe haber una solución más corta utilizando métodos de función y / o producto cartesiano, pero (¿por ahora?) Lo mejor que puedo administrar es un puerto de la solución JS de Arnauld, así que asegúrese de votarlo también.

©ß´Uz6)s+6-Uu6

Pruébalo o prueba los términos0-1000

Wolfram Language (Mathematica) , 88 78 bytes

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

Pruébalo en línea!

ahorrado 4 + 6 bytes gracias a @IanMiller

La lista es 1 indexada, genera el enésimo número.

Mathematica, 56 bytes

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

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

Pip -l , 16 bytes

x:YP6-,6W1PxCP:y

Emite la secuencia indefinidamente. Pruébalo en línea!

Explicación

La -lbandera significa que las listas se imprimen con cada elemento en su propia línea; Si un elemento es en sí mismo una lista, sus elementos se concatenan sin separador. Por ejemplo, la lista [1 [2 3] [4 [5 6]]]se imprimirá como

1
23
456

Con eso aclarado:

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

Después de la primera iteración del bucle, se xve así [[6;6];[6;5];[6;4];...;[1;1]]; después de la segunda iteración [[[6;6];6];[[6;6];5];[[6;6];4];...;[[1;1];1]]; y así. No debemos preocuparnos por aplanar las sublistas, porque -lefectivamente lo hace por nosotros.

Carbón , 18 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. 1 indexado. Explicación:

Ｎθ

Entrada n

Ｗθ«

Repita hasta que nsea ​​cero.

←Ｉ⊕﹪±θ⁶

Reduzca el -nmódulo 6, luego incremente el resultado y la salida de derecha a izquierda.

≔÷⊖θ⁶θ

Decremento ny número entero lo dividen entre 6.

Retina 0.8.2 , 36 bytes

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

Pruébalo en línea! El enlace incluye casos de prueba. 1 indexado. Explicación:

.+
$*_

Convierte a unario. (Retina 1 ahorraría 2 bytes aquí).

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

Convertir a base biyectiva 6 mediante divmod repetido. Tenga en cuenta que el uso de +significa que el dígito extraído siempre es un número de 1 a 6 en lugar de 0 a 5 para la conversión regular de base 6. ( (_{6})*es más rápido pero cuesta bytes extraer el cociente).

T`7-1`d

Transponga los dígitos para que los 6 sean los primeros y los 1 los últimos. (No hay 7 ni 0, pero esto me permite usar el dacceso directo.

Cubix , 22 bytes

Esto generará la secuencia indefinidamente. La idea general es que tiene un número base al que se agrega 6 - 1. Para cada adición, el resultado se genera multiplicado por 10, que se empuja al final de la pila para usarlo más adelante en la secuencia. Luego se abre la base y comienza la siguiente base.

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

Pruébalo en línea!

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

Míralo correr

C # (.NET Core) , impresión infinita, 181 180 88 bytes.

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;}

Lamentablemente, se bloquea repl.it en lugar de salir correctamente en la versión infinita como está escrito (creo que es un error en repl.it, ya que no sale como el programa se repite como debería), por lo que cualquiera que desee probar necesita un computadora. Si agrega una lectura al principio del bucle, también funciona en repl.it.

Salidas a la consola, obviamente.

En cualquier sistema finito, el código probablemente se bloqueará con un error de falta de memoria.

Se modificó el código para usar la lambda de @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)+" ");

Pruébalo en línea!

Adelante (gforth) , 63 bytes

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

Pruébalo en línea!

N-indexado salidas n-ésimo valor

Explicación

Si N es menor que 6, arroje el valor absoluto de N - 6. De lo contrario, obtenga el cociente y el resto de dividir N entre 6. Llame a la función recursivamente en el cociente, luego llámela al resto.

Explicación del código

: 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 caracteres, 54 bytes

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

traduzca la solución por dana /codegolf//a/179980 en APL ... prueba:

  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 #, imprimir de inicio a n, ??? bytes

Gracias a @dana por la expresión 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)+" ");

Operación: Ejecutar con el argumento 0 de la línea de comando igual al número entero con el que desea contar. (Cabe señalar que a[0]es una referencia a la matriz de argumentos de la línea de comandos que no se menciona, y no sé cómo contarla).