Não confunda com Mínimo Múltiplo Comum .

Dada uma lista de números inteiros positivos com mais de um elemento, retorne o produto mais comum de dois elementos na matriz.

Por exemplo, o MCM da lista [2,3,4,5,6]é 12, pois uma tabela de produtos é:

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

Obrigado DJMcMayhem pela mesa

Como 12aparece mais vezes (duas vezes como 2*6e 3*4). Observe que não estamos incluindo o produto de um elemento e ele próprio, portanto, 2*2ou 4*4não, aparece nesta lista. No entanto, elementos idênticos ainda serão multiplicados, portanto a tabela para[2,3,3] parece com:

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

Com o MCM sendo 6.

Em caso de empate, você pode retornar qualquer um dos elementos empatados ou uma lista de todos eles.

• Isso é código-golfe , então a contagem de bytes mais curta para cada idioma vence!

Casos de teste:

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

Braquilog , 11 bytes

{⊇Ċ×}ᶠọtᵒth

Experimente online!

Explicação

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

Experimente online!

Como alternativa, para 54 53 44 bytes:

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

Experimente online!

Em princípio, a última versão gera o resultado relevante mesmo sem a namesfunção, mas seguida pela contagem desses produtos mais frequentes, que não são solicitados ...

Obrigado a CriminallyVulgar por -4 e -1 e Giuseppe por -9 em ambos.

Gelatina , 6 bytes

ŒcP€Æṃ

Experimente online! ou Confira a suíte de testes .

Como funciona

ŒcP € - Programa completo / Link monádico.
Œc - Pares não ordenados sem substituição.
  P € - Produto de cada um.
    Æṃ - Modo (elemento mais comum).

Alternativa: ŒcZPÆṃ

Pitão, 12 bytes

eo/QN=*M.cQ2

Suíte de teste

Primeiro, pegamos todas as 2 combinações de elementos da entrada sem substituição ( .cQ2). Em seguida, mapeamos cada um desses pares para o seu produto ( *M). Em seguida, substituímos a variável de entrada pela lista de produtos ( =). Em seguida, classificamos a lista de produtos pelo número de ocorrências na lista de produtos ( o/QN). Por fim, pegue o elemento final da lista classificada ( e).

MATL , 8 7 bytes

2XN!pXM

Experimente online!

(-1 byte usando o método da resposta do Sr. 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

Resposta mais antiga:

8 bytes

&*XRXzXM

Experimente online!

&*    % 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 graças a @Kaldo .

Experimente online ou verifique todos os casos de teste .

Explicação:

æ         # 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 (e uma correção) graças a JungHwan Min .}

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

Função pura. Pega uma lista de números como entrada e retorna a lista de MCMs como saída.

MATLAB, 43 bytes

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

Também é uma espécie de trava-língua!

Explicação

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*@_)∖@_»²: *{*}:}

Experimente online!

Stax , 12 10 bytes

╢êv^⌐ö►♣Ä»

Execute e depure

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)

Experimente online!

Anexo , 59 bytes

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

Experimente online!

Ainda estou trabalhando um pouco no golfe, mas acho que isso é quase ideal para a abordagem que escolhi.

Explicação

Esta é uma composição de três funções:

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

A primeira função faz a maior parte do 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]

O segundo é um pouco complicado, mas faz algo bastante simples. Primeiro, é útil saber que f&né uma função que, quando chamada com argumentos ...x, retorna f[...x, n]. f&:né semelhante, retornando f[n, ...x]. Agora, vamos decompor isso:

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

Primeiro, f#gcria um garfo. Com a entrada n, ele retorna f[n, g[n]]. No entanto, neste caso, fé a função ~SortBy. ~finverte os argumentos da função. Isso significa que ~f#gé equivalente a f[g[n], n], ou aqui SortBy[(`& &: `~)[n], n],.

