27

आपका कार्य बहुत सरल है, A190810 के n-वें तत्व की गणना करें ।

A190810 के तत्वों की गणना इन नियमों के अनुसार की जाती है:

पहला तत्व 1 है
क्रम बढ़ता जा रहा है
यदि xअनुक्रम में होता है, तो 2x+1और 3x-1भी करते हैं

आप 1-आधारित या 0-आधारित अनुक्रमण का उपयोग कर सकते हैं, लेकिन यदि आप 0-आधारित अनुक्रमण का उपयोग करते हैं, तो कृपया उत्तर में कहें।

परीक्षण के मामलों

a(1) = 1
a(2) = 2
a(3) = 3
a(4) = 5
a(5) = 7
a(10) = 17
a(20) = 50
a(30) = 95
a(55) = 255

चूंकि यह कोड-गोल्फ है, बाइट्स जीत में सबसे छोटा जवाब!

— TuxCrafting
स्रोत

2

आपको बड़े परीक्षण मामलों को जोड़ना चाहिए।

— mbomb007

7

क्या आप इसे थोड़ा और स्पष्ट रूप से समझा सकते हैं? मैं एक देशी अंग्रेजी वक्ता हूं और मुझे नहीं पता "क्या है ... और यदि x एक 2x में है तो 1 + और 3x-1 एक में हैं।" माना जाता है।

— बिल्ली

1

@cat x ϵ A → (2*x) + 1 ϵ Aऔर x ϵ A → (3*x)-1 ϵ A, जहां का ϵअर्थ है "का एक सदस्य है" और →इसे "आशय" के रूप में समझा जा सकता है।

— स्टीवन एच।

3

निहित स्थिति: अनुक्रम में अन्य नियमों द्वारा आवश्यक संख्याएं नहीं होती हैं। (अन्यथा $ a (i) = i $ एक वैध अनुक्रम होगा)

— स्टिग हेमर

1

और आप मुफ्त मैथमेटिका और हास्केल के उत्तर पाने के लिए :) से शुरू करें

— रोकना मोनिका

9

जेली , 16 बाइट्स

×3’;Ḥ‘$;
1Ç¡ṢQ³ị

बहुत अकुशल। इसे ऑनलाइन आज़माएं!

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

1Ç¡ṢQ³ị   Main link. Argument: n (integer)

1         Set the return value to 1.
 Ç¡       Execute the helper link n times.
   Ṣ      Sort the resulting array.
    Q     Unique; deduplicate the sorted array.
     ³ị   Retrieve its n-th element.


×3’;Ḥ‘$;  Helper link. Argument: A (array)

×3        Multiply all elements of A by 3.
  ’       Decrement the resulting products.
      $   Combine the two links to the left into a monadic chain.
    Ḥ     Unhalve; multiply all elements of A by 2.
     ‘    Increment the resulting products.
   ;      Concatenate 3A-1 and 2A+1.
       ;  Concatenate the result with A.

— डेनिस
स्रोत

1

यह 16 वर्ण हो सकता है , लेकिन मुझे 30 से कम बाइट्स में प्रतिनिधित्व करने वाले किसी भी एन्कोडिंग का पता नहीं है ।

— अमीर रईस

18

जेली का अपना कोडपेज है जो इन पात्रों को प्रत्येक 1 बाइट के लिए अनुमति देता है।

15

पायथन 2, 88 83 72 बाइट्स

आप इस उत्तर में कार्यक्रमों को उल्टे क्रम में पढ़ना चाह सकते हैं ...

धीमी और छोटी अभी भी, डेनिस के लिए धन्यवाद:

L=1,;exec'L+=2*L[0]+1,3*L[0]-1;L=sorted(set(L))[1:];'*input()
print L[0]

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

यह तेजी से नहीं चलता है, लेकिन कम होता है ( 83 बाइट्स ।) प्रत्येक पुनरावृत्ति को छाँटकर और हटाकर, साथ ही पहले तत्व को हटाकर, मैं सूची में एक सूचकांक की आवश्यकता को हटा देता हूं। परिणाम nपुनरावृत्तियों के बाद बस पहला तत्व है ।

