私はあなたのために挑戦しています：

• 任意の言語を使用して「Hello World」を印刷します。
• 各文字は、独自の一意のスレッドから印刷する必要があります

それでおしまい。明らかに、スレッドが起動した順序で動作するという保証はないため、プログラムをスレッドセーフにして、出力が正しい順序で出力されるようにする必要があります。

そして、これはコードゴルフであるため、最短のプログラムが勝利します。

更新：

勝者は34文字のMarinusのAPLエントリです。また、最も読みにくいエントリで賞を獲得します。

APL（ダイアログ）（44 43 39 34）

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

説明：

• 2 11⍴'Hello World',⍳11 行列を作成します：（H、1）、（e、2）、...
• &⌿ 意味：マトリックスの列ごとに、個別のスレッドで実行します。
• スレッドで⍺は、今のキャラクターで⍵あり、今の時間です
• ⎕DL⊃⍵⍵秒待ちます。
• 次に、⍞←⍺文字を出力します。

C、61 62文字

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

pthreadライブラリ関数の名前はすべてloooooongであるため、代わりに文字ごとに個別のプロセス全体を起動しました。fork()ずっと短いです。

stdioバッファリング関数はスレッドセーフではないため、write()代わりに使用する必要がありましたputchar()。

編集済み：62文字までバックアップします。私の熱意で、61文字にドロップすると、スレッドセーフも低下しました。

ルビー、46文字

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

プログラムは、次のスレッドを開始して次の文字を続行する前にスレッドが終了するのを待つという事実のために同期されます。

Pythonect（35文字）

http://www.pythonect.org

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

パイソン（101 93 98）

これがPeter Taylorのソリューションです。N番目の文字の印刷をN秒遅らせることで機能します。コメントを参照してください。

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

これは元のものです：

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

単一の文字を印刷するのにかかる時間がPythonが新しいスレッドを初期化するのにかかる時間よりも短いため、機能しました。したがって、N番目のスレッドはN + 1番目のスレッドが作成される前に終了します。明らかにこれに依存することはルールに反しています。

C＃73

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

APL（Dyalog Unicode）、28 バイト^SBCS

完全なプログラム。stderrに出力します。マリナスのソリューションに触発されました。

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

オンラインでお試しください！

⍳11 最初の11個の整数

'Hello World'{… }&¨ 右引数（⍵）としての各整数に対して、左引数（⍺）として対応する文字を使用して次の関数を生成します。

 ⎕DL⍵ d e l ay右引数の秒

 ⍺⊣ 左引数の文字を優先してそれを破棄します（有効な遅延）

 ⍞← 改行なしで標準出力に出力します

Java（160文字）

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

ええ、私はこれがコードゴルフの間違った言語であることを知っています、私は楽しみのためにそれをします。

バッシュ（64）

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

ハスケル（120 118）

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

9999で乗算することについてはあまり確信がありません-2Ghz Xeonを使用しても問題なく動作しますが、それを必要とするPentium 4もあります（999は文字化けし、99は出力しませんでした） tは何もしません。）

scala（81 79文字）

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

Groovy、51文字

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

D（135文字）

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

現在の文字をすでに印刷している場合にのみ、次のスレッドを開始します

バインドチェックを向上させるために+2文字を編集

スカラ74

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

• zipWithIndexは（（H、0）、（e、1）、（l、2）...）を生成します。
• parはそれを並列コレクションにします。

テスト：

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

スカラ（45）

Thread＃joinベースのソリューション

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

または

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

これは私のF＃の試みです。私の最初の本格的なF＃プログラム。親切にしてください。

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

行く

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

アーラン（90）

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

コンパイル erlc +export_all h.erl

ニムロッド、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：文字が多すぎますが、機能します。

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

実行中のバージョン：http : //ideone.com/0dXNw

Objective-C（183文字）

-(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キャラクター

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

どのように機能するかは、各スレッドがその文字を表示した後に次のスレッドを開始するため、実際に有用なことは順不同で発生することはありません。

Bash、43バイト

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

オンラインでお試しください！

xargsprintf文字ごとに個別のプロセスをフォークします（そして、終了するのを待ちます）。

Bash、45バイト、外部ユーティリティなし

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

オンラインでお試しください！

(printf H); (printf e); (printf l); (printf l); (printf o); (printf \ ); (printf W); (printf o); (printf r); (printf l); (printf d);評価前に展開します。括弧はBashフォークを各文字のサブシェルにします（そして、それが終了するのを待ちます）が、今回printfはBashビルトインです。