473,854 Members | 1,967 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 20406
Julie wrote:
Howard wrote:

Haven't we beaten this dead horse long enough???

-Howard

No, just getting started.

Those that are not interested in the outcome or further discussion of this
Netscape (4.x), press 'K' and you will not be bothered any more w/ our
senseless blather on swapping and the (dis)similarity of variable

Hi,
may I offer a tentative definition for the term "variable" that hopefully
describes the way I use the term: To me a variable is a textual
representation of an lvalue within a piece of source code. The lvalue
condition distinguishes variables from arbitrary expressions. A variable
can change its value, and the basic means of accomplishing that is the
assignment. For instance, I consider "*p" a variable whenever "p" deontes a
pointer to something non-const.

It is clear from the definition I gave that there can be literally
thousands of variables that refer to the same memory location.

What is your prefered definition of variable?
Best

Kai-Uwe Bux
Nov 14 '05 #181
In <cb***********@ ns.felk.cvut.cz > ld <do*****@contro l.felk.cvut.cz> writes:
Ioannis Vranos wrote:
Ioannis Vranos wrote:
Jatinder wrote:

Q3 C/C++ : Exchange two numbers without using a temporary variable.

Isn't the bitwise solution safe only for unsigned integrals?

I just checked the standard, it is safe for both integral and
enumeration types.

...but it definitely is a nonsense for floating point numbers.
Therefore, there's no general way how to "Exchange two numbers without
using a temporary variable."

Wrong! The values of two objects of *any* type can be exchanged on
a byte by byte basis, without using a temporary variable. Is that
general enough for you?

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de
Nov 14 '05 #182
In <40************ ***@nospam.com> Julie <ju***@nospam.c om> writes:
Dan Pop wrote:

In <40************ ***@nospam.com> Julie <ju***@nospam.c om> writes:
>Dingo wrote:
>>
>> Julie <ju***@nospam.c om> wrote in message news:<40******* ********@nospam .com>...
>> > 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.
>> I wish to understand why you think a union member is not one.
>
>I'll retract my statement -- I'll agree that a union does allow for two
>variables to share the same memory address.
And, if you think even harder, you'll realise that it's the same thing
with pointers: *p and *q are two different variables, but they may share
the same memory address, depending on how the p and q variables have been
initialised (e.g. one may be pointing to one member of the union, the
other may be pointing to the other member of the union mentioned in the
union example :-)

Negative.

I see: I was pushing your thinking capabilities too hard ;-)
I do not consider pointers or references that point to the same
variable to *be* the same variable. In your example, yes _p_ and _q_ are
variables, _*p_ and _*q_ are not, they merely (may) point to 0 or more
variables.

Wrongo! *p and *q don't point to anything (unless p and q are pointers to
pointers), they are as "variables" as you can get. It is p and q that
point to variables.

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de
Nov 14 '05 #183
Julie <ju***@nospam.c om> wrote:
pete wrote:

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

In post
in the function n_sort, the variable (*node),
has the same address as either (tail) or (head) after this line:

Try again.

No *variable* is sharing the same address. Node, head, and tail all have
different addresses, unless you can say that any of the following is true:

It doesn't matter what node _points_ to, it matters where node _is_.

Under your logic, the following two variables:

int a = 1;
int b = 2;

become the _same_ same variable with the following:

b = 1;

Surely you don't now consider a and b the same _variable_, do you?

Remember, we are talking about _addresses_ of variables, not the _value_ of
variables.

<my two cents>

1. Technically, the discussion is about objects, identifiers that
designate/denote objects (aka variable names in C++), and values.

2. Julie is right, insofar as no two distinct identifiers can
designate the same object - with the obvious exception of union
members, but consider: union { int a, b; } u, *up = &u;
Now u.a, u.b, up->a and up->b denote the same object, but they are
*not* identifiers that denote objects, but expressions consisting
of two operands and one operator each. The member designators a
and b cannot be used in their own right to denote an object, they
can only appear as second operand of the . or -> operator.

3. The others are right, in that two pointer objects can reference the
same memory location (= have the same value, just like two ints
can hold equal values). This however has no bearing on the "swap a
variable with itself" issue: swapping the pointer values won't work
portably with XOR anyway, and using indirection to access the
pointed-to object involves an expression that is *not* a variable.

4. The infamous "swap with XOR" method has not only limitations WRT
the type of the operands[*], it's also broken by design, because
it fails to correctly swap the value of an object (sic!) with
itself.

5. I suggest to drop the term "variable" all together, *especially* in
cross-posts between c.l.c and c.l.c++, since it's not defined at
all in the C standard and IMHO somewhat vaguely defined in the C++
standard.

[*] Modulo accessing the representation of each operand byte-per-byte
through a pointers to unsigned char.

</my two (actually five ;-) cents>

