Uyku Sıralama, Internet'te bulduğum bir tamsayı sıralama algoritmasıdır. Bir çıkış akışını açar ve her giriş numarası için paralel olarak, saniye saniye geciktirir ve bu sayıyı çıkarır. Gecikmeler nedeniyle, en yüksek sayı en son verilecektir. O öğesinin (n + m) olduğunu tahmin ediyorum, burada n elementlerin sayısı ve m en yüksek sayıdır.

İşte Bash'deki orijinal kod

#!/bin/bash
function f() {
    sleep "$1"
    echo "$1"
}
while [ -n "$1" ]
do
    f "$1" &
    shift
done
wait

İşte sözde kod

sleepsort(xs)
 output = []
 fork
   for parallel x in xs:
     sleep for x seconds
     append x to output
 wait until length(output) == length(xs)
 return output

Göreviniz, Uyku Sıralama'yı seçtiğiniz programlama dilinde bir işlev olarak uygulamaktır. Yarış koşulları gibi eşzamanlılık faktörlerini ihmal edebilir ve paylaşılan kaynakları asla kilitlemeyebilirsiniz. En kısa kod kazanır. Fonksiyon tanımı kod uzunluğuna göre sayılır.

Giriş listesi yalnızca negatif olmayan tam sayılarla sınırlıdır ve giriş listesinin uzunluğunun makul uzunlukta olması beklenir (en az 10 sayı test edin), böylece yarış koşulları asla gerçekleşmez. ve yarış koşullarının asla gerçekleşmeyeceğini varsaymak.

Bir çeşit topal Perl girişimi, 59 55 52 38 32 karakter :

map{fork||exit print sleep$_}@a

Barebones: 25 Karakterler:

... eğer sıralama sonuçlarının kalıp çıktısı olarak sakıncası yoksa:

map{fork||die sleep$_}@a

Tüm abartılarla:

(maksimum meydan uyumluluğu için 44 karakter)

sub t{map{fork||exit print sleep$_}@_;wait}

Perl'in seni beklemesine izin verirsen, 39 karakter:

sub t{map{fork||exit print sleep$_}@_}

Ve yine, sakıncası yoksa die(), 32 karakter ...

sub t{map{fork||die sleep$_}@_}

Perl 6'da veya 'say' özelliği bildirildiğinde, her durumda bir karakterin kaydedilmesiyle printfonksiyonun değiştirilebileceğini unutmayın say. Açıkçası dieher ikisi de çatallı işlemi sonlandırdığı ve çıktıyı yazdığı için, en kısa çözüm olmaya devam ediyor.

C , 127 karakter, oldukça açık bir çözüm:

main(int c,char**v){
#pragma omp parallel for num_threads(c)
for(int i=1;i<c;++i){int x=atoi(v[i]);sleep(x);printf("%d ",x);}}

( gcc -std=c99 -fopenmp sort.cTüm uyarılarla derlenmiş ve yok sayılmış)

Yakut 1.9, 32 karakter

İşlev olarak:

s=->a{a.map{|i|fork{p sleep i}}}

Sadece önceden tanımlanmış bir değişken kullanabilirsek, 25 karaktere düşürür:

a.map{|i|fork{p sleep i}}

JavaScript , 65 karakter ( console.logsonucu yazdırmak için kullanmanıza veya başka bir şey kullanmanıza bağlı olarak)

a.map(function(v){setTimeout(function(){console.log(v)},v*1000)})

Bu a, negatif olmayan bir tamsayı map()dizisi olduğunu ve dizi prototipinde bulunduğunu varsayar (JavaScript 1.6+).

APL ( 15 13)

{⎕←⍵⊣⎕DL⍵}&¨⎕

Bu ne yapar:

¨⎕       : for each element of the input
&        : do on a separate thread
⎕DL⍵    : wait approx. ⍵ seconds
⎕←⍵     : output ⍵

Erlang'da dört deneme sayısı:

