नया आदेश # 4: दुनिया

Question

परिचय (नजरअंदाज किया जा सकता है)

अपने नियमित क्रम (1, 2, 3, ...) में सभी सकारात्मक संख्याओं को डालना थोड़ा उबाऊ है, है ना? इसलिए यहां सभी सकारात्मक संख्याओं के क्रमपरिवर्तन (फेरबदल) के आसपास चुनौतियों की एक श्रृंखला है। यह इस श्रृंखला में चौथी चुनौती है ( पहली , दूसरी और तीसरी चुनौती के लिए लिंक )।

इस चुनौती में, हम नहीं जानेंगे एक प्राकृतिक संख्या का क्रमचय, लेकिन एक पूरी दुनिया क्रमपरिवर्तन की!

2000 में, क्लार्क किम्बरलिंग ने कनाडाई मैथमैटिकल सोसाइटी द्वारा प्रकाशित गणित की वैज्ञानिक पत्रिका क्रूक्स मैथमैटिकोरम के 26 ^वें अंक में एक समस्या पेश की । समस्या यह थी:

$\text{Sequence }a = \begin{cases} a_1 = 1\\ a_n = \lfloor \frac{a_{n-1}}{2} \rfloor\text{ if }\lfloor \frac{a_{n-1}}{2} \rfloor \notin \{0, a_1, ... , a_{n-1}\}\\ a_n = 3 a_{n-1}\text{ otherwise} \end{cases}$

क्या इस क्रम में हर सकारात्मक पूर्णांक एक बार होता है?

2004 में, माट्यूज़ क्वासनिकी ने एक ही पत्रिका में सकारात्मक प्रमाण प्रदान किया और 2008 में, उन्होंने एक अधिक औपचारिक और (मूल प्रश्न की तुलना में) एक अधिक सामान्य प्रमाण प्रकाशित किया । उन्होंने पैरामीटर $p$ और q के साथ अनुक्रम तैयार किया$q$ :

$\begin{cases} a_1 = 1\\ a_n = \lfloor \frac{a_{n-1}}{q} \rfloor\text{ if }\lfloor \frac{a_{n-1}}{q} \rfloor \notin \{0, a_1, ... , a_{n-1}\}\\ a_n = p a_{n-1}\text{ otherwise} \end{cases}$

उन्होंने साबित किया कि किसी भी $p, q>1$ ऐसा है कि $log_p(q)$ अपरिमेय है, क्रम प्राकृतिक संख्याओं का क्रमपरिवर्तन है। चूंकि $p$ और $q$ मानों की एक अनंत संख्या है , जिसके लिए यह सत्य है, यह वास्तव में प्राकृतिक संख्याओं के क्रमपरिवर्तन की पूरी दुनिया है। हम मूल ( पी , क्यू ) = ( 3 , 2 ) के साथ चिपके रहेंगे$(p, q)=(3, 2)$, और इन पैरामीटर्स के लिए, अनुक्रम कोA050000 केरूप में पाया जा सकता है।OEIS में। इसके पहले 20 तत्व हैं:

1, 3, 9, 4, 2, 6, 18, 54, 27, 13, 39, 19, 57, 28, 14, 7, 21, 10, 5, 15

चूंकि यह एक "शुद्ध अनुक्रम" चुनौती है, कार्य उत्पादन के लिए है $a(n)$ के लिए एक दिया $n$ इनपुट, के रूप में जहां $a(n)$ है A050000 ।

कार्य

एक पूर्णांक इनपुट को देखते हुए $n$ , उत्पादन $a(n)$ पूर्णांक प्रारूप, जहां में:

$\begin{cases} a(1) = 1\\ a(n) = \lfloor \frac{a(n-1)}{2} \rfloor\text{ if }\lfloor \frac{a(n-1)}{2} \rfloor \notin \{0, a_1, ... , a(n-1)\}\\ a(n) = 3 a(n-1)\text{ otherwise} \end{cases}$

नोट: 1-आधारित अनुक्रमण यहाँ मान लिया गया है; आप 0-आधारित अनुक्रमण का उपयोग कर सकते हैं, इसलिए $a(0) = 1; a(1) = 3$ , आदि कृपया अपने उत्तर में इसका उल्लेख करें यदि आप इसका उपयोग करना चाहते हैं।

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

Input | Output
---------------
1     |  1
5     |  2
20    |  15
50    |  165
78    |  207
123   |  94
1234  |  3537
3000  |  2245
9999  |  4065
29890 |  149853

नियम

