Chào buổi tối các gôn thủ!

Thách thức của bạn là hoàn toàn hủy bỏ một loạt các số.

Đầu vào

Chính xác 100 số nguyên sẽ được đưa vào chương trình của bạn. Chương trình của bạn có thể chấp nhận đầu vào dưới dạng tệp hoặc qua stdin. Mỗi số nguyên sẽ được phân tách bằng một ký tự dòng mới.

100 số nguyên đó sẽ nằm trong phạm vi từ giá trị tối thiểu đến giá trị tối đa của một số nguyên đã ký trong ngôn ngữ bạn đã chọn.

Sẽ không có giá trị trùng lặp. Các giá trị có thể được sắp xếp, không theo thứ tự hoặc được đặt một phần - chương trình của bạn sẽ có thể xử lý từng trường hợp.

Đầu ra

Đầu ra phải là mỗi trong số 100 số nguyên, hoàn toàn chưa được sắp xếp, mỗi số được phân tách bằng một ký tự dòng mới. Đầu ra có thể thông qua thiết bị xuất chuẩn hoặc đến một tệp.

Hoàn toàn không được sắp xếp có nghĩa là không có giá trị nào liền kề với bất kỳ giá trị nào mà nó sẽ liền kề nếu danh sách được sắp xếp hoàn toàn theo thứ tự.

Ghi bàn

1 điểm cho mỗi nhân vật, và điểm thấp nhất sẽ thắng. Có phần thưởng -100 cho bất kỳ giải pháp nào sử dụng không có chức năng sắp xếp thư viện hoặc tích hợp. Có phần thưởng là -20 cho bất kỳ giải pháp nào không sử dụng hàm số ngẫu nhiên tích hợp.

Tôi đã cố gắng xác định câu hỏi này hoàn toàn có thể. Nếu bạn có bất kì câu hỏi nào, xin vui lòng hỏi. Nếu bạn có bất kỳ ý kiến ​​về cách tôi có thể làm tốt hơn vào lần tới, xin vui lòng cho tôi biết.

Trán!

GolfScript (điểm 27 - 120 = -93)

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

Lưu ý: đó $là tham chiếu một phần tử trên ngăn xếp. Có sắp xếp, nhưng nó được thực hiện với một loại bong bóng được mã hóa thủ công.

Cảm ơn Howard, vì -90 => -92; và Ilmari, người đã truyền cảm hứng -92 => -93.

Con trăn -26

(94-120): Cách tiếp cận mới, thô thiển. Tiếp tục đưa các phần tử thấp nhất vào danh sách mới để sắp xếp các phần tử, sau đó lặp lại:

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

Con trăn -13

(107-120): Cách tiếp cận đầu tiên: Loại bỏ bốn yếu tố thấp nhất tại một thời điểm, sau đó in bốn yếu tố này theo thứ tự khác:

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)

Chương trình đọc từ stdin và thực hiện một kiểu chèn đơn giản, sau đó nó in số thứ n cùng với số thứ n + 50, giống như nhiều giải pháp khác.

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--);}

Toán học -56 44 4 (95-120) = -25

Chỉnh sửa :

Phiên bản này không dựa trên các hàm dựng sẵn để sắp xếp danh sách, cũng không phải các hàm ngẫu nhiên.

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

Ký tự J, -63 (57-120)

Vì mọi người khác đang đi xuống tuyến đường tự viết ...

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

Không sử dụng bất kỳ hàm số ngẫu nhiên nào, cũng không có bất kỳ loại tích hợp nào.

Sử dụng một loại lựa chọn đệ quy đơn giản để sắp xếp đầu vào.

Hồng ngọc 1.9, -59

(61-120)

Đệ quy! Trên thực tế, cái này không giống như những lần thử Ruby trước đây của tôi, hủy bỏ danh sách bất kể thứ tự ban đầu của chúng.

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

Những nỗ lực trước đây

Một lớp lót dễ thương, hiện đang sử dụng sắp xếp dựng sẵn để hoạt động đúng:

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

Đầu tiên - Không nhất thiết hủy bỏ 4 giá trị cuối cùng:

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

