Sleep Sort è un algoritmo di ordinamento di numeri interi che ho trovato su Internet. Apre un flusso di output e, per ogni numero di input in parallelo, ritarda per il numero di secondi ed emette quel numero. A causa dei ritardi, l'ultimo numero verrà emesso per ultimo. Stimo che ha O (n + m), dove n è il numero di elementi e m è il numero più alto.

Ecco il codice originale in Bash

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

Ecco lo pseudocodice

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

Il tuo compito è implementare l'ordinamento in sospensione come funzione nel linguaggio di programmazione che preferisci. Puoi trascurare qualsiasi fattore di concorrenza come le condizioni di gara e non bloccare mai alcuna risorsa condivisa. Vince il codice più corto. La definizione della funzione conta per la lunghezza del codice.

L'elenco di input è limitato a numeri interi non negativi e la lunghezza dell'elenco di input dovrebbe essere ragionevolmente lunga (testare almeno 10 numeri) in modo che le condizioni di gara non si verifichino mai. e supponendo che le condizioni di gara non accadano mai.

Una specie di zoppo Perl , 59 55 52 38 32 caratteri :

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

Barebones: 25 Personaggi:

... se non ti dispiace i risultati dell'ordinamento come output die:

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

Con tutte le guarnizioni:

(per la massima conformità alla sfida, 44 caratteri)

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

Se permetti a perl di aspettarti, 39 caratteri:

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

E ancora, se non ti dispiace die(), 32 personaggi ...

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

Si noti che in Perl 6, o quando viene dichiarata la funzione 'say', è possibile sostituire la printfunzione con say, salvando un carattere in ogni istanza. Ovviamente poiché dieentrambi terminano il processo a fork e scrivono l'output, rimane la soluzione più breve.

C , 127 caratteri, una soluzione piuttosto ovvia:

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

(Compilato gcc -std=c99 -fopenmp sort.ce ignorato tutti gli avvisi.)

Ruby 1.9, 32 caratteri

Come una funzione:

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

Se possiamo semplicemente usare una variabile predefinita, si riduce a 25 caratteri:

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

JavaScript , 65 caratteri (a seconda che tu usi console.logo qualcos'altro per produrre il risultato)

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

Ciò presuppone che si atratti di un array di numeri interi non negativi e che map()esiste sul prototipo di array (JavaScript 1.6+).

APL ( 15 13)

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

Cosa fa:

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

Quattro tentativi a Erlang:

Uscita sulla console, si sono presi la libertà di farlo ciascuno 9ms * Numberpoiché questo è abbastanza per farlo funzionare (testato su una scheda Atom integrata = lenta):

Ha bisogno di 60 caratteri

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

L'output sulla console è totalmente non-cancellabile, quindi inviamo un messaggio da elaborare Pinvece:

Ha bisogno di 55 caratteri

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

Anche l'invio dopo un certo periodo di tempo può essere effettuato in modo diverso (funziona anche con 1ms * Number):

Ha bisogno di 41 caratteri

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

In realtà questo è un po 'ingiusto poiché la funzione integrata send_afterè in ritardo e necessita dello spazio dei nomi con erlang:prefisso, se consideriamo questo spazio dei nomi importato (fatto a livello di modulo):

Ha bisogno di 34 caratteri

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

C # - 137 caratteri

Ecco una risposta in C # (aggiornata con gradi di parallelismo come commentato)

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

Modifica del codice di BiggAl, dato che è il gioco a cui stiamo giocando ...

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

... o 97 175 con avviamento ritardato del filo

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

Accetta input dalla riga di comando, ala

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

Come con molti golf python, arriva un punto in cui il codice è abbastanza compatto che l'aliasing delle variabili per abbreviare i nomi non salva nemmeno i caratteri.

Questo è funky però perché alias sys e thread ENTRAMBE come t, quindi sys.argv diventa t.argv. Più breve rispetto all'importazione di foo * e un risparmio netto di carattere! Comunque suppongo che Guido non sarebbe contento ...

Nota per l'autoapprendimento ce smettere di giocare a golf in Python. SANTA MUCCA QUESTO È PIÙ BREVE DELLA SOLUZIONE C!

Per divertimento, ecco una versione di ColdFusion (8+) ;-) Ha 109 caratteri che non contano gli avvolgimenti di riga e il rientro che ho aggiunto per leggibilità qui.

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

Questo presuppone che <cfoutput>sia in vigore. Alcuni personaggi potrebbero essere salvati scrivendo tutto su una riga.

Java (alias mai vince a codegolf): 234 211 187 caratteri

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 caratteri

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

Scala - 42 40 caratteri (custodia speciale)

