Виклик

З огляду на ціле число n ≥ 4 , виведіть перестановку цілих чисел [0, n-1] із властивістю, що жодні два послідовних цілих числа не знаходяться поруч. Значення перестановки pi- це сума abs(pi[i] - i)всіх показників i.

Приклади

• (1, 3, 0, 2) має значення 6
• (0, 2, 4, 1, 3) має значення 6
• (0, 2, 4, 1, 3, 5) має значення 6
• (0, 2, 4, 1, 5, 3, 6) має значення 8

Оцінка вашої відповіді

Оцінка вашої відповіді - це сума значень ваших перестановок n = 4 .. 14плюс кількість байтів, які займає ваш код. Чим нижче оцінка, тим краще. Ваш код повинен дати дійсний вихід для всіх цих значень n.

Ви повинні мати змогу запустити свою заявку до завершення на вашій машині.

У разі зв’язків визначальним буде час останнього редагування, яке призвело до відповідної оцінки.

Це не те саме питання, як це ?

Відповіді на пов’язане запитання не будуть конкурентоспроможними для цього питання, оскільки вони не докладають зусиль для оптимізації значення перестановки. Наприклад n=10, перестановка, [1, 3, 5, 7, 9, 0, 2, 4, 6, 8]задана більшістю відповідей, дає значення 30. Ви можете зробити набагато краще, ніж це.

Для перестановочної частини питання оптимальне значення в цілому становить максимум 120. (Дякую @Laikoni.) Тоді як відповідь Денніса на попереднє запитання набирає 222 . (Дякую @ user202729.)

Желе , 36 34 33 32 31 30 байт, результат: 120

Дякуємо Деннісу за -1 байт! (неявно, виправляючи помилку Jelly, хоча функція позначає виклик)

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

Нова функція: накопичена сума ( Ä).

Спробуйте в Інтернеті!

Використовуйте 1-індексацію.

Займає і лінійний час.

Ця програма C ++ генерує лексикографічно найменшу перестановку, припускаючи, що | i - p _i | ≤ ширина (де ширина є твердою кодовою постійною) для всіх 0 ≤ i <n , з часовою складністю приблизно O (ширина ² × 2 ^{2 × ширина} × n) (що є просто O (n) для фіксованої ширини ): Спробуйте в Інтернеті !

Як?

1. Напишіть програму C ++, яка намагатиметься оптимально вирішити проблему.

2. Дотримуйтесь схему. Зауважимо, що послідовність усіх елементів, крім 4 останніх, є префіксом

   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. Обчислює інкрементальну різницю послідовності.

   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
   

   Зверніть увагу на період 5.

4. Реалізація желе:

   • n-4 перші елементи взяті з послідовності, наведеної вище. O (n) .

   • Для чотирьох останніх елементів просто грубою силою всі 24 можливості . O (1) .

     (зверніть увагу: я більше не переймаю всі 24 можливості з 32-байтової версії)

CJam (60 байт + 120 = 180 балів)

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

Онлайн тестовий набір з інтегрованим балом

Розширення до n = 24

Розсічення

{
  _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 оцінка + байти

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

Повторюється шаблон [1,3,0,2], останні mod i 4елементи налаштовуються вручну.

Попередній алгоритм (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]

Брутфорсує правильну кількість стрибків довжиною ± 2 або ± 3. Вибір останнього з правильними цифрами в ньому, здається, працює просто чудово і коштує набагато дешевше, ніж реалізація оцінки. Тіо просто закінчується час до останнього рахунку, який становить 18.

Спробуйте в Інтернеті!

Japt, 120 + 20 = 140

(Копіювання одного з моїх рішень з іншого завдання склало б мені 227)

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

Спробуйте або скористайтеся цією версією, щоб перевірити бали. Обидві версії можуть почати випиратися на вас близько 9.

Пояснення

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

Рубі , 120 балів + 112 106 91 82 байт

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

Спробуйте в Інтернеті!

Послідовність в основному (a-2)+(a+2)%5.

Якщо n mod 5 не дорівнює 0 або 1, останні 3 або 4 елементи відрізняються.

Це все ще наполовину жорстко, завжди знаходить найкраще рішення, можливо, це можна було б пограти ще трохи, але у мене не вистачає ідей.

JavaScript (Node.js) , 148 балів + 109 73 байт

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)

Спробуйте в Інтернеті! Пояснення: lвідслідковує останнє створене число та mвідслідковує наступне число протилежного паритету до l; після lперевищення m+2змінних змінних. На початку послідовності проводиться коригування, щоб послідовності, довжина яких не кратна 5, не пропускали жодних чисел, а для іншого робиться коригування n=4.