Hai số MU đầu tiên là 2 và 3. Mọi số MU khác là số nhỏ nhất chưa xuất hiện có thể được biểu thị là tích của hai số MU khác nhau trước đó theo đúng một cách.

Dưới đây là 10 đầu tiên

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

Bài tập

Cho một số dương tính toán và đầu ra n MU thứ .

Đây là một cuộc thi golf-code, vì vậy bạn nên đặt mục tiêu làm cho mã nguồn của mình càng nhỏ càng tốt.

OEIS A007335

Pyth, 22 21 byte

@u+Gfq2l@GcLTGheGQhB2

Hãy thử trực tuyến. Bộ thử nghiệm.

Chỉ số 0.

Giải trình

@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.

Haskell, 80 77 byte

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..])!!)

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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              

Thạch , 22 byte

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

Một liên kết đơn âm, 1 chỉ mục.

Hãy thử trực tuyến!

Làm sao?

Œ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

R , 127 118 111 108 105 100 98 90 byte

8 byte nhờ 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]

Hãy thử trực tuyến!

CJam (32 byte)

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

Bản demo trực tuyến với chỉ mục 0.

Tôi không chắc có nhiều việc phải làm ngoài một bản dịch tầm thường của thông số kỹ thuật với một ngoại lệ: bằng cách bắt đầu với một danh sách [0 1 2 3](thay vì [2, 3]) Tôi lưu một byte ngay lập tức khi khởi tạo và hai byte khác bằng cách có thể làm được 0=|(chỉ thêm phần tử mới vì tần số của nó đã 1và đã có trong danh sách), nhưng không giới thiệu bất kỳ phần tử sai nào vì cho mọi phần xtrong danh sách 0*xvà 1*xđã có trong danh sách.

Python 2 , 127 118 byte

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]

Hãy thử trực tuyến!

Toán học, 154 byte

sửa đổi đơn giản của mã được tìm thấy tại liên kết oeis

(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[[#]])&

PHP , 130 byte

Chỉ số 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];

Hãy thử trực tuyến!

Mở rộng

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 byte

Chỉ số 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];

Hãy thử trực tuyến!

PHP , 161 byte

Chỉ số 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];

Hãy thử trực tuyến!

Toán học, 140 byte

(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[[#]])&

MATL , 25 byte

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

Hãy thử trực tuyến!

Giải trình

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

Perl 6 , 96 byte

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

Hãy thử trực tuyến!

• 2, 3, { ... } ... *là một chuỗi vô hạn trong đó mỗi phần tử bắt đầu bằng phần ba được tính bằng khối mã được phân tách bằng dấu ngoặc. Vì khối mã lấy các đối số của nó thông qua slurpy@_ mảng , nó nhận được toàn bộ chuỗi hiện tại trong mảng đó.
• @_.combinations(2) là một chuỗi gồm tất cả các kết hợp 2 yếu tố của @_ .
• .classify({ [*] $_ }) phân loại mỗi 2 tuple theo sản phẩm của nó, tạo ra một hàm băm trong đó các sản phẩm là khóa và các giá trị là danh sách 2 tuple có sản phẩm đó.
• .grep(*.value == 1) chọn các cặp khóa-giá trị đó từ hàm băm trong đó giá trị (nghĩa là danh sách các cặp có khóa đó là sản phẩm) có kích thước là 1.
• ».keychỉ chọn các phím của mỗi cặp. Đây là danh sách các sản phẩm phát sinh từ chỉ một sự kết hợp của các yếu tố của trình tự hiện tại.
• .sort sắp xếp các sản phẩm bằng số.
• first * ∉ @_, ... tìm thấy sản phẩm đầu tiên chưa xuất hiện trong chuỗi.

JavaScript (ES6), 119 118 117 byte

Hàm đệ quy lấy chỉ số dựa trên 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)

Làm sao?

Ở mỗi lần lặp của f () , chúng tôi sử dụng thuật ngữ m cuối cùng của chuỗi và một mảng b ban đầu để xác định thuật ngữ tiếp theo. Đối với mỗi sản phẩm d> m của hai số MU khác nhau trước đó, chúng tôi thực hiện:

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

và sau đó giữ giá trị tối thiểu của b .

Biểu thức trên được đánh giá như sau:

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

Điều này đảm bảo rằng các sản phẩm có thể được thể hiện theo nhiều cách sẽ không bao giờ được chọn.

Định dạng và nhận xét

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

Bản giới thiệu

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));
}

Haskell , 117 115 113 byte

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

Hãy thử trực tuyến!

Python 3 2 , 167 139 136 133 123 121 120 118 byte

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]

Hãy thử trực tuyến!

Cảm ơn @ Mr.Xcoder và @LeakyNun vì những cải tiến!