Lưu ý: Đây là một nỗ lực tái chế (các) câu hỏi hoán vị của khách271314

Có một mô hình thú vị hình thành khi bạn tìm thấy sự khác biệt giữa các hoán vị được sắp xếp theo từ vựng của 10 số cơ bản với các chữ số duy nhất tăng dần. Ví dụ: 123có hoán vị:

123 132 213 231 312 321

Khi bạn tìm thấy sự khác biệt giữa những điều này, bạn sẽ có được chuỗi

9 81 18 81 9

Tất cả đều chia hết cho chín (vì tổng số chữ số của 10 số cơ sở), cũng như là palindromic.

Đáng chú ý, nếu chúng ta sử dụng số tiếp theo 1234, chúng ta sẽ nhận được chuỗi

9 81 18 81 9 702 9 171 27 72 18 693 18 72 27 171 9 702 9 81 18 81 9

Mà mở rộng trình tự trước trong khi còn lại palindromic khoảng $693$ . Mẫu này luôn giữ, ngay cả khi bạn bắt đầu sử dụng nhiều 10số đó , mặc dù độ dài của chuỗi là $n!-1$ cho số. Lưu ý rằng để sử dụng các số ở trên , chúng tôi không thay đổi thành một cơ sở khác, chúng tôi chỉ cần nhân số đó với , ví dụ .$n$0 to 9$10^x$$[1,12,11]_{10} = 1*10^2 + 12*10^1 + 11*10^0 = 231$

Mục tiêu của bạn là thực hiện chuỗi này, bằng cách trả về mỗi phần tử là bội số của chín. Ví dụ: 23 phần tử đầu tiên của chuỗi này là:

1 9 2 9 1 78 1 19 3 8 2 77 2 8 3 19 1 78 1 9 2 9 1

Một số trường hợp thử nghiệm khác (0 được lập chỉ mục):

23     => 657
119    => 5336
719    => 41015
5039   => 286694
40319  => 1632373
362879 => 3978052
100    => 1
1000   => 4
10000  => 3
100000 => 3

Quy tắc:

• Việc gửi có thể là bất kỳ:
  • Một chương trình / hàm lấy một số và trả về số đó tại chỉ mục đó, 0 hoặc 1 được lập chỉ mục.
  • Một chương trình / hàm lấy một số và trả về chỉ số thứ , 0 hoặc 1 được lập chỉ mục.$n$$n$
  • Một chương trình / hàm xuất / trả về chuỗi vô hạn.
• Chương trình phải có khả năng xử lý về mặt lý thuyết lên đến phần tử thứ và hơn thế nữa, mặc dù tôi hiểu nếu các hạn chế về thời gian / bộ nhớ làm cho điều này thất bại. Cụ thể, điều này có nghĩa là bạn không thể ghép các chữ số và đánh giá là cơ sở 10, vì một số thứ như sẽ sai.$11!-1$$012345678910$
• Đây là môn đánh gôn , vì vậy việc thực hiện ngắn nhất cho mỗi ngôn ngữ sẽ thắng!

Ghi chú:

• Đây là OEIS A217626
• Tôi đang cung cấp một khoản tiền thưởng 500 cho một giải pháp giải quyết trực tiếp các yếu tố mà không tính toán các hoán vị thực tế.
• Trình tự hoạt động cho bất kỳ chữ số liền kề. Ví dụ: sự khác biệt giữa các hoán vị của giống như với .$[1,2,3,4]_{10}$$[-4,-3,-2,-1]_{10}$

Thạch , 9 byte

,‘œ?ŻḌI÷9

Hãy thử trực tuyến! (in phần tử thứ n)

Hãy thử trực tuyến! (20 yếu tố đầu tiên)

Giải trình:

      I÷9      Compute the difference divided by 9 between
 ‘             the (n+1)th
  œ?           permutation
,              and
               the (n)th
  œ?           permutation
    Ż          of [0,1,2,...n]
     Ḍ         converted to decimal.

(Jelly có phần dựng sẵn œ?tính toán nhoán vị thứ của danh sách trong khoảng thời gian tuyến tính. Khá hữu ích.)

