Se le dará dos matrices / Listas / vectores de enteros no negativos A y B . Su tarea es dar salida al entero más alto de N que aparece tanto en A y B , y también es único en tanto A y B .

• Puede suponer que hay al menos uno de esos números.

• Se permite cualquier método / formato de entrada y salida razonable .

• Estas lagunas están prohibidas.

• Este es el código de golf , por lo que gana el código más corto en cada lenguaje de programación.

Casos de prueba:

A, B -> Salida

[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

Jalea , 7 bytes

fċ@ÐṂ;Ṁ

Pruébalo en línea!

Cómo funciona

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

¡Gracias a @seshoumara por jugar golf en 1 byte!

Pruébalo en línea!

Cómo funciona

uniq toma una entrada ordenada y realiza una o varias acciones, según los indicadores de la línea de comandos.

U<<<$1y U<<<$2llame a la función Ucon el primer y segundo argumento de línea de comando como entrada. Para cada uno, sort -rn|uniq -use ejecuta, ordenando la entrada numéricamente ( -n) y en orden descendente ( -r) para uniq , que imprimirá solo líneas únicas ( -u).

La salida de ambos (elementos únicos de cada matriz) se concatena e hilo a U D, es decir,
sort -rn|uniq -uD. Esta vez, uniq solo imprimirá líneas duplicadas ( -D) y solo la primera repetición de cada una.

Mientras que la página del manual dice que imprimirá todas las repeticiones, las -ucausas agregadas -Dimprimen solo la primera aparición de líneas duplicadas. Este comportamiento se logra normalmente con uniq -d.

Finalmente, se sed qcierra inmediatamente, reduciendo su entrada (elementos únicos de ambas matrices) a su primera línea. Como la salida se ordenó en orden descendente, este es el máximo.

Pyth, 12 9 bytes

Intentalo

eS@Fm.m/d

Guardado 3 bytes gracias al Sr. Xcoder.

Explicación

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 bytes

Guardado 7 bytes gracias a @ Mr.Xcoder , @ pizzapants184 y @ovs

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

Pruébalo en línea!

05AB1E , 9 8 bytes

-1 byte gracias a Erik the Outgolfer

εТÏ}`Ãà

Pruébalo en línea!

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

Casco , 7 bytes

→►≠OfEΠ

Toma la entrada como una lista de dos listas, también funciona para cualquier número de listas (si es posible, devuelve el número más alto que ocurre exactamente una vez en cada una). Pruébalo en línea!

Explicación

Esta es la primera respuesta de Husk para (ab) usar la nueva función "máximo por" ►.

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

Pruébalo en línea

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

Jalea , 11 bytes

ċ@Ị¥Ðf`€f/Ṁ

Pruébalo en línea!

J, 23 bytes

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

(-.-.@~:#]) elimina de una lista cualquier elemento repetido

& hacer esto a ambos args

([-.-.) Queremos que A se cruce con B. Esta es la frase equivalente: "A menos (A menos B)"

>./ Toma el máximo

Pruébalo en línea!

PowerShell , 94 bytes

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

Pruébalo en línea!

Toma entrada $ay $bcomo matrices. Construye un elemento filterque groupes el conjunto de elementos de la matriz de entrada y extrae solo aquellos con un count -equal 1(es decir, solo aquellos que son únicos en la matriz de entrada).

La siguiente línea construye el algoritmo. Primero nosotros sort $a, luego sacamos aquellos que son -inlos elementos únicos de $b. Esos son entonces únicos, [-1]se elige el más grande , y tomamos el .Namemismo. Eso queda en la tubería y la salida es implícita.

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))

Gracias @justinMariner por pasar de 102 a 86

Gracias @tsh por pasar de 86 a 75

Gracias @Arnauld por pasar de 75 a 71

Pruébalo en línea!

Haskell , 57 53 bytes

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

Pruébalo en línea!

UPD: Gracias @Laikoni

Wolfram Language (Mathematica) , 40 bytes

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

Pruébalo en línea!

Cómo funciona

Tally@#da una lista de los elementos únicos de la primera entrada, junto con sus conteos: por ejemplo, Tally[{2,2,2,6,3,5,8,2}]rendimientos {{2,4},{6,1},{3,1},{5,1},{8,1}}.

Tally@#2hace lo mismo para la segunda lista y ⋂encuentra pares presentes en ambos. Luego seleccionamos (con Cases) pares que terminan en 1, tomando el primer elemento de cada resultado, lo que nos da una lista de todos los gemelos únicos. Finalmente, Maxdevuelve el gemelo único más grande.

Röda , 48 bytes

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

Pruébalo en línea!

Inspirado por la respuesta jq170727 de jq .

Explicación:

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

Otra solución con countByeste tiempo:

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

Pruébalo en línea!

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

Pruébalo en línea!

100% F #! Cualquier ayuda es bienvenida!

¡6 bytes ganados gracias a la notación de prefijo!

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

@es la función concat! Gracias @ Ayb4btu por este algoritmo.

Pruébalo en línea!

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()

Pruébalo en línea!

Solución ingenua con LINQ ( using System;using System.Linq;+ 31 caracteres por lo que 116 bytes con encabezado)

84! ¡Olvidé el curry!

Pip , 17 16 bytes

MX{_Na=_Nb=1FIa}

Esta es una función que toma dos listas como argumentos. Pruébalo en línea!

Explicación

  {            }  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 caracteres = 23 bytes *

