पहले दो एमयू-नंबर 2 हैं और 3. हर दूसरे एमयू-नंबर सबसे छोटी संख्या है जो अभी तक प्रकट नहीं हुई है जिसे दो पूर्ववर्ती एमयू-संख्याओं के उत्पाद के रूप में व्यक्त किया जा सकता है।

यहाँ पहले 10 हैं

2, 3, 6, 12, 18, 24, 48, 54, 96, 162

कार्य

एक सकारात्मक संख्या की गणना और n वें MU- संख्या का उत्पादन ।

यह एक कोड-गोल्फ प्रतियोगिता है, इसलिए आपको अपने स्रोत कोड को यथासंभव छोटा बनाना चाहिए।

OEIS A007335

code-golf sequence

— गेहूं का जादूगर
स्रोत

1

0-इंडेक्सिंग या 1-इंडेक्सिंग?

— हाइपरनेत्रिनो

1

@ हाइपर न्यूट्रिनो या तो ठीक है।

— गेहूं जादूगर

2

कोई भी विचार क्यों इन्हें एमयू-संख्या कहा जाता है? (जंगली अनुमान: गुणन अनोखा?)

5

पायथ, 22 21 बाइट्स

@u+Gfq2l@GcLTGheGQhB2

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

0 अनुक्रमित।

व्याख्या

@u+Gfq2l@GcLTGheGQhB2Q    Implicitly append Q and read+eval input to it.
                  hB2     Take the list [2, 2 + 1].
 u               Q        Put the list in G and apply this Q times:
               eG           Get last number in G.
              h             Add one.
    f                       Starting from that, find the first T such that:
          cLTG                Divide T by each of the numbers in G.
        @G                    Find the quotients that are also in G.
       l                      Get the number of such quotients.
     q2                       Check that it equals 2.
  +G                        Append that T to G.
@                    Q    Get the Q'th number in G.

— PurkkaKoodari
स्रोत

@अंतिम पंक्ति पर हस्ताक्षर गलत संरेखित है। मैं सुझाया हुआ संपादन नहीं कर सकता, क्योंकि यह 2-वर्ण परिवर्तन है।

— user2357112

@ user2357112 फिक्स्ड।

— पुरकाकूदरी

4

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

