Forem: elisabethgross

A unique JavaScript interview challenge

elisabethgross — Thu, 27 Feb 2020 05:01:25 +0000

What’s up team?! Welcome back to Code Review, a series of coding interview challenges and career related content released weekly exclusively on Dev.to. I’m Elisabeth Gross and you might know me from the work I do on Coderbyte, a site dedicated to helping developers of any level get their next engineering job. Or, you may have heard of me via Breadwinnerss, a tool that helps users request intros for whichever roles they're interested in across dozens of companies.

The best part about writing this series is getting to know you all as a community of driven and excited developers, passionate about leveling up their coding skills. If you want more tips and tricks along with some developer lifestyle content, give me a follow on Instagram @elisabethgross568. I’ll be posting about what coffee shops I love to work at in NYC, some of my favorite playlists to listen to while coding and more! I can’t wait to engage with you all more. Alright, enough chit chat - let’s jump into the solution for last week’s challenge.

The solution

This solution finds how much volume of water can exist in a horizontal plane and then sums each layer to get the total volume. At each horizontal level, we can find the peaks, or the bounds where water can exist between, and subtract the indices of each peak to get the space between them where water can collect. This might be easier to visualize with some code!

Pro Tip

This problem is a GREAT opportunity to build some helper functions. Often, when solving an algorithm challenge where a lot is going on, it is helpful to start with the more general concepts, stubbing in helper functions that you can work on as the interview goes on. This communicates two things to your interviewer. First, you understand the larger concept of the problem and can build a mini roadmap for yourself made up of the smaller building blocks of the puzzle that will ultimately become your algorithm. And second, you don’t get bogged down with the details. Too often when I am interviewing someone, they get caught up in a small part of the algorithm early on and we never make it to the real meat of the algorithm. Stubbing in helper functions allows you to focus on the basic structure right off the bat, and then gives you opportunity to fill in those helper functions with the time you have left.


function totalWaterVolume(arr) {

    // first, we find the 'maxHeight’ which is the highest peak in the water collector
    const maxHeight = Math.max(...arr)

    let totalVolume = 0

    // this loop starts at the maxHeight then decrements the height
    for (let horizontalLevel = maxHeight; horizontalLevel > 0; horizontalLevel--) {

        // 'peaksAtHorizontalLevel' is set to the return value of our first helper function 'peakIndicesMaker' which will be an array of indices of rain collector walls that exist at that level
        var peaksAtHeightLevel = peakIndicesMaker(arr, horizontalLevel)

        // 'vol' is then incremented by the volume that exists at that level, returned from our second helper function 'volAtLevel'
        totalVolume += volAtLevel(peaksAtHeightLevel)
    }

    // total volume is returned
    return totalVolume
}

Let’s take a look at an example to help illustrate what we have so far.

Given the array [0, 3, 0, 1, 0, 0, 0, 1, 0, 2], our rainwater collector will look like this-

First we get the maxHeight which will be 3 in our example. We’ll start looping through each horizontal level beginning with 3.

Let’s start to build out the peakIndicesMaker function! Remember, this function should return the peaks at each horizontal layer of the rain catcher.

/* This function takes the original array, as well as the height level we are looking at, and returns an array of indices where reservoir walls exist */
function peakIndicesMaker(arr, level) {

    const peakIndices = []

    // loop over the entire array
    for (let i = 0; i < arr.length; i++) {

        // if the wall height present at each index is at least the height of the given level then that index is pushed to the output array
        if(arr[i] >= level) {
            peakIndices.push(i)
        }
    }

    // array of indices is returned
    return peakIndices
}

For our example, level 3 will return [1] (just one peak at index 1), level 2 will return [1, 9] (two peaks at index 1 and 9) and level 1 will return [1, 3, 7, 9] (four peaks at index 1, 3, 7, and 9).

Getting the indices of the peaks at each level will allow us to find the space between them which will ultimately give us the volume of water that will collect there! Let’s look at how that will look in code.

/* The distance between the two walls at the same height will also be the volume of water held between them. */
function volAtLevel(peakIndices) {

    let levelVol = 0

    // if there is only one wall at the height currently being calculated, there cannot physically be any water at that level. In this case, we return 0 volume.
    if (peakIndices.length === 1) {
        return 0
    } else {

        // levelVol is incremented for each 'pair' of walls at that level. It is important to note that we are comparing each wall to its adjacent neighbor located at the next index in the array. Therefore the last element in the array could not possibly hold water to its right.  This is because no wall exists at that level beyond the last wall
        for (let i = 0; i < peakIndices.length-1; i++) {

            // Measure the right side of one wall (this is why we look at peakIndices[i] + 1 and not just peakIndices[i]) to the left side of its neighbor
            levelVol += (peakIndices[i + 1] - (peakIndices[i] + 1))

        }
    }

    // the level volume is then returned after all pairs have been summed.
    return levelVol
}

For our example, at the first horizontal level (height = 3), we return 0 because there is only one peak index.

For the next level (height = 2), we have two peaks [1, 9]. We subtract 2 (the index of the first peak plus 1) from 9 (the index of the second peak) and get 7.

