473,838 Members | 1,654 Online

# Programming Puzzle

I found these questions on a web site and wish to share with all of u
out there,Can SomeOne Solve these Porgramming puzzles.
Programming Puzzles

Some companies certainly ask for these things. Specially Microsoft.
Here are my favorite puzzles. Don't send me emails asking for the
solutions.

Q1 Write a "Hello World" program in 'C' without using a semicolon.
Q2 Write a C++ program without using any loop (if, for, while etc) to
print numbers from 1 to 100 and 100 to 1;
Q3 C/C++ : Exchange two numbers without using a temporary variable.
Q4 C/C++ : Find if the given number is a power of 2.
Q5 C/C++ : Multiply x by 7 without using multiplication (*) operator.
Q6 C/C++ : Write a function in different ways that will return f(7) =
4 and f(4) = 7
Q7 Remove duplicates in array
Q8 Finding if there is any loop inside linked list.
Q9 Remove duplicates in an no key access database without using an
array
Q10 Write a program whose printed output is an exact copy of the
source. Needless to say, merely echoing the actual source file is not
allowed.
Q11 From a 'pool' of numbers (four '1's, four '2's .... four '6's),
each player selects a number and adds it to the total. Once a number
is used, it must be removed from the pool. The winner is the person
whose number makes the total equal 31 exactly.
Q12 Swap two numbers without using a third variable.
Given an array (group) of numbers write all the possible sub groups of
this group.
Q14 Convert (integer) number in binary without loops.

Q3,12 are similar , Q7 is simple & I know there answer For the Rest
Nov 14 '05
271 20376
>> >Not one, but *two* ways to do it have been
>shown in this thread. Of course it will break down if those variables
>happen to share the same memory location, which can be the case if using
>pointers and indirecting through them.

Please describe (in code) a situation where two variables share the same memory
location.

A union?

You could also end up calling swap() on to pointers that just happen
to sometimes end up being equal unless you carefully test that it's not.
It may be preferable to make swap() robust enough to deal with this
situation.

#include "card_t.h" /* This is part of the program, NOT the implementation*/
#define DECKSIZE 52
....
int i,j;
card_t deck[DECKSIZE];

/* bogo-shuffle the cards */
for (i = 0; i < DECKSIZE; i++) {
for (j = 0; j < DECKSIZE; j++) {
/*
* DO NOT CHANGE THE LINE OF CODE BELOW.
* Note: rand() % 2 is used here because it is
* a poor random number generator in many
* implementations , and if it isn't possible to
* cheat, *THEY* will break your legs repeatedly
* and cut off your supply of semicolons.
*/
if (rand() % 2) {
swap(&deck[i], &deck[j]);
}
}
}

Now, you can put a "&& i !=j " clause in the if statement, but
some may object to that on efficiency grounds.

Gordon L. Burditt
Nov 14 '05 #131
Gordon Burditt wrote:
>Not one, but *two* ways to do it have been
>shown in this thread. Of course it will break down if those variables
>happen to share the same memory location, which can be the case if using
>pointers and indirecting through them.
Please describe (in code) a situation where two variables share the same memory
location.

A union?

Nope -- a union is still a single variable, with just different ways to access
it.
You could also end up calling swap() on to pointers that just happen
to sometimes end up being equal unless you carefully test that it's not.
It may be preferable to make swap() robust enough to deal with this
situation.

Yes, I realize all what you said -- however, my point was/is: if you
'implement the xor swap function that operates on two variables', you don't
need the check, because you can't have two variables that share the same memory
location. The check is therefore redundant, and not warranted. If you change
the definition to 'implement an xor swap function' or 'implement an xor swap
function that takes two parameters', then the check *would* be warranted.

In case you still can't see my points:

- The original precondition of two numbers (variables) is sufficient to
eliminate the need for the check.

- Two variables *cannot* share the same memory location.
Nov 14 '05 #132
Gordon Burditt wrote:
#include "card_t.h" /* This is part of the program, NOT the
#implementation */ define DECKSIZE 52
...
int i,j;
card_t deck[DECKSIZE];

/* bogo-shuffle the cards */
for (i = 0; i < DECKSIZE; i++) {
for (j = 0; j < DECKSIZE; j++) {
/*
* DO NOT CHANGE THE LINE OF CODE BELOW.
* Note: rand() % 2 is used here because it is
* a poor random number generator in many
* implementations , and if it isn't possible to
* cheat, *THEY* will break your legs repeatedly
* and cut off your supply of semicolons.
*/
if (rand() % 2) {
swap(&deck[i], &deck[j]);
}
}
}

Hi,

I apologize, for this might not be the topic of this thread, however I feel
compelled to comment on this bogo-shuffle: is that taken from a text on how
*not* to generate a random permutation?

a) The use of rand() % 2 is bad. In a different thread I came across a
random number generator that would produce a strictly alternating sequence
of bits when used this way. The funny comment indicates that the author was
acutally aware of this shortcoming.

b) The method has quadratic runtime in DECKSIZE. Clearly a random-shuffle
can and should be done in linear time.

c) Finally, even with a perfect random number generator, this method is
guaranteed *not* to give equal probabilities to the different permutations.
For small DECKSIZE, the difference is even noticable.
Best

Kai-Uwe
Nov 14 '05 #133

"Julie" <ju***@nospam.c om> wrote in message
news:40******** *******@nospam. com...

Please describe a situation where two variables share the same memory
location.

There is a doubly-linked-list algorithm that uses the same
memory location for both forward and backward pointers.
They are stored as XORred, and given the address of an
anchor node, the chain of nodes can be traversed at either
direction.

- Risto -
Nov 14 '05 #134

"Ioannis Vranos" <iv*@guesswh.at .grad.com> wrote in message
news:cb******** **@ulysses.noc. ntua.gr...

