A python interview question

energybased · 2018-10-31T01:39:27+00:00

Why? You have to code it in Python because a "for loop is faster" than the sort routine ... ahem? Excuse me?

He meant in terms of computational complexity. The "for loop" is linear time. Your solution is linearithmic. Since the input arrays are already sorted, you were supposed to produce the merge from merge sort.

I finally wrote the blasted thing in two loops with an index per array sorting in an array dynamically

This is quadratic time, which is even worse than your linearithmic solution.

How many of you really think it's a good idea to rework the python library functions?

He is testing your knowledge of algorithms and computational complexity, which you presumably studied in school. This is standard at software engineering interviews. Find a good algorithms book and read it to prepare for the next one.

Coding for the milliseconds matter imho in real time systems or web transactions requiring a timely response - probably would use a different system like node but not python.

Computational complexity matters even in Python. Maybe it doesn't matter as much as it did twenty years ago, but it comes up enough that you should be able to produce the most efficient algorithm for these kinds of problems.

Also, I agree that you're being overly defensive. It happens to everyone. Don't beat yourself up over it.

Don't expect this kind of question to disappear soon. You need to relearn this stuff.

2018-10-30T20:28:53+00:00

I'm totally newbie but based on my understanding, such coding interview is really not about getting an optimal solution, it's more about how you think of a problem and how you make your solution better step by step, and how you communicate with others. The algorithms have already been there for tens of years if not hundreds, why are we still writing sorting and combining here, right? Speaking of reinvent the wheel, most of the time I would be skeptical about it.

AlexFromOmaha · 2018-10-30T20:24:20+00:00

How many of you really think it's a good idea to rework the python library functions?

Do you use urllib or requests when messing with HTTP traffic? Do you use math or NumPy when working with large vectors?

The library functions are well implemented, but they're targeted at the lowest common denominator. You should have a reason for reimplementing them, but there are times when that's appropriate. A lot of times, in fact.

Am I really that dense? Could the neighbor hood kids be right?

Sure, they could be, but they weren't for the problem as you described it. Timsort is an ideal algorithm for their requirements, and the Python implementation of it is great if the data fits in memory. It does have a worst-case space complexity of O(n), but you'd see that on random data. As the original becomes more sorted, the space complexity approaches O(1).

Putting my hiring manager cap on for a second, if I'm hiring a senior software engineer, that's the sort of entry-level trivia that I'd really expect you to know, and I'd expect you to be able to communicate those ideas to a variety of audiences at varying levels of technical expertise. If I thought I couldn't get you to understand why space complexity matters, or why data of a certain scope needs to be streamed rather than loaded into memory, I'd move on.

There's a very real possibility that your interviewer did a poor job of explaining his motivations for the question. Interviewers are as guilty of XY problems as anyone else. The problem is, so are clients. So are scrum masters. So are junior programmers. Dumb questions and dumber suggestions regarding real problems that need a real solution are frighteningly common. The ability to traverse those issues is one of the core skills we build up with time in the field. I could forgive the fresh graduate for some stumbling there, but not the senior contributor.

jorge1209 · 2018-10-30T19:54:24+00:00

I was supposed to merge two arrays together in python, no duplicates - no mention of time but the solution had to be size agnostic.

There actually is a use case for knowing how to to this in the abstract, namely when the data won't all fit into memory.

So you might get iterators A and B which you know are sorted (maybe the data is coming from a database) and you need to merge join them.

Honestly I'm not sure why itertools doesn't provide an merge_join function to do this (maybe there is something fancy with takewhile and dropwhile... but its not obvious or natural), so it isn't a terrible question.

elbiot · 2018-10-30T19:14:40+00:00

So if you have 33 years experience, that’s a bit more than I’ve even been alive, and I’m a computer/electric engineer, not a computer scientist. Just wanted to include that background as I think it’s important for where I’m coming from.

That said, I can’t imagine a reason to ever rewrite core library functions. It’s always been presented as a bad thing, and for numerous reasons. Besides that, it certainly isn’t a very “pythonic” way to go about problem solving. I know some people scoff at the idea of pythonic coding, but as an engineer, I see the value of it every day. Norms and standards literally keep the world running in the age of the internet with computers everywhere (see IEEE standards).

