программа Имя
Имена: массив строк = {Иван, Алексей, Юрий, ...}
начало
  цикл Индекс от 1 до Имена.КоличествоЭлементов 
    печать "Ваше имя ", Имена[Индекс], "? (Да или Нет)"
    цикл пока
      читать Ответ
      если Ответ = "Да" то начало
        печать "Ваше имя: ", Имена[Индекс]
        выходизпрограммы
      конец если
      иначе если Ответ = "Нет" то 
        выходизцикла
      иначе
        печать "Ответ не верный, введите правильный ответ (Да или Нет)"
    конец цикла пока 
  конец цикла
  печать "Ваше имя не известно системе"
конец

<?= round ((pow (2,32) / (60 * 60 * 24 * 365)) / 2); ?>

Первое что мне сказали когда я пришел в IBM — Do not think, do ask.
Я бы сразу задал вопрос — устраивает ли решение из STL. Умные задают дополнительные вопросы — дураки сразу "понимают".

Знаменитая история. Джоел спольски любил задавать вопрос — нарисуйте дом. Вы рисуете квадратик с шапочкой, может даже окошком и дверцей. И когда закончили, Спольски говорил — да, совсем забыл. Домик-то для двуголовых жирафов. Что, размеры не те? чего не уточняли? все, до свиданья.

Вполне адекватная задача для собеседования при условии, что человеку будут даваться подсказки и что он умеет обращать списки. Сформулировал задачу, как это сделал ты — пол решения. Разобрался, как работает сложение/вычитание на уровне битов — еще четверть.

Никаким хакером для решения этой задачи быть не надо, лично я — даже не программист, а деплоймент-инженер.

/// Gets current time
/** Return value is offset from time when function was called (in any measurement system).
    Precision: (0, 1] seconds
*/
inline int getCurrentTime() { return 0; }

int f(int x)
{
    int minusOneBit = (x-1)&x;
    int e = x^minusOneBit;
    return minusOneBit|(e>>1);
}

int func(int x)
{
    if (!(x&1))
        return f(x);
    return ~f(~x);
}

0 1|1   0 1 0|2    0 1 1|3    1 0 0|4    1 0 1|5    1 1 0|6     0 1 1 1|7     1 0 0 0|8     1 0 0 1|9      1 0 1 0|A       1 0 1 1 1|17
1 0|2   0 1 1|3    1 0 0|4    1 0 1|5    1 1 0|6    1 1 1|7     1 0 0 0|8     1 0 0 1|9     1 0 1 0|A      1 0 1 1|B       1 1 0 0 0|18
---     -----      -----      -----      -----      -----       -------       -------       -------        -------   ....  ---------
0 0|0   0 1 0|2    0 0 0|0    1 0 0|4    1 0 0|4    1 1 0|6     0 0 0 0|0     1 0 0 0|8     1 0 0 0|8      1 0 1 0|A       1 0 0 0 0|10

PlainData {
  id;
  parentId;
  data;
}

TreeData {
    id;
    *TreeData;
    data;
}

DP>int f(int x)
DP>{
DP>    int minusOneBit = (x-1)&x;
DP>    int e = x^minusOneBit;
DP>    return minusOneBit|(e>>1);
DP>}

DP>int func(int x)
DP>{
DP>    if (!(x&1))
DP>        return f(x);
DP>    return ~f(~x);
DP>}
DP>

f:    11110 -> 11101
func: 00001 -> 00010

0010 0000000000000000000000000011111 -> 0001 1111100000000000000000000000000

my_public = base ** my_secret mod prime
common_secret = his_public ** my_sectret mod prime

//Count the consecutive zero bits (trailing) on the right in parallel
unsigned int trailingZeroBits(unsigned int v)      // 32-bit word input to count zero bits on right
{
    unsigned int c = 32; // c will be the number of zero bits on the right
    v &= -signed(v);
    if (v) c--;
    if (v & 0x0000FFFF) c -= 16;
    if (v & 0x00FF00FF) c -= 8;
    if (v & 0x0F0F0F0F) c -= 4;
    if (v & 0x33333333) c -= 2;
    if (v & 0x55555555) c -= 1;

    return c;
}

