挑战：

这是序列的前100个项目：

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

这个序列是如何形成的？我们首先获得范围内的数字[6, 1]（单个芯片从最高到最低的所有可能值）。然后，我们得到数字[66..61, 56..51, 46..41, 36..31, 26..21, 16..11]（从最高到最低的两个骰子的所有可能的conconted值）。等等，
这与OEIS序列A057436有关：仅包含数字1到6，但是所有具有相等位数的数字在该序列中都向后排序。

面临的挑战是按照上述顺序为您的功能/程序选择以下三个选项之一：

1. 输入并输出此序列的第个值，该值可以为0索引或1索引。$n$$n$
2. 输入并输出此序列的前或值。$n$$n$$n+1$
3. 无限期地输出序列中的值。

当然，可以使用任何合理的输出格式。可以是字符串/整数/小数/等。可以是（无限）列表/数组/流/等；可以用空格/逗号/换行符/其他定界符输出到STDOUT；等等。请在回答中说明您使用的I / O和选项！

通用规则：

• 这是代码高尔夫球，因此最短答案以字节为单位。
  不要让代码高尔夫球语言阻止您发布使用非代码高尔夫球语言的答案。尝试针对“任何”编程语言提出尽可能短的答案。
• 标准规则适用于具有默认I / O规则的答案，因此允许您使用STDIN / STDOUT，具有适当参数的函数/方法以及返回类型的完整程序。你的来电。
• 默认漏洞是禁止的。
• 如果可能的话，请添加一个带有测试代码的链接（即TIO）。
• 另外，强烈建议为您的答案添加说明。

如果您选择选项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

果冻，5个字节

ḃ6ạ7V

在线尝试！

1分度的第n个值。

Perl 6的，24的23个字节

-1字节感谢nwellnhof

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

在线尝试！

输出由空格/换行符无限分隔的序列。或者，对于更多的字节，我们可以有一个懒惰的无限列表，可以改为索引。

Perl 6，27个字节

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

在线尝试！

说明：

{                         }    # 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字节

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

在线尝试！

输出1个索引编号

R，43个字节

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

在线尝试！

无限打印序列

• -9感谢@Kirill L.

Bash，31个字节

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

蒂奥

从注释更新，第n个值1索引，+ GNU工具+ perl，64个字节，由于使用@manatwork而节省了7个字节

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

64字节

MATL，11个字节

`6:P!V@Z^DT

无限期输出值。

在线尝试！

说明

`      % 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字节

无限数量的数字：

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

在线尝试！

较早的两个解决方案给出了无限的字符串列表，每个字符串使用38个字节：

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

在线尝试！

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

在线尝试！

JavaScript（ES6），26个字节

$n$

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

在线尝试！

Haskell，28个字节

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

在线尝试！

产生无限的数字列表l。使用<$>并<*>切断一个字节：

29个字节

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

在线尝试！

该方法类似于Haskell 输出所有字符串答案固定输入字符串“ 654321”，并通过更改其前缀位置来跳过空字符串输出。

30字节

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

在线尝试！

05AB1E，10个字节

无限期输出序列。

¸[6LRâJD»,

在线尝试！

说明

¸           # 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个字节

-3bytes @Xcali

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

37字节

40字节

Java（JDK），48个字节

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

在线尝试！

这将返回索引为1的^第 n ^个元素。

递归似乎击败了迭代lambda。

迭代版本，49字节

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

在线尝试！

Brachylog，13 11字节

感谢Fatalize 2个字节

6~d{⟧₁∋}ᵐẉ⊥

无限期输出。在线尝试！

$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字节

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

在线尝试！

输出第n个值（从1开始）。

Japt，14个字节

使用功能方法和/或笛卡尔积必须有一个更短的解决方案，但是（目前呢？）我能管理的最好的方法是移植Arnauld的JS解决方案，因此请确保也对他进行投票。

©ß´Uz6)s+6-Uu6

试试看或测试条款0-1000

Wolfram语言（Mathematica），88 78字节

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

在线尝试！

@IanMiller节省了4 + 6个字节

列表为1索引，输出第n个数字。

Mathematica，56个字节

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

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

点 -l，16字节

x:YP6-,6W1PxCP:y

无限期输出序列。在线尝试！

说明

该-l标志意味着列表与每个项目一起打印在自己的行上；如果项目本身是列表，则其元素串联而没有分隔符。例如，列表[1 [2 3] [4 [5 6]]]将打印为

1
23
456

清除后：

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

第一次循环迭代后，x看起来像[[6;6];[6;5];[6;4];...;[1;1]]; 在第二次迭代之后[[[6;6];6];[[6;6];5];[[6;6];4];...;[[1;1];1]]；等等。我们不需要担心将子列表弄平，因为-l它实际上对我们有用。

木炭，18字节

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

在线尝试！链接是详细版本的代码。1个索引。说明：

Ｎθ

输入项 n

Ｗθ«

重复直到n为零。

←Ｉ⊕﹪±θ⁶

减少-n模数6，然后从右到左递增结果并输出。

≔÷⊖θ⁶θ

减数n和整数除以6。

视网膜0.8.2，36字节

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

在线尝试！链接包括测试用例。1个索引。说明：

.+
$*_

转换为一元。（Retina 1将在此处节省2个字节。）

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

通过重复divmod转换为双射基数6。请注意，使用+表示提取的数字始终是1到6的数字，而不是常规的以6为基数的转换的0到5。（(_{6})*速度更快，但要花费字节来提取商。）

T`7-1`d

换位以使6排在最前面，而1排在最后。（没有7或0，但这使我可以使用d快捷方式。

Cubix，22个字节

这将无限期地输出序列。通常的想法是，它的基数要加上6-1。对于每个加法运算，结果将输出乘以10，然后将其推入堆栈的底部，以稍后在序列中使用。然后弹出该基准，然后开始下一个基准。

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

在线尝试！

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

观看它运行

C＃（.NET Core），无限打印，181180 88字节。

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

可悲的是，它冻结了repl.it，而不是按书面形式在无穷版本中正确输出（我相信这是repl.it中的错误，因为它不会像程序应有的那样在程序循环中输出），所以任何希望测试的人都需要电脑。如果在循环的最前面添加一个读取，则它也可以在repl.it中工作。

显然，输出到控制台。

在任何有限的系统上，代码很可能最终会因内存不足错误而崩溃。

重新编写代码以使用@dana的lambda。

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)+" ");

在线尝试！

第四（gforth），63字节

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

在线尝试！

0分度输出nth值

说明

如果N小于6，则输出N-6的绝对值。否则，得到商和N除以6的余数。对商递归调用该函数，然后对余数调用该函数。

代码说明

: 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个字符，54个字节

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

通过dana /codegolf//a/179980在APL中翻译解决方案...测试：

  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＃，从开始打印到n，??? 个字节

感谢@dana提供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)+" ");

操作：在命令行第0个参数等于要计算的整数的情况下运行。（应注意，它a[0]是对否则未提及的命令行args数组的引用，但我不知道该如何计数。）