Regards
--
Irrwahn Grausewitz (ir*******@free net.de)
welcome to clc: http://www.ungerhu.com/jxh/clc.welcome.txt
clc faq-list : http://www.faqs.org/faqs/C-faq/faq/
clc OT guide : http://benpfaff.org/writings/clc/off-topic.html
Nov 14 '05 #184
Dan Pop wrote:

In <40************ ***@nospam.com> Julie <ju***@nospam.c om> writes:
Dan Pop wrote:

In <40************ ***@nospam.com> Julie <ju***@nospam.c om> writes:

>Dingo wrote:
>>
>> Julie <ju***@nospam.c om> wrote in message news:<40******* ********@nospam .com>...
>> > 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.
>> I wish to understand why you think a union member is not one.
>
>I'll retract my statement -- I'll agree that a union does allow for two
>variables to share the same memory address.

And, if you think even harder, you'll realise that it's the same thing
with pointers: *p and *q are two different variables, but they may share
the same memory address, depending on how the p and q variables have been
initialised (e.g. one may be pointing to one member of the union, the
other may be pointing to the other member of the union mentioned in the
union example :-)

Negative.

I see: I was pushing your thinking capabilities too hard ;-)
I do not consider pointers or references that point to the same
variable to *be* the same variable. In your example, yes _p_ and _q_ are
variables, _*p_ and _*q_ are not, they merely (may) point to 0 or more
variables.

Wrongo! *p and *q don't point to anything (unless p and q are pointers to
pointers), they are as "variables" as you can get. It is p and q that
point to variables.

We disagree.
Nov 14 '05 #185
>> > > >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 waysto access > it.

I wish to understand why you think a union member is not one.

I'll retract my statement -- I'll agree that a union does allow for two
variables to share the same memory address.

I'll provide mine: modifiable lvalue.

By this definition, these are variables:

foo.a (where foo is a struct or union)
foo[1] (where foo is an array of dimension at least 2)
foo[j] (where foo is an array, and j is in range)
foo[k] (where foo is an array, and k is in range)

AND, I'll claim that foo[j] and foo[k] are variables, and they
are usually different variables (occupy different memory), but
they could refer to the same memory if j == k.

Gordon L. Burditt
Nov 14 '05 #186
Ioannis Vranos <iv*@guesswh.at .grad.com> wrote in message news:<cb******* ****@ulysses.no c.ntua.gr>...
int main (void)
{
if (printf("Hello World")) {}

/* Only needed for C90 compliance */
if (exit(EXIT_SUCC ESS),1){}
}

Here was my less elegant solution. But I didn't even use anything that
looks like a ';'. (commas look a lot like semicolons...) :)

#include <stdio.h>
#include <stdlib.h>

int main() {
while(printf("h ello\n") && 0) {
}
while(((int (*)(int))(exit) )(0) || 1) {}
}
Nov 14 '05 #187
waste of time. If I can't recall an exact algorithm, I just
look it up in one of my many reference books, including the
3 volumes of Knuth. The overall approach to solving a problem
and how I think about designing a solution is what's really
important. Don't sweat the small things, that's what junior
programmers are for.

When an interviewer uses these types of questions correctly they are
trying to see how you think. They aren't looking for the exact (or
even a correct) answer or exact syntax, but that you understand the
fundamentals the question is based on and that you can reason through
problems. Getting the right answer isn't the point.

Unfortunately these types of questions are often abused by people who
don't know how to interview. And if they don't ask anything but
bit-twiddler questions that's also a problem.
Nov 14 '05 #188
In article <jk************ *************** *****@4ax.com> ir*******@freen et.de writes:
Julie <ju***@nospam.c om> wrote: ....
No *variable* is sharing the same address. Node, head, and tail all have
different addresses, unless you can say that any of the following is true:

.... 1. Technically, the discussion is about objects, identifiers that
designate/denote objects (aka variable names in C++), and values.

Technically the case hinges on the definition of "variable", which C does
not give. Let Julie show the implementation of a swap function of two
"variables" in C, and after that we can look further.
--
dik t. winter, cwi, kruislaan 413, 1098 sj amsterdam, nederland, +31205924131
home: bovenover 215, 1025 jn amsterdam, nederland; http://www.cwi.nl/~dik/
Nov 14 '05 #189
"Dik T. Winter" wrote:

In article <jk************ *************** *****@4ax.com> ir*******@freen et.de writes:
> Julie <ju***@nospam.c om> wrote:

...
> >No *variable* is sharing the same address. Node, head, and tail all have
> >different addresses, unless you can say that any of the following is true:

...
> 1. Technically, the discussion is about objects, identifiers that
> designate/denote objects (aka variable names in C++), and values.

Technically the case hinges on the definition of "variable", which C does
not give. Let Julie show the implementation of a swap function of two
"variables" in C, and after that we can look further.

Actually, the original says "two numbers" -- it disintegrated into 'show me two
variables that have the same memory location' soon afterward.

It has been shown that two variables can have have the same memory location
using unions. Therefore, in order to successfully use the XOR swap trick, the
precondition needs to be: uses two variables that do not share the same