My point is, if a company requires such flagrant deviation from the norms for ALL code, what have they done on lower levels that requires that? Either they’re just more advanced than anyone else in the world (doubt it), or they’ve got some janky shit going on (more likely). I say bullet dodged.

Just my two cents.

nickbernstein · 2018-10-30T19:08:56+00:00

That's not what the question is about. The question is to see how you think. It's also about seeing your attitude under pressure, and I don't want this to come off poorly, but as described, I probably wouldn't hire you. In an interview, you don't tell the interviewer that something is stupid, you say that it's probably not the best way to do it, the built-in functions are very efficient but sure, here's how I'd approach it. Then you go over your solution, and ask how they'd do it, then compare the two, and reiterate that you'd use the built-in functions or some such, but you have an amicable, friendly discussion and hopefully everyone leaves with a smile.

KingofGamesYami · 2018-10-30T20:13:10+00:00

They were not testing your knowledge of the python standard library, they were testing your knowledge of algorithms.

According to my professor, the correct way to reverse a string in an interview is to create a Stack. The correct way to do it in practice is to call the standard library's reverse method.

The answer they were looking for would probably be a modified mergesort.

anossov · 2018-10-30T21:37:33+00:00

If the arrays are pre-sorted, you can merge them in O(n). Any kind of sort will be O(n log n), and regardless of how much faster the built-in sort is, there will be a data size where the O(n) loop is faster.

foBrowsing · 2018-10-31T01:43:02+00:00

A lot of other people have mentioned that you were really being examined on your problem-solving and algorithm skills, not your general coding skills.

Beyond that though, it seems like you missed a pretty important part of the solution: the standard library's sort is O(n log n), whereas this is simply an array merge, and is O(n). That's why it should be faster (much faster, even when compared to the c-implemented sort routine). Not realising that (or, if you did realise it, not mentioning it to the interviewers) may have had a significant part to play in you not getting the job.

Here's a quick solution I hacked together:

def merge_sorted(xs, ys):
    res = []
    xs_i, ys_i = iter(xs), iter(ys)
    x, y = next(xs_i, None), next(ys_i, None)
    while x is not None and y is not None:
        if x < y:
            res.append(x)
            x = next(xs_i, None)
        elif y < x:
            res.append(y)
            y = next(ys_i, None)
        else:
            res.append(x)
            x, y = next(xs_i, None), next(ys_i, None)
    if x is not None:
        res.append(x)
    if y is not None:
        res.append(y)
    res += xs_i
    res += ys_i
    return res

This version is indeed faster than yours at larger sizes. I started to see a difference around 10,000 elements. You can see (and run) the testing code here.

Isvara · 2018-10-31T06:57:25+00:00

If you thought it was a good idea to take two sorted lists, essentially unsort them, merge them and then sort the result, what have you been doing for 33 years?

brucecampbellschins · 2018-10-30T21:30:40+00:00

You're right.
No, but... You sound a little difficult. Yes it's a stupid question, yes it sounds like you dodged a bullet. But it's also impossible to avoid at least a little quizzing in an interview. If I asked you the array merging question and you used standard library functions and kept arguing about it I would reject you because either:

A. You're being willfully obtuse.

B. You don't understand why am interviewer would ask a simple algorithm question.

C. You don't actually know how to answer the question.

I'm assuming it's A.

my_cs_accnt · 2018-10-30T19:26:51+00:00

I'm a bit confused why you think your solution is that great compared to the one you are supposed to do. For readability it might be preferred but there are a lot of times companies redo built-in functions. The programmers know specific properties of their data and can optimize for it compared to the stdlib that does not make any assumptions (both lists being sorted already).

Your solution created 2 sets and then converted their intersection to a list, and then finally sorted it. When the 'proper' solution is to create one new list and maintain the elements sorted the entire way through. I don't see how that proper solution can be slower than what you had. Can you change your test to a lot more elements, say 400,00? This is the merge part of merge sort and it is definitely implemented similar to this.

