Sfida

Dato un numero intero n ≥ 4 , emette una permutazione degli interi [0, n-1] con la proprietà che non esistono due numeri interi consecutivi uno accanto all'altro. Il valore di una permutazione piè la somma di abs(pi[i] - i)per tutti gli indici i.

Esempi

• (1, 3, 0, 2) ha valore 6
• (0, 2, 4, 1, 3) ha valore 6
• (0, 2, 4, 1, 3, 5) ha valore 6
• (0, 2, 4, 1, 5, 3, 6) ha valore 8

Punteggio della tua risposta

Il punteggio della tua risposta è la somma dei valori delle tue permutazioni per n = 4 .. 14più il numero di byte che il tuo codice prende. Più basso è il punteggio, meglio è. Il tuo codice deve fornire un output valido per tutti quei valori di n.

Devi essere in grado di eseguire l'invio fino al completamento sul tuo computer.

In caso di pareggi, sarà il decisore il tempo dell'ultima modifica che ha portato al punteggio pertinente.

Non è la stessa domanda di questa ?

Le risposte alla domanda collegata non saranno competitive per questa domanda in quanto non fanno alcuno sforzo per ottimizzare il valore di una permutazione. Ad esempio n=10, la permutazione [1, 3, 5, 7, 9, 0, 2, 4, 6, 8]data dalla maggior parte delle risposte lì dà un valore di 30. Puoi fare molto meglio di così.

Per la parte di permutazione della domanda, il valore ottimale complessivo è al massimo 120. (Grazie a @Laikoni.) Considerando che la risposta di Dennis alla domanda precedente segna 222 . (Grazie a @ user202729.)

Gelatina , 36 34 33 32 31 30 byte, risultato: 120

Grazie a Dennis per -1 byte! (implicitamente correggendo un bug Jelly, anche se la funzionalità postdatizza la sfida)

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

Nuova funzione: somma accumulata ( Ä).

Provalo online!

Usa 1-indicizzazione.

Richiede anche un tempo lineare.

Questo programma C ++ genera la permutazione lessicograficamente più piccola, supponendo che | i - p _i | ≤ larghezza (dove larghezza è una costante codificata) per tutti 0 ≤ i <n , con complessità temporale circa O (larghezza ² × 2 ^{2 × larghezza} × n) (che è solo O (n) per larghezza fissa ): provalo online !

Come?

1. Scrivi un programma C ++ che tenti di risolvere il problema in modo ottimale.

2. Osserva lo schema. Notiamo che la sequenza di tutti gli elementi tranne 4 ultimi è un prefisso di

   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. Calcola la differenza incrementale della sequenza.

   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
   

   Nota il periodo 5.

4. L'implementazione di Jelly:

   • n-4 primi elementi sono presi dalla sequenza sopra. O (n) .

   • Per gli ultimi 4 elementi, forza bruta tutte e 24 le possibilità . O (1) .

     (nota: non ho più la forza bruta su tutte e 24 le possibilità dalla versione a 32 byte)

CJam (60 byte + 120 = 180 punti)

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

Suite di test online con punteggio integrato

Estensione fino a n = 24

Dissezione

{
  _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 punti + 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

Ripete il motivo [1,3,0,2], gli ultimi mod i 4elementi sono sintonizzati a mano.

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

Brute forza il numero corretto di salti di lunghezza ± 2 o ± 3. Seleziona l'ultimo che contiene i numeri corretti, sembra funzionare bene ed è molto più economico dell'implementazione del punteggio. Tio ha poco tempo prima dell'ultimo punteggio, che è 18.

Provalo online!

Japt, 120 + 20 = 140

(Copiare una delle mie soluzioni dall'altra sfida mi avrebbe segnato 227)

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

Provalo o usa questa versione per controllare i punteggi. Entrambe le versioni potrebbero iniziare a spuntare intorno a te intorno alle 9.

Spiegazione

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

Rubino , 120 punti + 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)}}

Provalo online!

La sequenza è sostanzialmente (a-2)+(a+2)%5.

Se n mod 5 non è 0 o 1, gli ultimi 3 o 4 elementi sono diversi.

Questo è ancora a metà hardcoded, trova sempre la soluzione migliore, forse potrebbe essere un po 'più golfato, ma ho esaurito le idee.

JavaScript (Node.js) , 148 punti + 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)

Provalo online! Spiegazione: ltiene traccia dell'ultimo numero generato e mtiene traccia del numero successivo della parità opposta a l; una volta lsuperato, m+2le variabili vengono scambiate. All'inizio della sequenza viene effettuata una regolazione in modo che le sequenze le cui lunghezze non siano multipli di 5 non perdano alcun numero e viene effettuata un'altra regolazione n=4.