Копирование битов: Решение

Опубликовано Dec 22, 2011 в Манипуляция битами | 11 коммент.

, ,

Ниже приведен код, который, по нашему мнению, является приемлемым решением задачи “Копирование битов”

Из кода видно условие проверки корректности значений startBit и stopBit (первый вопрос). Приведенные тестовые вызовы функции дают ответ на второй вопрос, уточняя на примерах ее поведение.

int copy_bits( int A, int B, int startBit, int stopBit) //Post 999
{
/* Биты считаем с нулевого, нулевой - это самый младший бит числа */
if((startBit > stopBit) || !(stopBit >= 0 && stopBit <=31)
|| !(startBit >= 0 && startBit <=31))
{
cout << "Incorrect stopBit||startBit";
return A;
}
int max = ~0; /* All 1’s, so max = 0xFFFFFFFF */
// 1’s through position stopBit, then 0’s
int left = max - ((1 << stopBit) - 1);
// 1’s after position startBit
int right = ((1 << startBit) - 1);
//Mask: 1’s, with 0s between startBit and stopBit
int mask = left | right;
// Clear startBit through stopBit in A
A = A & mask; 
//Clear all bits in B except bits between startBit and stopBit
B = B & ~mask;
// put bits from B there
return A | B;
}
int main()
{/* Unit tests for POST "Копирование битов" */
/* A: 1111 0101 (245) B: 0000 0100 (4) result should be: 1110 0101 (229) */
int n1 = copy_bits(245,4,2,5);
/* A: 1111 0101 (245) B: 0000 0100 (4) result should be: 1100 0101 (197) */
int n2 = copy_bits(245,4,2,6);
/* A: 1111 0101 (245) B: 0000 0101 (5) result should be: 1100 0101 (229) */
int n3 = copy_bits(245,5,2,5);
/* A: 0111 0101 (117) B: 1000 0101 (133) result should be: 0110 0101 (101)*/
int n6 = copy_bits(117,133,2,5);
}

Автор публикации:

11 Коммент. : “Копирование битов: Решение”

  1. Руслан says:

    1) В этом месте

    if((startBit > stopBit) || !(stopBit >= 0 && stopBit = 0 && startBit <=31))

    2-я проверка лишняя.

    2)
    A = A & mask
    можно записать покороче:
    A &= mask;

  2. Руслан says:

    Код что-то нормально в комментарии не вставляется

  3. Проверяется то, что startBit меньше чем stopBit и то, что оба этих значения попадают в диапазон о 0 до 31 (четырехбайтные целые числа).
    Замечание 2) – верное.

  4. Олька says:

    // Clear startBit through stopBit in A
    A = A & mask;

    обязательно необходимо добавить строку
    B = B & ~mask;
    иначе работает не корректно!!!

    /* A: 1111 0101 B: 0000 0110 result should be: 1100 0101 (229) */
    int n3 = copy_bits(245,5,2,5);
    Здесь тоже не совсем правда

  5. На каких исходных данных без строки B = B & ~mask; работает не корректно – приведите, пожалуйста, пример.

    Здесь тоже не совсем правда

    – таки да, неправильно записали число 5 в двоичном представлении, исправили.
    Изменяем биты со 2-го по 4-ый, StopBit НЕ МЕНЯЕМ.

    Биты   7 6 5 4   3 2 1 0
    ----------------------------
    (245)  1 1 1 1   0 1 0 1
    (5)    0 0 0 0   0 1 0 1
    ----------------------------
    (229)  1 1 1 0   0 1 0 1
    
    • Артём says:

      В условии задачи написано “Напишите функцию, которая бы скопировала биты из числа A в число B”, а Вы делаете наоборот – из числа В в число А, – тогда должно получится так:

      Биты 7 6 5 4 3 2 1 0
      —————————-
      (245) 1 1 1 1 0 1 0 1
      (5) 0 0 0 0 0 1 0 1
      —————————-
      (21) 0 0 0 1 0 1 0 1

  6. Олька says:

    Если int n3 = copy_bits(245,6,2,5);
    то должно быть
    Биты 7 6 5 4 3 2 1 0
    —————————-
    (245) 1 1 1 1 0 1 0 1
    (6) 0 0 0 0 0 1 1 0
    —————————-
    (229) 1 1 1 0 0 1 0 1
    а в данном решение получится 231

    или к примеру возьмем copy_bits(117,133,2,5);
    получим 229, а должно быть 101
    Биты 7 6 5 4 3 2 1 0
    —————————-
    (117) 0 1 1 1 0 1 0 1
    (133) 1 0 0 0 0 1 0 1
    —————————-
    (101) 0 1 1 0 0 1 0 1

  7. Олька says:

    A &= mask; обнуляется та часть куда будут копироваться биты
    B &= ~mask; обнуляются те биты которые не будут копироваться в A, за пределами необходимого интервала
    A | B непосредственное копирование

  8. Олег says:

    Я бы маску вычислял чуть проще:
    int ones = ~0; // 111111111
    int first = ones<<startBit; // 111111100
    int second = ones<<(stopBit); // 111000000
    int mask = first^second; // 000111100 – маска

    //return (A&mask)|(B&(~mask)); // из A в B
    return (B&mask)|(A&(~mask)); // из B в А

    И еще, у вас по примерам получается что вы копируете из B в А, хотя по условию надо копировать биты из А в B.

  9. Объясните пожалуйста как тут происходит копирование от 2 до 4 бита??

    Биты 7 6 5 4 3 2 1 0
    —————————-
    (245) 1 1 1 1 0 1 0 1
    (5) 0 0 0 0 0 1 0 1
    —————————-
    (229) 1 1 1 0 0 1 0 1

    —————————-
    Как я понимаю копирование должно происходить так(так же 2-4 биты)
    Биты 7 6 5 4 3 2 1 0
    —————————-
    (255) 1 1 1 1 1 1 1 1
    (0) 0 0 0 0 0 0 0 0
    —————————-
    (12) 0 0 0 0 1 1 0 0

    или я не понял задания??

Оставить комментарий

Ваш адрес email не будет опубликован.


*