सिंपल टास्क सॉल्वड थ्रिस

Question

आपको एक भाषा में 3 कार्यक्रम और / या कार्य लिखना चाहिए।

इन सभी कार्यक्रमों को एक ही कार्य को हल करना चाहिए लेकिन उन्हें सभी को अलग-अलग (लेकिन मान्य) आउटपुट देना चाहिए। (यानी कार्यक्रमों की प्रत्येक जोड़ी के लिए उनका कुछ इनपुट होना चाहिए जो आउटपुट संख्याओं के अलग (लेकिन मान्य) सेट उत्पन्न करता है।)

काम

• आपको एक पूर्णांक दिया जाता है n, 1 से अधिक
• आपको n अलग-अलग सकारात्मक पूर्णांक लौटना चाहिए या आउटपुट करना चाहिए , और उनमें से कोई भी विभाज्य नहीं होना चाहिएn ।
• संख्याओं का क्रम मायने नहीं रखता है और संख्याओं का क्रमांकन विभिन्न आउटपुट के रूप में नहीं गिना जाता है।

कुछ input => outputयुग्मों के साथ कार्यक्रमों का एक मान्य ट्रिपल :

program A:
    2 => 5 9
    4 => 5 6 9 10
    5 => 2 4 8 7 1

program B:
    2 => 1 11
    4 => 6 9 1 2
    5 => 4 44 444 4444 44444

program C (differs only in one number from program B):
    2 => 1 13
    4 => 6 9 1 2
    5 => 4 44 444 4444 44444

स्कोरिंग

• आपका स्कोर 3 कार्यक्रमों या कार्यों की लंबाई का योग है।
• लोअर स्कोर बेहतर है।
• यदि आपके प्रोग्राम / फ़ंक्शन कोड साझा करते हैं, तो साझा किए गए कोड को कोड का उपयोग करने वाले प्रत्येक प्रोग्राम की लंबाई में गिना जाना चाहिए।

Comments

क्या प्रत्येक कार्यक्रम को किसी भी शामिल किए बिना अपनी फ़ाइल से चलाने में सक्षम होना पड़ता है, या क्या प्रोग्राम कुछ साझा मॉड्यूल / लाइब्रेरी पर निर्भर कर सकते हैं जो केवल एक बार गिना जाता है?

— क्विंटोपिया

@quintopia प्रोग्राम / फ़ंक्शन को कोड साझा नहीं करना चाहिए। यदि वे करते हैं, तो साझा कोड को उन सभी कार्यक्रमों की लंबाई में गिना जाना चाहिए जो कोड का उपयोग करते हैं।

— यादृच्छिक 13

Answer 1

पायथ, 17 16 बाइट्स

5 बाइट्स:

^LhQQ

आउटपुट:

2: [1, 3]
3: [1, 4, 16]
4: [1, 5, 25, 125]

6 बाइट्स:

mh*QdQ

आउटपुट:

2: [1, 3]
3: [1, 4, 7]
4: [1, 5, 9, 13]

5 बाइट्स:

|RhQQ

आउटपुट:

2: [3, 1]
3: [4, 1, 2]
4: [5, 1, 2, 3]

वैकल्पिक संस्करण, बढ़ते क्रम में: -ShQQ

Comments

ऊह। मुझे वह तीसरी स्कीम पसंद है।

— क्विंटोपिया

@ आइसाकग ओह, क्षमा करें

— माल्टसेन

Answer 2

जे, 16 बाइट्स

फंक्शन 1, 5 बाइट्स

p:^i.

फंक्शन 2, 6 बाइट्स

+p:^i.

फंक्शन 3, 5 बाइट्स

>:^i.

यह काम किस प्रकार करता है

कार्य 1

p:^i.     Right argument: y

   i.     Compute (0 ... y-1).
p:        Compute P, the prime at index y (zero-indexed).
  ^       Return all powers P^e, where e belongs to (0 ... y-1).

जबसे P अभाज्य है और P> y , y P ^{e को} विभाजित नहीं कर सकता है ।

समारोह 2

+p:^i.    Right argument: y

 p:^i.    As before.
+         Add y to all results.

यदि y ने P को विभाजित किया है ^e +, तो यह P ^e + y - y = P ^e को भी विभाजित करेगा ।

समारोह 3

>:^i.     Right argument: y

   i.     Compute (0 ... y-1).
>:        Compute y+1.
  ^       Return all powers (y+1)^e, where e belongs to (0 ... y-1).

