в 5 пункті потрібно вікоритосувати тупу рекурсію

типу ні, погляньте на степені двійки в двійковій формі, як вам порадив пан koala

bool isPowerOfTwoRepresentable(unsigned int value) {
    return !(value&(value-1)) && !(value == 0);
}

  оптимізував 4 так і залишилось темним лісом

5:

bool isPowerOfTwoRepresentable(unsigned int value)
{
    return value && ((value - 1) & ~value) == value - 1;
}

4:

unsigned countSetBits(void *memory, unsigned bitsCount)
{
    unsigned count = 0,
        size = /*sizeof(void *) **/ 8,
        length = bitsCount / size,
        i = -1, j;
    while(++i < length)
    {
        j = -1;
        while(++j < size)
            count += (((char *)memory)[i] >> j) & 1;
    }
    j = -1;
    int end = bitsCount - length * size;
    while(++j < end)
        count += (((char *)memory)[i] >> j) & 1;
    return count;
}

Думаю це можна вважати за 1 рядок коду бо саме тіло power2 - 1 умова, тобто можна і тернарником записати

#include <cmath>
#include <iostream>
using namespace std;

size_t power2(size_t n);

int main(){
    cout<<pow(2.0, 5.0)<<" "<<power2(5)<<endl;
    cout<<pow(2.0, 17)<<" "<<power2(17)<<endl;
    return 0;
}


size_t power2(size_t n){
    if( n )
    return 2 << (n - 1);
    else
    return 1;
}

http://codepad.org/U2dOkNvB

upd: Поведінка при від'ємному значенні кількості зсувів — «невизначена», реальні компілятори можуть відпрацювати коректно (але справедливо побурчати). Ніколи на це не розраховував :-)
Тим більше, що при зсуві на змінну, в яку занесено від'ємне значення, попередження не буде, а результат однак невизначений. На x86 швидше за все -1 буде сприйнято як FF, а зсув на число, більше за розмір операнда (теж невизначена поведінка) дасть 0.

http://cpp.sh/72yh

#include <iostream>
using namespace std;

#define TST(a) cout << #a << " = " << a << endl

int main()
{
    TST( (1<<0) );
    TST( (1<<1) );
    TST( (1<<16) );
    TST( (8<<-2) );
    return 0;
}

Бурчання

 In function 'int main()':
11:12: warning: left shift count is negative
4:39: note: in definition of macro 'TST' 

Вихід

(1<<0) = 1
(1<<1) = 2
(1<<16) = 65536
(8<<-2) = 2

Про «буде сприйнято як FF» я писав про правий операнд оператора зсуву. По стандарту поведінка при цьому невизначена. Конкретно на x86 при вийманні правого операнда зі змінної буде використана команда зсуву з лічильником зсуву у 8-бітовому регістрі CL, там -1 буде сприйнято як FF, бо для асемблера цей операнд знаку не має. Тобто зсув таки у тому ж напрямку, а не у протилежному, але на дуже велике число і результат буде 0 (на іншій архітектурі може бути інший результат). Якщо ж правий операнд відомий на момент компіляції — приклад вище — компілятор побурчить, але правильно зсуне таки у протилежний бік. Саме тому навіть не implementation defined, а undefined.

Щодо лівого операнда, то ви не зовсім праві.
Стандарт каже, що для зсуву вправо при знаковому лівому операнді й при від'ємному значенні у ньому результат implementation defined, тобто для даних архітектури і компілятора завжди однаковий, але ніхто не гарантує, що це повториться на іншій платформі.
Тому так — мабуть, на всьому, з чим я зараз працюю, є команди асемблера для зсуву вправо з розмноженням старшого біта і при зсуві вправо від'ємні числа залишаються від'ємними.
Але я б на це не закладався, для знакових зсув використовую лише тоді, коли я точно знаю, що я роблю і навіщо.
До речі, для знакового-від'ємного числа навіть з розмноженням старшого біту зсув вправо на n бітів не еквівалентний діленню на 2ⁿ.

http://cpp.sh/9v2b

#include <iostream>
using namespace std;

#define TST(a) cout << #a << " = " << (a) << endl

int main()
{
    int a = -3;
    TST( a );
    TST( a >> 1 );
    TST( a / 2 );
    return 0;
}

a = -3
a >> 1 = -2
a / 2 = -1

Щось тут забагато. value & (value-1) обнулює наймолодший «1»-ний біт змінної.
Тому (value & (value-1)) == 0 означає, що у змінній була максимум одна одиничка.
Тому досить

bool isPowerOfTwoRepresentable(unsigned int value)
{
    return value != 0                   // є хоча б одна одиничка
           && (value & (value-1)) == 0; // була максимум одна одиничка
}

Ну або компактним записом (наче вище щось подібне проскакувало)

bool isPowerOfTwoRepresentable(unsigned int value)
{
    return value && !(value & (value-1));
}