You are right about that, however in reality a decent swap
implementation would check if the passed arguments have the same value
so as to avoid unneeded operations.

There are some algorithms for which the check itself is
an unneeded operation (i.e. which can be proved to be
"correct by construction") become inefficient if the swap
function itself makes such a redundant check. Various
sort algorithms belong to this category, because it is a
characteristic of the sort algorithm [and not a safety net
of swap] to compare items before swapping.

But then there are also some algorithms for which the
check is - if perhaps not redundant - but inefficient as
long as the swap preserves original value in the case of
self-swap.

[I know it's easy to code "more correctly", but] one such
algorithm would be string reversal which might be coded
so that the middle element will be "swapped" with itself
just before the algorithm tests for the termination. Then
you don't need to make an extra check every time before
entering the loop - you just enter the loop every time and
let it do the "right thing" even with strings of length one.

More examples can be found from permutation generation
algorithms, where a straightforward algorithm might benefit
from not having to make the check every time, even given
the cost of occasional self-swap.

- Risto -
Nov 14 '05 #135

"Ioannis Vranos" <iv*@guesswh.at .grad.com> wrote in message
news:cb******** **@ulysses.noc. ntua.gr...

That said, I would not place the equality/inequality check for the
possibility of the same variable passed in mind, but for efficiency.

Whoa!

Without check you have (assuming the temp var is in reg):

R = read memory * 2
W = write memory * 2

With check you have:

R = read memory * 2
C = compare registers
W = write memory * 2 * (1-p) where p = probability of match

For the equality-checking version to be more efficient you have...

C + W*2*(1-p) < W*2 => p > C/(W*2)

In other words, the probability of [arguments-have-the-same
value] should be higher than the ratio of the [comparison-cost]
and the [cost-of-two-writes]. I would guess that in most cases
comparing the arguments is really a pessimization.. .

Note that some systems can execute the writes in parallel,
and that a write and a compare both can be executed in one
cycle -> p = 1/1 which is a certain non-optimization. Also
note that the cost of the jump (which can be optimized away
if swap is a stand-alone function, but typically can not if it is
an inline function) has not even been factored in yet.

This is a micro-optimization at its finest!

- Risto -
Nov 14 '05 #136
Ioannis Vranos posted:
template<class T>
void swap(T &a, T &b)
{
if(a!=b)
{
// ...
}
}

Depends if you want a shallow swap or a deep swap. With my own template, I
was going for a shallow swap. Not how your example makes use of the !=
operator of the class, while mine doesn't even need a definiton of the class
at all. Then again, yours is probably a deep swap.

-JKop
Nov 14 '05 #137
JKop <NU**@null.null > scribbled the following
on comp.lang.c:
Ioannis Vranos posted:
template<class T>
void swap(T &a, T &b)
{
if(a!=b)
{
// ...
}
}
Depends if you want a shallow swap or a deep swap. With my own template, I
was going for a shallow swap. Not how your example makes use of the !=
operator of the class, while mine doesn't even need a definiton of the class
at all. Then again, yours is probably a deep swap.

crossposting to comp.lang.c. Thanks.

--
/-- Joona Palaste (pa*****@cc.hel sinki.fi) ------------- Finland --------\
\-- http://www.helsinki.fi/~palaste --------------------- rules! --------/
"A bee could, in effect, gather its junk. Llamas (no poor quadripeds) tune
and vow excitedly zooming."
- JIPsoft
Nov 14 '05 #138
In <tC************ *******@newssvr 29.news.prodigy .com> "Mabden" <mabden@sbc_glo bal.net> writes:
"Dan Pop" <Da*****@cern.c h> wrote in message
news:cb******* ****@sunnews.ce rn.ch...
In <zo************ ****@newssvr27. news.prodigy.co m> "Mabden"

<mabden@sbc_gl obal.net> writes:
>"Foobarius Frobinium" <fo******@youre mailbox.com> wrote in message
>news:a7******* *************** ****@posting.go ogle.com...
>> js*******@sanch arnet.in (Jatinder) wrote in message
>news:<22****** *************** *****@posting.g oogle.com>...
>> You mentioned MS often use these sorts of puzzles to test their
>> programmers. I got an even better one to stump even the best MS
>> programmers:
>> #include <stdio.h>
>>
>> int main(void) {
>> int *foo = NULL;
>>
>> fprintf(stdout, "%i\n", *foo);
>> }
>>
>> What will happen if I compile and run this program??
>
>You'll get a warning saying main() has no return value.

C:\TEMP>type test.c
#include <stdio.h>

int main(void) {
int *foo = NULL;

fprintf(stdout, "%i\n", *foo);
}
C:\TEMP>cl -c test.c
Microsoft (R) C/C++ Optimizing Compiler Version 8.00c

test.c
test.c(7) : warning C4035: 'main' : no return value

What part of "chapter and verse" was too difficult for you to understand?
Free clue: the C programming language is not defined by the behaviour of
one compiler or another.

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de
Nov 14 '05 #139
In <cb**********@u lysses.noc.ntua .gr> Ioannis Vranos <iv*@guesswh.at .grad.com> writes:
Mabden wrote:
C:\TEMP>type test.c
#include <stdio.h>

int main(void) {
int *foo = NULL;

fprintf(stdout, "%i\n", *foo);
}
C:\TEMP>cl -c test.c
Microsoft (R) C/C++ Optimizing Compiler Version 8.00c

test.c
test.c(7) : warning C4035: 'main' : no return value

In C90 a return statement is required, in C99 it is not.

Nope, in C90 a return statement is NOT required. Please restrict
yourself to topics you have a clue about.

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de
Nov 14 '05 #140

This thread has been closed and replies have been disabled. Please start a new discussion.