Senin için bir sorunum var:

• Herhangi bir dili kullanarak "Hello World" yazdırın.
• Her karakter kendi benzersiz iş parçacığından basılmalıdır

Bu kadar. Açıkça görüldüğü üzere, iş parçacığı çalıştırma sırasına göre çalışacağının garantisi olmadığından, çıktının doğru sırada yazdırılmasını sağlamak için program iş parçacığınızı güvenli hale getirmelisiniz.

Ve, çünkü bu kod golf, en kısa program kazanıyor.

Güncelleme:

Kazanan Marinus'un APL üyeliği 34 karakterde. Aynı zamanda en az okunabilir giriş ödülü kazandı.

APL (Dyalog) ( 44 43 39 34)

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

Açıklama:

• 2 11⍴'Hello World',⍳11 bir matris oluşturur: (H, 1), (e, 2), ...
• &⌿ şu anlama gelir: matrisin her sütunu için ayrı bir iş parçacığı yapın:
• Bir iş parçacığında, ⍺şimdi karakter ve ⍵şimdi zamanı
• ⎕DL⊃⍵⍵saniye bekler .
• Sonra ⍞←⍺karakteri çıkarır.

C, 61 62 karakter

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

Pthread kütüphanesi işlevlerinin hepsinde loooooong isimleri var, bu yüzden her karakter için ayrı bir süreç başlattım. fork()çok daha kısa.

Bunun write()yerine kullanmak gerekiyordu putchar()çünkü stdio tamponlama fonksiyonları iplik güvenli değil.

Düzenlendi : 62 karaktere kadar yedekleyin. Coşkumda 61 karaktere düşmek iplik güvenliğini de düşürdü.

Yakut, 46 karakter

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

Programın bir sonraki konuya başlamadan ve bir sonraki karaktere devam etmeden önce iş parçacığının bitmesini beklemesi nedeniyle senkronize edilir.

Pythonect (35 karakter)

http://www.pythonect.org

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

Python ( 101 93 98)

Bu Peter Taylor'ın çözümü. N'inci karakteri yazdırmayı N saniye geciktirerek çalışır. Yorumlara bakınız.

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

Bu orijinal olanıdır:

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

Tek bir karakterin basılması için geçen zaman Python'un yeni bir iş parçacığı başlatması için harcadığı zamandan daha az olduğu için, N + 1'inci iş parçacığı oluşturulmadan önce N-inci iş parçacığı bitecekti. Görünüşe göre buna güvenmek kurallara aykırı.

C # 73

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

APL (Dyalog Unicode) , 28 bayt ^SBCS

Tam program Stderr'ye yazdırır. Esinlenerek Marinus' çözümü .

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

Çevrimiçi deneyin!

⍳11 ilk 11 tam sayı

'Hello World'{… }&¨ Her bir tamsayı için doğru argüman ( ⍵) olarak, aşağıdaki işlevi sol argüman ( ⍺) olarak karşılık gelen karakterle oluşturun :

 ⎕DL⍵ d , e l ay sağ bağımsız değişken saniye

 ⍺⊣ bunu, (etkili gecikme) sol argüman karakteri lehine atın

 ⍞← bunu satır sonu izlemeden stdout'a yazdır

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

Evet, kod golf için yanlış bir dil olduğunu biliyorum, eğlence için yapıyorum.

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

9999 ile çarpma konusunda emin değilim - Ben olmasa bile iyi çalışacağı bir 2Ghz Xeon'um var, ama aynı zamanda ihtiyacı olan bir Pentium 4'üm var (999 bozuk çıktı verdi ve 99 hiçbir şey yapmayın.)

scala ( 81 79 karakter)

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

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

Bir sonraki konuya sadece şimdiki karakteri basıp yazdırdığımda başlıyorum.

daha iyi cilt kontrolü için +2 karakterini düzenle

Scala 74

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

• zipWithIndex ((H, 0), (e, 1), (1, 2) ...) üretir.
• par paralel bir koleksiyon yapar.

Testler:

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

skala (45)

Thread # join bazlı bir çözüm

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

veya

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

Bu benim F # denemem. İlk ciddi F # programım. Lütfen nazik ol.

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

Git

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

derleme 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: Çok fazla karakter var ama işe yarıyor.

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

Çalışan sürüm: http://ideone.com/0dXNw

Amaç-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 Karakterler

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

Nasıl çalıştığı her iş parçacığı karakterini gösterdikten sonra bir sonraki başlatır, bu yüzden aslında işe yaramaz şeyler sıra dışı olamaz.

Bash , 43 bayt

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

Çevrimiçi deneyin!

xargsprintfher karakter için ayrı bir işlem yapar (ve çıkmasını bekler).

Bash , 45 bayt, harici yardımcı program yok

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

Çevrimiçi deneyin!

(printf H); (printf e); (printf l); (printf l); (printf o); (printf \ ); (printf W); (printf o); (printf r); (printf l); (printf d);Değerlendirmeden önce genişler . Parantezler Bash çatalını her harf için bir alt kabuk haline getirir (ve çıkmasını bekleyin), fakat bu sefer printfBash yerleşiktir.