कॉनवे का प्रधान खेल

18

विशेष रूप से, कॉनवे का PRIMEGAME ।

यह जॉन एच। कॉनवे द्वारा तैयार एक एल्गोरिथ्म है, जो 14 तर्कसंगत संख्याओं के अनुक्रम का उपयोग करके अपराध उत्पन्न करता है:

 A   B   C   D   E   F   G   H   I   J   K   L   M   N
17  78  19  23  29  77  95  77   1  11  13  15  15  55
--  --  --  --  --  --  --  --  --  --  --  --  --  --
91  85  51  38  33  29  23  19  17  13  11  14   2   1

उदाहरण के लिए, एफ अंश है 77/29।

तो यहां बताया गया है कि एल्गोरिथ्म कैसे अभाज्य संख्याओं का पता लगाता है। संख्या से शुरू करते हुए 2, इस क्रम में पहली प्रविष्टि ढूंढें कि जब गुणक एक साथ एक पूर्णांक बनाता है। यहाँ यह है M, 15/2जो पैदा करता है, 15। फिर, उस पूर्णांक के लिए 15, अनुक्रम में पहली प्रविष्टि खोजें, जब गुणक एक पूर्णांक बनाता है। वह आखिरी है N, या 55/1, जो पैदावार देता है 825। इसी क्रम को लिखिए। (आपके बीच का अचरज इसे FRACTRAN कार्यक्रम के रूप में पहचान सकता है ।)

कुछ पुनरावृत्तियों के बाद, आपको निम्नलिखित मिलेंगे:

2, 15, 825, 725, 1925, 2275, 425, 390, 330, 290, 770, 910, 170, 156, 132, 116, 308, 364, 68, 4 ...

ध्यान दें कि सूचीबद्ध अंतिम आइटम है 4, या 2^2। 2इस एल्गोरिथ्म के साथ उत्पन्न हमारी पहली अभाज्य संख्या ( प्रतिपादक) को निहारना ! आखिरकार, अनुक्रम निम्नलिखित की तरह दिखेगा:

2 ... 2^2 ... 2^3 ... 2^5 ... 2^7 ... etc.

इस प्रकार, प्रमुख संख्याओं की उपज। यह OEIS A007542 है ।

चुनौती

एक इनपुट संख्या को देखते हुए n, या तो शून्य- या एक-अनुक्रमित (आपकी पसंद), या तो nइस क्रम की पहली संख्या को आउटपुट करता है, या इस क्रम की nवें संख्या को आउटपुट करता है ।

उदाहरण

नीचे दिए गए उदाहरण nशून्य-अनुक्रमित अनुक्रम के वें शब्द को आउटपुट कर रहे हैं ।

 n   output
 5   2275
19   4
40   408

नियम

  • यदि लागू हो, तो आप मान सकते हैं कि इनपुट / आउटपुट आपकी भाषा के देशी पूर्णांक प्रकार में फिट होगा।
  • इनपुट और आउटपुट किसी भी सुविधाजनक विधि द्वारा दिया जा सकता है ।
  • या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
  • मानक खामियों को मना किया जाता है।
  • यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।
code-golf  math  sequence  number-theory 
— AdmBorkBork
स्रोत
11
शायद कॉनवे का मुख्य खेल लेट्स प्ले ए गेम की तुलना में इस चुनौती के लिए अधिक वर्णनात्मक नाम होगा । इससे भविष्य में इस चुनौती को वापस पाना आसान हो जाएगा।
— लिन
क्या आउटपुट फ्लोट हो सकता है? 408.0के बजाय 408उदाहरण के लिए।
— dylnan
दुर्भाग्य से हमारे पास एक (विहित) "इंटरप्रैक्ट फ़्रेचरन" चुनौती नहीं है। पर एक स्टैक ओवरफ़्लो बंद है।
— user202729
@dylnan ज़रूर, यह ठीक है।
— AdmBorkBork

जवाबों:

5

पायथन 3 , 173 165 153 145 144 144 135 127 127 126 125 108 107 104 बाइट्स

