Thử thách

Cho một số nguyên n 4 , xuất ra một hoán vị của các số nguyên [0, n-1] với thuộc tính không có hai số nguyên liên tiếp nào nằm cạnh nhau. Giá trị của một hoán vị pilà tổng của abs(pi[i] - i)tất cả các chỉ số i.

Ví dụ

• (1, 3, 0, 2) có giá trị 6
• (0, 2, 4, 1, 3) có giá trị 6
• (0, 2, 4, 1, 3, 5) có giá trị 6
• (0, 2, 4, 1, 5, 3, 6) có giá trị 8

Điểm câu trả lời của bạn

Điểm của câu trả lời của bạn là tổng các giá trị hoán vị của bạn n = 4 .. 14cộng với số byte mà mã của bạn lấy. Điểm càng thấp càng tốt. Mã của bạn phải cung cấp đầu ra hợp lệ cho tất cả các giá trị đó n.

Bạn phải có thể chạy trình của bạn để hoàn thành trên máy của bạn.

Trong trường hợp quan hệ, thời gian chỉnh sửa cuối cùng dẫn đến số điểm có liên quan sẽ là người quyết định.

Đây không phải là câu hỏi tương tự như câu hỏi này sao?

Các câu trả lời cho câu hỏi được liên kết sẽ không thể cạnh tranh cho câu hỏi này vì chúng không nỗ lực để tối ưu hóa giá trị của một hoán vị. Ví dụ n=10, hoán vị [1, 3, 5, 7, 9, 0, 2, 4, 6, 8]được đưa ra bởi hầu hết các câu trả lời ở đó cho giá trị là 30. Bạn có thể làm tốt hơn thế nhiều.

Đối với phần hoán vị của câu hỏi, tổng giá trị tối ưu là tối đa 120. (Cảm ơn bạn @Laikoni.) Trong khi câu trả lời của Dennis cho câu hỏi trước đó là 222 điểm . (Cảm ơn bạn @ user202729.)

Jelly , 36 34 33 32 31 30 byte, kết quả: 120

Cảm ơn Dennis cho -1 byte! (hoàn toàn bằng cách sửa lỗi Jelly, mặc dù tính năng hoãn thử thách)

ðRḟISị“Ƥ¿‘Ʋœ?$;@µ2x5~4¦ṁ_4$Ä’

Tính năng mới: tổng tích lũy ( Ä).

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

Sử dụng 1 chỉ mục.

Mất thời gian tuyến tính, quá.

Chương trình C ++ này tạo ra hoán vị nhỏ nhất về mặt từ vựng, giả sử rằng | i - p _i | Chiều rộng (trong đó chiều rộng là hằng số được mã hóa cứng) cho tất cả 0 ≤ i <n , với độ phức tạp về thời gian khoảng O (chiều rộng ² × 2 ^{2 × chiều rộng} × n) (chỉ là O (n) cho chiều rộng cố định ): Hãy thử trực tuyến !

Làm sao?

1. Viết chương trình C ++ cố gắng giải quyết vấn đề một cách tối ưu.

2. Quan sát mô hình. Chúng tôi lưu ý rằng chuỗi tất cả các yếu tố ngoại trừ 4 yếu tố cuối cùng là tiền tố của

   0 2 4 1 3 5 7 9 6 8 10 12 14 11 13 15 17 19 16 18 20 22 24 21 23 25 ...
   

3. Tính toán sự khác biệt gia tăng của chuỗi.

   2 2 -3 2 2 2 2 -3 2 2 2 2 -3 2 2 2 2 -3 2 2 2 2 -3 2 2
   

   Lưu ý giai đoạn 5.

4. Việc thực hiện Jelly:

   • n-4 phần tử đầu tiên được lấy từ trình tự trên. O (n) .

   • Đối với 4 yếu tố cuối cùng, chỉ cần vũ phu tất cả 24 khả năng . O (1) .

     (lưu ý: Tôi không còn vũ phu tất cả 24 khả năng từ phiên bản 32 byte)

CJam (60 byte + 120 = 180 điểm)

{_5/4*8e!961=7_)er<:A\,^e!{A\+}%{2ew::-:z1&!},{_$.-:z1b}$0=}

