Vous recevrez deux tableaux / listes / vecteurs d'entiers non négatifs A et B . Votre tâche est de produire le plus grand entier N qui apparaît à la fois A et B , et est également unique dans les deux A et B .

• Vous pouvez supposer qu'il existe au moins un tel numéro.

• Toute méthode / format d'entrée et de sortie raisonnable est autorisé.

• Ces échappatoires sont interdites.

• C'est le code-golf , donc le code le plus court dans tous les langages de programmation gagne!

Cas de test:

A, B -> Sortie

[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

Gelée , 7 octets

fċ@ÐṂ;Ṁ

Essayez-le en ligne!

Comment ça marche

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 octets

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

Merci à @seshoumara d'avoir joué au golf sur 1 octet!

Essayez-le en ligne!

Comment ça marche

uniq prend les entrées triées et effectue une ou plusieurs actions, selon les indicateurs de ligne de commande.

U<<<$1 et U<<<$2 appelez la fonction Uavec le premier et le deuxième argument de ligne de commande en entrée. Pour chacun, sort -rn|uniq -uest exécuté, triant l'entrée numériquement ( -n) et dans l'ordre décroissant ( -r) pour uniq , qui n'imprimera que des lignes uniques ( -u).

La sortie des deux (éléments uniques de chaque tableau) est concaténée et dirigée vers U D , c'est- -dire
sort -rn|uniq -uD. Cette fois, uniq n'imprimera que les lignes en double ( -D), et seulement la première répétition de chacune.

Alors que la page de manuel indique qu'elle imprimera toutes les répétitions, les -ucauses ajoutées -Dn'imprimeront que la première occurrence des lignes dupliquées. Ce comportement est normalement obtenu avec uniq -d.

Finalement, sed q quitte immédiatement, réduisant son entrée (éléments uniques des deux tableaux) à sa première ligne. Étant donné que la sortie a été triée par ordre décroissant, il s'agit du maximum.

Pyth, 12 9 octets

Essayez-le

eS@Fm.m/d

Enregistré 3 octets grâce à M. Xcoder.

Explication

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 octets

7 octets enregistrés grâce à @ Mr.Xcoder , @ pizzapants184 et @ovs

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

Essayez-le en ligne!

05AB1E , 9 8 octets

-1 octet grâce à Erik l'Outgolfer

εТÏ}`Ãà

Essayez-le en ligne!

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

Husk , 7 octets

→►≠OfEΠ

Prend l'entrée comme une liste de deux listes, fonctionne également pour n'importe quel nombre de listes (renvoyant le nombre le plus élevé qui se produit exactement une fois dans chacune, si possible). Essayez-le en ligne!

Explication

Il s'agit de la première réponse Husk à (ab) utiliser la nouvelle fonction "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 octets

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

Essayez-le en ligne

Bash, 89 octets

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

Gelée , 11 octets

ċ@Ị¥Ðf`€f/Ṁ

Essayez-le en ligne!

J, 23 octets

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

