Vi verrà dato due array / Liste / Vettori di numeri interi non negativi A e B . Il vostro compito è quello di uscita il più alto numero intero N che compare in entrambe le A e B , ed è anche unico sia A e B .

• Puoi presumere che ci sia almeno un tale numero.

• È consentito qualsiasi metodo / formato di input e output ragionevole .

• Queste scappatoie sono vietate.

• Questo è code-golf , quindi vince il codice più corto in ogni linguaggio di programmazione!

Casi test:

A, B -> Uscita

[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

Gelatina , 7 byte

fċ@ÐṂ;Ṁ

Provalo online!

Come funziona

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 byte

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

Grazie a @seshoumara per giocare a golf a 1 byte!

Provalo online!

Come funziona

uniq accetta input ordinati ed esegue una o più azioni, a seconda dei flag della riga di comando.

U<<<$1e U<<<$2chiama la funzione Ucon il primo e il secondo argomento della riga di comando come input. Per ognuno, sort -rn|uniq -uviene eseguito, ordinando l'input numericamente ( -n) e in ordine decrescente ( -r) per uniq , che stamperà solo linee uniche ( -u).

L'output di entrambi (elementi univoci di ciascun array) viene concatenato e reindirizzato a U D, ad es
sort -rn|uniq -uD. Questa volta, uniq stamperà solo righe duplicate ( -D) e solo la prima ripetizione di ciascuna.

Mentre la pagina man dice che stamperà tutte le ripetizioni, le aggiunte -ucause -Ddi stampare solo la prima occorrenza di linee duplicate. Questo comportamento si ottiene normalmente con uniq -d.

Infine, si sed qchiude immediatamente, riducendo il suo input (elementi unici di entrambi gli array) alla sua prima riga. Poiché l'output è stato ordinato in ordine decrescente, questo è il massimo.

Pyth, 12 9 byte

Provalo

eS@Fm.m/d

Salvato 3 byte grazie a Mr. Xcoder.

Spiegazione

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.

Python 3 , 61 56 54 byte

Salvato 7 byte grazie a @ Mr.Xcoder , @ pizzapants184 e @ovs

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

Provalo online!

05AB1E , 9 8 byte

-1 byte grazie a Erik the Outgolfer

εТÏ}`Ãà

Provalo online!

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

Buccia , 7 byte

→►≠OfEΠ

Accetta input come un elenco di due elenchi, funziona anche per qualsiasi numero di elenchi (restituendo il numero più alto che si verifica esattamente una volta in ciascuno, se possibile). Provalo online!

Spiegazione

Questa è la prima risposta di Husk a (ab) utilizzare la nuova funzione "maximum by" ►.

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

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

Provalo online

Bash, 89 byte

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

Gelatina , 11 byte

ċ@Ị¥Ðf`€f/Ṁ

Provalo online!

J, 23 byte

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

