इस गोल्फ को एक फैक्टोरियल कैलकुलेशन की आवश्यकता होती है जिसे कई थ्रेड्स या प्रक्रियाओं के बीच विभाजित किया जाए।
कुछ भाषाएं दूसरों की तुलना में समन्वय करना आसान बनाती हैं, इसलिए यह लैंग अज्ञेयवादी है। अनगुल्ड उदाहरण कोड प्रदान किया गया है, लेकिन आपको अपना स्वयं का एल्गोरिदम विकसित करना चाहिए।
प्रतियोगिता का लक्ष्य यह देखना है कि N की गणना के लिए सबसे छोटा (बाइट्स, सेकंड में नहीं) मल्टीकोर फैक्टरोरिथम कौन आ सकता है! जब प्रतियोगिता बंद हो जाती है तो वोटों से मापा जाता है। एक मल्टीकोर लाभ होना चाहिए, इसलिए हमें आवश्यकता होगी कि यह एन ~ 10,000 के लिए काम करे। यदि लेखक प्रोसेसर / कोर के बीच काम को कैसे फैलाता है और गोल्फ की सहमति के आधार पर वोट देता है, तो लेखक को मत देने के लिए असफल होने पर मतदाताओं को वोट देना चाहिए।
जिज्ञासा के लिए, कृपया कुछ प्रदर्शन संख्याएँ पोस्ट करें। कुछ बिंदु पर एक प्रदर्शन बनाम गोल्फ स्कोर ट्रेडऑफ़ हो सकता है, जब तक यह आवश्यकताओं को पूरा करता है तब तक गोल्फ के साथ जाएं। मुझे यह जानने की उत्सुकता होगी कि ऐसा कब होता है।
आप आमतौर पर उपलब्ध एकल कोर बड़े पूर्णांक पुस्तकालयों का उपयोग कर सकते हैं। उदाहरण के लिए, पर्ल आमतौर पर बिगिन के साथ स्थापित किया जाता है। हालाँकि, ध्यान दें कि केवल सिस्टम प्रदान करने वाले फैक्टरियल फ़ंक्शन को कॉल करने से सामान्य रूप से कई कोर पर काम नहीं होगा।
आपको STDIN या ARGV से इनपुट N को स्वीकार करना होगा और N के मान को STDOUT में आउटपुट करना होगा। आप प्रोग्राम के लिए प्रोसेसर / कोर की संख्या प्रदान करने के लिए वैकल्पिक रूप से एक 2 इनपुट पैरामीटर का उपयोग कर सकते हैं, इसलिए यह वह नहीं करता है जो आप नीचे देखेंगे :-) या आप 2, 4 के लिए स्पष्ट रूप से डिज़ाइन कर सकते हैं, जो भी आपके पास उपलब्ध है।
मैं नीचे अपनी खुद की ऑडबॉल उदाहरण प्रस्तुत करूंगा, जो पहले अलग-अलग भाषाओं में फैक्टरियल एल्गोरिदम के तहत स्टैक ओवरफ्लो पर प्रस्तुत की गई थी । यह गोल्फ नहीं है। कई अन्य उदाहरण प्रस्तुत किए गए, उनमें से कई गोल्फ थे लेकिन कई नहीं। शेयर-समान लाइसेंस के कारण, ऊपर दिए गए लिंक में किसी भी उदाहरण में शुरुआती बिंदु के रूप में कोड का उपयोग करने के लिए स्वतंत्र महसूस करें।
मेरे उदाहरण में प्रदर्शन कई कारणों से कमजोर है: यह बहुत अधिक प्रक्रियाओं, बहुत अधिक स्ट्रिंग / बिगिन रूपांतरण का उपयोग करता है। जैसा कि मैंने कहा कि यह एक जानबूझकर विषम उदाहरण है। यह 5000 की गणना करेगा! यहाँ एक 4 कोर मशीन पर 10 सेकंड से कम में। हालाँकि, अगले लूप के लिए एक अधिक स्पष्ट दो लाइनर 5000 कर सकते हैं! 3.6 में चार प्रोसेसर में से एक पर।
आपको निश्चित रूप से इससे बेहतर करना होगा:
#!/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);
}
}
इसमें मेरी दिलचस्पी बस (1) ऊब को कम करने में है; और (2) कुछ नया सीखना। यह मेरे लिए कोई होमवर्क या शोध समस्या नहीं है।
सौभाग्य!