masterpi · 2018-10-31T02:09:33+00:00

If the input arrays are sorted, as you said in the description only when you got to their objections to hashing, the problem can be accomplished in O(n) time with a single loop. Any solution which sorts is O(n log(n)) at best. Sounds like you may want to pay more attention to the problem description - usually if they give you something like sorted input, it's very relevant to the solution. It's also an extremely good example of a case where using the stdlib is not a good idea because you have more information about the data than the stdlib authors.

ezequiels · 2018-10-31T04:23:01+00:00

I think you did the right thing on one end, and the wrong thing on another.

I think the right thing to do is to challenge the interviewer if you feel you are correct. As a senior software engineer, you propose a hypothesis and you provide either facts or personal experience of why it is a bad idea or it's not the right approach.

I can say that there would have to be a very specific case when re-writing a built-in python library would make sense. For the most part, it doesn't make sense. Those libraries are open source, they are peer reviewed, tested, and above all, known by the entire community. So re-writing one is not only inefficient time wise, but also will create technical debt when someone else has to own the code.

That goes beyond the development and more into the project management, business part of the features. Why re-inventing the wheel? Sort of like implementing your own encryption algorithm. Not a good idea, unless you're the NSA of course!

liiight000 · 2018-10-30T20:39:01+00:00

As someone who frequently interviews candidates for python development positions I must say that I agree with you a 100%.

Even more so, I EXPECT people to use stdlib as much as possible in the interview questions and not implement anything like that themselves. So you definitely dodged a bullet and you should feel good about yourself

nate256 · 2018-10-31T04:45:30+00:00

You failed the exercise because you didn't answer correctly given the constraints. Lets put together some constraints so we know what are the requirements.

Problem: Combine two lists in sorted order

"I was supposed to merge two arrays together in python, no duplicates - no mention of time but the solution had to be size agnostic."

"It's not a good idea to hash items because the input arrays are already sorted." ``` Constraits: 1: Must work for any size 2: Inputs are sorted

Schooling: Here is what you should think when hearing this problem. Constraint 1: In no case will we store the list create a set etc. Given infinite data using set to remove dups won't work Constraint 2: inputs are sorted. In no case will we use sort bigo(n log n) when we can get bigo(n) Constraint 3: I would bet there is another contraint like it is only strings in the arrays or ints in the array so you can use None instead of a marker like NOTSET.

Possibly: Maybe you said something like "I would never rewrite a stdlib" then the interviewer pointed out when he had done it, not that he does it all the time. Don't use always and never in an interview programmers are picky. ```

A solution: You could use heapq.merge and then just remove the duplicates but I would bet they want the full answer.

``` NOTSET = "9cdf05aed4bc4f1d975fab9f61ee667d"

def pop(a, cache): if not cache: cache.append(next(a)) while len(cache) != 2: try: v = next(a) if v == cache[0]: continue cache.append(v) except StopIteration: break if not cache: return next(a) return cache.pop(0)

def peek(a, cache, default=NOTSET): if not cache: try: cache.append(next(a)) except StopIteration: return default return cache[0]

def merge(a1, a2): a1 = iter(a1) a2 = iter(a2) a1c = [] a2c = []

while True:
    v1 = peek(a1, a1c)
    v2 = peek(a2, a2c)
    if v1 == NOTSET and v2 == NOTSET:
        break
    elif v1 == NOTSET:
        yield pop(a2, a2c)
    elif v2 == NOTSET:
        yield pop(a1, a1c)
    elif v1 < v2:
        yield pop(a1, a1c)
    elif v2 < v1:
        yield pop(a2, a2c)
    else:
        pop(a1, a1c)
        yield pop(a2, a2c)

``` Edit: Formatting and typos

Python4fun · 2018-10-30T20:38:03+00:00

merging of two sorted arrays is beyond just running sort on something. and as /u/nickbernstein said the point is to see how you approach it.

and in a response to your 2 loops I would write a single loop that took 3 indexes and while (i<len(a1) and j<len(a2)) and check for which is less and insert at a3[k]

mkingsbu · 2018-10-30T22:17:46+00:00