l#(a:b)|[x]<-[a|i<-l,j<-l,i<j,i*j==a]=a:(a:l)#b|1<2=l#b
((2:3:[2,3]#[4..])!!)

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

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

2:3:             -- start the list with 2 and 3 and append a call to # with
    [2,3]        -- the list so far and
         #[4..]  -- list of candidate elements

l # (a:b)        -- l -> list so far, a -> next candidate element, b -> rest c.el.
  | [x]<-[...]   -- if the list [...] is a singleton list
    =a:(a:l#b) -- the result is a followed by a recursive call with l extended
                    by a and b
  | 1<2=l#b      -- if it's not a singleton list, drop a and retry with b

                 -- the [...] list is
 [ i<-l,j<-l,    -- loop i through l and j through l and whenever   
       i<j,      -- i<j and
       i*j==a]   -- i*j==a
  a|             -- add a to the list

— nimi
स्रोत

3

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

ŒcP€ḟ⁸ṢŒgLÞḢḢṭ
2,3Ç¡ị@

एक एकादश लिंक, 1-अनुक्रमित।

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

कैसे?

ŒcP€ḟ⁸ṢŒgLÞḢḢṭ - Link 1, add the next number: list, a  e.g. [2,3,6,12,18,24]
Œc             - unordered pairs                            [[2,3],[2,6],[2,12],[2,18],[2,24],[3,6],[3,12],[3,18],[3,24],[6,12],[6,18],[6,24],[12,18],[12,24],[18,24]]
  P€           - product of €ach                            [6,12,24,36,48,18,36,54,72,72,108,144,216,288,432]
     ⁸         - chain's left argument, a                   [2,3,6,12,18,24]
    ḟ          - filter discard                             [36,48,36,54,72,72,108,144,216,288,432]
      Ṣ        - sort                                       [36,36,48,54,72,72,108,144,216,288,432]
       Œg      - group runs of equal elements               [[36,36],[48],[54],[72,72],[108],[144],[216],[288],[432]]
          Þ    - sort by:
         L     -   length                                   [[48],[54],[108],[144],[216],[288],[432],[36,36],[72,72]]
           Ḣ   - head                                       [48]
            Ḣ  - head                                       48
             ṭ - tack to a                                  [2,3,6,12,18,24,48]

2,3Ç¡ị@ - Link: number, i                              e.g. 7
2,3     - literal [2,3]                                     [2,3]
    ¡   - repeat i times:
   Ç    -   call last link (1) as a monad                   [2,3,6,12,18,24,48,54,96]
     ị@ - index into with swapped @rguments (with i)        48

— जोनाथन एलन
स्रोत

3

आर , 127 118 111 108 105 100 98 90 बाइट्स

8 बाइट्स Giuseppe के लिए धन्यवाद।

r=3:2;for(i in 1:scan())r=c(min((g=(r%o%r)[i:-1<i])[colSums(g%o%g==g*g)+g%in%r<3]),r);r[3]

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

— लीक नन
स्रोत

यह मुझे हमेशा के लिए महसूस हुआ कि <इसकी पूर्ववर्ती स्थिति कम है, +इसलिए मैं यह पता नहीं लगा सका कि हेक क्या +g%in%r<3कर रहा था, और जब मैं ऐसा कर रहा था, तो आपने मुझे सुझाए गए दो हिस्सों को नीचे गिरा दिया ... +1

— Giuseppe

@Giuseppe मैंने अभी आर सीखना शुरू किया ... एक सभ्य आर गोल्फर से मिलकर अच्छा लगा।

— लीक नून

मैं आपसे यही कहने जा रहा था .............

— Giuseppe

आह, एक और बात, आप n=scan()स्टड से पढ़ने के लिए एक फ़ंक्शन परिभाषा के बजाय उपयोग कर सकते हैं ; वह आपको 100

— Giuseppe

इनपुट के लिए 0

— Rift

2

CJam (32 बाइट्स)

4,{_2m*{~>},::*1$-$e`$0=|}qi*-2=

0-अनुक्रमण के साथ ऑनलाइन डेमो ।

मुझे यकीन नहीं है कि एक अपवाद के साथ कल्पना के एक तुच्छ अनुवाद से परे बहुत कुछ किया जाना है: की सूची के साथ शुरू करके [0 1 2 3](इसके बजाय [2, 3]) मैं एक बाइट को तुरंत आरंभीकरण पर और दूसरे दो को करने में सक्षम होने से बचा लेता हूं 0=|(केवल जोड़कर नया तत्व क्योंकि इसकी आवृत्ति है 1और पहले से ही सूची में है), लेकिन किसी भी गलत तत्व को प्रस्तुत नहीं करते हैं क्योंकि xसूची में प्रत्येक के लिए 0*xऔर 1*xपहले से ही सूची में हैं।

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

2

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

n=input()
l=[2,3]
exec't=sorted(x*y for i,x in enumerate(l)for y in l[i+1:]);l+=min(t,key=(l+t).count),;'*n
print l[n]

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

— छड़ी
स्रोत

1

मैथेमेटिका, 154 बाइट्स

ois लिंक पर पाए गए कोड का सरल संशोधन

(s={2,3};Do[n=Select[Split@Sort@Flatten@Table[s[[j]]s[[k]],{j,Length@s},{k,j+1,Length@s}],#[[1]]>s[[-1]]&&Length@#==1&][[1,1]];AppendTo[s,n],{#}];s[[#]])&

— J42161217
स्रोत

1

PHP , 130 बाइट्स

0 अनुक्रमित

for($r=[2,3];!$r[$argn];$r[]=$l=min($m)/2){$m=[];foreach($r as$x)foreach($r as$y)($p=$x*$y)<=$l|$y==$x?:$m[$p]+=$p;}echo$r[$argn];

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

विस्तारित

for($r=[2,3];!$r[$argn]; #set the first to items and loop till search item exists
$r[]=$l=min($m)/2){ # add the half of the minimum of found values to the result array
  $m=[]; # start with empty array
  foreach($r as$x) # loop through result array
    foreach($r as$y) # loop through result array
      ($p=$x*$y)<=$l|$y==$x? # if product is greater as last value and we do multiple two distinct values
        :$m[$p]+=$p; # add 2 times or more the product to array so we drop 36 cause it will be 144  
}
echo$r[$argn]; # Output

PHP , 159 बाइट्स

0 अनुक्रमित

for($r=[2,3];!$r[$argn];$r[]=$l=min(array_diff_key($m,$d))){$d=$m=[];foreach($r as$x)foreach($r as$y)$x<$y?${dm[$m[$p=$x*$y]<1&$p>$l]}[$p]=$p:0;}echo$r[$argn];

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

PHP , 161 बाइट्स

0 अनुक्रमित

for($r=[2,3];!$r[$argn];$r[]=$l=min(array_diff($m,$d))){$d=$m=[];foreach($r as$x)foreach($r as$y)$x<$y?${dm[!in_array($p=$x*$y,$m)&$p>$l]}[]=$p:0;}echo$r[$argn];

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

— जार्ग हुल्सरमैन
स्रोत

1

गणितज्ञ, 140 बाइट्स

(t=1;s={2,3};While[t<#,s=AppendTo[s,Sort[Select[First/@Select[Tally[Times@@@Permutations[s,{2}]],#[[2]]==2&],#>Last@s&]][[1]]];t++];s[[#]])&

— J42161217
स्रोत

1

MATL , 25 बाइट्स

3:i:"t&*9B#u2=)yX-X<h]2_)

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

व्याख्या

3:     % Push [1 2 3]. Initial array of MU numbers, to be extended with more numbers
i:     % Input n. Push [1 2 ... n]
"      % Do this n times
  t    %   Duplicate array of MU numbers so far
  &*   %   Matrix of pair-wise products
  9B   %   Push 9 in binary, that is, [1 0 0 1]
  #    %   Specify that next function will produce its first and fourth ouputs
  u    %   Unique: pushes unique entries (first output) and their counts (fourth)
  2=   %   True for counts that equal 2
  )    %   Keep only unique entries with count 2
  y    %   Duplicate (from below) array of MU numbers so far
  X-   %   Set difference
  X<   %   Minimum. This is the new MU number
  h    %   Concatenate vertically horizontally to extend the array
]      % End
2_     % Push 2 negated, that is, -2
)      % Get entry at position -2, that is, third-last. Implicitly display

— लुइस मेंडो
स्रोत

1

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

{(2,3,{first *∉@_,@_.combinations(2).classify({[*]
$_}).grep(*.value==1)».key.sort}...*)[$_]}

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

2, 3, { ... } ... *एक अनंत अनुक्रम है, जहां तीसरे के साथ शुरू होने वाले प्रत्येक तत्व को ब्रेस-सीमांकित कोड ब्लॉक द्वारा गणना की जाती है। चूंकि कोड ब्लॉक स्लरी के माध्यम से अपने तर्क देता है@_ एरे के , यह उस एरे में पूरे वर्तमान अनुक्रम को प्राप्त करता है।
@_.combinations(2) के सभी 2-तत्व संयोजन का एक क्रम है @_ ।
.classify({ [*] $_ }) प्रत्येक 2-ट्यूपल को उसके उत्पाद द्वारा वर्गीकृत करता है, एक हैश का निर्माण करता है जहां उत्पाद कुंजी हैं और मूल्य 2-ट्यूपल की सूची है जो कि उत्पाद है।
.grep(*.value == 1) हैश से उन की-वैल्यू पेयर को सिलेक्ट करते हैं जहाँ वैल्यू (यानी, प्रोडक्ट के तौर पर उस की की होने वाली जोड़ियों की लिस्ट) का साइज 1 है।
».keyप्रत्येक जोड़ी की कुंजी का चयन करता है। यह उन उत्पादों की सूची है जो वर्तमान अनुक्रम के कारकों के केवल एक संयोजन से उत्पन्न होते हैं।
.sort उत्पादों को संख्यात्मक रूप से क्रमबद्ध करें।
first * ∉ @_, ... उन उत्पादों को खोजता है जो पहले से ही अनुक्रम में दिखाई नहीं दिए हैं।

— शॉन
स्रोत

1

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

एक पुनरावर्ती फ़ंक्शन जो 0-आधारित इंडेक्स लेता है।

f=(n,a=[2,m=3])=>a[n]||a.map(c=>a.map(d=>c<d&(d*=c)>m?b[d]=b[d]/0||d:0),b=[])|f(n,a.push(m=b.sort((a,b)=>a-b)[0])&&a)

कैसे?

F () के प्रत्येक पुनरावृत्ति पर , हम अगले पद की पहचान करने के लिए अनुक्रम और अंतिम रूप से खाली सरणी b के अंतिम पद m का उपयोग करते हैं । प्रत्येक उत्पाद के लिए d> m पहले दो अलग-अलग MU-नंबर, हम करते हैं:

b[d] = b[d] / 0 || d

और फिर बी का न्यूनतम मूल्य रखें ।

उपरोक्त अभिव्यक्ति का मूल्यांकन इस प्रकार है:

b[d]               | b[d] / 0  | b[d] / 0 || d
-------------------+-----------+--------------
undefined          | NaN       | d
already equal to d | +Infinity | +Infinity
+Infinity          | +Infinity | +Infinity

यह गारंटी देता है कि जिन उत्पादों को एक से अधिक तरीकों से व्यक्त किया जा सकता है उन्हें कभी चुना नहीं जाएगा।

प्रारूपित और टिप्पणी की गई

f = (n, a = [2, m = 3]) =>           // given: n = input, a[] = MU array, m = last term
  a[n] ||                            // if a[n] is defined, return it
  a.map(c =>                         // else for each value c in a[]:
    a.map(d =>                       //   and for each value d in a[]:
      c < d &                        //     if c is less than d and
      (d *= c) > m ?                 //     d = d * c is greater than m:
        b[d] = b[d] / 0 || d         //       b[d] = either d or +Infinity (see 'How?')
      :                              //     else:
        0                            //       do nothing
    ),                               //   end of inner map()
    b = []                           //   initialization of b[]
  ) |                                // end of outer map()
  f(                                 // do a recursive call:
    n,                               //   - with n
    a.push(                          //   - push in a[]:
      m = b.sort((a, b) => a - b)[0] //     m = minimum value of b[]
    ) && a                           //     and use a[] as the 2nd parameter
  )                                  // end of recursive call

डेमो

कोड स्निपेट दिखाएं

f=(n,a=[2,m=3])=>a[n]||a.map(c=>a.map(d=>c<d&(d*=c)>m?b[d]=b[d]/0||d:0),b=[])|f(n,a.push(m=b.sort((a,b)=>a-b)[0])&&a)

for(var n = 0; n < 10; n++) {
  console.log('MU[' + n + '] = ' + f(n));
}

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

— Arnauld
स्रोत

0

हास्केल , 117 115 113 बाइट्स

n x=[a*b|[a,b]<-mapM id[1:x,x]]
d x=minimum[a|a<-n x,2==sum[1|b<-n x,b==a]]:x
l x|x<3=x+1:[2]|1>0=d$l$x-1
(!!0).l

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

— गेहूं का जादूगर
स्रोत

पहली पंक्ति को ऑपरेटर कार्टेशियन उत्पाद के लिए एक उपयोगी मुहावरे के रूप में लिखा जा सकता है:n x=(*)<$>x<*>1:x

— xnor

0

अजगर 3 2 , 167 139 136 133 123 121 120 118 बाइट्स

a=[2,3];exec'p=[x*y for x in a for y in a if x-y];a+=min(q for q in p if p.count(q)+(q in a)<3),;'*input();print a[-2]

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

सुधार के लिए @ Mr.Xcoder और @LeakyNun को धन्यवाद!

— चेस वोगेली
स्रोत

159 बाइट्स , केवल अनावश्यक रिक्त स्थान और ब्रैकेट को हटाकर।

— श्री एक्सकोडर

@ Mr.Xcoder सुधार के लिए धन्यवाद। मुझे यकीन है कि नहीं बदल रहा हूँ p.count(q)==1करने के लिए p.count(q)>0, मान्य है, क्योंकि वह कोड है कि चुनौती के "वास्तव में एक तरह से" हालत सुनिश्चित करता है।

— चोगे जोगी

p.count(q)-~(q in a)<=3के बराबर हैp.count(q)+(q in a)<3

— लीकी नून

@LeakyNun धन्यवाद!

— चोगे वोगेली

एमयू-संख्या की गणना करें

कार्य

पायथ, 22 21 बाइट्स

व्याख्या

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

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

कैसे?

आर , 127 118 111 108 105 100 98 90 बाइट्स

CJam (32 बाइट्स)

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

मैथेमेटिका, 154 बाइट्स

PHP , 130 बाइट्स

PHP , 159 बाइट्स

PHP , 161 बाइट्स

गणितज्ञ, 140 बाइट्स

MATL , 25 बाइट्स

व्याख्या

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

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

कैसे?

प्रारूपित और टिप्पणी की गई

डेमो

हास्केल , 117 115 113 बाइट्स

अजगर 3 2 , 167 139 136 133 123 121 120 118 बाइट्स