Comment trouver TMax sans l'aide de changements

En utilisant UNIQUEMENT

 ! ~ & ^ | +

Comment puis-je savoir si un nombre 32 bits est TMax?

TMax est le maximum, en complément à deux du nombre.

Mes pensées ont été jusqu'à présent:

int isTMax(int x)
{
  int y = 0;

  x = ~x;
  y = x + x;

  return !y;
}

Qui est juste une des nombreuses choses que j'ai en vain ont essayé, mais je ne peux pas penser à une propriété de TMax, qui me donnerait TMax dos. Comme l'ajout de tmax à lui-même devrait être unique par rapport à tous les autres entiers.

Ici, est le problème réel:

/*
 * isTMax - return 1 if x is the maximum, two's complement number,
 *     and 0 return otherwise. 
 *   Legal ops: ! ~ & ^ | +
 *   Max ops: 10
 *   Rating: 1
 */
int isTMax(int x) {
        int y = 0;

  x = ~x;
  y = x + x;

  return !y;
}

int de 32 bits, donc le max signés serait probablement 0x7FFFFFFF

  • Qu'est-ce que TMax? Le maximum de non signé (ou signé) entier?
  • Je pense que vous aurez besoin d'élaborer sur ce que le TMax est.
  • Maximum en complément à deux du nombre. Désolé de ne pas élaborer.
InformationsquelleAutor David | 2011-09-04
  1. 0

    Quelque chose comme ceci peut-être?
    0x7FFFFFFF est le maximum positif signé sur 32 bits en complément à deux du nombre.

    int isTMax(int x){
    return !(x ^ 0x7FFFFFFF);
}

    Je ne suis pas sûr, vous pouvez avoir besoin de le jeter aux non signé pour que cela fonctionne.

    • Casting n'est pas autorisé.
    • Cela fonctionne parfaitement merci beaucoup, je ne sais pas pourquoi j'ai essayé de overthink il.
    • Est cette réponse acceptable? J'ai été en supposant constantes n'ont pas été autorisées, soit. Si oui, alors oui, c'est la meilleure solution.
    • Les constantes sont autorisés parce que nous supposons ses un nombre 32 bits depuis en C ints sont 32 en longueur.
    InformationsquelleAutor Ben Goodrich
  2. 4

    Autant que je sache, il n'y a aucun moyen de déterminer si une valeur est la valeur max d'un signé type sans en sachant déjà la valeur maximale de ce type et de faire une comparaison directe. C'est parce que signé des expressions de l'expérience d'un comportement indéfini de débordement. Si il y avait une réponse à votre question, cela impliquerait l'existence d'une réponse à un grave problème non résolu qui a été flottant autour sur pendant un certain temps: procédure de programmation pour déterminer la valeur maximale pour un type signé.

    • le dépassement est pas traitée uniquement en 32 bits seront représentées si il va sur son perdu.
    • Non, il invoque un comportement indéfini et vous ne pouvez pas supposer quoi que ce soit sur le programme de la sortie. Celui qui est venu avec cette affectation, apparemment, ne sait pas C...
    InformationsquelleAutor R..
  3. 1
    int isTmax(int x) {


    //add one to x if this is Tmax. If this is Tmax, then this number will become Tmin
    //uses Tmin = Tmax + 1
    int plusOne = x + 1;

    //add to x so desired input becomes 0xFFFFFFFF, which is Umax and also -1
    //uses Umax = 2Tmax + 1
    x = x + plusOne;

    plusOne = !(plusOne);

    //is x is 0xffffffff, then this becomes zero when ~ is used
    x = ~x;
    x = x | plusOne;
    x = !x;

    return x;
}
    InformationsquelleAutor N.W.
  4. 0
    #include <stdio.h>
#include <stdlib.h>

int test(int n) {
  return !(n & 0x80000000) & !~(n | (n + 1));
}

//or just effectively do a comparison

int test2(int n) {
  return !(n ^ 0x7fffffff);
}

int main(int ac, char **av) {
  printf("is%s TMax\n", test(atoi(av[1])) ? "" : " not");
  return 0;
}
    InformationsquelleAutor DigitalRoss
  5. 0

    si c'est Tmax : 011111.....

    puis nous xor avec 10000....

    nous obtenons 11111....

    puis nous ~ pour obtenir tous les 0 = 0 , !0 nous obtenons 1:

    int isTmax(int x) {
  return !(~((1 << 31) ^ x ));
}
    • veuillez noter que << est interdit dans le titre
    InformationsquelleAutor XueYu
  6. 0

    Passer 3 heures sur ce problème. Je sais que ce problème vient de csapp les données de laboratoire et de sa toute dernière exigence est 

    1. Integer constants 0 through 255 (0xFF), inclusive. You are
  not allowed to use big constants such as 0xffffffff
....

* isTmax - returns 1 if x is the maximum, two's complement number,
 *     and 0 otherwise
 *   Legal ops: ! ~ & ^ | +
 *   Max ops: 10
 *   Rating: 1

    Donc, le changement d'opérateur(<</>> et 0x7FFFFFFF accepté de répondre est interdit maintenant)

    Ci-dessous est ma façon:

    TDD-style:

    isTmax(2147483647) == isTmax(0b011111111111...1) == 1
isTmax(2147483646) == isTmax(0b011111111111...0) == 0
isTmax(-1) == isTmax(0b111111111...1) == 0
isTmax(-2147483648) == isTmax(0b100000000...0) == 0

    le retour doit être 0 ou 1. Dans, c, ! + tout différent de zéro sera de retour 0. Donc ! est un must, sinon nous ne pouvons pas garantir l'obtention 0 pour tous les nombres.

    Première naïf essayer:

    parce que 0b0111111...1(aka 2147483647) est le seul argument qui devrait faire isTmax retour 1 et 2147483647 + 1 devrait être 10000000...0(aka -2147483648)

    0b011111111...1 xor 0b1000000000...0 est 0b11111111111...111. Parce que nous devons utiliser !, ce que nous espérons voir se 0(aka 0b0000000000000...0). De toute évidence, il suffit d'appliquer logique de ne pas(aka !) à 0b1111111...1), puis nous aurons 0b000000000000):

    !(~(x ^ (x + 1))

    laisser printf il

    void print(int x)
{
     printf("%d\n", !(~(x ^ (x + 1))));
}
int main() {
        print (2147483647);
        print(2147483646);
        print(-1);
        print(-2147483648);
}

    1

    0

    1

    0

    démo

    Pas mauvais, seulement -1 ne fonctionne pas comme nous l'espérions.

    deuxième essai:

    Comparons -1 et 2147483647

    11111111111111111111111111111111

    01111111111111111111111111111111

    Nous pouvons trouver -1 + 1 = 0 tout 2147483647 + 1 = -2147483648. Souligner encore une fois, ce que nous voulons, c'est diff -1 et 2147483647, parce que les deux d'entre eux de retour 1 comme ci-dessus montre. Regarder en arrière pour le protety de logique de ne pas dans c: toute différente de zéro sera de retour 0, donc !-2147483648 == 0 et !(-1 + 1) != 0. Ne modifier que la partie gauche de l' x ^ (x + 1)(x) dans x + !(x + 1). Si x est 2147483647, x + !(x + 1) sera égale à x.

    Exécuter de nouveau: 

    void print(int x)
{
    printf("%d\n", !(~( x + !(x + 1) ^ (x + 1))));
}
int main() {
        print (2147483647);
        print(2147483646);
        print(-1);
        print(-2147483648);
}

    1

    0

    0

    0

    démo

    Fait!

    InformationsquelleAutor 陳 力