396621_fr-FR

liliconcom

Défi 9 – Trouver les différences et les similitudes

La nécessité de créer des intersections, des différences et des unions survient lorsque nous avons besoin de connaître des valeurs communes, exclusives ou uniques à deux ou plusieurs ensembles de données. Pour ce mois, créez trois fonctions :

1. intersection ( aList , bList ) – Renvoie une liste de valeurs contenues dans aList et bList .
2. différence ( aList , bList ) – Renvoie deux listes. Le premier contient les valeurs de aList qui ne sont pas dans bList , le second contient les valeurs de bList qui ne sont pas dans aList .
3. union ( aList , bList ) – Renvoie une liste de toutes les valeurs de aList et bList , en supprimant tous les doublons.

Par exemple, si :

aListe = {"a", "b", "c", "d", "e", "e"}

bListe = {"a", "a", "c", "f", "g"}

alors,

intersection (aList, bList) => {"a", "c"}

différence (aList, bList) => {{"b", "d", "e"},{" f", "g"}}

union(aList,bList) => {"a", "b", "c", "d", "e", "f", "g"}

Pour un crédit supplémentaire, étendez l'intersection et l'union pour prendre une liste de trois listes ou plus.

Cantor, pouvez-vous résoudre ce défi ?

Automatisation et scriptsRe: Défi 9 – Trouver des différences et des similitudes

Utilisation de tableaux associatifs et de récursivité. Le code n'est peut-être pas plus facile à comprendre parce que je ne le suis pas : j'utilise des variables de support clairement nommées, j'utilise des tableaux récursifs et associatifs, et il manque également tous les commentaires.

Names Default To Here(1);

intersection = function({temp_list}, {Default Local},
	Try(
		tempAa = Associative Array(temp_list[1]);
		tempAa << Intersect(AssociativeArray(temp_list[2])),
		return("not enough lists provided");
	);
	If(N Items(temp_list) == 2,
		return(tempAa << get keys);
	);
	If(N Items(temp_list) > 2,
		recurse(Insert(EvalList({tempAa << get keys}), Remove(temp_list, 1,2)))
	);
);

difference = function({firstList, secondList}, {Default Local},
	tempAaFirst = Associative Array(firstList);
	tempAaSecond = Associative Array(secondList);
	tempAaFirst << Remove(Associative Array(secondList));
	tempAaSecond << Remove(Associative Array(firstList));
	return(Eval List({tempAaFirst << get keys, tempAaSecond << get keys}));
);

union = function({temp_list}, {Default Local},
	Try(
		Insert Into(temp_list[1], temp_list[2]),
		return("not enough lists provided");
	);
	If(N Items(temp_list) == 2,
		return(Associative Array(temp_list[1]) << get keys);
	);
	If(N Items(temp_list) > 2,
		recurse(Insert(EvalList({Associative Array(temp_list[1]) << get keys}), Remove(temp_list, 1,2)))
	);
);

//test cases
Clear log();
aList = {"a","b","c","d","e","e"};
bList = {"a","a","c","f","g"};
cList = {"a", "b", "c", "h"};
dList = {"i", "j", "k"};

Print("intersection()");
Show(intersection(Eval List({aList})));
Show(intersection(Eval List({aList, bList})));
Show(intersection(Eval List({aList, bList, cList})));
Show(intersection(Eval List({aList, bList, cList, dList})));

Print("\!Ndifference()");
Show(difference(aList, bList));


Print("\!Nunion()");
Show(union(Eval List({aList})));
Show(union(Eval List({aList, bList})));
Show(union(Eval List({aList, bList, cList})));
Show(union(Eval List({aList, bList, cList, dList})));

Cela pourrait devenir un peu lent au moins pour supprimer les valeurs dupliquées lors de l'utilisation de tableaux associatifs, au moins lorsque l'obtention de valeurs uniques à partir de tables de données à l'aide de Summarize devient plus rapide à un moment donné.