Ich habe eine Herausforderung für dich:

• Drucken Sie "Hello World" in einer beliebigen Sprache.
• Jedes Zeichen muss aus einem eigenen, eindeutigen Thread gedruckt werden

Das ist es. Da es keine Garantie dafür gibt, dass die Threads in der Reihenfolge ausgeführt werden, in der Sie sie starten, müssen Sie Ihren Programm-Thread sicher machen, um sicherzustellen, dass die Ausgabe in der richtigen Reihenfolge gedruckt wird.

Und weil dies Codegolf ist, gewinnt das kürzeste Programm.

Aktualisieren:

Der Gewinner ist Marinus 'APL-Eintrag mit 34 Zeichen. Es gewinnt auch den Preis für den am wenigsten lesbaren Eintrag.

APL (Dyalog) ( 44 43 39 34)

{⍞←⍺⊣⎕DL⍵}&⌿2 11⍴'Hello World',⍳11

Erläuterung:

• 2 11⍴'Hello World',⍳11 Erstellt eine Matrix: (H, 1), (e, 2), ...
• &⌿ bedeutet: für jede Spalte der Matrix machen Sie auf einem separaten Thread:
• In einem Thread ⍺ist jetzt der Charakter und ⍵ist jetzt die Zeit
• ⎕DL⊃⍵wartet ⍵Sekunden.
• Dann ⍞←⍺gibt das Zeichen.

C, 61 62 Zeichen

i;main(){write(1,"Hello World\n"+i++,1);i>13||fork()||main();}

Die Funktionen der pthread-Bibliothek haben alle laaaaange Namen, daher habe ich stattdessen für jedes Zeichen einen eigenen Prozess gestartet. fork()ist so viel kürzer.

Es musste write()statt verwendet werden, putchar()da die stdio-Pufferfunktionen nicht threadsicher sind.

Bearbeitet : Bis zu 62 Zeichen sichern. In meinem Eifer ließ das Abfallen auf 61 Zeichen auch die Fadensicherheit fallen.

Ruby, 46 Zeichen

"Hello World".chars{|c|Thread.new{$><<c}.join}

Es wird synchronisiert, da das Programm auf das Ende des Threads wartet, bevor der nächste Thread gestartet und mit dem nächsten Zeichen fortgefahren wird.

Pythonect (35 Zeichen)

http://www.pythonect.org

"Hello World"|list|_.split()->print

Python ( 101 93 98)

Dies ist Peter Taylors Lösung. Das Drucken des N-ten Zeichens wird um N Sekunden verzögert. Zeige Kommentare.

import sys.threading as t
for x in range(11):t.Timer(x,sys.stdout.write,"Hello World"[x]).start()

Dies ist das Original:

import sys,threading as t
for x in "Hello World":t.Thread(None,sys.stdout.write,x,x).start()

Es hat funktioniert, weil das Drucken eines einzelnen Zeichens weniger Zeit in Anspruch nimmt als das Initialisieren eines neuen Threads in Python. Daher wurde der N-te Thread beendet, bevor der N + 1-te Thread erstellt wurde. Offensichtlich verstößt es gegen die Regeln, sich darauf zu verlassen.

C # 73

"hello world".ToList().ForEach(c=>Task.Run(()=>Console.Write(c)).Wait());

APL (Dyalog Unicode) , 28 Byte ^SBCS

Volles Programm. Druckt nach stderr. Inspiriert von Marinus 'Lösung .

'Hello World'{⍞←⍺⊣⎕DL⍵}&¨⍳11

Probieren Sie es online!

⍳11 erste 11 ganze Zahlen

'Hello World'{… }&¨ Erzeugen Sie für jede Ganzzahl als rechtes Argument ( ⍵) die folgende Funktion mit dem entsprechenden Zeichen als linkes Argument ( ⍺):

 ⎕DL⍵ d e l ay richtige Argument Sekunden

 ⍺⊣ Verwerfen Sie diese (die effektive Verzögerung) zugunsten des Zeichens mit dem linken Argument

 ⍞← drucke das auf stdout ohne abschließenden Zeilenumbruch

Java (160 Zeichen)

class A{static int i;public static void main(String...a){new Thread(){public void run(){System.out.print("Hello World".charAt(i++));if(i<11)main();}}.start();}}

Ja, ich weiß, das ist die falsche Sprache für Code-Golf. Ich mache es zum Spaß.

Bash (64)

:(){ [ "$1" ]&&(echo -n "${1:0:1}"&: "${1:1}")};: "Hello World"

Haskell ( 120 118)

import Control.Concurrent
t=threadDelay.(*3^8)
main=(\(x,y)->forkIO$t x>>putChar y)`mapM_`zip[0..]"Hello World">>t 99

Ich bin mir nicht ganz sicher, ob ich mit 9999 multiplizieren soll - ich habe einen 2-GHz-Xeon, auf dem es auch dann funktioniert, wenn Sie es nicht tun. überhaupt nichts tun.)

Scala ( 81 79 Zeichen)