Python 2: 90 char

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]

cố gắng lười biếng nhưng chỉ cho người mới bắt đầu

Con tră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

Không được thử nghiệm điều này bởi vì nó không được đảm bảo (hoặc có khả năng) chạy trong bất kỳ khoảng thời gian hợp lý nào, nhưng sẽ hoạt động theo lý thuyết với thời gian vô hạn.

Con trăn 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]

Lưu ý: khoảng trắng trước if L[i]>...phải là một tab nhưng rõ ràng hiển thị dưới dạng khoảng trắng trong khối mã.

Perl 5: 95 - 120 = -25 ký tự

Đếm dòng lệnh sau:

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 ký tự - 120)

Tôi đã làm tương tự như nhiều câu trả lời khác: lặp đi lặp lại loại bỏ max và min khỏi danh sách đầu vào và nối chúng vào đầu ra. Tuy nhiên, tôi nhận ra rằng nếu 2 số ở hai bên của trung vị là liên tiếp nhau thì đầu ra sẽ không chính xác (vì 2 số liên tiếp đó sẽ xuất hiện cùng nhau ở cuối đầu ra). Để khắc phục điều này, tôi xoay danh sách "chưa sắp xếp" theo 1 phần tử:

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

Hoặc, để làm việc với nhiều đầu vào tùy ý (chỉ sử dụng thêm 4 ký tự):

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

Lưu ý: Một số câu trả lời Ruby ít hơn đã được đăng, nhưng những giải pháp đó không giải quyết được vấn đề trung bình (và / hoặc giả sử một danh sách đầu vào được sắp xếp).

J 37 - 100 = -63

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

Sử dụng không sắp xếp (mặc dù không sử dụng xếp hạng lên) Sử dụng số ngẫu nhiên.

Giải trình:

({~?~@#)             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ẉᵐ

Hãy thử trực tuyến!

Liên kết TIO chỉ có đầu vào gồm tám số nguyên, thay vì một trăm, vì tốc độ này chậm đến mức không thể xử lý được nữa trong 60 giây. Lý do cho điều này là, trong số những thứ khác, thay vì thực hiện một số thuật toán sắp xếp đơn giản nhưng bình thường cho phần thưởng bắt buộc, tôi vì lợi ích của sự ngắn gọn đã sử dụng số tiền cho một bogosort xác định: p≤₁quay lại qua mọi hoán vị của đầu vào cho đến khi tìm thấy đó là không giảm. Mặc dù một lý do lớn hơn có lẽ là nó sử dụng một mức độ vũ phu tương tự để tìm đầu ra, và nó tính toán lại phiên bản đã sắp xếp mỗi lần ... Tôi đã thử kiểm tra nó trên đầu vào thực tế có kích thước 100, nhưng tôi không chắc chắn sẽ mất bao nhiêu ngày.

Một phiên bản tổng thể tốt hơn:

Brachylog , 14 byte - 20 = -6

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

Hãy thử trực tuyến!

Điều này bỏ qua các yêu cầu I / O cổ xưa về tính ngắn gọn và bỏ qua việc nhận phần thưởng -100 để có thể kiểm tra mà không cần siêu máy tính (mặc dù khi viết bài này, tôi đã chạy nó chỉ với 20 mục trong vài phút và nó vẫn chưa cho tôi bất cứ thứ gì).

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

Hãy thử trực tuyến!

Bỏ qua các yêu cầu đầu vào cũ và lấy đầu vào làm địa chỉ trong bộ nhớ nơi các số được lưu trữ.

Giải trình

Vòng lặp thông qua tất cả các số từ 0 đến 99. Với mỗi số (n):

• Nếu n bằng 0:
  • xuất giá trị tại địa chỉ mảng + 1
• Khác Nếu n là 99:
  • xuất giá trị tại địa chỉ mảng + 98
• Khác Nếu n là số lẻ:
  • xuất giá trị tại địa chỉ mảng + (n + 2)

• Khác (n là chẵn):

  • xuất giá trị tại địa chỉ mảng + (n - 2)

• Xuất một dòng mới

Giải thích mã

: 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