For the next level (height = 1), we have 4 peaks [1, 3, 7, 9]. We subtract 2 (the index of the first peak plus 1) from 3 (the index of the second peak) and get 1. We then subtract 4 (the index of the second peak plus 1) from 7 (the index of the third peak) and get 3. And finally we subtract 8 (the index of the third peak plus 1) from 9 (the index of the fourth peak) and get 1.

The total volume will be the sum of all the volumes at each layer which in this case will be 12. And that’s it! Hope you enjoyed this problem as much as I did :) See you next week!

A fun JavaScript interview challenge

elisabethgross — Thu, 20 Feb 2020 04:48:51 +0000

My favorite part about writing this series is getting to know you all as a community of driven and excited developers, passionate about leveling up their coding skills. If you want more tips and tricks along with some developer lifestyle content, give me a follow on Instagram @elisabethgross568. I’ll be posting about what coffee shops I love to work at in NYC, some of my favorite playlists to listen to while coding and lot of other fun stuff! I can’t wait to engage with you all more. Alright, enough chit chat - lets jump into the solution for last week’s challenge.

The solution

This solution leverages the fact that anagrams will all have the same letter frequency as each other albeit in a different order. We can use an object to store what letters are in each string and how often they appear. If both strings have the same letter frequency - we have an anagram! Here’s what that looks like in code:

function anagram(str1, str2) {
  // replace all whitespace characters
  const arr1 = str1.toLowerCase().replace(/\s+/g, '').split('')
  const arr2 = str2.toLowerCase().replace(/\s+/g, '').split('')

  const obj = {}
  arr1.forEach(letter => {
    if (!obj[letter]) obj[letter] = 0
    obj[letter]++
  })
  arr2.forEach(letter => {
    if (!obj[letter]) return false
    else obj[letter]--
  })
  for (var letter in obj) {
    if (obj[letter] !== 0) return false
  }
  return true
}

Time complexity

This solution has a time complexity of O(n) because we only have to go through each string one time to build the objects that track the letter frequency. Often you can use objects to keep track of something as a great way to reduce the time complexity of an algorithm. Using objects is cheap because getting and setting keys and values has a time complexity of O(1).

This week’s challenge

You are a programmer that has decided to move out of the city and into the forest for some much needed peace and quiet. You normally get your water from a local well, but it seems to have gone dry. You’ve decided to collect rain water to filter, however, your collection device isn’t flat. Write an algorithm to determine how much rain you can possibly collect at once given n non-negative integers representing an elevation map where the width of each bar is 1.

Example: Given [0,3,0,1,0,0,0,1,0,2] return 12

This can be visualized as follows:

Enjoy!

Our newsletter 📫

We send out a small, feature reveal snippet every time we release something big, so our community is the first to know when we break out something new. Give us your email here and we'll add you to our "first to know" list :)

Exclusive Coderbyte promo

And, as a thank you to our awesome Dev.to community, we'd love to extend a special promo to our readers. Check out this secret checkout page for 30% off our subscriptions and one-time payments.

A classic interview question

elisabethgross — Wed, 05 Feb 2020 17:10:56 +0000

Hey everyone! Welcome back to Code Review, a series of coding interview challenges and career related content released weekly exclusively on Dev.to. I’m Elisabeth Gross and you might know me from the work I do on Coderbyte.com, a site dedicated to helping developers of any level get their next engineering job. Or, you may have heard of me via Breadwinnerss, a tool that helps users request intros for whichever roles they're interested in across dozens of companies. You might just be part of this awesome Dev.to community of passionate coders. Regardless of where you came from, welcome! If you like content like this - be sure to sign up for our newsletter here. Stand up’s over - lets get into the article!

The challenge

Given two strings, return true if they are anagrams of each other. Remember, an anagram is a word, phrase, or name formed by rearranging the letters of another, such as cinema, formed from iceman.

The less optimal approach

The sort function

This solution takes advantage of the built in sort function that comes with the javascript language. Many languages have a sort function but it’s important to know what the sort implementation is under the hood, especially when it comes to the overall time complexity of your algorithm. The V8 engine (the engine that powers the javascript that runs in the Chrome browser and Node.js) implements array sort using the MergeSort algorithm and has a time complexity of O(nlog(n)). It’s really important to demonstrate to your interviewer that you understand that using a built in method isn’t “free”, it’s just someone else’s code :)

The solution

Once you sort the strings, you can just compare them! If they are equal, they are anagrams. If they aren’t, return false. This is relatively straightforward in code.

function anagram(str1, str2) {

  // replace all whitespace in string, split into arrays, sort and rejoin as strings
  sorted1 = str1.toLowerCase().replace(/\s+/g, '').split('').sort().join()
  sorted2 = str2.toLowerCase().replace(/\s+/g, '').split('').sort().join()

  return sorted1 === sorted2
}

Try and come up with a more optimal solution for next week. Happy coding!

A JavaScript interview question asked at Google

elisabethgross — Wed, 29 Jan 2020 20:40:15 +0000

Hello and welcome back to Code Review, a series of coding interview challenges and career related content released weekly exclusively on Dev.to. I’m Elisabeth and I’ve been a software engineer for about 4+ years now. I’m passionate about sharing my knowledge, and best tips and tricks when it comes to acing that interview and or just leveling up your coding skills. If you want more content and challenges like these, subscribe to the Coderbyte newsletter here. That’s it for stand up - let’s get to challenge solving!

The Challenge