def?(l:String){if(l.size!=0)new Thread{print(l(0));?(l.tail)}}
?("Hello World")

Groovy, 51 Zeichen

"Hello World".each{a->Thread.start{print a}.join()}

D (135 Zeichen)

import std.concurrency,std.stdio;
void main(){
    p("Hello World");
}
void p(string h){
    write(h[0]);
    if(h.length>1)spawn(&p,h[1..$]);
}

Ich starte den nächsten Thread erst, wenn ich das aktuelle Zeichen bereits gedruckt habe

bearbeite +2 Zeichen für eine bessere Kontrolle

Scala 74

"Hello World".zipWithIndex.par.map(x=>{Thread.sleep(x._2*99);print(x._1)})

• zipWithIndex erzeugt ((H, 0), (e, 1), (l, 2) ...).
• par macht es zu einer parallelen Sammlung.

Tests:

(1 to 10).foreach {_ => "Hello World".zipWithIndex.par.map(x=>{Thread.sleep(x._2*99);print(x._1)});println()}
Hello World
Hello World
Hello World
...
Hello World

Javascript (72)

(function f(){console.log("Hello world"[i++]);i<11&&setTimeout(f)})(i=0)

scala (45)

Thread # Join-basierte Lösung

"Hello World"map{x=>new Thread{print(x)}join}

oder

for(x<-"Hello World")new Thread{print(x)}join

Dies ist mein F # -Versuch. Mein erstes ernstes F # Programm. Bitte sei nett.

let myprint c = async {
        printfn "%c"c
}
"Hello World"|>Seq.map myprint|>Async.Parallel|>Async.RunSynchronously|>ignore

Gehen

package main
import"fmt"
func main(){o:=make(chan int)
for _,c:=range"Hello World"{go func(c rune){fmt.Printf("%c",c)
o<-0}(c)}
for i:=0;i<11;i++{<-o}}

Erlang (90)

-module(h).
r()->r("Hello World").
r([])->'';r([H|T])->spawn(h,r,[T]),io:format("~c",[H]).

Kompilieren erlc +export_all h.erl

Nimrod, 121

proc p(c:char){.thread.}=write(stdout,c)
for c in "Hello World":
 var t:TThread[char]
 createThread(t,p,c)
 joinThread(t)

Python: zu viele Zeichen, aber es funktioniert.

# Ok. First we patch Threading.start to test wether our solution actually works

import threading
import random, time
original_run = threading.Thread.run


def myRun(self):
    tosleep = random.randint(0,200)/1000.0
    time.sleep(tosleep)
    original_run(self)

threading.Thread.run = myRun

# And now the real code:
import time, sys, threading
string_to_write = "Hello World\n"
current_char_index = 0 # This integer represents the index of the next char to be written
# It will act as a semaphore: threads will wait until it reaches
# the index of the single char that particular thread is due to output

class Writer(threading.Thread):
    def __init__(self, char_to_write, index_to_write):
        self.char_to_write, self.index_to_write = char_to_write, index_to_write
        super(Writer, self).__init__()
    def run(self):
        ch = globals()['current_char_index']
        while not self.index_to_write == ch:
            time.sleep(0.005)
        sys.stdout.write(self.char_to_write)
        # This will be atomic because no other thread will touch it while it has "our" index
        globals()['current_char_index'] += 1

for i, char in enumerate(string_to_write):
    Writer(char, i).start()

C # 90 84

foreach(var c in"Hello World"){var t=new Thread(Console.Write);t.Start(c);t.Join();}

Laufende Version: http://ideone.com/0dXNw

Ziel-C (183 Zeichen)

-(void) thread {[self performSelectorInBackground:@selector(printC) withObject:nil];}
-(void) printC {char *c = "Hello World"; for(int i = 0; c[i] != '\0'; i++) {printf("%c", c[i]);}}

Haskell 99 Zeichen

import Control.Concurrent
f[]=return()
f(x:xs)=(putChar x)>>(forkIO$f xs)>>f[]
main=f"Hello World"

Wie es funktioniert, beginnt jeder Thread am nächsten, nachdem er seinen Charakter angezeigt hat, so dass tatsächlich nützliche Dinge nicht außerhalb der Reihenfolge passieren können.

Bash , 43 Bytes

xargs -n1 printf<<<'H e l l o \  W o r l d'

Probieren Sie es online!

xargsGibt printffür jedes Zeichen einen eigenen Prozess aus (und wartet, bis es beendet wird).

Bash , 45 Bytes, keine externen Dienstprogramme

eval \(printf\ {H,e,l,l,o,\\\ ,W,o,r,l,d}\)\;

Probieren Sie es online!

Erweitert bis (printf H); (printf e); (printf l); (printf l); (printf o); (printf \ ); (printf W); (printf o); (printf r); (printf l); (printf d);vor der Auswertung. Die Klammern machen Bash Fork zu einer Unterschale für jeden Buchstaben (und warten, bis er beendet ist), aber diesmal printfist der Bash eingebaut.