나는 당신에게 도전이 있습니다 :

• 모든 언어를 사용하여 "Hello World"를 인쇄하십시오.
• 각 문자는 고유 한 고유 스레드에서 인쇄해야합니다

그게 다야. 스레드가 시작 순서대로 작동한다는 보장이 없으므로 출력이 올바른 순서로 인쇄되도록 프로그램 스레드를 안전하게 만들어야합니다.

그리고 이것이 코드 골프이기 때문에 가장 짧은 프로그램이 승리합니다.

최신 정보:

우승자는 34자인 Marinus의 APL 출품작 입니다. 또한 가장 읽기 어려운 항목으로 선정되었습니다.

APL (Dyalog) ( 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 + 1 스레드가 생성되기 전에 N 번째 스레드가 완료되기 때문에 작동했습니다. 분명히 이것에 의존하는 규칙에 위배됩니다.

C # 73

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

APL (Dyalog Unicode) , 28 바이트 ^SBCS

전체 프로그램. stderr에 인쇄합니다. marinus의 솔루션에서 영감을 얻었습니다 .

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

온라인으로 사용해보십시오!

⍳11 처음 11 개의 정수

'Hello World'{… }&¨ 오른쪽 인수 ( ⍵) 로 각 정수에 대해 해당 문자를 왼쪽 인수 ( ⍺) 로 사용하여 다음 함수를 생성합니다 .

 ⎕DL⍵ D의 예 리터 AY 오른쪽 인수 초

 ⍺⊣ 왼쪽 인수 특성에 찬성하여 (유효 지연) 버립니다

 ⍞← 줄 바꿈없이 stdout에 인쇄

자바 (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가 필요합니다. 아무것도하지 마십시오.)

스칼라 ( 81 79 자)

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

그루비, 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

자바 스크립트 (72)

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

스칼라 (45)

스레드 # 조인 기반 솔루션

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

파이썬 : 문자가 너무 많지만 작동합니다.

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

하스켈 99 자

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

작동 방식은 각 스레드가 문자를 표시 한 후 다음에 시작되므로 실제로 유용한 항목은 순서가 맞지 않을 수 없습니다.

배쉬 , 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가 내장되어 있습니다.