À ne pas confondre avec le plus petit multiple commun .

Étant donné une liste d'entiers positifs avec plus d'un élément, renvoyez le produit le plus courant de deux éléments du tableau.

Par exemple, le MCM de la liste [2,3,4,5,6]est 12, comme une table de produits est:

    2  3  4  5  6
  ---------------
2 | #  6  8  10 12
3 | #  #  12 15 18
4 | #  #  #  20 24
5 | #  #  #  #  30
6 | #  #  #  #  #

Merci DJMcMayhem pour la table

Comme cela 12apparaît le plus souvent (deux fois comme 2*6et 3*4). Notez que nous n'incluons pas le produit d'un élément et lui-même, donc 2*2ou 4*4n'apparaissons pas dans cette liste. Cependant, les éléments identiques seront toujours multipliés, donc le tableau pour [2,3,3]ressemble à:

    2  3  3
  ----------
2 | #  6  6 
3 | #  #  9
3 | #  #  #

Avec le MCM 6.

En cas d'égalité, vous pouvez retourner n'importe lequel des éléments liés ou une liste de tous.

• Il s'agit de code-golf , donc le nombre d'octets le plus court pour chaque langue gagne!

Cas de test:

[2,3,4,5,6] -> 12
[7,2] -> 14
[2,3,3] -> 6
[3,3,3] -> 9
[1,1,1,1,2,2] -> 2
[6,200,10,120] -> 1200
[2,3,4,5,6,7,8,8] -> 24
[5,2,9,10,3,4,4,4,7] -> 20
[9,7,10,9,7,8,5,10,1] -> 63, 70, 90 or [63,70,90]

Brachylog , 11 octets

{⊇Ċ×}ᶠọtᵒth

Essayez-le en ligne!

Explication

{   }ᶠ          Find all:
 ⊇Ċ×              Product of a subset of 2 elements
      ọtᵒ       Order by occurrences
         th     Take the last element and discard the number of occurrences

R , 54 50 41 octets

order(-tabulate(combn(scan(),2,prod)))[1]

Essayez-le en ligne!

Alternativement, pour 54 53 44 octets:

names(sort(-table(combn(scan(),2,prod))))[1]

Essayez-le en ligne!

En principe, cette dernière version produit le résultat pertinent même sans la namesfonction, mais suivie du nombre de produits les plus fréquents, ce qui n'est pas demandé ...

Merci à CriminallyVulgar pour -4 et -1, et Giuseppe pour -9 sur les deux.

Gelée , 6 octets

ŒcP€Æṃ

Essayez-le en ligne! ou Découvrez la suite de tests .

Comment ça marche

ŒcP € Æṃ - Programme complet / Lien monadique.
Œc - Paires non ordonnées sans remplacement.
  P € - Produit de chacun.
    Æṃ - Mode (élément le plus courant).

Alternative: ŒcZPÆṃ

Pyth, 12 octets

eo/QN=*M.cQ2

Suite de tests

Tout d'abord, nous prenons les 2 combinaisons d'éléments de l'entrée sans remplacement ( .cQ2). Ensuite, nous mappons chacune de ces paires à leur produit ( *M). Ensuite, nous remplaçons la variable d'entrée par la liste des produits ( =). Ensuite, nous trions la liste des produits par le nombre d'occurrences dans la liste des produits ( o/QN). Enfin, prenez l'élément final de la liste triée ( e).

MATL , 8 7 octets

2XN!pXM

Essayez-le en ligne!

(-1 octet en utilisant la méthode de la réponse @Mr. Xcoder Jelly .)

2XN     % nchoosek - get all combinations of 2 elements from input
!p      % get the product of each combination
XM      % 'mode': get the most common value from that

Ancienne réponse:

8 octets

&*XRXzXM

Essayez-le en ligne!

&*    % multiply input by its transpose,
      %  getting all elementwise products
XR    % take the upper-triangular portion of that,
      %  zeroing out repetitions and mainly self-multiplications
Xz    % remove the zeroed out parts
XM    % 'mode' calculation - get the most common value from that

05AB1E , 8 6 octets

æ2ùP.M

-2 octets grâce à @Kaldo .

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

æ         # Take the powerset of the input-list
          #  i.e. [2,3,3] → [[],[2],[3],[3],[2,3],[2,3],[3,3],[2,3,3]]
 2ù       # Leave only the inner lists of size 2:
          #  i.e. [[],[2],[3],[3],[2,3],[2,3],[3,3],[2,3,3]] → [[2,3],[2,3],[3,3]]
   P      # Take the product of each remaining pair
          #  i.e. [[2,3],[2,3],[3,3]] → [6,6,9]
    .M    # Only leave the most frequent value(s) in the list
          #  i.e. [6,6,9] → [6]

Mathematica, 32 octets

