Tôi có một thử thách cho bạn:

• In "Hello World" bằng bất kỳ ngôn ngữ nào.
• Mỗi ký tự phải được in từ chủ đề độc đáo của riêng mình

Đó là nó. Rõ ràng, vì không có gì đảm bảo rằng các luồng sẽ hoạt động theo thứ tự bạn khởi động chúng, bạn phải làm cho luồng chương trình của bạn an toàn để đảm bảo đầu ra được in theo đúng thứ tự.

Và, bởi vì đây là mã golf, chương trình ngắn nhất sẽ thắng.

Cập nhật:

Người chiến thắng là mục APL của Marinus , với 34 ký tự. Nó cũng giành giải thưởng cho mục nhập ít đọc nhất.

APL (Dyalog) ( 44 43 39 34)

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

Giải trình:

• 2 11⍴'Hello World',⍳11 tạo ma trận: (H, 1), (e, 2), ...
• &⌿ có nghĩa là: đối với mỗi cột của ma trận, hãy thực hiện trên một luồng riêng biệt:
• Trong một chủ đề, ⍺bây giờ là nhân vật và ⍵bây giờ là thời gian
• ⎕DL⊃⍵Chờ đợi trong ⍵vài giây.
• Sau đó, ⍞←⍺xuất ký tự.

C, 61 62 ký tự

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

Tất cả các chức năng thư viện pthread đều có tên loooooong, vì vậy thay vào đó tôi đã khởi động toàn bộ một quy trình riêng cho mỗi nhân vật. fork()ngắn hơn rất nhiều

Nó là cần thiết để sử dụng write()thay putchar()vì bởi vì các chức năng đệm stdio không an toàn cho luồng.

Đã chỉnh sửa : Sao lưu tới 62 ký tự. Trong lòng nhiệt thành của tôi, giảm xuống còn 61 ký tự cũng giảm độ an toàn của luồng.

Ruby, 46 ký tự

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

Nó được đồng bộ hóa do thực tế là chương trình đợi luồng kết thúc trước khi bắt đầu luồng tiếp theo và tiếp tục với char tiếp theo.

Pythonect (35 ký tự)

http://www.pythonect.org

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

Con trăn ( 101 93 98)

Đây là giải pháp của Peter Taylor. Nó hoạt động bằng cách trì hoãn in ký tự N-th bằng N giây. Xem ý kiến.

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

Đây là bản gốc:

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

Nó hoạt động vì thời gian để in một ký tự ít hơn thời gian Python cần để khởi tạo một luồng mới, do đó, luồng thứ N sẽ kết thúc trước khi luồng N + 1 được tạo. Rõ ràng nó là trái với các quy tắc để dựa vào điều này.

C # 73

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

APL (Dyalog Unicode) , 28 byte ^SBCS

Chương trình đầy đủ. In ra stderr. Lấy cảm hứng từ giải pháp của bến .

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

Hãy thử trực tuyến!

⍳11 11 số nguyên đầu tiên

'Hello World'{Chiếm }&¨ cho mỗi số nguyên là đối số bên phải ( ⍵), sinh ra hàm sau với ký tự tương ứng là đối số bên trái ( ⍺):

 ⎕DL⍵ d e l ay giây đối số đúng

 ⍺⊣ loại bỏ rằng (độ trễ hiệu quả) có lợi cho ký tự bên trái

 ⍞← in nó ra thiết bị xuất chuẩn mà không ngắt dòng

Java (160 ký tự)

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

Vâng, tôi biết đây là ngôn ngữ sai cho mã golf, tôi làm nó cho vui.

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

Tôi không chắc chắn về việc nhân với 9999 - Tôi có Xeon 2Ghz, nó sẽ hoạt động tốt ngay cả khi bạn không, nhưng tôi cũng có Pentium 4 cần nó (999 cho đầu ra bị cắt xén và 99 không ' t làm bất cứ điều gì cả.)

scala ( 81 79 ký tự)

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

Groovy, 51 ký tự

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

D (135 ký tự)

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

Tôi chỉ bắt đầu chuỗi tiếp theo khi tôi đã in char hiện tại

chỉnh sửa ký tự +2 để kiểm tra ràng buộc tốt hơn

Scala 74

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

• zipWith Index tạo ra ((H, 0), (e, 1), (l, 2) ...).
• mệnh làm cho nó một bộ sưu tập song song.

Các xét nghiệm:

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

Giải pháp dựa trên chủ đề # tham gia

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

hoặc là

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

Đây là nỗ lực F # của tôi. Chương trình F # nghiêm túc đầu tiên của tôi. Làm ơn.

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

Đi

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

Biên dịch 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: quá nhiều ký tự, nhưng nó hoạt động.

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

Phiên bản đang chạy: http://ideone.com/0dXNw

Mục tiêu-C (183 ký tự)

-(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 Nhân vật

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

Cách thức hoạt động là mỗi luồng bắt đầu tiếp theo sau khi đã hiển thị ký tự của nó, vì vậy chúng thực sự là những thứ hữu ích không thể xảy ra ngoài chuỗi.

Bash , 43 byte

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

Hãy thử trực tuyến!

xargstạo ra một printfquy trình riêng cho mỗi nhân vật (và chờ cho nó thoát ra).

Bash , 45 byte, không có tiện ích bên ngoài

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

Hãy thử trực tuyến!

Mở rộng để (printf H); (printf e); (printf l); (printf l); (printf o); (printf \ ); (printf W); (printf o); (printf r); (printf l); (printf d);trước khi đánh giá. Các dấu ngoặc đơn làm cho Bash fork là một nhánh con cho mỗi chữ cái (và đợi nó thoát ra), nhưng lần này printflà hàm dựng sẵn của Bash.