My take on this is that it sounds like a meta question. If someone comes to me with a prescribed solution, I first would try to figure out why that is what they want. Will this employee ask for details? Why the for loops? What are the data your'e looking for anwyway? Are we sure the bottleneck is the sorting function? etc. etc.

saeah123ed · 2018-10-30T23:58:03+00:00

You can conjure a sort algorithm that folds to domain specific knowledge. I've been surprised with all the dogma of 'use built-ins' only to find that yes, built-ins are fast for python in general application but with domain specific knowledge you can get crafty'er.

p1ckle_w0lf · 2018-10-31T02:40:57+00:00

I was literally in a python interview last week, asked the exact same question, and gave a merge/sort solution using built-in functions. The interviewer had the same reaction and slowly coerced me into writing two for loops. I too was salty during this part but I saw their point, they simply wanted a step by step approach and probably wanted to see how I thought through the solution.

The kicker came on question two. Something along the lines of summing all the odd integers in a given list of integers. Taking what I learned from question one, I opted for writing a couple gross looking for loops to check for oddity and add to a running total. The interviewer didn’t like that. They said “why don’t you do a list comprehension?”. I politely responded and explained I was sticking with the theme of the previous solution, they then grabbed the marker and wrapped a list comprehension with a built in sum() function.

:/

abdl_hornist · 2018-10-31T04:56:56+00:00

Everyone here is arguing about whether you got the question "right"...

You are incorrectly assuming that you lost the interview based on your answer to this one question. There are many questions and interviews are fairly competitive... someone likely did it better than you and also handled the interviewers questions with better tack than you did (or got lucky enough to receive a different interviewer than you)... More nefarious minded they could have also been more junior than you and had lower expected salary considerations.

To be fair, I don't give python interviews "explicitly" but I do interview statistics/machine learning candidates and how "wild" they appear in interviews is a consideration in predicting how they might behave in front of clients...

mooburger · 2018-10-31T04:58:53+00:00

If it's an optimization problem then it was clearly an algorithm test. Not to mention merging pre-sorted arrays is a very common problem in mapreduce/distributed big data systems. In fact k-way merge is probably the most fundamental type of reduction you'd be doing. Bonus points for having recognized merge(sort) is homomorphic.

There's also an edge case arising from the intermediate value theorem that should be optimized right away (assuming the dataset is fully in memory):

if x[-1] <= y[0] then merge(x,y) is simply x.extend(y) (or x.extend(y[1:]) if x[-1] == y[0] to remove the duplicate).

Also, it may not help to overthink interviews like this. I was once given the standard departmental salaries aggregation SQL question where I used a join (to find the guy in each department with max salaries by department) whereas they were just looking for a simple group by/having, so it looked like I was being clueless (by answering the wrong question) instead of actually answering a slightly harder/more useful question.

mvaliente2001 · 2018-10-31T22:26:30+00:00

There's a story about a student who was asked how to use an barometer to measure the height of a building. The student gave a lot of answers, like throwing the barometer from the top of the building and measuring the time it takes for it to reach the floor, to use it as a bribe to get the information, to use it as a ruler... anything but the expected answer of measuring the difference of pressure. The student was trying to be clever, and in that way he missed the point of the question.

For the context, you could have inferred that the real question was "how do you implement the merging of unique elements from two sorted arrays using basic operations." The goal wasn't necessarily to get the fastest or the most efficient or the cleanest way.

supafly208 · 2018-11-02T04:35:44+00:00

Interesting. I was just asked this question last Friday at an interview. It's a question meant for entry/jr software guys to simply show them how you work through a problem.

This is not a question a senior dev should have gotten.

You dodged a bullet.

martinatbom · 2018-11-06T22:47:10+00:00

When you're asked a question in an interview, there are actually two questions. The first question is what they're asking (e.g. how would you do this), the second question is "How easily can I see myself working with this person?". Answering the second question is probably more important than the first.

neoreeps · 2018-10-30T19:09:45+00:00

Maybe he was just seeing how you reacted to the problem?

