DevBlog – JoseTomasTocino.com

Horizontal messaging bus using postal.js

I just came across this series of posts about JavaScript, and they’re great! They cover the most recent technologies in the front-end scene nowadays. Among them, there was a concept that I had never heard of before: mediated events. When you use (for instance) jQuery’s on, you’re saying that whenever an event is triggered by an element, a callback must be launched.

With mediated events, you don’t have that tight coupling. Instead, elements (and any other kind of event publisher) publishes events about a certain topic on a certain channel with some attached data. Then, some other objects subscribe callbacks to those channels and topics. You could have different channels and, within those, different topics.

In this example, I’m going to use postal.js, one of the most popular libraries for this kind of tasks. I’ve set up a MeteoGuy who publishes reports on the status of the wind and rain. Also, I’ve set up two listeners who are subscribed to wind and rain-related events respectivelly. As you can see, the listeners are not subscribed to TheMeteoGuy directly, but to TheWeatherChannel.

var TheMeteoGuy = {
    report : function (concept, newStatus) {
        postal.publish({
            channel : 'TheWeatherChannel',
            topic : concept + "." + newStatus,
            data : {
                status : newStatus
            }
        });
    },

    reportSunnyDay : function () {
        this.report('Wind', 'stops');
        this.report('Rain', 'stops');
    }
};

var WindEventListener = postal.subscribe({
    channel : "TheWeatherChannel",
    topic : "Wind.*",
    callback : function (data, envelope){
        console.log('Something happened with the wind! It ' + data.status);
    }
});

var RainEventListener = postal.subscribe({
    channel : "TheWeatherChannel",
    topic : "Rain.*",
    callback : function (data, envelope){
        console.log('Something happened with the rain! It ' + data.status);
    }
});

TheMeteoGuy.report('Wind', 'improves');
TheMeteoGuy.report('Rain', 'worsens');
TheMeteoGuy.reportSunnyDay();