Write a class, EventEmitter that has three methods: on, emit, and removeListener.

on("eventName", callbackFn) - a function that takes an eventName and a callbackFn, should save the callbackFn to be called when the event with eventName is emitted.
emit("eventName", data) - a function that takes an eventName and data object, should call the callbackFns associated with that event and pass them the data object.
removeListener("eventName", callbackFn) - a function that takes eventName and callbackFn, should remove that callbackFn from the event.

For example:


let superbowl = new EventEmitter()

const cheer = function (eventData) {
  console.log('RAAAAAHHHH!!!! Go ' + eventData.scoringTeam)
}

const jeer = function (eventData) {
  console.log('BOOOOOO ' + eventData.scoringTeam)
}

superbowl.on('touchdown', cheer)
superbowl.on('touchdown', jeer)

superbowl.emit('touchdown', { scoringTeam: 'Patriots' }) // Both cheer and jeer should have been called with data

superbowl.removeListener('touchdown', jeer)

superbowl.emit('touchdown', { scoringTeam: 'Seahawks' }); // Only cheer should have been called

The solution:

This is a great opportunity to use ES6 classes. In case you haven’t used them before, check out their syntax here. We can start with a basic structure for the class EventEmitter and initialize it with an object events that we will use to track our events.

class EventEmitter {
  constructor () {
    this.events = {}
  }
}

On

Next we can start working on our methods. First up is on. Here is the code for that:

on (eventName, callbackFn) {
  if (!this.events[eventName])  {
    this.events[eventName] = []
  }
  this.events[eventName].push(callbackFn)
}

Because functions are first class objects in javascript, which basically means they can be stored in a variable, an object, or an array, we can just push the callback function to an array stored at the key eventName in our events object.

Emit

Now, for our emit function.

  emit (eventName, eventData) {
    if (!this.events[eventName]) return
    this.events[eventName].forEach(fn => fn(eventData))  
  }

This solution takes advantage of what is called closure in javascript. If you are coding in Javascript in your interview, understanding closure can be vital. A closure is essentially when a function has references to its surrounding state or its lexical environment. You can also think of this as a closure allowing you access to an outer function’s scope from inside an inner function. Using global variables is a great simple example of closure.

Here’s another great example of using closure to track how many times a function was called.

function tracker (fn) {
  let numTimesCalled = 0
  return function () {
    numTimesCalled++
    console.log('I was called', numTimesCalled)
    return fn()
  }
}

function hello () {
  console.log('hello')
}

const trackedHello = tracker(hello)

The inner function returned in tracker closes over the variable numTimesCalled and maintains a reference to it for the life of the trackedHello function. Cool stuff huh??

RemoveListener

The removeListener method is probably the easiest of the three. Here is a solution -

removeListener (eventName, callbackFn) {
  const idx = this.events[eventName].indexOf(callbackFn)
  if (idx === -1) return
  this.events[eventName].splice(idx, 1)
}

And that’s the class! Pun intended :) Seeing if you can implement methods that are part of the language is a great way to practice for interviews. See you all next week!

How to build a side project that will impress future employers

elisabethgross — Tue, 21 Jan 2020 04:01:11 +0000

Hey everyone! Welcome to a special edition of Code Review, our weekly series of coding challenges and job related content. In this post, I’ll be talking about one of my favorite side projects, Breadwinnerss, and how you can impress future employers by flexing your coding and problem-solving skills! I’ll go over what makes for a great side project and how to talk about your projects on your resume and in interviews.

Remember, if you like this content and want more of it, subscribe to our newsletter here to receive the latest and greatest we are putting out on Dev.to and on Coderbyte.

Finding awesome project ideas

From a technical perspective, a good project idea is perhaps the least important part of any good side project. But, trust me, a compelling project that solves a real problem is way more impressive to an interviewer than another 'alarm clock app.' So how do you find awesome project ideas?

You might have your own, but since you're a developer, the odds are you know someone is good at identifying cool problems to solve. Personally, I connected with the founder of the first company I worked at Nis Frome. Entrepreneurs have a track record for problem solving and I've found that they usually have a backlog of ideas, big and small. You probably know more than a few who would love to partner.

Nis had a number of projects he wanted to work on, but one in particular required some cutting-edge tech, which made it attractive to me. Today, the project is called Breadwinnerss and it solves a problem that Nis is very passionate about: helping people in his network find jobs at companies in his network.

Every week Nis gets 5-6 requests from job seekers asking for introductions to companies he has contacts at. Before Breadwinnerss, Nis would spend time browsing career pages from companies in his network to make matches and intros. Breadwinnerss was born to help alleviate some of that manual work. We essentially built a massive web scraper that scrapes career pages and aggregates the jobs into one live feed (kind of like an rss feed… get it? Breadwinnerss?). That way, when someone asks Nis for an intro, he can just send them a single link to his Breadwinnerss feed where the user can request intros for whichever roles they're interested in across dozens of companies. Already, Nis and our other users have helped several people get really cool new jobs.

Flexing your dev skills

The main goal for this side project was to learn, so I specifically picked technologies that I hadn’t done much work with before. This is an excellent talking point in an interview. It’s an opportunity to show your interviewer exactly what you can do when faced with new or unfamiliar technologies which is essentially what will happen at almost every new job you ever take.

