Сколько установлено пар бит в числе

    unsigned char a=57;
    int l=sizeof(a)*8;
    char *mask=(char*)malloc(l+1);
 
    memset(mask,'0',l);
    mask[l-2]=mask[l-1]='1';
    mask[l]=0;
    for(; a; a>>=1)
    {
        if((a&3)==3) printf("%s\n",mask);
        memmove(mask,mask+1,l-1);
        mask[l-1]='0';
    }
    free(mask);

#include <stdio.h>
 
/* Msk - маска, содержащая 1 в своём старшем разряде и нули во всех остальных.
   Эта маска позволяет "вырезать" старший бит числа.
   Определяем её как макрос препроцессора.                                    */
 
#define Msk    (1 << sizeof(int) * 8 - 1)
 
 
int main()
{
 int n, N;     /* n - анализируемое число.
                  N - его копия, используемая для вспомогательных нужд.   */
 int i;
 int t;
 int p = 0;    /* Счётчик числа пар соседствующих единичных бит.  */
 int s = 0;    /* Переменная, хранящая состояние прошлого бита,
                  которое используется при анализе текущего бита. */
 int m;        /* Остаток от деления p на 10. Используется для получения
                  правильного окончания в выходном сообщении.             */
 
 
 /* Выводим подсказку-приглашение для ввода. */
 
 printf("Введите целое число:           ");
 
 
 /* Вводим анализируемое целое число в десятичной форме. */
 
 t = scanf("%d", &n);
 
 
 /* Анализируем возвращённое функцией scanf() значение, чтобы выявить ошибку
    при вводе числа. Если она действительна произошла, выводим сообщение
    в стандартный поток ошибок stderr и завершаем работу программы. */
 
 if(t==0 || t==EOF)
   {fprintf(stderr, "Данные введены с ошибкой. "
                    "Программа завершает свою работу.\n");
    return 1; }
 
 
 /* Выводим это же число в двоичном виде. Этого не требуется в задании,
    но это полезно нам, чтобы посмотреть, как выглядит число в двоичной форме.
    Т. к. в C нет спецификатора формата для двоичного представления чисел,
    позволяющего вывести целое число в двоичном виде с помощью функции
    printf(), пишем для этого маленький алгоритм c циклом и сдвигами в нём.   */
 
 printf("Двоичное представление числа:  ");
 
 N = n;        /* Работаем с копией N числа n. */
 
 for(i=0; i < sizeof(int) * 8; i++)
  {printf("%d", N & Msk ? 1 : 0);    /* Если в старшем бите числа N
                                        находится 1 - выводим 1,
                                        в противном случае выводим 0.  */
   N <<= 1;    /* Сдвигаем N на 1 бит влево. */
  }
 
 printf("\n");
 
 
 /* Подсчёт количества пар соседних единичных бит в числе n.
    Ведём его путём поразрядного сдвига числа n влево точно так же,
    как мы делали и при выводе этого числа в двоичном коде. */
 
  while(n)      /* Выполняем цикл, пока в числе есть хоть один единичный бит. */
{
 if(n & Msk)    /* Если в старшем разряде стоит 1,... */
   {if(s) p++;  /* Если в прошлый раз в старшем разряде была 1, увеличиваем
                   количество найденных пар соседних единичных бит на 1.    */
    s = 1;      /* Запоминаем, что в старшем разряде находилась 1,
                   для следующей итерации цикла, в которой будет
                   анализироваться следующий бит.                  */
   }
 else s = 0;    /* Если в старшем разряде находился 0, запоминаем это
                   для следующей итерации цикла. */
 n <<= 1;       /* Сдвигаем n на 1 двоичный разряд влево. */
}
 
 
 /* Выводим число p пар соседних единичных бит в числе n. Учитываем окончание
    в слове "пар(а)" в выходном сообщении. */
 
 printf("В числе встречается %d пар%s соседних единичных бит.\n", p,
        (m = p%10)>1 && m<5 ? "ы" : m==1 ? "a" : "");
 
 
 return 0; }

#include <limits.h>
sizeof(int) * CHAR_BIT

unsigned int bitpairs(unsigned int n) {
    unsigned int r=0;
    for (int i=8*sizeof n-1; i>0; --i) {
        r += (n&3)==3;
        n >>= 1;
    }
    return r;
}

unsigned int bitpairs(int n) {
    unsigned int r=0, m=3;
    for (int i=8*sizeof n-1; i>0; --i) {
        r += (n&m)==m;
        m <<= 1;
    }
    return r;
}

    while (n) {
        r += (n&3)==3;
        n >>= 1;
    }

    while (n>=3) {
        r += (n&3)==3;
        n >>= 1;
    }

#include <stdlib.h>
#include <inttypes.h>
#include <stdio.h>
 
#define ghb(n) (__builtin_clz(n))
#define shb(n) ((n) << ghb(n))
 
 
int main()
{
    uint32_t x = 2564554656u;
    uint32_t count = 0;
    if (~x) {
        while(x) {
            x = shb(x);
            uint32_t n = ghb(~x);
            if (n > 1) {
                count += (n - 1);
            }
            x <<= n;       
        }
    } else {
        count = 31;
    }
    printf("%" PRIu32, count);
}

#include <stdio.h>
 
unsigned char PAIRS[] = { 3, 6, 12, 24, 48, 96, 192 };
#define PAIRS_COUNT ( sizeof(PAIRS) / sizeof(PAIRS[0]) )
 
int main(void) {
    unsigned char n;
    
    while ( printf("Number[0 - 255]: ") && scanf("%hhu", &n) == 1 ) {
        int cnt = 0, i;
        
        for ( i = 0; i < PAIRS_COUNT; ++i )
            cnt += ( n & PAIRS[i] ) == PAIRS[i];
        
        printf("%d bit pairs.\n", cnt);
    }
    
    return 0;
}

    int n = 0x80000000;