यदि y विभाजित (y + 1) ^ई कुछ प्रमुख कारक Q की y विभाजित करने के लिए होगा (y + 1) ^ई ।

लेकिन फिर, क्यू दोनों y और y + 1 को विभाजित करेगा और इसलिए, y + 1 - y = 1 ।

Answer 3

डायलॉग एपीएल, 16 17 बाइट्स

1+⊢×⍳

⊢+1+⊢×⍳

1+⊢*⍳

Answer 4

Vitsy , 54 बाइट्स

कार्यक्रम:

V1V \ [DV * 1 + N '' O1 +]

V2V \ [DV * 1 + N '' O1 +]

V3V \ [DV * 1 + N '' O1 +]

आउटपुट:

2 => 3 7
4 => 5 9 13 17
5 => 6 11 16 21 26

2 => 5 7
४ => ९ १३ १ 17 २१
5 => 11 16 21 26 31

2 => 7 9
4 => 13 17 21 25 
5 => 16 21 26 31 36

यह कैसे काम करता है (स्पष्टीकरण के रूप में पहले कार्यक्रम का उपयोग करके):

V1V \ [DV * 1 + N '' O1 +]
V अंतिम वैश्विक चर के रूप में निहित इनपुट पर कब्जा।
 1 बाद में उपयोग के लिए स्टैक में एक पुश करें।
  V \ [] कोष्ठक इनपुट समय में सब कुछ करो।
     D स्टैक के शीर्ष आइटम को डुप्लिकेट करें।
      V वैश्विक वैरिएबल को स्टैक पर रखें।
       * 1 + गुणा करें, फिर 1 जोड़ें। यह इसे गैर-विभाज्य बनाता है।
          N '' O आउटपुट एक स्पेस के बाद का नंबर।
               1+ स्टैक में छोड़ी गई संख्या में एक जोड़ें।

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

Answer 5

पर्ल, 79

प्रत्येक कार्यक्रम में एक चार को जोड़ा गया क्योंकि इसके लिए -nध्वज की आवश्यकता होती है ।

for$a(0..$_-1){say$_*$a+1}
for$a(1..$_){say$_*$a+1}
for$a(2..$_+1){say$_*$a+1}

काफी सरल।

Answer 6

गणितज्ञ, 12 + 12 + 12 = 36 बाइट्स

# Range@#-1&
# Range@#+1&
#^Range@#+1&

टेस्ट:

# Range@#-1&[10]
(* -> {9, 19, 29, 39, 49, 59, 69, 79, 89, 99} *)
# Range@#+1&[10]
(* -> {11, 21, 31, 41, 51, 61, 71, 81, 91, 101} *)
#^Range@#+1&[10]
(* -> {11, 101, 1001, 10001, 100001, 1000001, 10000001, 100000001, 1000000001, 10000000001} *)

Comments

क्या आप कुछ उदाहरण आउटपुट जोड़ सकते हैं?

— पाओलो एबरमैन

Answer 7

सीजाम, 8 + 8 + 8 = 24 बाइट्स

{,:)))+}
{_,f*:)}
{)_(,f#}

ये तीन अनाम कार्य हैं जो nस्टैक पर होने की उम्मीद करते हैं और इसके स्थान पर पूर्णांक की एक सूची छोड़ते हैं। मुझे यकीन नहीं है कि यह इष्टतम है, लेकिन मुझे बाद में एक छोटे समाधान के लिए शिकार करना होगा।

परीक्षण सूट।

परिणाम:

{,:)))+}
2 => [1 3]
3 => [1 2 4]
4 => [1 2 3 5]
5 => [1 2 3 4 6]

{_,f*:)}
2 => [1 3]
3 => [1 4 7]
4 => [1 5 9 13]
5 => [1 6 11 16 21]

{)_(,f#}
2 => [1 3]
3 => [1 4 16]
4 => [1 5 25 125]
5 => [1 6 36 216 1296]

पहले वाला भी काम करता है

{_),:)^}

या

{_(,+:)}

Comments

आपके परिणाम तीनों को एक ही आउटपुट देते हुए दिखाते हैं जब n = 2

— स्पर्धा

@ शेपर की अनुमति है। चुनौती में उदाहरण देखें। केवल आवश्यकता यह है कि वे अलग-अलग कार्यों की गणना करते हैं, न कि हर इनपुट पर अलग-अलग परिणाम।

— मार्टिन एंडर

आह, उन्हें कुछ इनपुट पर अलग परिणाम देना होगा । यही मैंने गलत समझा।