That being said, you don’t have to reinvent the wheel. For Breadwinnerss, I chose full stack Javascript because that is something I am comfortable with, but I chose almost all new frameworks and tools to go with it. I used Node and scraping libraries called Cheerio and Puppeteer to build the scraper. I deployed that to a Google Cloud function which runs daily. The scraper script itself scrapes each company’s career page with a custom scraper function I built and saves all those results to a file in an AWS S3 bucket. The web application part of Breadwinnerss is also built using Node, with express as the routing framework and Postgres as the database. The front end was built using Vue.js. The web app reads the scraped jobs from s3 and serves them to the front end. It lives on Heroku.

  filterDepts (data, $) {
    // needed to capture the class instance (at this point the 'this' context) which becomes the document in the cheerio callbacks 'this' context
    const that = this
    const filteredDepts = data.filter(function () {
      const dept = $(this).closest('.ptor-jobs-list__department-section').find('h2').text()
      return utils.myFilter(that.targetDepts, that.badDepts, dept)
    })
    const ret = []
    filteredDepts.each(function () {
      const jobTitle = $(this).find('a').text()
      const url = $(this).find('a').attr('href')
      const location = $(this).find('.ptor-jobs-list__item-location').text()
      ret.push({
        jobTitle,
        location,
        url
      })
    })
    return ret
  }
  filterJobs (jobs) {
    return _.filter(jobs, (job) => _.includes(usCities, job.location))
  }

Emphasize technical challenges and solutions

To a large extent, tech interviews are basically one big simulated problem-solving exercise. Can you troubleshoot? Can you learn quickly? Can you jump into a fluid environment and adapt? It's important to emphasize how you solved technical problems while building your project – it'll alleviate a lot of pressure during the interview.

One of the biggest changes we made to the architecture of the app was changing how and when the actual scraping happened. When we started, the initial proof of concept was just for Nis and scraping the 8-10 companies from his network. Naturally, I just scraped every company on page load of Nis’ Breadwinnerss feed. The scraper was coupled with the web application code and would get the latest list of jobs every time someone visited the feed. This actually worked for us for quite a while and doing that as our MVP allowed us to release an early working version. Some people might think that learning 5 things at once and perfecting the tech stack before release will look very impressive, but more often than not, it just prevents you from ever releasing it.

That was fine until we got to scraping about 20 companies. At that point, the request for scraped jobs was taking longer than the maximum Heroku will allow a request to last (about 30 seconds). This was when we decided to cache the results of each scrape in a file in an S3 bucket. We also moved the scraper code to be in a self contained module that we deployed to Google cloud functions to be run on a daily cron. All this allowed for feeds that load quickly and the ~100 companies we now include in our scrape every evening.

async function processCompanies (browser, companies) {

  const processedCompanies = []
  for (const connectorCompany of companies) {
    const { target_jobs, bad_jobs, target_depts, bad_depts, module_name, scrape_url, base_url, companies_name, company_url, type } = connectorCompany
    console.log(`Scraping ${module_name}...`)
    const companyModule = require(`./companies/${module_name}.js`)
    const connectorCompanyModule = new companyModule(target_jobs, bad_jobs, target_depts, bad_depts, scrape_url, base_url, companies_name, company_url, type)
    const result = await scrape(connectorCompanyModule, browser)
    processedCompanies.push(result)
  }
  return processedCompanies
}

Showcase projects on your resume

Most developers already put their GitHub profiles on their resume. If your project is in a public repo, savvy recruiters may check it out. But that's basically burying something that gives you a significant edge.

I'd recommend instead creating a dedicated section to call out your project, any cutting-edge tech used to build it, and any market traction or validation you have such as number of users or even revenue.

Main takeaways

In summary, here are 4 of my main tips when it comes to building a side project:

Find and solve a compelling problem.
Use the project as an opportunity to mess around with new technologies.
Iterate! Build a quick prototype in less than a month and then improve it based on user feedback.
Collaborate with friends who you wouldn't normally get to work with. Side projects don't have to be lonely!

Check out the code on github!

We felt it was important to make the code public so other people can learn from how we built this project. Go check it out on github and let us know what you think.

Mastering recursion

elisabethgross — Tue, 14 Jan 2020 02:02:43 +0000

Welcome back to another week in Code Review, a series of coding challenges and interview related content delivered weekly. Last week we started to discuss recursion. In case you missed it - check out last week’s article here. Additionally, we released our new newsletter! Give us your email here and we'll add you to our "first to know" list :) And without further ado - let's get solving last week’s problem!

The solution

This solution involves, you guessed it, recursion! If you solved it in a more “dynamic programming” approach, be sure to comment with your solution below.

Something that helps me solve any algorithm problem is stopping and thinking for a moment how would my brain solve this problem? What if I had to count the ways to make change of a certain amount with coins with a specific set of denominations?

Let’s say I had to make 5 cents from coins worth 1 and 2 cents. I’d probably start by taking one 2 cents coin, subtract 2 cents from my desired total 5 cents and work with the remaining 3 cents. I’d take another 2 cents coin, subtract that from the remaining 3 cents leaving me with 1 cent needed to make my desired 5. Taking another 2 cents would push my total over, so I’d move on to the next smallest denomination, in this case 1 cent. Taking that gets me to 5 cents and that is one way to make 5 cents with 2 cents and 1 cents. And I’d continue down the coins list like that until I found all the ways. How to translate that into code? Well, it sounds like when my total remaining cents to make is 0 we have found a way right? That sounds like a base case. And if we go over the total desired into negative territory, that isn’t a way. That also sounds like a base case.

