Buona sera golfisti!

La tua sfida è annullare completamente una serie di numeri.

Ingresso

Esattamente 100 numeri interi verranno inviati al tuo programma. Il tuo programma può accettare l'input come file o tramite stdin. Ogni numero intero sarà separato da un carattere di nuova riga.

Quei 100 numeri interi varieranno dai valori minimi a massimi di un numero intero con segno nella lingua scelta.

Non ci saranno valori duplicati. I valori possono essere ordinati, non ordinati o parzialmente ordinati: il tuo programma dovrebbe essere in grado di gestire ogni caso.

Produzione

L'output deve essere ciascuno dei 100 numeri interi, completamente non ordinato, ciascuno separato da un carattere di nuova riga. L'output può essere tramite stdout o su un file.

Completamente non ordinato significa che nessun valore è adiacente a nessun valore a cui sarebbe adiacente se l'elenco fosse completamente ordinato in una sequenza ordinata.

Punto

1 punto per personaggio e vince il punteggio più basso. C'è un bonus di -100 per qualsiasi soluzione che non utilizza funzioni di ordinamento di librerie o incorporate. C'è un bonus di -20 per qualsiasi soluzione che non utilizza funzioni numeriche casuali integrate.

Ho cercato di definire questa domanda nel modo più completo possibile. Se avete domande, si prega di chiedere. Se avete commenti su come potrei fare di meglio la prossima volta, per favore fatemi sapere.

Prua, testa!

GolfScript (punteggio 27-120 = -93)