मेरे पास डेनिस गोल्फ हो सकता है। : डी

L=[1]
n=input()
while n:L+=[2*L[0]+1,3*L[0]-1];n-=1;L=sorted(set(L))[1:]
print L[0]

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

नीचे दिया गया यह संस्करण ( 88 बाइट्स ) वास्तव में तेजी से चलता है, लगभग दो सेकंड में 500000 वां तत्व खोजता है।

यह बहुत आसान है। सूची के तत्वों की गणना तब तक करें जब तक कि तीन गुना अधिक तत्व न हों n, क्योंकि प्रत्येक जोड़ा गया तत्व अधिकतम 2 और अद्वितीय तत्वों को जोड़ सकता है। फिर डुप्लिकेट को हटाएं, और nवें तत्व को प्रिंट करें (शून्य-अनुक्रमित)।

L=[1]
i=0
n=input()
while len(L)<3*n:L+=[2*L[i]+1,3*L[i]-1];i+=1
print sorted(set(L))[n]

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

— mbomb007
स्रोत

8

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

t={1}
exec'm=min(t);t=t-{m}|{2*m+1,3*m-1};'*input()
print m

@ Mbomb007 के पायथन उत्तर के आधार पर । Ideone पर इसका परीक्षण करें ।

— डेनिस
स्रोत

"एक बस डेनिस से बाहर नहीं निकलता" ... काश मैं सेट शाब्दिक का उपयोग करने के बारे में सोचता। यह अब इतना स्पष्ट लगता है। यदि आप एक स्ट्रिंग को वास्तविक कोड में बदलने से बदलते हैं तो क्या यह उत्तर मेरे "तेज" कार्यक्रम से भी तेज है?

— mbomb007

नहीं। यह धीमा है। सेट ऑपरेशन अधिक महंगे हैं।

— mbomb007

हाँ, minहै हे (एन) सूची अनुक्रमण है, जबकि हे (1) , तो यह समाधान कम से कम है ओ (n²) ...

— डेनिस

8

हास्केल, 76 73 69 बाइट्स

a#b=mod a b<1&&t(div a b)
t x=x<2||(x-1)#2||(x+1)#3
(filter t[1..]!!)

0-आधारित इंडेक्स का उपयोग करता है। प्रयोग उदाहरण: (filter t[1..]!!) 54-> 255।

बार-बार डालने के द्वारा सूची बनाने के बजाय 2x+1और 3x-1जैसा कि अधिकांश अन्य उत्तरों में देखा जाता है, मैं सभी पूर्णांकों के माध्यम से जाता हूं और जांचता हूं कि क्या वे 1बार-बार आवेदन करके (x-1) / 2या (x+1) / 3विभाज्य से कम हो सकते हैं ।

— nimi
स्रोत

यह वास्तव में एक फ़ंक्शन या वैध कोड स्निपेट को परिभाषित नहीं करता है, क्या यह करता है?

— जेटा

@Zeta अंतिम पंक्ति एक अनाम फ़ंक्शन का मूल्यांकन करती है।

— जर्गुल

@Zgarb जो हास्केल फ़ाइल में एक त्रुटि है, और कोई भी दुभाषिया जिससे मैं अवगत नहीं हूँ, इस तरह की सुविधा का समर्थन करता है। तो, कृपया, मुझे बताएं, किसी उपयोगकर्ता को किसी भी तरह से ऊपर कोड को संशोधित किए बिना इसका उपयोग कैसे करना चाहिए ? या आप मुझे एक मेटा पोस्ट की ओर संकेत कर सकते हैं जो इस तरह के कोड की अनुमति देता है?

— ज़ीटा

2

@Zgarb मैं अंतिम पंक्ति के लिए सोचता हूं, इसे एक बाध्यकारी (जैसे f=filter t[1..]!!) असाइन करता हूं, क्योंकि मुझे नहीं लगता कि यह सही है।

— TuxCrafting

1