// see if you can spot the bug before I complete this function below!
function coins (amount) {
 const coinsArr = [ 1, 2 ]
 if (amount === 0) return 1
 if (amount < 0) return 0

 let numberOfWays = 0
 for (let i = 0; i < coinsArr.length; i++) {
   numberOfWays += coins(amount - coinsArr[i])
 }
 return numberOfWays
}

After our base cases, we essentially just loop through the coins array trying to make change for the remaining amounts.

Walk through

Let's walk through some inputs so we can follow this recursion tree. First we call the function with an amount = 4. We start with the first coin, 1 and subtract it from the current amount, 4 and get 3. We then call coins again with that number. We then reenter the coins function with an amount of 3 and we again start with the first coin 1. We subtract 1 from 3 and call coins again with 2. And so on until we subtract 1 from 1 and get 0 and hit our first base case and add 1 to our numberOfWays variable. This is the 1,1,1,1 way. We come back out into the for loop (with the amount 1) and subtract 2 and get -1. This brings us to our other base case and we return 0. And so on. This is shown as a tree below:

So have you spotted it yet?

That’s right - we’re counting some combinations multiple times due to different permutations of the same coins. 1,1,2, 1,2,1 and 2,1,1 are all the same combination for our purposes. So how can we not restart each for loop for every time we call the coins function? Pass in whatever coin we are up to of course! Another good tip - talk with your interviewer about the function signature. You never know when an extra parameter might be needed or desired. Usually, this can be a good talking point with your interviewer. Don’t be shy!

Here that is in code:

function coins (amount, idx) {
 const coinsArr = [ 1, 2 ]
 if (amount === 0) return 1
 if (amount < 0) return 0

 let numberOfWays = 0
 for (let i = idx; i < coinsArr.length; i++) {
   numberOfWays += coins(amount - coinsArr[i], i)
 }
 return numberOfWays
}

And here is the tree to help you visualize it:

Good work all! See you next week, where I'll break down how I built my favorite side project, Breadwinnerss.

A common recursion interview challenge

elisabethgross — Mon, 06 Jan 2020 02:10:43 +0000

Hey everyone! Welcome back to Code Review, a series of coding challenges and job related content released weekly. We took a brief hiatus for the holiday season, but we’re back and ready to show 2020 all we got. Our team at Coderbyte has been hacking away given the extra time away from our day jobs and we have some big things planned for 2020.

Newsletter 📫

First, I'm excited to mention our new newsletter! We’re going to be sending out a small, feature reveal snippet every time we release something big, so our community is the first to know when we break out something new. Give us your email here and we'll add you to our "first to know" list :) Let’s get started on this week’s challenge. Cheers to 2020! 🎉

The Problem:

Given an infinite amount of quarters, dimes, nickels, and pennies, write a function that returns the number of ways of representing n cents with coins.

Some tips when it comes to recursion

Recursion can get overwhelming at times. Something that really helps me relax when it comes to coming up with an approach to a recursive problem is remembering that by definition, recursive solutions are made up of solutions to smaller subproblems.

Take the classic "calculate the nth Fibonacci number" challenge. In case you haven’t heard this one - the Fibonacci series is a sequence of numbers where each number is the sum of the two preceding ones, starting from 0 and 1. We can take a bottom-up approach, where we’ll try and solve the problem for a simple case and build on it from there. The most simple case for this problem is getting the 0th number of the Fibonacci series which will return 0 as per the definition of the series. Let's build on that to get the 1st number which will return 1, also per the definition. To calculate the 2nd number of the Fibonacci series we add 0 and 1 and we get another 1. To calculate the 3rd number, we add 1 and 1 and we get 2. And the series continues as follows 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ....

This can be summarized as follows: fibonacci(0) will always be 0; fibonacci(1) will always be 1. After that, fibonacci(n) will be the sum of the two preceding numbers aka fibonacci(n-1) and fibonacci(n-2).

In this problem, always returning 1 when n is 1 and 0 when n is 0 are the base cases, which you can think of as the smallest subproblems you can break the problem down into.

This is what that looks like in code:

function fibonacci(n) {
  if (n === 0) return 0
  if (n === 1) return 1
  return fibonacci(n - 1) + fibonacci(n - 2)
}

Big-O

Often to find the Big-O of a recursive solution, it helps to draw the code paths as a recursion tree. For the example above:

The rule is this: the amount of branches each node has in the tree is the base of the power and the levels in the tree are the exponent. So for this example, the Big-O is O(2^n) because each function call splits into 2 function calls. And the number of levels of the tree corresponds to n.

Have fun all and see you next with the solution and a brand new challenge!

How I prepared for interviews and landed my first engineering job

elisabethgross — Mon, 16 Dec 2019 02:25:06 +0000

Hello DEV community and welcome back to Code Review, a series of coding challenges and job related content released weekly. I thought I’d do something a little special this week to celebrate the holidays and gear you up for greatness in 2020. This article is going to cover some of my best tips for landing that new engineering job. After all, isn’t a new and engaging engineering job at an awesome company high on everyone’s holiday wish lists? :)

