좋은 저녁 골퍼!

당신의 도전은 일련의 숫자를 완전히 분류하는 것입니다.

입력

정확히 100 개의 정수가 프로그램에 공급됩니다. 프로그램은 입력을 파일 또는 stdin을 통해 승인 할 수 있습니다. 각 정수는 개행 문자로 구분됩니다.

100 개의 정수는 선택한 언어에서 부호있는 정수의 최소값에서 최대 값까지입니다.

중복 값이 ​​없습니다. 값은 순서가 있거나 순서가 없거나 순서대로 정렬 될 수 있습니다. 프로그램은 각 경우를 처리 할 수 ​​있어야합니다.

산출

출력은 완전히 정렬되지 않은 100 개의 정수로 각각 개행 문자로 구분되어야합니다. 출력은 stdout 또는 파일을 통해 이루어질 수 있습니다.

완전 정렬 되지 않음은 목록이 정렬 된 순서대로 완전히 정렬 된 경우 인접한 값에 인접한 값이 없음을 의미합니다.

점수

캐릭터 당 1 점, 가장 낮은 점수가 승리합니다. 내장 또는 라이브러리 정렬 기능을 사용하지 않는 솔루션의 경우 -100의 보너스가 있습니다. 내장 난수 함수를 사용하지 않는 솔루션에는 -20의 보너스가 있습니다.

이 질문을 가능한 한 완벽하게 정의하려고 노력했습니다. 궁금한 점이 있으면 문의하십시오. 다음에 더 잘할 수있는 방법에 대한 의견이 있으면 알려주십시오.

전부!

GolfScript (점수 27-120 = -93)

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

참고 : $스택의 요소를 참조하고 있습니다. 정렬이 있지만 수동으로 코딩 된 버블 정렬로 수행됩니다.

Howard 덕분에 -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

파이썬 -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 + 50 번째 숫자와 함께 n 번째를 인쇄합니다.

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

난수 함수 나 내장 정렬을 사용하지 않습니다.

간단한 재귀 선택 정렬을 사용하여 입력을 정렬합니다.

루비 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

파이썬 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]

게으른 시도이지만 초보자를위한 것

파이썬 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

합리적인 시간 동안 실행되는 것이 보장되지는 않지만 (무한한 시간 내에 이론적으로 작동해야하기 때문에) 이것을 테스트하지 않았습니다.

파이썬 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]>...은 탭이어야하지만 코드 블록에는 공백으로 표시됩니다.

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

나는 다른 많은 답변과 동일하게 입력 목록에서 max와 min을 반복적으로 제거하고 출력에 추가합니다. 그러나 중간 값의 양쪽에있는 2 개의 숫자가 연속적이라면 출력이 올바르지 않습니다 (2 개의 연속 된 숫자가 출력의 끝에 함께 나타나기 때문에). 이 문제를 해결하기 위해 "정렬되지 않은"목록을 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 링크는 100 개가 아닌 8 개의 정수만 입력합니다. 이는 너무 느려서 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이 홀수 인 경우 :
  • 배열 주소 + (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