Konsolun çıktısı, her birini yapma özgürlüğünü kullandı, 9ms * Numberçünkü çalışması için yeterince yeterli (Atom'un gömülü panosunda test edildi = yavaş):

60 karakter gerekiyor

s(L)->[spawn(fun()->timer:sleep(9*X),io:write(X)end)||X<-L].

Konsolun çıktısı tamamen Erlangish değil, bu yüzden işlem Pyerine bir mesaj gönderiyoruz :

55 karakter gerekiyor

s(P,L)->[spawn(fun()->timer:sleep(9*X),P!X end)||X<-L].

Bir süre sonra gönderme de farklı şekilde yapılabilir (bu, bununla da çalışır 1ms * Number):

41 karakter gerekiyor

s(P,L)->[erlang:send_after(X,P,X)||X<-L].

Aslında bu biraz haksızdır çünkü yerleşik işlevi send_aftergeç gelen bir isimdir ve erlang:eğer bu isim alanının içe aktarıldığını düşünürsek (modül düzeyinde yapılır) önceden adlandırılmış ad alanına ihtiyaç duyar :

34 karakter gerekiyor

s(P,L)->[send_after(X,P,X)||X<-L].

137 karakter

İşte C # 'daki bir cevap (yorumlandığı gibi paralellik dereceleriyle güncellendi)

void ss(int[]xs){xs.AsParallel().WithDegreeOfParallelism(xs.Length).Select(x=>{Thread.Sleep(x);return x;}).ForAll(Console.WriteLine);}

Python - 81 93 148 150 153

Tweaking @ BiggAl'in kodu, çünkü oynadığımız oyun bu ...

import threading as t,sys
for a in sys.argv[1:]:t.Timer(int(a),print,[a]).start()

... veya 97 175 gecikmeli diş başlangıcında

import threading as t,sys
for x in [t.Timer(int(a),print,[a]) for a in sys.argv[1:]]:x.start()

Komut satırı, ala üzerinden girdi alır

./sleep-sort\ v0.py 1 7 5 2 21 15 4 3 8

Pek çok python golfde olduğu gibi, kodun yeterince küçük olduğu ve isimleri kısaltmak için değişkenlerin isimlendirilmesinin bile karakterleri kurtarmayacağı bir noktaya gelir.

Bu, ancak sys isimlendirdiği ve BOTH'yi t olarak geçirdiği için korkak, bu yüzden sys.argv, t.argv olur. Foo ithalinden * daha kısa ve net karakter tasarrufu! Ancak sanırım Guido memnun olmazdı ...

Kendine dikkat - c öğren ve python ile golf oynamayı bırak. KUTSAL İNANÇ BU C ÇÖZÜMÜNDEN DAHA FAZLA!

Eğlence için, işte bir ColdFusion (8+) sürümü ;-) Satır sargılarını ve okunabilirliği eklemek için eklediğim sayılan 109 karakterden oluşuyor.

<cfloop array="#a#" index="v">
  <cfthread><cfthread action="sleep" duration="#v*1000#"/>#v#</cfthread>
</cfloop>

Bu <cfoutput>, yürürlükte olduğunu varsayar . Hepsi tek bir satıra yazılarak birkaç karakter kaydedilebilir.

Java (aka asla kodgolfta kazanmaz): 234 211 187 karakter

public class M{public static void main(String[]s){for(final String a:s)new Thread(){public void run(){try{sleep(Long.parseLong(a));}catch(Exception e){}System.out.println(a);}}.start();}}

ungolfed:

public class M {
    public static void main(String[] s) {
        for(final String a:s) new Thread(){
            public void run() {
                try {
                    sleep(Long.parseLong(a));
                } catch(Exception e){}
                System.out.println(a);
            }
        }.start();
    }
}

Javascript - 52 karakter

for(i in a)setTimeout("console.log("+a[i]+")",a[i])

Scala - 42 40 karakter (özel durum)

Bir iş parçacığı havuzunuz varsa, en azından liste öğesi sayısı boyutunda:

a.par.map{i=>Thread.sleep(i);println(i)}

Scala - 72 karakter (genel)

a.map(i=>new Thread{override def run{Thread.sleep(i);println(i)}}.start)

Haskell - 143 karakter

import Control.Concurrent
import System
d=threadDelay
f x=d(10^6*x)>>print x
g s=mapM(forkIO.f)s>>d(10^6*maximum s+1)
main=getArgs>>=g.map read

Bu seçenek, eğer bir seçenek olsaydı, stdin'e girdi alarak daha da kısaltılabilirdi, ancak geç ve her iki durumda da, fonksiyonun kendisi için hala 104 karakterdir.

