En Küçük Ortak Çoklu ile karıştırılmamalıdır .

Birden fazla elemana sahip pozitif tamsayıların bir listesi göz önüne alındığında, dizideki iki öğenin en yaygın ürününü döndürün.

Örneğin, liste MCM [2,3,4,5,6]olan 12bir ürün tablosu olarak:

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

Tablo için teşekkürler DJMcMayhem

As 12en çok (iki kat daha görünür 2*6ve 3*4). Bir öğenin ürününü ve kendisinin dahil etmediğimizi, bu listede görünmediğini 2*2veya 4*4görünmediğini unutmayın. Bununla birlikte, aynı elemanlar hala çarpılacaktır, bu nedenle [2,3,3]aşağıdaki gibi görünüyor:

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

MCM ile 6.

Beraberlik durumunda, bağlı öğelerin herhangi birini veya bunların bir listesini geri verebilirsiniz.

• Bu kod golf , yani her dil için en kısa bayt sayısı kazanıyor!

Test-vaka:

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

{⊇Ċ×}ᶠọtᵒth

Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi deneyin!

Alternatif olarak, 54 53 44 bayt için:

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

Çevrimiçi deneyin!

Prensip olarak, ikinci versiyon, namesfonksiyonun olmadığı durumlarda bile ilgili sonucu verir , ancak bunun için en sık rastlanan ürünlerin sayısı ...

-4 ve -1 için CriminallyVulgar'a ve her ikisinde de -9 için Giuseppe'ye teşekkür ederiz.

Jöle , 6 bayt

ŒcP€Æṃ

Çevrimiçi deneyin! veya Test odasına bakın .

Nasıl çalışır

ŒcP € Æṃ - Tam program / Monadic bağlantısı.
Œc - Değiştirilmeden sıralanmamış çiftler.
  P € - Her birinin ürünü.
    Æṃ - Mod (en yaygın eleman).

Alternatif: ŒcZPÆṃ

Pyth, 12 bayt

eo/QN=*M.cQ2

Test odası

Öncelikle, girişin tüm 2 eleman kombinasyonunu değiştirmeden alıyoruz (.cQ2 ). Daha sonra, bu çiftlerin her birini ürünlerine eşleriz ( *M). Daha sonra, girdi değişkeninin ürünler listesiyle ( =) üzerine yazıyoruz . Ardından, ürünler listesini ürünler listesindeki oluşum sayısına göre sıralarız ( o/QN). Son olarak, sıralanmış listenin ( e) son elemanını alın .

MATL , 8 7 bayt

2XN!pXM

Çevrimiçi deneyin!

