help with sorting

[ruel loehr]

Hey guys,

I am looking for some insight:
Given two sorted arrays of integers A and B, where array B has enough
extra room in it to hold the contents of both A and B. Merge array A
and B together such that the result is the sorted combination of the
two (do not remove duplicates) and the result resides in the B array.
I cannot perform any memory allocations to solve the problem.
Performance considerations should be taken into account in your
solution (so brute force method is not an option). Here is some
example data to help explain:

Array A: 4 7 10 15 17
Array B: 2 4 14 27 X X X X X

Where the X'es are unused slots in array B. The solution would end up
with B looking like this:

Array B: 2 4 4 7 10 14 15 17 27
Using the following function prototype:

void Merge (int *a, int na, int *b, int nb)

Where a and b point to the two arrays, na and nb are the number of
elements in each array. For array b, nb is the number of used
elements, not the size of the array. Assume array b is large enough to
hold the contents of a and b. Using the above example data na would be
5 and nb would be 4.

Also please specify the order of complexity for the algorithm you
chose to solve the problem.

My first thoughts are merge sort of course, although it requires your
to perform additional memory allocation. This leads to me an in
place merge sort.

What do you guys thinks? Any suggestions? Code isn't so important (i
can write that) but I am looking for help with the algorithm.
Thanks!

[Tom St Denis]

"ruel loehr" <ru*******@hotmail.com> wrote in message
news:50**************************@posting.google.c om...

Hey guys,

I am looking for some insight:

This is called merge sorting.

How about instead of asking someone here todo your homework you attend
class, read the suggested material, google and trial-and-error?

Tom

[Randy Howard]

In article <bD******************@news04.bloor.is.net.cable.ro gers.com>,
to********@iahu.ca says...

"ruel loehr" <ru*******@hotmail.com> wrote in message
news:50**************************@posting.google.c om...

Hey guys,

I am looking for some insight:
This is called merge sorting.

Which was mentioned in the original. You snipped it, for whatever
reason.
How about instead of asking someone here todo your homework you attend
class, read the suggested material, google and trial-and-error?

He was asking for opinions about how to implement, and also said that
he was not looking for the code, but merely suggestions about how to
implement it. You snipped that again, for suspect reasons.

That being said, this should probably be asked in comp.programming
instead of here, because it isn't really language limited.

Either way, your response was once again rude for no apparent reason.
--
Randy Howard
2reply remove FOOBAR

[didgerman]

"ruel loehr" <ru*******@hotmail.com> wrote in message
news:50**************************@posting.google.c om...

Hey guys,

I am looking for some insight:
Given two sorted arrays of integers A and B, where array B has enough extra room in it to hold the contents of both A and B. Merge array A
and B together such that the result is the sorted combination of the
two (do not remove duplicates) and the result resides in the B array. I cannot perform any memory allocations to solve the problem.
Performance considerations should be taken into account in your
solution (so brute force method is not an option). Here is some
example data to help explain:

Array A: 4 7 10 15 17
Array B: 2 4 14 27 X X X X X

Where the X'es are unused slots in array B. The solution would end up with B looking like this:

Array B: 2 4 4 7 10 14 15 17 27
Using the following function prototype:

void Merge (int *a, int na, int *b, int nb)

Where a and b point to the two arrays, na and nb are the number of
elements in each array. For array b, nb is the number of used
elements, not the size of the array. Assume array b is large enough to hold the contents of a and b. Using the above example data na would be 5 and nb would be 4.

Also please specify the order of complexity for the algorithm you
chose to solve the problem.

My first thoughts are merge sort of course, although it requires your to perform additional memory allocation. This leads to me an in
place merge sort.

What do you guys thinks? Any suggestions? Code isn't so important (i can write that) but I am looking for help with the algorithm.
Thanks!

Try this:
strcat(arrayB, arrayA);

That should work.
As our grumpy friend says, do a search on google for the strcat
function and the headers it needs.
Be aware that there is no white space etween the arrays once this has
been done.
I'm lazy so I just added an array of one whitespace first, then added
the second array.
This function returns the first array's name as the new combined
array.
You can right code to check it will all fit before the cat' takes
place.
hth

