Desafio

Dado um número inteiro n ≥ 4 , imprima uma permutação dos números inteiros [0, n-1] com a propriedade de que não há dois números inteiros consecutivos próximos um do outro. O valor de uma permutação pié a soma de abs(pi[i] - i)todos os índices i.

Exemplos

• (1, 3, 0, 2) tem valor 6
• (0, 2, 4, 1, 3) tem valor 6
• (0, 2, 4, 1, 3, 5) tem valor 6
• (0, 2, 4, 1, 5, 3, 6) tem valor 8

Pontuação da sua resposta

A pontuação da sua resposta é a soma dos valores de suas permutações para n = 4 .. 14mais o número de bytes que seu código leva. Quanto menor a pontuação, melhor. Seu código deve fornecer uma saída válida para todos esses valores de n.

Você deve poder executar seu envio até a conclusão em sua máquina.

Em caso de empate, o tempo da última edição que resultou na pontuação relevante será a decisão.

Não é a mesma pergunta que esta ?

As respostas à pergunta vinculada não serão competitivas para essa questão, pois não fazem nenhum esforço para otimizar o valor de uma permutação. Por exemplo n=10, para a permutação [1, 3, 5, 7, 9, 0, 2, 4, 6, 8]dada pela maioria das respostas, dá um valor de 30. Você pode fazer muito melhor que isso.

Para a parte de permutação da pergunta, o valor ótimo geral é no máximo 120. (Obrigado a @Laikoni.) Enquanto a resposta de Dennis para a pergunta anterior tem 222 pontos . (Obrigado a @ user202729.)

Geléia , 36 34 33 32 31 30 bytes, resultado: 120

Agradecimentos a Dennis por -1 byte! (implicitamente, corrigindo um bug do Jelly, embora o recurso seja posterior ao desafio)

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

Novo recurso: soma acumulada ( Ä).

Experimente online!

Use a indexação 1.

Também leva tempo linear.

Esse programa C ++ gera a menor permutação lexicograficamente, assumindo que | i - p _i | ≤ largura (onde largura é uma constante codificada) para todos os 0 ≤ i <n , com complexidade de tempo de cerca de O (largura ² × 2 ^{2 × largura} × n) (que é apenas O (n) para largura fixa ): Experimente on-line !

Quão?

1. Escreva um programa C ++ tentando resolver o problema da melhor maneira possível.

2. Observe o padrão. Observamos que a sequência de todos os elementos, exceto os 4 últimos, é um prefixo de

   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. Calcula a diferença incremental da sequência.

   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
   

   Observe o período 5.

4. A implementação do Jelly:

   • Os primeiros elementos n-4 são retirados da sequência acima. O (n) .

   • Para os 4 últimos elementos, basta força bruta em todas as 24 possibilidades . O (1) .

     (nota: não uso mais força bruta em todas as 24 possibilidades da versão de 32 bytes)

CJam (60 bytes + 120 = 180 pontos)

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

Conjunto de testes on-line com pontuação integrada

Extensão até n = 24

Dissecação

{
  _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 pontos + bytes

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

Repete o padrão [1,3,0,2], os últimos mod i 4elementos são ajustados manualmente.

Algoritmo anterior (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]

Bruteforça o número correto de saltos de comprimento ± 2 ou ± 3. Seleciona o último que possui os números corretos, parece funcionar muito bem e é muito mais barato que implementar a pontuação. Tio acaba o tempo antes da última pontuação, que é 18.

Experimente online!

Matemática5 pontos

(Copiar uma das minhas soluções do outro desafio teria me marcado 227)

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

Experimente ou use esta versão para verificar as pontuações. Ambas as versões podem começar a cagar em torno de 9.

Explicação

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 score + 112 106 91 82 bytes

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

Experimente online!

A sequência é basicamente (a-2)+(a+2)%5.

Se n mod 5 não for 0 ou 1, os últimos 3 ou 4 elementos serão diferentes.

Isso ainda é meio codificado, sempre encontra a melhor solução, talvez possa ser um pouco mais jogado, mas fiquei sem ideias.

JavaScript (Node.js) , 148 pontuação + 109 73 bytes

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)

Experimente online! Explicação: lacompanha o último número gerado e macompanha o próximo número da paridade oposta a l; uma vez lexcedido, m+2as variáveis ​​são trocadas. Um ajuste é feito no início da sequência para que as seqüências cujos comprimentos não sejam múltiplos de 5 não percam nenhum número e outro ajuste é feito n=4.