28

लिस्ट कॉमन मल्टीपल के साथ भ्रमित होने की नहीं ।

एक से अधिक तत्वों के साथ सकारात्मक पूर्णांकों की सूची को देखते हुए, सरणी में दो तत्वों के सबसे सामान्य उत्पाद को लौटाएं।

उदाहरण के लिए, उत्पादों की एक तालिका के रूप में सूची [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 | #  #  #

एमसीएम होने के साथ 6।

एक टाई की स्थिति में, आप किसी भी बंधे हुए तत्व, या उन सभी की एक सूची वापस कर सकते हैं।

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा की जीत के लिए सबसे छोटी बाइट गिनती है!

परीक्षण के मामलों:

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

code-golf array-manipulation

— मजाक कर रहा है
स्रोत

सैंडबॉक्स (हटाए गए)

— जो किंग

5

सुझाया गया परीक्षण मामला: एक जहां सभी तत्व समान हैं (यानी [3,3,3] -> 9)। आपके सभी मौजूदा परीक्षण मामलों के साथ किसी भी जोड़े को फ़िल्टर करना जहां तत्व समान हैं ( [2,3,3]समान मूल्यों वाले परीक्षण मामलों के लिए भी ) अभी भी सही परीक्षण-परिणाम पकड़ेंगे, लेकिन इस परीक्षण मामले के लिए विफल रहेंगे क्योंकि फ़िल्टर करने के बाद कोई भी नहीं रहेगा।

— केविन क्रूज़सेन

@ केविन अच्छा सुझाव, जोड़ा गया

— जो राजा

11

ब्रेकीलॉग , 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

— Fatalize
स्रोत

मुझे नहीं पता कि कोड गोल्फ आमतौर पर कैसे काम करता है, लेकिन मानक 256 कोड बिंदुओं के बाहर इनमें से कुछ वर्ण नहीं हैं और इसलिए प्रत्येक एकाधिक बाइट्स?

— होलोवे

2

@ हेलो ब्रेकीलॉग एक कस्टम कोड पेज का उपयोग करते हैं

— घातक

11

आर , 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।

— किरिल एल।
स्रोत

1

दूसरे पर, आप -1 के लिए उतरते = TRUE के बजाय -table () का उपयोग कर सकते हैं। मैं वास्तव में पहले वाले की चतुराई पसंद करता हूं। संपादित करें: बस एहसास हुआ कि आप इसे -4 के लिए पहले वाले पर भी लागू कर सकते हैं, इसलिए ऐसा है। इसे ऑनलाइन आज़माएं!

— क्रिमिनल

1

combn(scan(),2,prod)उपयोग करने के बजाय काम करता हैapply

— Giuseppe

8

जेली , 6 बाइट्स

ŒcP€Æṃ

इसे ऑनलाइन आज़माएं!या परीक्षण सूट की जाँच करें ।

यह काम किस प्रकार करता है

ŒcP € Æṃ - पूर्ण कार्यक्रम / मौद्रिक लिंक।
Œc - बिना प्रतिस्थापन के अनियंत्रित जोड़े।
  P € - प्रत्येक का उत्पाद।
    Most - मोड (सबसे आम तत्व)।

वैकल्पिक: :cZPÆṃ

— श्री Xcoder
स्रोत

7

पायथ, 12 बाइट्स

eo/QN=*M.cQ2

परीक्षण सूट

पहले, हम प्रतिस्थापन के बिना इनपुट के सभी 2 तत्व संयोजन लेते हैं ( .cQ2)। फिर, हम इनमें से प्रत्येक जोड़े को उनके उत्पाद ( *M) में मैप करते हैं । अगला, हम उत्पादों की सूची के साथ इनपुट चर को ओवरराइट करते हैं ( =)। अगला, हम उत्पादों की सूची में घटनाओं की संख्या से उत्पादों की सूची को सॉर्ट करते हैं ( o/QN)। अंत में, सॉर्ट की गई सूची का अंतिम तत्व ( e) लें।

— isaacg
स्रोत

7

MATL , 8 7 बाइट्स

2XN!pXM

इसे ऑनलाइन आज़माएं!

(@Mr। Xcoder के जेली उत्तर से विधि का उपयोग करके -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

— sundar - मोनिका को बहाल करना
स्रोत

6

05AB1E , 8 6 बाइट्स

æ2ùP.M

-2 बाइट्स @Kaldo को धन्यवाद ।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

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

— केविन क्रूज़सेन
स्रोत

1

6 बाइट्स के लिए æ2ùP.M

— Kaldo

@ बाल्डो धन्यवाद! पूरी तरह से भूल गया ù।

— केविन क्रूज़सेन

6

गणितज्ञ, 32 बाइट्स

^{-17 बाइट्स (और एक फिक्स) जुंगहवन मिन को धन्यवाद ।}

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

शुद्ध कार्य। इनपुट के रूप में संख्याओं की सूची लेता है और आउटपुट के रूप में एमसीएम की सूची देता है।

— LegionMammal978
स्रोत

दरअसल ऐसा लग रहा है कि हम दोनों ने इस सवाल को गलत बताया है। यह इनपुट के लिए विफल है {3, 3, 3}। निश्चित:Commonest[1##&@@@#~Subsets~{2}]&

— जंगवान मिन

@ जुंगह्वानिन हं। मैंने सोचा था कि Subsetsअलग-अलग तत्वों के रूप में दोहराता नहीं है। ऐसा लगता है जैसे यह करता है, इसलिए धन्यवाद!

— लीजियनममाल 978

5

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

— जैकब वॉटसन
स्रोत

1

मुझे यकीन नहीं है कि आपको ऐसा करने की आवश्यकता है I'*I*1-eyeक्यों नहीं I'*I-eye?

— आआआआ कहते हैं कि मोनिका

5

पर्ल 6 , 41 38 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— nwellnhof
स्रोत

क्या आप मुझे समझा सकते हैं (या मुझे डॉक्स की ओर इशारा करते हैं) कॉलन वहां क्या कर रहे हैं? मैं काफी हद तक इसे नहीं बना सकता ... मैं देख सकता हूँ कि इसके पास तर्क पारित करने के लिए कुछ है लेकिन इससे अधिक कुछ नहीं।

— रामलीज 22

1

@Ramillies यह infix: ऑपरेटर है।

— nwellnhof

ओह समझा। धन्यवाद।

— Ramillies

4

स्टैक्स , 12 10 बाइट्स

╢êv^⌐ö►♣Ä»

इसे चलाएं और डीबग करें

— व्यर्थ का
स्रोत

4

पायथन 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)

इसे ऑनलाइन आज़माएं!

— OVS
स्रोत

4

अटैची , 59 बाइट्स

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

इसे ऑनलाइन आज़माएं!

अभी भी यह थोड़ा नीचे गोल्फिंग पर काम कर रहा है, लेकिन मुझे लगता है कि यह मेरे द्वारा चुने गए दृष्टिकोण के लिए इष्टतम है।

व्याख्या

यह तीन कार्यों की एक रचना है:

{Flat[UpperTriangle&1!Table&_!`*]^^0}
SortBy#`&&:`~
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&nयह एक फ़ंक्शन है, जिसे जब तर्क के साथ बुलाया जाता है ...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वह तत्व लेता है जो सबसे अधिक होता है। टाईस को एल्गोरिथ्म द्वारा छांटा जाता है।

— कोनोर ओ ब्रायन
स्रोत

क्या अपरट्रेलंगल पार्ट की आवश्यकता है? क्या आप केवल टेबल को समतल कर सकते हैं और सॉर्ट कर सकते हैं?

— svavil

@svavil हाँ, यह आवश्यक है; [5, 2, 9, 10, 3, 4, 4, 4, 7] -> 16इसके बजाय इसके 20बिना।

— कॉनर ओ'ब्रायन

4

जावास्क्रिप्ट (ईएस 6), 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

इसे ऑनलाइन आज़माएं!

— Arnauld
स्रोत

@tsh समस्या मुख्य विकर्ण है, जहां गुणकों को बिल्कुल भी नहीं गिना जाना चाहिए। इसलिए यह उस प्रचलित परीक्षण मामले के लिए विफल है जिसमें तीन हैं

16

$16$ मुख्य विकर्ण पर, अपने स्कोर को उच्च लाने के लिए अपेक्षित के बजाय वापस आ गया

20

$20$ ।

— अरनौलद

3

चारकोल , 24 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｗθ

जबकि इनपुट सरणी गैर-रिक्त है ...

×⊟θθ

... पिछले तत्व को पॉप करें और उस तत्व द्वारा बाकी सरणी को गुणा करें ...

Ｆ...⊞υκ

... और परिणामों को पूर्वनिर्धारित खाली सूची में धकेल दें।

⌈Ｅυ№υλ

प्रत्येक उत्पाद सूची में दिखाई देने और अधिकतम लेने की संख्या की गणना करें ...

Φυ⁼№υι...

... फिर उन उत्पादों के लिए फ़िल्टर करें जिनकी गिनती उस अधिकतम के बराबर है ...

Ｉ⊟

... तो अंतिम तत्व पॉप और अंतर्निहित प्रिंट के लिए स्ट्रिंग करने के लिए।

— नील
स्रोत

3

भूसी , 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]

— ბიმო
स्रोत

3

एपीएल (डायलॉग यूनिकोड) , 29 27 19 बाइट्स

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

इसे ऑनलाइन आज़माएं!

टैसीट एफएन।

टैटिट संस्करण और 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.

— जे। सल्ल
स्रोत

1

यह केवल 27 है ।

— अड्म

3

जाप , 20 16 बाइट्स

@ बग्घी से -4 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— लुइस फेलिप डी जीसस मुनोज
स्रोत

16 बाइट्स

— झबरा

3

सीजेएम , 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 में एक पॉवरसेट फंक्शन नहीं है (अन्य गोल्फ भाषाओं के एक टन के विपरीत - मेरी तरफ से बढ़िया विकल्प), जिसका मतलब है कि मुझे मैन्युअल रूप से पॉवरसेट ढूंढना था। हालांकि, इसने मुझे एक पावरसेट फ़ंक्शन के साथ अन्य उत्तरों के विपरीत, किसी भी अमान्य संख्या को अनदेखा करने का अवसर दिया।

यह गोल्फ का होना चाहिए, यह देखते हुए कि मैं सीजेएम में भयानक हूं।

परिवर्तन:

हेलेन 2 बाइट्स काट दिया!

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

1-एस बदलने से बस (हमें एक ही प्रभाव मिलता है लेकिन कम बाइट गिनती के साथ।

— हेलेन
स्रोत

2

जावा (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;}

इसे ऑनलाइन आज़माएं!

— ओलिवियर ग्रेजायर
स्रोत

2

हास्केल , 96 94 बाइट्स

^{-2 बाइट्स नीमी ( 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]

इसे ऑनलाइन आज़माएं!

— ბიმო
स्रोत

2

MATLAB 39 बाइट्स

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

साथ ही जैकब वॉटसन का जवाब भी देखें

— आआआआ कहती है मोनिका को बहाल करो
स्रोत

1

दूसरी पंक्ति होने b=triu(a'*a,1);से 4 बाइट बचती हैं।

— सूंदर -

ओह @sundar स्नैप, तुम ठीक कह रहे :) मैं था triuशुरू में लेकिन दूर किसी भी तरह हो गए

— aaaaa कहते ही पुन: स्थापित मोनिका

अच्छा समाधान, मुझे एहसास नहीं था कि ऊपरी त्रिकोण फ़ंक्शन बहुत छोटा था!

— जैकब वॉटसन

2

SQL सर्वर, 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 या विभाजन खंड का उपयोग करने के लिए नहीं मिला, लेकिन वे अभी बहुत लंबे थे। 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कॉलम का उपयोग करना सबसे कम है।

— ब्रायन जे
स्रोत

2

सीजेएम , 29 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— आउटग्रॉफर को एरिक करें
स्रोत

2

बर्लेस्क - 8 बाइट्स

Jcp)pdn!

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

इसे यहाँ ऑनलाइन आज़माएँ।

(और हाँ, बर्लेस्क के पास "कम से कम सामान्य तत्व" के लिए एक कमांड भी है)

— mroman
स्रोत

2

सी # (विज़ुअल सी # इंटरएक्टिव कंपाइलर) , 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

— दाना
स्रोत

1

PHP, 91 बाइट्स

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

कमांड लाइन तर्कों से इनपुट लेता है; साथ चलाएं -nrयाइसे ऑनलाइन प्रयास करें ।

स्ट्रिप मोड मोड से बचने के लिए PHP 7 का उपयोग करें।

— टाइटस
स्रोत

1

जे, २ ९ २५ २४ २३ बाइट्स

(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

— जोनाह
स्रोत

1

जाप `-h`, 11 बाइट्स

à2 ®×Ãü ñÊÌ

कोशिश करो

á2 ®×
ñ@è¥X

कोशिश करो

— झबरा
स्रोत

0

एपीएल (एनएआरएस), 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

— RosLuP
स्रोत

सबसे आम कई

परीक्षण के मामलों:

ब्रेकीलॉग , 11 बाइट्स

व्याख्या

आर , 54 50 41 बाइट्स

जेली , 6 बाइट्स

यह काम किस प्रकार करता है

पायथ, 12 बाइट्स

MATL , 8 7 बाइट्स

8 बाइट्स

05AB1E , 8 6 बाइट्स

गणितज्ञ, 32 बाइट्स

MATLAB, 43 बाइट्स

पर्ल 6 , 41 38 बाइट्स

स्टैक्स , 12 10 बाइट्स

पायथन 3 , 77 72 बाइट्स

अटैची , 59 बाइट्स

व्याख्या

जावास्क्रिप्ट (ईएस 6), 72 70 बाइट्स

चारकोल , 24 बाइट्स

भूसी , 7 बाइट्स

व्याख्या

एपीएल (डायलॉग यूनिकोड) , 29 27 19 बाइट्स

किस तरह:

जाप , 20 16 बाइट्स

सीजेएम , 70 68 बाइट्स

व्याख्या

परिवर्तन:

जावा (JDK 10) , 132 बाइट्स

हास्केल , 96 94 बाइट्स

MATLAB 39 बाइट्स

SQL सर्वर, 93 बाइट्स

वैकल्पिक, 183 बाइट्स

सीजेएम , 29 बाइट्स

बर्लेस्क - 8 बाइट्स

सी # (विज़ुअल सी # इंटरएक्टिव कंपाइलर) , 95 बाइट्स

PHP, 91 बाइट्स

जे, २ ९ २५ २४ २३ बाइट्स

किस तरह

जाप -h, 11 बाइट्स

एपीएल (एनएआरएस), 53 चार्ट, 106 बाइट्स

जाप `-h`, 11 बाइट्स