Da non confondere con il minimo comune multiplo .

Dato un elenco di numeri interi positivi con più di un elemento, restituisce il prodotto più comune di due elementi nell'array.

Ad esempio, l'MCM dell'elenco [2,3,4,5,6]è 12, poiché una tabella di prodotti è:

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

Grazie DJMcMayhem per la tabella

Come 12appare più volte (due volte come 2*6e 3*4). Nota che non stiamo includendo il prodotto di un elemento e se stesso, quindi 2*2o 4*4non compariamo in questo elenco. Tuttavia, gli elementi identici verranno comunque moltiplicati, quindi la tabella per [2,3,3]appare come:

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

Con l'MCM 6.

In caso di pareggio, è possibile restituire uno qualsiasi degli elementi legati o un elenco di tutti loro.

• Questo è code-golf , quindi vince il conteggio dei byte più breve per ogni lingua!

Casi 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 byte

{⊇Ċ×}ᶠọtᵒth

Provalo online!

Spiegazione

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

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

Provalo online!

In alternativa, per 54 53 44 byte:

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

Provalo online!

In linea di principio, quest'ultima versione fornisce il risultato pertinente anche senza la namesfunzione, ma seguita dal conteggio di tali prodotti più frequenti, che non viene richiesto ...

Grazie a CriminallyVulgar per -4 e -1 e Giuseppe per -9 su entrambi.

Gelatina , 6 byte

ŒcP€Æṃ

Provalo online! oppure Dai un'occhiata alla suite di test .

Come funziona

ŒcP € Æṃ - Programma completo / collegamento Monadic.
Œc - Coppie non ordinate senza sostituzione.
  P € - Prodotto di ciascuno.
    Æṃ - Modalità (elemento più comune).

Alternativa: ŒcZPÆṃ

Pyth, 12 byte

eo/QN=*M.cQ2

Suite di test

Innanzitutto, prendiamo tutte e 2 le combinazioni di elementi dell'input senza sostituzione ( .cQ2). Quindi, mappiamo ciascuna di queste coppie sul loro prodotto ( *M). Successivamente, sovrascriviamo la variabile di input con l'elenco dei prodotti ( =). Successivamente, ordiniamo l'elenco dei prodotti in base al numero di occorrenze nell'elenco dei prodotti ( o/QN). Infine, prendi l'elemento finale dell'elenco ordinato ( e).

MATL , 8 7 byte

2XN!pXM

Provalo online!

(-1 byte usando il metodo dalla risposta Jelly di @Mr. Xcoder .)

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

Risposta precedente:

8 byte

&*XRXzXM

Provalo 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 byte

æ2ùP.M

-2 byte grazie a @Kaldo .

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

^{-17 byte (e una correzione) grazie a JungHwan Min .}

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

Funzione pura. Prende un elenco di numeri come input e restituisce l'elenco di MCM come output.

MATLAB, 43 byte

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

È anche una specie di scioglilingua!

Spiegazione

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 byte

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

Provalo online!

Stax , 12 10 byte

╢êv^⌐ö►♣Ä»

Esegui ed esegui il debug

Python 3 , 77 72 byte

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

Provalo online!

Attache , 59 byte

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

Provalo online!

Sto ancora lavorando sul golf un po ', ma penso che sia quasi ottimale per l'approccio che ho scelto.

Spiegazione

Questa è una composizione di tre funzioni:

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

La prima funzione esegue la maggior parte del calcolo:

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

Il secondo è un po 'complicato ma fa qualcosa di piuttosto semplice. Innanzitutto, è utile sapere che f&nè una funzione che, quando viene chiamata con argomenti ...x, restituisce f[...x, n]. f&:nè simile, tornando f[n, ...x]. Ora, scomponiamo questo:

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

Innanzitutto, f#gcrea una forchetta. Con input n, ritorna f[n, g[n]]. Tuttavia, in questo caso, fè la funzione ~SortBy. ~finverte gli argomenti della funzione. Ciò significa che ~f#gè equivalente af[g[n], n] , o qui SortBy[(`& &: `~)[n], n],.

`& &: `~segue il modulo f&:n. Ma cosa sono `&e `~? Sono "virgolette dell'operatore" e restituiscono una funzione equivalente all'operatore tra virgolette. Quindi, in questo caso, `&è la stessa cosa di ${ x & y }. Con questo in mente, questa espressione è equivalente alla seguente per gli operatori binari:

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

