My First Technical Interview Ever
POSITION: Software Engineer Intern @ LinkedIn
This is a snippet from a blog post I wrote on December 11, 2017 while applying for summer internships during my junior year of college.
I just finished my first technical phone interview in my life. Before I go into the specifics, I’ll talk about how I heard of the internship in the first place.
Recently, I attended an event in Downtown LA called Accelerate U. The entire event was a learning day for students consisting of workshops, activities, and opportunities to network with LinkedIn employees. In the event, I learned how to effectively build my personal brand, network confidently, maximize interview success, and accelerate towards the career of my dreams.
Through Accelerate U, I made a plethora of new connections. In particular, I befriended a sophomore from UCLA studying computer science and a business major from Cal State Fullerton. I definitely learned a lot, and I was truly inspired by all the ambitious students around me. After an entire day of networking, presentations, and a technical breakout session, we were told that LinkedIn would open a software engineer intern position exclusively for students at the Accelerate U event.
A few days after I applied, I was contacted by a recruiter to set up a phone interview. The interview went super well! The recruiter started off by asking me why I was applying to LinkedIn. She also asked me to describe several of my personal projects and whether or not I had any previous technical internships. And finally, we talked about the work culture at LinkedIn and what types of projects were going on. At the end of the conversation, she let me know that I would be moving onto the technical phone interview.
That brings us to today. The technical phone interview lasted one hour, and I talked with a software engineer who worked primarily on the backend technologies and infrastructure of LinkedIn. More specifically, he mentioned that he worked on the analytics team and used Apache Hadoop to process data and construct data pipelines.
Overall, I felt that my performance on the interview was mediocre. I struggled to answer the technical question, and I spent the entire hour trying to come up with a solution. I vocalized my thought process, and I even asked for hints several times. In the end, I managed to write a partial but still incomplete solution (basically a helper method).
The problem was stated as follows:
Given a nested list of integers, return the sum of all integers in the list weighted by their depth. For example, given the list {{1, 1}, 2, {1, 1}} the function should return 10 (four 1’s at depth 2, one 2 at depth 1). Given the list {1, {4, {6}}} the function should return 27 (one 1 at depth 1, one 4 at depth 2, and one 6 at depth 3).
I was also given some partially written code to begin with:
public int depthSum (List<NestedInteger> input) {
// Implement method here
}/**
* This is the interface that represents nested lists.
* You should not implement it, or speculate about its implementation.
*/
public interface NestedInteger {
/** @return true if this NestedInteger holds a single integer,
rather than a nested list */
boolean isInteger(); /** @return the single integer that this NestedInteger holds,
if it holds a single integer
* Return null if this NestedInteger holds a nested list *
Integer getInteger(); /** @return the nested list that this NestedInteger holds, if
it holds a nested list
* Return null if this NestedInteger holds a single integer */
List<NestedInteger> getList();
}
I started off by mentioning that the most elegant approach to solving the problem would most likely include recursion, and he agreed. Despite this, I struggled to figure out how to keep track of the depth for each element. After bouncing many ideas off the interviewer and stumbling around in my own code, I asked him for some guidance. He recommended that I start by trying to implement a method that finds the maximum depth of the given list, and I managed to write this:
public int getMaxDepth(List<NestedInteger> input) {
int[] depths = new int[input.size()];
for (int i = 0; i < input.size(); i++) {
int depth = 1;
if (!input.isInteger()) {
List<NestedInteger> nestedList = input.get(i);
depth = 1 + getMaxDepth(nestedList);
}
depths[i] = depth;
} // Find max depth
int max = depths[0];
for (int i = 1; i < depths.length; i++) {
if (depths[i] > max) {
max = depths[i];
}
}
return max;
}
Although the problem seemed relatively easy and straightforward, I was thrown off by the recursive aspect of the problem. I’m not too surprised since the concept of recursion can be quite difficult for programmers to wrap their heads around. Ultimately, I definitely felt pressured and nervous going into the interview, and I think this significantly influenced my performance.
If I could go through the same exact interview again, I would definitely take more time to bounce my ideas off the interviewer and form a coherent plan before I start coding. I would also ask more clarifying questions.
In the end, I definitely learned a lot from this technical interview. LinkedIn is a well-reputed company to work for, and I’m glad I had the opportunity to attend Accelerate U and go through two rounds of phone interviews. I’m still waiting for my decision that will determine whether I move onto the in-person interviews, so I just wanted to write a quick review/recap of everything that has happened to this point. Cheers!
Update: I didn’t pass the technical phone interview and move onto on-sites, but I learned a lot from the experience!