Than , 71 byte

≔⟦Ｎ⊕θ⟧ηＷ⌈η≧÷Ｌ⊞ＯυＥη﹪κ⊕Ｌυη≔⁰δＦ²«≔Ｅυλζ≔⟦⟧ηＦ⮌Ｅυ§κι«⊞η§ζκ≔Φζ⁻μκζ»≦⁻↨ηχδ»Ｉ÷δ⁹

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

≔⟦Ｎ⊕θ⟧η

Lấy một danh sách chứa đầu vào và một nhiều hơn đầu vào.

Ｗ⌈η

Lặp lại cho đến khi cả hai giá trị bằng không.

≧÷Ｌ⊞ＯυＥη﹪κ⊕Ｌυη

Thực hiện chuyển đổi cơ sở giai thừa trên cả hai giá trị. Đây là lần đầu tiên tôi thực sự sử dụng ≧trong danh sách!

≔⁰δ

Xóa kết quả.

Ｆ²«

Vòng lặp trên mỗi số cơ sở giai thừa.

≔Ｅυλζ

Lập danh sách các chữ số từ 0 đến dài - 1.

≔⟦⟧η

Khởi tạo kết quả vào một danh sách trống.

Ｆ⮌Ｅυ§κι«

Lặp lại các chữ số của số cơ sở giai thừa.

⊞η§ζκ

Thêm chữ số hoán vị tiếp theo vào kết quả.

≔Φζ⁻μκζ»

Xóa chữ số đó khỏi danh sách.

≦⁻↨ηχδ»

Chuyển đổi hoán vị dưới dạng số 10 cơ sở và trừ kết quả cho đến nay.

Ｉ÷δ⁹

Chia kết quả cuối cùng cho 9 và truyền thành chuỗi.

Perl 6 , 82 byte

-2 byte nhờ Jo King

->\n{([-] map {$/=[^n];:10[map {|splice $/,$_,1},[R,] .polymod(1..n-2)]},n+1,n)/9}

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

Chỉ số 0. Không liệt kê tất cả các hoán vị. Về mặt lý thuyết nên hoạt động cho tất cả n, nhưng giải cứu cho n> 65536 với "Quá nhiều đối số trong mảng làm phẳng".

Phiên bản 80 byte sau hoạt động với n lên tới 98! -2 và nhanh hơn rất nhiều:

{([-] map {$/=[^99];:10[map {|splice $/,$_,1},[R,] .polymod(1..97)]},$_+1,$_)/9}

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

Phiên bản 53 byte sau đây về mặt lý thuyết sẽ hoạt động cho tất cả n, nhưng giải cứu cho n> = 20 với "từ chối hoán vị hơn 20 phần tử".

{[-](map {:10[$_]},permutations(1..$_+1)[$_,$_-1])/9}

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

JavaScript (Node.js) , 134 byte

n=>(F=_=>f>n?((G=(n,z=0,x=f,y=l,b=[...a])=>y?G(n%(x/=y),+b.splice(n/x,1)+z*10,x,y-1,b):z)(n--)-G(n))/9:F(a.push(++l),f*=l))(a=[l=f=1])

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

1 chỉ mục.

@ khách271314 ý kiến ​​là đúng. Tính toán hoán vị trực tiếp ngắn hơn ...

Giải trình

n=>(                           // Function -
 F=_=>                         //  Helper func to calculate length needed
 f>n?                          //   If f > n (meaning the length is enough) -
  (
   (
    G=(                        //    Helper func to calculate permutation value -
     n,
     z=0,                      //     Initial values
     x=f,                      //     Made as copies because we need to alter
     y=l,                      //     these values and the function will be
     b=[...a]                  //     called twice
    )=>
    y?                         //     If still elements remaining -
     G(
      n%(x/=y),                //      Get next element
      +b.splice(n/x,1)+z*10,   //      And add to the temporary result
      x,
      y-1,                     //      Reduce length
      b                        //      Remaining elements
     )
    :z                         //     Otherwise return the permutation value
   )(n--)-G(n)                 //    Calculate G(n) - G(n - 1)
  )/9                          //    ... the whole divided by 9 
 :F(
  a.push(++l),                 //   Otherwise l = l + 1, push l into the array
  f*=l                         //   ... and calculate l!
 )
)(
 a=[l=f=1]                     //  Initial values
)

