Asa cum am arătat $n & (n - 1)$ are ca rezultat numărul $n$ din care s-a scăzut cel mai puţin semnificativ bit. Folosind această idee obţinem următoarea funcţie:
==code(cpp)|
int low1(long n){

   return n ^ (n & (n - 1));

    return n ^ (n & (n - 1));

}
==

==code(cpp)|
int high1(long n) {

   long num = 0;
   if (!n) return -1;
   if (0xFFFF0000 & n) {
     n = (0xFFFF0000 & n)>>16;
     num += 16;
   }
   if (0xFF00 & n) {
      n = (0xFF00 & n) >> 8;
      num += 8;
   }
   if (0xF0 & n) {
      n = (0xF0 & n) >> 4;
      num += 4;
   }
   if (12 & n) {
      n = (12 & n) >> 2;
      num += 2;
   }
   if (2 & n) {
      n = (2 & n) >> 1;
      num += 1;
   }
   return 1 << num;

    long num = 0;
    if (!n) return -1;
    if (0xFFFF0000 & n) {
        n = (0xFFFF0000 & n)>>16;
        num += 16;
    }
    if (0xFF00 & n) {
        n = (0xFF00 & n) >> 8;
        num += 8;
    }
    if (0xF0 & n) {
        n = (0xF0 & n) >> 4;
        num += 4;
    }
    if (12 & n) {
        n = (12 & n) >> 2;
        num += 2;
    }
    if (2 & n) {
        n = (2 & n) >> 1;
        num += 1;
    }
    return 1 << num;

}
==

==code(cpp)|
int indexHigh1(long n){

  n = n | (n >> 1);
  n = n | (n >> 2);
  n = n | (n >> 4);
  n = n | (n >> 8);
  n = n | (n >> 16);
  return count(n) - 1;

    n = n | (n >> 1);
    n = n | (n >> 2);
    n = n | (n >> 4);
    n = n | (n >> 8);
    n = n | (n >> 16);
    return count(n) - 1;

==
Pentru ca această metodă să fie eficientă ne trebuie o metodă *count* eficientă.

==code(cpp)|
int isTwoPower(long n){

  return (n & (n-1) == 0);

    return (n & (n-1) == 0);

}
==

==code(cpp)|
int count(long n){

  return num[n & 0xFFFF] + num[n >> 16];

    return num[n & 0xFFFF] + num[n >> 16];

}
==

==code(cpp)|
int parity(long n){

  return par[n & 0xFFFF] ^ par[n >> 16];

    return par[n & 0xFFFF] ^ par[n >> 16];

}
==

==code(cpp)|
int low(long n){

  if (l[n & 0xFFFF]) return l[n & 0xFFFF];
  else return l[n >> 16] << 16;

    if (l[n & 0xFFFF]) return l[n & 0xFFFF];
    else return l[n >> 16] << 16;

}
==

==code(cpp)|
int high(long n){

  if (h[n >> 16]) return h[n >> 16] << 16;
  else return h[n & 0xFFFF];

    if (h[n >> 16]) return h[n >> 16] << 16;
    else return h[n & 0xFFFF];

}
==

==code(cpp)|
int indexHigh(long n) {

  if (iH[n >> 16] != -1) return iH[n >> 16] + 16;
  else return iH[n & 0xFFFF];

    if (iH[n >> 16] != -1) return iH[n >> 16] + 16;
    else return iH[n & 0xFFFF];

}
==

define maxsize 10000000
char at[maxsize]; // vector de valori logice în care numerele prime vor fi marcate cu 0

int n;

int isPrime(int x){

return (!at[x]) ;

    return (!at[x]) ;

}
void sieve(){

  int i, j;
  memset(at,0,sizeof(at)) ;
  for (i = 2; i <= maxsize; i++)
     if (!at[i])
       for (j = i + i; j <= maxsize; j += i)
          at[j]=1; //marcam toti multipli lui i ca fiind numere prime

    int i, j;
    memset(at,0,sizeof(at)) ;
    for (i = 2; i <= maxsize; i++) if (!at[i])
        for (j = i + i; j <= maxsize; j += i)
            at[j] = 1; // marcăm toţi multipli lui i ca fiind numere prime

}
==

==code(cpp)|
#define maxsize 10000000

char at[maxsize];
int n;

int isPrime(int x){

  return (!at[x]) ;

    return (!at[x]) ;

}

void sieve(){

  int i, j;
  memset(at,0,sizeof(at));
  for (i = 4; i <= maxsize; i += 2)
     at[i] = 1;
  for (i = 3; i <= maxsize; i += 2)
     if (!at[i])
       for (j = i + i + i; j <= maxsize; j += i + i)
          at[j] = 1;

    int i, j;
    memset(at,0,sizeof(at));
    for (i = 4; i <= maxsize; i += 2)
        at[i] = 1;
    for (i = 3; i <= maxsize; i += 2) if (!at[i])
        for (j = i + i + i; j <= maxsize; j += i + i)
            at[j] = 1;

}
==

==code(cpp)|
void sieve(){

  int i, j;
  memset(at,0,sizeof(at));
  for (i = 4; i <= maxsize; i += 2)
     at[i] = 1;
  for (i = 3; i <= maxsize; i += 2)
     if (!at[i])
       for (j = i * i; j <= maxsize; j += i + i)
          at[j] = 1;

    int i, j;
    memset(at,0,sizeof(at));
    for (i = 4; i <= maxsize; i += 2)
        at[i] = 1;
    for (i = 3; i <= maxsize; i += 2) if (!at[i])
        for (j = i * i; j <= maxsize; j += i + i)
            at[j] = 1;

}
==

==code(cpp)|
#define maxsize 10000000

char at[maxsize/16];

char at[maxsize / 16];

int n;
int isPrime(int x) {

  if (!(x & 1))
     if (x==2) return 0 ;
     else return 1 ;
     else return (at[((x - 3) >> 1) >> 8] &
                       (1 << (((x - 3) >> 1) & 7))) ;

    if (!(x & 1))
        if (x == 2) return 0 ;
        else return 1 ;
        else return (at[((x - 3) >> 1) >> 8] & (1 << (((x - 3) >> 1) & 7))) ;

}

void sieve() {

  int i, j;
  memset(at, 0, sizeof(at)) ;
  for (i = 3; i <= maxsize; i += 2)
     if (!at[((i - 3) >> 1) >> 8] &
                         (1 << (((i - 3) >> 1) & 7)))
       for (j=i * i ; j <= maxsize ; j += i + i)
          at[((i - 3) >> 1) >> 8] |=
                       (1 << (((i - 3) >> 1) & 7))) ;

    int i, j;
    memset(at, 0, sizeof(at)) ;
    for (i = 3; i <= maxsize; i += 2)
        if (!at[((i - 3) >> 1) >> 8] & (1 << (((i - 3) >> 1) & 7)))
            for (j = i * i ; j <= maxsize ; j += i + i)
                at[((i - 3) >> 1) >> 8] |= (1 << (((i - 3) >> 1) & 7))) ;

}
==