Befunge-98, 38 31 bayt

Bunun eski bir meydan okuma olduğunu biliyorum, ancak kısa bir süre önce hem sleeport hem de 2D dilleri keşfettim, onları nasıl birleştireceğimiz hakkında bir fikrim vardı ve onu göndermek için bir yer aradım, işte buradayız.

&#vt6j@p12<'
v:^ >$.@
>:!#^_1-

Ana IP bir sayı ( &) okur , sonra klonuna isabet eder t: biri aynı hatta ilerler, yeni sayılar okur ve diziyi sonlandıran EOF'a ulaşana kadar yeni çiller üretir. Tüm alt işlemler , ana IP girişi okumayı bitirene ve karakteri (1,2) konumuna koyan, komutun üzerine yazıp boş bırakan komut dizisini yerine getirene kadar kapalı bir döngüde ( vve ^üçüncü sütunun içinde) sıkışıp kalır. aynı anda dönmeye başlayan çocuk süreçleri, her bir yinelemede sayıları 1 azalır. Farklı IP'lerin yürütme hızı befunge'de senkronize edildiğinden, giriş listesini sıralayarak sırayla sonlandıracak (ve değerlerini yazdıracaklardır).'<21p<^

Partiye biraz geç kaldım:

Akçaağaç - 91 83 karakter

91'de:

M:=():use Threads in p:=proc(n)Sleep(n);:-M:=M,n;end:Wait(map(i->Create(p(i)),L)[])end:[M];

83'te:

M:=():use Threads in Wait(seq(Create(proc(n)Sleep(n);:-M:=M,n end(i)),i=L))end:[M];

(Bu Maple sürüm 15 gerektirir ve listenin L cinsinden sıralanmasını bekler)

C, 70 69 karakter

Alt işlemlerin geri dönmesini beklemez, aksi takdirde çalışır.

main(n) {
    while(~scanf("%d",&n)?fork()||!printf("%d\n",n,sleep(n)):0);
}

PHP 57 bayt

<?for(;$i=fgets(STDIN);)pcntl_fork()?:die($i.usleep($i));

pcntl_fork () yalnızca linux altında kullanılabilir.

Bash (38):

xargs -P0 -n1 sh -c 'sleep $0;echo $0'

Düzenleme: Stdin'den kayan nokta, boşluk veya yeni satırlarla ayrılmış.

Haskell, 90

import Control.Concurrent
s::[Int]->IO()
s=mapM_(\x->forkIO$threadDelay(x*9999)>>print x)

Umarım bu tüm şartları yerine getirir.

11, 11 karakter / 22 bayt

ïć⇝שĤ⇀ôa,a⸩

Try it here (Firefox only).

שĤ⇀ôa, bu harika görünüyor.

@Rmckenzie 'nin versiyonundan sadece bir kaç ayar:

Python gecikmeli iş parçacığı başlangıç 155 152 114 108 107:

import sys, threading as t
for x in [t.Timer(int(a),sys.stdout.write,[a]) for a in sys.argv[1:]]:x.start()

Gecikme olmadan Python 130 128 96 95 93:

import sys,threading as t
for a in sys.argv[1:]:t.Timer(int(a),sys.stdout.write,[a]).start()

TimerBunun yerine, Threaddaha özlü bir aramaya sahip olan ve içe aktarma ihtiyacını ortadan kaldıran birkaç optimizasyon gerçekleştirildi time. Gecikmeli iş parçacığı başlangıç ​​yöntemi, listeyi başlangıçta ayrı başlatma gerekliliğini ortadan kaldırdığından liste kavramasından yararlanır, ancak "["+"]"+" "-":"for döngüsünden iki karakter daha uzun ( ) olsa da gecikmeli başlatma olmadan işe yaramaz ve bir liste kullanmaya dikkat etmeniz gerekir. Bir jeneratör yerine, veya siz jeneratörden geçinceye kadar gerçekte zamanlayıcı iş parçacıkları oluşturmazsınız.

Başka birinin optimizasyonu var mı?

