foo.bar: Rusty calculator

Last week I wrote about the code challenge foo.bar: Peculiar balance. Today I’ll tease you with another one:

Rusty calculator
================

Lab minion Rusty works for Professor Boolean, a mad scientist. He’s been stuck in this dead-end job crunching numbers all day since 1969. And it’s not even the cool type of number-crunching – all he does is addition and multiplication. To make matters worse, under strict orders from Professor Boolean, the only kind of calculator minions are allowed to touch is the Unix dc utility, which uses reverse Polish notation.

Recall that reverse Polish calculators such as dc push numbers from the input onto a stack. When a binary operator (like “+” or “*”) is encountered, they pop the top two numbers, and then push the result of applying the operator to them.

For example:
2 3 * => 6
4 9 + 2 * 3 + => 13 2 * 3 + => 26 3 + => 29

Each day, Professor Boolean sends the minions some strings representing equations, which take the form of single digits separated by “+” or “*”, without parentheses. To make Rusty’s work easier, write function called answer(str) that takes such a string and returns the lexicographically largest string representing the same equation but in reverse Polish notation.

All numbers in the output must appear in the same order as they did in the input. So, even though “32+” is lexicographically larger than “23+”, the expected answer for “2+3″ is “23+”.

Note that all numbers are single-digit, so no spaces are required in the answer. Further, only the characters [0-9+*] are permitted in the input and output.

The number of digits in the input to answer will not exceed 100.

Test cases
==========

Inputs:
(string) str = “2+3*2″
Output:
(string) “232*+”

Inputs:
(string) str = “2*4*3+9*3+5″
Output:
(string) “243**93*5++”

The solution (in Python) is surprisingly short:

```def answer(normal):
res = ''
muls = normal.split('+')
for mul in muls:
if len(mul) > 1:
local_mul = mul.split('*')
res += ''.join(local_mul)
res += (len(local_mul) - 1) * '*'
else:
res += mul
res += (len(muls)-1) * '+'
return res```

That’s definitely NOT the way you should write your code…
Can you figure it out?

Hint: a similar technique was used here

foo.bar: Peculiar balance

In the past few months Google pulled “Matrix” on many Python and Java engineers: if you google terms like “python lambda” you might get pulled into “The Matrix” as well…
To me it happened on a Saturday around midnight, I googled something related to Python and suddenly the search page collapsed and became dark. There was a single sentence that said something like:
“You speak our language”.
and then it invited me to participate in a series of code-challenges.
As a veteran member of CodeEval I gladly stepped into the Matrix and started solving different challenges. All was good until I ran into the following:

Peculiar balance
================
Can we save them? Beta Rabbit is trying to break into a lab that contains the only known zombie cure – but there’s an obstacle. The door will only open if a challenge is solved correctly. The future of the zombified rabbit population is at stake, so Beta reads the challenge: There is a scale with an object on the left-hand side, whose mass is given in some number of units. Predictably, the task is to balance the two sides. But there is a catch: You only have this peculiar weight set, having masses 1, 3, 9, 27, … units. That is, one for each power of 3. Being a brilliant mathematician, Beta Rabbit quickly discovers that any number of units of mass can be balanced exactly using this set.
To help Beta get into the room, write a method called answer(x), which outputs a list of strings representing where the weights should be placed, in order for the two sides to be balanced, assuming that weight on the left has mass x units.
The first element of the output list should correspond to the 1-unit weight, the second element to the 3-unit weight, and so on. Each string is one of:

“L” : put weight on left-hand side
“R” : put weight on right-hand side
“-” : do not use weight

To ensure that the output is the smallest possible, the last element of the list must not be “-“.
x will always be a positive integer, no larger than 1000000000.

Test cases
==========
Inputs:
(int) x = 2
Output:
(string list) [“L”, “R”]
Inputs:
(int) x = 8
Output:
(string list) [“L”, “-“, “R”]