Se si dispone di un pool di thread almeno delle dimensioni del numero di elementi dell'elenco:

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

Scala - 72 caratteri (generale)

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

Haskell - 143 caratteri

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

Questo probabilmente potrebbe essere abbreviato prendendo input su stdin se fosse un'opzione, ma è tardi e in entrambi i casi, è ancora 104 caratteri per la funzione stessa.

Befunge-98, 38 31 byte

So che questa è una vecchia sfida, ma di recente ho scoperto sia i linguaggi sleepsort che i linguaggi 2D, ho avuto un'idea su come combinarli e ho cercato un posto per pubblicarlo, quindi eccoci qui.

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

L'IP principale legge un numero ( &), quindi colpisce chi lo tclona: uno procede sulla stessa linea e cicli, leggendo nuovi numeri e generando nuovi figli fino a raggiungere EOF che termina la sequenza. Tutti i processi figlio rimangono bloccati in un ciclo chiuso (la ve ^della terza colonna) fino a quando l'IP principale non termina la lettura dell'input ed esegue la sequenza di comandi '<21p, che mette il carattere <in posizione (1,2), sovrascrivendo ^e liberando tutto i processi figlio, che iniziano a scorrere contemporaneamente, riducendo di 1 il loro numero ad ogni iterazione. Poiché la velocità di esecuzione di IP diversi è sincronizzata in befunge, termineranno (e stamperanno il loro valore) in ordine, ordinando l'elenco di input.

Un po 'in ritardo alla festa:

Acero - 91 83 caratteri

Nel 91:

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

Nell'83:

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

(Ciò richiede Maple versione 15 e si aspetta che l'elenco venga ordinato in L)

C, 70 69 caratteri

Non attende la restituzione dei processi figlio, altrimenti funziona.

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

PHP 57 byte

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

pcntl_fork () è disponibile solo su Linux.

Bash (38):

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

Modifica: virgola mobile dallo stdin, separato da spazi o newline.

Haskell, 90

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

Spero che questo soddisfi tutti i requisiti.

𝔼𝕊𝕄𝕚𝕟, 11 caratteri / 22 byte

ïć⇝שĤ⇀ôa,a⸩

Try it here (Firefox only).

שĤ⇀ôa, sembra fantastico.

Solo alcune modifiche dalla versione di @rmckenzie:

Inizio del thread ritardato Python 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()

Python senza indugio 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()

Ha gestito alcune ulteriori ottimizzazioni, utilizzando Timerinvece di Thread, che ha una chiamata più concisa e ha rimosso la necessità di importare time. Il metodo di avvio ritardato del thread trae vantaggio dalla comprensione dell'elenco in quanto elimina la necessità di inizializzare l'elenco separatamente all'inizio, sebbene sia più lungo di due caratteri ( "["+"]"+" "-":") rispetto al ciclo for, quindi è inutile senza avvio ritardato e devi fare attenzione a usare un elenco piuttosto che un generatore, o in realtà non stai creando i thread del timer fino a quando non attraversi il generatore.

Qualcun altro ha qualche ottimizzazione?

Il trucco con asaiuta, ma in 2.7.1 puoi importare solo un modulo in un alias, e dopo aver giocato un po 'su di te non puoi nemmeno import mod1,mod2 as a,b, devi farlo import mod1 as a, mod2 as b. Salva ancora alcuni personaggi, ma non è proprio la cura-tutto ciò che pensavo fosse ... E in effetti è meglio lasciare sys come sys. Aliasing threading aiuta ancora comunque ...

Clojure, 54

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

Ruggine - 150 byte

Ed è per questo che non si codice golf in Rust, è più prolisso di Java;). Dipende dalla cassa esterna crossbeam, senza di essa sarebbe anche peggio.

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

Programma di test completo:

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

Tipo di noioso, porto di C #, solo per ricominciare con la lingua:

F # - 90 caratteri

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

o 71/65 caratteri con non standardità:

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

Tcl 8.6, 41 caratteri

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

Devi ucciderlo con ^C

VB.NET 100 byte

Poiché VB.Net richiede lambda a riga singola per contenere solo un'istruzione, questo codice deve contenere più righe:

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

Tuttavia non sono sicuro se conti le dichiarazioni di importazione nei conteggi dei byte perché se non le conti allora potrei scrivere questo:

VB.NET 71 byte

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 byte

Presuppone che i numeri siano indicati nella riga di comando ...

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

Mathematica, 34 o 36 byte

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

Basta aggiungere l'elenco da ordinare alla fine di questo codice e valutare. Se deve essere una definizione di funzione valida, sono necessari due byte extra:

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

C ++ 11, 229 byte

#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 e utilizzo:

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