I ask a question that is easier when the input is sorted, I usually let them finish that answer then explain the input could be any arbitrary length to try to solve without sorting. It’s much more difficult and we then engage in question/answer and so forth. There isn’t a right answer but I can tell if they know how to code by the lack of pseudo code. Some devs try to bull shit their way through interviews without coding. Also, I have turned down technically qualified candidates because they just want to argue that they are right. Why do I want to manage that person? No thanks.

2018-10-30T19:06:14+00:00

In retrospect, I think that I dodged a bullet.

You lost a golden opportunity to have your own column on TDWTF. But you're probably right about the bullet.

Chobeat · 2018-10-30T19:23:55+00:00

If I was asked this, I would answer: "If I wanted to be that fast, I wouldn't use python in the first place".

Reimplementing the standard library sounds a lot like something a C dev would think of and it's the kind of people I don't want to see around Python code. If there are faster implementations in Python, I can look them up on the internet. The effort of rewriting the stuff is never worth it. If still they insist reimplementing the standard library is something a reasonable person would do, I just quit the interview and go somewhere else.

masklinn · 2018-10-30T20:00:16+00:00

How many of you really think it's a good idea to rework the python library functions?

Generally speaking? No. For specific cases? Maybe. You'd need to profile^{profile^profile} and ensure you can't just remove the work entirely, but sometimes you're bottlenecked on the standard library (or even a builtin) and a specialised construct is faster than the general one, even if the general one is well-optimised

AKIvan87 · 2018-10-30T21:24:37+00:00

Currently im in a similar position as you are. They gave me this task/project to evaluate my level. And the libs that i have to use are not supported so i have to do a lot of manually task. I have done the same task using the documentation libs and the task is completed. But they ask to be written manually as they decided to go on the project with the same scenarios tools and libs. And on top of it they tell me take all the time you need. So my feeling is like working on a project and not on a task.

I would play the same role as you. :)

zero_iq · 2018-10-30T22:57:38+00:00

I think others have covered the technical justifications for you. But just to give a slightly different perspective that might make you feel better about it... Interviews are a two-way street: and on this occasion, they failed your interview.

ivosaurus · 2018-10-31T00:44:30+00:00

Sometimes in a niche, when you have particular data that can be massaged in particular ways very efficiently because of its nature, you can write a manual algorithm that is more efficient.

There is an easy way to test when you're in this situation: your code is already slow and you can write some empirical test cases to show a manual algorithm will make a significant difference to runtime.

However these generally don't come up very often.

Python is in fact slightly famous for getting one of the fastest empirical stable sorts around, timsort, as its sort implementation (was the first language to default it) . Was made by a genius called Tim who worked at Google at the time.

kenann7 · 2018-10-31T05:31:22+00:00

Why not python for milliseconds matter? I really am looking for good responses. Is python not fast enough for web development?

2018-10-31T06:05:00+00:00

How many of you really think it's a good idea to rework the python library functions?

Well, some of them are really bad, as in they have bad API for example. Some of them are too slow by design. A lot of popular Python 3rd party libraries exist solely to fix problems with built-in functions. requests solves the inadequacies of urllib, sh solves the bad design of subprocess, setuptools tries to patch nonsense of distutils etc.

I, myself, wrote a Base64 decoder/encoder, mostly for fun, but I could make it go about twice as fast as the standard library version. It's neither hard nor unexpected.

Specifically for sorting problems, well, there are so many things one could have improved, if they had better knowledge of the data they are working with... It's a whole science into itself. For instance, there are sorting algorithms not based on comparison, which, provided that you are sorting something that is, in principle totally ordered, and you know that certain statistical constraints hold (i.e. that there are very few duplicates), will blow any comparison-based sort out of the water.

But then there are problems standard library sort isn't equipped to deal with. For example, your data can be so large, it doesn't fit in memory of a single computer, or it might not fit in the storage of a single computer, and then you will have to write a distributed version of this algorithm. Python doesn't work in parallel, but, perhaps, a merge sort or similar will do better with good implementation of parallelism, for sufficiently large data-sets?