After playing a bit with numbers, I figured out my strategy:
Given a number x I’ll try to find the minimal integer y >=x so that y can be presented as a sum of distinct powers of 3.
I say “distinct” because the coefficients for any power of 3 can be either 0 or 1.
Example:
A good solution: 12 = 0*3^0 + 1*3^1 + 1*3^2
A bad solution: 12 = 3*3^0 + 0*3^1 + 1*3^2
The second solution is bad because one of the coefficients is 3.
So I need to find the smallest y that respects this rule. Once I’ve found such a y, and since I already know how to represent it as a series of distinct powers of 3 – it’s a good candidate for ‘R’.
Now I still need to figure out how to represent the difference y-x as a “series of distinct powers of 3″ and I’m done.
As you might already started suspecting: we cannot find such a representation for any y-x. And indeed, in case we fail, we’ll have to look for the “next y” and on and forth.
The code looked like this:
```from itertools import combinations

"""
Main logic:
find the closest number y >= x so such that:
1. y is a sum of powers of 3
2. x + z = y where z is sum of numbers, each of which is a power of 3
3. z will be decomposed to "L" and y will be decomposed to "R" in build_list()
"""
next = find_next_sum_of_powers(x)
left = represent_as_powers(next - x)
while list(set(left)) != left: # meaning we have the same item more than once in "left"
# look for the next "sum of powers" and try to use it instead
next = find_next_sum_of_powers(next + 1)
left = represent_as_powers(next - x)
right = represent_as_powers(next)
return build_list(left, right)

def find_next_sum_of_powers(x):
"""
Given a number x, find the closest number y
such that y >= x and y is one of the numbers
returned by get_list_of_sums() and there is no number z,
which is also returned by get_list_of_sums() such that:
y > z > x
"""
next = find_next_power(x)
if x == next:
return x
if x <= next // 2:
sums = []
for list_of_sums in get_list_of_sums(x):
for sm in list_of_sums:
if sm not in sums:
if x == sm:
return x
if sm - x in sums:
return sm
sums.append(sm)
else:
return next

def is_power_of_3(x):
"""
Checks if x is a power of 3
"""
n = 0
b = 0
while n < x:
n = 3 ** b
b += 1
return n == x

def get_list_of_sums(x):
"""
Generates a list of sums of powers of 3:
1, 3, 4, 9, 10, 12, 13...
4 = 3 + 1; 10 = 9 + 1; 12 = 9 + 3; 13 = 9 + 3 + 1; ...
"""
workset = []
for i in gen_next_power():
if i > x:
break
workset.append(i)
res = []
for i in range(len(workset)+1):
for j in combinations(workset, i):
res.append(j)
yield map(sum, res[1:])

def gen_next_power():
"""
Generator for powers of 3
each iteration will get the next power
"""
pow = 0
while True:
yield 3 ** pow
pow += 1

def find_next_power(x):
"""
Given a number x find the closest
power of 3, y such that y > x and there
is no power of 3, z such that  x < z < y
"""
if x == 1:
return x
t = 3
while t < x:
t *= 3
return t

def represent_as_powers(num):
res = []
while num > 0:
t = find_next_power(num)
if t > num:
t /= 3
res.append(t)
num -= t
return res[::-1]

def build_list(left, right):
stop = right[-1]
res, i = [],  0
while 3 ** i <= stop :
if 3 ** i in left:
res.append("L")
elif 3 ** i in right:
res.append("R")
else:
res.append("-")
i += 1
return res
```
Now, this works. Only problem is – this approach of trying different y’s could get really expensive.
In fact, if I limited the number “retries” to a small number – I could get almost all the test-cases to pass – all but one…
But I wasn’t ready to give up 🙂
So I started googling and found this post which provided a good direction but to be honest – I didn’t understand:
1. how balanced ternary representation helps to solve our problem
2. how to translate from ternary representation to balanced ternary
These questions are coupled, and it took me some extra-reading to figure it out and what I’d like to do now – is save you the time that I spent, by trying to explain it a little better than that post, wikipedia and other resources I ran into during my investigation.
Let’s start with the second question which is pure technical, by comparing numbers in different bases, we’ll represent “balanced” with 1,0,-1:
decimal      1    2      3     4      5
ternary      1    2      10    11     12
balanced     1    1-1    10    11     1-1-1
Trying to follow up on the “balanced” gave me a headache… but after playing with it for a bit, and reading some search results like this answer (which explains how to add numbers in balanced-ternary form), made things much clearer:
in “balanced” we’re still using ternary-base, and the numbers 1/0/-1 are simply the coefficients of the respective power of 3. Lets demonstrate:
2 = 1*3^1 -1*3^0 = 1-1
3 = 1*3^1 + 0*3^0 = 10
4 = 1*3^1 + 1*3^0 = 11
5 = 1*3^2 1*3^1 1*3^0 = 9 – 3 – 1 = 1-1-1
etc
Once you realize the answer to #2 it’s only another small step to understand the connection to the code challenge:
Given that number x, once we find its balanced-ternary representation we can express it as a… sum of distinct powers of 3!
Now we have only a small obstacle: this sum has positive and negative elements – how do we handle it?
The challenge was to balance weights, which means that instead of “subtracting” the left side we can “add” the weight to the right side – like balancing equations!
The meaning of this is that the balanced-ternary form is actually the answer we’re looking for, lets take the number 5 from the previous example:
5 = 1*3^2 1*3^1 1*3^0 = 9 – 3 – 1 = 1-1-1
in the form of our answer – we’re looking at the result from right to left, which means that
1-1-1 = [-1, -1, 1] = 1*3^0 1*3^1 + 1*3^2
and the way it helps us solving the problem is by using ‘R’ as 1*3^2 and balancing it with ‘L’ by adding to ‘L’ 1*3^0 + 1*3^1 which ends up as simply replacing letters in the reversed version of the balanced-ternary form
from: [-1, -1, 1]
to:   [L,  L,  R]

