Boa noite golfistas!

Seu desafio é desorganizar completamente uma série de números.

Entrada

Exatamente 100 números inteiros serão alimentados no seu programa. Seu programa pode aceitar a entrada como um arquivo ou via stdin. Cada número inteiro será separado por um caractere de nova linha.

Esses 100 números inteiros variam do mínimo ao máximo de um número inteiro assinado no idioma escolhido.

Não haverá valores duplicados. Os valores podem ser ordenados, não ordenados ou parcialmente solicitados - seu programa deve poder lidar com cada caso.

Resultado

A saída deve ser cada um dos 100 números inteiros, completamente sem classificação, cada um separado por um caractere de nova linha. A saída pode ser via stdout ou para um arquivo.

Completamente não classificado significa que nenhum valor é adjacente a qualquer valor ao qual seria adjacente se a lista fosse completamente classificada em uma sequência ordenada.

Ponto

1 ponto por personagem e a pontuação mais baixa vence. Há um bônus de -100 para qualquer solução que não utilize funções de classificação de biblioteca ou internas. Há um bônus de -20 para quaisquer soluções que não utilizem funções numéricas aleatórias incorporadas.

Eu tentei definir esta questão o mais completamente possível. Se você tem alguma dúvida, por favor, pergunte. Se você tiver algum comentário sobre como eu poderia melhorar na próxima vez, entre em contato.

Fore!

GolfScript (pontuação 27 - 120 = -93)

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

Nota: isso $está referenciando um elemento na pilha. Há classificação, mas é feita com uma classificação de bolha codificada manualmente.

Graças a Howard, por -90 => -92; e Ilmari, que inspirou -92 => -93.

Python -26

(94-120): Nova abordagem bruta. Continue inserindo os elementos mais baixos na nova lista para classificar os elementos e itere:

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): Primeira abordagem: remove os quatro elementos mais baixos de cada vez e imprime esses quatro em outra ordem:

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)

O programa lê a partir de stdin e faz uma ordenação de inserção simples, depois imprime o enésimo com o número n + 50, como muitas das outras soluções.

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

Editar :

Esta versão não depende de funções internas para classificação de listas, nem de funções aleatórias.

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

J, -63 (57-120) caracteres

Como todo mundo está seguindo a rota de classificação auto-escrita ...

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

Não usa nenhuma função de número aleatório, nem qualquer classificação interna.

Usa uma classificação de seleção recursiva simples para classificar a entrada.

Ruby 1.9, -59

(61-120)

Recursão! De fato, este, diferentemente das minhas tentativas anteriores de Ruby, desorganiza a lista, independentemente da ordem original.

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

Tentativas anteriores

One-liner bonito, agora usando a classificação incorporada para funcionar corretamente:

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

Primeiro - não ordenou necessariamente os últimos 4 valores:

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

Caractere Python 2: 90

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]

tentativa preguiçosa, mas apenas para iniciantes

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

Não testei isso porque não é garantido (ou provável) que seja executado em um período de tempo razoável, mas deve funcionar em teoria, dado um 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: os espaços anteriores if L[i]>...devem ser uma guia, mas aparentemente aparecem como espaços em um bloco de código.

Perl 5: 95 - 120 = -25 caracteres

Contando a seguinte linha de comando:

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

Ruby: -50 (70 caracteres - 120)

Fiz o mesmo que muitas outras respostas: remova iterativamente o max e min da lista de entrada e anexe-os à saída. No entanto, percebi que se os 2 números em ambos os lados da mediana forem consecutivos, a saída estará incorreta (porque esses 2 números consecutivos aparecerão juntos no final da saída). Para corrigir isso, eu giro a lista "não classificada" diretamente por 1 elemento:

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

Ou, para trabalhar com muitas entradas arbitrariamente (usando apenas mais 4 caracteres):

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

Nota: Algumas respostas Ruby com menos caracteres já foram publicadas, mas essas soluções não abordaram o problema médio (e / ou assumiram uma lista de entrada classificada).

J 37 - 100 = -63

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

Não usa classificação (embora use classificação acima) Usa números aleatórios.

Explicação:

({~?~@#)             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 bytes - 120 = -98

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

Experimente online!

O link TIO possui apenas uma entrada de oito números inteiros, em vez de cem, porque é tão terrivelmente lento que não aguenta mais em 60 segundos. A razão para isso é que, entre outras coisas, em vez de implementar algum algoritmo de classificação simples, mas normal, para o bônus obrigatório, eu, por questões de brevidade, usei o que equivale a um bogoort determinístico:p≤₁ retrocede a cada permutação da entrada até encontrar uma. o que não diminui. Embora um motivo maior provavelmente seja o fato de que ele emprega um grau semelhante de força bruta para encontrar a saída e que recalcula a versão classificada toda vez ... Tentei testá-la em uma entrada real do tamanho 100, mas estou não tenho certeza de quantos dias serão necessários.

Uma versão geral melhor:

Brachylog , 14 bytes - 20 = -6

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

Experimente online!

Isso ignora os requisitos de E / S antiquados para concisão e deixa de receber o bônus de -100 para que possa ser testado sem um supercomputador (embora, ao escrever isso, eu o tenha executado em apenas 20 itens por vários minutos e ainda não me deu nada).

 .                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.

Quarto (gforth) , 79 - 120 = -21 bytes

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

Experimente online!

Ignore os requisitos de entrada antiquados e recebe a entrada como um endereço na memória onde os números estão armazenados.

Explicação

Passa por todos os números de 0 a 99. Para cada número (n):

• Se n for 0:
  • gera o valor no endereço da matriz + 1
• Senão Se n for 99:
  • gera o valor no endereço da matriz + 98
• Senão Se n for ímpar:
  • gera o valor no endereço da matriz + (n + 2)

• Senão (n é par):

  • gera o valor no endereço da matriz + (n - 2)

• Saída de uma nova linha

Código Explicação

: 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