Nicht zu verwechseln mit Least Common Multiple .

Wenn Sie eine Liste positiver Ganzzahlen mit mehr als einem Element erhalten, geben Sie das häufigste Produkt von zwei Elementen im Array zurück.

Der MCM der Liste [2,3,4,5,6]lautet beispielsweise 12wie folgt:

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

Danke DJMcMayhem für den Tisch

Wie 12erscheint am häufigsten (zweimal als 2*6und 3*4). Beachten Sie, dass wir ohne das Produkt eines Elements sind und sich so 2*2oder 4*4nicht in dieser Liste nicht angezeigt. Identische Elemente werden jedoch weiterhin multipliziert, sodass die Tabelle für [2,3,3]wie folgt aussieht:

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

Mit dem MCM sein 6.

Im Falle eines Unentschieden können Sie eines der verknüpften Elemente oder eine Liste aller Elemente zurückgeben.

• Das ist Code-Golf , also gewinnt die kürzeste Anzahl von Bytes für jede Sprache!

Testfälle:

[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

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Alternativ für 54 53 44 Bytes:

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

Probieren Sie es online!

Im Prinzip gibt die letztere Version das relevante Ergebnis auch ohne die namesFunktion aus, gefolgt von der Zählung der häufigsten Produkte, die nicht nachgefragt wird ...

Danke an CriminallyVulgar für -4 und -1 und Giuseppe für -9 für beide.

Gelee , 6 Bytes

ŒcP€Æṃ

Probieren Sie es online! oder Schauen Sie sich die Testsuite an .

Wie es funktioniert

ŒcP € Æṃ - Vollständiges Programm / Monadic Link.
Œc - Ungeordnete Paare ohne Ersatz.
  P € - Produkt von jedem.
    Æṃ - Modus (häufigstes Element).

Alternative: ŒcZPÆṃ

Pyth, 12 Bytes

eo/QN=*M.cQ2

Testsuite

Zunächst nehmen wir alle 2 Elementkombinationen der Eingabe ohne Ersetzung ( .cQ2). Dann ordnen wir jedes dieser Paare ihrem Produkt zu ( *M). Als nächstes überschreiben wir die Eingabevariable mit der Liste der Produkte ( =). Als nächstes sortieren wir die Liste der Produkte nach der Anzahl der Vorkommen in der Liste der Produkte ( o/QN). Zuletzt nehmen Sie das letzte Element der sortierten Liste ( e).

MATL , 8 7 Bytes

2XN!pXM

Probieren Sie es online!

(-1 Byte mit der Methode aus der Antwort von @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

Ältere Antwort:

8 Bytes

&*XRXzXM

Probieren Sie es 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 dank @Kaldo .

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

æ         # 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 (und ein Update ) dank JungHwan Min .}

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

Funktion pur. Nimmt eine Liste von Zahlen als Eingabe und gibt die Liste von MCMs als Ausgabe zurück.

MATLAB, 43 Bytes

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

Es ist auch eine Art Zungenbrecher!

Erläuterung

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

Probieren Sie es online!

Stax , 12 10 Bytes

╢êv^⌐ö►♣Ä»

Führen Sie es aus und debuggen Sie es

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)

Probieren Sie es online!

Attache , 59 Bytes

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

Probieren Sie es online!

Ich arbeite immer noch daran, das ein bisschen herunter zu spielen, aber ich denke, das ist nahezu optimal für den Ansatz, den ich gewählt habe.

Erläuterung

Dies ist eine Komposition aus drei Funktionen:

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

Die erste Funktion übernimmt den Großteil der Berechnung:

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

Die zweite ist etwas kompliziert, macht aber etwas ziemlich Einfaches. Zunächst ist es nützlich zu wissen, dass f&nes sich um eine Funktion handelt, die beim Aufruf mit Argumenten zurückgegeben ...xwird f[...x, n]. f&:nist ähnlich und kehrt zurück f[n, ...x]. Zerlegen wir nun Folgendes:

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

Zunächst f#gerstellt eine Gabel. Mit der Eingabe nkehrt es zurück f[n, g[n]]. In diesem Fall fist jedoch die Funktion ~SortBy. ~fKehrt die Argumente der Funktion um. Das heißt, das ~f#gist gleichbedeutend mit f[g[n], n]oder hierSortBy[(`& &: `~)[n], n] .

`& &: `~folgt der Form f&:n. Aber was ist `&und `~? Sie sind "Operator-Anführungszeichen" und geben eine Funktion zurück, die dem angegebenen Operator entspricht. Also, in diesem Fall `&ist das Gleiche wie ${ x & y }. In diesem Sinne entspricht dieser Ausdruck für binäre Operatoren dem Folgenden:

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

Dies ergibt die Funktion `~&x, wobei xdas Ergebnis der ersten Funktion ist. n ~ azählt die Vorkommen von nin a. Dies gibt also eine Funktion zurück, die das Auftreten des Arguments in dem berechneten Array von Funktion 1 zählt.

Zurück zu SortBy: Jedes Element im Array wird so oft angezeigt, wie es darin enthalten ist.

Schließlich Lastnimmt das Element, das am häufigsten auftritt. Verbindungen werden durch den Sortieralgorithmus unterbrochen.

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

Probieren Sie es online!

Holzkohle , 24 Bytes

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

Probieren Sie es online!Link ist eine ausführliche Version des Codes. Erläuterung:

Ｗθ

Während das Eingabearray nicht leer ist ...

×⊟θθ

... füge das letzte Element ein und multipliziere den Rest des Arrays mit diesem Element ...

Ｆ...⊞υκ

... und verschieben Sie die Ergebnisse in die vordefinierte leere Liste.

⌈Ｅυ№υλ

Zählen Sie, wie oft jedes Produkt in der Liste erscheint, und nehmen Sie das Maximum ...

Φυ⁼№υι...

... dann filtern Sie nach den Produkten, deren Anzahl dem Maximum entspricht ...

Ｉ⊟

... dann füge das letzte Element ein und gib es als String für den impliziten Druck aus.

Schale , 7 Bytes

Ṡ►#mΠṖ2

Probieren Sie es online!

Erläuterung

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

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

Probieren Sie es online!

Tacit fn.

Vielen Dank an Adám für die stillschweigende Version und 2 Bytes.

Danke an ngn für 8 Bytes!

Wie:

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

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

Probieren Sie es online!

CJam , 70 68 Bytes

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

Probieren Sie es online!

Erläuterung

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

Sie müssen nach rechts scrollen, um die Erklärungen zu sehen, da der Code ziemlich lang ist, sowie die Erklärungen.

Dies war ein absoluter Albtraum zu schreiben. CJam hat keine Powerset-Funktion (im Gegensatz zu vielen anderen Golfsprachen - eine gute Wahl für mich), was bedeutet, dass ich das Powerset manuell finden musste. Dies gab mir jedoch die Möglichkeit, eine ungültige Anzahl von Faktoren zu ignorieren, im Gegensatz zu anderen Antworten mit einer Powerset-Funktion.

Das sollte Golf sein, wenn man bedenkt, dass ich bei CJam schrecklich bin.

Änderungen:

Helen hat 2 Bytes abgeschnitten!

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

Durch Ändern der 1- s in einfach , (erhalten Sie den gleichen Effekt, jedoch mit einer geringeren Bytezahl.

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

Probieren Sie es online!

Haskell , 96 94 Bytes

^{-2 bytes dank nimi (mit sortOn(0<$)statt 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]

Probieren Sie es online!

MATLAB 39 Bytes

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

Lesen Sie auch die Antwort von 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

Es wird davon ausgegangen, dass die Eingabe aus einer Tabelle des Formulars stammt

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

Beispiel einer Tabellenpopulation:

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

Erläuterung:

Ich gehe davon aus, dass einer "Liste von Ganzzahlen" ein Index zugeordnet ist, in meinem Fall die Spalte i. Die Spalte aenthält die Werte der Liste.

Ich erstelle Produkte von jedem Paar, wobei das linke Paar früher in der Liste steht als das rechte Paar. Ich gruppiere dann nach dem Produkt und sortiere nach der bevölkerungsreichsten Zahl.

Ich bin ein bisschen traurig, dass ich keine CTE- oder Partitionierungsklauseln verwenden durfte, aber sie waren einfach zu lang. SELECTist ein sehr teures Stichwort.

Alternative, 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

Wenn SQL keine separate Indexspalte hat, ist hier eine Lösung, bei der ich mithilfe der ROW_NUMBERFunktion einen Index erstelle . Ich persönlich interessiere mich nicht für die Bestellung, aber eine Bestellung ist erforderlich und die Verwendung der aSpalte ist die kürzeste.

CJam , 29 Bytes

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

Probieren Sie es online!

Burlesque - 8 Bytes

Jcp)pdn!

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

Probieren Sie es hier online aus.

(und ja, Burlesque hat auch einen Befehl für "am wenigsten verbreitetes Element")

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

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

Probieren Sie es online!

Weniger Golf Code:

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

Nimmt Eingaben von Befehlszeilenargumenten entgegen. Laufen Sie mit -nroder versuchen Sie es online .

Verwenden Sie PHP 7, um die STRICT MODE-Warnung zu vermeiden.

J, 29 25 24 23 Bytes

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

Probieren Sie es online!

Wie

(~. {.@\: 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 ®×Ãü ñÊÌ

Versuch es

á2 ®×
ñ@è¥X

Versuch es

APL (NARS), 53 Zeichen, 106 Byte

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

Prüfung:

  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