İyi akşamlar golfçüler!

Zorluklarınız bir dizi sayıyı tamamen alt üst etmek.

Giriş

Programınıza tam olarak 100 tamsayı beslenecektir. Programınız girdiyi bir dosya veya stdin aracılığıyla kabul edebilir. Her tamsayı yeni satır karakteri ile ayrılır.

Bu 100 tam sayı, seçtiğiniz dilde işaretli bir tam sayının en düşük değeri ile en yüksek değeri arasında değişir.

Yinelenen değerler olmayacak. Değerler sipariş edilebilir, sırasız veya kısmen sipariş edilebilir - programınız her durumu işleyebilmelidir.

Çıktı

Çıktı, her biri bir satırsonu karakteriyle ayrılmış, tamamen ayrılmamış 100 tamsayıdan her biri olmalıdır. Çıktı stdout aracılığıyla veya bir dosyaya gönderilebilir.

Tamamen Sıralanmamış , listenin sıralı bir sırayla tamamen sıralanması durumunda herhangi bir değerin bitişik olmadığı anlamına gelir.

Puan

Karakter başına 1 puan ve en düşük puan kazanır. Yerleşik veya kütüphane sıralama işlevlerini kullanmayan herhangi bir çözüm için -100 bonusu vardır. Yerleşik rasgele sayı işlevlerini kullanan herhangi bir çözüm için -20 bonusu vardır.

Bu soruyu olabildiğince tam olarak tanımlamaya çalıştım. Herhangi bir sorunuz varsa lütfen sorun. Bir dahaki sefere nasıl daha iyi yapabileceğim hakkında yorumlarınız varsa, lütfen bana bildirin.

Fore!

GolfScript (puan 27-120 = -93)

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

Not: $yığındaki bir öğeye gönderme yapıyor. Sıralama var, ancak manuel olarak kodlanmış bir kabarcık sıralaması ile yapıldı.

Howard sayesinde, -90 => -92 için; ve -92 => -93'e ilham veren Ilmari.

Python -26

(94-120): Yeni, kaba bir yaklaşım. Öğeleri sıralamak için en düşük öğeleri yeni listeye atmaya devam edin, ardından tekrarlayın:

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): İlk yaklaşım: Bir seferde en düşük dört öğeyi kaldırır, ardından bu dördü başka bir sırada yazdırır:

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)

Program stdin'den okur ve basit bir kesici uç sıralaması yapar, daha sonra n n + 50 nolu sayı ile birlikte diğer birçok çözüm gibi yazdırır.

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

Düzenle :

Bu sürüm, listeleri sıralamak için yerleşik işlevlere veya rasgeleleştirme işlevlerine dayanmaz.

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

J, -63 (57-120) karakter

Herkes kendi kendine yazılan sıralama yolunda ilerlediğinden ...

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

Herhangi bir rastgele sayı işlevi veya yerleşik bir sıralama kullanmaz.

Girişi sıralamak için basit bir özyinelemeli seçim sıralaması kullanır.

Yakut 1.9, -59

(61-120)

Özyineleme! Aslında bu, önceki Ruby girişimlerimin aksine, orijinal sıralarına bakılmaksızın listeyi iptal eder.

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

Önceki denemeler

Düzgün çalışmak için yerleşik sıralama kullanan sevimli tek astar:

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

Birincisi - Son 4 değeri mutlaka düşürmek zorunda değildi:

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

Python 2: 90 karakter

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]

tembel girişim ama sadece yeni başlayanlar için

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

Bunu test etmedim, çünkü makul bir süre içinde çalışacağı garanti edilmedi (veya muhtemelen), ancak sonsuz zaman verilen teoride çalışmalı.

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]

Not: önceki boşluklar if L[i]>...bir sekme olmalıdır, ancak görünüşe göre bir kod bloğundaki boşluklar olarak görünmelidir.

Perl 5: 95-120 = -25 karakter

Aşağıdaki komut satırını sayma:

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

Yakut: -50 (70 karakter - 120)

Diğer birçok cevapla aynı şeyi yaptım: giriş listesinden max ve min'i yinelemeli olarak kaldırın ve çıkışa ekleyin. Ancak, medyanın her iki tarafındaki 2 sayının kendisinin ardışık olması durumunda çıktının yanlış olacağını fark ettim (çünkü bu 2 ardışık sayı çıktının sonunda birlikte görünecektir). Bunu düzeltmek için, "sıralanmamış" listesini sağa doğru 1 öğe döndürürüm:

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

Veya keyfi olarak çok sayıda girişle çalışmak için (yalnızca 4 karakter daha kullanarak):

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

Not: Bazı daha az sayıda Ruby cevabı zaten yayınlanmıştır, ancak bu çözümler medyan sorunu ele almamıştır (ve / veya sıralı bir giriş listesi olduğu varsayılmıştır).

J 37-100 = -63

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

Sıralama kullanmaz (sıralamayı kullanır) Rastgele sayılar kullanır.

Açıklama:

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

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

Çevrimiçi deneyin!

TIO bağlantısı, yüz yerine yalnızca sekiz tamsayı girdisine sahiptir, çünkü bu çok korkunç bir şekilde yavaştır ve 60 saniyede daha fazla işleyemez. : Bunun nedeni bir deterministik saçma sıralama ne miktarda kullanılan kısalık uğruna, I zorunlu ikramiye için bazı basit fakat normal sıralama algoritması uygulamak yerine, başka şeylerin yanı sıra, yani p≤₁o bulana kadar girdi her permütasyon yoluyla geri adım attığı ki bu azalmaz. Daha büyük bir neden muhtemelen çıktıyı bulmak için benzer derecede kaba kuvvet kullanması ve sıralanan sürümü her seferinde yeniden hesaplaması olsa da ... 100 büyüklüğünde gerçek bir girdi üzerinde test etmeye çalıştım, ama ben kaç gün alacağından emin değilim.

Genel olarak daha iyi bir sürüm:

Brachylog , 14 bayt - 20 = -6

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

Çevrimiçi deneyin!

Bu, kısaltılmış eski G / Ç gereksinimlerini görmezden gelir ve -100 bonusu almayı ihmal eder, böylece bir süper bilgisayar olmadan test edilebilir (bunu yazarken, birkaç dakika boyunca sadece 20 ürün üzerinde çalıştım ve hala bana hiçbir şey vermedi).

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

Dördüncü (gforth) , 79-120 = -21 bayt

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

Çevrimiçi deneyin!

Antika olmayan giriş gereksinimlerini yok sayın ve girişi sayıların depolandığı bir adres olarak alır.

açıklama

0 ile 99 arasındaki tüm sayılar arasında geçiş yapar. Her sayı için (n):

• N 0 ise:
  • dizi adresi + 1'deki değeri çıktılar
• Else n 99 ise:
  • dizi adresi + 98'deki değeri çıktılar
• Else n tuhafsa:
  • dizi adresi + (n + 2) 'de değeri çıktılar

• Başka (n eşittir):

  • değeri dizi adresindeki çıktısı + (n - 2)

• Yeni satır çıktısı al

Kod Açıklaması

: 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