Comments on: Programming job interview challenge

By: Jake

Jake — Sun, 15 Jan 2012 14:58:36 +0000

Sorry, I forgot to mention what was obvious to me – 64kb array you use to reverse 2 bytes at a time.

By: Jake

Jake — Sun, 15 Jan 2012 14:56:10 +0000

Igor & co – as long as you use a pre-cached array, it does not really matter how you init it – fast or slow c trick make no diff.
The only reason to use bit tricks here is if you can make the reverse function faster than the array lookup. The array lookup is very cheap so unbeatable.

If array lookup is “free”, I’d expect a “good” answer to at least mention that you can use 64kb array. How about a 4gb array?

What about cache misses? this could cost you 200 cycles per 64 bytes. So it might be worthwhile to skip the array for an input shorter than, say, 100 cycles to process, for the 256 byte array. Probably a lot more for bigger ones (which renders it a good answer only in theory). Micro benchmarks will not give you the answer in this case, only real life probing.

By: Igor Ostrovsky

Igor Ostrovsky — Tue, 12 Jul 2011 22:28:07 +0000

Philip: Yes, that approach certainly works. In fact, that’s the approach I was referring to when I said that “There is an obvious solution which uses a for loop and some bit manipulation”

By: Philip

Philip — Sun, 10 Jul 2011 23:23:20 +0000

It seems commenting engine ate some parts of C++ code in my last comment. Here is the original.

By: Philip

Philip — Sun, 10 Jul 2011 23:04:12 +0000

There is another interesting approach to inverting bits problem.

Let us assume you need to reverse each number in range [0 .. 2^n - 1]. Notice that “increment some number” means delete (i.e. change to 0′es) a group of 1′s at the end of it and place 1 before this group. So if you know reversed(m) and want to get reversed(m + 1) then all you need is to delete a group of ones at the beginning of reversed(m) and place 1 right after them.

Here is the code:

int MAX = (1 << n);
for (int i = 0, revi = 0; i > 1);
for (; revi & bit; bit >>= 1)
revi ^= bit;
revi |= bit;

reversed[i] = revi;
}

Careful analysis shows, that this algorithm works in linear time.

By: Duc

Duc — Sun, 10 Apr 2011 16:38:01 +0000

Dear Igor,

Yes it is interesting crazy , , .
Also, it is also slower than your version (compiler
can not compete with handcraft-assembler code).

Regards
DL

By: Igor Ostrovsky

Igor Ostrovsky — Wed, 23 Feb 2011 19:20:13 +0000

Duc: Crazy C tricks with packed structs.

Interesting.

By: Duc

Duc — Wed, 23 Feb 2011 18:33:35 +0000

Dear Igor,

Sorry about the last post; something is missing;
I am reposting the main body. Sorry again. Thanks
again.

=============================================================
uint16 i;
for (i = 0; i f = cbi->e;
cba->s = cbi->sv;
cba->t = cbi->sx;
cba->fo = cbi->ff;
cba->ff = cbi->fo;
cba->sx = cbi->t;
cba->sv = cbi->s;
cba->e = cbi->f;
}
printf (“I am done , , ”);

========================================================

By: Duc

Duc — Wed, 23 Feb 2011 18:29:36 +0000

Dear Igor,

Cool stuff and thanks.

What do you think about the below implementation?

typedef unsigned char uint8;
typedef struct ch_bit char_bit;
struct ch_bit
{
uint8 f:1;
uint8 s:1;
uint8 t:1;
uint8 fo:1;
uint8 ff:1;
uint8 sx:1;
uint8 sv:1;
uint8 e:1;
} __attribute__ ((__packed__));

char_bit reverse_array[256];
char_bit *cbi;
char_bit *cba;
uint8 i;
for (i = 0; i f = cbi->e;
cba->s = cbi->sv;
cba->t = cbi->sx;
cba->fo = cbi->ff;
cba->ff = cbi->fo;
cba->sx = cbi->t;
cba->sv = cbi->s;
cba->e = cbi->f;
}
printf (“I am done , , ”);

This is not cool as yours. But implementation-wise it is
much simpler; speed-wise I think it is fast too.

Again, thanks for cool posts.

Regards
Duc

By: Skip lists are fascinating! | Igor Ostrovsky Blogging

Skip lists are fascinating! | Igor Ostrovsky Blogging — Wed, 09 Sep 2009 07:31:23 +0000

[...] Programming job interview challenge [igoro.com] [...]