(-.-.@~:#]) supprime d'une liste tous les éléments répétés

& faites cela aux deux arguments

([-.-.) Nous voulons que A intersecte B. C'est la phrase équivalente: "A moins (A moins B)"

>./ Prenez le maximum

Essayez-le en ligne!

PowerShell , 94 octets

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

Essayez-le en ligne!

Prend des entrées $aet des $btableaux. Construit un filterqui groupest des éléments de réseau d'entrée en même temps et sort seulement ceux qui ont un count -equel à1 ( par exemple, seuls ceux qui sont uniques dans le tableau d'entrée).

La ligne suivante construit ensuite l'algorithme. D'abord, nous sort $aretirons ensuite ceux qui sont -inles éléments uniques de $b. Ceux-ci sont alors eux-mêmes uniques, le plus grand [-1]est choisi, et nous en prenons .Name. Cela reste sur le pipeline et la sortie est implicite.

Javascript (ES6), 102 86 75 71 octets

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

Merci @justinMariner d'être passé de 102 à 86

Merci @tsh d'être passé de 86 à 75

Merci @Arnauld d'être passé de 75 à 71

Essayez-le en ligne!

Haskell , 57 53 octets

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

Essayez-le en ligne!

UPD: Merci @Laikoni

Wolfram Language (Mathematica) , 40 octets

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

Essayez-le en ligne!

Comment ça marche

Tally@#donne une liste des éléments uniques de la première entrée, ainsi que leur nombre: par exemple, les Tally[{2,2,2,6,3,5,8,2}]rendements {{2,4},{6,1},{3,1},{5,1},{8,1}}.

Tally@#2fait de même pour la deuxième liste et ⋂trouve des paires présentes dans les deux. Ensuite, nous sélectionnons (avec Cases) les paires se terminant par 1, en prenant le premier élément de chaque résultat, ce qui nous donne une liste de tous les jumeaux uniques. Enfin, Maxretourne le plus grand jumeau unique.

Röda , 48 octets

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

Essayez-le en ligne!

Inspiré par la réponse jq de jq170727 .

Explication:

{ /* 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 de base) , 117 115 114 111 108 octets

115 114 octets

Une autre solution avec countBycette fois:

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

Essayez-le en ligne!

117 111 octets

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

Essayez-le en ligne!

100% F #! Toute aide est la bienvenue!

6 octets gagnés grâce à la notation des préfixes!

108 octets

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

@est la fonction concat! Merci @ Ayb4btu pour cet algorithme.

Essayez-le en ligne!

C # (.NET Core) , 85 84 octets

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

Essayez-le en ligne!

Solution naïve avec LINQ ( using System;using System.Linq;+ 31 caractères, donc 116 octets avec en-tête)

84! J'ai oublié de curry!

Pip , 17 16 octets

MX{_Na=_Nb=1FIa}

Il s'agit d'une fonction qui prend deux listes comme arguments. Essayez-le en ligne!

Explication

  {            }  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 caractères = 23 octets *

Un corps de programme complet. Demande la liste des listes de STDIN. Fonctionne avec n'importe quel nombre de listes. Sorties vers STDOUT.

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

Essayez-le en ligne!

⎕ invite pour l'entrée évaluée de STDIN

{… }⌸¨ Pour chaque liste, appelez la fonction suivante pour chaque élément unique de cette liste, en utilisant l'élément unique comme argument de gauche ( ⍺) et la liste des indices de son occurrence comme argument de droite ( ⍵):

 ≢⍵ le décompte des indices (ie le nombre d'occurrences)

 1= égal à 1

 ⍺⍴⍨ utiliser cela pour remodeler l'élément spécifique (c.-à-d. donne une liste vide s'il n'est pas unique)

Nous avons maintenant deux listes d'éléments uniques pour chaque liste d'entrée (bien que chaque élément soit une liste, et il existe des listes vides comme résidu des éléments non uniques).

∩/ intersection (réduction)

∊ ϵ nlist (aplatir)

⌈/ max (réduction)

* en Classique, comptant ⌸comme ⎕U2338.

MATL , 13 octets

,iSY'1=)]X&X>

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

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

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

Fournissez des tableaux en tant que paramètres GET aet b.

Java 8, 133 octets

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

Explication:

Essayez-le ici.

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 octets

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

Essayez-le en ligne!

Calcule l' Aintersection B, puis le maximum de la différence entre cela et les éléments dupliqués de AetB .

JavaScript ES5, 122 121 114 octets

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

Je suis nouveau ici, donc je ne sais pas vraiment si je peux supprimer la définition de la fonction et simplement mettre son contenu (ce qui me ferait économiser 17 octets)

Voici l'exemple de travail: 122 121 114

122 à 121 octets: initialisation de l'habillage dans un for

121 à 114 octets: bdoit être une chaîne

SQLite , 118 octets

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)

Essayez-le en ligne!

Première fois en SQL, toute aide est la bienvenue!

Jq 1,5 , 76 octets

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

Étendu

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

Essayez-le en ligne!

Voici une autre solution de même longueur:

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

Étendu

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

Essayez-le en ligne!

APL, 47 octets

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

Déclare une fonction anonyme qui prend deux vecteurs, élimine les éléments en double, puis trouve le plus grand élément à l'intersection des résultats.

A←⍺et B←⍵stocker les arguments passés à la fonction dans Aet B.

a=brenvoie un vecteur avec 1 dans chaque index dans lequel aest égal à b. Si aest un scalaire (c'est-à-dire une quantité unique et non un vecteur), cela renvoie un vecteur avec 1 partout où l'élément dans best aet 0 quand il ne l'est pas. Par exemple:

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

{+/⍵=A}: fonction anonyme imbriquée; trouver les occurrences de l'argument dans le vecteur Aet les additionner, c'est-à-dire trouver le nombre d'occurrences de l'argument dansA

1={+/⍵=A}¨A: appliquer la fonction anonyme imbriquée à chaque élément de A et trouver ceux qui égalent 1, c'est-à-dire des éléments uniques

((1={+/⍵=A}¨A)/A←⍺): après avoir trouvé l' emplacement des éléments uniques, sélectionnez uniquement ces éléments dans le vecteur d'origine ( /sélectionne parmi les arguments de droite les éléments dont les emplacements correspondent à 1 dans l'argument de gauche)

R←((1={+/⍵=A}¨A)/A←⍺)∩(1={+/⍵=B}¨B)/B←⍵: répète le processus pour le deuxième argument; maintenant que nous avons juste les éléments uniques, trouvez l'intersection c'est-à-dire les éléments communs et stockez-les dans le vecteurR

R[⍒R]: accéder aux éléments de Rdans l'ordre décroissant

1↑R[⍒R]: prendre le premier élément du Rmoment où il est trié par ordre décroissant

Cas de test:

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 octets

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

Comment ça marche:

Je commence par tester où les deux listes se chevauchent =/(insère un test d'égalité entre tous les membres des listes:

   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

Plus d'un 1 dans la même colonne signifie que le nombre n'est pas unique pour l'argument de gauche (6 dans ce cas); dans la rangée - pour le bon argument (3)

Ensuite, je résume toutes les lignes et toutes les colonnes pour trouver où sont les doublons:

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

Je trouve le produit cartésien des listes ci-dessus et définit les membres supérieurs à 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

Je masque la matrice d'égalité c avec m pour trouver les éléments uniques communs aux deux listes et multiplie l'argument de gauche par ceci.

]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

Ensuite, j'aplatis la liste et trouve l'élément max:

 >./,l 
4

Essayez-le en ligne!

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

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

Essayez-le en ligne!

+31 octets pour using System;using System.Linq;

Je me suis inspiré de la réponse de @ aloisdg. Cependant, au lieu de rechercher des valeurs uniques dans les deux tableaux, j'ai inversé l'ordre des opérations afin que ce intersectsoit en premier, puis je trouve la valeur maximale des éléments qui se produisent deux fois lorsque les tableaux sont concaténés et se trouvent à leur intersection. Je peux utiliser <3comme Countsera au moins 2 pour n'importe quelle valeur, comme ce sera dans les deux tableaux.

Remerciements

-1 octet grâce à @aloisdg et sa suggestion d'utiliser le Funccurry.

Octave , 57 56 octets

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

Fonction anonyme qui prend en entrée un tableau de cellules de deux tableaux numériques.

Essayez-le en ligne!

Explication

Pour chacun ( cellfun(@(x)...)) des deux tableaux d'entrée, cela crée une matrice de comparaisons d'égalité par paire entre ses entrées ( x.'==x); conserve ( x(...)) uniquement les entrées pour lesquelles la somme des colonnes est 1( sum(...)==1); et emballe le résultat dans une cellule ( {...}). L'intersection ( intersect) des deux résultats ( {:}) est calculée et le maximum ( max(...)) est pris.

Wolfram Language (Mathematica) , 49 octets

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

Essayez-le en ligne!