[Randy Howard]

In article <50**************************@posting.google.com >,
ru*******@hotmail.com says...

Given two sorted arrays of integers A and B, where array B has enough
extra room in it to hold the contents of both A and B. Merge array A
and B together such that the result is the sorted combination of the
two (do not remove duplicates) and the result resides in the B array.
I cannot perform any memory allocations to solve the problem.
Performance considerations should be taken into account in your
solution (so brute force method is not an option).

Well, depending on what the definition of "brute force" is in your
class, I think the simplest solution, given there will always be
sufficient room in array B to hold all of A, is to simply copy the
contents of array A into the unused slots in B. The use whatever
sort algorithm defies the rules against "brute force" and does not
require memory allocation while preserving duplicates. Bubble,
quicksort, shellsort, etc. should all be suitable once you get
the data into B, with no memory allocation required.

That's probably not what the instructor is looking for, but it seems
like an awfully straightforward method, and it could be done using
the Merge() prototype provided.
--
Randy Howard
2reply remove FOOBAR

[CBFalconer]

ruel loehr wrote:

I am looking for some insight:

Given two sorted arrays of integers A and B, where array B has enough
extra room in it to hold the contents of both A and B. Merge array A
and B together such that the result is the sorted combination of the
two (do not remove duplicates) and the result resides in the B array.
I cannot perform any memory allocations to solve the problem.
Performance considerations should be taken into account in your
solution (so brute force method is not an option). Here is some
example data to help explain:

Array A: 4 7 10 15 17
Array B: 2 4 14 27 X X X X X

Where the X'es are unused slots in array B. The solution would end up
with B looking like this:

Array B: 2 4 4 7 10 14 15 17 27
Using the following function prototype:

void Merge (int *a, int na, int *b, int nb)

Where a and b point to the two arrays, na and nb are the number of
elements in each array. For array b, nb is the number of used
elements, not the size of the array. Assume array b is large enough to
hold the contents of a and b. Using the above example data na would be
5 and nb would be 4.

Also please specify the order of complexity for the algorithm you
chose to solve the problem.

My first thoughts are merge sort of course, although it requires your
to perform additional memory allocation. This leads to me an in
place merge sort.

What do you guys thinks? Any suggestions? Code isn't so important (i
can write that) but I am looking for help with the algorithm.

You are in the wrong place for the algorithm. I can think of one
that is O(n) and needs no additional allocation, provided we can
tell XX from an entry. Try comp.programming.

--
Chuck F (cb********@yahoo.com) (cb********@worldnet.att.net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home.att.net> USE worldnet address!

[Ben Pfaff]

"didgerman" <aw******@hotmail.com> writes:

"ruel loehr" <ru*******@hotmail.com> wrote in message
news:50**************************@posting.google.c om...

Given two sorted arrays of integers A and B, where array B has

enough

Try this:
strcat(arrayB, arrayA);

That should work.

Did you fail to read the OP's article or do you just like giving
stupid and incorrect advice?
--
"The way I see it, an intelligent person who disagrees with me is
probably the most important person I'll interact with on any given
day."
--Billy Chambless

[Tom St Denis]

"Ben Pfaff" <bl*@cs.stanford.edu> wrote in message
news:87************@pfaff.stanford.edu...

"didgerman" <aw******@hotmail.com> writes:

"ruel loehr" <ru*******@hotmail.com> wrote in message
news:50**************************@posting.google.c om...

Given two sorted arrays of integers A and B, where array B has

enough

Try this:
strcat(arrayB, arrayA);

That should work.

Did you fail to read the OP's article or do you just like giving
stupid and incorrect advice?

My guess was that was intentional [e.g. give horribly bad advice so the
stupid fucking idiot won't fucking come back here to cheat on his/her/it's
assignment].

That's just my understanding. I could be wrong.

Tom

[Simon Bachmann]

ruel loehr wrote:

Hey guys,

I am looking for some insight:

Given two sorted arrays of integers A and B, where array B has enough
extra room in it to hold the contents of both A and B. Merge array A
and B together such that the result is the sorted combination of the
two (do not remove duplicates) and the result resides in the B array.
I cannot perform any memory allocations to solve the problem.
Performance considerations should be taken into account in your
solution (so brute force method is not an option). Here is some
example data to help explain:

Array A: 4 7 10 15 17
Array B: 2 4 14 27 X X X X X

Where the X'es are unused slots in array B. The solution would end up
with B looking like this:

Array B: 2 4 4 7 10 14 15 17 27
Using the following function prototype:

void Merge (int *a, int na, int *b, int nb)

Where a and b point to the two arrays, na and nb are the number of
elements in each array. For array b, nb is the number of used
elements, not the size of the array. Assume array b is large enough to
hold the contents of a and b. Using the above example data na would be
5 and nb would be 4.

Also please specify the order of complexity for the algorithm you
chose to solve the problem.

My first thoughts are merge sort of course, although it requires your
to perform additional memory allocation. This leads to me an in
place merge sort.

What do you guys thinks? Any suggestions? Code isn't so important (i
can write that) but I am looking for help with the algorithm.

