473,839 Members | 1,509 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 20382

On Mon, 28 Jun 2004, Branimir Maksimovic wrote:

Jatinder wrote:
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.

#include <cstdio>
using namespace std;int main(){const char* s="#include <cstdio>%cusi ng
namespace std;int main(){const char*
s=%c%s%c;printf (s,10,34,s,34,1 0);}%c";printf( s,10,34,s,34,10 );}

% cat > test.cpp
#include <cstdio>
using namespace std;int main(){const char* s="#include <cstdio>%cusi ng
namespace std;int main(){const char*
s=%c%s%c;printf (s,10,34,s,34,1 0);}%c";printf( s,10,34,s,34,10 );}
% g++ test.cpp
test.cpp:2:46: warning: multi-line string literals are deprecated
% ./a.out
#include <cstdio>
using
namespace std;int main(){const char*
s="#include <cstdio>%cusi ng
namespace std;int main(){const char*
s=%c%s%c;printf (s,10,34,s,34,1 0);}%c";printf( s,10,34,s,34,10 );}
Certainly doesn't look like an "exact copy" to me. Besides
which, it doesn't work on my DeathStation 9000.
A trivial application of my 'quine' program produces the
C program reproduced below my signature line. (Now I just have
to figure out how to make 'usenetify2' interface with 'quine',
and I've got a winner! ;-))

-Arthur
http://www.contrib.andrew.cmu.edu/~a...ftware/quine.c

#include <stdio.h>
void quine(void)
{
static char q[] = {
'0',
'}', ';', '\n', ' ', ' ', ' ', ' ', 'i', 'n', 't',
' ', 'i', ';', '\n', ' ', ' ', ' ', ' ', 'p', 'u',
't', 's', '(', '"', '\\', 'n', '#', 'i', 'n', 'c',
'l', 'u', 'd', 'e', ' ', '<', 's', 't', 'd', 'i',
'o', '.', 'h', '>', '\\', 'n', '\\', 'n', '"', ')',
';', '\n', ' ', ' ', ' ', ' ', 'p', 'u', 't', 's',
'(', '"', 'v', 'o', 'i', 'd', ' ', 'q', 'u', 'i',
'n', 'e', '(', 'v', 'o', 'i', 'd', ')', '\\', 'n',
'{', '\\', 'n', ' ', ' ', ' ', ' ', 's', 't', 'a',
't', 'i', 'c', ' ', 'c', 'h', 'a', 'r', ' ', 'q',
'[', ']', ' ', '=', ' ', '{', '"', ')', ';', '\n',
' ', ' ', ' ', ' ', 'f', 'o', 'r', ' ', '(', 'i',
'=', '0', ';', ' ', 'q', '[', 'i', ']', ';', ' ',
'+', '+', 'i', ')', ' ', '{', '\n', ' ', ' ', ' ',
' ', ' ', ' ', ' ', ' ', 'i', 'n', 't', ' ', 'n',
'l', ' ', '=', ' ', '(', 'i', '%', '1', '0', ')',
'?', ' ', '\'', ' ', '\'', ':', ' ', '\'', '\\', 'n',
'\'', ';', '\n', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
' ', 'i', 'f', ' ', '(', 'q', '[', 'i', ']', ' ',
'=', '=', ' ', '\'', '\\', 'n', '\'', ')', '\n', ' ',
' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'p',
'r', 'i', 'n', 't', 'f', '(', '"', '\'', '\\', '\\',
'n', '\'', ',', '%', 'c', '"', ',', ' ', 'n', 'l',
')', ';', '\n', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
' ', 'e', 'l', 's', 'e', ' ', 'i', 'f', ' ', '(',
'q', '[', 'i', ']', ' ', '=', '=', ' ', '\'', '\\',
't', '\'', ')', '\n', ' ', ' ', ' ', ' ', ' ', ' ',
' ', ' ', ' ', ' ', 'p', 'r', 'i', 'n', 't', 'f',
'(', '"', '\'', '\\', '\\', 't', '\'', ',', '%', 'c',
'"', ',', ' ', 'n', 'l', ')', ';', '\n', ' ', ' ',
' ', ' ', ' ', ' ', ' ', ' ', 'e', 'l', 's', 'e',
' ', 'i', 'f', ' ', '(', 'q', '[', 'i', ']', ' ',
'=', '=', ' ', '\'', '\\', '\'', '\'', ')', '\n', ' ',
' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'p',
'r', 'i', 'n', 't', 'f', '(', '"', '\'', '\\', '\\',
'\'', '\'', ',', '%', 'c', '"', ',', ' ', 'n', 'l',
')', ';', '\n', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
' ', 'e', 'l', 's', 'e', ' ', 'i', 'f', ' ', '(',
'q', '[', 'i', ']', ' ', '=', '=', ' ', '\'', '\\',
'\\', '\'', ')', '\n', ' ', ' ', ' ', ' ', ' ', ' ',
' ', ' ', ' ', ' ', 'p', 'r', 'i', 'n', 't', 'f',
'(', '"', '\'', '\\', '\\', '\\', '\\', '\'', ',', '%',
'c', '"', ',', ' ', 'n', 'l', ')', ';', '\n', ' ',
' ', ' ', ' ', ' ', ' ', ' ', ' ', 'e', 'l', 's',
'e', '\n', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
' ', ' ', 'p', 'r', 'i', 'n', 't', 'f', '(', '"',
'\'', '%', 'c', '\'', ',', '%', 'c', '"', ',', ' ',
'q', '[', 'i', ']', ',', ' ', 'n', 'l', ')', ';',
'\n', ' ', ' ', ' ', ' ', '}', '\n', ' ', ' ', ' ',
' ', 'f', 'p', 'u', 't', 's', '(', 'q', ',', ' ',
's', 't', 'd', 'o', 'u', 't', ')', ';', '\n', '}',
'\n', '\n', 'i', 'n', 't', ' ', 'm', 'a', 'i', 'n',
'(', ')', '\n', '{', '\n', ' ', ' ', ' ', ' ', 'q',
'u', 'i', 'n', 'e', '(', ')', ';', '\n', ' ', ' ',
' ', ' ', 'r', 'e', 't', 'u', 'r', 'n', ' ', '0',
';', '\n', '}', '\n', '\n', 0};
int i;
puts("\n#includ e <stdio.h>\n\n") ;
puts("void quine(void)\n{\ n static char q[] = {");
for (i=0; q[i]; ++i) {
int nl = (i%10)? ' ': '\n';
if (q[i] == '\n')
printf("'\\n',% c", nl);
else if (q[i] == '\t')
printf("'\\t',% c", nl);
else if (q[i] == '\'')
printf("'\\'',% c", nl);
else if (q[i] == '\\')
printf("'\\\\', %c", nl);
else
printf("'%c',%c ", q[i], nl);
}
fputs(q, stdout);
}

int main()
{
quine();
return 0;
}

Nov 14 '05 #101
>Dan Pop wrote:
void swap(int *p, int *q) { ... } [snippage] swap(&i, &i);

In article <40************ ***@nospam.com> Julie <ju***@nospam.c om> wrote:Just because you have two pointers that _point_ to the same address, this
doesn't mean that they (the variables here which are still the **pointers**)
share the same memory location.

As I see it, there are *four* variables in the swap() function: p,
q, *p, and *q. It also happens to be the case that two of these
variables -- *p and *q -- are potentially the same single variable,
the "i" in the call above.

The C99 standard, at least, does not seem to define the term
"variable", so one is free to use it to mean whatever one likes.
If you prefer to reserve the word only for "p" and "q" themselves,
and not refer to *p and *q as "variables" , that is your right --
but there will be confusion when communicating with those who *do*
call *p and *q "variables" .

(It is possible that the current C++ standard defines the term
"variable" in such a way that swap() has only two. I have not been
keeping up with C++.)
--
In-Real-Life: Chris Torek, Wind River Systems
Salt Lake City, UT, USA (40°39.22'N, 111°50.29'W) +1 801 277 2603
email: forget about it http://web.torek.net/torek/index.html
Reading email is like searching for food in the garbage, thanks to spammers.
Nov 14 '05 #102
Ioannis Vranos <iv*@guesswh.at .grad.com> wrote in news:cbpreo\$6tu \$4
@ulysses.noc.nt ua.gr:
josh wrote:
Julie wrote:
Please describe (in code) a situation where two variables share the
same memory
location.

union
{
int x;
int y;
} a;

&a.x == &a.y

That was good :-)

Although somewhat misleading... the variable is a, not x or y..... (to be
pedantic.....)
Nov 14 '05 #103

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

I think the non-temporary requirement is not for space concerns but to
find out how c00l we are. :-) Even under severe space concerns there is
always space for a *temporary* variable. If there are space concerns to
the extreme, then we should write numbers in its memory directly. :-)

Oh, I see I'm carrying my argument over from another thread with that point.
We had another recent thread regarding this issue, and I got mixed up as to
where this discussion originated (esp. since at some point the subject line
changed...for *some* reason! :-)).