^{-17 octets (et un correctif) grâce à JungHwan Min .}

Commonest[1##&@@@#~Subsets~{2}]&

Fonction pure. Prend une liste de nombres en entrée et renvoie la liste des MCM en sortie.

MATLAB, 43 octets

I=input('');i=I'*I*1-eye(nnz(I));mode(i(:))

C'est aussi une sorte de virelangue!

Explication

I=input('');           % Takes an input like "[2,3,4,5,6]"
i=I'*I                 % Multiplies the input by its own transverse
      *1-eye(nnz(I));  % Multiplies by 1-identity matrix to remove diagonal
mode(i(:))             % Calculates most common value and prints it

Perl 6 , 41 38 octets

{key max bag(@_ X*@_)∖@_»²: *{*}:}

Essayez-le en ligne!

Stax , 12 10 octets

╢êv^⌐ö►♣Ä»

Exécuter et déboguer

Python 3 , 77 72 octets

f=lambda k,*l,m=[]:l and f(*l,m=m+[k*x for x in l])or max(m,key=m.count)

Essayez-le en ligne!

Attaché , 59 octets

Last##~SortBy#`&&:`~##{Flat[UpperTriangle&1!Table&_!`*]^^0}

Essayez-le en ligne!

Je travaille toujours un peu sur le golf, mais je pense que c'est presque optimal pour l'approche que j'ai choisie.

Explication

Il s'agit d'une composition de trois fonctions:

1. {Flat[UpperTriangle&1!Table&_!`*]^^0}
2. SortBy#`&&:`~
3. Last

La première fonction effectue l'essentiel du calcul:

{Flat[UpperTriangle&1!Table&_!`*]^^0}
{                                   }    anonymous lambda; input: _ (e.g.: [2,3,4,5,6])
                      Table&_!`*         shorthand for Table[`*, _]
                                         this creates a multiplication table using the input
                                         e.g.:
                                           4  6  8 10 12
                                           6  9 12 15 18
                                           8 12 16 20 24
                                          10 15 20 25 30
                                          12 18 24 30 36

      UpperTriangle&1!                   takes the strict upper triangle of this matrix
                                         e.g.:
                                          0 6  8 10 12
                                          0 0 12 15 18
                                          0 0  0 20 24
                                          0 0  0  0 30
                                          0 0  0  0  0
Flat[                           ]^^0     flattens this list and removes all 0s
                                         e.g.: [6, 8, 10, 12, 12, 15, 18, 20, 24, 30]

Le second est un peu compliqué mais fait quelque chose d'assez simple. Tout d'abord, il est utile de savoir qu'il f&ns'agit d'une fonction qui, lorsqu'elle est appelée avec des arguments ...x, renvoie f[...x, n]. f&:nest similaire, en revenant f[n, ...x]. Maintenant, décomposons ceci:

( ~SortBy ) # (`& &: `~)

D'abord, f#gcrée une fourchette. Avec entrée n, il revient f[n, g[n]]. Cependant, dans ce cas, fc'est la fonction ~SortBy. ~finverse les arguments de la fonction. Cela signifie que ~f#géquivaut à f[g[n], n], ou ici, SortBy[(`& &: `~)[n], n].

`& &: `~suit le formulaire f&:n. Mais que sont `&et `~? Ce sont des "guillemets d'opérateur" et retournent une fonction équivalente à l'opérateur cité. Donc, dans ce cas, `&c'est la même chose que ${ x & y }. Dans cet esprit, cette expression est équivalente à la suivante pour les opérateurs binaires:

f&:n   <=>   ${ f[n, x] }
       <=>   ${ (`&)[`~, x] }
       <=>   ${ `~ & x }

Cela donne la fonction `~&x, où xest le résultat de la première fonction. n ~ acompte les occurrences de nin a. Ainsi, cela renvoie une fonction qui compte les occurrences de l'argument dans le tableau calculé à partir de la fonction 1.

Pour en revenir à SortBy, chaque élément du tableau est multiplié par le nombre de fois qu'il y apparaît.

Enfin, Lastprend l'élément qui se produit le plus. Les liens sont rompus par l'algorithme de tri.

JavaScript (ES6), 72 70 octets

a=>a.map(m=o=(y,Y)=>a.map(x=>Y--<0?m=(o[x*=y]=-~o[x])<m?m:o[r=x]:0))|r

Essayez-le en ligne!

Fusain , 24 octets

ＷθＦ×⊟θθ⊞υκＩ⊟Φυ⁼№υι⌈Ｅυ№υλ

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

Ｗθ

Alors que le tableau d'entrée n'est pas vide ...

×⊟θθ

... éclatez le dernier élément et multipliez le reste du tableau par cet élément ...

Ｆ...⊞υκ

... et poussez les résultats dans la liste vide prédéfinie.

⌈Ｅυ№υλ

Comptez le nombre de fois que chaque produit apparaît dans la liste et prenez le maximum ...

Φυ⁼№υι...

... puis filtrez les produits dont le nombre est égal à ce maximum ...

Ｉ⊟

... puis ouvrez le dernier élément et transformez-le en chaîne pour une impression implicite.

Husk , 7 octets

Ṡ►#mΠṖ2

Essayez-le en ligne!

Explication

Ṡ►#mΠṖ2  -- example input [3,3,3]
     Ṗ2  -- subsequences of length 2: [[3,3],[3,3],[3,3]]
   mΠ    -- map product: [9,9,9]
Ṡ        -- apply 
  #      -- | count occurences in list
 ►       -- to maxOn that list: [9]

APL (Dyalog Unicode) , 29 27 19 octets

{⌈/⊢/⊣¨⌸∊⍵}⍳∘≢↓¨⊢×⊂

Essayez-le en ligne!

Tacit fn.

Merci à Adám pour la version tacite et 2 octets.

Merci à ngn pour 8 octets!

Comment:

{⌈/⊢/⊣¨⌸∊⍵}⍳∘≢↓¨⊢×⊂
                ⊢×⊂   ⍝ Multiply each element with the entire argument, then
           ⍳∘≢↓¨      ⍝ Remove 1 from the first, two from the next etc. (removes repeated multiplications);
                      ⍝ The result is then fed into the function:
{       ∊⍵}           ⍝ Flatten the result;
     ⊣¨⌸              ⍝ Key; creates a matrix in which each row corresponds to a unique product;
   ⊢/                 ⍝ Get the rightmost column of the matrix;
 ⌈/                   ⍝ Get the highest value.

Japt , 20 16 octets

• -4 octets de @Shaggy

£s°Y m*XÃc
ñ@è¥X

Essayez-le en ligne!

CJam , 70 68 octets

q',/S*~_,(:L{LX-,0a\+[{X1++}*](;{_X=\_Y=@*\}fY}fX]~;]_{\_@e=}$\;_,(=

Essayez-le en ligne!

Explication

q',/S*~                                                                  Turn input string into a valid CJam array
       _,(                                                               Find the length of the array and subtract 1
          :L                                                             Assign the result to L
            {                                 }fX                        Outer for loop
             LX-,0a\+[{X1++}*](;                                         Create an array with all the array indexes bigger than X
                                {          }fY                           Inner for loop
                                 _X=\_Y=@*\                              Create a multiple of array[X] and array[Y] (Guaranteed to be from a unique combination of factors)
                                                 ~;]                     Casts away all stack items except for an array of the multiples
                                                    _{\_@e=}$\;          Sorts array by number of occurrences (largest number of occurences at the end)
                                                               _,(=      Gets the last element of the array

Vous devrez faire défiler vers la droite pour voir les explications car le code est assez long, ainsi que les explications.

C'était un cauchemar absolu à écrire. CJam n'a pas de fonction PowerSet (contrairement à une tonne d'autres langues de golf - un excellent choix de ma part), ce qui signifie que j'ai dû trouver manuellement le PowerSet. Cependant, cela m'a donné la possibilité d'ignorer tout nombre non valide de facteurs, contrairement à d'autres réponses avec une fonction Powerset.

Cela devrait être jouable au golf, étant donné que je suis terrible à CJam.

Changements:

Helen a coupé 2 octets!

Ancien: q',/S*~_,1-:L{LX-,0a\+[{X1++}*](;{_X=\_Y=@*\}fY}fX]~;]_{\_@e=}$\;_,1-=
Nouveau:q',/S*~_,(:L{LX-,0a\+[{X1++}*](;{_X=\_Y=@*\}fY}fX]~;]_{\_@e=}$\;_,(=

En modifiant 1-simplement le s, (nous obtenons le même effet mais avec un nombre d'octets inférieur.

Java (JDK 10) , 132 octets

a->{int l=a.length,i=l,j=0,r=99999,m[]=new int[r];for(;i-->0;)for(j=l;--j>i;)m[a[i]*a[j]]++;for(;r-->0;)i=m[r]<i?i:m[j=r];return j;}

Essayez-le en ligne!

Haskell , 96 94 octets

^{-2 octets grâce à nimi (en utilisant à la sortOn(0<$)place de length)!}

import Data.List
f a|b<-zip[0..]a=last.last.sortOn(0<$).group$sort[x*y|(i,x)<-b,(j,y)<-b,i/=j]

Essayez-le en ligne!

MATLAB 39 octets

a=input('');
b=triu(a'*a,1);
mode(b(b~=0))

Consultez également la réponse de Jacob Watson

SQL Server, 93 octets

SELECT TOP 1a.a*b.a
FROM @ a
JOIN @ b ON a.i<b.i
GROUP BY a.a*b.a
ORDER BY COUNT(a.a*b.a)DESC

L'entrée est supposée provenir d'un tableau du formulaire

DECLARE @ TABLE (A int, i int identity);

Exemple de population de table:

INSERT INTO @ VALUES (9), (7), (10), (9), (7), (8), (5), (10), (1);

Explication:

Je suppose qu'une "liste d'entiers" aura un index qui leur est associé, qui dans mon cas est la colonne i. La colonne acontient les valeurs de la liste.

Je crée des produits de chaque paire, où la paire gauche vient dans la liste plus tôt que la bonne paire. Je regroupe ensuite le produit et trie par le numéro le plus peuplé.

Je suis un peu triste de ne pas avoir utilisé de clauses cte ou de partitionnement, mais elles étaient tout simplement trop longues. SELECTest un mot-clé très cher.

Alternative, 183 octets

WITH c
AS(SELECT a,ROW_NUMBER()OVER(ORDER BY a)r
FROM @),d AS(SELECT a.a*b.a p,COUNT(a.a*b.a)m
FROM c a
JOIN c b ON a.r<b.r GROUP BY a.a*b.a)SELECT TOP 1p
FROM d
ORDER BY m DESC

Si SQL ne parvient pas à avoir une colonne d'index distincte, voici une solution où je crée un index à l'aide de la ROW_NUMBERfonction. Personnellement, je ne me soucie pas de la commande, mais une commande est requise et l'utilisation de la acolonne est la plus courte.

CJam , 29 octets

q~:L,2m*{:-},{Lf=:*}%$e`:e>1=

Essayez-le en ligne!

Burlesque - 8 octets

Jcp)pdn!

J        duplicate
 cp      cross product
   )pd   map . product
      n! most common element

Essayez-le en ligne ici.

(et oui, Burlesque a également une commande pour "l'élément le moins commun")

C # (Visual C # Interactive Compiler) , 95 octets

x=>x.SelectMany(y=>(x=x.Skip(1)).Select(z=>y*z)).GroupBy(y=>y).OrderBy(y=>y.Count()).Last().Key

Essayez-le en ligne!

Code moins golfé:

// x is a list of integers
x=>
  // iterate over each integer and
  // return a list per element.
  // flatten the list of lists to 1 list
  x.SelectMany(y=>
    // skip the current value and save
    // newly offset list to x so that it
    // can be incrementally offset
    // again next pass
    (x=x.Skip(1))
      // compute the product
      .Select(z=>y*z))
    // get the unique products
    .GroupBy(y=>y)
    // sort the products by number
    // of occurrences
    .OrderBy(y=>y.Count())
    // pick the product with the
    // greatest number of occurrences
    .Last().Key

PHP, 91 octets

while($c=$argv[++$i])for($k=$i;--$k;)$r[$c*$argv[$k]]++;asort($r);echo end(array_flip($r));

prend l'entrée des arguments de la ligne de commande; courir avec -nrou essayer en ligne .

Utilisez PHP 7 pour éviter l'avertissement STRICT MODE.

J, 29 25 24 23 octets

(0{~.\:1#.=)@(</#&,*/)~

Essayez-le en ligne!

Comment

(~. {.@\: 1 #. =)@(</ #&, */)~
                  (</ #&, */)~  NB. all products, dups removed:
                          */    NB. create the times table
                   </           NB. lower triangular ones matrix
                       &,       NB. flatten each and
                      #         NB. filter based on lower triangle
                 @              NB. pass that result to
(~. {.@\: 1 #. =)               NB. get the most frequent list item:
       \:                       NB. sort down
 ~.                             NB. the uniq elements
          1 #. =                NB. by their count
    {.@                         NB. and take the first element

Japt -h, 11 octets

à2 ®×Ãü ñÊÌ

Essayez-le

á2 ®×
ñ@è¥X

Essayez-le

APL (NARS), 53 caractères, 106 octets

{0=l←↑⍴⍵:⍵⋄t⊃⍨q⍳⌈/q←{+/t=⍵}¨t←×/¨(∊(⍳l)∘.<⍳l)/,⍵∘.,⍵}

Tester:

  p←{0=l←↑⍴⍵:⍵⋄t⊃⍨q⍳⌈/q←{+/t=⍵}¨t←×/¨(∊(⍳l)∘.<⍳l)/,⍵∘.,⍵}
  p 9
9
  p 1 3
3
  p 2 3 4 5 6
12
  p 7 2
14
  p 2 3 3
6
  p 3 3 3
9
  p 1 1 1 1 2 2
2
  p 6 200 10 120
1200
  p 2 3 4 5 6 7 8 8
24
  p 5 2 9 10 3 4 4 4 7
20
  p 9 7 10 9 7 8 5 10 1
63
  p 3 3
9