(@Mr. Xcoder'in Jelly cevabındaki yöntemi kullanarak -1 bayt .)

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

Daha eski cevap:

8 bayt

&*XRXzXM

Çevrimiçi deneyin!

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

æ2ùP.M

@Kaldo sayesinde -2 bayt .

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

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

^{- JungHwan Min sayesinde -17 bayt (ve bir düzeltme) .}

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

Saf işlevi. Girdi olarak sayıların bir listesini alır ve çıktı olarak MCM'lerin listesini döndürür.

MATLAB, 43 bayt

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

Aynı zamanda bir tür dil twister!

açıklama

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 bayt

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

Çevrimiçi deneyin!

Stax , 12 10 bayt

╢êv^⌐ö►♣Ä»

Koş ve hata ayıkla

Python 3 , 77 72 bayt

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

Çevrimiçi deneyin!

ataşe , 59 bayt

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

Çevrimiçi deneyin!

Hala biraz aşağı golf oynamaya devam ediyorum, ancak bence bu seçtiğim yaklaşım için en uygun olanı.

açıklama

Bu üç fonksiyonun bir bileşimidir:

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

İlk işlev, hesaplamanın büyük bölümünü yapar:

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

İkincisi biraz karışık ama oldukça basit bir şey yapıyor. İlk olarak, bunun f&nargümanlarla çağrıldığında ...xdöndüğü bir fonksiyon olduğunu bilmek faydalıdır f[...x, n]. f&:nbenzer, dönen f[n, ...x]. Şimdi şunu çözelim:

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

İlk önce, f#gbir çatal oluşturur. Giriş ile ngeri döner f[n, g[n]]. Ancak, bu durumda, fişlevdir ~SortBy. ~fişlevin argümanlarını tersine çevirir. Bu , buna veya buraya ~f#geşdeğer anlamına gelir .f[g[n], n]SortBy[(`& &: `~)[n], n]

`& &: `~formu takip eder f&:n. Ama ne `&ve `~? Bunlar "operatör fiyatları" dır ve belirtilen operatöre eşdeğer bir işlev döndürürler. Yani, bu durumda, `&aynı şeydir ${ x & y }. Bunu akılda tutarak, bu ifade ikili operatörler için aşağıdakine eşittir:

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

Bu fonksiyon elde edilir `~&x, xilk işlevi sonucudur. n ~ atekrarlarını sayar nina . Böylece, bu, hesaplanan dizideki argümanın oluşumunu işlev 1'den sayan bir işlev döndürür.

Geri dönüyor SortBy , dizideki her öğe içinde göründüğü sayısına göre .

En sonunda, Last en çok meydana gelen elemanı alır. Bağlar, sıralama algoritmasıyla bozulur.

JavaScript (ES6), 72 70 bayt

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

Çevrimiçi deneyin!

Kömür , 24 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

Ｗθ

Giriş dizisi boş değilken ...

×⊟θθ

... son öğeyi aç ve dizinin geri kalanını bu öğeyle çarp ...

Ｆ...⊞υκ

... ve sonuçları önceden tanımlanmış boş listeye itin.

⌈Ｅυ№υλ

Her ürünün listede göründüğü sayıyı sayın ve maksimumda ...

Φυ⁼№υι...

... sonra sayısı maksimum olan ürünlere filtre uygulayın ...

Ｉ⊟

... sonra son öğeyi açın ve örtük baskı için dizgiye aktarın.

Kabuğu , 7 bayt

Ṡ►#mΠṖ2

Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi deneyin!

Yapışkanlık fn.

Taktik sürüm ve 2 bayt için Adám'a teşekkürler.

8 bayt için ngn teşekkürler!

Nasıl:

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

• @Shaggy'den -4 bayt

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

Çevrimiçi deneyin!

CJam , 70 68 bayt

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

Çevrimiçi deneyin!

açıklama

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

Açıklamaları yanı sıra kod oldukça uzun olduğu için açıklamaları görmek için sağa kaydırmanız gerekir.

Bu yazmak için mutlak bir kabus oldu. CJam'ın bir powerset işlevi yok (diğer golf dillerinin aksine - benim açımdan harika bir seçim), yani powerset'i manuel olarak bulmak zorunda kaldım. Bununla birlikte, bu bana güç işlevli diğer cevapların aksine geçersiz sayısız faktörü göz ardı etme fırsatı verdi.

CJam'da korkunç olduğum düşünülürse, bu golf oynanabilir olmalı.

değişiklikler:

Helen 2 byte kesti!

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

1-S yi değiştirerek basitçe (aynı etkiyi elde ederiz, fakat daha düşük byte sayısı ile

Java (JDK 10) , 132 bayt

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

Çevrimiçi deneyin!

Haskell , 96 94 bayt

^{Nimi sayesinde -2 bayt ( sortOn(0<$)yerine kullanmak yerine 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]

Çevrimiçi deneyin!

MATLAB 39 bayt

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

Ayrıca Jacob Watson tarafından verilen cevaba da bakın.

SQL Server, 93 bayt

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

Giriş formun bir tablodan geldiği varsayılmaktadır

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

Örnek tablo popülasyonu:

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

Açıklama:

Bir "tamsayı listesi" nin, benim durumumda sütun olan bir indekse sahip olacağını varsayıyorum i. Sütun alistenin değerlerini içerir.

Soldaki çiftin listeden sağdaki çiftten daha önce geldiği her çiftin ürünlerini oluşturuyorum. Daha sonra ürün üzerinde grupladım ve en kalabalık sayıya göre sıraladım.

Biraz üzgünüm, herhangi bir cte veya bölümleme cümlesini kullanamadım, ama onlar çok uzundu. SELECTçok pahalı bir anahtar kelimedir.

Alternatif, 183 bayt

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

Eğer SQL ayrı bir indeks sütununa sahip olmazsa, işte ROW_NUMBERfonksiyonu kullanarak bir indeks oluşturduğum bir çözüm . Şahsen sipariş umrumda değil, ama bir emir gerekiyor ve asütunu kullanmak en kısa yol.

CJam , 29 bayt

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

Çevrimiçi deneyin!

Burlesque - 8 bayt

Jcp)pdn!

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

Burada çevrimiçi deneyin.

(ve evet, Burlesque'in ayrıca "en az kullanılan element" komutunu da vardır)

C # (Visual C # Etkileşimli Derleyici) , 95 bayt

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

Çevrimiçi deneyin!

Daha az golf kodu:

// 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 bayt

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

komut satırı argümanlarından girdi alır; çevrimiçi olarak koş -nrveya dene .

STRICT MODE uyarısından kaçınmak için PHP 7'yi kullanın.

J, 29 25 24 23 bayt

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

Çevrimiçi deneyin!

Nasıl

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

à2 ®×Ãü ñÊÌ

Dene

á2 ®×
ñ@è¥X

Dene

APL (NARS), 53 karakter, 106 bayt

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

Ölçek:

  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