(-.-.@~:#]) rimuove da un elenco qualsiasi elemento ripetuto

& fai questo per entrambi gli arg

([-.-.) Vogliamo A intersecare B. Questa è la frase equivalente: "A meno (A meno B)"

>./ Prendi il massimo

Provalo online!

PowerShell , 94 byte

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

Provalo online!

Accetta input $ae $bcome array. Costruisce una filterche groups elementi di matrice di ingresso insieme ed estrae solo quelle con un count -equale per 1(ossia solo quelli che sono unici nella matrice di ingresso).

La riga successiva costruisce quindi l'algoritmo. Prima di tutto sort $a, quindi estrarre quelli che sono -ingli elementi unici di $b. Quelli sono essi stessi unici, [-1]se ne sceglie il più grande e noi ne prendiamo il resto .Name. Rimane in cantiere e l'output è implicito.

Javascript (ES6), 102 86 75 71 byte

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

Grazie @justinMariner per essere passato da 102 a 86

Grazie @tsh per essere passato da 86 a 75

Grazie @Arnauld per ottenere da 75 a 71

Provalo online!

Haskell , 57 53 byte

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

Provalo online!

UPD: Grazie @Laikoni

Wolfram Language (Mathematica) , 40 byte

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

Provalo online!

Come funziona

Tally@#fornisce un elenco degli elementi univoci del primo input, insieme ai loro conteggi: ad esempio, i Tally[{2,2,2,6,3,5,8,2}]rendimenti {{2,4},{6,1},{3,1},{5,1},{8,1}}.

Tally@#2fa lo stesso per il secondo elenco e ⋂trova le coppie presenti in entrambi. Quindi scegliamo (con Cases) le coppie che finiscono 1, prendendo il primo elemento di ogni risultato, che ci dà un elenco di tutti i gemelli unici. Infine, Maxrestituisce il gemello unico più grande.

Röda , 48 byte

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

Provalo online!

Ispirato dalla risposta jq di jq170727 .

Spiegazione:

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

115 114 byte

Un'altra soluzione con countByquesto tempo:

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

Provalo online!

117 111 byte

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

Provalo online!

100% F #! Qualsiasi aiuto è il benvenuto!

6 byte vinti grazie alla notazione del prefisso!

108 byte

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

@è la funzione concat! Grazie @ Ayb4btu per questo algoritmo.

Provalo online!

C # (.NET Core) , 85 84 byte

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

Provalo online!

Soluzione ingenua con LINQ ( using System;using System.Linq;+ 31chars quindi 116 byte con intestazione)

84! Ho dimenticato il curry!

Pip , 17 16 byte

MX{_Na=_Nb=1FIa}

Questa è una funzione che accetta due elenchi come argomenti. Provalo online!

Spiegazione

  {            }  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 caratteri = 23 byte *

Un corpo di programma completo. Richiede un elenco di elenchi da STDIN. Funziona con qualsiasi numero di elenchi. Uscita su STDOUT.

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

Provalo online!

⎕ richiesta di input valutato da STDIN

{... }⌸¨ per ogni elenco, chiama la seguente funzione per ciascun elemento univoco in quell'elenco, usando l'elemento univoco come argomento sinistro ( ⍺) e l'elenco degli indici della sua occorrenza come argomento giusto ( ⍵):

 ≢⍵ il conteggio degli indici (ovvero il numero di occorrenze)

 1= uguale a 1

 ⍺⍴⍨ usalo per rimodellare l'elemento specifico (es. dà un elenco vuoto se non univoco)

Ora abbiamo due elenchi di elementi univoci per ciascun elenco di input (sebbene ogni elemento sia un elenco e ci sono elenchi vuoti come residui dagli elementi non univoci).

∩/ intersezione (riduzione)

∊ ϵ nlist (appiattisci)

⌈/ max (riduzione)

* in classico, contando ⌸come ⎕U2338.

MATL , 13 byte

,iSY'1=)]X&X>

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

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

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

Fornire array come parametri GET ae b.

Java 8, 133 byte

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

Spiegazione:

Provalo qui.

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 byte

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

Provalo online!

Calcola l' Aintersezione B, quindi il massimo della differenza tra quello e gli elementi duplicati di Ae B.

JavaScript ES5, 122 121 114 byte

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

Sono nuovo qui, quindi non so davvero se posso rimuovere la definizione della funzione e metterne semplicemente il contenuto (che mi farebbe risparmiare 17 byte)

Ecco l'esempio funzionante: 122 121 114

Da 122 a 121 byte: inizializzazione di wrapping in a per

Da 121 a 114 byte: bdeve essere una stringa

SQLite , 118 byte

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)

Provalo online!

La prima volta in SQL, qualsiasi aiuto è il benvenuto!

Jq 1,5 , 76 byte

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

allargato

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

Provalo online!

Ecco un'altra soluzione che ha la stessa lunghezza:

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

allargato

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

Provalo online!

APL, 47 byte

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

Dichiara una funzione anonima che accetta due vettori, elimina gli elementi duplicati, quindi trova l'elemento più grande nell'intersezione dei risultati.

A←⍺e B←⍵memorizza gli argomenti passati alla funzione in Ae B.

a=brestituisce un vettore con 1 in ciascun indice in cui aè uguale a b. Se aè uno scalare (cioè quantità singola e non un vettore) questo restituisce un vettore con 1 laddove l'elemento bè ae 0 quando non lo è. Per esempio:

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

{+/⍵=A}: funzione anonima nidificata; trova le occorrenze dell'argomento in vettoriale Ae sommale, ovvero trova il numero di occorrenze dell'argomento inA

1={+/⍵=A}¨A: applica la funzione anonima nidificata a ciascun elemento in A e trova quelli che equivalgono a 1 cioè elementi univoci

((1={+/⍵=A}¨A)/A←⍺): avendo trovato la posizione degli elementi univoci, selezionare solo questi elementi nel vettore originale ( /seleziona tra gli elementi dell'argomento destro le cui posizioni corrispondono a 1 nell'argomento sinistro)

R←((1={+/⍵=A}¨A)/A←⍺)∩(1={+/⍵=B}¨B)/B←⍵: ripete la procedura per il secondo argomento; ora che abbiamo solo gli elementi unici, trova l'intersezione, cioè elementi comuni e memorizzalo nel vettoreR

R[⍒R]: accedi agli elementi Rin ordine decrescente

1↑R[⍒R]: prendi il primo elemento di Rquando è ordinato in ordine decrescente

Caso di prova:

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 byte

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

Come funziona:

Comincio con i test in cui i due elenchi si sovrappongono =/(inserisce test di uguaglianza tra tutti i membri degli elenchi:

   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

Più di 1 nella stessa colonna indica che il numero non è univoco per l'argomento sinistro (6 in questo caso); nella riga - per l'argomento giusto (3)

Quindi riassumo tutte le righe e tutte le colonne per trovare dove sono i duplicati:

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

Trovo il prodotto cartesiano degli elenchi sopra e imposto i membri maggiori di 1 a 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

Maschero la matrice di uguaglianza c con m per trovare gli elementi univoci comuni a entrambe le liste e moltiplicare l'argomento sinistro per questo.

]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

Quindi appiattisco l'elenco e trovo l'elemento max:

 >./,l 
4

Provalo online!

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

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

Provalo online!

+31 byte per using System;using System.Linq;

Ho preso ispirazione dalla risposta di @ aloisdg. Tuttavia, anziché cercare valori univoci in entrambi gli array, ho invertito l'ordine delle operazioni in modo che intersectsia il primo, quindi trovo il valore massimo degli elementi che si verificano due volte quando gli array sono concatenati e si trovano nella loro intersezione. Posso usare <3come Countsarà almeno 2 per qualsiasi valore, come sarà in entrambi gli array.

Ringraziamenti

-1 byte grazie a @aloisdg e al suo suggerimento di usare il Funccurry.

Ottava , 57 56 byte

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

Funzione anonima che accetta come input una matrice di celle di due array numerici.

Provalo online!

Spiegazione

Per ciascuno ( cellfun(@(x)...)) dei due array di input, questo crea una matrice di confronti di uguaglianza a coppie tra le sue voci ( x.'==x); mantiene ( x(...)) solo le voci per le quali la somma delle colonne è 1( sum(...)==1); e racchiude il risultato in una cella ( {...}). L'intersezione ( intersect) dei due risultati ( {:}) viene calcolata e max(...)viene preso il massimo ( ).

Wolfram Language (Mathematica) , 49 byte

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

Provalo online!