Bộ kiểm tra trực tuyến với tính năng tích hợp

Gia hạn tối đa n = 24

Mổ xẻ

{
  _5/4*        e# Work out how much of the hard-coded prefix to use
  8e!961=7_)er e# Prefix [0 2 4 1 3 5 8 6]
               e# I identified this by brute forcing up to n=10 and looking for patterns
               e# I then used the identified prefix [0 2 4 1] to brute-force further
  <:A          e# Take the desired prefix of the hard-coded array, and store a copy in A
  \,^e!        e# Generate all permutations of the values in [0 .. n-1] which aren't in A
  {A\+}%       e# Prepend A to each of them
  {            e# Filter...
    2ew::-     e#   Take each difference of two consecutive elements
    :z         e#   Find their absolute values
    1&         e#   Test whether 1 is among those absolute values
    !          e#   Reject if it is
  },
  {            e# Sort by...
    _$.-       e#   Take pairwise differences of permutation with the identity
    :z         e#   Absolute values
    1b         e#   Add them (by interpreting in base 1)
  }$
  0=           e# Take the first
}

Haskell , 146 + 89 điểm + byte

f i|k<-mod i 4=scanl(+)1$take(i-2-k)(cycle[2,-3,2,3])++[[2],[2,2],[5,-3,2],[5,-3,2,2]]!!k

Lặp lại mẫu [1,3,0,2], mod i 4các yếu tố cuối cùng được điều chỉnh bằng tay.

Thuật toán trước (132 + 116):

f i=last$filter(\a->all(`elem`a)[0..i-1]).(!!(i-1)).iterate((\l->map((:l).(+head l))[-3,2,-2,3])=<<)$pure<$>[i-3..i]

Bruteforces số lần nhảy chính xác có độ dài ± 2 hoặc ± 3. Chọn cái cuối cùng có số chính xác trong đó, dường như chỉ hoạt động tốt và rẻ hơn rất nhiều so với việc thực hiện điểm số. Tio chỉ hết thời gian trước khi điểm cuối cùng, đó là 18.

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

Japt, 120 + 20 = 140

(Sao chép một trong những giải pháp của tôi từ thử thách khác sẽ ghi điểm cho tôi 227)

o á k_äa d¥1ÃñxÈaYÃg

Hãy thử nó hoặc sử dụng phiên bản này để kiểm tra điểm số. Cả hai phiên bản có thể bắt đầu xuất hiện trên bạn khoảng 9.

Giải trình

o                        :Range [0,input)
  á                      :All permutations
    k_      Ã            :Remove sub-arrays that return true
      äa                 :  Get the consecutive absolute differnces
         d¥1             :  Do any equal 1?
               È  Ã      :Pass the integers in each remaining sub-array through a function
                aY       :  Get the absolute difference with the integer's index
              x          :Reduce by addition
             ñ           :Sort the main array by those values
                   ñ     :Return the first sub-array

Ruby , 120 điểm + 112 106 91 82 byte

->n{(0...n).map{|a|a+(a+2)%5-([[],[],[0,4,3],[-1,4,4,4],[1,1,6,1]][n%5][a-n]||2)}}

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

Trình tự là cơ bản (a-2)+(a+2)%5.

Nếu n mod 5 không phải là 0 hoặc 1, thì 3 hoặc 4 phần tử cuối cùng sẽ khác nhau.

Đây vẫn là một nửa mã hóa, luôn luôn tìm ra giải pháp tốt nhất, có thể nó có thể được đánh gôn nhiều hơn một chút, nhưng tôi đã hết ý tưởng.

JavaScript (Node.js) , 148 điểm + 109 73 byte

n=>[...Array(n)].map(_=>l=!m|l>n%5+2&&l>m+2?[+m,m=l+2][0]:l+2,m=n>4,l=~m)

Hãy thử trực tuyến! Giải thích: ltheo dõi số cuối cùng được tạo và mtheo dõi số tiếp theo của tính chẵn lẻ đối diện l; một khi lvượt quá m+2các biến được trao đổi. Một điều chỉnh được thực hiện ở đầu chuỗi để các chuỗi có độ dài không phải là bội số của 5 không bỏ sót bất kỳ số nào và một điều chỉnh khác được thực hiện cho n=4.