İşin püf noktası asyardımcı olur, ancak 2.7.1'de yalnızca bir modülü bir takma adı içine aktarabilirsiniz, ve bazılarınız oyundan sonra bile yapamazsınız . Hala birkaç karakter kaydeder, ama tam olarak düşündüğüm tek tedavi değil ... Sys'i sys olarak bırakmak daha iyidir. Takma diş takma işlemi yine de yardımcı olur ...import mod1,mod2 as a,bimport mod1 as a, mod2 as b

Clojure, 54

(defn s[n](doseq[i n](future(Thread/sleep i)(prn i))))

Pas - 150 bayt

Ve bu yüzden Rust'ta golf kodunu yazmıyorsunuz, Java'dan daha ayrıntılı;). Dış kasaya bağlı olarak crossbeam, onsuz daha da kötü olurdu.

|x|{extern crate crossbeam;crossbeam::scope(|s|for&v in x{s.spawn(move||{std::thread::sleep(std::time::Duration::from_secs(v));println!("{}",v)});})}

Komple test programı:

fn main() {
    let z =
    |x|{extern crate crossbeam;crossbeam::scope(|s|for&v in x{s.spawn(move||{std::thread::sleep(std::time::Duration::from_secs(v));println!("{}",v)});})}
    ;
    z(&[4, 2, 3, 5, 7, 8, 9, 1, 6, 10])
}

Bir nevi sıkıcı, C # limanı, tekrar dil ile başlamak için:

F # - 90 karakter

PSeq.withDegreeOfParallelism a.Length a|>PSeq.iter(fun x->Thread.Sleep(x);printfn "%A" x)

JavaScript, 74

function(a){for(i=0;i<a.length;i++)setTimeout('alert('+a[i]+')',a[i]*1e3)}

veya standart olmayan 71/65 karakter:

function(a){a.map(function(v){setTimeout('console.log('+v+')',v*1e3)})}

Tcl 8.6, 41 karakter

lmap c $argv {after $c "puts $c"};vwait f

Onu öldürmek zorundasın. ^C

VB.NET 100 bayt

VB.Net sadece bir cümle içermesi için tek satırlı lambda gerektirdiğinden, bu kodun birden çok satırının olması gerekir:

Array.ForEach(i, Async Sub(x)
Await Threading.Tasks.Task.Delay(x*1000)
Console.WriteLine(x)
End Sub)

Ungolfed:

Option Strict Off

Sub Main(i() as String)
    Array.ForEach(i, Async Sub(x)
                         Await Threading.Tasks.Task.Delay(x * 1000)
                         Console.WriteLine(x)
                     End Sub)
End Sub

Ancak bayt sayıları içindeki ithalat ifadelerini sayıp saymadığınızdan emin değilim çünkü saymazsanız şunu yazabilirim:

VB.NET 71 bayt

a.ForEach(i, Async Sub(x)
Await t.Delay(x*1000)
c.WriteLine(x)
End Sub)

Ungolfed:

Option Strict Off
Imports t = System.Threading.Tasks.Task
Imports c = System.Console
Imports a = System.Array

Sub Main(i() as String)
    a.ForEach(i, Async Sub(x)
                     Await t.Delay(x * 1000)
                     c.WriteLine(x)
                 End Sub)
End Sub

Groovy, 47 bayt

Sayıların komut satırında verildiğini varsayar ...

args.each{i->Thread.start{sleep(i*22)print i}}

Mathematica, 34 veya 36 bayt

RunScheduledTask[Print@#,{#,1}]&/@

Sadece bu kodun sonuna göre sıralanacak listeyi ekleyin ve değerlendirin. Geçerli bir fonksiyon tanımı olması gerekiyorsa iki ekstra bayt alır:

RunScheduledTask[Print@#,{#,1}]&/@#&

C ++ 11, 229 bayt

#import<future>
#import<iostream>
using namespace std;int main(int a,char**v){auto G=new future<void>[a];while(--a){G[a]=move(async([=](){this_thread::sleep_for(chrono::seconds(atoi(v[a])));cout<<v[a]<<" "<<flush;}));}delete[]G;}

Ungolfed ve kullanım:

#import<future>
#import<iostream>
using namespace std;
int main(int a,char**v){
 auto G=new future<void>[a];
 while(--a){
  G[a]=move(async(
   [=](){
    this_thread::sleep_for(chrono::seconds(atoi(v[a])));
    cout<<v[a]<<" "<<flush;
   }
  ));
 }
 delete[]G;
}