@ T @xCräftîñg इस मेटा पोस्ट पर , यह निर्धारित किया गया था कि अतिरिक्त सहायक कार्य इस स्थिति में डिफ़ॉल्ट रूप से स्वीकार्य हैं। यह वह प्रारूप भी है जिसे मैं आमतौर पर हास्केल के उत्तर के लिए देखता हूं। बेशक, आप चुनौती लेखक के रूप में अंतिम प्राधिकारी हैं।

— जर्बेर जूल

7

हास्केल, 77 74 बाइट्स

import Data.List
i=insert
f(x:y)=x:f(i(2*x+1)$i(3*x-1)y)
a=(!!)(nub$f[1])

यह aएन-वें प्रविष्टि के लिए एक फ़ंक्शन प्रदान करता है । यह शून्य अनुक्रमित है। वैकल्पिक रूप से, a=nub$f[1]पूरी सूची (आलसी) बनाएंगे।

यह रेनहार्ड ज़ुम्केलर के Setकोड का एक सूची-प्रकार है ।

— जीटा
स्रोत

दो बाइट बचाने के yबजाय क्यों नहीं xs? इसके अलावा, मेरा मानना है कि आप अंतिम पंक्ति में कुछ कटौती करने में सक्षम हो सकते हैं जैसे(!!)$nub.f[1]

— माइकल क्लेन

@MichaelKlein: मैं अभी भी आदत है (x:xs), पूरी तरह से भूल गया कि, धन्यवाद।

— जेटा

6

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

g=lambda k:g(k%2*k/2)|g(k%3/2*-~k/3)if k>1else k
f=lambda n,k=1:n and-~f(n-g(k),k+1)

Ideone पर इसका परीक्षण करें ।

— डेनिस
स्रोत

13

आप कुछ अपठनीय में कुछ सरल मोड़ पर एक समर्थक हैं।

— mbomb007

6

पायथ, 20 19 बाइट्स

hutS{+G,hyhGt*3hGQ0

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

शून्य-आधारित अनुक्रमण का उपयोग करता है।

— PurkkaKoodari
स्रोत

1

@ जकुब धन्यवाद। मुझे आश्चर्य है कि जब मैंने अभी 1- अभी कोशिश की, तो मैंने यह कैसे पता लगाया कि यह स्पष्ट रूप से काम नहीं करता है।

— पुरकाकूदरी

5

ब्रेकीलॉग , 45 बाइट्स

:1-I,?:?*:1ydo:Im.
1.|:1-:1&I(:3*:1-.;I*:1+.)

N = 1000मेरी मशीन पर लगभग 6 सेकंड में गणना करता है।

यह 1-अनुक्रमित है, उदा

run_from_file('code.brachylog',1000,Z).
Z = 13961 .

व्याख्या

मुख्य विधेय:

:1-I,               I = Input - 1
     ?:?*           Square the Input
         :1y        Find the first Input*Input valid outputs of predicate 1
            do      Remove duplicates and order
              :Im.  Output is the Ith element

1 समर्पित करें:

1.                  Input = Output = 1
|                   Or
:1-:1&I             I is the output of predicate 1 called with Input - 1 as input
       (            
         :3*:1-.      Output is 3*I-1
       ;            Or
         I*:1+.       Output is 2*I+1
       )

आप ध्यान दें कि जब हम कॉल करते हैं तो हम 1 इनपुट को विधेय करने के लिए कोई इनपुट पास नहीं करते हैं y - Yield। बाधा प्रसार के कारण, यह सही इनपुट को एक बार 1.क्लॉज तक पहुंचा देगा जो सही इनपुट मानों का प्रचार करेगा।

— Fatalize
स्रोत

4

MATL, 19, 18 17 बाइट्स

1w:"tEQy3*qvSu]G)

यह एक अत्यंत अक्षम एल्गोरिथ्म है। ऑनलाइन इंटरप्रेटर 13 से अधिक इनपुट के लिए मेमोरी से बाहर चलाता है।

एक बाइट बचाया, लुइस मेंडो के लिए धन्यवाद!

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

यह संस्करण लंबा है, लेकिन अधिक कुशल (21 बाइट्स)

1`tEQy3*qvSutnG3*<]G)

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

स्पष्टीकरण:

यह करने का तार्किक तरीका है, तत्वों को सरणी में जोड़ना जब तक कि यह i'th तत्व को हथियाने के लिए पर्याप्त लंबा न हो। यही कारण है कि कुशल एक काम करता है। Golfy (और अक्षम) जिस तरह से यह करने के लिए, बस सरणी आकार बढ़ाने के लिए है मैं बार।

तो सबसे पहले, हम स्टार्ट एरे को परिभाषित करते हैं 1:। फिर हम शीर्ष दो तत्वों को स्वैप करते हैं, ताकि इनपुट शीर्ष पर हो। w। अब, हम इनपुट के माध्यम से लूप करते हैं :"। इसलिए मैं कई बार:

t             %Duplicate our starting (or current) array.
 EQ           %Double it and increment
   y          %Push our starting array again
    3*q       %Multiply by 3 and decrement
       v      %Concatenate these two arrays and the starting array
        Su    %Sort them and remove all duplicate elements.

अब, हमारे पास अनुक्रम का एक विशाल सरणी है। (गणना करने के लिए अधिक से अधिक रास्ता आवश्यक है) इसलिए हम लूप करना बंद कर देते हैं ], और इस सरणी से G)(1-इंडेक्स) के साथ i'th संख्या को पकड़ते हैं।

— DJMcMayhem
स्रोत

@LuisMendo टिप के लिए धन्यवाद! आप लूप के बजाय थोड़ी देर के लूप के साथ इसे फिर से कैसे लिखेंगे? (हो सकता है कि Matl चैट रुम के लिए एक बेहतर सवाल होगा)

— DJMcMayhem

यह इस तरह से किया जा सकता है 1`tEQy3*qvuStnG<]G):। लूप स्थिति है tnG<(बाहर निकलें जब सरणी में पहले से ही आवश्यक आकार है)