Thanks!

I would do something like this:

-you need two counters(ia ib): one for a, one for b. their initial value
is na respecively nb
-use this counters to compare the respective elements of the two arrays
-copy the greather to the last (empty) element of b
-decrease the counter ia OR ib (ia if a[ia] > b[ib], ib otherwise)
-go on "filling up" b from the last element towards the first, comparing
a[ia] b[ib]

This way you need no additional memory allocation, and work will be done
with exactly na+nb passages.

Hope you understand my description. it isn't that clear...

[CBFalconer]

Ben Pfaff wrote:

.... snip ...
Did you fail to read the OP's article or do you just like giving
stupid and incorrect advice?

I sent you an e-mail a few days ago, and got no reply, yet
something in the newsgroups got an immediate response. Did you
receive anything from me? I have some things to bring up.

BTW give thanks that he is not Trollsdale, St Denis, or Nilges.

--
Chuck F (cb********@yahoo.com) (cb********@worldnet.att.net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home.att.net> USE worldnet address!

[osmium]

Simon Bachmann writes:

ruel loehr wrote:

Hey guys,

I am looking for some insight:

Given two sorted arrays of integers A and B, where array B has enough
extra room in it to hold the contents of both A and B. Merge array A
and B together such that the result is the sorted combination of the
two (do not remove duplicates) and the result resides in the B array.
I cannot perform any memory allocations to solve the problem.
Performance considerations should be taken into account in your
solution (so brute force method is not an option). Here is some
example data to help explain:

Array A: 4 7 10 15 17
Array B: 2 4 14 27 X X X X X

Where the X'es are unused slots in array B. The solution would end up
with B looking like this:

Array B: 2 4 4 7 10 14 15 17 27
Using the following function prototype:

void Merge (int *a, int na, int *b, int nb)

Where a and b point to the two arrays, na and nb are the number of
elements in each array. For array b, nb is the number of used
elements, not the size of the array. Assume array b is large enough to
hold the contents of a and b. Using the above example data na would be
5 and nb would be 4.

Also please specify the order of complexity for the algorithm you
chose to solve the problem.

My first thoughts are merge sort of course, although it requires your
to perform additional memory allocation. This leads to me an in
place merge sort.

What do you guys thinks? Any suggestions? Code isn't so important (i
can write that) but I am looking for help with the algorithm.

Thanks!

I would do something like this:

-you need two counters(ia ib): one for a, one for b. their initial value
is na respecively nb
-use this counters to compare the respective elements of the two arrays
-copy the greather to the last (empty) element of b
-decrease the counter ia OR ib (ia if a[ia] > b[ib], ib otherwise)
-go on "filling up" b from the last element towards the first, comparing
a[ia] b[ib]

This way you need no additional memory allocation, and work will be done
with exactly na+nb passages.

Hope you understand my description. it isn't that clear...

It's very clear. And kind of clever, too.

[Ben Pfaff]

