Sie werden zwei Arrays / Listen / Vektoren von nicht negativen ganzen Zahlen angegeben werden A und B . Ihre Aufgabe ist es, die höchste Ganzzahl N auszugeben, die sowohl in A als auch in B vorkommt und auch in A und B eindeutig ist .

• Sie können davon ausgehen, dass es mindestens eine solche Nummer gibt.

• Jede sinnvolle Eingabe- und Ausgabemethode / -format ist zulässig.

• Diese Lücken sind verboten.

• Das ist Code-Golf , also gewinnt der kürzeste Code in jeder Programmiersprache!

Testfälle:

A, B -> Ausgabe

[6], [1, 6] -> 6
[1, 2, 3, 4], [4, 5, 6, 7] -> 4
[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, 6, 3, 5, 8, 2], [8, 7, 5, 8] -> 5
[12, 19, 18, 289, 19, 17], [12, 19, 18, 17, 17, 289] -> 289
[17, 29, 39, 29, 29, 39, 18], [19, 19, 18, 20, 17, 18] -> 17
[17, 29, 39, 29, 29, 39, 18, 18], [19, 19, 18, 20, 17, 18] -> 17

Gelee , 7 Bytes

fċ@ÐṂ;Ṁ

Probieren Sie es online!

Wie es funktioniert

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.

Bash + Coreutils, 49 Bytes

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

Vielen Dank an @seshoumara für das Golfen ab 1 Byte!

Probieren Sie es online!

Wie es funktioniert

uniq nimmt sortierte Eingaben entgegen und führt abhängig von den Befehlszeilen-Flags eine oder mehrere Aktionen aus.

U<<<$1und U<<<$2rufen Sie die Funktion Umit dem ersten und zweiten Befehlszeilenargument als Eingabe auf. Für jede sort -rn|uniq -uwird ausgeführt, die Eingabe wird numerisch ( -n) und in absteigender Reihenfolge ( -r) für uniq sortiert , wodurch nur eindeutige Zeilen gedruckt werden ( -u).

Die Ausgabe von beiden (eindeutigen Elementen jedes Arrays) wird verkettet und weitergeleitet U D, dh
sort -rn|uniq -uD. Diesmal druckt uniq nur doppelte Zeilen ( -D) und jeweils nur die erste Wiederholung.

Während der Mann Seite sagt , wird es alle Wiederholungen drucken, die zusätzlichen -uUrsachen -Ddrucken nur das erste Vorkommen Zeilen dupliziert. Dieses Verhalten wird normalerweise mit erreicht uniq -d.

Schließlich sed qbeendet sofort seinen Eingang (eindeutige Elemente beider Arrays) Reduzieren seiner ersten Zeile. Da die Ausgabe in absteigender Reihenfolge sortiert wurde, ist dies das Maximum.

Pyth, 12 9 Bytes

Versuch es

[email protected]/d

3 Bytes gespart dank Mr. Xcoder.

Erläuterung

[email protected]/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.

Python 3 , 61 56 54 Bytes

7 Bytes gespart dank @ Mr.Xcoder , @ pizzapants184 und @ovs

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

Probieren Sie es online!

05AB1E , 9 8 Bytes

-1 Byte danke an Erik den Outgolfer

εТÏ}`Ãà

Probieren Sie es online!

ε   }    # For each input
 Ð¢Ï     #   Get the unique elements
     `Ã  # Keep only the elements that appear in both lists
       à # Keep the greatest element
         # Implicit print

Schale , 7 Bytes

→►≠OfEΠ

Nimmt die Eingabe als Liste mit zwei Listen an und funktioniert auch für eine beliebige Anzahl von Listen (wobei nach Möglichkeit die höchste Anzahl zurückgegeben wird, die jeweils genau einmal vorkommt). Probieren Sie es online!

Erläuterung

Dies ist die erste Antwort von Husk, um (ab) die neue Funktion "Maximum by" zu verwenden ►.

→►≠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

Bash + Coreutils, 60 Bytes

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