— लुइस मेंडो

सुनिश्चित नहीं हैं कि कितना धोखाधड़ी यह है, लेकिन में for-loop संस्करण आप कर सकते हैं एकल में इनपुट लेने के एक स्ट्रिंग के रूप और हटाने:

— लुइस Mendo

4

जावास्क्रिप्ट (ईएस 6), 63 बाइट्स

 f=(n,a=[1],i=0)=>a[i++]?--n?f(n,a,a[i*2]=a[i*3-2]=1):i:f(n,a,i)

शायद पुनरावृत्ति के कारण जल्दी छोड़ देता है।

— नील
स्रोत

4

रेटिना, 57

^.+
$*¶¶1
¶¶(1(1*))
¶1$1$1¶$2$1$1
O`
}`(¶1+)\1\b
$1
G2`
1

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

0 अनुक्रमित। इस प्रकार है अक्सर इस्तेमाल किया एल्गोरिथ्म:, वर्तमान सेट से न्यूनतम मूल्य को दूर इसे कहते xहैं, और जोड़ने 2x+1और 3x-1सेट कई बार इनपुट करने के लिए बराबर करने के लिए, तो अग्रणी संख्या परिणाम है। रेटिना में "सेट" सिर्फ एक सूची है जिसे बार-बार क्रमबद्ध किया जाता है और इसमें केवल अद्वितीय तत्व होते हैं। गोल्फ के लिए एल्गोरिथ्म में कुछ डरपोक बिट्स जोड़े गए हैं, जिन्हें मैं एक बार समझाने के बाद कुछ और बताऊंगा।

लगभग 20 बाइट को बंद करने के लिए मार्टिन का बड़ा धन्यवाद!

— FryAmTheEggman
स्रोत

4

क्लोजर, 114 108 बाइट्स

#(loop[a(sorted-set 1)n 1](let[x(first a)](if(= n %)x(recur(conj(disj a x)(+(* 2 x)1)(-(* 3 x)1))(inc n)))))

मुझे आश्चर्य नहीं होगा अगर यह एक महत्वपूर्ण राशि से कम / कम किया जा सकता है, लेकिन setएनटी का समर्थन नहीं करने से वास्तव में मेरे विचार की ट्रेन को चोट लगी है।

ऑनलाइन कोशिश करें

रिक्त स्थान के साथ संस्करण:

#(loop [a (sorted-set 1)
        n 1]
  (let [x (first a)]
    (if (= n %)
      x
      (recur (conj (disj a x) (+ (* 2 x) 1) (- (* 3 x) 1)) (inc n))
      )))

— क्रिस एफ
स्रोत

4

05AB1E, 18 17 बाइट्स

CP-1252 एन्कोडिंग का उपयोग करता है ।

$FÐ·>s3*<)˜Ù}ï{¹è

व्याख्या

$                  # initialize with 1
 F          }      # input number of times do
  Ð                # triplicate current list/number
   ·>              # double one copy and add 1
     s3*<          # multiply one copy by 3 and subtract 1
         )˜Ù       # combine the 3 lists to 1 list and remove duplicates
             ï{    # convert list to int and sort
               ¹è  # take the element from the list at index input

छोटी संख्या के लिए इसे ऑनलाइन आज़माएं

बहुत धीमी गति से।
0-आधारित अनुक्रमण का उपयोग करता है।

— Emigna
स्रोत

3

सी ++, 102 बाइट्स

[](int i){int t;map<int,int>k;for(k[1];i--;k.erase(t))t=k.begin()->first,k[t*2+1],k[t*3-1];return t;};

इस लंबो फ़ंक्शन की आवश्यकता है #include <map>और using std::map।

mapयहाँ सिर्फ चाबियों का एक संग्रह है; उनके मूल्यों की अनदेखी की जाती है। मैं mapसम्मिलन के लिए ट्रिक कोड से लाभ के लिए उपयोग करता हूं :

k[1]; // inserts the key 1 into the map

के क्रमबद्ध क्रम के लिए धन्यवाद map, सबसे छोटा तत्व द्वारा निकाला जाता है k.begin()->first।

— anatolyg
स्रोत

1

थोड़ा कम (97) का उपयोग कर setऔर initializer सूची [](int i){int t;set<int>k{1};for(;i--;k.erase(t))t=*k.begin(),k.insert({t*2+1,t*3-1});return t;};:।

— nwn

3

दरअसल, 27 बाइट्स

╗1#╜`;;2*1+)3*1@-#++╔S`n╜@E

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

