Thử thách:

Ở đây chúng tôi có 100 mục đầu tiên của chuỗi:

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

Trình tự này được hình thành như thế nào? Đầu tiên chúng ta có số trong phạm vi [6, 1](tất cả các giá trị có thể có của một lần chết từ cao nhất đến thấp nhất). Sau đó chúng ta có các số [66..61, 56..51, 46..41, 36..31, 26..21, 16..11](tất cả các giá trị được ẩn của hai con xúc xắc từ cao nhất đến thấp nhất). Vv
này liên quan đến trình tự OEIS A057436: Có chữ số từ 1 đến 6 chỉ , nhưng với tất cả các số với số tiền bằng chữ số được sắp xếp ngược trong chuỗi.

Thách thức là chọn một trong ba tùy chọn này cho chức năng / chương trình của bạn với trình tự trên:

1. Tham dự một đầu vào và đầu ra các 'th giá trị của chuỗi này, nơi mà nó có thể là 0-lập chỉ mục hoặc 1-lập chỉ mục.$n$$n$
2. Lấy đầu vào và xuất giá trị hoặc đầu tiên của chuỗi này.$n$$n$$n+1$
3. Xuất các giá trị từ chuỗi vô thời hạn.

Tất nhiên, bất kỳ định dạng đầu ra hợp lý có thể được sử dụng. Có thể là chuỗi / số nguyên / số thập phân / vv.; có thể là một danh sách (vô hạn) / mảng / luồng / vv.; có thể là đầu ra với dấu cách / dấu phẩy / dòng mới / dấu phân cách khác cho STDOUT; v.v ... Vui lòng cho biết I / O và tùy chọn bạn đang sử dụng trong câu trả lời của mình!

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Quy tắc chuẩn áp dụng cho câu trả lời của bạn với quy tắc I / O mặc định , vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn (ví dụ TIO ).
• Ngoài ra, thêm một lời giải thích cho câu trả lời của bạn rất được khuyến khích.

Dưới đây là một số trường hợp thử nghiệm lớn hơn nếu bạn chọn tùy chọ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

Thạch , 5 byte

ḃ6ạ7V

Hãy thử trực tuyến!

Giá trị thứ n chỉ số 1.

Perl 6 , 24 23 byte

-1 byte nhờ nwellnhof

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

Hãy thử trực tuyến!

Xuất ra chuỗi được phân tách vô hạn bởi khoảng trắng / dòng mới. Hoặc, để có thêm một vài byte, chúng ta có thể có một danh sách vô hạn lười biếng mà chúng ta có thể lập chỉ mục thay thế.

Perl 6 , 27 byte

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

Hãy thử trực tuyến!

Giải trình:

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

Hãy thử trực tuyến!

Đầu ra số 1 chỉ mục

R , 43 byte

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

Hãy thử trực tuyến!

In trình tự vô thời hạn

• -9 cảm ơn @Kirill L.

Bash, 31 byte

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

TIO

cập nhật từ các nhận xét, giá trị thứ 1 được lập chỉ mục, + công cụ GNU + perl, 64 byte, 7 byte được lưu nhờ @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

Xuất ra các giá trị vô thời hạn.

Hãy thử trực tuyến!

Giải trình

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

Một danh sách vô số các số:

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

Hãy thử trực tuyến!

Hai giải pháp trước đó cung cấp danh sách chuỗi vô hạn, mỗi chuỗi sử dụng 38 byte:

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

JavaScript (ES6), 26 byte

$n$

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

Hãy thử trực tuyến!

Haskell , 28 byte

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

Hãy thử trực tuyến!

Tạo ra một danh sách vô hạn các số l. Sử dụng <$>và <*>cắt một byte tắt:

29 byte

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

Hãy thử trực tuyến!

Cách tiếp cận tương tự như Haskell Output All String trả lời chuỗi đầu vào cố định "654321" và bỏ qua đầu ra chuỗi trống bằng cách thay đổi nơi nó được đặt trước.

30 byte

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

Hãy thử trực tuyến!

05AB1E , 10 byte

Xuất ra chuỗi vô thời hạn.

¸[6LRâJD»,

Hãy thử trực tuyến!

Giải trình

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

-3byte nhờ @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):"";}

Hãy thử trực tuyến!

Điều này trả về phần tử ^thứ n được lập chỉ mục .

Đệ quy dường như đánh bại lambda lặp đi lặp lại.

Phiên bản lặp, 49 byte

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

Hãy thử trực tuyến!

Brachylog , 13 11 byte

Cảm ơn Fatalize cho 2 byte

6~d{⟧₁∋}ᵐẉ⊥

Đầu ra vô thời hạn. Hãy thử trực tuyến!

$n$

Giải trình

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;

Hãy thử trực tuyến!

Xuất giá trị thứ n (dựa trên 1).

Japt, 14 byte

Phải có một giải pháp ngắn hơn bằng cách sử dụng các phương thức chức năng và / hoặc sản phẩm của Cartesian nhưng (bây giờ?), Cách tốt nhất tôi có thể quản lý là một cổng của giải pháp JS của Arnauld, vì vậy hãy chắc chắn nâng cấp anh ấy.

