晚上好，高尔夫球手！

您面临的挑战是完全不对一系列数字进行排序。

输入值

恰好100个整数将被喂入您的程序。您的程序可以将输入作为文件或通过stdin接受。每个整数将由换行符分隔。

在您选择的语言中，这100个整数的范围从带符号整数的最小值到最大值。

不会有重复的值。这些值可以是有序的，无序的或部分有序的-您的程序应该能够处理各种情况。

输出量

输出必须是100个完全未排序的整数，每个整数之间都用换行符分隔。输出可以通过stdout或到文件。

完全未排序表示如果列表按有序序列完全排序，则该值将不与该值相邻。

得分了

每个角色1分，最低分获胜。不使用任何内置或库排序功能的解决方案，则奖励为-100。对于没有内置随机数功能的任何解决方案，奖励为-20。

我试图尽可能完整地定义这个问题。如果您有任何问题，请询问。如果您对我下次如何做有任何评论，请告诉我。

前面！

GolfScript（分数27-120 = -93）

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

注意：这$是在堆栈上引用一个元素。有排序，但是它是通过手动编码的气泡排序完成的。

感谢霍华德，对于-90 => -92; 和Ilmari，他启发了-92 => -93。

蟒蛇-26

（94-120）：新的粗略方法。不断将最低的元素弹出到新列表中，以对元素进行排序，然后进行迭代：

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）：第一种方法：一次删除四个最低元素，然后以另一顺序打印这四个元素：

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）

像许多其他解决方案一样，该程序从stdin读取并执行简单的插入排序，然后将第n个与第n + 50个数字一起打印。

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

编辑：

此版本既不依赖用于列表排序的内置功能，也不依赖于随机化功能。

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

J，-63（57-120）个字符

由于其他所有人都走了自写的排序路线...

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

不使用任何随机数函数，也不使用任何内置排序。

使用简单的递归选择排序对输入进行排序。

Ruby 1.9，-59

（61-120）

递归！实际上，与我之前的Ruby尝试不同，该命令确实对列表进行了排序，而不管它们的原始顺序如何。

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

以前的尝试

可爱的一线飞机，现在使用内置排序功能可以正常工作：

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

第一个-不一定要对最后4个值进行排序：

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

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]

懒惰的尝试，但只适合初学者

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

尚未对此进行测试，因为不能保证（或可能）它在任何合理的时间内运行，但在理论上应该在无限的时间内运行。

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]

注意：之前的空格if L[i]>...应为制表符，但显然在代码块中显示为空格。

Perl 5：95-120 = -25个字符

计算以下命令行：

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

红宝石：-50（70个字符-120）

我做了很多其他的回答：迭代地从输入列表中删除最大值和最小值，并将它们附加到输出中。但是，我意识到，如果中位数两侧的两个数字本身是连续的，则输出将是错误的（因为这两个连续的数字将一起出现在输出的末尾）。为了解决这个问题，我将“未排序”列表向右旋转了1个元素：

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

或者，要使用任意多个输入（仅使用4个以上的字符）：

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

注意：已经发布了一些字符数较少的Ruby答案，但是这些解决方案未解决中位数问题（和/或假设输入列表已排序）。

J 37-100 = -63

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

不使用排序（尽管确实使用排名）使用随机数。

说明：

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

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

在线尝试！

TIO链接仅输入八个整数，而不是一百个，因为它是如此之慢，以至于它无法在60秒内处理更多。原因是，除其他外，我没有为强制性奖金实施一些简单但正常的排序算法，为了简洁起见，我使用了确定性bogosort：p≤₁在输入的每个排列中回溯，直到找到一个这是不减少的。尽管更大的原因可能是它使用相似程度的蛮力来查找输出，并且每次都重新计算排序后的版本...我试图在大小为100的实际输入上进行测试，但是不知道需要多少天。

总体上更好的版本：

Brachylog，14个字节-20 = -6

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

在线尝试！

这忽略了过时的过时I / O要求，并忽略了-100奖金，因此它可能无需超级计算机就可以进行测试（尽管在撰写本文时，我让它仅在20个项目上运行了几分钟，仍然没有给我任何东西）。

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

第四（gforth），79-120 = -21字节

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

在线尝试！

忽略过时的输入要求，并将输入作为存储数字的内存中的地址。

说明

循环从0到99的所有数字。对于每个数字（n）：

• 如果n为0：
  • 在数组地址+1处输出值
• 否则，如果n为99：
  • 在数组地址+ 98处输出值
• 否则，如果n为奇数：
  • 在数组地址+（n + 2）处输出值

• 否则（n为偶数）：

  • 输出数组地址+（n-2）的值

• 输出换行符

代码说明

: 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