Further, if we have a zero in the balanced-ternary form it means that neither L nor R should add the respective power of 3, so we can simply replace any zero with “-” (dash).
We’re now ready to look at the code:
```def answer(x):

def to_ternary(x):
"""
convert decimal into ternary
"""
res = ""
while x > 0:
res = str(x % 3) + res
x /= 3
return int(res)

def to_balanced(t):
"""
convert ternary number into balanced-ternary
and then to L/-/R representation
"""
res = map(int, str(t))[::-1] # iterating the digit from right --> left
for i in range(0, len(res)):
# zeros will remain zeros and ones remain ones
# the only thing we need to convert is 2 into +- (== +1-1)
if res[i] == 2:
res[i] = -1
res = inc(res, i + 1)

# convert from (1,0,-1) representation to (R,-,L)
return ['-' if x == 0 else ('R' if x == 1 else 'L') for x in res]

def inc(arr, ind):
"""
calculate the carryover
"""
if len(arr) == ind:
arr +=  # prepend the last carryover
elif arr[ind] == -1:
arr[ind] = 0
elif arr[ind] == 0:
arr[ind] = 1
elif arr[ind] == 1:
arr[ind] = -1
arr = inc(arr, ind + 1)
else: # arr[ind] == 2
arr[ind] = 0
arr = inc(arr, ind + 1)
return arr

```
Needless to say that this solution worked perfectly. Last week a friend asked me to help him prepare for a job-interview at FB. The first thing I did was pointing him to Cracking the Coding Interview which provides an excellent overview of all the main subjects an Engineer might be asked during an interview. My recommendation was to take the time and go through each and every chapter, and try to solve the questions. It’s very important not to “cheat” and try hard to solve them by yourself – otherwise you won’t improve!

Another important thing is, in case you weren’t able to solve a question and you checked out the answer – DO NOT try to memories it! instead, go on and continue solving other questions, and after a few days, try again to solve that same question. You might be surprised to find out that even though you saw the answer – it’s not always trivial to re-write it. Further, this is a good exercise that sharpens another important skill: being able to write code that expresses the algorithm we have in mind.

There’s plenty of good information available online, just Google it and you’ll find excellent blog posts such as this one, and many others.

Another smart thing my friend did was to go over job-interview websites and forums and copy questions that other candidates wrote they were asked during their interviews in FB. The following is a list of such questions:

1. Calculate the square root of a double
2. Given n intervals [si, fi], find the maximum number of overlapping intervals.
3. Print all the paths from root to every leaf in a binary tree.
4. Print the sum of all the numbers at every vertical level in a binary tree
5. Given a set of n jobs with [start time, end time, cost] find a subset so that no 2 jobs overlap and the cost is maximum ?
6. Given 1 trillion messages on FB and each message has at max 10 words, how do you build the index table and how many machines do you need on the cluster to store the index table ?
7. Given an input array and another array that describes a new index for each element, mutate the input array so that each element ends up in their new index. Discuss the runtime of the algorithm and how you can be sure there won’t be any infinite loops.
8. Find all the anagrams in an array of strings
9. Combinations(n, k) – print all combinations of k out of n items
10. Printing a binary tree L-R,
11. Implementing a comparator function to sort files based on a certain naming convention.
12. Implement a LRU cache
13. Design FB newsfeed
14. How would you query for all the Places near a given coordinate? The focus is on how to scale this to a large number of places while keeping response time to within acceptable user expectations
15. Given a list of words, group anagrams.
16. Find all 3 items that sum to 0 in an array.
17. Write a function that calculates input strings with operators +,-,*,/ eg. “5+5*6″ should output 35
18. Printing the nodes of a linked list in reverse
19. Finding the longest palindrome in a given string
20. Finding maximum subarray sum (similar to Kadane’s Algorithm) with the constraint that two numbers in the array that form the max sum cannot be next to each other
21. How do you use Facebook app and what are the problems with it? How would you fix it?
22. Design a Facebook travel app
23. designing a system to do spam detection work and describing it in a huge flowchart, as might be done in an early but detailed product planning session. Be prepared to think on large scales.
24. Write a palindrome-checking function
25. Print a tree, level by level.
26. Write all solutions for a^3+b^3 = c^3 + d^3, where a, b, c, d lie between [0, 10^5]
27. Print a list in reverse
28. Compute maximum profit for buying selling a stock given an array of prices for n days.
29. Check if two binary trees are Isomorphic
30. How would you come to an agreement if you and another senior level engineer couldn’t agree on a technical design?
31. Write a function that takes 2 arguments: a binary tree and an integer n, it should return the n-th element in the inorder traversal of the binary tree.
32. Add up two big integers represented in arrays.
33. Design a system to support Facebook status update.
34. Design the recommendation system for search keywords
35. Given 2 very large numbers, each of which is so large it can only be represented as an array of integers, write a function to multiply them.
36. Write a function to display a JSON string in pretty format.
37. Write a function to check if polygon is simple based on given list of points
38. Function to compute the number of ways to climb a flight of n steps. Taking 1, 2, or 3 steps at a time. Do it in Linear time and constant space. Example:
```n = 3.
1 1 1
1 2
2 1
3
Ans = 4```
39. Interweave a linked list. Do it in Linear time and constant space.
```Input: A->B->C->D->E
Output: A->E->B->D->C```
40. Given a dictionary based simple password, create all possible (special character) passwords based on a provided mapping.
```Input: face
Map: {a -> @, 4, A}
Output: f@ce, f4ce, fAce```
41. Get numeric number out of a roman string, linear time
```Given: mapping I = 1, V = 5, X = 10, L = 50, C = 100, D = 500, M = 1000
Input/Output:
II = 2, III = 3, IV = 4
VI, VII, VIII
IX = 9
XL = 40,
XLIX = 49```
42. Merge ‘k’ sorted arrays, each array may have max ‘n’ elements
43. What would you change in Facebook?
44. Given a sorted array, write a program to decide if two elements sum up to a third.
45. Determine the 10 most frequent words given a terabyte of strings

Good Luck!

WALP (We Are Lazy People) Yesterday, one of my colleagues reminded me that I once said that I’m going to do the minimum to maintain project X. Project X is not its real name but maybe I should back up a few steps and start with providing some background:
one of the things that happens at Netflix pretty often is that teams change, responsibilities shift and as a result projects are handed off between teams. Project X is such project, it was written long time ago (more than two years back which is basically forever in our industry) by a guy that now manages another team, and was handed off to a team that currently doesn’t exist, and when that team was disassembled I was given this project.

So yesterday, the guy who wrote project X reminded my that I said I’m planning to do the minimum to maintain it. I was surprised because one of the things that doesn’t fit me is to come up with such a statement, and then I remembered: WALP.