— 20

Answer 8

पायथन 2, 79 बाइट्स

lambda n:range(1,n*n,n)
lambda n:range(1,2*n*n,2*n)
lambda n:range(1,3*n*n,3*n)

तीन अनाम फ़ंक्शन जो शर्तों 1के n, 2*n, 3*nलिए प्रत्येक पर शुरू और गिनते nहैं।

Answer 9

गंभीरता से, 20 बाइट्स

,;r*1+

,;R*1+

,;R1+*1+

हाँ, यह इष्टतम नहीं है ...

Answer 10

Par , 16 बाइट्स

यहाँ वर्णित कस्टम एन्कोडिंग, प्रति वर्ण केवल एक बाइट का उपयोग करता है।

✶″{*↑                   ## 3 => (0 1 2) => (0 3 6)  => (1 4 7)
✶″U{ⁿ↑                  ## 3 => (1 2 3) => (3 9 27) => (4 10 28)
✶U¡↑◄                   ## 3 => (1 2 3) =>             (1 2 4)

आउटपुट

2 => (1 3)
3 => (1 4 7)
4 => (1 5 9 13)
5 => (1 6 11 16 21)

2 => (3 5)
3 => (4 10 28)
4 => (5 17 65 257)
5 => (6 26 126 626 3126)

2 => (1 3)
3 => (1 2 4)
4 => (1 2 3 5)
5 => (1 2 3 4 6)

Answer 11

हास्केल, 54 बाइट्स

f n=n+1:[1..n-1]
g n=5*n+1:[1..n-1]
h n=9*n+1:[1..n-1]

ये तीन कार्य बहुत सीधे हैं ...

Answer 12

ऑक्टेव, 11 + 13 + 13 = 37 बाइट्स

@(a)1:a:a^2
@(a)a-1:a:a^2
@(a)(1:a)*a+1

Answer 13

पायथन 2, 125 बाइट्स

N=input();print[i*N+1for i in range(N)]
N=input();print[i*N+1for i in range(1,N+1)]
N=input();print[i*N+1for i in range(2,N+2)]

यहां प्रत्येक पंक्ति एक संपूर्ण कार्यक्रम है। मेरे दिमाग में सबसे स्पष्ट समाधान।

EDIT @ Sherlock9 ने दो बाइट्स बचाए।

Answer 14

हास्केल, 50

f n=n+1:[1..n-1]
f n=1:[n+1..2*n-1]
f n=[1,n+1..n^2]

उदाहरण:

 f1 5=[6,1,2,3,4]
 f2 5=[1,6,7,8,9]
 f3 5=[1,6,11,16,21]

Answer 15

गोल्फस्क्रिप्ट, 50 51 57 बाइट्स

क्या हुआ करता था की एक Golfscript संस्करण quintopia के अजगर कोड। प्रत्येक फ़ंक्शन nस्टैक को हटा देता है।

{.,{1$*)}%\;}:f;    i*n+1 for i in range(n)
{.,{)1$*)}%\;}:g;   i*n+1 for i in range(1,n+1)
{.,{1$)\?}%\;}:h;   (n+1)**i for i in range(n)

Answer 16

TI-Basic (TI-84 Plus CE), 55 40 बाइट्स कुल

PRGM:C 12 bytes
    seq(AnsX+1,X,1,Ans

PRGM:B 14 bytes
    seq(AnsX+1,X,2,Ans+1

PRGM:C 14 bytes
    seq(AnsX+1,X,3,Ans+2

सरल, यहाँ कई अन्य उत्तरों के समान है, प्रत्येक एक्स (रेंज) में एक्स (रेंज) के लिए संख्याओं (एक्स + ए) एन + 1 की सूची प्रदर्शित करता है और ए प्रोग्राम (1, 2, या 3) होने के साथ।

पुराना समाधान (55 बाइट्स):

PRGM:C 17 bytes
    Prompt N
    For(X,1,N
    Disp XN+1
    End

PRGM:B 19 bytes
    Prompt N
    For(X,2,N+1
    Disp XN+1
    End

PRGM:C 19 bytes
    Prompt N
    For(X,3,N+2
    Disp XN+1
    End

सरल, यहाँ कई अन्य उत्तरों के समान है, प्रत्येक एक्स (रेंज) में एक्स (रेंज) के लिए संख्या (एक्स + ए) एन + 1 प्रदर्शित करता है और ए के साथ कौन सा प्रोग्राम (1, 2, या 3) है।