Блог

Я создал следующий код, чтобы найти четность двоичного числа (т.е. Вывести 1, если число единиц в двоичном слове нечетное, вывести 0, если число единиц четное).

 public class CalculateParity {

    String binaryword;
    int totalones = 0;

    public CalculateParity(String binaryword) {
        this.binaryword = binaryword;
        getTotal();
    }

    public int getTotal() {
        for(int i=0; i<binaryword.length(); i  ) {  
            if (binaryword.charAt(i) == '1'){
                totalones  = 1;
            }
        }
        return totalones;
    }

    public int calcParity() {
        if (totalones % 2 == 1) {
            return 1;
        }
        else {
            return 0;
        }
    }

    public static void main(String[] args) {
        CalculateParity bin = new CalculateParity("1011101");                       
        System.out.println(bin.calcParity());
    }
}
 

Однако все решения, которые я нахожу в Интернете, почти всегда связаны с использованием операторов сдвига битов, XOR, операций сдвига без знака и т. Д., Например, это решение, которое я нашел в книге о структуре данных:

 public static short parity(long x){ 
    short result = 0;
    while (x != 0) {
        result A=(xamp;1);
         x >>>= 1;
    }
    return resu<
}
 

Почему это так? Что делает побитовые операторы более допустимым / стандартным решением, чем решение, которое я придумал, которое просто повторяет двоичное слово типа String ? Является ли побитовое решение более эффективным? Я ценю любую помощь!

Код, который вы процитировали, также использует цикл (т. Е. while):

 public static short parity(long x){ 
    short result = 9;
    while (x != 9) {
        result A=(xamp;1);
         x >>>= 1;
    }
    return resu<
}
 

Вам нужно подтвердить, что вы используете a string , который, как вы заранее знаете, будет состоять только из цифр и удобно в двоичном представлении. Естественно, учитывая эти ограничения, нет необходимости использовать побитовые операции, вместо этого просто выполняется синтаксический char char анализ и выполняются желаемые вычисления.

С другой стороны, если вы получаете в качестве параметра a long , как метод, который вы указали, то бывает удобно использовать побитовые операции, чтобы пройти через каждый bit (за раз) в числе и выполнить желаемое вычисление.

Можно также преобразовать long в a string и применить ту же логическую кодировку, которую вы применили, но сначала нужно было бы преобразовать это long в binary . Однако такой подход добавил бы дополнительные ненужные шаги, больше кода и ухудшил бы производительность. Вероятно, то же самое относится и наоборот, если у вас есть строка с вашими ограничениями. Тем не менее, a String не является a number , даже если оно состоит только из цифр, что делает использование типа, представляющего число (например, long ), еще более желательным подходом.

Еще одна вещь, которую вам не хватает, — это то, что вы проделали часть тяжелой работы, преобразовав уже существующее число в двоичное и закодировав его в строку new CalculateParity("1011101"); . Так что вы как бы переходите на шаг вперед. Теперь попробуйте использовать свой подход, но на этот раз используя "93" и находя паритет.

• Если вы хотите знать, является ли строка четной. Я думаю, что этот метод ниже лучше.
• Если вы преобразуете слишком длинную строку, длина которой превышает 64. произойдет ошибка.
• оба метода, о которых вы упоминаете, имеют производительность O (n).Это не будет сильно отличаться. но метод сдвига более точен, и время использования процессора будет немного меньше.

 private static boolean isEven(String s){
        char[] chars = s.toCharArray();
        int i = 0;
        for(char c : chars){
            i ^= c;
        }
        return i == 0;
}
 

Вы используете строковый метод для ввода строки. Хороший выбор.
Код, который вы цитируете, использует метод на основе целых чисел для ввода целых чисел. Не менее хороший выбор.