unsigned int next(unsigned int x)
{
    unsigned int zeroBits = trailingZeroBits(x);
    unsigned int bit = x - (x & (x-1));
    x += bit;
    unsigned int totalBits = trailingZeroBits(x);
    x += (1u << (totalBits - 1 - zeroBits)) - 1;
    return x;
}

Но сеньёр-девелопер, не могущий решить задачку по программированию для первокурсников — это ведь просто смешно.

import Data.Bits
import Numeric
import Data.Char

binary x = showIntAtBase 2 intToDigit x ""

f x = (((x .&. (x - 1)) `xor` x) + x) .|. (x .&. (x - 1))
g x = putStrLn $ (binary x) ++ " --> " ++ (binary (f x))

$ ghci bits_public_morozov.hs 
GHCi, version 6.8.2: http://www.haskell.org/ghc/  :? for help
Loading package base ... linking ... done.
[1 of 1] Compiling Main             ( bits_public_morozov.hs, interpreted )
Ok, modules loaded: Main.
*Main> g 3
11 --> 110
*Main>

#include <iostream>
#include <string.h>

unsigned int number_of_trailing_zero_bits(unsigned int x) //Count the consecutive zero bits (trailing) on the right in parallel
{
    unsigned int result = 32;
    x &= -signed(x);
    if (x) result--;
    if (x & 0x0000FFFF) result -= 16;
    if (x & 0x00FF00FF) result -= 8;
    if (x & 0x0F0F0F0F) result -= 4;
    if (x & 0x33333333) result -= 2;
    if (x & 0x55555555) result -= 1;

    return result;
}
inline unsigned int clear_lowest_unit_bit(unsigned int x) { return x & (x-1); }
inline unsigned int lowest_unit_bit(unsigned int x)       { return x ^ clear_lowest_unit_bit(x); }
inline unsigned int create_unit_bits(unsigned int n) { return (1u << n) -1; }

inline unsigned int number_of_pretrailing_unit_bits(unsigned int x)
{
    return number_of_trailing_zero_bits(x+lowest_unit_bit(x)) - number_of_trailing_zero_bits(x);
}
unsigned int next(unsigned int x)
{
    unsigned int y = x + lowest_unit_bit(x); /// это мы получаем тот самый сдвиг одного бита налево... но коммент должет быть длиннее
    unsigned int result = y | (create_unit_bits( number_of_pretrailing_unit_bits(x) ) >> 1) ;
    if( result <= y) /// FIXME а компилятор не решит ли соптимизировать это нафиг?
        throw "no next";
    else
        return result;
}

int trailingZeroCount(U64 bb) {
   static const int lookup67[67+1] = {
      64,  0,  1, 39,  2, 15, 40, 23,
       3, 12, 16, 59, 41, 19, 24, 54,
       4, -1, 13, 10, 17, 62, 60, 28,
      42, 30, 20, 51, 25, 44, 55, 47,
       5, 32, -1, 38, 14, 22, 11, 58,
      18, 53, 63,  9, 61, 27, 29, 50,
      43, 46, 31, 37, 21, 57, 52,  8,
      26, 49, 45, 36, 56,  7, 48, 35,
       6, 34, 33, -1 };
   return lookup67[(bb & -bb) % 67];
}

const int index64[64] = {
   63,  0, 58,  1, 59, 47, 53,  2,
   60, 39, 48, 27, 54, 33, 42,  3,
   61, 51, 37, 40, 49, 18, 28, 20,
   55, 30, 34, 11, 43, 14, 22,  4,
   62, 57, 46, 52, 38, 26, 32, 41,
   50, 36, 17, 19, 29, 10, 13, 21,
   56, 45, 25, 31, 35, 16,  9, 12,
   44, 24, 15,  8, 23,  7,  6,  5
};
 
int bitScanForward(U64 bb) {
   const U64 debruijn64 = C64(0x07EDD5E59A4E28C2);
   assert (bb != 0);
   return index64[((bb & -bb) * debruijn64) >> 58];
}