How to Ace the Google Interview: Ultimate Guide

Obviously not saying FAANGs are quite that bad, but still, this is a pretty shallow reason to work somewhere.

Yes, I confirmed that by pasting it into the REPL and verifying that it gives the wrong answer for a one-element list. Apparently the author failed to follow his own advice to always test code that you write.

As a SQL guy who knows Python, but specifically just pandas/seaborn/numpy (matrix/set operations rather than the underlying constructs which make numpy/pandas possible), as opposed to a SWE with OO skills, could you point me in the right direction to learn how this question should be answered?

>"explain to me what a left outer join does". He shook his head in confusion "Never heard of it". Actually happened! I'm not even exaggerating!

I... I don't even know what to say here. That's absurd to me he would claim SQL knowledge and respond with that answer.

My response would be "that is the same as a `left join`" (then I'd explain what a left join was) and follow up with "I exclusively write 'left join' and never 'left outer join' as my experiences with the DB/MS I'm most familiar with (Postgres, Redshift, MySQL, MSSQL and a couple others) accept the `left join` syntax without specifying `outer`".

Ok, couldn't find a sample on the web so here's mine. It's not right for brevity and because this is the first python code I've done in ~3 years, so any criticisms welcome. Hopefully can get the formatting right

  # super.init omitted for brevity
  class Expession: # abstract base class
      def eval(): pass

  class Literal(Expession):
      def __init__(self, val): self.value = val        
      def eval(self): return self.value

  lit1 = Literal(8)
  print(lit1.eval()) # prints 8

  class UnaryExpr(Expession): pass # base class for unary expressions

  class Negate(UnaryExpr):
      def __init__(self, expr): self.expression = expr
      def eval(self): return - self.expression.eval()

  lit2 = Literal(13)
  neg = Negate(lit2)
  print(neg.eval()) # prints -13

  class BinaryExpression: pass # base class for binary expressions

  # Note that subclasses Add and Multiply have the same
  # __init__ code so I should hoist that into the BinaryExpression
  # base class but for clarity I'm leaving it in the subclasses

  class Add(BinaryExpression):
      def __init__(self, leftExpr, rightExpr):
          self.leftExpression = leftExpr
          self.rightExpression = rightExpr
      def eval(self):
          return self.leftExpression.eval() + self.rightExpression.eval()

  add2literals = Add(lit1, lit2) # 8 + 13
  print(add2literals.eval()) # prints 21

  class Multiply(BinaryExpression):
      def __init__(self, leftExpr, rightExpr):
          self.leftExpression = leftExpr
          self.rightExpression = rightExpr
      def eval(self): return self.leftExpression.eval() * self.rightExpression.eval()

  mult2literals = Multiply(lit1, lit2) # 8 * 13
  print(mult2literals.eval()) # prints 104

  # now let's make a complex expression, say (7 + 2) * (-4)
  # Doing this by hand but a parser would build this from that
  # string
  expr = Multiply(
      Add(Literal(7), Literal(2))
      ,
      Negate(Literal(4)))
  print(expr.eval()) # prints -36

Make sense?

Re. the left join, I abbreviated it. Full event was that there was 2 interviewers, me + other guy. I said to our interviewee, "what's a left join?". Cue puzzled expression and headshake. My co-interviewer qualified that for him: "what's a left outer join?", getting the response "never heard of it". He claimed 4 years of sql on his CV. No job for you, matey.

This isn't rare either, worked at a recruitment office and overheard a conversation which recruitment agent used to check applicant wasn't clueless. Applicant was applying for C++ job. Q: "give me 4 STL containers". Applicant replied "cin and cout".

If you've done no C++ that's like asking a python guy "give me some python data structures" and getting back the reply "input() and print()"

Edit: to clarify about the expression eval stuff, I wasn't expecting code, just an obvious grasp of a tree of objects with relevant subtypes, and eval(). He knew roughly how to do it procedurally, but blatantly had no clue on the OO style (which, yes, he claimed to have on his CV).

Incidentally, I'm just starting my very first step into Pandas today. Looks SQL-ish!