CBFalconer <cb********@yahoo.com> writes:

I sent you an e-mail a few days ago, and got no reply, yet
something in the newsgroups got an immediate response. Did you
receive anything from me? I have some things to bring up.

Somehow Spamassassin decided it was spam. Will send reply.
--
int main(void){char p[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuv wxyz.\
\n",*q="kl BIcNBFr.NKEzjwCIxNJC";int i=sizeof p/2;char *strchr();int putchar(\
);while(*q){i+=strchr(p,*q++)-p;if(i>=(int)sizeof p)i-=sizeof p-1;putchar(p[i]\
);}return 0;}

[CBFalconer]

Ben Pfaff wrote:

CBFalconer <cb********@yahoo.com> writes:

I sent you an e-mail a few days ago, and got no reply, yet
something in the newsgroups got an immediate response. Did you
receive anything from me? I have some things to bring up.

Somehow Spamassassin decided it was spam. Will send reply.

It would have the same From and Reply to as this, if that triggers
things.

--
Chuck F (cb********@yahoo.com) (cb********@worldnet.att.net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home.att.net> USE worldnet address!

[Barry Schwarz]

On 17 Jan 2004 08:28:31 -0800, ru*******@hotmail.com (ruel loehr)
wrote:

Hey guys,

I am looking for some insight:
Given two sorted arrays of integers A and B, where array B has enough
extra room in it to hold the contents of both A and B. Merge array A
and B together such that the result is the sorted combination of the
two (do not remove duplicates) and the result resides in the B array.
I cannot perform any memory allocations to solve the problem.
Performance considerations should be taken into account in your
solution (so brute force method is not an option). Here is some
example data to help explain:

If you attack the problem from the back end, it may be easier. A
merge would normally have two inputs and an output. If you consider
the last entry of A as input 1, the last used entry of B as input 2,
and the last entry of B as the output, you can safely move data from
the appropriate either input to output repeatedly until you have
finished with the first elements of both inputs.
<<Remove the del for email>>

[Sidney Cadot]

Tom St Denis wrote:

[...] My guess was that was intentional [e.g. give horribly bad advice so the
stupid fucking idiot won't fucking come back here to cheat on his/her/it's
assignment].

Yeah!

You really are a mean, bad, and way-cool dude, talking like that.

Rrrespect,

Sidney

[Michael Scovetta]

Way to post the Microsoft interview question. Hope they don't use google!

ru*******@hotmail.com (ruel loehr) wrote in message news:<50**************************@posting.google. com>...

Hey guys,

I am looking for some insight:
Given two sorted arrays of integers A and B, where array B has enough
extra room in it to hold the contents of both A and B. Merge array A
and B together such that the result is the sorted combination of the
two (do not remove duplicates) and the result resides in the B array.
I cannot perform any memory allocations to solve the problem.
Performance considerations should be taken into account in your
solution (so brute force method is not an option). Here is some
example data to help explain:

Array A: 4 7 10 15 17
Array B: 2 4 14 27 X X X X X

Where the X'es are unused slots in array B. The solution would end up
with B looking like this:

Array B: 2 4 4 7 10 14 15 17 27
Using the following function prototype:

void Merge (int *a, int na, int *b, int nb)

Where a and b point to the two arrays, na and nb are the number of
elements in each array. For array b, nb is the number of used
elements, not the size of the array. Assume array b is large enough to
hold the contents of a and b. Using the above example data na would be
5 and nb would be 4.

Also please specify the order of complexity for the algorithm you
chose to solve the problem.

My first thoughts are merge sort of course, although it requires your
to perform additional memory allocation. This leads to me an in
place merge sort.

What do you guys thinks? Any suggestions? Code isn't so important (i
can write that) but I am looking for help with the algorithm.
Thanks!

[pete]

Barry Schwarz wrote:

On 17 Jan 2004 08:28:31 -0800, ru*******@hotmail.com (ruel loehr)
wrote:

Hey guys,

I am looking for some insight:
Given two sorted arrays of integers A and B, where array B has enough
extra room in it to hold the contents of both A and B. Merge array A
and B together such that the result is the sorted combination of the
two (do not remove duplicates) and the result resides in the B array.
I cannot perform any memory allocations to solve the problem.
Performance considerations should be taken into account in your
solution (so brute force method is not an option). Here is some
example data to help explain:

If you attack the problem from the back end, it may be easier. A
merge would normally have two inputs and an output. If you consider
the last entry of A as input 1, the last used entry of B as input 2,
and the last entry of B as the output, you can safely move data from
the appropriate either input to output repeatedly until you have
finished with the first elements of both inputs.

I think that's the solution that the author of the problem had in mind.

--
pete

[Richard Heathfield]

Simon Bachmann wrote:

<snip>

I would do something like this:

-you need two counters(ia ib): one for a, one for b. their initial value
is na respecively nb
-use this counters to compare the respective elements of the two arrays
-copy the greather to the last (empty) element of b
-decrease the counter ia OR ib (ia if a[ia] > b[ib], ib otherwise)
-go on "filling up" b from the last element towards the first, comparing
a[ia] b[ib]

This way you need no additional memory allocation, and work will be done
with exactly na+nb passages.

I was about to complain that you would need to reserve storage for ia and
ib, but of course you can use na and nb, which you get for free. Very neat.

--
Richard Heathfield : bi****@eton.powernet.co.uk
"Usenet is a strange place." - Dennis M Ritchie, 29 July 1999.
C FAQ: http://www.eskimo.com/~scs/C-faq/top.html
K&R answers, C books, etc: http://users.powernet.co.uk/eton

[pete]

Richard Heathfield wrote:

Simon Bachmann wrote:

<snip>

I would do something like this:

-you need two counters(ia ib):
one for a, one for b. their initial value is na respecively nb
-use this counters to compare the respective elements
of the two arrays
-copy the greather to the last (empty) element of b
-decrease the counter ia OR ib (ia if a[ia] > b[ib], ib otherwise)
-go on "filling up" b from the last element towards the first,
comparing a[ia] b[ib]

This way you need no additional memory allocation,
and work will be done with exactly na+nb passages.

I was about to complain that you would need to reserve
storage for ia and ib, but of course you can use na and nb,
which you get for free. Very neat.

You still need another object to keep track of
the last (empty) element of b.

If you copy a[0], then you're done.
If you copy b[0], then you can copy the rest of a[]
without comparisons between the rest of the elements.

--
pete

[pete]

Richard Heathfield wrote:

Simon Bachmann wrote:

<snip>

I would do something like this:

-you need two counters(ia ib):
one for a, one for b. their initial value is na respecively nb
-use this counters to compare the respective elements
of the two arrays
-copy the greather to the last (empty) element of b
-decrease the counter ia OR ib (ia if a[ia] > b[ib], ib otherwise)
-go on "filling up" b from the last element
towards the first, comparing a[ia] b[ib]

This way you need no additional memory allocation,
and work will be done with exactly na+nb passages.

I was about to complain that you would need to reserve
storage for ia and ib, but of course you can use na and nb,
which you get for free. Very neat.

I very much prefer the "pointer to element, size_t"
sorting function interface, which I got from Dann Corbit,
over the interface where everything is int and pointers to int,
for two reasons: 1 pedagogy, 2 practicality.

From a sorting algorithm point of view,
the objects which are used for book keeping inside the function,
like your ia and ib above, are conceptually,
completely different from the array elements which are also integers.

From practical point of view,
the function can be written as a template.

You can change E_TYPE to any arithmetic type without
affecting the ouptut of merge.c
If you wanted to sort non arithmetic types,
then the GT() macro would also need to be rewritten,
but you have to write a new compar function everytime you
want use qsort in a new way, so it's no big deal.

/* BEGIN merge.c */

#include <stdio.h>

#define arrayA {4, 7, 10, 15, 17}
#define arrayB {2, 4, 14, 27, 'X', 'X', 'X', 'X', 'X'}
#define E_TYPE int
#define GT(A, B) (*(A) > *(B))
#define N(E) (sizeof (E) / sizeof *(E))

typedef E_TYPE e_type;

void Merge(e_type *, size_t, e_type *, size_t);

int main(void)
{
e_type a[] = arrayA;
e_type b[] = arrayB;
size_t element;

Merge(a, N(a), b, N(b));
for (element = 0; element != N(b); ++element) {
printf("%lu, ", (long unsigned)b[element]);
}
putchar('\n');
return 0;
}

void Merge(e_type *a, size_t na, e_type *b, size_t nb)
{
e_type *end;

end = b + nb--;
nb -= na--;
for (;;) {
if (GT(b + nb, a + na)) {
*--end = b[nb];
if (nb == 0) {
break;
} else {
--nb;
}
} else {
*--end = a[na];
if (na == 0) {
return;
} else {
--na;
}
}
}
do {
*--end = a[na];
} while (na-- != 0);
}

/* END merge.c */

I like pointers:
/*
void Merge(e_type *a, size_t na, e_type *b, size_t nb)
{
e_type *end, *B, *A;

end = b + nb;
A = a + na - 1;
B = b + nb - na - 1;
for (;;) {
if (GT(B, A)) {
*--end = *B;
if (B == b) {
break;
} else {
--B;
}
} else {
*--end = *A;
if (A == a) {
return;
} else {
--A;
}
}
}
*--end = *A;
while (A != a) {
*--end = *--A;
}
}
*/
--
pete

[CBFalconer]

pete wrote:

Richard Heathfield wrote:

Simon Bachmann wrote:

<snip>

I would do something like this:

-you need two counters(ia ib):
one for a, one for b. their initial value is na respecively nb
-use this counters to compare the respective elements
of the two arrays
-copy the greather to the last (empty) element of b
-decrease the counter ia OR ib (ia if a[ia] > b[ib], ib otherwise)
-go on "filling up" b from the last element
towards the first, comparing a[ia] b[ib]

This way you need no additional memory allocation,
and work will be done with exactly na+nb passages.

I was about to complain that you would need to reserve
storage for ia and ib, but of course you can use na and nb,
which you get for free. Very neat.

I very much prefer the "pointer to element, size_t"
sorting function interface, which I got from Dann Corbit,
over the interface where everything is int and pointers to int,
for two reasons: 1 pedagogy, 2 practicality.

From a sorting algorithm point of view,
the objects which are used for book keeping inside the function,
like your ia and ib above, are conceptually,
completely different from the array elements which are also integers.

.... snip code etc. ...

Here is my version of the algorithm. The actual merge is 4 lines
of code. It is O(N), where N is the size of the merged array.

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

/* Simulating arrays to mergesort in place with strings */
/* blanks represent empty locations. The strlen represents */
/* the actual array capacity, which is fixed */

char aitem[] = "abde ";
char bitem[] = "acegjmpr ";
char citem[] = "acegjmpr ";
char ditem[] = "acegjmpr ";

#define UNUSED ' '

/* ----------------- */

void showitem(char *s, int index)
{
if (index >= 0) printf("[%d] ", index);
printf("\"%s\"\n", s);
} /* showitem */

/* ----------------- */

void merge(char *new, char* into)
{
int intosize, intolgh, newlgh;

/* extract parameters */
intosize = strlen(into);
intolgh = strchr(into, UNUSED) - into;
newlgh = strchr(new, UNUSED) - new;

/* validate space available */
if (intosize < (intolgh + newlgh)) return; /* No room */
if (intosize > (intolgh + newlgh))
intosize = intolgh + newlgh;

/* The actual merge operation */
while (newlgh && (intosize > intolgh)) {
if (into[intolgh-1] > new[newlgh-1])
into[--intosize] = into[--intolgh];
else into[--intosize] = new[--newlgh];
}
} /* merge */

/* ----------------- */

int main(void)
{
showitem(aitem, -1); showitem(bitem, -1);
merge(aitem, /* into */ bitem);
showitem(bitem, -1);
showitem(aitem, -1); showitem(citem, -1);
merge(aitem, /* into */ citem);
showitem(citem, -1);
showitem(aitem, -1); showitem(ditem, -1);
merge(aitem, /* into */ ditem);
showitem(ditem, -1);
return 0;
}

--
Chuck F (cb********@yahoo.com) (cb********@worldnet.att.net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home.att.net> USE worldnet address!

[Gledgard]

<<<Way to post the Microsoft interview question. Hope they don't use google!

We do actually. Google is quite helpful. :) Not to post for a job, but since it was brought up here, if anyone thinks they have what it takes to answer a question like this (on their own)and is interested in working for Microsoft, feel free to e-mail me at to*****@microsoft.com. :)

Gretchen Ledgard
Sr. Talent Scout
Microsoft Corporation

[Gledgard]

<<<Way to post the Microsoft interview question. Hope they don't use google!

We do actually. Google is quite helpful. :) Not to post for a job, but since it was brought up here, if anyone thinks they have what it takes to answer a question like this (on their own)and is interested in working for Microsoft, feel free to e-mail me at to*****@microsoft.com. :)