Un cuerpo completo del programa. Solicita una lista de listas de STDIN. Funciona con cualquier cantidad de listas. Salidas a STDOUT.

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

Pruébalo en línea!

⎕ solicitud de entrada evaluada de STDIN

{... }⌸¨ para cada lista, llame a la siguiente función para cada elemento único en esa lista, utilizando el elemento único como argumento izquierdo ( ⍺) y la lista de índices de su aparición como argumento derecho ( ⍵):

 ≢⍵ el recuento de índices (es decir, el número de ocurrencias)

 1= igual a 1

 ⍺⍴⍨ use eso para remodelar el elemento específico (es decir, da una lista vacía si no es única)

Ahora tenemos dos listas de elementos únicos para cada lista de entrada (aunque cada elemento es una lista, y hay listas vacías como residuo de los elementos no únicos).

∩/ intersección (reducción)

∊ ϵ nlist (aplanar)

⌈/ max (reducción)

* en Clásico, contando ⌸como ⎕U2338.

MATL , 13 bytes

,iSY'1=)]X&X>

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

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

Proporcionar matrices como parámetros GET ay 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;}

Explicación:

Pruébalo aquí

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

Pruébalo en línea!

Las computadoras se Acruzan B, luego el máximo de la diferencia entre eso y los elementos duplicados de Ay 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]}

Soy nuevo aquí, así que no sé si puedo eliminar la definición de la función y simplemente poner su contenido (lo que me ahorraría 17 bytes)

Aquí está el ejemplo de trabajo: 122 121 114

122 a 121 bytes: inicialización de ajuste en un para

121 a 114 bytes: btiene que ser una cadena

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)

Pruébalo en línea!

¡Primera vez en SQL, cualquier ayuda es bienvenida!

Jq 1.5 , 76 bytes

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

Expandido

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

Pruébalo en línea!

Aquí hay otra solución que tiene la misma longitud:

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

Expandido

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

Pruébalo en línea!

APL, 47 bytes

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

Declara una función anónima que toma dos vectores, elimina elementos duplicados y luego encuentra el elemento más grande en la intersección de los resultados.

A←⍺y B←⍵almacenar los argumentos pasados ​​a la función en Ay B.

a=bdevuelve un vector con 1 en cada índice en el que aes igual a b. Si aes un escalar (es decir, una sola cantidad y no un vector), devuelve un vector con 1 donde sea que besté el elemento ay 0 cuando no lo esté. Por ejemplo:

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

{+/⍵=A}: función anónima anidada; encontrar las ocurrencias del argumento en vector Ay sumarlas, es decir, encontrar el número de ocurrencias del argumento enA

1={+/⍵=A}¨A: aplica la función anónima anidada a cada elemento en A y encuentra las que son iguales a 1, es decir, elementos únicos

((1={+/⍵=A}¨A)/A←⍺): después de encontrar la ubicación de los elementos únicos, seleccione solo estos elementos en el vector original ( /selecciona de los elementos de argumento correctos cuyas ubicaciones corresponden a 1 en el argumento izquierdo)

R←((1={+/⍵=A}¨A)/A←⍺)∩(1={+/⍵=B}¨B)/B←⍵: repite el proceso para el segundo argumento; ahora que tenemos solo los elementos únicos, encuentre la intersección, es decir, elementos comunes y almacénelos en un vectorR

R[⍒R]: acceder a los elementos de Ren orden decreciente

1↑R[⍒R]: toma el primer elemento de Rcuando se ordena en orden decreciente

Caso de prueba:

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=*/)+/)@(=/)

Cómo funciona:

Comienzo con la prueba donde las dos listas se superponen =/(inserta la prueba de igualdad entre todos los miembros de las listas:

   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

Más de un 1 en la misma columna significa que el número no es único para el argumento izquierdo (6 en este caso); en la fila - por el argumento correcto (3)

Luego, sumo todas las filas y todas las columnas para encontrar dónde están los duplicados:

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

Encuentro el producto cartesiano de las listas anteriores y establezco los miembros mayores de 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

Enmascaro la matriz de igualdad c con m para encontrar los elementos únicos que son comunes a ambas listas y multiplico el argumento izquierdo por esto.

]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

Luego aplano la lista y encuentro el elemento max:

 >./,l 
4

Pruébalo en línea!

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()

Pruébalo en línea!

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

Me inspiré en la respuesta de @ aloisdg. Sin embargo, en lugar de buscar valores únicos en ambas matrices, invertí el orden de las operaciones para que intersectsea ​​primero, y luego encuentre el valor máximo de los elementos que ocurren dos veces cuando las matrices se concatenan y están en su intersección. Puedo usar <3como Countserá al menos 2 para cualquier valor, ya que estará en ambas matrices.

Expresiones de gratitud

-1 byte gracias a @aloisdg y su sugerencia de usar Funccurry.

Octava , 57 56 bytes

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

Función anónima que toma como entrada una matriz de celdas de dos matrices numéricas.

Pruébalo en línea!

Explicación

Para cada ( cellfun(@(x)...)) de las dos matrices de entrada, esto crea una matriz de comparaciones de igualdad por pares entre sus entradas ( x.'==x); mantiene ( x(...)) solo las entradas para las que la suma de la columna es 1( sum(...)==1); y empaqueta el resultado en una celda ( {...}). Se calcula la intersección ( intersect) de los dos resultados ( {:}) y max(...)se toma el máximo ( ).

Wolfram Language (Mathematica) , 49 bytes

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

Pruébalo en línea!