최소 공배수와 혼동하지 마십시오 .

요소가 둘 이상인 양의 정수 목록이 제공되면 배열에서 두 요소의 가장 일반적인 곱을 반환합니다.

예를 들어,리스트의 MCM은 [2,3,4,5,6]입니다 12제품의 표와 같이 :

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

감사합니다 DJMcMayhem 테이블

으로는 12가장 시간 (두 배 표시 2*6등을 3*4). 우리는 요소 자체의 제품을 포함하지 않는, 그래서 참고 2*2또는 4*4이 목록에 표시되지 않습니다. 그러나 동일한 요소가 계속 곱해 지므로 표는 [2,3,3]다음과 같습니다.

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

MCM으로 6.

동점 인 경우 묶인 요소 중 하나 또는 모든 요소의 목록을 반환 할 수 있습니다.

• 이것은 code-golf 이므로 각 언어의 최단 바이트 수가 이깁니다!

테스트 사례 :

[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 바이트

{⊇Ċ×}ᶠọtᵒth

온라인으로 사용해보십시오!

설명

{   }ᶠ          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 바이트

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

온라인으로 사용해보십시오!

또는 54 53 44 바이트의 경우 :

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

온라인으로 사용해보십시오!

원칙적으로 후자 버전은 names 기능이 하지만 가장 빈번한 제품의 수는 다음과 같습니다.

-4와 -1의 CriminallyVulgar와 -9의 Giuseppe에게 감사드립니다.

젤리 , 6 바이트

ŒcP€Æṃ

온라인으로 사용해보십시오! 또는 테스트 스위트를 확인하십시오 .

작동 원리

ŒcP € Æṃ – 전체 프로그램 / Monadic 링크.
Œc – 교체하지 않고 정렬되지 않은 쌍.
  P € – 각각의 제품.
    Æṃ – 모드 (가장 일반적인 요소).

대안 : ŒcZPÆṃ

Pyth, 12 바이트

eo/QN=*M.cQ2

테스트 스위트

먼저, 입력의 두 가지 요소 조합을 모두 교체없이 사용합니다 ( .cQ2). 그런 다음 각 쌍을 해당 제품 ( *M)에 매핑합니다 . 다음으로 입력 변수를 제품 목록 ( =)으로 덮어 씁니다 . 다음으로, 제품 목록 ( o/QN) 에서 발생 횟수별로 제품 목록을 정렬합니다 . 마지막으로 정렬 된 목록의 마지막 요소 ( e)를 가져옵니다 .

MATL , 8 7 바이트

2XN!pXM

온라인으로 사용해보십시오!

(@Mr. Xcoder의 Jelly answer 방법을 사용하여 1 바이트 )

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

더 오래된 답변 :

8 바이트

&*XRXzXM

온라인으로 사용해보십시오!

&*    % 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 바이트

æ2ùP.M

@Kaldo 덕분에 -2 바이트 .

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

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

수학, 32 바이트

^{JungHwan Min 덕분에 -17 바이트 (및 수정) .}

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

순수한 기능. 숫자 목록을 입력으로 취하고 MCM 목록을 출력으로 리턴합니다.

MATLAB, 43 바이트

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

또한 일종의 혀 트위스터입니다!

설명

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

펄 6 , 41 38 바이트

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

온라인으로 사용해보십시오!

Stax , 12 10 바이트

╢êv^⌐ö►♣Ä»

실행 및 디버깅

파이썬 3 , 77 72 바이트

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

온라인으로 사용해보십시오!

첨부 , 59 바이트

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

온라인으로 사용해보십시오!

아직도이 문제를 해결하기 위해 노력하고 있지만 이것이 내가 선택한 접근 방식에 거의 최적이라고 생각합니다.

설명

이것은 세 가지 기능으로 구성됩니다.

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

첫 번째 함수는 대량의 계산을 수행합니다.

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

두 번째는 약간 복잡하지만 다소 간단한 작업을 수행합니다. 먼저, f&narguments를 사용하여 호출하면를 ...x반환 하는 함수 임을 아는 것이 유용 합니다 f[...x, n]. f&:n을 반환하는 것과 비슷 f[n, ...x]합니다. 이제 이것을 분해하자 :

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

먼저 f#g포크를 만듭니다. 입력 n하면를 반환합니다 f[n, g[n]]. 그러나이 경우 f함수 ~SortBy입니다. ~f함수의 인수를 반대로합니다. 이것은 또는 여기에 ~f#g해당함을 의미합니다 .f[g[n], n]SortBy[(`& &: `~)[n], n]

`& &: `~형식을 따릅니다 f&:n. 그러나 무엇 `&과 `~? 그것들은 "연산자 인용 부호"이며, 인용 된 연산자와 동등한 함수를 반환합니다. 따라서이 경우 `&와 같습니다 ${ x & y }. 이를 염두에두고이 표현식은 이진 연산자에 대해 다음과 같습니다.

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

이렇게 산출 기능 `~&x, x상기 제 함수의 결과이다. n ~ a의 발생 카운트 n에서를 a. 따라서 함수 1의 계산 된 배열에서 인수의 발생 횟수를 계산하는 함수를 반환합니다.

로 돌아가서 SortBy배열의 각 요소는 배열에 나타나는 횟수만큼 나타납니다.

마지막으로 Last가장 많이 발생하는 요소를 취합니다. 정렬 알고리즘에 의해 연결이 끊어집니다.

자바 스크립트 (ES6), 72 70 바이트

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

온라인으로 사용해보십시오!

숯 , 24 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

Ｗθ

입력 배열이 비어 있지 않은 동안 ...

×⊟θθ

... 마지막 요소를 팝하고 배열의 나머지 부분에 해당 요소를 곱하십시오 ...

Ｆ...⊞υκ

... 결과를 사전 정의 된 빈 목록으로 푸시합니다.

⌈Ｅυ№υλ

각 제품이 목록에 나타나는 횟수를 세고 최대 값을 가져옵니다.

Φυ⁼№υι...

... 그런 다음 개수가 최대 값과 같은 제품을 필터링하십시오.

Ｉ⊟

... 마지막 요소를 팝하고 암시 적 인쇄를 위해 문자열로 캐스트합니다.

껍질 , 7 바이트

Ṡ►#mΠṖ2

온라인으로 사용해보십시오!

설명

Ṡ►#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 바이트

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

온라인으로 사용해보십시오!

암묵적 fn.

암묵적 인 버전과 2 바이트에 대한 Adám에게 감사드립니다.

8 바이트의 ngn에 감사합니다!

방법:

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

• @Shaggy에서 -4 바이트

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

온라인으로 사용해보십시오!

CJam , 70 68 바이트

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

온라인으로 사용해보십시오!

설명

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

코드가 길기 때문에 설명과 설명을 보려면 오른쪽으로 스크롤해야합니다.

이것은 절대 악몽이었다. CJam에는 다른 골프 언어와 달리 파워 셋 기능이 없으므로 수동으로 파워 셋을 찾아야했습니다. 그러나 이것은 powerset 함수를 사용하는 다른 답변과 달리 유효하지 않은 요소를 무시할 수있는 기회를 제공했습니다.

나는 CJam에서 끔찍한 것을 고려할 때 골프를 칠 수 있어야합니다.

변경 사항 :

헬렌 은 2 바이트를 끊었다!

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

1-s를 간단히 변경하면 (동일한 효과를 얻을 수 있지만 더 적은 바이트 수를 갖습니다.

자바 (JDK 10) , 132 바이트

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

온라인으로 사용해보십시오!

하스켈 , 96 94 바이트

^{-2 덕분 바이트 nimi을 (사용하는 sortOn(0<$)대신에 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]

온라인으로 사용해보십시오!

MATLAB 39 바이트

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

또한 Jacob Watson의 답변을 확인하십시오.

SQL Server, 93 바이트

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

입력은 양식의 테이블에서 온 것으로 가정합니다.

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

테이블 인구 예 :

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

설명:

"정수 목록"에 색인이 연결되어 있다고 가정합니다 i. 필자의 경우 열 입니다. 이 열에 a는 목록의 값이 포함됩니다.

왼쪽 쌍이 오른쪽 쌍보다 먼저 목록에 나오는 모든 쌍의 제품을 만듭니다. 그런 다음 제품을 그룹화하고 가장 인구가 많은 숫자로 정렬합니다.

cte 또는 partitioning 절을 사용하지 않아서 조금 슬프지만 너무 길었습니다. SELECT매우 비싼 키워드입니다.

대안, 183 바이트

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

SQL에 별도의 인덱스 열이 없으면 ROW_NUMBER함수를 사용하여 인덱스를 만드는 솔루션이 있습니다. 나는 개인적으로 주문에 관심이 없지만 주문이 필요하며 a열을 사용하는 것이 가장 짧습니다.

CJam , 29 바이트

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

온라인으로 사용해보십시오!

해 학적 인-8 바이트

Jcp)pdn!

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

여기에서 온라인으로 사용해보십시오.

(예, Burlesque에는 "최소 공통 요소"에 대한 명령도 있습니다)

C # (Visual C # 대화식 컴파일러) , 95 바이트

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

온라인으로 사용해보십시오!

덜 골프 코드 :

// 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 바이트

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

명령 행 인수에서 입력을받습니다. 온라인으로 실행 -nr하거나 사용해보십시오 .

STRICT MODE 경고를 피하려면 PHP 7을 사용하십시오.

J, 29 25 24 23 바이트

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

온라인으로 사용해보십시오!

방법

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

apt -h, 11 바이트

à2 ®×Ãü ñÊÌ

시도 해봐

á2 ®×
ñ@è¥X

시도 해봐

APL (NARS), 53 자, 106 바이트

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

테스트:

  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