Gretchen Ledgard
Sr. Talent Scout
Microsoft Corporation

[Gledgard]

<<<Way to post the Microsoft interview question. Hope they don't use google!

We do actually. Google is quite helpful. :) Not to post for a job, but since it was brought up here, if anyone thinks they have what it takes to answer a question like this (on their own)and is interested in working for Microsoft, feel free to e-mail me at to*****@microsoft.com. :)

Gretchen Ledgard
Sr. Talent Scout
Microsoft Corporation

[Gledgard]

<<<Way to post the Microsoft interview question. Hope they don't use google!

We do actually. Google is quite helpful. :) Not to post for a job, but since it was brought up here, if anyone thinks they have what it takes to answer a question like this (on their own)and is interested in working for Microsoft, feel free to e-mail me at to*****@microsoft.com. :)

Gretchen Ledgard
Sr. Talent Scout
Microsoft Corporation

[Gledgard]

User error. :) Didn't mean to spam with 4 posts.

Apologies again,
Gretchen

[Alan Connor]

On Tue, 10 Feb 2004 20:00:43 -0600, Gledgard <to*****@microsoft.com> wrote:

<<<Way to post the Microsoft interview question. Hope they don't use google!

We do actually. Google is quite helpful. :) Not to post for a job, but since it was brought up here, if anyone thinks they have what it takes to answer a question like this (on their own)and is interested in working for Microsoft, feel free to e-mail me at to*****@microsoft.com. :)