var TheMeteoGuy = {

report : function (concept, newStatus) {

postal.publish({

channel : 'TheWeatherChannel',

topic : concept + "." + newStatus,

data : {

status : newStatus

}

});

reportSunnyDay : function () {

this.report('Wind', 'stops');

this.report('Rain', 'stops');

}

};

var WindEventListener = postal.subscribe({

channel : "TheWeatherChannel",

topic : "Wind.*",

callback : function (data, envelope){

console.log('Something happened with the wind! It ' + data.status);

}

});

var RainEventListener = postal.subscribe({

channel : "TheWeatherChannel",

topic : "Rain.*",

callback : function (data, envelope){

console.log('Something happened with the rain! It ' + data.status);

}

});

TheMeteoGuy.report('Wind', 'improves');

TheMeteoGuy.report('Rain', 'worsens');

TheMeteoGuy.reportSunnyDay();

To better see the power of these kind of messages you could, for instance, add a NewspaperWeatherSection that would publish to the same TheWeatherChannel, and the listeners would receive the messages as well.

var NewspaperWeatherSection = {
    reportSomething : function () {
        var concept = ['Wind', 'Rain'][_.random(0,1)];
        var status = ['improves', 'worsens', 'stays'][_.random(0,2)];

        postal.publish({
            channel : 'TheWeatherChannel',
            topic : concept + "." + status,
            data : {
                "status" : status
            }
        });
    }
};

NewspaperWeatherSection.reportSomething();

var NewspaperWeatherSection = {

reportSomething : function () {

var concept = ['Wind', 'Rain'][_.random(0,1)];

var status = ['improves', 'worsens', 'stays'][_.random(0,2)];

postal.publish({

channel : 'TheWeatherChannel',

topic : concept + "." + status,

data : {

"status" : status

}

});

}

};

NewspaperWeatherSection.reportSomething();

As you can see, the posibliities behind this are endless. However, here’s a word of caution. If you abuse this, you’ll end up with a lot of messages being sent from everwhere, and no easy way of tracking them.

Bookmarklet to open 500px images on a new tab

Whenever you try to right-click an image in 500px, you’ll get a warning message saying that the picture is copyrighted and stuff. You can’t therefore save the image because the context menu does not appear. However, there’s an easy fix for this. The image is contained in a div with the id thephoto, so you can easily get the images’s source path and open it in a new window or tab using the following javascript snippet:

(function() { window.open(document.querySelector('#thephoto img').src, '_blank');})();

1	(function() { window.open(document.querySelector('#thephoto img').src, '_blank');})();

To use it, just drag and drop this link: 500px Isolate Image to your bookmarks toolbar. Then, whenever you’re surfing 500px and want to download an image, click the bookmarklet and you’ll see a new window with the image for you to download.

FB Hacker Cup – Qualification Round

Last weekend, Facebook launched the qualification round of their Hacker cup, an annual worldwide programming competition. The way this competition works is pretty similar to that of other programming contests out there: a series of programming problems are presented, each of which has a sample input and a sample output along with a (sometimes minimal) explanation of the problem. Once you’ve programmed a solution using the sample input and output, you request the test input. That’s the real deal. Usually test inputs pose corner cases where you’re algorithm will likely have a bad time if it’s not properly thought out. The last step is to send the output for the test input along with the source code of your solution.

The qualification round presented three problems. Solving any of them qualifies you to compete in round 1. Here’s my take on each of them.

Beautiful strings

For the first problem (click here to see the full formulation) you had to calculate the grade of beautifulness of a set of strings. Each letter is assigned an unknown value (from 1 to 26), and the score for the string is the sum of the values of all the letters, ignoring punctuation and case. After looking at the sample cases I realized that the letters had their score assigned depending on the repetitions of each letter within the string, so the letter that appeared more often had a value of 26, the next more common had a value of 25 and so on.

Therefore, it was a matter of filtering the string, counting the appearances of each letter and calculating the total value. Here’s my take in Python:

import sys

def main():
    # Read the number of cases
    numCases = int(sys.stdin.readline())

    # Generate all valid letters
    # This could have been replaced by string.ascii_lowercase
    letters = map(chr, range(97, 123));

    # Loop over the cases
    for i in xrange(numCases):

        # Filter the string
        line = [x for x in sys.stdin.readline().strip().lower() if x in letters]

        # Count the repetitions of each letter, sorting in descending order
        # This could have been replaced by a collections.Counter object, but I didn't know it at that time
        letterRepetitions = sorted([ line.count(letter) for letter in set(line)], reverse=True)

        # Make up the total count
        totalCount = 0

        for ind, val in enumerate(letterRepetitions):
            totalCount += val * (26 - ind)

        print 'Case #%i: %i' % (i+1, totalCount)

if __name__ == '__main__':
    main()

import sys

def main():

# Read the number of cases

numCases = int(sys.stdin.readline())

# Generate all valid letters

# This could have been replaced by string.ascii_lowercase

letters = map(chr, range(97, 123));

# Loop over the cases

for i in xrange(numCases):

# Filter the string

line = [x for x in sys.stdin.readline().strip().lower() if x in letters]

# Count the repetitions of each letter, sorting in descending order

# This could have been replaced by a collections.Counter object, but I didn't know it at that time

letterRepetitions = sorted([ line.count(letter) for letter in set(line)], reverse=True)

# Make up the total count

totalCount = 0

for ind, val in enumerate(letterRepetitions):

totalCount += val * (26 - ind)

print 'Case #%i: %i' % (i+1, totalCount)

if __name__ == '__main__':

main()

After sending it I started to think about minifying my solution… and it came down to ONE SINGLE LINE, take a look:

import sys, string
from collections import Counter

print '\n'.join(['Case #%i: %i' % (i, reduce(lambda y, x: x[0] * x[1] + y, zip(reversed(range(27)), sorted(Counter(filter(lambda x: x in string.ascii_lowercase, cadena.lower())).values(), reverse=True)), 0)) for i,cadena in enumerate(sys.stdin.readlines()) if i != 0])

import sys, string

from collections import Counter

print '\n'.join(['Case #%i: %i' % (i, reduce(lambda y, x: x[0] * x[1] + y, zip(reversed(range(27)), sorted(Counter(filter(lambda x: x in string.ascii_lowercase, cadena.lower())).values(), reverse=True)), 0)) for i,cadena in enumerate(sys.stdin.readlines()) if i != 0])

Balanced smileys

The second problem was about balancing parentheses according to some rules about valid strings. Pretty easy stuff using recursion and regular expressions:

import sys, pprint, re

def isBalanced (s):

    # Base case
    if s == '':
        return True

    # Smiley face
    if re.match(r'^\:[\(\)]', s):
        subS = s[2:]
        return isBalanced(subS)

    # Word
    m = re.match(r'^[a-z\: ]',s)
    if m:
        subS = s[len(m.group(0)):]
        return isBalanced(subS)

    # Balanced message within parentheses
    m = re.match(r'^\((.*?)\)',s)
    if m:
        firstSubString = m.group(1)
        secondSubString = s[len(m.group(0)):]
        return isBalanced(firstSubString) and isBalanced(secondSubString)

    return False

def main():
    numCases = int(sys.stdin.readline())

    for i in xrange(numCases):
        currentString = sys.stdin.readline().strip()
        print 'Case #%i: %s' % (i + 1, isBalanced(currentString) and 'YES' or 'NO')

if __name__ == '__main__':
    main()

import sys, pprint, re

def isBalanced (s):

# Base case

if s == '':

return True

# Smiley face

if re.match(r'^\:[\(\)]', s):

subS = s[2:]

return isBalanced(subS)

# Word

m = re.match(r'^[a-z\: ]',s)

if m:

subS = s[len(m.group(0)):]

return isBalanced(subS)

# Balanced message within parentheses

m = re.match(r'^\((.*?)\)',s)

if m:

firstSubString = m.group(1)

secondSubString = s[len(m.group(0)):]

return isBalanced(firstSubString) and isBalanced(secondSubString)

return False

def main():

numCases = int(sys.stdin.readline())

for i in xrange(numCases):

currentString = sys.stdin.readline().strip()

print 'Case #%i: %s' % (i + 1, isBalanced(currentString) and 'YES' or 'NO')

if __name__ == '__main__':

main()

Find the min

The last problem was obviously the hardest. You’re better off reading the original formulation here. I didn’t give much thought to it and the implementation was sub-par, so I could not provide the output for the test input within the given time frame (6 minutes). The values for the k elements repeated after some period, which I could not find out. I’ve posted a question in math.stackexchange to see if they can shed some light on the subject.

Anyways, here’s my brute-force algorithm for the last question:

import sys, pprint, re
from collections import deque
from math import pow

def getMinimumNotContainedIn(l):
    for i in range(max(l) + 2):
        if i not in l:
            return i

def solveCase(n, k, a, b, c, r):

    print 'n: %i, k: %i, a: %i, b: %i, c: %i, r: %i' % (n,k,a,b,c,r)

    # Generating function
    genfun = lambda m1: (b * m1 + c) % r

    # We only keep the last k elements
    m = deque(maxlen = k)
    prev = a
    for i in xrange(1,n):
        if i < k:
            v = genfun(prev)
            prev = v
        else:
            break
            v = getMinimumNotContainedIn(m)

        m.append(v)

    return m.pop()

def main():
    numCases = int(sys.stdin.readline())

    for i in xrange(numCases):

        n,k = map(int, filter(None,sys.stdin.readline().strip().split()))
        a,b,c,r = map(int, filter(None,sys.stdin.readline().strip().split()))

        print 'Case #%i: %s' % (i + 1, solveCase(n, k, a, b, c, r))

if __name__ == '__main__':
    main()

import sys, pprint, re

from collections import deque

from math import pow

def getMinimumNotContainedIn(l):

for i in range(max(l) + 2):

if i not in l:

return i

def solveCase(n, k, a, b, c, r):

print 'n: %i, k: %i, a: %i, b: %i, c: %i, r: %i' % (n,k,a,b,c,r)

# Generating function

genfun = lambda m1: (b * m1 + c) % r

# We only keep the last k elements

m = deque(maxlen = k)

prev = a

for i in xrange(1,n):

if i < k:

v = genfun(prev)

prev = v

else:

break

v = getMinimumNotContainedIn(m)

m.append(v)

return m.pop()

def main():

numCases = int(sys.stdin.readline())

for i in xrange(numCases):

n,k = map(int, filter(None,sys.stdin.readline().strip().split()))

a,b,c,r = map(int, filter(None,sys.stdin.readline().strip().split()))

print 'Case #%i: %s' % (i + 1, solveCase(n, k, a, b, c, r))

if __name__ == '__main__':

main()

I’m looking forward to seeing the problems in the next round!