Some people will describe it like this, but I just rather say that I’ll do the maximum to be in a condition where I have to do the minimum in order to maintain an existing project. Sounds confusing ? well, not really…

Project X was written in Python and had two major components (class-files) which became monolithic: functions that perform multiple tasks (which goes against SRP) with hundreds lines of code, a few levels of nested loops – complicated to follow and understand, a nightmare to debug and horror to test.

So, in order to be able to “do the minimum to maintain it” one of the first things I did was refactoring these two classes: breaking the logic into smaller functions, minimizing the number of arguments, working according to DRY and SRP, renaming variables and functions, adding unit-tests and while I was “shaking the tree” a few bugs were discovered and fixed as well.

There wasn’t much “fun” in it, it’s not like writing a project from scratch which is really tempting to most engineers but usually is a bad idea. It’s tempting because you think “I’ll get it right this time” or “I can do much better than that” and let’s be honest: when you’re maintaining someone else’s code – it will never “belong” to you, that other guy will always get the credit for writing this project – even if the code changed so much that it doesn’t look anything like it originally did…

Back to the story, the refactoring paid off, and it wasn’t even in the long term:
* a few bugs were found and fixed
* bugs that were discovered later on, were easier to debug and fix
* I had to write a few additional features, all were implemented very quickly, easily, without any pain and were easy to test

So yes, I AM lazy, and I’m willing to work really hard to sustain it…

How I wrote FeedMe A few days ago I released the first version of FeedMe, a small Android app I wrote over the last few weekends. I promised my wife to write it after our first daughter was born and we found ourselves keeping tracks of her feedings using notes that were all over the house. After a few nights that we woke up, the baby was crying, and we couldn’t find the notes anywhere around (had to go to the living room, kitchen etc) I’ve had it and decided to build this side project.

By the time I got to it, our daughter was already a few months old, and she slept through the night and there was no real need, but I promised my wife that for the second one – I’ll make sure to build it in time.

And I did!

Our second daughter was born a couple of days ago, only a few days after I released the app. Needless to say that the app is free, and I intend to keep it so, and not only that: I plan to open source it and I’ll appreciate if other hackers will decide to contribute, add features, improve the code, or do whatever they want with it.

I will release the code together with other Bitbucket and GitHub projects, as soon as I fix the code a bit and make it presentable (I did some quick & dirty hacking in order to make it work cause I was short in time and I don’t have experience developing apps).

I’d love to get your feedback, but please don’t send feature-requests because I got plenty features & ideas I want to implement but I lack the time to do so…

Grails is Groovy! Grails is a framework that uses the advantages of Groovy, a dynamic type language which is almost a superset of Java, and the principle of “convention over configuration” in order to supply a very easy to use and quick to develop web-applications. It relies on the JVM and Spring as well as some other technologies that are out of scope for this post (Hibernate, templates etc).

Grails is based on MVC design pattern, in case you’re not familiar with it yet – you should, but until you do I’ll give you the highlights:
MVC stands for Model-View-Controller, which separates concerns and thus eliminates dependencies between the data (model), display (view) and business logic (controller). The controller is the entry point to the app, the HTTP request is dispatched to the relevant controller which drive the data from the Model, and might process it using one or more of the Service classes and will choose the proper View for display. The View doesn’t have to be strictly “display” it could also be JSON/XML or any other representation of the data.

In the rest of this post we’ll create the helloworld example and run it – with one major added value: I’ll help you avoid the pitfalls that I ran into. Ready ?

If you already have JDK installed – good for you, if not, you’ll have to install it first (not the JRE!)
It took me less than 10 minutes to download, install and run my first “Hello World!”
All you have to do is:
1. extract the zip file into the location you want it to be
2. add the environment variable `GRAILS_HOME` – make it point to that folder
3. update the `PATH` variable to `PATH="\$PATH:\$GRAILS_HOME/bin"`