यह प्रोग्राम 0-आधारित इंडेक्सिंग का उपयोग करता है। दृष्टिकोण बहुत ही क्रूर है, इसलिए इसे बड़े इनपुट के लिए ऑनलाइन दुभाषिया में काम करने की उम्मीद न करें।

स्पष्टीकरण:

╗1#╜`;;2*1+)3*1@-#++╔S`n╜@E
╗                            save input (n) in register 0
 1#                          push [1]
   ╜                         push n
    `;;2*1+)3*1@-#++╔S`n     do the following n times:
     ;;                        make two copies of the list
       2*1+                    apply 2x+1 to each element in one copy
           )3*1@-              and 3x-1 to each element in the other copy
                 #             workaround for a weird list bug
                  ++           append those two lists to the original list
                    ╔S         uniquify and sort
                        ╜@E  get the nth element (0-indexed)

— मै जाऊं
स्रोत

2

CJam (25 बाइट्स)

ri1a1${{_2*)1$3*(}%_&}*$=

ऑनलाइन डेमो । ध्यान दें कि यह शून्य-आधारित अनुक्रमण का उपयोग करता है।

यह अधिकांश के लिए एक समान दृष्टिकोण का उपयोग करता है: ट्रांसफ़ॉर्म nबार लागू करें और फिर nवें आइटम को सॉर्ट करें और निकालें । दक्षता के लिए एक नोड के रूप में कटौती लूप के अंदर लागू होती है और लूप के बाहर छँटाई की जाती है।

— पीटर टेलर
स्रोत

2

