Saya punya tantangan untuk Anda:

• Cetak "Hello World" menggunakan bahasa apa pun.
• Setiap karakter harus dicetak dari utasnya sendiri yang unik

Itu dia. Jelas, karena tidak ada jaminan bahwa utas akan beroperasi sesuai urutan Anda memulainya, Anda harus membuat utas program Anda aman untuk memastikan hasil cetak dalam urutan yang benar.

Dan, karena ini golf kode, program terpendek menang.

Memperbarui:

Pemenangnya adalah entri APL Marinus , dengan 34 karakter. Itu juga memenangkan hadiah untuk entri yang paling mudah dibaca.

APL (Dyalog) ( 44 43 39 34)

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

Penjelasan:

• 2 11⍴'Hello World',⍳11 membuat matriks: (H, 1), (e, 2), ...
• &⌿ berarti: untuk setiap kolom matriks, lakukan pada utas terpisah:
• Di utas, ⍺sekarang karakter dan ⍵sekarang waktunya
• ⎕DL⊃⍵menunggu ⍵sebentar.
• Kemudian, ⍞←⍺menampilkan karakter.

C, 61 62 karakter

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

Fungsi pthread library semuanya memiliki nama loooooong, jadi alih-alih saya menjalankan seluruh proses terpisah untuk setiap karakter. fork()jauh lebih pendek.

Itu perlu digunakan write()daripada putchar()karena fungsi buffer stdio tidak aman-thread.

Diedit : Cadangkan hingga 62 karakter. Dalam semangat saya, menjatuhkan ke 61 karakter juga menjatuhkan keamanan benang.

Ruby, 46 karakter

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

Ini disinkronkan karena fakta bahwa program menunggu utas berakhir sebelum memulai utas berikutnya dan melanjutkan dengan arang berikutnya.

Pythonect (35 karakter)

http://www.pythonect.org

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

Python ( 101 93 98)

Ini adalah solusi Peter Taylor. Ini bekerja dengan menunda pencetakan karakter ke-N oleh N detik. Lihat komentar.

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

Ini yang asli:

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

Ini berhasil karena waktu yang diperlukan untuk mencetak satu karakter lebih kecil daripada waktu yang diperlukan Python untuk menginisialisasi utas baru, oleh karena itu utas N-th akan selesai sebelum utas N + 1-th dibuat. Rupanya melanggar aturan untuk mengandalkan ini.

C # 73

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

APL (Dyalog Unicode) , 28 byte ^SBCS

Program lengkap. Mencetak ke stderr. Terinspirasi oleh solusi marinus .

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

Cobalah online!

⍳11 11 bilangan bulat pertama

'Hello World'{... }&¨ untuk setiap integer sebagai argumen kanan ( ⍵), muncul fungsi berikut dengan karakter yang sesuai sebagai argumen kiri ( ⍺):

 ⎕DL⍵ d e l ay detik argumen kanan

 ⍺⊣ Buang itu (penundaan efektif) yang mendukung karakter argumen-kiri

 ⍞← cetak itu untuk stdout tanpa tertinggal garis putus

Jawa (160 karakter)

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

Ya, saya tahu ini adalah bahasa yang salah untuk kode golf, saya melakukannya untuk bersenang-senang.

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

Saya tidak begitu yakin tentang mengalikan dengan 9999 - Saya memiliki Xeon 2Ghz yang berfungsi dengan baik bahkan jika Anda tidak, tetapi saya juga memiliki Pentium 4 yang membutuhkannya (999 memberikan output kacau dan 99 tidak t melakukan apa pun.)

scala ( 81 79 karakter)

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

Groovy, 51 karakter

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

D (135 karakter)

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

Saya hanya memulai utas berikutnya ketika saya sudah mencetak karakter saat ini

sunting +2 karakter untuk pemeriksaan batas yang lebih baik

Scala 74

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

• zipWithIndex menghasilkan ((H, 0), (e, 1), (l, 2) ...).
• par membuatnya menjadi koleksi paralel.

Tes:

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

Utas # gabung solusi berbasis

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

atau

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

Ini adalah upaya F # saya. Program F # serius pertama saya. Mohon berbaik hati.

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

Pergi

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

Menyusun 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: terlalu banyak karakter, tetapi berhasil.

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

Versi yang sedang berjalan: http://ideone.com/0dXNw

Objective-C (183 karakter)

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

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

Cara kerjanya adalah setiap utas dimulai berikutnya setelah menampilkan karakternya, sehingga sebenarnya hal-hal yang bermanfaat tidak dapat terjadi di luar urutan.

Bash , 43 byte

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

Cobalah online!

xargsbercabang printfproses terpisah untuk setiap karakter (dan menunggu itu untuk keluar).

Bash , 45 byte, tidak ada utilitas eksternal

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

Cobalah online!

Perluas (printf H); (printf e); (printf l); (printf l); (printf o); (printf \ ); (printf W); (printf o); (printf r); (printf l); (printf d);sebelum evaluasi. Tanda kurung membuat Bash garpu subkulit untuk setiap huruf (dan tunggu sampai keluar), tapi kali ini printfadalah Bash bawaan.