#codesignal

So about a month ago, as I was surfing Indeed, I found an interesting potential job. Handshake.ai opens up projects periodically and pays people to do piecework at some hourly rate; I was specifically looking at Project Helix, which offered $65/hour basically analyzing AI-generated code and coming up with improvements, etc.

So I signed up and took the CodeSignal test that they prescribed. I made sure to pick my time and place so there wouldn't be any interruptions, and I took a few practice tests to make sure I understood the system.

And I got no response for weeks. After a while, I saw that there was a status change on the Handshake dashboard, so it seems that the first test I took wasn't recognized or accepted. Weird. I gave up and moved on.

Within the last 2 days, I was contacted by Handshake.ai, telling me that Project Helix was "finally open" (you mean it wasn't before?) and they would dearly like me to take the CodeSignal assessment. They said I looked like a strong candidate, maybe from parsing my résumé.

So this time, I said "screw it" and took the damn test. Again. Some of the questions were the same, but the final coding question was different. And because I didn't pace myself this time, I didn't have a whole lot of time to refine my final answer. I was failing some of the hidden test cases, but I was passing the ones I could see.

Also of note, that final test question was the only actual coding problem on the entire test; just about everything else was some kind of free-form essay. This is an important detail.

Within about 5 minutes of submission, I got an e-mail with a rejection. Said I didn't pass the assessment and would not move forward.

So someone please explain to me how they were able to grade me so fast the second time around? I doubt that a human being looked at it. Either that last question counted for more than I realized, or they had a machine looking at my essay answers and "grading" them. I'm pretty sure my responses didn't completely suck.

The other thing is, the final question was a Java programming exercise, and in the instructions they tell you to take some value and compute the modulus with a large-ish value (10^9 + 7) and return that result. Well, everyone knows in Java that you compute the integer modulus using the % operator. Except that the version of modulus that the test writers expected isn't that, because the modulus operation they expected doesn't handle negative values the same as % does. This caused me a lot of grief. The specification (instructions) didn't say which kind of modulus to take, so I had to reverse engineer it from the test cases that I was actually able to see.

My suspicion is that whoever wrote this test was writing it from the standpoint of another programming language (probably Python), and just expected me to know that mathematical function instead of the way modulus is implemented in just about every C-like language out there. Yes, there's a formula for computing the mathematical modulus for negative values in languages like Java that return a negative modulus result: ((a % b) + b) % b

I certainly couldn't remember the precise formula (had to look it up just now and do the obligatory face palm – couldn't do that during the test). My point is, this is pretty misleading for a Java-language problem.

I didn't run into this problem with the last CodeSignal test, and even HackerRank doesn't pull this level of "gotcha" crap.

Question Link: groupingPipelineNodes

Solution: gist.github.com/djacales

The question has the following requirements.

Given a datapipeline in the format of:

n -> number of nodes

g -> edges between nodes, [p,c] => parent and child

v -> nodes to be merged

Validate if the resulted pipeline is a valid one, in other words, the new pipeline does not have cycles ( self-cycles excluded).

So, at first this seems to be graph problem, we can separate the tasks to solve this challenge as follows:

1.- Create a graph structure that supports merge operations between nodes.

2.- Merge the nodes, update graph

Input: lastBackupTime = 461620205

changes = [[461620203, 1],           [461620204, 2],           [461620205, 6],           [461620206, 5],           [461620207, 3],           [461620207, 5],           [461620208, 1]]

Introduction

Haskell is a pure functional programming language with a lot of great features, one of them is the simplicity that offers for handling with list manipulation.

In this example, found at code signal, given a lastBackupTime timestamp and a list of process ( each process is a list where index 0 is the timestamp of the last change to the file, and index 0 is the file id ). The program has to return a list of unique file ids for those who last modification occurs after the lastBackupTime.

Solution

import Data.List

import Data.Ord

incrementalBackups lastBackupTime changes = sort $ nub $ map ( !! 1 ) $ filter (\xs -> xs !! 0 > lastBackupTime) changes

Explanation

This problem can be divided into 4 small problems. First we need to filter those files where lastModification happen after the backup timestime.

Luckly Haskell has exaclty a filter function:

filter :: (a -> Bool) -> [a] -> [a]

The filter signature applies a comparison function to a list and for those elements where the comparison is true are part of the result.

filter (\xs -> xs !! 0 > lastBackupTime) changes

For our problem whe use a lambda function that takes the index 0, timestamp, for each element on the changes list and compares it to the lastBackupTime value.

Our next task is to select only the file 1, this can be done with the map function

map :: ( a -> a ) [a]

map applies a function to each element of a list and return a list of the same size where each element is a transformation of the element after aplying the function.

In Haskell to access elements on a list at specific index whe can use the ( list !! index) operator.

map ( !! 1 ) $ filter (\xs -> xs !! 0 > lastBackupTime) changes

f $ g is equivalent to f ( g ())

Good to notice here is the $ operator what this does is explicit indicates to the Haskell compiler than whe apply the map function after we apply the filter to our changes list.

After applying the map function we need to select only unique file ids,

The Data.List module has a nub function that does this.

After removing duplicates the last thing to do is to sort the file ids.

For this we can use the sort function available at the Data.Ord module.

“Our core strength and the tech we built is the ability to assess technical ability and to do it as scale,” CodeSignal CEO Tigran Sloyan told me. “The crown jewel of that is the Coding Score. The Coding Score is our equivalent of a credit score for developers because you need an easy way for the industry to agree on a standard for skills.”

I’m not sure everybody will agree with his assessment, but Sloyan is right that today’s methods of rating a developer’s skill based on what school somebody went to, resumes, GitHub projects, and coding interviews doesn’t present a full picture of an applicant’s abilities. He also notes that this process where the actual hiring decision is often based on the preferences of only a few people can lead to biased decisions. The Coding Score, Sloyan argues, takes away many of these biases and purely focuses on an applicant’s abilities.

How does CodeSignal calculate this score? Sloyan tells me that a developer only has to solve three challenges on the site to get a score — and that first score is accurate to about 85 percent. As developers solve more challenges, the service starts refining the score. Developers are ranked based on their speed and accuracy (which are weighted according to the difficulty of the challenge), and how they solve those problems. CodeSignal benchmarks developers against each others. To do all of this this, the team trained a machine learning model on the vast trove of data the company has collected since it launched its first coding challenges in 2014.

CodeSignal started pitching the Coding Score to recruiters at major tech firms over the course of the last few months. Sloyan admitted that it took a while before these recruiters trusted these scores, but today a number of these companies use the scores to bypass phone interviews and move right to in-person interviews for some candidates.

Developers, it’s worth noting, can choose to share their scores publicly or keep the private until their want to share them with recruiters.

Looking ahead, CodeSignal wants the Coding Score to become the de facto standard in the developer hiring market. While this model is surely applicable to other fields, Sloyan noted that CodeSignal isn’t all that interested in branching out right now, but he left the door open for adding scores for other technical fields as well. “I do believe the model scales,” he told me. “What you need is a platform for people to practice and learn a certain skill. That platform needs to have an automatic assessment engine behind it.” And with enough data from that, it can then analyze those scores and calculate a score.

Bonus: To launch the new scoring system, CodeSignal calculated and ranked the average scores of users from a number of companies and colleges.