Probieren Sie es online

Bash, 89 Bytes

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

Jelly , 11 Bytes

ċ@Ị¥Ðf`€f/Ṁ

Probieren Sie es online!

J, 23 Bytes

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

(-.-.@~:#]) Entfernt alle wiederholten Elemente aus einer Liste

& Tun Sie dies für beide Argumente

([-.-.) Wir wollen A schneiden B. Dies ist die äquivalente Phrase: "A minus (A minus B)"

>./ Nehmen Sie die max

Probieren Sie es online!

PowerShell , 94 Byte

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

Probieren Sie es online!

Übernimmt Eingaben $aund $bals Arrays. Konstruiert ein filter, groupdas die Eingabe-Array-Elemente zusammenfasst, und zieht nur die mit dem count -eqBuchstaben ual bis heraus1 (dh nur diejenigen, die im Eingabearray eindeutig sind).

Die nächste Zeile konstruiert dann den Algorithmus. Zuerst ziehen wir sort $adann die heraus, die -indie einzigartigen Einzelteile von sind $b. Diese sind dann selbst einmalig, die größte [-1]wird ausgewählt und wir nehmen die .Namedavon. Das bleibt in der Pipeline und die Ausgabe ist implizit.

Javascript (ES6), 102 86 75 71 Bytes

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

Vielen Dank an @justinMariner, dass Sie von 102 auf 86 gekommen sind

Danke @tsh, dass du von 86 auf 75 gekommen bist

Danke @Arnauld, dass du von 75 auf 71 gekommen bist

Probieren Sie es online!

Haskell , 57 53 Bytes

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

Probieren Sie es online!

UPD: Danke @Laikoni

Wolfram Language (Mathematica), 40 bytes

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

Try it online!

How it works

Tally@# gives a list of the unique elements of the first input, together with their counts: e.g., Tally[{2,2,2,6,3,5,8,2}] yields {{2,4},{6,1},{3,1},{5,1},{8,1}}.

Tally@#2 does the same for the second list, and ⋂ finds pairs present in both. Then we pick out (with Cases) pairs ending in 1, taking the first element of each result, which gives us a list of all the unique twins. Finally, Max returns the largest unique twin.

Röda, 48 bytes

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

Try it online!

Inspired by jq170727's jq answer.

Explanation:

{ /* 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 */
}

F# (.NET Core), 117 115 114 111 108 bytes

115 114 bytes

Another solution with countBy this time:

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

Try it online!

117 111 bytes

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

Try it online!

100% F#! Any help is welcome!

6 byte won thanks to prefix notation!

108 bytes

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

@ is the concat function! Thank you @Ayb4btu for this algorithm.

Try it online!

C# (.NET Core), 85 84 bytes

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

Try it online!

Naive solution with LINQ (using System;using System.Linq; +31chars so 116 bytes with header)

84! I forgot currying!

Pip, 17 16 bytes

MX{_Na=_Nb=1FIa}

This is a function that takes two lists as arguments. Try it online!

Explanation

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

APL (Dyalog), 18 chars = 23 bytes*

A full program body. Prompts for list of lists from STDIN. Works with any number of lists. Outputs to STDOUT.

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

Try it online!

⎕ prompt for evaluated input from STDIN

{…}⌸¨ for each list, call the following function for each unique element in that list, using the unique element as left argument (⍺) and the list of indices of its occurrence as right argument (⍵):

 ≢⍵ the tally of indices (i.e. the number of occurrences)

 1= equal to 1

 ⍺⍴⍨ use that to reshape the specific element (i.e. gives empty list if non-unique)

Now we have two lists of unique elements for each input list (although each element is a list, and there are empty lists as residue from the non-unique elements).

∩/ intersection (reduction)

∊ ϵnlist (flatten)

⌈/ max (reduction)

* in Classic, counting ⌸ as ⎕U2338.

MATL, 13 bytes

,iSY'1=)]X&X>

Try it online! Or Verify all test cases.

Explanation

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

PHP, 98 bytes

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

Provide arrays as GET parameters a and b.

Java 8, 133 bytes

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

Explanation:

Try it here.

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

R, 73 bytes

function(A,B)max(setdiff(intersect(A,B),c(A[(d=duplicated)(A)],B[d(B)])))

Try it online!

Computes A intersect B, then the maximum of the difference between that and the duplicated elements of A and B.

JavaScript ES5, 122 121 114 bytes

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

I'm new here, so I don't really know if I can remove the function definition and just put its contents (which would save me 17 bytes)

Here's the working example: 122 121 114

122 to 121 bytes: Wrapping initialization in a for

121 to 114 bytes: b has to be a string

SQLite, 118 bytes

SELECT MAX(x)FROM(SELECT X FROM A GROUP BY X HAVING COUNT(X)=1
INTERSECT
SELECT X FROM B GROUP BY X HAVING COUNT(X)=1)

Try it online!

First time in SQL, any help is welcome!

Jq 1.5, 76 bytes

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

Expanded

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

Try it online!

Here is another solution which is the same length:

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

Expanded

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

Try it online!

APL, 47 bytes

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

Declares an anonymous function that takes two vectors, eliminates duplicate elements, then finds the biggest element in the intersection of the results.

A←⍺ and B←⍵ store the arguments passed to the function in A and B.

a=b returns a vector with 1 in each index in which a is equal to b. If a is a scalar (i.e. single quantity and not a vector) this returns a vector with 1 wherever the element in b is a and 0 when it is not. For example:

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

{+/⍵=A}: nested anonymous function; find the occurrences of the argument in vector A and add them up i.e. find the number of occurrences of the argument in A

1={+/⍵=A}¨A: apply the nested anonymous function to each element in A and find the ones that equal 1 i.e. unique elements

((1={+/⍵=A}¨A)/A←⍺): having found the location of the unique elements, select just these elements in the original vector (/ selects from the right argument elements whose locations correspond to 1 in the left argument)

R←((1={+/⍵=A}¨A)/A←⍺)∩(1={+/⍵=B}¨B)/B←⍵: repeat the process for the second argument; now that we have just the unique elements, find the intersection i.e. common elements and store this in vector R

R[⍒R]: access the elements of R in decreasing order

1↑R[⍒R]: take the first element of R when it's sorted in decreasing order

Test case:

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

J, 30 bytes

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

How it works:

I start with testing where the two list overlap by =/ (inserts equality test between all the members of the lists:

   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

More than one 1 in the same column means that the number is not unique for the left argument (6 in this case); in the row - for the right argument (3)

Then I sum up all rows and all columns to find where are the duplicates:

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

I find the cartesian product of the above lists and set the members greater than 1 to 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

I mask the equality matrix c with m to find the unique elements that are common to both lists and multiply the left argument by this.

]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

Then I flatten the list and find the max element:

 >./,l 
4

Try it online!

C# (.NET Core), 66+31=97 65+31=96 bytes

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

Try it online!

+31 bytes for using System;using System.Linq;

I took inspiration from @aloisdg's answer. However, instead of searching for unique values in both arrays, I inverted the order of operations so that intersect is first, and then find the max value of the items that occur twice when the arrays are concatenated and are in their intersect. I can use <3 as Count will be at least 2 for any value, as it will be in both arrays.

Acknowledgements

-1 byte thanks to @aloisdg and his suggestion to use Func currying.

Octave, 57 56 bytes

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

Anonymous function that takes as input a cell array of two numerical arrays.

Try it online!

Explanation

For each (cellfun(@(x)...)) of the two input arrays, this creates a matrix of pairwise equality comparisons between its entries (x.'==x); keeps (x(...)) only the entries for which the column sum is 1 (sum(...)==1); and packs the result in a cell ({...}). The intersection (intersect) of the two results ({:}) is computed, and the maximum (max(...)) is taken.

Wolfram Language (Mathematica), 49 bytes

Last@Select[a=Join@##;Sort[#⋂#2],a~Count~#<3&]&

Try it online!