After we’re done with the installation, navigate to the location where you want the project to be created (command prompt if you’re a windows user) and type:
`grails create-app hello`
after a few seconds, a new directory will be created by the surprising name of…
yes you guessed right: “hello” (convention over configuration anyone?)
Lets get in by typing `cd hello` and create our first controller. Can you guess the command ?
`grails create-controller hello`
if you missed this one – don’t be upset, you’ll get the next one.
One of the lines that were printed after the last command should have been:
`Created file grails-app/controllers/hello/HelloController.groovy`
Open a text-editor and edit HelloController.groovy:

```package hello
class HelloController {

def index() {
render "Hello World!"
}
}```

That’s it! now, can you guess how to run our app ? that’s right:
`grails run-app`
it starts running, looking good, it even prints:
`Server running. Browse to http://localhost:8080/hello`
which seems awesome, but before we get to copy the URL and paste it into the browser…
``` *** java.lang.instrument ASSERTION FAILED ***: "!errorOutstanding" with message transform method call failed at ../../../src/share/instrument/JPLISAgent.c line: 844 Exception in thread "main" | Error Forked Grails VM exited with error ```

Hey! that’s not a nice thing to do!
Don’t worry guys, I hear you, here’s how we can fix it:
go to: hello/grails-app/conf
and edit the file BuildConfig.groovy – comment out the following section using /* … */ like this:
``` /* grails.project.fork = [ // configure settings for compilation JVM, note that if you alter the Groovy version forked compilation is required // compile: [maxMemory: 256, minMemory: 64, debug: false, maxPerm: 256, daemon:true], // configure settings for the test-app JVM, uses the daemon by default test: [maxMemory: 768, minMemory: 64, debug: false, maxPerm: 256, daemon:true], // configure settings for the run-app JVM run: [maxMemory: 768, minMemory: 64, debug: false, maxPerm: 256, forkReserve:false], // configure settings for the run-war JVM war: [maxMemory: 768, minMemory: 64, debug: false, maxPerm: 256, forkReserve:false], // configure settings for the Console UI JVM console: [maxMemory: 768, minMemory: 64, debug: false, maxPerm: 256] ] */ ```

Now for most of the readers it should work: if you’ll `grails run-app` paste the following URL into your browser:
`http://localhost:8080/hello`
you should see the link to the controller that prints “Hello World!

But… if you’re like me… all the wrong things WILL happen: another issue I had was that port 8080 was already in use. To work around that, you can run your app on a different port:
`grails -Dserver.port=8090 run-app`

That’s it, now you should definitely see in your browser the following page: and once you’ll click the controller-link, you’ll receive a sweet “Hello World!” in Grails.

Update: there is actually an open bug for the issue described above, and a fix should be deployed on the next release (Grails 2.3.3)

A simple calculator in Ruby

Today I ran (again) into the following question:

• Write a function that doesn’t use eval that calculates input strings with operators +,-,*,/ eg. “5+5*6+4/2″ should output 37

The first time I ran into this question I designed a solution, in Java, which had a SimpleCalculator class, and `enam Operation` which supported the four basic arithmetic operations: +-*/ each of which had an `apply` method etc. Very object oriented.

When I read this question today, I figured that it would be a nice exercise to do in Ruby – a few minutes later the result spread, elegantly, over less than 20 lines of code (and I bet that a professional Rubiest can do it in less)!

```def is_number? expr
return false if expr.nil?
expr = "#{expr}"              # we need this condition in case the expr is a number
expr.match /^(\d+|\d+\.\d+)\$/ # since match() is defined only for strings
end

def calc(expr)
return expr.to_i if is_number? expr
expr.gsub!(" ","") # clean the string from whitespaces
# pay attention to the order: + and - should come before * and /
# can you figure out why ?
arr = expr.split /\+/
return arr.inject(0){|x,y| calc(x) + calc(y) } if arr.size > 1
arr = expr.split /\-/
return arr.inject(0){|x,y| calc(x) - calc(y) } if arr.size > 1
arr = expr.split /\*/
return arr.inject(1){|x,y| calc(x) * calc(y) } if arr.size > 1
arr = expr.split /\//
return arr.inject   {|x,y| calc(x) / calc(y) } if arr.size > 1
end

puts calc("5+5* 6+4/2.0")
#output 37
```

Do you have a better/shorter/more elegant solution ?