J'ai un challenge pour toi:

• Imprimez "Hello World" en utilisant n'importe quelle langue.
• Chaque caractère doit être imprimé à partir de son propre fil unique

C'est ça. Bien entendu, comme il n’est pas garanti que les threads fonctionneront dans l’ordre dans lequel vous les avez démarrés, vous devez sécuriser votre thread de programme pour que le résultat soit imprimé dans le bon ordre.

Et, parce que c'est du golf de code, le programme le plus court gagne.

Mise à jour:

Le gagnant est l’entrée APL de Marinus , avec 34 caractères. Il remporte également le prix de l'entrée la moins lisible.

APL (Dyalog) ( 44 43 39 34)

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

Explication:

• 2 11⍴'Hello World',⍳11 crée une matrice: (H, 1), (e, 2), ...
• &⌿ signifie: pour chaque colonne de la matrice, faites sur un thread séparé:
• Dans un fil, ⍺c'est maintenant le personnage et ⍵c'est maintenant le moment
• ⎕DL⊃⍵attend des ⍵secondes.
• Puis, ⍞←⍺sort le caractère.

C, 61 62 caractères

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

Les fonctions de la bibliothèque pthread ont toutes un nom loooooong. J'ai donc lancé un processus distinct pour chaque caractère. fork()est tellement plus courte.

Il était nécessaire d'utiliser à la write()place de putchar()parce que les fonctions de tampon stdio ne sont pas thread-safe.

Édité : Sauvegarde jusqu'à 62 caractères. Dans mon zèle, le fait de descendre à 61 caractères a également fait tomber le filet de sécurité.

Ruby, 46 personnages

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

Il est synchronisé car le programme attend la fin du thread avant de démarrer le prochain thread et de continuer avec le caractère suivant.

Pythonect (35 caractères)

http://www.pythonect.org

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

Python ( 101 93 98)

C'est la solution de Peter Taylor. Cela fonctionne en retardant l'impression du Nième caractère de N secondes. Voir les commentaires.

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

C'est l'original:

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

Cela a fonctionné, car le temps nécessaire pour imprimer un seul caractère est inférieur au temps nécessaire à l'initialisation d'un nouveau thread par Python. Le N-ème thread s'achèverait donc avant la création du N-1-ème thread. Apparemment, il est contraire aux règles de s'en prévaloir.

C # 73

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

APL (Dyalog Unicode) , ^{SBCS sur} 28 octets

Programme complet. Imprime sur stderr. Inspiré par la solution de marinus .

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

Essayez-le en ligne!

⍳11 11 premiers entiers

'Hello World'{… }&¨ Pour chaque entier sous forme d'argument de droite ( ⍵), créez la fonction suivante avec le caractère correspondant sous forme d'argument de gauche ( ⍺):

 ⎕DL⍵ d e l ay des secondes d'argument juste

 ⍺⊣ rejeter que (le délai effectif) en faveur du caractère d'argument de gauche

 ⍞← imprimer cela sur stdout sans fin de ligne

Java (160 caractères)

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

Oui, je sais que c'est la mauvaise langue pour le code golf, je le fais pour le plaisir.

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

Je ne suis pas sûr de pouvoir multiplier par 9999 - j'ai un Xeon 2Ghz qui fonctionnera bien même si vous ne le faites pas, mais j'ai aussi un Pentium 4 qui en a besoin (999 donne une sortie tronquée et 99 ne le sont pas. ne rien faire du tout.)

scala ( 81 79 caractères)

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

Groovy, 51 caractères

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

D (135 caractères)

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..$]);
}

Je ne commence le prochain thread que lorsque j'ai déjà imprimé le caractère actuel

éditer +2 caractères pour un meilleur contrôle lié

Scala 74

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

• zipWithIndex produit ((H, 0), (e, 1), (l, 2) ...).
• par en fait une collection parallèle.

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 # rejoindre la solution basée

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

ou

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

Ceci est ma tentative de F #. Mon premier programme F # sérieux. S'il vous plaît soyez gentil.

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

Aller

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

Compiler 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: trop de caractères, mais ça marche.

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

Version en cours d'exécution: http://ideone.com/0dXNw

Objective-C (183 caractères)

-(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 personnages

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

Comment cela fonctionne-t-il? Chaque thread commence le suivant après avoir affiché son caractère, de sorte qu'il ne peut pas arriver que des choses utiles se déroulent dans le désordre.

Bash , 43 octets

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

Essayez-le en ligne!

xargsforks un printfprocessus séparé pour chaque caractère (et attend sa sortie).

Bash , 45 octets, aucun utilitaire externe

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

Essayez-le en ligne!

S'étend à (printf H); (printf e); (printf l); (printf l); (printf o); (printf \ ); (printf W); (printf o); (printf r); (printf l); (printf d);avant l'évaluation. Les parenthèses font de Bash un sous-shell pour chaque lettre (et attendent qu’elle se printftermine ), mais cette fois, c’est la fonction intégrée de Bash.