f=lambda n:2>>n*2or[f(n-1)*t//d for t,d in zip(b"NM_M\r7",b"[U3&!\r")if f(n-1)*t%d<1][0]

इसे ऑनलाइन आज़माएं!

  • -30 बाइट्स के लिए धन्यवाद जोनाथन फ्रेच!
  • -3 बाइट्स लिन को धन्यवाद!

2>>n*2के 2लिए है n==0और 0अन्यथा।

103 बाइट्स अगर हम फ्लोट्स वापस कर सकते हैं।

— dylnan
स्रोत
पायथन 2 का उपयोग करना; 153 बाइट्स ।
— जोनाथन फ्रीच
@JonathanFrech कूल, अच्छी चाल। धन्यवाद!
— डायलन
1
पायथन 3, 146 बाइट्स में रहना !
— जोनाथन फ्रीच
— जोनाथन फ्रीच
फिर से धन्यवाद, आपने जितना किया था उससे अधिक अब मैंने किया!
— dylnan
5

FRACTRAN , 99 बाइट्स

17/2821 78/2635 19/1581 23/1178 29/1023 77/899 95/713 77/589 1/527 11/403 13/341 15/434 15/62 55/31

इसे ऑनलाइन आज़माएं!

कार्यक्रम लेता है 2*31^n एक इनपुट के रूप में , जिसका उपयोग प्रारंभिक अवस्था के रूप में किया जाता है।

मूल FRACTRAN कार्यक्रम के सभी अंशों को 31 (पहला अप्रयुक्त प्रधान रजिस्टर) से विभाजित किया गया है, इसलिए कार्यक्रम nth पुनरावृत्ति पर रुक जाता है।

— विंसेंट
स्रोत
चुटीला जवाब। ;-)
— AdmBorkBork
3

पायथन 3 , 107 बाइट्स