Here are 10 tips for landing your dream engineering job:

1. It’s a numbers game

One of the most important ways you can help yourself land that dream job is to apply to all the jobs you can. The hard truth is, you won’t hear back from most jobs you apply to, especially if you are looking for your first tech job. So the more jobs you apply for, the more likely you are to get a call back. In my experience, I’ve applied to hundreds of jobs and received relatively few callbacks. Every job applied to increases your chances of getting a response.

2. Tell a story

When I interview prospective candidates, I try and figure out what led this particular candidate to this particular interview so that I can try and project how their story might continue if we hire them. I ask what attracted them to coding in the first place, how they learned what they know and what excites them to ascertain whether their values align with our team’s. An interview is such a short amount of time to determine whether someone is a good fit to spend a large amount of time with on the job. Hone in on your story and what makes you unique so your interviewer can picture what it would be like to work with you.

3. Side projects

When I was interviewing for my first engineering role, I had little experience to speak to. That is why it is especially important to work on side projects when looking for your first dev role. Interviewers want to know you have some experience building applications, even on a small scale. Side projects also help demonstrate that you are passionate about your craft and enjoy doing it even when you aren’t getting paid. Most bootcamps will incorporate side projects into the program, but it’s helpful to go above and beyond to demonstrate your skills and differentiate your resume. That’s why I work on fun projects like Breadwinnerss.com.

4. Network

I know, I know, networking events. Most people hate them, myself included. However, there is NOTHING like having someone put in a good word for you at a company. Having an internal referral is gold in this industry and will help your resume stand out from the rest. Make a goal to go to a networking event as often as you can. I find my best networking events through Meetup where you can filter by topic. Don’t limit yourself to job fairs or job search related events! Go to something you’re passionate about so that you’ll have meaningful conversations with the people you meet. You don’t need a recruiter to get a job referral, any engineer can provide that for you. Trust me, it will pay off!

5. Real technical challenges you’ve had

Everytime I interview someone, I ask them about a technical challenge they faced and how they handled it. Sometimes, a candidate’s answer to this question is the determining factor in whether we hire them over someone else. Why? Because we as engineers spend almost our entire careers facing technical challenges. We realize something we thought would take a couple hours is actually going to take a couple weeks, or two libraries we hoped we could use together actually don’t play nice with one another. Something that separates good engineers from great ones is the ability to be flexible in our approach and communicate the problem effectively so similar miscalculations aren’t repeated (make new mistakes!). Spend some time, and think about one or two challenges you’ve faced (likely you’ve had many to choose from) and how you dealt with them.

6. Practice, practice, practice

This is pretty straightforward. Practice those algorithm questions!! Don’t let a question take you by surprise. There are infinite amounts of algorithm questions that you may get asked, but the underlying concepts are limited. You can master them all with regular practice while prepping for interviews. Whether you’re interviewing for a junior role or a senior one, I recommend using a platform like Coderbyte to help practice those algorithm questions. Almost all technical interviews require that you can do a classic white board problem and writing application code just won’t prepare you for those problems. The more you do, the more comfortable you’ll feel in front of that whiteboard.

7. Get comfortable with being uncomfortable

This is probably the hardest tip and one I still struggle with. Being interviewed is UNCOMFORTABLE. It’s a short amount of time where you have to demonstrate your skills, usually by solving some contrived problem in addition to having some basic chemistry with your interviewer which you really have very little control over. That’s ok. Don’t know the answer to the question they asked? Great. It’s a learning opportunity so you’ll know it next time. Profusely sweating because you wore your favorite sweater and the interview room is hot? Not a big deal - it’s happened to everyone. Its okay to be uncomfortable. In fact - if the interview is a breeze, it may be an indication that the role is too junior for you. Start to see every moment of discomfort as an opportunity for growth.

8. Personal website

This one is pretty self explanatory. Make a personal website! It’s good practice and also a great thing to attach to your resume. It’s also an opportunity to make a first impression that’s a little more three dimensional than your plain ol’ resume.

9. Master your language

Many interviews are language agnostic and for good reason. Most engineering jobs will have a good amount of onboarding time where you’ll have to learn the ins and outs of the company’s tech stack and allllll that sweet sweet institutional knowledge. Most engineering skills are transferable from language to language and for that reason, companies are generally understanding if you have to learn a new language on the job. That being said, it is a bad sign when a candidate doesn’t have a grasp on the ins and outs of their language of choice. Because if a candidate clearly hasn’t mastered the language they’re best at, they might not be able to master a language they will have to learn to be successful on the job.

10. Have fun

Lastly, don’t take yourself too seriously and have some fun. Interviewing is stressful and requires a lot of patience, but it’s also a great time to meet new people, have new experiences, and challenge yourself in ways you never would otherwise.

Our newsletter 📫

We’re going to be sending out a small, feature reveal snippet every time we release something big, so our community is the first to know when we break out something new. Give us your email here and we'll add you to our "first to know" list :)

A JavaScript interview question asked at Facebook

elisabethgross — Mon, 09 Dec 2019 04:07:24 +0000

Wow what a week! Last week’s challenge was a big hit. In case you missed it, here's a link to last week’s article here and the challenge on Coderbyte.

