[Nil]

Wow, that's an awesome story and read. Really hoping you pull it out. I personally think you're exceptionally prepared to work for Amazon based on your past experiences and simply what you're able to share on this forum with such depth. Nice to see someone with the skills get a chance rather than the guy who did nothing but study ds & algorithms for days on end and has every interview problem memorized and pretends they haven't seen the problem before during the interview.

It would be nice if you kept us updated, for better or worse. Hopefully for better, but it'd be a nice learning experience for people reading to see how things were handled even this late in the interview process and what to look out for.

[Blink]

Good luck! Seems like a nice job.

The first solution I thought of would have a really odd computational and memory complexity, reduced if there are no duplicate numbers. However, it would vary based on the size of the largest number in the array, so there is no guarantee to be above or below O(nlogn). (based on bucket sort, my favorite sorting algorithm) Later thoughts were less weird.

[phyrrus9]

It would be nice if you kept us updated, for better or worse. Hopefully for better, but it'd be a nice learning experience for people reading to see how things were handled even this late in the interview process and what to look out for.

I plan on it.

Good luck! Seems like a nice job.

The first solution I thought of would have a really odd computational and memory complexity, reduced if there are no duplicate numbers. However, it would vary based on the size of the largest number in the array, so there is no guarantee to be above or below O(nlogn). (based on bucket sort, my favorite sorting algorithm) Later thoughts were less weird.

Keep in mind, has to work for ALL data sets, of any size > 1 that the computer can hold. The data constraints were
array of integers in range [-2147483647, 2147483647]
size of array is always > 1
never larger than maximum system memory (subtracting memory needed for program code, data, and OS)
all numbers are chosen at random and in no order

[Blink]

Good luck!  Seems like a nice job.

The first solution I thought of would have a really odd computational and memory complexity, reduced if there are no duplicate numbers.  However, it would vary based on the size of the largest number in the array, so there is no guarantee to be above or below O(nlogn). (based on bucket sort, my favorite sorting algorithm) Later thoughts were less weird.

Keep in mind, has to work for ALL data sets, of any size > 1 that the computer can hold. The data constraints were
array of integers in range [-2147483647, 2147483647]
size of array is always > 1
never larger than maximum system memory (subtracting memory needed for program code, data, and OS)
all numbers are chosen at random and in no order

Then what if nlogn < 5? Your algorithm would be worse than nlogn there too.

[mothered]

Congratulations on this! You certainly have the skills and qualifications. If anyone on here deserves this I'd say its you.

After having to apply half a bottle of eye drops and get new subscription lenses, I've made my way to read your thread.

And I don't even wear glasses.

I do hope you didn't take my above comment literally.

On-topic, congrats again.

[phyrrus9]

Good luck!  Seems like a nice job.

The first solution I thought of would have a really odd computational and memory complexity, reduced if there are no duplicate numbers.  However, it would vary based on the size of the largest number in the array, so there is no guarantee to be above or below O(nlogn). (based on bucket sort, my favorite sorting algorithm) Later thoughts were less weird.

Keep in mind, has to work for ALL data sets, of any size > 1 that the computer can hold. The data constraints were
array of integers in range [-2147483647, 2147483647]
size of array is always > 1
never larger than maximum system memory (subtracting memory needed for program code, data, and OS)
all numbers are chosen at random and in no order

Then what if nlogn < 5? Your algorithm would be worse than nlogn there too.

Code:

if (list_size <= 5) memcpy(largest, list, list_size * sizeof(int); else { // actual algo goes here } for (i = 0; i < 5 && i < list_size; ++i) // not part of the algo, this is just printing the results printf("%d\n", largest[i]);

[Blink]

Keep in mind, has to work for ALL data sets, of any size > 1 that the computer can hold. The data constraints were
array of integers in range [-2147483647, 2147483647]
size of array is always > 1
never larger than maximum system memory (subtracting memory needed for program code, data, and OS)
all numbers are chosen at random and in no order

Then what if nlogn < 5? Your algorithm would be worse than nlogn there too.

Code:

if (list_size <= 5)     memcpy(largest, list, list_size * sizeof(int); else {     // actual algo goes here } for (i = 0; i < 5 && i < list_size; ++i) // not part of the algo, this is just printing the results     printf("%d\n", largest[i]);

In that case, then I could do the same...

[phyrrus9]

Then what if nlogn < 5? Your algorithm would be worse than nlogn there too.

Code:

if (list_size <= 5)     memcpy(largest, list, list_size * sizeof(int); else {     // actual algo goes here } for (i = 0; i < 5 && i < list_size; ++i) // not part of the algo, this is just printing the results     printf("%d\n", largest[i]);

In that case, then I could do the same...

Remember, solving the problem is only one part of the question, and it's not a very significant one

[Nil]

Hey phyrrus9, how are things going?

[Wolfsschanze]

Next cover letter I compose, I'm definitely fitting in that "Time Magazine Person of the Year 2006" joke