f=lambda n,k=2:n and f(n-1,[k*a//b for a,b in zip(b"NM_M\r7",b"[U3&!\r")if k*a%b<1][0])or k

इसे ऑनलाइन आज़माएं!

भिन्नात्मक zipकम ASCII वर्णों वाले दो बाइट्स द्वारा भिन्न की सूची को एन्कोड करता है।

यदि nशून्य है, तो हम तर्क लौटाते हैं k; अन्यथा हम नए मापदंडों के साथ पुनरावृत्ति करते हैं। हमारी नई सूची में कुछ अंश से संबंधित kपहला मूल्य है जैसे कि पूर्णांक, यानी ।k*a//b(a, b)k*a//bk*a%b<1

— लिन
स्रोत
2

MATL , 50 बाइट्स

Hi:"'0m26<l~l *,..V'31-*'{uSFA=731-+."!'32-&\w~)1)

इसे ऑनलाइन आज़माएं!

— लुइस मेंडो
स्रोत
3
लगता है कि कोड के कौन से भाग स्ट्रिंग शाब्दिक हैं और कौन से वास्तविक कथन हैं ...
— लुइस मेंडो
2
Hi:... aww, "हैलो" आपको भी, कोड। :-)
— AdmBorkBork
2

जे , ११६ 110 बाइट्स

g=.3 :0
((1047856500267924709512946135x%&(96#.inv])5405040820893044303890643137x)([:({.@I.@(=<.){[)*)])^:y 2
)

इसे ऑनलाइन आज़माएं!

0 अनुक्रमित; एन-वें नंबर देता है

कुछ बाइट्स को क्रिया को शांत करने से बचाया जा सकता है, लेकिन मुझे समस्याएँ हैं ^: काम ।

स्पष्टीकरण:

J , NrD के रूप में तर्कसंगत संख्याओं का वर्णन करता है, जहाँ N अंश है और D, भाजक है, उदाहरण के लिए 17r91 78r85 19r51 23r38...मैंने अंक और भाजक के लिए 2 अलग-अलग सूचियाँ बनाईं और उनसे 2 आधार -96 संख्याएँ बनाईं।

1047856500267924709512946135x%&(96#.inv])5405040820893044303890643137x आधार -96 संख्याओं को सूचियों में परिवर्तित करता है और दो सूचियों को विभाजित करके अंशों की सूची का निर्माण करता है।

   1047856500267924709512946135x%&(96#.inv])5405040820893044303890643137x
17r91 78r85 19r51 23r38 29r33 77r29 95r23 77r19 1r17 11r13 13r11 15r14 15r2 55

2 2 से शुरू करें

^:y इसके बाईं ओर क्रिया को दोहराएं n समय (y फ़ंक्शन का तर्क है)

] सही तर्क (2 से शुरू होता है, और फिर प्रत्येक पुनरावृत्ति के परिणाम का उपयोग करता है)

* सही तर्क द्वारा भिन्न की सूची गुणा करें

(=<.) परिणाम पूर्णांक हैं (इसकी मंजिल के साथ प्रत्येक संख्या की तुलना करें)

{.@I.@I.पहले का सूचकांक पाता है{.पूर्णांकों का

{[ नंबर प्राप्त करने के लिए इंडेक्स का उपयोग करता है

— गैलेन इवानोव
स्रोत
1
62 बाइट्स:('0m26<l~l *,..V'%&(31x-~3&u:)'ztRE@<620,*-! ')&(0{*#~0=1|*)2:
— मील
@ मीलों धन्यवाद, मुझे लगता है कि आपको अपना समाधान पोस्ट करना चाहिए, यह मेरा से बेहतर तरीका है।
— गैलेन इवानोव
2

05AB1E ,  44  43 बाइट्स

0 अनुक्रमित

2sF•Ë₁ǝßÌ?ƒ¥"h2ÔδD‡béαA5À>,•тв2ä`Š*s‰ʒθ_}нн

इसे ऑनलाइन आज़माएं!

व्याख्या

2                                             # initialize stack with 2
 sF                                           # input times do:
   •Ë₁ǝßÌ?ƒ¥"h2ÔδD‡béαA5À>,•                  # push a base-255 compressed large number
                            тв                # convert to a list of base-100 digits
                              2ä`             # split in 2 parts to stack
                                 Š            # move denominators to bottom of stack
                                  *           # multiply the last result by the numerators
                                   s‰         # divmod with denominators
                                     ʒθ_}     # filter, keep only those with mod result 0
                                         нн   # get the div result

बड़ी संख्या में धकेल दिया गया है 17781923297795770111131515559185513833292319171311140201

— Emigna
स्रोत
1

जावास्क्रिप्ट (Node.js) , 106 95 बाइट्स

  • 11 बाइट्स कम करने के लिए @Arnauld और @Neil को धन्यवाद
(n,N=2,I=13,B=Buffer(`[U3&!\rNM_M\r7`))=>n--?f(n,N/B.find(x=>N%x<!!++I)*B[I]):N

इसे ऑनलाइन आज़माएं!

— DanielIndie
स्रोत
बाइट्स के एक जोड़े को निचोड़ने में कामयाब रहा, लेकिन यह सोचने में मदद नहीं कर सकता कि मैं कुछ याद कर रहा हूं: इसे ऑनलाइन आज़माएं!
— नील
1
@ नील को प्रसार ऑपरेटर का उपयोग करने की कोई आवश्यकता नहीं है Buffer। इसके अलावा, मुझे लगता है कि सभी डेटा को एक सिंगल बफ़र में रखना सुरक्षित है: 95 बाइट्स ।
— अरनुलद
@Arnauld ओपी ने प्रसार संचालक का उपयोग किया (मैं बफ़र से अपरिचित हूं इसलिए मुझे कोई बेहतर नहीं पता था) लेकिन यह एकल बफ़र के साथ एक बढ़िया चाल है!
— नील
@Arnauld सही, अद्यतन :)
— DanielIndie
1

रेटिना , 213 बाइट्स

K`17/91¶78/85¶19/51¶23/38¶29/33¶77/29¶95/23¶77/19¶1/17¶11/13¶13/11¶15/2¶1/7¶55/1¶17/91¶78/85¶19/51¶23/38¶29/33¶77/29¶95/23¶77/19¶1/17¶11/13¶13/11¶15/2¶1/7¶55/1¶2
\d+
*
"$+"+`((_+)/(_+)¶(.+¶)*)(\3)+$
$1$#5*$2
r`_\G

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

K`17/91¶78/85¶19/51¶23/38¶29/33¶77/29¶95/23¶77/19¶1/17¶11/13¶13/11¶15/2¶1/7¶55/1¶17/91¶78/85¶19/51¶23/38¶29/33¶77/29¶95/23¶77/19¶1/17¶11/13¶13/11¶15/2¶1/7¶55/1¶2

इनपुट को सभी अंशों की सूची के साथ बदलें, साथ ही प्रारंभिक पूर्णांक।

\d+
*

सबकुछ एकतरफा कर दो।

"$+"+`

मूल इनपुट द्वारा दिए गए समय की संख्या को प्रतिस्थापन दोहराएं।

((_+)/(_+)¶(.+¶)*)(\3)+$

एक भाजक खोजें जो समान रूप से पूर्णांक को विभाजित करता है।

$1$#5*$2

अंश के परिणाम के साथ पूर्णांक को अंश से गुणा करें।

r`_\G

पूर्णांक को दशमलव में परिवर्तित करें और परिणाम आउटपुट करें।

— नील
स्रोत
1

अटैच , 81 बाइट्स

Nest<~{Find[Integral,_*&`//=>Chop[Ords!"0zmt2R6E<@l<~6l2 0*,,*.-.!V "-31,2]]},2~>

इसे ऑनलाइन आज़माएं! एक अंश आउटपुट करता है1 से अधिक । उदाहरण के लिए, इनपुट 5रिटर्न 2275/1। इस N@कार्यक्रम के लिए तैयार करके प्लस 2 बाइट्स के साथ तय किया जा सकता है ।

व्याख्या

यह एक क्यूरेटेड फंक्शन है, जो करी करता है Nest दो पूर्वनिर्धारित तर्कों के साथ होता है:

{Find[Integral,_*&`//=>Chop[Ords!"0zmt2R6E<@l<~6l2 0*,,*.-.!V "-31,2]]}

तथा 2 । यह अंतिम तर्क बस प्रारंभिक बीज है, और इस फ़ंक्शन के लिए दिया गया तर्क दिए गए फ़ंक्शन को घोंसला करने के लिए पुनरावृत्तियों की संख्या है।

निम्नलिखित का उपयोग PRIMEGAME को एन्कोड करने के लिए किया जाता है:

&`//=>Chop[Ords!"0zmt2R6E<@l<~6l2 0*,,*.-.!V "-31,2]]

इसका मूल्यांकन इस प्रकार किया जाता है:

A> "0zmt2R6E<@l<~6l2 0*,,*.-.!V "
"0zmt2R6E<@l<~6l2 0*,,*.-.!V "
A> Ords!"0zmt2R6E<@l<~6l2 0*,,*.-.!V "
[48, 122, 109, 116, 50, 82, 54, 69, 60, 64, 108, 60, 126, 54, 108, 50, 32, 48, 42, 44, 44, 42, 46, 45, 46, 33, 86, 32]
A> Ords!"0zmt2R6E<@l<~6l2 0*,,*.-.!V "-31
[17, 91, 78, 85, 19, 51, 23, 38, 29, 33, 77, 29, 95, 23, 77, 19, 1, 17, 11, 13, 13, 11, 15, 14, 15, 2, 55, 1]
A> Chop[Ords!"0zmt2R6E<@l<~6l2 0*,,*.-.!V "-31,2]
 17 91
 78 85
 19 51
 23 38
 29 33
 77 29
 95 23
 77 19
  1 17
 11 13
 13 11
 15 14
 15  2
 55  1
A> &`//=>Chop[Ords!"0zmt2R6E<@l<~6l2 0*,,*.-.!V "-31,2]
[(17/91), (78/85), (19/51), (23/38), (29/33), (77/29), (95/23), (77/19), (1/17), (11/13), (13/11), (15/14), (15/2), (55/1)]

आइए इस अभिव्यक्ति Gको स्पष्टीकरण में बदलें । हमारा पहला कार्य बन जाता है:

{Find[Integral,_*G]}

यह FRACTRAN कोड का एक एकल पुनरावृत्ति करता है _, फ़ंक्शन के लिए इनपुट। यह सरणी का Findएक Integralसदस्य (एक पूर्णांक) है _*G, जो कि _प्रत्येक सदस्य के साथ गुणा किया गया इनपुट है G।Nestबस इस परिवर्तन को दी गई संख्या को लागू करता है।

अटैची, 42 बाइट्स

मैंने $langsइस चुनौती से प्रेरित होकर पुस्तकालय के कुछ हिस्सों को लागू किया है, इसलिए मैं इस खंड को गैर-प्रतिस्पर्धी मानता हूं।

Needs[$langs]2&FRACTRAN_EXAMPLES.prime.run

यह केवल FRACTRAN_EXAMPLESI की सूची पर सवाल उठाता है। प्रत्येक उदाहरण एक FractranExampleउदाहरण है, जो इनबिल्ट FRACTRANफ़ंक्शन को कॉल करता है। इसका primeउदाहरण कॉनवे का PRIMEGAME है।

— कोनोर ओ ब्रायन
स्रोत
0

PHP, 183 बाइट्स ("php" टैग के साथ 189)

गोल्फ: 

$t=2;for(;@$i++<$argv[1];){foreach([17/91,78/85,19/51,23/38,29/33,77/29,95/23,77/19,1/17,11/13,13/11,15/14,15/2,55/1]as$n){$a=$t*$n;if(preg_match('/^\d+$/',$a)){$t=$a;break;}}}echo$t;

Ungolfed: 

<?php 
$t=2;
for(;@$i++<$argv[1];){
    foreach([17/91,78/85,19/51,23/38,29/33,77/29,95/23,77/19,1/17,11/13,13/11,15/14,15/2,55/1] as $n){
        $a=$t*$n;
        if(preg_match('/^\d+$/',$a)){
            $t=$a;break;
        }
    }
}
echo $t;

इसे ऑनलाइन आज़माएं!

— बोयान इवानोव
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.