Before I begin talking about the solution to the challenge, I also wanted to let you all know that we at Coderbyte want to hear from you! Have you just had a technical interview and want feedback on how you think you did? Email me at liz.gross@coderbyte.com with interview questions you've been asked and your answers and I'll get back to you with feedback on your solution. Looking forward to hearing from you all!

And now, without further ado, here is a common way to solve this google interview question:

Stack approach:

When I first heard of this question, I immediately thought of using a stack. A stack is a basic data structure where insertion and deletion of elements takes place at the top of the stack. There are normally three basic operations that can be performed on a stack:

inserting an item into a stack (push)
deleting an item from the stack (pop off the top)
displaying the contents of the stack

In javascript, implementing a stack can be as simple as using an array and its push and pop methods. This is an excellent choice of data structure for our problem. As you iterate through the keypresses, you can push them to a stack. As soon as you hit a backspace keypress, just pop the top item off the stack! Here that is in code:

function removeBackspaces(arr) {
  const result = [];
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] === '-B' && result.length > 0) {
      result.pop();
    } else if (arr[i] !== '-B') {
      result.push(arr[i]);
    }
  }
  return result;
}

function checkEqualInputs(arr) {
  const [arr1, arr2] = arr.map((e) => e.split(','))
  const result1 = removeBackspaces(arr1);
  const result2 = removeBackspaces(arr2);
  // check if arrays are equal
  return result1.join('') === result2.join('');
}

Big O:

This is a great solution because it is relatively cheap in terms of time and space. The run-time complexity for both time and space is O(n+m) where n is the length of the first string and m is the length of the second. You will only ever have to iterate through each string once, and store stacks with at most the lengths of each string.

This week’s challenge:

This week, we’ll be solving a coding problem that was given in an actual Facebook phone screen interview. Please comment below with your solutions! And be sure to look at the Facebook Interview Questions course on Coderbyte for more Facebook related challenges!

Write a function that takes a DOM element and smoothly animates it from its current position to distance pixels to the right over duration milliseconds. Implement the following function, animate(el, milliseconds, distance)

For example, animate(document.querySelector('#myDiv'), 2000, 100) would move the element with id myDiv 100px to the right over 2 seconds. Implement this function without using jQuery or any other third-party libraries.

Can’t wait to see what you all come up with. Have fun and happy coding!

Our newsletter 📫

A coding interview question asked at Google

elisabethgross — Mon, 02 Dec 2019 04:50:36 +0000

Hey everyone! Hope you enjoyed solving last week’s challenge. In case you haven’t seen it, I’ll link last week’s article so you can go check it out.

The article
The challenge on Coderbyte

Here's a popular way to solve last week's challenge:

Two index approach:

A more optimized solution (one that is possible because the strings of numbers are sorted) involves initializing two indexes at the start of both strings. Check to see if the element at the index in the first string is equal to, less than, or greater than the element at the index in the second string. If they are equal, push the value to the result array. Because the strings are sorted, if the element in the first string is less than the element in the second string, you can be sure the first element doesn’t exist in the second string. Therefore, you can increment the first index to look at the next value. If the element in the first string is greater than the element in the second string, you can be sure that the value in the second string doesn’t exist in the first string and can increment the second index to look at the next value. This might be clearer to see in code!

 function intersection (arr) {
  const inBothArrays = []
  const [arr1, arr2] = arr.map((str) => str.split(', ').map((e) => parseInt(e)))

  let index1 = 0
  let index2 = 0

  while (index1 < arr1.length && index2 < arr2.length) {
    const elem1 = arr1[index1]
    const elem2 = arr2[index2]

    if (elem1 === elem2) {
      inBothArrays.push(elem1)
      index1++
      index2++
    } else if (elem1 > elem2) {
      index2++
    } else if (elem1 < elem2) {
      index1++
    }
  }

  return inBothArrays.join(',')
}

So for the example:

Calling intersection([“3, 4, 7, 11, 15”, “1, 3, 5, 8, 11”]); your function should return “3,11”.

Here is an illustration that might make this a little clearer.

Remember, this solution only works because the arrays are sorted. The time complexity of this solution is O(n+m).

This week's challenge:

For this week, we'll be solving a coding problem that was given in an actual Google phone screen interview. Remember to head over to Coderbyte to submit your code!

Write a function that takes an array containing two strings where each string represents keypresses separated by commas. For this problem, a keypress can be either a printable character or a backspace (represented by -B). Your function should determine if the two strings of keypresses are equivalent.

You can produce a printable string from such a string of keypresses by having backspaces erase one preceding character. Consider two strings of keypresses equivalent if they produce the same printable string. For example:

checkEquivalentKeypresses(["a,b,c,d", "a,b,c,c,-B,d"]) // true
checkEquivalentKeypresses(["-B,-B,-B,c,c", "c,c"]) // true
checkEquivalentKeypresses(["", "a,-B,-B,a,-B,a,b,c,c,c,d"]) // false

Have fun and you got this!!

Our newsletter 📫

A common coding interview question

elisabethgross — Mon, 25 Nov 2019 03:39:20 +0000

Hey everyone! Welcome back to Code Review, a series of interview challenges released weekly that are completely free for the community. This week we’ll be working on a common, relatively straightforward question that I personally have been asked multiple times in interviews. I chose this challenge because there are multiple ways to approach the problem, each with various time and space trade-offs.

