Trouvez les jumeaux uniques

28

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 .


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
M. Xcoder
la source

Réponses:

7

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.
Dennis
la source
7

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.

Dennis
la source
6

Pyth, 12 9 octets

Essayez-le

[email protected]/d

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

Explication

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

la source
Agréable! Ma solution était également de 12 octets .
M. Xcoder
Jouer ma solution un peu plus bas, 9 octets (en utilisant [email protected]/d) et prendre l'entrée comme une liste de deux listes.
M. Xcoder
@ Mr.Xcoder Cela semble suffisamment différent pour être sa propre réponse.
Étant donné que je suis le PO du défi, j'hésite à le publier. Vous pouvez simplement l'utiliser et donner du crédit, en mentionnant votre approche actuelle comme alternative (si vous le souhaitez bien sûr)
M. Xcoder
5

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
Riley
la source
5

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
Zgarb
la source
4

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

Nahuel Fouilleul
la source
1
Utilisez sort -rnavec sed qà la fin au lieu de tail -1raser 1 octet. Super trouvaille avec grep -wfbtw. +1
seshoumara
@seshoumara, merci pour le conseil, en fait je pourrais raser 3 octets avec l'option -m1 grep.
Nahuel Fouilleul
3

Gelée , 11 octets

ċ@Ị¥Ðf`€f/Ṁ

Essayez-le en ligne!

Erik le Outgolfer
la source
Utilisation intelligente de `!
M. Xcoder
3

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!

Jonas
la source
De manière équivalente, vous pouvez remplacer la pièce d'intersection par e.~#]. Jouer au golf s'est avéré difficile ... J'ai essayé d'utiliser /.-key sans succès ( ((1=#)/.~#~.)pour la première partie qui est de 2 octets de plus selon mon décompte)
cole
@cole, oui, j'ai également essayé une approche clé, et aussi une auto-classification. Je n'ai pas pu battre ma soumission ci-dessus avec une autre approche.
Jonah
2

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.

AdmBorkBork
la source
2

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!

Nate
la source
Bienvenue chez PPCG! Pour autant que je sache, cela ne garantit pas que cela n'apparaît equ'une fois dans aet b.
Martin Ender
@MartinEnder Merci! Modifié la réponse pour refléter les détails que j'ai manqués!
Nate
1
Je n'ai jamais pensé à utiliser lastIndexOfcomme ça, c'est assez intelligent. Vous pouvez le réduire à 86 octets: essayez-le en ligne! . Consultez les conseils JS pour en savoir plus.
Justin Mariner
1
Il semble que l'utilisation (g=x=>x.filter(y=>y==e).length==1)soit plus courte.
tsh
1
Je pense que celui-ci passe également tous les cas de bord (71 octets).
Arnauld
2

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

user28667
la source
Bienvenue au golf PPCG et Haskell en particulier! Ceci est une belle première réponse! Deux petites choses: vous pouvez également déclarer en ftant qu'opérateur infixe et écrire [1|...]==[1]au lieu de sum[1|...]==1pour enregistrer certains octets.
Laikoni
Si vous ne les avez pas déjà vus, voici quelques liens qui pourraient être intéressants: notre collection de conseils de golf à Haskell , le guide des règles de golf à Haskell et Of Monads and Men , notre salon de discussion à Haskell.
Laikoni
1
L'intégration !avec andenregistre deux octets supplémentaires: essayez-le en ligne!
Laikoni
2

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.

Misha Lavrov
la source
2

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

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!

aloisdg dit Réintégrer Monica
la source
2

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!

aloisdg dit Réintégrer Monica
la source
2

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
DLosc
la source
2

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.

Adam
la source
1

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
Luis Mendo
la source
1

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.

Titus
la source
Pensez que vous pouvez échanger ces paramètres GET contre des constantes.
Progrock
@Progrock Ce n'est pas une méthode d'entrée valide.
Titus
Les phrases question que A et B sont données sous forme de tableaux. Et dit toute méthode d'entrée et de sortie raisonnable ... pas que je puisse suivre ce lien facilement. J'aime vraiment votre recette. (Chokes en Php 5.6 obsolète cependant.)
Progrock
1

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
Kevin Cruijssen
la source
1

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 .

Giuseppe
la source
1

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

Piyin
la source
2
Bienvenue chez PPCG! Vous ne pouvez pas supprimer la définition de la fonction, mais vous pourrez peut-être utiliser une fonction lambda à la place (je ne connais pas JS donc je ne peux pas vous aider avec cela).
M. Xcoder
Merci d'avoir clarifié cela. Je ne pense pas que les fonctions lambda puissent enregistrer des caractères, mais je vais essayer. De plus, puisque vous dites "Toute méthode / format d'entrée et de sortie raisonnable est autorisé", puis-je accepter une chaîne sous bet l'enregistrer b=''+b,?
Piyin
J'ai réussi à se rendre à 115 octets , bien que je ne sais pas 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]}.
M. Xcoder
1
Oui, bien sûr, une entrée de chaîne serait bien
M. Xcoder
Mais ce JavaScript que vous avez créé serait ES5, pas ES6. Une réponse ES6 est déjà publiée, c'est pourquoi j'ai publié l'ES5. Et merci d'avoir répondu à la deuxième question hehe
Piyin
1

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!

aloisdg dit Réintégrer Monica
la source
1

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!

jq170727
la source
1

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
Arc676
la source
1

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!

Galen Ivanov
la source
1

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.

Ayb4btu
la source
1
Bonne idée! Je l'aime vraiment
aloisdg dit Reinstate Monica
3 octets gagnés en F # :) codegolf.stackexchange.com/a/147073/15214
aloisdg dit Reinstate Monica
Avec le curry, vous pouvez gagner 1 octet! Essayez-le en ligne!
aloisdg dit Réintégrer Monica
0

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.

Luis Mendo
la source