Giải pháp gốc (159 byte)

n=>(x=l=t=0n,P=(a,b=[])=>n?""+a?a.map(z=>P(a.filter(y=>y-z),[...b,z])):(v=b.reduce((u,y)=>u=u*10n+y),x?--n?0:t=v-x:0,x=v):0)([...Array(n+1))].map(_=>++l))&&t/9n

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

Liên kết là một phiên bản dài hơn được thực hiện cho hiệu suất. Array(n+1)trở thành Array(Math.min(n+1,15))để làm cho công việc demo. Về mặt lý thuyết hoạt động đến vô cùng (tối đa giới hạn ngăn xếp trong thực tế).

Giải trình

Ý tôi là có quá nhiều thứ để giải thích.

n=>(                             // Function
 x=l=t=0n,                       // Initialization
 P=(                             // Function to determine the permutation -
  a,                             //  remaining items
  b=[]                           //  storage
 )=>
 n?                              //  if we haven't reached the required permutation yet - 
  ""+a?                          //   if we haven't the last layer of loop - 
   a.map(                        //    loop over the entries -
    z=>      
    P(                           //     recurse -
     a.filter(y=>y-z),           //      pick out the selected number
     [...b,z]                    //      append to next 
    )
   )
  :(                             //   if we are at the last layer -
   v=b.reduce((u,y)=>u=u*10n+y), //    calculate the value of the permutation
   x?                            //    if not the first number -
    --n?                         //     if not the last -
     0                           //      do nothing
    :t=v-x                       //     else calculate difference
   :0,                           //    else do nothing
   x=v                           //    record ot anyway
  )
 :0                              //   else do nothing
)
(
 [...Array(n+1)].map(_=>++l)     // the list of numbers to permute
)&&t/9n                          // last difference divided by 9

Bình thường, 15 14 byte

.+m/i.PdSQT9,h

Trả về số hạng thứ n. Hãy thử nó ở đây .

.+                     Find the differences between adjacent elements of
   m                   mapping lambda d:
      .PdSQ                the dth permutation of input,
     i     T               converted to base 10
    /       9              divided by 9
             ,         over [Q+1,Q]
               h Q
               Q

J , 44 , 41 byte

(9%~[:(2-~/\])i.(10#.1+A.)[:i.@>.!inv)@>:

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

Lưu ý: hoạt động ngay cả trong 10! trường hợp thử nghiệm, nhưng mất một số độ chính xác ở đó ...

giải thích ban đầu

(9 %~ [: (2 -~&(10&#.)/\ ]) 1 + i. A. i.@>.@(!inv))@>:
(                                                 )@>: NB. add one to input
                                                       NB. since n-1 deltas
                                                       NB. gives n results
                                                       NB. call that "n"
(                               i.                )    NB. take the first n
(                                  A.             )    NB. lexicographically
                                                       NB. sorted items of
(                                     i.@         )    NB. 0 up to...
(                                        >.@      )    NB. the ceil of...
(                                           (!inv))    NB. the inverse of 
                                                       NB. the factorial
(                           1 +                   )    NB. add 1 so our
                                                       NB. lists start at 1
                                                       NB. instead of 0
(     [: (                )                       )    NB. apply what's in 
                                                       NB. parens to that
                                                       NB. list of lists
(        (2 -~        /\ ])                       )    NB. take successive
                                                       NB. differences BUT
(        (    &(10&#.)    )                       )    NB. convert each list
                                                       NB. to a base 10
                                                       NB. number first
(9 %~                                             )    NB. and divide every
                                                       NB. items of the
                                                       NB. result by 9

JavaScript (ES6), 112 byte

Rất giống với thuật toán của Shieru Asakoto .

n=>(g=N=>(h=a=>k>n?(F=r=>--i?F(+a.splice(N/(k/=i),1)+r*10,N%=k):r/9)``:h([i+1,...a],k*=i++))([i=k=1]))(n++)-g(n)

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