• इनपुट और आउटपुट पूर्णांक हैं (आपके प्रोग्राम को कम से कम इनपुट और आउटपुट का समर्थन करना चाहिए 1 से 32767 तक की सीमा में)
• अमान्य इनपुट (0, फ़्लोट्स, स्ट्रिंग्स, नकारात्मक मान आदि) अप्रमाणित आउटपुट, त्रुटियों या (बिना परिभाषित) व्यवहार को जन्म दे सकते हैं।
• डिफ़ॉल्ट I / O नियम लागू होते हैं।
• डिफ़ॉल्ट कमियां निषिद्ध हैं।
• यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम उत्तर जीतता है

Comments

मैं TI-BASIC का उपयोग करके इसका उत्तर दूंगा, लेकिन इनपुट तक सीमित होगा क्योंकि सूचियां 999 तत्वों तक सीमित हैं। फिर भी बड़ी चुनौती! $0<N<1000$

— ताउ

@ ताऊ: हालांकि आउट-ऑफ-स्पेक (और यह गैर-प्रतिस्पर्धात्मक), मुझे आपके समाधान में दिलचस्पी होगी। क्या आपके पास एक है जिसे आप पोस्ट कर सकते हैं?

— अग्ली

मैंने कार्यक्रम को हटा दिया, लेकिन मुझे इसे फिर से बनाने में सक्षम होना चाहिए। मैं इसे दोबारा प्राप्त करने के बाद इसे गैर-प्रतिस्पर्धात्मक के रूप में पोस्ट करूंगा ।

— ताउ

@ कोई भी, "गैर-प्रतिस्पर्धात्मक" अमान्य समाधान को कवर नहीं करता है; यह उन भाषाओं या भाषा सुविधाओं का उपयोग करने के लिए था जो एक चुनौती पोस्ट किए जाने के बाद बनाई गई थीं।

— झबरा

पीपी और सीजी मेटा वास्तव में इस पर बहुत स्पष्ट है। मैं "गैर-प्रतिस्पर्धा" की इतनी सख्त व्याख्या का पुरस्कार नहीं था ... @ ताऊ: ऐसा लगता है कि आप इन नियमों के तहत अपने TI-BASIC समाधान को पोस्ट नहीं कर सकते। माफ़ करना।

— agtoever

Answer 1

जाप , 15 14 बाइट्स

1 अनुक्रमित।

@[X*3Xz]kZ Ì}g

कोशिश करो

@[X*3Xz]kZ Ì}g     :Implicit input of integer U
             g     :Starting with the array [0,1] do the following U times, pushing the result to the array each time
@                  :  Pass the last element X in the array Z through the following function
 [                 :    Build an array containing
  X*3              :      X multiplied by 3
     Xz            :      X floor divided by 2
       ]           :    Close array
        kZ         :    Remove all elements contained in Z
           Ì       :    Get the last element
            }      :  End function
                   :Implicit output of the last element in the array

Answer 2

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

@ बंब के लिए 1 बाइट धन्यवाद @EmbodimentofIgnorance
सहेजा गया

n=>eval("for(o=[p=2];n--;)o[p=o[q=p>>1]?3*p:q]=p")

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

Comments

55 बाइट्स

— अज्ञानता

@EododimentofIgnorance मैं आमतौर पर उस चाल से बचता हूं, क्योंकि eval'ed कोड बहुत धीमा है। लेकिन अंतर उस एक के लिए मुश्किल से ध्यान देने योग्य है, इसलिए मुझे लगता है कि यह ठीक है।

— अरनुलद

लेकिन यह कोड-गोल्फ है, हम गति के बारे में परवाह नहीं करते हैं, जब तक कि यह काम पूरा नहीं हो जाता है

— अज्ञानता का अवतार

n=>eval("for(o=[p=2];n--;)o[p=o[q=p>>1]?3*p:q]=p")

— टीएस

Answer 3

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

µ×3żHḞḢḟȯ1Ṫ;µ¡Ḣ

पूर्णांक को स्वीकार करने वाला एक पूर्ण कार्यक्रम, n(1-आधारित), STDIN से जो परिणाम प्रिंट करता है।

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

कैसे?

µ×3żHḞḢḟȯ1Ṫ;µ¡Ḣ - Main Link: no arguments (implicit left argument = 0)
µ           µ¡  - repeat this monadic chain STDIN times (starting with x=0)
                -                   e.g. x = ...  0      [1,0]            [9,3,1,0]
 ×3             -   multiply by 3                 0      [3,0]            [27,9,3,0]
    H           -   halve                         0      [1.5,0]          [4.5,1.5,0.5,0]
   ż            -   zip together                  [0,0]  [[3,1.5],[0,0]]  [[27,4.5],[9,1.5],[3,0.5],[0,0]]
     Ḟ          -   floor                         [0,0]  [[3,1],[0,0]]    [[27,4],[9,1],[3,0],[0,0]]
      Ḣ         -   head                          0      [3,1]            [27,4]
       ḟ        -   filter discard if in x        []     [3]              [27,4]
        ȯ1      -   logical OR with 1             1      [3]              [27,4]
          Ṫ     -   tail                          1      3                4
           ;    -   concatenate with x            [1,0]  [3,1,0]          [4,9,3,1,0]
              Ḣ - head                            1      3                4
                - implicit print

