Tengo un reto para usted:

• Imprime "Hello World" en cualquier idioma.
• Cada personaje debe imprimirse desde su propio hilo único.

Eso es. Obviamente, como no hay garantía de que los subprocesos funcionen en el orden en que los inicia, debe hacer que el subproceso de su programa sea seguro para garantizar que la salida se imprima en el orden correcto.

Y, como se trata de código de golf, gana el programa más corto.

Actualizar:

El ganador es la entrada APL de Marinus , con 34 caracteres. También gana el premio por la entrada menos legible.

APL (Dyalog) ( 44 43 39 34)

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

Explicación:

• 2 11⍴'Hello World',⍳11 crea una matriz: (H, 1), (e, 2), ...
• &⌿ significa: para cada columna de la matriz, hacer en un hilo separado:
• En un hilo, ⍺ahora es el personaje y ⍵ahora es el momento
• ⎕DL⊃⍵espera por ⍵segundos
• Luego, ⍞←⍺genera el carácter.

C, 61 62 caracteres

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

Todas las funciones de la biblioteca pthread tienen muuuucho nombres, así que en su lugar, inicié un proceso completamente separado para cada personaje. fork()Es mucho más corto.

Era necesario usarlo en write()lugar de putchar()porque las funciones de almacenamiento en búfer stdio no son seguras para subprocesos.

Editado : Copia de seguridad de hasta 62 caracteres. En mi celo, bajar a 61 caracteres también dejó caer el hilo de seguridad.

Ruby, 46 caracteres.

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

Se sincroniza debido al hecho de que el programa espera a que finalice el subproceso antes de comenzar el siguiente subproceso y continuar con el siguiente carácter.

Pythonect (35 caracteres)

http://www.pythonect.org

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

Python ( 101 93 98)

Esta es la solución de Peter Taylor. Funciona retrasando la impresión del enésimo carácter en N segundos. Ver comentarios.

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

Este es el original:

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

Funcionó porque el tiempo que lleva imprimir un solo carácter es menor que el tiempo que tarda Python en inicializar un nuevo subproceso, por lo tanto, el subproceso N terminaría antes de que se creara el subproceso N + 1. Aparentemente es contrario a las reglas confiar en esto.

C # 73

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

APL (Dyalog Unicode) , ^{SBCS de} 28 bytes

Programa completo Imprime en stderr. Inspirado en la solución de marinus .

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

Pruébalo en línea!

⍳11 primeros 11 enteros

'Hello World'{… }&¨ Para cada entero como argumento derecho ( ⍵), genera la siguiente función con el carácter correspondiente como argumento izquierdo ( ⍺):

 ⎕DL⍵ d e l segundos de argumento correcto

 ⍺⊣ descartar eso (la demora efectiva) a favor del carácter de argumento izquierdo

 ⍞← imprima eso en stdout sin salto de línea final

Java (160 caracteres)

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

Sí, sé que este es el lenguaje incorrecto para el golf de código, lo hago por diversión.

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

No estoy tan seguro de multiplicar por 9999: tengo un Xeon de 2Ghz en el que funcionará bien incluso si no lo haces, pero también tengo un Pentium 4 que lo necesita (999 dio una salida confusa y 99 no No hagas nada en absoluto.)

scala ( 81 79 caracteres)

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

Groovy, 51 personajes

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

D (135 caracteres)

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

Solo comienzo el siguiente hilo cuando ya he impreso el carácter actual

editar +2 caracteres para una mejor verificación encuadernada

Scala 74

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

• zipWithIndex produce ((H, 0), (e, 1), (l, 2) ...).
• par lo convierte en una colección paralela.

Pruebas:

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

Hilo # unirse a la solución basada

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

o

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

Este es mi intento de F #. Mi primer programa serio de F #. Por favor se amable.

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

Ir

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

Compilar 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: demasiados caracteres, pero funciona.

# 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ón en ejecución: http://ideone.com/0dXNw

Objetivo-C (183 caracteres)

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

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

La forma en que funciona es que cada subproceso comienza el siguiente después de haber mostrado su carácter, por lo que las cosas realmente útiles no pueden suceder fuera de secuencia.

Bash , 43 bytes

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

Pruébalo en línea!

xargs se bifurca por separado printf proceso para cada personaje (y espera a que salga).

Bash , 45 bytes, sin utilidades externas

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

Pruébalo en línea!

Se expande a (printf H); (printf e); (printf l); (printf l); (printf o); (printf \ ); (printf W); (printf o); (printf r); (printf l); (printf d);antes de la evaluación. Los paréntesis hacen que Bash se bifurque en un subshell para cada letra (y espere a que salga), pero esta vez printfes el Bash incorporado.