22: 1ari{(_2*)\3*(@||$}*0=(बहुत अधिक कुशल।)

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

2

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

.+
$*
+1`^(((!*)!(!|\3)(?=\3!1))*!)1|\b
!$1
-2`.

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

निम्मी के जवाब से प्रेरित होकर मैंने सोचा कि मैं रेटिना के लिए एक अलग दृष्टिकोण की कोशिश करूँगा, जिससे रेगेक्स इंजन के बैकट्रैकिंग का उपयोग करके यह पता लगाया जा सकेगा कि कोई दिया गया (यूनेरी) क्रम अनुक्रम में है या नहीं। यह पता चला है कि यह 27 बाइट रेगेक्स के साथ निर्धारित किया जा सकता है, लेकिन इसका उपयोग करने में कुछ अधिक खर्च होता है, लेकिन यह अभी भी जेनेरिक दृष्टिकोण से कम है।

यहाँ एक वैकल्पिक 48-बाइट समाधान है:

.+
$*
{`1\b
1!
}T`1``1((!*)!(!|\2)(?=!\2$))*!$
!

और यूरी I / O का उपयोग करके हम 42 बाइट्स कर सकते हैं, लेकिन मैं इससे बचने की कोशिश कर रहा हूं और अन्य रेटिना उत्तर दशमलव का भी उपयोग करता है:

1\b
1!
}T`1``1((!*)!(!|\2)(?=!\2$))*!$
!
1

— मार्टिन एंडर
स्रोत

2

रूबी, 70 बाइट्स

->n{a=*1
n.times{a<<a.map{|i|([2*i+1,3*i-1]-a).min||1.0/0}.min}
a[-2]}

व्याख्या

->n{
    # Magical, golfy way of initializing an array. Equivalent to a = [1].
    a=*1
    n.times{
        # Generate the next element in the sequence, by...
        a<<
            # ... finding the minimal term that will appear at some point.
            a.map{|i|
                ([2*i+1,3*i-1]-a).min||1.0/0
            }.min
    }
    # We generated n+1 elements, so we'll take the *second* to last one.
    a[-2]
}

— एम-Chrzan
स्रोत

1

वह *1चाल साफ

— सुथरी है

1

जे, 31 बाइट्स

{1(]]/:~@~.@,3&*,&:<:2*>:)^:[~]

शून्य-आधारित अनुक्रमण का उपयोग करता है। बहुत स्मृति-अक्षम।

व्याख्या

{1(]]/:~@~.@,3&*,&:<:2*>:)^:[~]  Input: n
                              ]  Identity function, gets n
 1                               The constant 1
  (                      )^:[~   Repeat n times with an initial array a = [1]
                       >:          Increment each in a
                     2*            Multiply by 2 to get 2a+2
             3&*                   Multiply each in a by 3 to get 3a
                 &:<:              Decrement both x and y to get 2a+1 and 3a-1
                ,                  Join them
    ]                              Identity function, gets a
            ,                      Join a with 2a+1 and 3a-1
         ~.@                       Take the distinct values
     /:~@                          Sort up
   ]                               Return the sorted list
{                                Select the value from the list at index n and return it

— मील की दूरी पर
स्रोत

1

ऑक्टेव, 68 बाइट्स

function r=a(n)s=1;for(i=1:n)r=s(i);s=union(s,[r*2+1 r*3-1]);end;end

— dcsohl
स्रोत

आप अंतिम निकाल सकते हैं;end

— लुइस Mendo

मेरे द्वारा उपयोग किए जाने वाले संस्करण पर, कम से कम (4.0.0) आप नहीं कर सकते ...

— dcsohl

1

पर्ल, 173 132 बाइट्स +1 फॉर-एन = 133

sub c{my$a=pop;return($a==1||($a%2&&c(($a-1)/2))?1:$a%3!=2?0:$a%3==2?c(($a+1)/3):1)}while($#b<$_){$i++;@b=(@b,$i)if c$i}say$b[$_-1];

Ungolfed:

my @array = ();
my $n = <>;
sub chk {
    my $a = shift;
    return 1 if ($a == 1);
    if ($a % 2 == 0) {
        if ($a % 3 != 2) {
            return 0;
        } else {
            return chk(($a + 1) / 3);
        }
    } else {
        if (chk(($a - 1) / 2) == 0) {
            if ($a % 3 != 2) {
                return 0;
            } else {
                return chk(($a + 1) / 3);
            }
        } else {
            return 1
        }
    }
}
my $i = 1;
while ($#array < $n-1) {
    push(@array,$i) if (chk($i) == 1);
    $i++;
}
print $array[$n];

मैं शायद बेहतर कर सकता हूं अगर मैंने इसके बारे में अधिक सोचा, लेकिन यह वही है जो मैं बस कुछ ही मिनटों के बाद आया था। मेरी पहली बार गोल्फ, तो यह बहुत मजेदार था!

-40 बाइट्स के लिए @Dada और @ TùxCräftgñg (और मामूली बाइट-अनुकूलन का एक गुच्छा) के लिए धन्यवाद

— गेब्रियल बेनामी
स्रोत

1

मुझे लगता है कि आप mys के बाद रिक्त स्थान छोड़ सकते हैं , returnऔर print(परीक्षण नहीं कर सकते, perl नहीं है)

— TuxCrafting

1

@ T @xCräftîñg के बारे में सही है return। printएक से की जगह किया जा सकता है say। अधिकांश की myजरूरत नहीं है (आपको $aलगता है कि फ़ंक्शन से पहले मुझे केवल एक की आवश्यकता है। न तो इनिशियलाइज़ करें और न ही घोषित करें @b। आप शायद अंत में के बजाए जब $iआप $i++शुरुआत में करते हैं , तो आप इनिशियलाइज़ेशन को छोड़ सकते हैं । pop) से कम shift। ध्यान रखें कि व्हेलस्पेस और न्यूलाइन्स को हटाने की तुलना में पेल गोल्फिंग के लिए बहुत कुछ है ...

— दादा

0

जावास्क्रिप्ट (ईएस 6), 58

n=>(a=>{for(;n;)a[++i]?a[i-~i]=a[3*i-1]=--n:0})([i=0,1])|i

कम गोल्फ वाला

n=>{
  a=[];
  a[1] = 1;
  for(i = 0; n;)
  {
    ++i
    if (a[i])
    {
      a[2*i+1] = 1;
      a[3*i-1] = 1;
      --n;
    }
  }
  return i
}

परीक्षा

समय और मेमोरी के बारे में: ~ 500 सेकंड में तत्व 500000 और मेरे फायरफॉक्स 64 बिट अल्फा द्वारा उपयोग किए जाने वाले 300 एमबी

F=
n=>(a=>{for(;n;)a[++i]?a[i-~i]=a[3*i-1]=--n:0})([i=0,1])|i

function test() {
  var n=+I.value, t0=+new Date
  O.textContent = F(n)
  console.log((+new Date-t0)/1000,'sec')
}  

test()

#I { width:5em}

<input id=I type=number value=10 oninput="test()"> 
<span id=O></span>

स्निपेट का विस्तार करें

— edc65
स्रोत

A190810 की गणना करें

जेली , 16 बाइट्स

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

पायथन 2, 88 83 72 बाइट्स

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

हास्केल, 76 73 69 बाइट्स

हास्केल, 77 74 बाइट्स

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

पायथ, 20 19 बाइट्स

ब्रेकीलॉग , 45 बाइट्स

व्याख्या

MATL, 19, 18 17 बाइट्स

जावास्क्रिप्ट (ईएस 6), 63 बाइट्स

रेटिना, 57

क्लोजर, 114 108 बाइट्स

05AB1E, 18 17 बाइट्स

सी ++, 102 बाइट्स

दरअसल, 27 बाइट्स

CJam (25 बाइट्स)

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

रूबी, 70 बाइट्स

व्याख्या

जे, 31 बाइट्स

व्याख्या

ऑक्टेव, 68 बाइट्स

पर्ल, 173 132 बाइट्स +1 फॉर-एन = 133

जावास्क्रिप्ट (ईएस 6), 58