Answer 4

05AB1E , 16 15 बाइट्स

केविन क्रूज़सेन को 1 बाइट धन्यवाद दिया ।
0 अनुक्रमित।

¾ˆ$FDˆx3*‚;ï¯Kн

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

व्याख्या

n=1उदाहरण के रूप में उपयोग करना

¾ˆ                 # initialize global array as [0]
  $                # initialize stack with 1, input
   F               # input times do:
    Dˆ             # duplicate current item (initially 1) and add one copy to global array
                   # STACK: 1, GLOBAL_ARRAY: [0, 1]
      x            # push Top_of_stack*2
                   # STACK: 1, 2, GLOBAL_ARRAY: [0, 1]
       3*          # multiply by 3
                   # STACK: 1, 6, GLOBAL_ARRAY: [0, 1]
         ‚;ï       # pair and integer divide both by 2
                   # STACK: [0, 3], GLOBAL_ARRAY: [0, 1]
            ¯K     # remove any numbers already in the global array
                   # STACK: [3], GLOBAL_ARRAY: [0, 1]
              н    # and take the head
                   # STACK: 3

Comments

15 बाइट्स

— केविन क्रूज़सेन

@ केविनक्रूजसेन: धन्यवाद! मैंने वैश्विक सरणी का उपयोग करने के बारे में सोचा, लेकिन यह मान लिया कि यह स्टैक पर एक सूची के समान लंबाई होगी और कभी भी इसकी कोशिश नहीं की: /

— एमिग्ना

Answer 5

पर्ल 6 , 49 बाइट्स

-2 बाइट्स nwellnof के लिए धन्यवाद

{(1,3,{(3*@_[*-1]Xdiv 6,1).max(*∉@_)}...*)[$_]}

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

अनुक्रम में 0-अनुक्रमित तत्व देता है। 0,1इसके बदले प्रारंभिक तत्वों को बदलकर आप इसे 1-अनुक्रमित कर सकते हैं1,3

स्पष्टीकरण:

{                                             }  # Anonymous code block
 (                                   ...*)[$_]   # Index into the infinite sequence
  1,3                                            # That starts with 1,3
     ,{                             }            # And each element is
       (                 ).max(    )             # The first of
          @_[*-1]X                               # The previous element
        3*        div 6                          # Halved and floored
        3*        div  ,1                        # Or tripled
                               *∉@_             # That hasn't appeared in the sequence yet

Answer 6

जे , 47 40 बाइट्स

