No debe confundirse con el mínimo común múltiplo .

Dada una lista de enteros positivos con más de un elemento, devuelve el producto más común de dos elementos en la matriz.

Por ejemplo, el MCM de la lista [2,3,4,5,6]es 12, como una tabla de productos, es:

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

Gracias DJMcMayhem por la mesa

Como 12aparece la mayoría de las veces (dos veces como 2*6y 3*4). Tenga en cuenta que no estamos incluyendo el producto de un elemento y en sí, por lo que 2*2o 4*4no no aparece en esta lista. Sin embargo, los elementos idénticos se seguirán multiplicando, por lo que la tabla para [2,3,3]parece:

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

Con el ser MCM 6.

En caso de empate, puede devolver cualquiera de los elementos vinculados o una lista de todos ellos.

• Este es el código de golf , por lo que gana el recuento de bytes más corto para cada idioma.

Casos de prueba:

[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 bytes

{⊇Ċ×}ᶠọtᵒth

Pruébalo en línea!

Explicación

{   }ᶠ          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 bytes

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

Pruébalo en línea!

Alternativamente, para 54 53 44 bytes:

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

Pruébalo en línea!

En principio, la última versión genera el resultado relevante incluso sin la namesfunción, pero seguido por el recuento de los productos más frecuentes, que no se solicita ...

Gracias a CriminallyVulgar por -4 y -1, y Giuseppe por -9 en ambos.

Jalea , 6 bytes

ŒcP€Æṃ

Pruébalo en línea! o Echa un vistazo a la suite de prueba .

Cómo funciona

ŒcP € Æṃ - Programa completo / Enlace monádico.
Œc - Pares desordenados sin reemplazo.
  P € - Producto de cada uno.
    Æṃ - Modo (elemento más común).

Alternativa: ŒcZPÆṃ

Pyth, 12 bytes

eo/QN=*M.cQ2

Banco de pruebas

Primero, tomamos las 2 combinaciones de elementos de la entrada sin reemplazo ( .cQ2). Luego, asignamos cada uno de estos pares a su producto ( *M). A continuación, sobrescribimos la variable de entrada con la lista de productos ( =). A continuación, ordenamos la lista de productos por el número de ocurrencias en la lista de productos ( o/QN). Finalmente, tome el elemento final de la lista ordenada ( e).

MATL , 8 7 bytes

2XN!pXM

Pruébalo en línea!

(-1 byte usando el método de @Mr. Xcoder's Jelly answer .)

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

Respuesta anterior:

8 bytes

&*XRXzXM

Pruébalo en línea!

&*    % 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 bytes

æ2ùP.M

-2 bytes gracias a @Kaldo .

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

æ         # 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 bytes

^{-17 bytes (y una solución) gracias a JungHwan Min .}

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

Pura función. Toma una lista de números como entrada y devuelve la lista de MCM como salida.

MATLAB, 43 bytes

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

¡También es una especie de trabalenguas!

Explicación

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 bytes

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

Pruébalo en línea!

Stax , 12 10 bytes

╢êv^⌐ö►♣Ä»

Ejecutar y depurarlo

Python 3 , 77 72 bytes

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

Pruébalo en línea!

Adjunto , 59 bytes

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

Pruébalo en línea!

Todavía estoy trabajando en jugar golf un poco, pero creo que esto es casi óptimo para el enfoque que he elegido.

Explicación

Esta es una composición de tres funciones:

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

La primera función realiza la mayor parte del cálculo:

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

El segundo es un poco complicado pero hace algo bastante simple. Primero, es útil saber que f&nes una función que, cuando se llama con argumentos ...x, devuelve f[...x, n]. f&:nEs similar, volviendo f[n, ...x]. Ahora, descompongamos esto:

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

Primero, f#gcrea un tenedor. Con entrada n, vuelve f[n, g[n]]. Sin embargo, en este caso, fes la función ~SortBy. ~finvierte los argumentos de la función. Esto significa que ~f#ges equivalente a f[g[n], n], o aquí SortBy[(`& &: `~)[n], n],.

`& &: `~la siguiente forma f&:n. Pero que son `&y `~? Son "comillas de operador" y devuelven una función equivalente al operador citado. Entonces, en este caso, `&es lo mismo que ${ x & y }. Con eso en mente, esta expresión es equivalente a la siguiente para operadores binarios:

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

Esto produce la función `~&x, donde xes el resultado de la primera función. n ~ acuenta las ocurrencias de nin a. Entonces, esto devuelve una función que cuenta las ocurrencias del argumento en la matriz calculada desde la función 1.

Volviendo a SortBy, este cada elemento en la matriz por el número de veces que aparece en él.

Finalmente, Lasttoma el elemento que más ocurre. Los lazos se rompen por el algoritmo de clasificación.

JavaScript (ES6), 72 70 bytes

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

Pruébalo en línea!

Carbón de leña , 24 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｗθ

Mientras la matriz de entrada no está vacía ...

×⊟θθ

... haga estallar el último elemento y multiplique el resto de la matriz por ese elemento ...

Ｆ...⊞υκ

... y empuje los resultados a la lista vacía predefinida.

⌈Ｅυ№υλ

Cuente la cantidad de veces que cada producto aparece en la lista y tome el máximo ...

Φυ⁼№υι...

... luego filtre los productos cuyo recuento es igual a ese máximo ...

Ｉ⊟

... luego haga estallar el último elemento y lo convierta en cadena para impresión implícita.

Casco , 7 bytes

Ṡ►#mΠṖ2

Pruébalo en línea!

Explicación

Ṡ►#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 bytes

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

Pruébalo en línea!

Tácito fn.

Gracias a Adám por la versión tácita y 2 bytes.

¡Gracias a ngn por 8 bytes!

Cómo:

{⌈/⊢/⊣¨⌸∊⍵}⍳∘≢↓¨⊢×⊂
                ⊢×⊂   ⍝ 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 bytes

• -4 bytes de @Shaggy

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

Pruébalo en línea!

CJam , 70 68 bytes

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

Pruébalo en línea!

Explicación

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

Deberá desplazarse hacia la derecha para ver las explicaciones, ya que el código es bastante largo, así como las explicaciones.

Esta fue una pesadilla absoluta para escribir. CJam no tiene una función de powerset (a diferencia de una tonelada de otros idiomas de golf, una gran elección por mi parte), lo que significa que tuve que encontrar manualmente el powerset. Sin embargo, esto me dio la oportunidad de ignorar cualquier número inválido de factores, a diferencia de otras respuestas con una función powerset.

Esto debería ser golfable, considerando que soy terrible en CJam.

Cambios:

¡Helen cortó 2 bytes!

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

Al cambiar 1-s simplemente (, obtenemos el mismo efecto pero con un recuento de bytes más bajo.

Java (JDK 10) , 132 bytes

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

Pruébalo en línea!

Haskell , 96 94 bytes

^{-2 bytes gracias a nimi (usando en sortOn(0<$)lugar 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]

Pruébalo en línea!

MATLAB 39 bytes

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

También mira la respuesta de Jacob Watson

SQL Server, 93 bytes

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

Se supone que la entrada proviene de una tabla de la forma

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

Ejemplo de población de tabla:

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

Explicación:

Supongo que una "lista de enteros" tendrá un índice asociado con ellos, que en mi caso es la columna i. La columna acontiene los valores de la lista.

Creo productos de cada par, donde el par izquierdo aparece en la lista antes que el par derecho. Luego, agrupo el producto y clasifico por el número más poblado.

Estoy un poco triste porque no pude usar ninguna cláusula cte o de partición, pero fueron demasiado largas. SELECTEs una palabra clave muy cara.

Alternativa, 183 bytes

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 no llega a tener una columna de índice separada, aquí hay una solución donde creo un índice usando la ROW_NUMBERfunción. Personalmente no me importa el pedido, pero se requiere un pedido y el uso de la acolumna es el más corto.

CJam , 29 bytes

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

Pruébalo en línea!

Burlesque - 8 bytes

Jcp)pdn!

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

Pruébelo en línea aquí.

(y sí, Burlesque también tiene un comando para "elemento menos común")

C # (compilador interactivo de Visual C #) , 95 bytes

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

Pruébalo en línea!

Menos código de 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 bytes

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

toma datos de los argumentos de la línea de comandos; ejecutar -nro probarlo en línea .

Use PHP 7 para evitar la advertencia de MODO ESTRICTO.

J, 29 25 24 23 bytes

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

Pruébalo en línea!

cómo

(~. {.@\: 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 bytes

à2 ®×Ãü ñÊÌ

Intentalo

á2 ®×
ñ@è¥X

Intentalo

APL (NARS), 53 caracteres, 106 bytes

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

Prueba:

  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