Questo produce la funzione `~&x, dove xè il risultato della prima funzione. n ~ aconta le occorrenze din in a. Quindi, questo restituisce una funzione che conta le occorrenze dell'argomento nell'array calcolato dalla funzione 1.

Tornando a SortBy , questo ogni elemento dell'array per il numero di volte che appare in esso.

Infine, Lastprende l'elemento che si presenta di più. I legami vengono interrotti dall'algoritmo di ordinamento.

JavaScript (ES6), 72 70 byte

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

Provalo online!

Carbone , 24 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

Ｗθ

Mentre l'array di input non è vuoto ...

×⊟θθ

... pop l'ultimo elemento e moltiplicare il resto dell'array per quell'elemento ...

Ｆ...⊞υκ

... e invia i risultati all'elenco vuoto predefinito.

⌈Ｅυ№υλ

Conta il numero di volte che ciascun prodotto appare nell'elenco e prendi il massimo ...

Φυ⁼№υι...

... quindi filtra i prodotti il ​​cui conteggio equivale a quello massimo ...

Ｉ⊟

... quindi pop l'ultimo elemento e cast su stringa per la stampa implicita.

Buccia , 7 byte

Ṡ►#mΠṖ2

Provalo online!

Spiegazione

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

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

Provalo online!

Tacit fn.

Grazie ad Adám per la versione tacita e 2 byte.

Grazie a ngn per 8 byte!

Come:

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

• -4 byte da @Shaggy

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

Provalo online!

CJam , 70 68 byte

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

Provalo online!

Spiegazione

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

Dovrai scorrere verso destra per vedere le spiegazioni poiché il codice è piuttosto lungo, così come le spiegazioni.

Questo è stato un incubo assoluto da scrivere. CJam non ha una funzione powerset (a differenza di molti altri linguaggi del golf - ottima scelta da parte mia), il che significa che ho dovuto trovare manualmente il powerset. Tuttavia, ciò mi ha dato l'opportunità di ignorare qualsiasi numero non valido di fattori, a differenza di altre risposte con una funzione di powerset.

Questo dovrebbe essere giocabile a golf, considerando che sono terribile in CJam.

I cambiamenti:

Helen tagliato 2 byte!

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

Modificando la 1-s semplicemente (otteniamo lo stesso effetto ma con un numero di byte inferiore.

Java (JDK 10) , 132 byte

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

Provalo online!

Haskell , 96 94 byte

^{-2 byte grazie a nimi (usando sortOn(0<$)invece di 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]

Provalo online!

MATLAB 39 byte

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

Controlla anche la risposta di Jacob Watson

SQL Server, 93 byte

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

Si presume che l'input provenga da una tabella del modulo

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

Popolazione della tabella di esempio:

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

Spiegazione:

Presumo che un "elenco di numeri interi" avrà un indice associato a loro, che nel mio caso è la colonna i. La colonna acontiene i valori dell'elenco.

Creo prodotti per ogni coppia, in cui la coppia di sinistra viene visualizzata nell'elenco prima della coppia di destra. Quindi raggruppo il prodotto e seleziono per il numero più popoloso.

Sono un po 'triste di non aver usato nessuna clausola cte o di partizionamento, ma erano troppo lunghi. SELECTè una parola chiave molto costosa.

Alternativa, 183 byte

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 SQL non riesce ad avere una colonna di indice separata, ecco una soluzione in cui creo un indice utilizzando la ROW_NUMBERfunzione. Personalmente non mi interessa l'ordine, ma è necessario un ordine e l'utilizzo della acolonna è il più breve.

CJam , 29 byte

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

Provalo online!

Burlesque - 8 byte

Jcp)pdn!

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

Provalo online qui.

(e sì, Burlesque ha anche un comando per "elemento meno comune")

C # (compilatore interattivo Visual C #) , 95 byte

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

Provalo online!

Meno codice 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 byte

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

accetta input dagli argomenti della riga di comando; corri con -nro provalo online .

Utilizzare PHP 7 per evitare l'avvertenza MODALITÀ STRICT.

J, 29 25 24 23 byte

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

Provalo online!

Come

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

à2 ®×Ãü ñÊÌ

Provalo

á2 ®×
ñ@è¥X

Provalo

APL (NARS), 53 caratteri, 106 byte

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

Test:

  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