[:{:0 1(],<.@-:@{:@](e.{[,3*{:@])])^:[~]

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

ungolfed

[: {: 0 1 (] , <.@-:@{:@] (e. { [ , 3 * {:@]) ])^:[~ ]

जे। में परिभाषा का सीधा अनुवाद यह ^:आवश्यक मूल्य की प्रारंभिक संख्या से पुनरावृति का उपयोग करके नीचे बनाता है ।

Answer 7

जावा 10, 120 99 बाइट्स

n->{var L=" 1 0 ";int r=1,t;for(;n-->0;L+=r+" ")if(L.contains(" "+(r=(t=r)/2)+" "))r=t*3;return r;}

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

स्पष्टीकरण:

n->{                              // Method with integer as both parameter and return-type
  var L=" 1 0 ";                  //  Create a String that acts as 'List', starting at [1,0]
  int r=1,                        //  Result-integer, starting at 1
      t;                          //  Temp-integer, uninitialized
  for(;n-->0;                     //  Loop the input amount of times:
      L+=r+" "))                  //    After every iteration: add the result to the 'List'
                          t=r     //   Create a copy of the result in `t`
                       r=(...)/2  //   Then integer-divide the result by 2
    if(L.contains(" "+(...)+" ")) //   If the 'List' contains this result//2:
      r=t*3;                      //    Set the result to `t` multiplied by 3 instead
  return r;}                      //  Return the result

Answer 8

हास्केल , 67 65 बाइट्स

(h[1,0]!!)
h l@(a:o)|elem(div a 2)o=a:h(3*a:l)|1>0=a:h(div a 2:l)

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

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

EDIT: शर्तों को बदलने और स्विच elemकरने के बजाय 2 बाइट्स सहेजे गएnotElem

Answer 9

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

Ø.;0ị×3$:2$:2eɗ?Ɗ$⁸¡Ṫ

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

एक मौद्रिक लिंक जो शून्य-अनुक्रमित होता है $n$ तर्क और वापसी के रूप में $a(n)$।

Answer 10

रूबी , 54 52 48 बाइट्स

->n{*s=0;j=2;n.times{s<<j=s==s-[j/2]?j/2:j*3};j}

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

Answer 11

C ++ (gcc) , 189 180 बाइट्स

-9 बाइट्स से लेकर छोटे गोल्फ तक

#import<vector>
#import<algorithm>
int a(int n){std::vector<int>s={1};for(int i=0;i<n;++i)s.push_back(i&&std::find(s.begin(),s.end(),s[i]/2)==s.end()?s[i]/2:3*s[i]);return s[n-1];}

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

अनुक्रम की गणना करता है n, फिर वांछित तत्व देता है। बड़े सूचकांकों के लिए धीमी गति से।

Comments

@ceilingcat दुर्भाग्य से जो ऑपरेटर की पूर्वता को प्रभावित करता है और फ़ंक्शन के आउटपुट को बदलता है।

— नील ए

Answer 12

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

l=lambda n,p=1,s=[0]:p*(n<len(s))or l(n,3*p*(p/2in s)or p/2,[p]+s)

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

शून्य-आधारित अनुक्रमण का उपयोग करता है। लंबोदर पुनरावृत्ति क्रम से थोड़ा अधिक करता है और आवश्यक सूचकांक तक पहुंचते ही वापस लौट जाता है।

Answer 13

स्टैक्स , 14 बाइट्स

üÑα↕○Ü1∟¡f↑ô┬♥

इसे चलाएं और डीबग करें

शून्य अनुक्रमित।

Answer 14

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 63 बाइट्स

(L=Last)@Nest[{##,If[FreeQ[#,x=⌊L@#/2⌋],x,3L@#]}&,{0,1},#]&

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

यह 0-अनुक्रमित है
(TIO में मैंने प्रत्येक परीक्षण मामले में -1 जोड़ा)

Answer 15

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

a=lambda n:n<1or a(n-1)*6**(a(n-1)//2in[0]+map(a,range(n)))//2

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

के लिए लौटता Trueहै a(0)। 0 अनुक्रमित।

Answer 16

पायथन 3 , 105 103 100 95 83 बाइट्स

-2 बाइट्स धन्यवाद
-12 बाइट्स ArBo करने के लिए धन्यवाद

def f(n):
 s=0,1
 while len(s)<=n:t=s[-1]//2;s+=(t in s)*3*s[-1]or t,
 return s[-1]

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

Comments

आप लूप while len(s)<=nको आई के साथ बदल सकते हैं और आई के साथ बदल सकते हैं -1। यह दो पात्रों में से एक को शेव करना चाहिए।

— Agtoever

@ हालांकि यह बहुत चालाक है - धन्यवाद! :)

— नूडल

83 बाइट्स एक सूची के बजाय एक टपल के साथ काम करके, और लूप ifसे हटाने के लिए उस whileलूप को एक-लाइनिंग की अनुमति देता है

— ArBo

@ArBo वाह! बिल्कुल शानदार - धन्यवाद :)

— नूडल

Answer 17

गैया , 22 20 बाइट्स

2…@⟨:):3פḥ⌋,;D)+⟩ₓ)

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

0-आधारित सूचकांक।

दृष्टिकोण के लिए झबरा का श्रेय

2…			| push [0 1]
  @⟨		 ⟩ₓ	| do the following n times:
    :):			| dup the list L, take the last element e, and dup that
       3פḥ⌋,		| push [3*e floor(e/2)]
	     ;D		| take the asymmetric set difference [3*e floor(e/2)] - L
	       )+	| take the last element of the difference and add it to the end of L (end of loop)
		   )	| finally, take the last element and output it

;D

Answer 18

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

(1%[0]!!)
a%o|b<-div a 2=a:last(b:[3*a|elem b o])%(a:o)

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

गोल्फ user1472751 के चालाक सूची पीढ़ी विधि ।

एक ही लंबाई:

(1%[0]!!)
a%o=a:[x|x<-[div a 2,a*3],all(/=x)o]!!0%(a:o)

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

Answer 19

लूआ , 78 बाइट्स

x,y=1,3 u={}for _=2,...do
u[x]=0
x,y=y,y//2
if u[y]then y=3*x end
end
print(x)

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

Comments

कुछ व्हाट्सएप को हटाने के माध्यम से 68 बाइट्स , zवेरिएबल को हटाकर और अगर स्टेटमेंट को टर्नेरी में बदल दिया जाए

— जो किंग