The Challenge:

Write a function, FindIntersection, that reads an array of strings which will contain two elements: the first element will represent a list of comma-separated numbers sorted in ascending order, the second element will represent a second list of comma-separated numbers (also sorted). Your goal is to return a string of numbers that occur in both elements of the input array in sorted order. If there is no intersection, return the string "false".

For example: if the input array is ["1, 3, 4, 7, 13", "1, 2, 4, 13, 15"] the output string should be "1, 4, 13" because those numbers appear in both strings. The array given will not be empty, and each string inside the array will be of numbers sorted in ascending order and may contain negative numbers.

The Brute Force Solution:

A brute-force solution is to loop over the numbers of the first string, and for each number in the first string, loop over all numbers of the other string, looking for a match. If a match is found, concat that value to a result string.

function FindIntersection (strArr) {
  const inBothStrings = []
  const arr1 = strArr[0].split(', ')
  const arr2 = strArr[1].split(', ')
  arr1.forEach(elementArr1 => {
    const numArr1 = parseInt(elementArr1)
    arr2.forEach(elementArr2 => {
      const numArr2 = parseInt(elementArr2)
      if (numArr1 === numArr2) {
        inBothStrings.push(numArr1)
      }
    })
  })
  return inBothStrings.join(',')
}

Although this will work, it is not the most optimal solution. The worst case scenario (if there are no matches) is that for every element in the first string, we will have to iterate through every element in the second string. This has a time complexity of O(nm) where n and m are the size of the given strings.

If you haven’t heard of Big O notation, check out this great article which goes into all the details. Understanding Big O notation and being able to communicate how optimal your solution is to an interviewer is an extremely important part of any technical interview.

Try it Out:

Head on over to Coderbyte and try and solve the problem in a more optimized way. Remember to come back next week where I’ll discuss some other solutions and common pitfalls to this problem. Good luck coding :)

Our newsletter 📫

Introducing Code Review, a weekly coding challenge series!

elisabethgross — Thu, 14 Nov 2019 05:36:06 +0000

Hey everyone! My name is Elisabeth Gross and I have the privilege of working on the Coderbyte platform alongside a talented and passionate team. We're working hard to enable 300,000+ developers to improve their skills and land their dream jobs.

We're launching a brand new series of free articles and challenges exclusively for the Dev.to community. It's called Code Review and I'm super excited to be leading the initiative.

Introducing: Code Review 🤓

Each week (beginning next week) we'll release one coding challenge on Dev.to that will be completely free for the community. The awesome part is that we won't just be posting the challenge – we'll also include real stats and insights from thousands of results in our database so you can see common mistakes, average scores, and average time to complete.

I'll be in the comments section each week discussing the inspiration for the challenge, key concepts, and giving out special rewards to the most clever solutions. We'll begin next week, but in the meantime, here's a bit more about me and my coding journey.

Introducing: Me 👋

I’ve been a software developer for about 3 years. I majored in Biology in college thinking I wanted to be a doctor, but by the time graduation came around, I just wasn’t ready to sign myself up for another 4 years of school, plus a residency and a huge amount of debt. I began working with a friend, Nis Frome, at his company, Alpha, writing content and learning about startup culture and the tech world. Very quickly, I started hanging out with the developers and fell in love with the creative problem solving they were doing in their everyday work. I began to teach myself bits and pieces and eventually attended the Grace Hopper Program at Fullstack Academy in NYC.

I have had a couple full stack developer roles over the years and currently work as a senior software engineer for Moz, a mid-sized SaaS company based in Seattle. I love being an engineer and am passionate about teaching and mentoring to help get more talented people into this great field!

Forem: elisabethgross

A unique JavaScript interview challenge

The solution

Pro Tip

A fun JavaScript interview challenge

The solution

Time complexity

This week’s challenge

Our newsletter 📫

Exclusive Coderbyte promo

A classic interview question

The challenge

The less optimal approach

The sort function

The solution

A JavaScript interview question asked at Google

The Challenge

The solution:

On

Emit

RemoveListener

How to build a side project that will impress future employers

Finding awesome project ideas

Flexing your dev skills

Emphasize technical challenges and solutions

Showcase projects on your resume

Main takeaways

Check out the code on github!

Mastering recursion

The solution

Walk through

A common recursion interview challenge

Newsletter 📫

The Problem:

Some tips when it comes to recursion

Big-O

How I prepared for interviews and landed my first engineering job

Here are 10 tips for landing your dream engineering job:

1. It’s a numbers game

2. Tell a story

3. Side projects

4. Network

5. Real technical challenges you’ve had

6. Practice, practice, practice

7. Get comfortable with being uncomfortable

8. Personal website

9. Master your language

10. Have fun

Our newsletter 📫

A JavaScript interview question asked at Facebook

Stack approach:

Big O:

This week’s challenge:

Our newsletter 📫

A coding interview question asked at Google

Two index approach:

This week's challenge:

Our newsletter 📫

A common coding interview question

The Challenge:

The Brute Force Solution:

Try it Out:

Our newsletter 📫

Introducing Code Review, a weekly coding challenge series!

Introducing: Code Review 🤓

Introducing: Me 👋

Introducing: Our newsletter 📫