`& &: `~segue o formulário f&:n. Mas o que são `&e `~? São "cotações do operador" e retornam uma função equivalente ao operador entre aspas. Então, neste caso, `&é a mesma coisa que ${ x & y }. Com isso em mente, essa expressão é equivalente ao seguinte para operadores binários:

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

Isso gera a função `~&x, onde xestá o resultado da primeira função. n ~ aconta as ocorrências de nema . Portanto, isso retorna uma função que conta as ocorrências do argumento na matriz computada da função 1.

Voltando a SortBy, cada elemento na matriz pelo número de vezes que aparece nela.

Por fim, Lastpega o elemento que mais ocorre. Os laços são quebrados pelo algoritmo de classificação.

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

Experimente online!

Carvão , 24 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

Ｗθ

Enquanto a matriz de entrada não estiver vazia ...

×⊟θθ

... pop o último elemento e multiplique o restante da matriz por esse elemento ...

Ｆ...⊞υκ

... e envie os resultados para a lista vazia predefinida.

⌈Ｅυ№υλ

Conte o número de vezes que cada produto aparece na lista e faça o máximo ...

Φυ⁼№υι...

... em seguida, filtre os produtos cuja contagem é igual a esse máximo ...

Ｉ⊟

... em seguida, pop o último elemento e convertido em string para impressão implícita.

Casca , 7 bytes

Ṡ►#mΠṖ2

Experimente online!

Explicação

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

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

Experimente online!

Tácito fn.

Agradecimentos a Adám pela versão tácita e 2 bytes.

Graças a ngn por 8 bytes!

Quão:

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

Japonês , 20 16 bytes

• -4 bytes de @Shaggy

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

Experimente online!

CJam , 70 68 bytes

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

Experimente online!

Explicação

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

Você precisará rolar para a direita para ver as explicações, pois o código é bastante longo e também as explicações.

Este foi um pesadelo absoluto para escrever. O CJam não possui uma função de conjunto de potências (diferente de outras línguas de golfe - ótima opção da minha parte), o que significa que eu tive que encontrar manualmente o conjunto de potências. No entanto, isso me deu a oportunidade de ignorar qualquer número inválido de fatores, ao contrário de outras respostas com uma função de conjunto de poderes.

Isso deve ser jogável, considerando que eu sou péssimo no CJam.

Alterar:

Helen cortou 2 bytes!

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

Alterando os 1-para simplesmente (obtemos o mesmo efeito, mas com uma contagem de bytes mais baixa.

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

Experimente online!

Haskell , 96 94 bytes

^{-2 bytes graças a nimi (usando em sortOn(0<$)vez 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]

Experimente online!

MATLAB 39 bytes

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

Confira também a resposta 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

Presume-se que a entrada vem de uma tabela do formulário

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

Exemplo de população da tabela:

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

Explicação:

Presumo que uma "lista de números inteiros" terá um índice associado a eles, que no meu caso é a coluna i. A coluna acontém os valores da lista.

Crio produtos de cada par, em que o par esquerdo entra na lista mais cedo que o par direito. Em seguida, agrupo o produto e classifico pelo número mais populoso.

Estou um pouco triste por não ter usado nenhuma cláusula cte ou de particionamento, mas elas eram muito longas. SELECTé uma palavra-chave muito 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

Se o SQL não tiver uma coluna de índice separada, aqui está uma solução em que eu crio um índice usando a ROW_NUMBERfunção Pessoalmente, não me importo com o pedido, mas é necessário um pedido e o uso doa coluna é o mais curto.

CJam , 29 bytes

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

Experimente online!

Burlesco - 8 bytes

Jcp)pdn!

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

Experimente online aqui.

(e sim, Burlesque também possui um comando para o "elemento menos comum")

C # (compilador interativo do 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

Experimente online!

Menos código de golfe:

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

recebe entrada de argumentos de linha de comando; execute -nrou experimente online .

Use o PHP 7 para evitar o aviso do modo estrito.

J, 29 25 24 23 bytes

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

Experimente online!

quão

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

Japonês -h, 11 bytes

à2 ®×Ãü ñÊÌ

Tente

á2 ®×
ñ@è¥X

Tente

APL (NARS), 53 caracteres, 106 bytes

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

Teste:

  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