J'ai réfléchi à ce problème pendant des heures. Ici c'est:
Écrivez une expression qui retourne 1 si un entier "X" donné a des bits égaux à 1. Retournez 0 sinon.
Je comprends que je suis essentiellement d'essayer de comprendre si x == 0 parce que c'est le seul Int qui n'a pas de 1 bits, mais je ne peux pas comprendre une solution. Vous ne pouvez pas utiliser les structures de contrôle traditionnelles. Vous pouvez utiliser des opérateurs binaire, une addition, une soustraction et des changements de bits. Suggestions?
13 Réponses :
masque chacun des bits individuellement, déplacez-les tous vers la position LSB, et ou à eux ensemble.
Comme dans 16 expressions différentes pour 16 bits? Je pense qu'il y a une solution plus élégante.
Voici le meilleur que je puisse proposer: où bits = 32 pour 32 bits INTS, c'est-à-dire Voici un programme de test: P> bits = taille de (int) * char_bit; code> #include <stdio.h>
#include <stdlib.h>
#include <limits.h>
int main(int argc, char *argv[])
{
const int BITS = sizeof(int) * CHAR_BIT;
if (argc == 2)
{
int x = atoi(argv[1]);
int y = (((-x) | x) >> (BITS - 1)) & 1;
printf("%d -> %d\n", x, y);
}
return 0;
}
Attendez, (-x) | x n'est pas toujours 1 ??
Pour 0 est 0 sinon msb bit équivaut à 1
-x >> (bits - 1) fonctionne bien je pense. Le | x est inutile parce que vous allez déplacer ces bits quand même
-x ne fonctionne pas sur les nombres négatifs. -x | x Définit 1 msb bit, car l'une des deux valeurs est négative.
@MARLON: Comme @RRALU dit, vous devez vous assurer que si X est négatif, vous obtenez toujours le jeu MSB, d'où le besoin de -x | x
Bonjour @Paulr !! Je cherche un problème similaire ... j'écris une commande et je veux vérifier si x = 0. La seule commande conditionnelle est JMP N, qui vérifie si la valeur du courant est négative, si oui, nous allons ensuite à la commande n, si non, nous venons de continuer. Nous devons donc vérifier est X <0. Mais nous devons aussi vérifier si x> 0, mais comment? Utilisation de l'opération Bitwise, ce n'est pas le négatif du nombre, c'est l'inverse des bits ....
@Marystar: Vous pouvez simplement le faire avec deux tests: faites un JMP N pour gérer des valeurs négatives, puis effectuez un deuxième JMP N - Ce deuxième test traitera des valeurs positives> 0, mais une valeur nulle toujours être zéro après un peu pas.
Mais par le biothèques, pas un niveau négatif d'un? @Paulr
@Marystar: Le bitwise ne vous donne pas le complément de 1, mais cela n'a pas d'importance - tout ce qui compte, c'est que le bit de signalisation sera défini si X est positif, vous pouvez simplement utiliser JMP N pour tester cela.
Vous pouvez simplement lancer votre int à un bool . Mais je doute que c'est le but de vos devoirs; -)
bool n'existe pas dans la norme C (seulement C99).
Vrai, et il utilise probablement la logique de branche interne, qui viole les règles des devoirs. Mais dans le cas général (si soutenu par la langue), il est un moyen concis de faire le travail.
@Sven Marnach: Je pense que j'appellerais C99 "Standard C" et tout le reste "Hors date Old C".
non testé, c'est la première chose qui me suis venu à mon esprit: si e == 16 après la boucle n est 0. < / p>
Vous semblez utiliser beaucoup plus que des opérations bitwises ici?
pow (2, e) doit être remplacé par 1 << e qui est beaucoup plus rapide et satisfait également aux exigences
int any_bits_to_one(unsigned int n) {
int result = 0, i;
for (i=0; !result && i < sizeof(unsigned int) * 8; i++)
result |= (n & (1<<i)) ? 1 : 0;
return result;
}
pour les entiers 32 bits
Bitwise et avec 0 et tout nombre doit être égal à zéro, mais le seul test anti-infaillible serait avec 0xFFFF ou tout un peu défini. Pour obtenir tous les bits, vous devez avoir une INT signée et l'attribuer -1. Vous aurez alors un int avec tous les bits définis à 1, quelle que soit la taille.
Donc, ma réponse serait vers le sens du bit et elle avec -1
Pour une valeur 32 bits, les éléments suivants fonctionneront pour tous les modèles bit.
return (a | -a) >> 31;
Assurez-vous que le changement est logique et non arithmétique du cours - dans C utiliser le type non signé.
Notez également que la solution "retour ~ (x ^ x-1) >> 31;" Ci-dessus, ne fonctionne pas pour la valeur 0x80000000.
Pour le décalage arithmétique, il peut être modifié à - ((a | -a) >> 31)
On dirait! (x && ~ x) && x? Cela semble fonctionner, mais je ne sais pas quand le débordement se produit.
Si vous êtes autorisé && alors x && 1 est un peu plus simple
0 || Number - cela reviendra 0 uniquement si le numéro est 0 et retournera 1 si le numéro est un autre nombre de 0. Étant donné qu'un numéro sans bit comme 1 sera égal à 0, nous devons vérifier avec 0.
|| n'est pas autorisé car c'est un opérateur logique
Utiliser !! X vous donnera la bonne réponse. Depuis! 0 = 1 et! (Tout numéro non nul) = 0.
De c perspective qui est la meilleure solution, mais ce n'est pas en respectant les contraintes de la tâche.
Je crois que c'est la manière la plus simple.
return !!(0|x);
Malheureusement, ! est un opérateur logique qui n'est pas autorisé
en langage C, toute valeur autre que zéro (positif ou négatif) est traité comme vrai. Et il devrait y avoir une condition de vérifier que la solution de votre question renvoie à zéro ou à un (ou autre que zéro). Par conséquent, cette réponse est parfaitement selon vos besoins. Cela utilise uniquement des opérateurs bit-sisage.
return (x & 0xFFFF);
Est-ce pour n'importe quelle taille entier ou avez-vous une taille connue?
L'ajout et la soustraction ne sont pas des opérations biteux ...
Si l'une des réponses résout votre problème, vous devriez le vérifier comme «accepté».