Gretchen Ledgard
Sr. Talent Scout
Microsoft Corporation

Sorry. Working for Microsoft is way below cleaning sewers on my list of
preferred jobs.

You couldn't pay me to work with or for that grotesque OS.

I remember fondly the day that I wrote random numbers 25X over the parition
that was home to XPernicious.
Linux/UNIX are where it's at, but SCO can kiss my ass.

How typical of a M$ employee (if you aren't just a fucking troll) to
have a deceptive subject on their post.
AC
--
ed(1)
Check out the original tutorials by Brian W. Kernighan:
----- http://tinyurl.com/2uprx -----
If it's good enough for BWK, it's good enough for me.

[Richard Heathfield]

[text re-flowed]

Gledgard wrote:

<<<Way to post the Microsoft interview question. Hope they don't use
google!

We do actually. Google is quite helpful. :) Not to post for a job, but
since it was brought up here, if anyone thinks they have what it takes to
answer a question like this (on their own)and is interested in working for
Microsoft, feel free to e-mail me at <email address elided>

Please adjust your news client's line length setting. There is often some
dispute in Usenet about whether 60, or 65, or 72, or some other comparable
number is the Right Maximum Length for a Usenet line, but I think it's
generally accepted that 278 is way too long.

--
Richard Heathfield : bi****@eton.powernet.co.uk
"Usenet is a strange place." - Dennis M Ritchie, 29 July 1999.
C FAQ: http://www.eskimo.com/~scs/C-faq/top.html
K&R answers, C books, etc: http://users.powernet.co.uk/eton