Encuentra los gemelos únicos

28

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 .


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
Sr. Xcoder
fuente

Respuestas:

7

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.
Dennis
fuente
7

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.

Dennis
fuente
6

Pyth, 12 9 bytes

Intentalo

[email protected]/d

Guardado 3 bytes gracias al Sr. Xcoder.

Explicación

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

fuente
¡Agradable! Mi solución también fue de 12 bytes .
Sr. Xcoder
Golfing mi solución un poco, 9 bytes (usando [email protected]/d) y tomando la entrada como una lista de dos listas.
Sr. Xcoder
@ Mr.Xcoder Eso parece lo suficientemente diferente como para ser su propia respuesta.
Como soy el OP del desafío, soy reacio a publicarlo. Puede usarlo y dar crédito, mencionando su enfoque actual como alternativa (si lo desea, por supuesto)
Sr. Xcoder
5

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
Riley
fuente
5

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
Zgarb
fuente
4

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

Nahuel Fouilleul
fuente
1
Úselo sort -rncon sed qal final en lugar de tail -1afeitarse 1 byte. Gran descubrimiento con por grep -wfcierto. +1
seshoumara
@seshoumara, gracias por el consejo, de hecho, podría reducir 3 bytes con la opción -m1 grep.
Nahuel Fouilleul el
3

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!

Jonás
fuente
De manera equivalente, puede reemplazar la parte de intersección con e.~#]. Golf esto ha demostrado ser difícil ... He intentado utilizar /.tecla o ningún éxito ( ((1=#)/.~#~.)para la primera parte, que es de 2 bytes ya por mi cuenta)
Cole
@cole, sí, también probé un enfoque clave, y también uno con autoclasificación. Sin embargo, no pude superar mi presentación anterior con ningún otro enfoque.
Jonás
2

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.

AdmBorkBork
fuente
2

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!

Nate
fuente
Bienvenido a PPCG! Por lo que puedo decir, esto no asegura que eaparezca solo una vez en ay b.
Martin Ender
@MartinEnder Gracias! ¡Edité la respuesta para reflejar los detalles que me perdí!
Nate
1
Nunca pensé en usar lastIndexOfasí, eso es bastante inteligente. Puede reducir esto a 86 bytes: ¡ Pruébelo en línea! . Consulte los consejos de JS para obtener más información.
Justin Mariner el
1
Parece que el uso (g=x=>x.filter(y=>y==e).length==1)es más corto.
tsh
1
Creo que este también está pasando todos los casos límite (71 bytes).
Arnauld el
2

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

usuario28667
fuente
¡Bienvenido a PPCG y al golf Haskell en particular! Esta es una buena primera respuesta! Dos pequeñas cosas: también puede declarar fcomo operador infijo y escribir en [1|...]==[1]lugar de sum[1|...]==1guardar algunos bytes.
Laikoni
En caso de que aún no los haya visto, aquí hay algunos enlaces que pueden ser interesantes: nuestra colección de consejos de golf en Haskell , la guía de reglas de golf en Haskell y Of Monads and Men , nuestra sala de chat de Haskell.
Laikoni
1
En línea !con andguarda dos bytes más: ¡ Pruébelo en línea!
Laikoni
2

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.

Misha Lavrov
fuente
2

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 */
}
fergusq
fuente
2

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!

aloisdg dice Reinstate Monica
fuente
2

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!

aloisdg dice Reinstate Monica
fuente
2

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
DLosc
fuente
2

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.

Adán
fuente
1

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
Luis Mendo
fuente
1

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.

Titus
fuente
Piensa que podrías cambiar esos parámetros GET por constantes.
Progrock
@Progrock Ese no es un método de entrada válido.
Tito el
Las frases de preguntas que A y B se dan como matrices. Y dice que cualquier método de entrada y salida razonable ... no es que pueda seguir ese enlace fácilmente. Realmente me gusta tu receta. (Sin embargo
ahoga
1

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
Kevin Cruijssen
fuente
1

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.

Giuseppe
fuente
1

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

Piyin
fuente
2
Bienvenido a PPCG! No puede eliminar la definición de la función, pero es posible que pueda usar una función lambda en su lugar (no conozco JS, así que no puedo ayudarlo con eso).
Sr. Xcoder
Gracias por aclarar eso. No creo que las funciones lambda puedan guardar ningún carácter, pero lo intentaré. Además, dado que dice "Se permite cualquier método / formato de entrada y salida razonable", ¿podría aceptar una cadena como by guardar b=''+b,?
Piyin
Me las arreglé para llegar a 115 bytes, aunque no sé JavaScript: 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]}.
Sr. Xcoder
1
Sí, seguro que una entrada de cadena estaría bien
Sr. Xcoder
Pero ese JavaScript que se te ocurrió sería ES5, no ES6. Ya se publicó una respuesta de ES6, por eso publiqué el ES5. Y gracias por responder la segunda pregunta jeje
Piyin
1

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!

aloisdg dice Reinstate Monica
fuente
1

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!

jq170727
fuente
1

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
Arc676
fuente
1

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!

Galen Ivanov
fuente
1

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.

Ayb4btu
fuente
1
¡Buena idea! Realmente me gusta
aloisdg dice Reinstate Monica
3 bytes ganados en F # :) codegolf.stackexchange.com/a/147073/15214
aloisdg dice Reinstate Monica el
¡Con el curry puedes ganar 1 byte! Pruébalo en línea!
aloisdg dice Reinstate Monica
0

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

Luis Mendo
fuente