~].,{{.2$<{\}*}*]}*.(;+2%n*

Nota: che $fa riferimento a un elemento nello stack. C'è l'ordinamento, ma è fatto con un ordinamento a bolle codificato manualmente.

Grazie a Howard, per -90 => -92; e Ilmari, che ha ispirato -92 => -93.

Python -26

(94-120): nuovo approccio grezzo. Continua a inserire gli elementi più bassi nel nuovo elenco per ordinarli, quindi esegui l'iterazione:

t=l=[]
i=N=100
exec't=t+[input()];'*N+'l+=[t.pop(t.index(min(t)))];'*N+'print l[i%N];i+=3;'*N

Python -13

(107-120): Primo approccio: rimuove quattro elementi più bassi alla volta, quindi stampa questi quattro in un altro ordine:

exec'l=[]'+'+[input()]'*100
while l:
 a,b,c,d=eval('l.pop(l.index(min(l))),'*4)
 for e in[b,d,a,c]:print e

C: 11 (131-120)

Il programma legge da stdin ed esegue un semplice tipo di inserimento, dopodiché stampa l'ennesimo insieme al numero n + 50, come molte altre soluzioni.

main(){int*i,a[101],*j=a;while(scanf("%d",a)>0)for(i=++j;i-->a;)i[1]=*i>=*a?*i:*(i=a);while(a<(i=j-50))printf("%d\n%d\n",*i,*j--);}

Mathematica -56 44 4 (95-120) = -25

Modifica :

Questa versione non si basa né su funzioni integrate per elenchi di ordinamento né su funzioni di randomizzazione.

Riffle[RotateLeft[#[[All, 2]], 2], #[[All, 1]]] &
[Partition[l //. {x___, a_, b_, y___} /; b < a :> {x, b, a, y}, 2]]

J, -63 (57-120) caratteri

Dal momento che tutti gli altri stanno seguendo la strada dell'ordinamento auto-scritto ...

,50(}.,.{.)($:@([-.m),~m=.]#~]=<./)^:(0<#),".[;._2[1!:1[3

Non utilizza alcuna funzione di numero casuale, né alcun ordinamento incorporato.

Utilizza un semplice ordinamento di selezione ricorsiva per ordinare l'input.

Ruby 1.9, -59

(61-120)

Ricorsione! Questo, infatti, a differenza dei miei precedenti tentativi di Ruby, annulla l'elenco indipendentemente dal loro ordine originale.

p *(f=->l{l[1]&&f[l-m=l.minmax]+m||[]})[$<.map &:to_i].rotate

Tentativi precedenti

Simpatico one-liner, ora utilizza l'ordinamento incorporato per funzionare correttamente:

$<.map(&:to_i).sort.each_slice(4){|a,b,c,d|p b,d,a,c}

Primo: non ho necessariamente annullato gli ultimi 4 valori:

l=$<.map &:to_i
48.times{l-=p *l.minmax}
a,b,c,d=l
p b,d,a,c

Python 2: 90 caratteri

n=100
s=sorted(int(raw_input())for i in range(n))
for i in range(n):print s[(4*i+4*i/n)%n]

tentativo pigro ma solo per cominciare

Python 48 = (148-100)

from random import*
x=[input()for i in range(100)]
while any(abs(x[i]-x[i+1])>1 for i in range(99)):n=randint(1,99);x=x[n:]+x[:n]
for j in x:print j

Non l'ho testato perché non è garantito (o probabile) che funzioni in un periodo di tempo ragionevole, ma dovrebbe funzionare in teoria a tempo infinito.

Python 27 (147-100-20)

R=range
def S(L):
 for i in R(len(L)-1):
    if L[i]>L[i+1]:L[i:i+2]=[L[i+1],L[i]];S(L)
a=map(input,['']*100);S(a)
for i in R(100):print a[i/2+i%2*50]

Nota: gli spazi precedenti if L[i]>...dovrebbero essere una scheda ma apparentemente devono apparire come spazi in un blocco di codice.

Perl 5: 95-120 = -25 caratteri

Contando la seguente riga di comando:

perl -ne '$n=$_;splice@n,(grep{$n[$_]>$n}0..@n),0,$n}{print for map{@n[$_,$#n/2+$_+1]}0..$#n/2'

Rubino: -50 (70 caratteri - 120)

Ho fatto lo stesso di molte altre risposte: rimuove iterativamente il massimo e il minimo dall'elenco di input e li aggiunge all'output. Tuttavia, mi sono reso conto che se i 2 numeri su entrambi i lati della mediana sono essi stessi consecutivi, l'output sarà errato (perché quei 2 numeri consecutivi appariranno insieme alla fine dell'output). Per risolvere questo problema, ho ruotato l'elenco "non ordinato" proprio di 1 elemento:

n=$*.map &:to_i;u=[];50.times{u+=n.minmax;n-=u.last 2};p *u.rotate(-1)

Oppure, per lavorare con arbitrariamente molti input (usando solo altri 4 caratteri):

n=$*.map &:to_i;u=[];(u+=n.minmax;n-=u.last 2)while n.any?;p *u.rotate(-1)

Nota: sono già state pubblicate alcune risposte di Ruby con un numero inferiore di caratteri, ma tali soluzioni non hanno risolto il problema mediano (e / o hanno assunto un elenco di input ordinato).

J 37 - 100 = -63

({~?~@#)^:(+./@(1=|)@(2&(-/\))@/:)^:_

Non utilizza alcun ordinamento (sebbene utilizzi il rango superiore) Utilizza numeri casuali.

Spiegazione:

({~?~@#)             NB. Randomizes the array
^: foobar ^:_        NB. as long as
foo =: +./@(1 = |)   NB. as any 1 == absolute value of
bar =: (2&(-/\))@/:  NB. differences between adjacent ranks
foobar =: foo@bar

Brachylog , 22 byte - 120 = -98

ṇịᵐpX¬{p≤₁s₂.&s₂p}∧Xẉᵐ

Provalo online!

Il collegamento TIO ha solo un input di otto numeri interi, anziché cento, perché è così terribilmente lento che non può più gestirlo in 60 secondi. La ragione di ciò è che, tra le altre cose, piuttosto che implementare un algoritmo di ordinamento semplice ma normale per il bonus obbligatorio, io per brevità ho usato ciò che equivale a un bogosort deterministico: indietreggia p≤₁attraverso ogni permutazione dell'input fino a quando non ne trova uno che non è in calo. Anche se un motivo più grande sarebbe probabilmente che impiega un simile grado di forza bruta per trovare l'output e che ricalcola la versione ordinata ogni volta ... Ho tentato di testarlo su un input effettivo di dimensioni 100, ma sono non sono sicuro di quanti giorni ci vorranno.

Una versione complessivamente migliore:

Brachylog , 14 byte - 20 = -6

p.¬{os₂.&s₂p}∧

Provalo online!

Ciò ignora i requisiti di I / O antiquati per brevità e trascura di prendere il bonus di -100 in modo che possa essere testato senza un supercomputer (anche se al momento della stesura di questo, l'ho fatto funzionare su soli 20 articoli per diversi minuti e non mi ha ancora dato nulla).

 .                The output is
p                 a permutation of
                  the input
  ¬{        }∧    such that it cannot be proven that
         s₂       a pair of adjacent values in
        &         the output
       .   p      is a permutation of
     s₂           a pair of adjacent values in
    o             the output sorted.

Forth (gforth) , 79-120 = -21 byte

: f 100 0 do dup i 2 mod 4 * 2 - i + i 99 = i 0 = - 3 * + cells + @ . cr loop ;

Provalo online!

Ignora i requisiti di input antiquati e accetta input come indirizzo nella memoria in cui sono memorizzati i numeri.

Spiegazione

Passa attraverso tutti i numeri da 0 a 99. Per ogni numero (n):

• Se n è 0:
  • emette il valore all'indirizzo array + 1
• Altrimenti se n è 99:
  • emette il valore all'indirizzo array + 98
• Altrimenti se n è dispari:
  • emette il valore all'indirizzo array + (n + 2)

• Altrimenti (n è pari):

  • emette il valore all'indirizzo array + (n - 2)

• Invia una nuova riga

Spiegazione del codice

: f               \ start new word definition
  100 0 do        \ loop from 0 to 99
    dup           \ duplicate the array address
    i             \ place the loop index on the stack
    2 mod 4 * 2 - \ convert to 2 if it's odd and -2 if it's even
    i +           \ add the result to the the loop index
    i 99 =        \ if i = 99 place -1 on top of the stack, else place a 0
    i 0 =         \ i i = 0 place -1 on top of the stack, else place 0
    - 3 *         \ subtract previous two results from each other and multiply by 3
\ the above line is used to avoid writing if/then by instead using math to get 98 and 1
    +             \ add result to existing result from above
    cells         \ multiply by the size of a single integer in memory
    +             \ add to the array's starting address
    @ . cr        \ get the value at the calculated address, print it, then print a newline
  loop            \ end the loop
;                 \ end the word definition