Comment puis-je déterminer si * exactement * un booléen est vrai, sans conversion de type?
Donné un arbitraire liste de booléens, ce qui est la façon la plus élégante de déterminer que exactement l'un d'entre eux est vrai?
Le plus évident hack est le type de conversion: la conversion à 0
pour false
et 1
pour true
et puis en faisant la somme, et le retour sum == 1
.
Je voudrais savoir si il existe un moyen de le faire sans les convertir en entiers, fait à l'aide de la logique booléenne.
(Ce qui semble comme il devrait être trivial, idk, longue semaine)
Edit: Dans le cas où il n'était pas évident, ce n'est plus un code-golf /question théorique. Je ne suis pas embêté à propos de l'utilisation de ce type de conversion /int plus en PROD, code, je suis juste intéressé si il y a moyen de le faire sans que.
Edit2: Désolé les gars c'est une longue semaine et je n'ai pas à m'expliquer. Laissez-moi essayer ceci:
Dans la logique booléenne, ANDing une collection de booléens est vrai si toutes les valeurs booléennes sont remplies, la Bague de la collection est vrai si l'un d'eux est vrai. Est-il une construction logique qui sera vrai si exactement un booléen qui est vrai? XOR est-ce pour une collection de deux booléens par exemple, mais pas plus que cela et il tombe.
source d'informationauteur SCdF
Vous devez vous connecter pour publier un commentaire.
Avec plaine de la logique booléenne, il peut ne pas être possible d'obtenir ce que vous voulez. Parce que ce que vous demandez est une vérité évaluation non seulement fondée sur la vérité des valeurs, mais aussi sur des informations supplémentaires(comptez dans ce cas). Mais boolean évaluation est la logique binaire, il ne dépend de rien d'autre, mais sur les opérandes eux-mêmes. Et il n'y a aucun moyen de le désosser pour trouver les opérandes étant donné une valeur de vérité, car il peut y avoir quatre combinaisons possibles des opérandes, mais seulement deux résultats. Étant donné un faux, pouvez-vous dire si c'est à cause de F ^ F ou T ^ T dans votre cas, de sorte que la prochaine évaluation peut être déterminée sur la base d'?.
Vous pouvez réellement accomplir cela en utilisant seulement la logique booléenne, bien qu'il y a peut-être aucune valeur pratique de cette dans votre exemple. Le booléen version est beaucoup plus que de simplement compter le nombre de vraies valeurs.
De toute façon, pour l'amour de satisfaire la curiosité intellectuelle, va ici. Tout d'abord, l'idée d'utiliser une série de XORs est bon, mais il ne nous fait la moitié du chemin. Pour toutes les deux variables x et y
x ⊻ y
est vrai quand exactement l'un d'entre eux est vrai. Toutefois, cela ne veut pas continuer à être vrai si vous ajoutez une troisième variable z,
x ⊻ y ⊻ z
La première partie, x ⊻ yest encore vrai si exactement un de x et y est vrai. Si x ou y est vrai, alors z doit être faux pour l'ensemble de l'expression pour être vrai, c'est ce que nous voulons. Mais voyons ce qui se passe si les deux x et y sont remplies. Puis x ⊻ y est faux, et pourtant, tout l'expression peut devenir réalité si z est vrai. Alors, soit une variable ou tous les trois doivent être remplies. En général, si vous avez un énoncé qui est une chaîne de XORs, il sera vrai si un nombre impair de variables sont vraies.
Depuis qu'on est un nombre impair, cela pourrait s'avérer utile. Bien sûr, la vérification d'un nombre impair de vérités n'est pas assez. En outre, nous avons besoin de s'assurer que pas plus d'une variable est vrai. Cela peut être fait par paires de la mode en prenant toutes les paires de deux variables et vérifier qu'ils ne sont pas vraies. Pris ensemble, ces deux conditions s'assurer que exactement si les variables sont vraies.
Ci-dessous est un petit script Python pour illustrer l'approche.
Et voici la sortie.
Après vos éclaircissements, ici, il est avec aucun des entiers.
Il peut être fait assez bien avec la récursivité, par exemple en Haskell
Bien sûr, vous pourriez faire quelque chose comme ceci (pseudo-code, puisque vous n'avez pas mention de la langue):
Pas mentionné que cette "opération" que nous recherchons est un raccourci-mesure de la même façon booléens ET et OU dans la plupart des langues. Voici une implémentation en Java:
booleanList.Où(y => y).Count() == 1;
Comment voulez-vous compter combien sont vraies sans, vous le savez, comptage? Bien sûr, vous pourriez faire quelque chose de salissant comme (la syntaxe du C, mon Python est horrible):
Je suis sûr que vous serez d'accord que le gagnant (le cas échéant) est faible, et la lisibilité est mauvais.
OK, un autre essai. Appelez les différentes valeurs booléennes
b[i]
et de l'appeler une tranche d'entre eux (de la matrice)b[i .. j]
. Définir des fonctionsnone(b[i .. j])
etjust_one(b[i .. j])
(on peut remplacer les définitions récursives pour obtenir des formules explicites si nécessaire). Nous avons, en utilisant la notation C pour les opérations logiques (&&
est et,||
est ou,^
pour xor (pas vraiment en C),!
ne l'est pas):Et puis, de manière récursive:
Et vous êtes intéressés à
just_one(b[1 .. n])
.Les expressions sera horrible.
Amusez-vous!
Que le script python fait le travail très bien. Voici le one-liner qu'il utilise:
((x ∨ (y ∨ z)) ∧ ((x ∧ y) ∧ ((z ∧ x) ∧ (y ∧ z))))
Une façon de le faire est d'effectuer deux à deux
AND
et de vérifier ensuite si l'une quelconque des comparaisons par paires retourné véritable avec enchaînéOR
. En python, je voudrais mettre en œuvre à l'aide deCette approche généralise facilement à des listes de longueur arbitraire, bien que pour de très longues listes, le nombre possible de paires se développe très rapidement.
Il n'est pas possible sans boucle. Vérifier BitSet de cardinalité() en java, la mise en œuvre.
http://fuseyism.com/classpath/doc/java/util/BitSet-source.html
Pourquoi ne pas simplement faire:
Court, doux, pas de possibilité de quiconque jamais l'incompréhension de ce qui se passe ici. Et si que est n'importe où près de critique pour les performances de votre application, vous avez beaucoup de travail à faire sur la réorganisation de votre calcul et de représentation des données.
Nous pouvons faire de cette façon:-