-Howard

Nov 14 '05 #104
Howard wrote:
Oh, I see I'm carrying my argument over from another thread with that point.
We had another recent thread regarding this issue, and I got mixed up as to
where this discussion originated (esp. since at some point the subject line
changed...for *some* reason! :-)).

Well, at some point I considered the "thing" to be more accurate than
the original term used. :-)

Regards,

Ioannis Vranos
Nov 14 '05 #105
Howard wrote:

"Julie" <ju***@nospam.c om> wrote in message
news:40******** *******@nospam. com...
Yes, but the two variables are pointers, and they do not share the same

memory
location -- they may *point* to the same location.

So, I still haven't seen two variables that share the same memory

location. I
think that you can probably do it w/ placement new (C++ only!), but using

(C++)
references or pointers, you can't have two variables that share the same

memory
location.

Geez, give me a break! What I've shown exhibits *exactly* the kind of
problem that can happen when trying to swap two integers using the xor
technique. Just because someone used terminology that suggested the two
variables themselves had the same memory location, surely you knew what was
meant! The problem is when both memory locations are the same, which can
happen if using pointers or references. That's all that was meant, not that
there were two *different* variables occupying the *same* memory.
-Howard

Break given.

Your example doesn't swap two integers, it swaps one.

I know exactly what is meant -- using the xor technique on two variables will
never fail; using the xor technique on the same variable (same literal
variable, reference, or pointer -- still all *ONE* variable) will fail for most
cases.

