अद्वितीय जुड़वा बच्चों को खोजें

28

आपको गैर-ऋणात्मक पूर्णांकों A और B के दो एरे / लिस्ट / क्षेत्र दिए जाएंगे । आपका कार्य उच्चतम पूर्णांक एन को आउटपुट करना है जो ए और बी दोनों में दिखाई देता है , और ए और बी दोनों में भी अद्वितीय है ।

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

ए, बी -> आउटपुट

[६], [१, ६] -> ६
[१, २, ३, ४], [४, ५, ६,>] -> ४
[0, 73, 38, 29], [38, 29, 73, 0] -> 73
[1, 3, 4, 6, 6, 9], [8, 7, 6, 3, 4, 3] - 4
[२, २, २, ६, ३, ५, 2, २], [2, 2, ५, -] - ५
[१२, १ ९, १ 18, २, ९, १ ९, १ [], [१२, १ ९, १ 18, १ 18, १ 18, २ 28 ९]> १ ९
[१ 39, २ ९, ३ ९, २ ९, २ ९, ३ ९, १ [], [१ ९, १ ९, १ 39, २०, १ 39, १>] -> १ 39
[१ 39, २ ९, ३ ९, २ ९, २ ९, ३ ९, १ 39, १ [], [१ ९, १ ९, १ 39, २०, १ 39, १ 39, १ 39 -> १ 39
code-golf  number  array-manipulation  integer 
— श्री Xcoder
स्रोत

जवाबों:

7

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

fċ@ÐṂ;Ṁ

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

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

fċ@ÐṂ;Ṁ  Main link. Left argument: A. Right argument: B

f        Filter; keep those elements of A that appear in B.
   ÐṂ    Yield all elements of the result for which the link to left yields a
         minimal value (2).
 ċ@        Count the occurrences of the element...
     ;     in the concatenation of A and B.
      Ṁ  Take the maximum.
— डेनिस
स्रोत
7

बैश + कोरुटिल्स, 49 बाइट्स

U()(sort -rn|uniq -u$1)
(U<<<$1;U<<<$2)|U D|sed q

1 बाइट को बंद करने के लिए @seshoumara को धन्यवाद!

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

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

uniq क्रमबद्ध इनपुट लेता है और कमांड-लाइन झंडे के आधार पर एक या कई क्रियाएं करता है।

U<<<$1और इनपुट के रूप में पहले और दूसरे कमांड-लाइन तर्क के साथ U<<<$2फ़ंक्शन Uको कॉल करें । प्रत्येक के लिए, sort -rn|uniq -uनिष्पादित किया जाता है, इनपुट को संख्यात्मक रूप से ( -n) और अवरोही क्रम में ( -r) uniq के लिए छांटा जाता है , जो केवल अनूठी पंक्तियों ( -u) को प्रिंट करेगा ।

दोनों के उत्पादन (प्रत्येक सरणी के अद्वितीय तत्व) को संघटित और पाइप किया जाता है U D, अर्थात
sort -rn|uniq -uD। इस समय, यूनीक केवल डुप्लिकेट लाइनें ( -D) प्रिंट करेगा , और प्रत्येक का केवल पहला दोहराव होगा।

जबकि मैन पेज कहता है कि यह सभी पुनरावृत्तियों को प्रिंट करेगा, जोड़े गए -uकारणों -Dको केवल डुप्लिकेट लाइनों की पहली घटना को प्रिंट करना होगा। यह व्यवहार सामान्य रूप से प्राप्त होता है uniq -d।

अंत में, sed qअपनी पहली पंक्ति में इसके इनपुट (दोनों सरणियों के अनूठे तत्व) को कम करते हुए, तुरंत छोड़ देता है। चूंकि उत्पादन अवरोही क्रम में क्रमबद्ध था, इसलिए यह अधिकतम है।

— डेनिस
स्रोत
6

अजगर, 12 9 बाइट्स

कोशिश करो

eS@Fm.m/d

श्री Xcoder के लिए 3 बाइट्स सहेजे गए।

व्याख्या

eS@Fm.m/d
    m  /d   Count the occurrences of each element.
     .m     Take only those that appear the minimum number of times.
  @F        Apply the above to A and B and take the intersection.
eS          Take the largest.
अच्छा! मेरा समाधान भी 12 बाइट्स था ।
— श्री एक्सकोडर
मेरे समाधान को थोड़ा नीचे करके , 9 बाइट्स (उपयोग करके eS@Fm.m/d) और दो सूचियों की सूची के रूप में इनपुट लेना।
— श्री एक्सकोडर
@ Mr.Xcoder जो अपने जवाब होने के लिए अलग-अलग लगता है।
चूंकि मैं चुनौती का ओपी हूं, इसलिए मैं इसे पोस्ट करने को लेकर अनिच्छुक हूं। आप बस इसका उपयोग कर सकते हैं और क्रेडिट दे सकते हैं, अपने वर्तमान दृष्टिकोण को एक विकल्प के रूप में उल्लेख कर सकते हैं (यदि आप चाहते हैं)
— श्री Xcoder
6

पायथन 3 , 61 56 54 बाइट्स

7 बाइट्स का धन्यवाद @ Mr.Xcoder , @ pizzapants184 और @ovs को दिया

lambda a,b:max(f*(a.count(f)==b.count(f)<2)for f in a)

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

— हलवार्ड वुल्म
स्रोत
मुझे एक मिनट से हराया!
— १२:११ बजे pizzapants184
— pizzapants184
— श्री एक्सकोडर
— ओव्स
5

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

→►≠OfEΠ

इनपुट को दो सूचियों की सूची के रूप में लेता है, किसी भी संख्या में सूचियों के लिए भी काम करता है (उच्चतम संख्या लौटाता है जो प्रत्येक में एक बार होता है, यदि संभव हो तो)। इसे ऑनलाइन आज़माएं!

व्याख्या

यह (एबीएस) नए "अधिकतम" फ़ंक्शन का उपयोग करने वाला पहला उत्तर है ►।

→►≠OfEΠ  Implicit input, say [[3,2,1,3],[1,2,3,4]]
      Π  Cartesian product: [[3,1],[2,1],[3,2],[2,2],[1,1],[3,3],[1,2],[3,1],[3,4],[2,3],[1,3],[3,2],[2,4],[3,3],[1,4],[3,4]]
    fE   Keep those that have equal elements: [[2,2],[1,1],[3,3],[3,3]]
   O     Sort: [[1,1],[2,2],[3,3],[3,3]]
 ►≠      Find rightmost element that maximizes number of other elements that are not equal to it: [2,2]
→        Take last element: 2
— Zgarb
स्रोत
4

बैश + कोरुटिल्स, 60 बाइट्स

f()(sort -rn<<<"$1"|uniq -u);grep -m1 -wf<(f "$1") <(f "$2")

यह ऑनलाइन की कोशिश करो

बैश, 89 बाइट्स

c()(for e;{((e^$1||r++,2^r));});for x in $1 $2;{((x<r))||c $x $1||c $x $2||r=$x;};echo $r

TIO

— नहुएल फौलीउल
स्रोत
1
1 बाइट दाढ़ी के बजाय अंत में sort -rnसाथ प्रयोग करें । Btw के साथ महान पाते हैं । +1sed qtail -1grep -wf
— शीशमारा
@ शीशमौरा, आपको टिप के लिए धन्यवाद, वास्तव में -m1 grep विकल्प के साथ मैं 3 बाइट शेव कर सकता हूं।
— नहुएल फौलीउल
3

जे, 23 बाइट्स

>./@([-.-.)&(-.-.@~:#])

(-.-.@~:#]) किसी भी दोहराया तत्वों की सूची से निकाल देता है

& दोनों के लिए यह करो

([-.-.) हम एक प्रतिच्छेदन बी चाहते हैं। यह समकक्ष वाक्यांश है: "ए माइनस (ए माइनस बी)"

>./ अधिकतम ले लो

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

— जोनाह
स्रोत
समान रूप से, आप चौराहे के हिस्से को बदल सकते हैं e.~#]। यह कठिन साबित हो रहा है ... मैंने /.बिना किसी सफलता के -key का उपयोग करने की कोशिश की ( ((1=#)/.~#~.)पहले भाग के लिए जो मेरी गिनती से 2 बाइट्स लंबा है)
— कोल
@cole, हाँ, मैंने एक प्रमुख दृष्टिकोण की कोशिश की और साथ ही आत्म-वर्गीकरण के साथ भी। हालांकि मैं किसी भी अन्य दृष्टिकोण के साथ अपने सबमिशन को हरा नहीं सका।
— जोनाह
2

पॉवरशेल , 94 बाइट्स

param($a,$b)filter f($x){$x|group|?{$_.count-eq1}}
(f($a|sort|?{$_-in((f $b).Name)}))[-1].Name

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

इनपुट $aऔर $bसरणियों के रूप में लेता है । एक निर्माण करती है filterकि groupइनपुट सरणी तत्व एक साथ है और केवल एक साथ उन लोगों के बाहर खींचती है count -eqकरने के लिए UAL 1(यानी, केवल उन है कि इनपुट सरणी में अद्वितीय हैं)।

अगली पंक्ति एल्गोरिथ्म का निर्माण करती है। पहले हम sort $a, फिर उन -inचीजों को बाहर निकालते हैं जो अद्वितीय वस्तुएं हैं $b। फिर वे खुद अनोखे-आइफाइड होते हैं, सबसे बड़ा [-1]चुना जाता है, और हम इसे लेते .Nameहैं। यह पाइपलाइन पर छोड़ दिया गया है और आउटपुट निहित है।

— AdmBorkBork
स्रोत
2

जावास्क्रिप्ट (ईएस 6), 102 86 75 71 बाइट्स

a=>b=>Math.max(...a.map(e=>(g=x=>x.map(y=>y-e||x--,x=1)|!x)(a)*g(b)*e))

धन्यवाद @justinMariner 102 से 86 के लिए पाने के लिए

86 से 75 प्राप्त करने के लिए @tsh धन्यवाद

धन्यवाद @ अरनल्ड को 75 से 71 तक मिलने के लिए

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

— नैट
स्रोत
PPCG में आपका स्वागत है! जहाँ तक मुझे इस बताने लगता है कि नहीं है के रूप में eशो केवल एक बार aऔर b।
— मार्टिन एंडर
@MartinEnder धन्यवाद! मेरे द्वारा बताए गए विवरण को प्रतिबिंबित करने के लिए उत्तर संपादित करें!
— नैट
1
मैंने कभी इस lastIndexOfतरह का उपयोग करने के बारे में नहीं सोचा , यह बहुत चालाक है। आप इसे 86 बाइट्स तक प्राप्त कर सकते हैं: इसे ऑनलाइन आज़माएं! । अधिक के लिए जेएस युक्तियों की जांच करें ।
— जस्टिन मैरीनर
1
ऐसा लगता है कि उपयोग (g=x=>x.filter(y=>y==e).length==1)करना कम है।
— tsh
1
मुझे लगता है कि यह भी सभी किनारे मामलों (71 बाइट्स) से गुजर रहा है।
— Arnauld
2

हास्केल , 57 53 बाइट्स

x?y|let v!x=filter(==v)x==[v]=maximum[a|a<-x,a!x,a!y]

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

UPD: धन्यवाद @ लाईकोनी

— user28667
स्रोत
विशेष रूप से PPCG और हास्केल गोल्फ में आपका स्वागत है! यह एक अच्छा पहला जवाब है! दो छोटी-छोटी बातें: आप fइनफ़िक्स ऑपरेटर के रूप में भी घोषणा कर सकते हैं और कुछ बाइट्स को बचाने के [1|...]==[1]बजाय लिख सकते हैं sum[1|...]==1।
— लकोनी
यदि आपने उन्हें पहले से नहीं देखा है, तो यहां कुछ लिंक दिए गए हैं जो दिलचस्प हो सकते हैं: हास्केल में गोल्फिंग टिप्स का हमारा संग्रह , हास्केल में गोल्फिंग नियमों का मार्गदर्शक और मोनाड्स और मेन , हमारा हास्केल चैट रूम।
— लकोनी
1
इन-अस्तर !के साथ andदो और बाइट्स की बचत होती है: यह ऑनलाइन कोशिश करो!
— लैकोनी
2

वोल्फ्राम भाषा (गणितज्ञ) , 40 बाइट्स

Max@Cases[Tally@#⋂Tally@#2,{x_,1}:>x]&

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

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

Tally@#पहले इनपुट के अनूठे तत्वों की सूची देता है, साथ में उनकी गणना: जैसे, Tally[{2,2,2,6,3,5,8,2}]पैदावार {{2,4},{6,1},{3,1},{5,1},{8,1}}।

Tally@#2दूसरी सूची के लिए भी ऐसा ही है, और ⋂दोनों में मौजूद जोड़े को खोजता है। फिर हम प्रत्येक परिणाम के पहले तत्व को लेते हुए Casesसमाप्त होने वाले ( जोड़े) जोड़े जाते हैं 1, जो हमें सभी अद्वितीय जुड़वा बच्चों की सूची देता है। अंत में, Maxसबसे बड़ा अनोखा जुड़वाँ रिटर्न देता है।

— मिशा लावरोव
स्रोत
2

रोड़ा , 48 बाइट्स

{m={|n|sort|count|[_]if[_=n]};[_()|m 1]|m 2|max}

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

Jq170727 के jq उत्तर से प्रेरित ।

स्पष्टीकरण:

{ /* Anonymous function, takes input from the stream */
  m={|n|        /* Local function m with parameter n: */
    sort|count| /*   Count unique values in the stream */
    [_]if[_=n]  /*   For each value, push it to the stream if its count is n */
  };
  [      /* For each list in the stream: */
    _()| /*   Flat it (push its values to the stream) */
    m 1  /*   Push values that appear only once to the stream */
  ]|
  m 2|   /* Push values that appear twice to the stream */
  max    /* Find the max value in the stream */
}
— fergusq
स्रोत
2

एफ # (.NET कोर) , 117 115 114 111 108 बाइट्स

115 114 बाइट्स

countByइस समय के साथ एक और समाधान :

let u x=x|>Seq.countBy id|>Seq.filter(fun a->snd a=1)|>Seq.map fst|>set
let f x y=Set.intersect(u x)(u y)|>Seq.max

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

117 111 बाइट्स

let u x=x|>Seq.filter(fun a->x|>Seq.filter((=)a)|>Seq.length=1)|>set
let f x y=Set.intersect(u x)(u y)|>Seq.max

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

100% F #! किसी भी मदद का स्वागत है!

6 बाइट ने उपसर्ग संकेतन के लिए धन्यवाद जीता!

108 बाइट्स

let f a b=Set.intersect(set a)(set b)|>Seq.filter(fun x->a@b|>Seq.filter(fun y->y=x)|>Seq.length<3)|>Seq.max

@अवतल कार्य है! इस एल्गोरिथम के लिए @ Ayb4btu धन्यवाद।

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

— aloisdg का कहना है कि मोनिका को बहाल करें
स्रोत
2

सी # (.NET कोर) , 85 84 बाइट्स

x=>y=>x.Where(a=>x.Count(b=>b==a)<2).Intersect(y.Where(a=>y.Count(b=>b==a)<2)).Max()

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

LINQ के साथ Naive सोल्यूशन ( using System;using System.Linq;हेडर के साथ 31 बाइट्स तो 116 बाइट्स)

84! मैं कराहना भूल गया!

— aloisdg का कहना है कि मोनिका को बहाल करें
स्रोत
2

पिप , 17 16 बाइट्स

MX{_Na=_Nb=1FIa}

यह एक ऐसा कार्य है जो दो सूचियों को तर्क के रूप में लेता है। इसे ऑनलाइन आज़माएं!

व्याख्या

  {            }  Define function, args are a & b:
            FIa    Filter elements of a on this function:
   _Na              Count of element in a
      =_Nb          equals count of element in b
          =1        equals 1
                  This gives a function that returns a list of unique twins
MX                Modify it to take the max and return that instead
— DLosc
स्रोत
2

APL (Dyalog) , 18 वर्ण = 23 बाइट्स *

एक पूर्ण कार्यक्रम निकाय। एसटीडीआईएन से सूचियों की सूची के लिए संकेत। किसी भी सूची के साथ काम करता है। STDOUT में आउटपुट।

⌈/∊∩/{⊂⍺⍴⍨1=≢⍵}⌸¨⎕

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

⎕ STDIN से मूल्यांकन किए गए इनपुट के लिए संकेत

{...}⌸¨  प्रत्येक सूची के लिए, उस सूची के प्रत्येक अद्वितीय तत्व के लिए निम्न फ़ंक्शन को बाएं तर्क ( ⍺) और उसके तर्क के सूचकांकों की सूची को सही तर्क ( ⍵) के रूप में उपयोग करते हैं:

 ≢⍵ सूचकांकों की संख्या (यानी घटनाओं की संख्या)

 1= 1 के बराबर

 ⍺⍴⍨ विशिष्ट तत्व को फिर से देखने के लिए इसका उपयोग करें (अर्थात यदि गैर-अद्वितीय है तो खाली सूची देता है)

अब हमारे पास प्रत्येक इनपुट सूची के लिए अद्वितीय तत्वों की दो सूचियां हैं (हालांकि प्रत्येक तत्व एक सूची है, और गैर-अद्वितीय तत्वों से अवशेष के रूप में खाली सूची हैं)।

∩/ चौराहा (कमी)

∊ ϵ nlist (समतल)

⌈/ अधिकतम (कमी)

* क्लासिक में, के ⌸रूप में गिनती ⎕U2338।

— एडम
स्रोत
1

MATL , 13 बाइट्स

,iSY'1=)]X&X>

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

व्याख्या

,      % Do twice
  i    %   Take input: array
  S    %   Sort array
  Y'   %   Run-length encode: pushes array of values and array of run lengths
  1=   %   Compare each run length with 1
  )    %   Use as logical index. This keeps only values that have appeared once
]      % End
X&     % Intersection of the two arrays
X>     % Maximum of array. Implicitly display
— लुइस मेंडो
स्रोत
1

PHP, 98 बाइट्स

<?foreach(($c=array_count_values)($_GET[a])as$a=>$n)$n-1||$c($_GET[b])[$a]-1||$a<$r||$r=$a;echo$r;

GET पैरामीटर के रूप में सरणियाँ प्रदान करें aऔर b।

— टाइटस
स्रोत
लगता है कि आप स्थिरांक के लिए उन GET पारमों को स्वैप कर सकते हैं।
— प्रोग्रोक
@ ड्रोग्रोक कोई वैध इनपुट विधि नहीं है।
— टाइटस
प्रश्न वाक्यांश जो ए और बी सरणियों के रूप में दिए गए हैं। और किसी भी उचित इनपुट और आउटपुट विधि का कहना है .... ऐसा नहीं है कि मैं उस लिंक का आसानी से पालन कर सकता हूं। वास्तव में आपकी रेसिपी की तरह। (हालांकि अप्रचलित Php 5.6 में
— चुटकुले
1

जावा 8, 133 बाइट्स

a->b->{long r;for(java.util.Collections c=null;;a.remove(r))if(b.contains(r=c.max(a))&c.frequency(a,r)*c.frequency(b,r)==1)return r;}

स्पष्टीकरण:

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

a->b->{                  // Method with two ArrayList<Long> parameters and long return-type
  long r;                //  Result-long
  for(java.util.Collections c=null; 
                         //  Create a java.util.Collections to save bytes
      ;                  //  Loop indefinitely
       a.remove(r))      //    After every iteration, remove the current item
    if(b.contains(r=c.max(a)) 
                         //   If the maximum value in `a` is present in `b`,
       &c.frequency(a,r)*c.frequency(b,r)==1)
                         //   and this maximum value is unique in both Lists:
      return r;          //    Return this value
                         //  End of loop (implicit / single-line body)
}                        // End of method
— केविन क्रूज़सेन
स्रोत
1

जावास्क्रिप्ट ES5, 122 121 114 बाइट्स

function f(a,b){for(i=a.sort().length;--i+1;)if(a[i]!=a[i+1]&&a[i]!=a[i-1]&&!(b.split(a[i]).length-2))return a[i]}

मैं यहां नया हूं, इसलिए मुझे नहीं पता कि क्या मैं फंक्शन की परिभाषा को हटा सकता हूं और इसकी सामग्री डाल सकता हूं (जो मुझे 17 बाइट्स से बचाएगा)

यहाँ काम कर रहे उदाहरण है: 122 121 114

122 से 121 बाइट्स: एक में रैपिंग आरंभीकरण

121 से 114 बाइट्स: bएक स्ट्रिंग होना चाहिए

— Piyin
स्रोत
2
PPCG में आपका स्वागत है! आप फ़ंक्शन की परिभाषा को नहीं निकाल सकते, लेकिन आप इसके बजाय एक लंबो फ़ंक्शन का उपयोग करने में सक्षम हो सकते हैं (मुझे जेएस नहीं पता है इसलिए मैं आपको इसके लिए मदद नहीं कर सकता)।
— श्री एक्सकोडर
इसे साफ़ करने के लिए धन्यवाद। मुझे नहीं लगता कि लैम्ब्डा फ़ंक्शन किसी भी वर्ण को बचा सकता है, लेकिन मैं कोशिश करूँगा। इसके अलावा, जब से आप कहते हैं "किसी भी उचित इनपुट और आउटपुट विधि / प्रारूप की अनुमति है", क्या मैं एक स्ट्रिंग को स्वीकार कर सकता हूं bऔर बचा सकता हूं b=''+b,?
— पियिन
मैंने 115 बाइट्स प्राप्त करने का प्रबंधन किया, हालांकि मुझे जावास्क्रिप्ट नहीं पता है f=(a,b)=>{for(b=''+b,i=a.sort().length;--i+1;)if(a[i]!=a[i+1]&&a[i]!=a[i-1]&&!(b.split(a[i]).length-2))return a[i]}:।
— मिस्टर एक्सकोडर
1
हाँ यकीन है कि एक स्ट्रिंग इनपुट ठीक होगा
— श्री एक्सकोडर
लेकिन आप जो जावास्क्रिप्ट लेकर आए हैं वह ES5 होगा, ES6 नहीं। एक ES6 उत्तर पहले से ही पोस्ट किया गया है, यही वजह है कि मैंने ES5 पोस्ट किया है। और दूसरे प्रश्न का उत्तर देने के लिए धन्यवाद hehe
— पियिन
1

Jq 1.5 , 76 बाइट्स

def m(n):[.[indices(.[])|select(length==n)[]]]|unique[];[map(m(1))|m(2)]|max

विस्तारित

def m(n): # function to emit elements of multiplicity n
  [
    .[                         # select elements with
         indices(.[])          # number of indices in the array
       | select(length==n)[]   # equal to specified multiplicity
    ]
  ] | unique[]                 # emit deduped values
;

[
    map(m(1))   # collect multiplicity 1 elements from each array
  | m(2)        # collect multiplicity 2 elements
] | max         # choose largest of these elements

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

यहाँ एक और समाधान है जो समान लंबाई है:

def u:[keys[]as$k|[.[$k]]-(.[:$k]+.[$k+1:])]|add;map(u)|.[0]-(.[0]-.[1])|max

विस्तारित

def u: # compute unique elements of input array
  [
      keys[] as $k                   # for each index k
    | [.[$k]] - (.[:$k]+.[$k+1:])    # subtract other elements from [ .[k] ]
  ]                                  # resulting in [] if .[k] is a duplicate
  | add                              # collect remaining [ .[k] ] arrays
;
  map(u)                             # discard duplicates from each input array
| .[0]-(.[0]-.[1])                   # find common elements using set difference
| max                                # kepp largest element

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

— jq170727
स्रोत
1

एपीएल, 47 बाइट्स

{1↑R[⍒R←((1={+/⍵=A}¨A)/A←⍺)∩(1={+/⍵=B}¨B)/B←⍵]}

एक अज्ञात फ़ंक्शन की घोषणा करता है जो दो वैक्टर लेता है, डुप्लिकेट तत्वों को समाप्त करता है, फिर परिणामों के प्रतिच्छेदन में सबसे बड़ा तत्व पाता है।

A←⍺और B←⍵में Aऔर समारोह में पारित तर्कों को संग्रहीत करें B।

a=bप्रत्येक सूचकांक में 1 के साथ एक वेक्टर लौटाता है जिसमें aसमान है b। यदि aएक अदिश राशि (यानी एकल मात्रा और एक वेक्टर नहीं है) तो यह एक वेक्टर को 1 के साथ लौटाता है जहां तत्व नहीं bहै aऔर जब यह नहीं है। उदाहरण के लिए:

Input: 1=1 2 3
Output: 1 0 0

{+/⍵=A}: नेस्टेड अनाम फ़ंक्शन; वेक्टर में तर्क की घटनाओं का पता लगाएं Aऔर उन्हें जोड़ दें अर्थात तर्क की घटनाओं की संख्या का पता लगाएंA

1={+/⍵=A}¨A: ए में प्रत्येक तत्व के लिए नेस्टेड अनाम फ़ंक्शन लागू करें और उन लोगों को ढूंढें जो समान 1 अर्थात अद्वितीय तत्व हैं

((1={+/⍵=A}¨A)/A←⍺): अद्वितीय तत्वों का स्थान पाए जाने पर , मूल वेक्टर में इन तत्वों का चयन करें ( /दाएं तर्क तत्वों से चयन करें जिनके स्थान बाएं तर्क में 1 के अनुरूप हैं)

R←((1={+/⍵=A}¨A)/A←⍺)∩(1={+/⍵=B}¨B)/B←⍵: दूसरे तर्क के लिए प्रक्रिया को दोहराएं; अब जब हमारे पास सिर्फ अनूठे तत्व हैं, तो प्रतिच्छेदन अर्थात सामान्य तत्व ढूंढें और इसे वेक्टर में स्टोर करेंR

R[⍒R]: Rघटते क्रम में तत्वों का उपयोग

1↑R[⍒R]: Rघटते क्रम में क्रमबद्ध होने पर पहला तत्व लें

परीक्षण का मामला:

Input: 17 29 39 29 29 39 18 18 {1↑R[⍒R←((1={+/⍵=A}¨A)/A←⍺)∩(1={+/⍵=B}¨B)/B←⍵]} 19 19 18 20 17 18
Output: 17
— Arc676
स्रोत
1

जे , 30 बाइट्स

[:>./@,[*([*+/"1(1=*/)+/)@(=/)

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

मैं परीक्षण से शुरू करता हूं जहां दो सूची ओवरलैप करती हैं =/( सूची के सभी सदस्यों के बीच समानता परीक्षण सम्मिलित करती है:

   a =. 1 3 4 6 6 9
   b =. 8 7 6 3 4 3
   ]c=. a =/ b 
0 0 0 0 0 0
0 0 0 1 0 1
0 0 0 0 1 0
0 0 1 0 0 0
0 0 1 0 0 0
0 0 0 0 0 0

एक ही कॉलम में एक से अधिक 1 का अर्थ है कि बाएं तर्क के लिए संख्या अद्वितीय नहीं है (इस मामले में 6); पंक्ति में - सही तर्क के लिए (3)

फिर मैं सभी पंक्तियों और सभी स्तंभों को यह पता लगाने के लिए जोड़ रहा हूं कि डुप्लिकेट कहां हैं:

   +/ c
0 0 2 1 1 1
   +/"1 c
0 2 1 1 1 0

मैं उपरोक्त सूचियों का कार्टेशियन उत्पाद ढूंढता हूं और सदस्यों को 1 से 0 से अधिक सेट करता हूं। 

    m =. (+/"1 c) (1=*/) +/c
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 1 1 1
0 0 0 1 1 1
0 0 0 1 1 1
0 0 0 0 0 0

मैं उन अद्वितीय तत्वों को खोजने के लिए m के साथ समानता मैट्रिक्स c को मास्क करता हूं जो दोनों सूचियों के लिए सामान्य हैं और इसके द्वारा बाएं तर्क को गुणा करें।

]l =. a * m * c
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 4 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0

फिर मैं सूची को समतल करता हूं और अधिकतम तत्व पाता हूं:

 >./,l 
4

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

— गैलेन इवानोव
स्रोत
1

सी # (.NET कोर) , 66 + 31 = 97 65 + 31 = 96 बाइट्स

a=>b=>a.Intersect(b).Where(x=>a.Concat(b).Count(y=>y==x)<3).Max()

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

+31 बाइट्स के लिए using System;using System.Linq;

मैंने @ अलिस्दग के उत्तर से प्रेरणा ली। हालांकि, दोनों सरणियों में अद्वितीय मूल्यों की खोज करने के बजाय, मैंने ऑपरेशन के क्रम को उल्टा कर दिया, ताकि intersectपहले हो, और फिर उन वस्तुओं का अधिकतम मूल्य खोजें जो दो बार होती हैं जब सरणियों को समतल किया जाता है और उनके प्रतिच्छेदन में होते हैं। मैं के <3रूप में उपयोग कर सकते हैंCount किसी भी मूल्य के लिए कम से कम 2 हो जाएगा, क्योंकि यह दोनों सरणियों में हो जाएगा।

स्वीकृतियाँ

-1 बाइट @aloisdg और करी का उपयोग करने के लिए उनके सुझाव के लिए Funcधन्यवाद।

— Ayb4btu
स्रोत
1
अछा सुझाव! मैं वास्तव में इसे पसंद करता हूं
— अलोएडग ने
— aloisdg का कहना है कि मोनिका
साथ currying आप 1 बाइट जीत सकते हैं! इसे ऑनलाइन आज़माएं!
— aloisdg का कहना है कि
0

ऑक्टेव , 57 56 बाइट्स

@(x)max(intersect(cellfun(@(x){x(sum(x'==x)==1)},x){:}))

बेनामी फ़ंक्शन जो इनपुट के रूप में दो संख्यात्मक सरणियों के सेल सरणी को लेता है।

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

व्याख्या

cellfun(@(x)...)दो इनपुट सरणियों के प्रत्येक ( ) के लिए, यह अपनी प्रविष्टियों के बीच जोड़ीदार समानता समानता का एक मैट्रिक्स बनाता है ( x.'==x); रखता है ( x(...)) केवल प्रविष्टियाँ जिसके लिए कॉलम योग है 1( sum(...)==1); और एक सेल में परिणाम पैक ( {...})। intersectदो परिणामों के चौराहे ( ) की {:}गणना की जाती है, और अधिकतम ( max(...)) लिया जाता है।

— लुइस मेंडो
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.