Les deux premiers nombres MU sont 2 et 3. Chaque autre nombre MU est le plus petit nombre non encore apparu qui peut être exprimé comme le produit de deux nombres MU distincts antérieurs d'une seule manière.

Voici les 10 premiers

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

Tâche

Étant donné un calculate nombre positif et la sortie du n ième numéro MU.

Il s'agit d'une compétition de code-golf , vous devez donc viser à rendre votre code source aussi petit que possible.

OEIS A007335

Pyth, 22 21 octets

@u+Gfq2l@GcLTGheGQhB2

Essayez-le en ligne. Suite de tests.

0 indexé.

Explication

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

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

Essayez-le en ligne!

Comment ça fonctionne

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              

Gelée , 22 octets

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

Un lien monadique, indexé 1.

Essayez-le en ligne!

Comment?

Œ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 octets

8 octets grâce à 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]

Essayez-le en ligne!

CJam (32 octets)

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

Démo en ligne avec indexation 0.

Je ne suis pas sûr qu'il y ait beaucoup à faire au-delà d'une traduction triviale de la spécification à une exception près: en commençant par une liste de [0 1 2 3](au lieu de [2, 3]) j'enregistre un octet immédiatement à l'initialisation et deux autres en étant capable de le faire 0=|(en ajoutant juste le nouvel élément car sa fréquence est 1et est déjà dans la liste), mais n'introduisez pas de faux éléments car pour chacun xdans la liste 0*xet 1*xsont déjà dans la liste.

Python 2 , 127 118 octets

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]

Essayez-le en ligne!

Mathematica, 154 octets

simple modification du code trouvé sur le lien 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 octets

0 indexé

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];

Essayez-le en ligne!

Étendu

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 octets

0 indexé

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];

Essayez-le en ligne!

PHP , 161 octets

0 indexé

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];

Essayez-le en ligne!

Mathematica, 140 octets

(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 octets

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

Essayez-le en ligne!

Explication

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 octets

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

Essayez-le en ligne!

• 2, 3, { ... } ... *est une séquence infinie où chaque élément commençant par le troisième est calculé par le bloc de code délimité par des accolades. Puisque le bloc de code prend ses arguments via le @_tableau slurpy , il reçoit la séquence actuelle entière dans ce tableau.
• @_.combinations(2)est une séquence de toutes les combinaisons de 2 éléments de @_.
• .classify({ [*] $_ }) classe chaque 2-tuple par son produit, produisant un hachage où les produits sont les clés et les valeurs sont la liste des 2-tuples qui ont ce produit.
• .grep(*.value == 1) sélectionne ces paires clé-valeur à partir du hachage où la valeur (c'est-à-dire la liste des paires ayant cette clé comme produit) a une taille de 1.
• ».keysélectionne uniquement les clés de chaque paire. Il s'agit de la liste des produits issus d'une seule combinaison de facteurs de la séquence actuelle.
• .sort trie les produits numériquement.
• first * ∉ @_, ... trouve le premier de ces produits qui n'est pas déjà apparu dans la séquence.

JavaScript (ES6), 119 118 117 octets

Une fonction récursive qui prend un index basé sur 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)

Comment?

À chaque itération de f () , nous utilisons le dernier terme m de la séquence et un tableau b initialement vide pour identifier le terme suivant. Pour chaque produit d> m de deux nombres MU distincts antérieurs, nous faisons:

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

puis conservez la valeur minimale de b .

L'expression ci-dessus est évaluée comme suit:

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

Cela garantit que les produits qui peuvent être exprimés de plusieurs manières ne seront jamais sélectionnés.

Formaté et commenté

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

Démo

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 octets

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

Essayez-le en ligne!

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

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]

Essayez-le en ligne!

Merci à @ Mr.Xcoder et @LeakyNun pour les améliorations!