You have given example(s) of the latter, *not* the former. There is no
disagreement on the latter.
Nov 14 '05 #106
Ioannis Vranos wrote:

Julie wrote:
How can you _not_ remove an element from an array?

Here is a trivial case:
Since you use the malloc() family and this is cross posted to clc, I
assume you use C.

You assume wrong.

malloc is part of C **AND** C++.

size_t count = 2;
int * array = (int *)malloc(sizeof (int) * count);

In C this casting is not needed.

however it is valid, and required in C++.
array[0] = 42;
array[1] = 9000;
array = (int *)realloc(array , sizeof(int) * (--count));

In C this casting is not needed.

however it is valid, and required in C++.
Nov 14 '05 #107
Howard wrote:

"Julie" <ju***@nospam.c om> wrote in message
news:40******** *******@nospam. com...
Here is the point in my version of 'plain English': you can't have two
variables that share the same memory address (excluding placement new).

So, if
the precondition for swap is that it operates on two variables, then it

will
always work provided the precondition is met.

So who ever sid the procondition was that you were swapping two non-pointer,
non-reference variables? If you're writing the swap as a function, you have
to use references or pointers, or else you'll only be swapping local copies.
That's what makes this an important consideration, because those pointer or
references parameters could be referring to the same memory location. The
swap function need to contain a check to handle that specific case.

-Howard

All that was said was that there were two variables (originally numbers) that
were to be swapped. Your examples use 1 variable, aliased 1 or more times.

Write your code with 2 variables where the xor trick fails, excluding placement
new.
Nov 14 '05 #108
Ioannis Vranos wrote:

Dan Pop wrote:
Since you seem to be unable to understand plain English:

#include <stdio.h>

void swap(int *p, int *q) { ... }

int main()
{
int i = 10;
swap(&i, &i);
printf("%d\n", i);
return 0;
}

Try this code for different implementations of the swap function, using
a temp var and using in-place swapping. Compare the results.

This example is trivial, but the situation can realistically arise in more
complex algorithms.

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.

Regards,

Ioannis Vranos

or simply state the precondition that the swap operates on 2 variables, no
check is necessary or warranted.
Nov 14 '05 #109
Julie wrote:
Since you use the malloc() family and this is cross posted to clc, I
assume you use C.

You assume wrong.

malloc is part of C **AND** C++.

In C this casting is not needed.

however it is valid, and required in C++.

In C this casting is not needed.
however it is valid, and required in C++.

Ok, Ok. :-)

Regards,

Ioannis Vranos
Nov 14 '05 #110

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