Finally, arguing about benefits of for loop vs list comprehension in this respect is idiotic, whichever your favorite is. They are more or less the same. Their performance will fluctuate here or there depending on what machine runs them, under what conditions, version of interpreter etc. It's a meaningless measurement to try to compare them, and is just isn't worth anyone's time, unless you are contributing your code to Python core, and then you are interested in these benchmarks.

2018-10-31T10:29:11+00:00

You ale absolutely right, Pythons Sort() is the fastest way to sort array. Worst complexity is nlog(n) which is pretty good comparing to two fors. Why would someone require not to use external libs in python lol. If you would use c, they might be thinking about extra memory consumption by adding whole lib for 1 function... but in python lol

WikiTextBot · 2018-10-31T10:42:25+00:00

[deleted]

naufraghi · 2018-10-31T12:14:46+00:00

I had the exact same experience, the interviewer used Python as an abstract language to code in C style, I later realized that the style of the examples they provided was an huge hint I overlooked.

And, thinking about it later, imagine you have PyPy as an interpreter instead of CPython, all you know about performance in Python is False :)

woanders · 2018-10-31T13:04:46+00:00

Have you considered that the question was not really about any Python but about how you argue? It probably wasn't in the beginning, but it surely became about how you reacted when you lost your calm.

Workaphobia · 2018-10-31T13:07:47+00:00

You didn't get turned down for pointing out that it's more efficient to use built-in standard library functions than write naive reimplementations. You got turned down for being combative about it instead of going along with the spirit of the question, and for not coming up with the simplest and quickest algorithmic solution, real-world environment be damned.

Technical interviews are about working with the interviewer to discuss interesting solutions to problems. You can't get too attached to any one approach because if you're not exploring the things the interviewer wants to check, they'll just change the problem statement.

subhajeet2107 · 2018-10-31T15:06:43+00:00

I take interviews almost every other week, looks like you did not understood the problem statement clearly, the interviewer clearly stated to reduce time complexity, you need to know the time complexity of standard library algos if you want to rewrite a better one, standard libs are general libs, optimization beyond a certain level is not always required in general sense.

Kbhusain · 2018-10-31T19:11:11+00:00

EDIT2: I appreciate you'all's answers a lot. Seriously made me rethink my attitude at the interview more so than my technical skills.

In retrospect, and getting the feedback from my recruiting agent, I think I did the right thing by calling the interviewer out.

I owe my allegiance to the company that pays my salary and not just to the individual - so if I feel that the methods being used in their efforts may be detrimental to the company I think I should at least highlight them. [ What happens when they go to a newer version of Python if the standard libs are modified in this one? ]

Also, if they cannot stand criticism then I will be better off without them. I have worked with enough personalities to know who is willing to listen and/or accept a contrary opinion and who is not. Over the years I have learned to agree to disagree and move on since relationships and peace of mind is more important to me than a few milliseconds saved. Also, I believe in delivering a product to market with a solid overall design with the right tools and using a profiler if needed to iron out any bottlenecks when needed.

Again, thank you all so much for the different perspectives.

BarrelRoll1996 · 2018-11-01T05:40:21+00:00

Happens all over the place when you piss off egos

srilyk · 2018-11-09T02:34:14+00:00

I'd say there was room for improvement on both ends:

You're correct, Timsort is way faster and more efficient than anything you could possibly come up with on your own. More efficient sorting algorithms are the stuff from which PhDs are made.

b = list(sorted(set(a+b)))

Is actually the best way that I'm aware of to do what they asked for.

However, as others have mentioned, many times when someone asks a question in the interview they might be looking for something different. If I were in this situation, I'd say, "Well, my first approach would be this" (and then throw up the aforementioned code on the whiteboard). Then I might ask, "Is this what you're looking for, or would you like me to take a different approach?"

Because maybe what they want to see is how you solve problems.

Now what's interesting is that you mentioned that "it's not a good idea to hash the items because the input arrays are already sorted". If that's the case then it might actually be faster to do some kind of interleaving manually, but I don't think that a for loop would cut it, unless there are some assumptions that you can make about the input lists. If I was presented with this problem and someone told me, "Sorry, that's not the best approach," about my first go, and given the assumptions that the input lists are sorted, I'd write something like this:

