Comment trouver si deux nombres sont des nombres consécutifs en gris séquence de code

En fait, plusieurs des autres réponses semblent mauvais: il est vrai que les deux binaire réfléchi Gris code voisins diffèrent que par un seul bit (je suppose que par « le » Gris séquence de code, tu veux dire le binaire original reflète Gris séquence de code comme décrit par Frank Gray). Toutefois, cela ne signifie pas que les deux Gris des codes qui diffèrent par un seul bit sont voisins (a => b ne signifie pas que b => a). Par exemple, le Gris des codes de 1000 et 1010 diffèrent que par un peu, mais ne sont pas des voisins (1000 et 1010 sont respectivement de 15 et 12 en décimal).

Si vous voulez savoir si deux Gris des codes de a et b sont voisins, vous avez pour vérifier si previous(a) = b OR next(a) = b. Pour un Gris code, vous obtenez un seul voisin en positionnant le bit le plus à droite et l'autre voisin peu en inversant les bits à gauche de la droite de bit. Pour le Gris code 1010, les voisins sont 1011 et 1110 (1000 n'est pas l'un d'eux).

Si vous obtenez le précédent ou le suivant voisin en feuilletant un de ces bits dépend en réalité de la parité du Gris code. Cependant, puisque nous voulons tous les deux voisins, nous n'avons pas à vérifier pour la parité. Le pseudo-code devrait vous dire si les deux Gris des codes de pays voisins (à l'aide de C-comme des opérations au niveau du bit):

function are_gray_neighbours(a: gray, b: gray) -> boolean
    return b = a ^ 1 OR
           b = a ^ ((a & -a) << 1)
end

Peu d'astuce ci-dessus: a & -a isole le rigthmost de bit en nombre. Nous décalage de bits d'une position vers la gauche pour obtenir le peu dont nous avons besoin pour flip.

public int checkConsecutive2(int b1, int b2){
    int x =  (b1 ^ b2);

    if((x & (x - 1)) !=0){
      return 0;
    }else{
      return 1;
    }

}

Une réponse évidente, mais il fonctionne.
Convertir chaque gris code dans sa forme Binaire, la différence entre les deux. Si votre réponse est un équivalent binaire de +1 ou de -1, alors les deux gris codes sont adjacentes.

Ce qui semble être un plus tuer, mais quand vous êtes à l'implantation dans une interview et qui ne savent pas la bonne méthode, cela fonctionne. Aussi, pour optimiser, on peut vérifier le bit de différence de filtre, de manière à ne pas perdre le temps de la conversion et la soustraction des nombres que nous savons pour sûr ne sont pas adjacentes.

Vous pouvez vérifier si deux nombres ne diffèrent que par un peu ou pas, comme suit. Dans cette méthode, la différence dans la longueur des nombres binaires sont pris en charge. Par exemple, la sortie 11 (1011) et 3 (11) sera renvoyé dans le vrai.
Aussi, cela ne résout pas le deuxième critère pour les niveaux de Gris code d'adjacence. Mais si vous voulez seulement de vérifier si les chiffres diffèrent d'un bit, le code ci-dessous va vous aider.

class Graycode{
    public static boolean graycheck(int one, int two){
        int differences = 0;
        while (one > 0 || two > 0){
            //Checking if the rightmost bit is same
            if ((one & 1) != (two & 1)){
                differences++;
            }
            one >>= 1;
            two >>= 1;
        }
        return differences == 1;
    }
    public static void main(String[] args){
        int one = Integer.parseInt(args[0]);
        int two = Integer.parseInt(args[1]);
        System.out.println(graycheck(one,two));
    }
}