Questo golf richiede un calcolo fattoriale suddiviso tra più thread o processi.
Alcune lingue rendono questo più facile da coordinare rispetto ad altri, quindi è lang agnostico. Viene fornito un codice di esempio non registrato, ma è necessario sviluppare un proprio algoritmo.
L'obiettivo del concorso è vedere chi può elaborare l'algoritmo fattoriale multicore più breve (in byte, non secondi) per il calcolo di N! come misurato dai voti alla chiusura del concorso. Dovrebbe esserci un vantaggio multicore, quindi richiederemo che funzioni per N ~ 10.000. Gli elettori dovrebbero votare verso il basso se l'autore non fornisce una spiegazione valida di come distribuisce il lavoro tra processori / core e votare in base alla concisione del golf.
Per curiosità, si prega di pubblicare alcuni numeri di performance. Ad un certo punto potrebbe esserci un compromesso tra prestazioni e punteggio del golf, andare con il golf purché soddisfi i requisiti. Sarei curioso di sapere quando questo accadrà.
È possibile utilizzare librerie di interi grandi single core normalmente disponibili. Ad esempio, perl è solitamente installato con bigint. Tuttavia, si noti che il semplice richiamo di una funzione fattoriale fornita dal sistema normalmente non suddivide il lavoro su più core.
È necessario accettare da STDIN o ARGV l'ingresso N e trasmettere a STDOUT il valore di N !. Puoi facoltativamente utilizzare un secondo parametro di input per fornire anche il numero di processori / core al programma in modo che non faccia ciò che vedrai di seguito :-) O puoi progettare esplicitamente per 2, 4, qualunque cosa tu abbia a disposizione.
Pubblicherò il mio esempio perl di oddball di seguito, precedentemente inviato su Stack Overflow in Algoritmi fattoriali in diverse lingue . Non è golf. Sono stati presentati numerosi altri esempi, molti dei quali golf, ma molti no. A causa delle licenze simili alle condivisioni, sentiti libero di usare il codice in tutti gli esempi del link sopra come punto di partenza.
Le prestazioni nel mio esempio sono scarse per una serie di ragioni: utilizza troppi processi, troppa conversione stringa / bigint. Come ho detto, è un esempio intenzionalmente strano. Calcolerà 5000! in meno di 10 secondi su una macchina a 4 core qui. Tuttavia, un liner più ovvio per il prossimo / prossimo ciclo può fare 5000! su uno dei quattro processori in 3.6s.
Dovrai sicuramente fare di meglio:
#!/usr/bin/perl -w
use strict;
use bigint;
die "usage: f.perl N (outputs N!)" unless ($ARGV[0] > 1);
print STDOUT &main::rangeProduct(1,$ARGV[0])."\n";
sub main::rangeProduct {
my($l, $h) = @_;
return $l if ($l==$h);
return $l*$h if ($l==($h-1));
# arghhh - multiplying more than 2 numbers at a time is too much work
# find the midpoint and split the work up :-)
my $m = int(($h+$l)/2);
my $pid = open(my $KID, "-|");
if ($pid){ # parent
my $X = &main::rangeProduct($l,$m);
my $Y = <$KID>;
chomp($Y);
close($KID);
die "kid failed" unless defined $Y;
return $X*$Y;
} else {
# kid
print STDOUT &main::rangeProduct($m+1,$h)."\n";
exit(0);
}
}
Il mio interesse per questo è semplicemente (1) alleviare la noia; e (2) imparare qualcosa di nuovo. Per me questo non è un problema di compiti o di ricerca.
In bocca al lupo!