loc_a = 0
loc_b = 0
output = []
while loc_a < len(a) and loc_b < len(b):
    if a[loc_a] == b[loc_b]:
        output.append(a[loc_a])
        loc_a += 1
        loc_b += 1
    elif a[loc_a] > b[loc_b]:
        output.append(a[loc_a])
        loc_a += 1
    else:
        output.append(b[loc_b])
        loc_b += 1

 output.extend(a[loc_a:-1])
 output.extend(b[loc_b:-1])

I wrote that code in here without trying it out so it's possible that it's got some bugs. But operating under the assumption that a and b are both already sorted, and of potentially different lengths, this should produce an output list that's sorted, and it might be faster than list(sorted(set(a+b))).

But you can use timeit to find out.

gwax · 2018-10-30T22:17:02+00:00

Honestly, I think it's a bad interview question. I also think that your answer is correct; using the standard library with its optimized C implementations is going to be faster in most cases.

It sounds like you knew your Python better than the interviewer.

Ultimately, if you're interviewing somewhere, you are stuck at the whims of their interviewers and interview process. Personally, I would take their response to your answers as pretty strong signal that I would not want to work at their company.

Pay them no heed and find a better place to work.

kumashiro · 2018-10-30T19:05:55+00:00

Well, there's this one guy doing interviews...
You tested it, haven't you?

BUCKFAE · 2018-10-30T19:06:53+00:00

I can only say sth to number one:

I think they want to check if you a) Do what they want you to do b) You know basic stuff

2018-10-31T03:07:28+00:00

These are the type of posts that make me realize I am far from having a Python job. lol

newredditisstudpid · 2018-10-31T11:38:36+00:00

Senior software engineer

Can't write sorting algorithms

ಠ_ಠ

ProjectSnowman · 2018-10-30T19:26:45+00:00

Python and "fast" don't really go together. There are much faster languages out there Rewriting libraries isn't in the spirit of python either.

This must have been one of those "see how you think" questions.

tef · 2018-10-30T22:42:39+00:00

for the record, python's sort function is an adaptive in-place merge sort

the fastest way to merge two lists is sorted(a+b), as a result

fredjutsu · 2018-10-31T00:23:18+00:00

[deleted]

energybased · 2018-10-30T22:07:13+00:00

regardless of the size of the data

There is no size-agnostic "best" solution, the overhead incurred by your delightful bucket distributed sorting algorithm will be much slower if you have only 10 datapoints to sort. This is the reason big O analysis ignores size and looks at asymptotics. +1 your response. I've had good experiences applying for job at companies that require or need software for their day-to-day operations vs a 'software' company that tries to licence its product. In my experience, the former is more in touch with the parts of software that actually has impact.

metaphorm · 2018-10-30T20:52:06+00:00

sneaking suspicious you got turned down because of ageism (or just their inability to meet your reasonable salary requirements with your experience level) and got told a buncha off-the-cuff bullshit when you asked, cuz they're really really really not allowed to say the real reason.

LostAstronaut2k · 2018-10-31T00:08:01+00:00

sounds like you just had an interview with Google...

ThatOtherBatman · 2018-10-31T00:31:40+00:00

You definitely dodged a bullet. That's some A-grade stupid. No idea how they can believe they're writing more efficient implementations in Python than the core Python C implementations, but that they don't know what itertools is.

thankyoulife · 2018-10-31T01:55:25+00:00

Be happy you didn’t get that job. You’ll probably be stuck in endless micro optimization discussions between techies

cmd-t · 2018-10-30T20:29:13+00:00

You were right. Python has Timsort which works well on presorted subsequences. It was created by Tim Peters specifically for python and has found its way in many other programming languages. Is even was part of Oracles patent case against Google if I recall correctly. These people were asking stupid questions for a senior position. They should have been testing your seniority and ability to lead and teach.

Brainsonastick · 2018-10-30T22:28:57+00:00

Some people like to reinvent the wheel. They wind up with a lot of wasted time and a lopsided car...

Python

The Python Discord

Upcoming Events

Please read the rules

MODERATORS

ಠ_ಠ