©ß´Uz6)s+6-Uu6

Hãy thử nó hoặc kiểm tra các điều khoản0-1000

Ngôn ngữ Wolfram (Mathicala) , 88 78 byte

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

Hãy thử trực tuyến!

đã lưu 4 + 6 byte nhờ @IanMiller

Danh sách là 1 được lập chỉ mục, xuất ra số thứ n.

Toán học, 56 byte

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

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

Pip -l , 16 byte

x:YP6-,6W1PxCP:y

Xuất ra chuỗi vô thời hạn. Hãy thử trực tuyến!

Giải trình

Các -lphương tiện cờ mà danh sách được in với mỗi mục trên một dòng riêng; nếu một mục tự nó là một danh sách, các phần tử của nó được nối với nhau không có dấu phân cách. Ví dụ: danh sách [1 [2 3] [4 [5 6]]]sẽ được in dưới dạng

1
23
456

Với điều đó đã được xóa:

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

Sau lần lặp đầu tiên, xhình như [[6;6];[6;5];[6;4];...;[1;1]]; sau lần lặp thứ hai , [[[6;6];6];[[6;6];5];[[6;6];4];...;[[1;1];1]]; vân vân Chúng tôi không cần phải lo lắng về việc làm phẳng các danh sách con, bởi vì -lnó thực sự làm điều đó cho chúng tôi.

Than , 18 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. 1 chỉ mục. Giải trình:

Ｎθ

Đầu vào n

Ｗθ«

Lặp lại cho đến khi nbằng không.

←Ｉ⊕﹪±θ⁶

Giảm -nmodulo 6, sau đó tăng kết quả và đầu ra từ phải sang trái.

≔÷⊖θ⁶θ

Giảm nvà số nguyên chia nó cho 6.

Võng mạc 0.8.2 , 36 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. 1 chỉ mục. Giải trình:

.+
$*_

Chuyển đổi sang unary. (Retina 1 sẽ lưu 2 byte ở đây.)

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

Chuyển đổi sang cơ sở phỏng đoán 6 bằng divmod lặp đi lặp lại. Lưu ý rằng việc sử dụng +có nghĩa là chữ số được trích xuất luôn là một số từ 1 đến 6 thay vì 0 đến 5 cho chuyển đổi cơ sở 6 thông thường. ( (_{6})*nhanh hơn nhưng chi phí byte trích xuất thương số.)

T`7-1`d

Chuyển các chữ số sao cho 6s đến trước và 1 cuối. (Không có 7 hoặc 0 nhưng điều này cho phép tôi sử dụng dphím tắt.

Khối , 22 byte

Điều này sẽ xuất ra chuỗi vô thời hạn. Ý tưởng chung là nó có số cơ sở 6 - 1 được thêm vào. Đối với mỗi lần thêm, kết quả là đầu ra nhân với 10, được đẩy xuống dưới cùng của ngăn xếp để sử dụng sau trong chuỗi. Cơ sở sau đó được bật lên và cơ sở tiếp theo bắt đầu.

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

Hãy thử trực tuyến!

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

Xem nó chạy

C # (.NET Core) , in vô hạn, 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;}

Đáng buồn là nó đóng băng repl.it thay vì xuất ra đúng phiên bản vô hạn như đã viết (tôi tin rằng đó là một lỗi trong repl.it, vì nó không xuất ra như các vòng lặp chương trình như nó nên), vì vậy bất cứ ai hy vọng kiểm tra đều cần máy vi tính. Nếu bạn thêm một lần đọc ở phía trước của vòng lặp, nó cũng hoạt động trong repl.it.

Đầu ra cho giao diện điều khiển, rõ ràng.

Trên bất kỳ hệ thống hữu hạn nào, mã rất có thể cuối cùng sẽ gặp sự cố với lỗi hết bộ nhớ.

Làm lại mã để sử dụng lambda của @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)+" ");

Hãy thử trực tuyến!

Forth (gforth) , 63 byte

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

Hãy thử trực tuyến!

Đầu ra 0 chỉ số giá trị thứ n

Giải trình

Nếu N nhỏ hơn 6, xuất giá trị tuyệt đối của N - 6. Mặt khác, lấy thương số và phần còn lại chia N cho 6. Gọi hàm đệ quy trên thương số, sau đó gọi nó vào phần còn lại.

Giải thích mã

: 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 ký tự, 54 byte

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

thử nghiệm giải pháp bằng dana /codegolf//a/179980 trong APL ... kiểm tra:

  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 #, in từ đầu đến n, ??? byte

Tín dụng cho @dana cho biểu thức 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)+" ");

Hoạt động: Chạy với đối số dòng lệnh 0th bằng số nguyên bạn muốn đếm. (Cần lưu ý rằng đó a[0]là một tham chiếu đến dòng lệnh không được đề cập khác, và tôi không biết cách đếm nó.)