
import { FormattedMessage } from 'react-intl';

import Anchor from '../components/article/Anchor';
import Bold from '../components/article/Bold';
import Image from '../components/article/Image';
import TinyIcon from '../components/article/TinyIcon';

One short window of time can make all the difference for the future outlook of the position you're thinking of taking.

![Salary Negotiations](https://res.cloudinary.com/bytesizedpieces/image/upload/v1657605807/article/how-best-to-negotiate-your-salary-when-given-a-job-offer/compensation_negotiation_hvajkh.png)

Let's be honest. You're likely reading this article because right now, you have a job offer on your hands or the prospects of one! Congratulations! Let's make your job offer even better, shall we?

Salary negotiation crosses most people's minds, but few decide to take their chances. Studies show that salary negotiation is a skill that is not discriminatory, everyone struggles with it! A <Anchor href="https://news.usc.edu/192848/women-men-salary-negotiation-virtual-agents-usc-research/#:~:text=Key%20findings%20from%20salary%20negotiation%20study&text=The%20researchers%20found%2043%25%20of,good%20at%20negotiating%20in%20general.">USC study</Anchor> shows that from a group of 440 software engineers, 43% chose not to negotiate at all!

*Why is it that almost 50% of individuals choose not to negotiate?*

The two biggest reasons people choose not to negotiate salary are <Bold>fear of discomfort in the negotiation process or the perception of being "pushy".</Bold> Why don't we do some quick math on the damage done by choosing to pass on a few minutes of discomfort?

 Let's say that with negotiating, our job seeker can boost their salary by an additional $5,000. Note that $5,000 is the average increase in salary earned by negotiating.

The value in this salary bump comes from the compounding effect. An individual with a $5,000 salary bump is subject to receive an annual growth rate of 5 percent over a 45-year career. In essence, they would earn about <Bold><Italics>$750,000 more during their lifetime</Italics></Bold> than if they'd stuck with that first offer! Bear in mind this is from negotiation with the first job!

On average, men and women tend to hold 12 jobs in their lifetime. These are 12 separate negotiation rounds. Let's say each negotiation round takes 30 minutes. This results in just 6 hours of that person's entire work-life history of 45 years, spent negotiating. <Bold><Italics>6 uncomfortable hours in your work lifetime, could quite literally be costing you millions.</Italics></Bold> The key takeaway here is to *negotiate, negotiate, negotiate*!

Enough talk and convincing. Let's talk about how we can approach negotiation without it compromising our job prospects. We only want to do good by trying to negotiate with our potential employers, not harm, right?

## 5 steps to take when engaging in compensation negotiation
1. Evaluate yourself and what you have to offer
2. Research market compensation average
3. Prepare your reasoning for negotiation
4. Practice, practice, practice! (May be skipped if negotiation can be done via email)
5. Be confident and positive

Now we get to the fun part! I'm going to break down each step and discuss how you can fulfill them. When the time for negotiating your salary comes, it'll be a breeze!

### Evaluate yourself and what you have to offer
Self-evaluation is a difficult skill for people to attain. We are our own worst critics. One may either be too harsh on themselves or too easy.
For self-evaluation, it is critical to find the right balance of what value you bring to the company by joining while remaining cognizant of areas that need improvement.

With that it's important to consider:
* Skillset
* Career Performance
* Metrics from contributions
* Market need

Consider your skillsets and how desirable they are. Do many candidates potentially have these skills and are they in high demand?

![Skills Checklist Per Candidate](https://res.cloudinary.com/bytesizedpieces/image/upload/v1657605839/article/how-best-to-negotiate-your-salary-when-given-a-job-offer/candidate_skills_uz5utz.png)

If you were previously employed, refer back to your performance over the recent most years or months. Have you shown improvement and growth in this recent period of time?

Another critical component to consider is the metrics from your contributions. What did you do that was beneficial for your prior employer? You can evaluate these metrics in relation to company KPIs or internal improvements made. Anything goes as long as something positive came out of the work you put in.

Lastly, consider the market need for candidates like yourself. Is the market hot for individuals with your skillsets? Do you see growth in your field?

These points justify compensation negotiation. It is just crucial we *be realistic and honest.*

### Research market compensation average
By now you should have done a heart-to-heart with yourself and see the value you bring by joining the company that extended you an offer. The next step involves research on market compensation averages.

Market compensation average awareness is *really important.* In the end, we know what compensation would make us go through the roof with excitement. Considering your value, your research will tell you if your expectations are too high, are realistic, or not on target!

![Research on Table](https://res.cloudinary.com/bytesizedpieces/image/upload/v1657605884/article/how-best-to-negotiate-your-salary-when-given-a-job-offer/Screen_Shot_2022-07-11_at_11.04.39_PM_didob8.png)

When we are conducting our research, we need to evaluate the company whose offers we are considering as well as those of their competitors. It may seem odd to research salary offerings from companies you did not interview for. I can assure you that your company will care about its competitors' offerings. Your desired company does not want to risk losing valuable candidates like yourself to competitors!

Businesses must  hire skilled employees who enable growth in order to see success. Competitive salaries demonstrate that the business values its team members as much as other employers in the industry.

When  you are conducting your market compensation research, make sure to focus on the job tasks, responsibilities, and expectations as well as job titles.

Consider variables such as

* <Bold>Type and size of the company</Bold>
* <Bold>Location</Bold>
* <Bold>Years of experience required</Bold>
* <Bold>Date salaries were reported</Bold> (consider inflation and other factors that could make a salary offering less appealing than the present)

Consider these free options as resources for conducting your market compensation research: <Bold>Glassdoor, Comparably, PayScale and Dice.com</Bold>. In my particular case as a Software Engineer, a tried and true resource has unquestionably been <Anchor href="http://www.levels.fyi">levels.fyi</Anchor>. The salaries posted there are extremely up to date and have been on the money (pun intended).

Determine the average salary given your matching qualifications and bear in mind the higher end as well. You should be aiming for the average or better!

### Prepare your reasoning for negotiation
The time comes to determine how best to apply your research. The goal in mind is to explain your skillset, demand in the market as well as competitor offerings in a respectful, but convincing manner.

The best way to accomplish this is by following these talking points:

* Express gratitude and excitement about the opportunity
* If you have an offer from another company, mention it without disclosing details
* Keep verbiage with as little specificity for your true salary expectations. Express you feel the offer needs strengthening.
* Keep the desired salary in mind and the more unrealistic higher salary. Use the unrealistic salary if directly prompted
* <Italics>Focus on one or two potential areas</Italics> only that need improvement in the offer
* Finish off with again expressing gratitude and excitement for the opportunity

Make sure to write your justification for your salary negotiation down, this will help in the next step.

To explain a few of these points, note that we want to be ambiguous in the beginning to enable the company to give you an unbiased adjusted offer. <Bold><Italics>Specificity can be risky when negotiating.</Italics></Bold>

Imagine you lowball what the company can do, they will just meet you at your number and you're leaving money on the table! On the contrary, if you give way too high of a number it could cause the recruiter to do a double-take. Most companies will still try to meet you where they can, but having a candidate with too high expectations may be discouraging.

This is why absolutely prioritize trying to control the conversation and maintain ambiguity. However, if we have to give away numbers it's still ok! We have done our due diligence for research and will give the slightly higher bound number (but not to the moon crazy). Why are we still not saying exactly what we want? We do not want to give our exact desired number because the recruiter will negotiate on their end too, with the goal of saving the company money. They will almost without a doubt offer something lower than what you asked for. If you ask for higher than your desired, they might just hit the mark on what you actually wanted! If they don't negotiate then even better, you just hit higher than your desired target.

We also want to make sure we do not ask for too many changes to the offer. This may come across as unappreciative or make you appear like an unreasonable candidate. One or two changes need prioritization. If there are other alternatives the recruiter will try to meet you with those.

Finally, your closing statement should express excitement about the opportunity. Go through the pros of the job! You can discuss the culture, focus of work, product, team, what have you. Finish with a statement that is indisputable. When determining what you want to say here, make sure to distance yourself emotionally. Objectively analyze your contributions and value and look at things from the company's perspective. What would the company want to hear from you as a positive of meeting your negotiation asks?

For instance, I would express that I want to make sure that you stay at the company for a long period of time. I would explain that this negotiation would help me realize that desire. There is nothing unreasonable about wanting to make sure you stay at that company for as long as possible!

### Practice, practice, practice!
This step may potentially be skipped if you are able to perform the negotiation via email with your recruiter. This is always the best format for negotiation, as you can phrase your justification with confidence and revise as needed. When your recruiter first provides you with your offer, you can ensure negotiation takes place via email by sharing that you need time to consider the offer. Add that you will follow up with them yourself in a few days. This gives you control over the process!

Let's get back to this step if the recruiter will be the individual to follow up on the offer.

If you followed the prior steps, then you have what you should say to the recruiter and it's time to roll up your sleeves and practice!

![Practice](https://res.cloudinary.com/bytesizedpieces/image/upload/v1657605999/article/how-best-to-negotiate-your-salary-when-given-a-job-offer/practice_nhs191.webp)

* Practice your justification while looking in the mirror
* Practice with a friend or family member
* Make sure to sound grateful yet confident when delivering the speech

You want to make sure you are able to cleanly get through your negotiation points. It will inevitably be more challenging when the time comes and the recruiter is the one on the other end!

### Be confident and positive
After you've delivered your speech to the recruiter, make sure to remain confident and positive throughout the rest of the process. Bear in mind that you already received an offer from the company. They want you to join and will try their best to meet your requirements while adhering to their own capabilities. Remember your worth and the value you would bring to the company by joining.

![Confidence](https://res.cloudinary.com/bytesizedpieces/image/upload/v1657605799/article/how-best-to-negotiate-your-salary-when-given-a-job-offer/confidence_nhoga3.jpg)

When you receive your counteroffer always express gratitude for the recruiter's efforts. This is critical even if the counter isn't what you want to hear! If the offer does not come back quite as you expected, oftentimes it is still within reason to try once more with negotiation. I personally would not recommend more rounds than that, however.

---

Salary negotiation does not have to be a daunting and unachievable task. Everyone experiences nervous energy when facing a job offer from a desirable company. It's understandable that you don't want to squander the opportunity! However, it is extremely important to keep in mind your value. Simply put, you are the best, so you deserve the best! Don't miss out on those millions by dismissing 30 minutes of discomfort. You will be grateful you are earning what you are truly worth and will perform better at your new job!

Now go out there, negotiate, and land the job AND salary of your dreams!

---

Remember, developers are creatures that turn coffee into code. So I'd very much appreciate if you <Anchor slug="overcome-imposter-syndrome" action="buy_coffee_overcome-imposter-syndrome_click" href={"https://www.buymeacoffee.com/stefanagloginic"} styles={{ 'display': 'inline-flex', 'alignItems': 'center' }}>bought me a coffee! <TinyIcon alt="buy me a coffee icon" styles={{
    width: '23px',
    height: '23px',
    marginLeft: '3px'
}} src={"https://res.cloudinary.com/bytesizedpieces/image/upload/v1639952578/assets/buymeacoffee_udskx4.png"} /></Anchor> I’m a new writer and I will be posting very frequently on my findings and learnings in the tech industry and beyond. Join my newsletter if you would like to stay tuned!

Thanks for reading again! ❤️


One short window of time can make all the difference for the future outlook of the position you're thinking of taking

Article providing a guide on how a job candidate can negotiation their salary with companies. It goes over strategies for researching market demand of skillsets, preparation and tips for negotiation, as well as how best to engage with recruiters respectfully.

Guide on salary negotiation for job offer

How best to negotiate your salary when given a job offer


import { FormattedMessage } from 'react-intl';

import Anchor from '../components/article/Anchor';
import Italics from '../components/article/Italics';
import Bold from '../components/article/Bold';
import BigQuotes from '../components/article/BigQuotes';
import TinyIcon from '../components/article/TinyIcon';

![Big O Complexities with Number of Computations by n](https://res.cloudinary.com/bytesizedpieces/image/upload/v1656883388/article/analyze-big-o-notation-and-save-your-valuable-reputation/big_o_zmqza6.png)

Big O Notation understanding is just one of those things a Software Developer has to have in their toolkit. Understanding Big O Notation is vital for success in software engineer interviews. Most software engineer interview questions will present a problem for which you need to provide and potentially implement a solution, and the follow up questions assess your capability of evaluating the complexity of your solution through Big O Notation.

Big O Notation starts off easy and can feel understandable, then BAM the complexity comes in and it leaves you reeling.

Let's do a dive into Big O Notation, and discuss how you can get acquainted with analyzing algorithm complexity without it leaving you perplexed.

## What is Big O Notation?
Big O notation is a mathematical notation that describes a limiting behavior of an algorithm or a function. It uses algebraic terms to describe the complexity of our code.

## Why is Big O Notation important to understand?
An engineer's job involves a lot of risk minimization. We always need to scrutinize *worst-case scenarios* as this is the critical point where an application can be deemed incredible by our users or not worth using.

Big O Notation tells us how our code will scale according to traffic, data, you name it. With an analysis of complexity, we can confidently determine how our code will hold up in difficult scenarios.

If you need more convincing, understand that the company's reputation is at stake if its engineers are not considering the worst-case scenarios. One such example of the disasters that can happen is the <Anchor href="https://www.theverge.com/2017/7/25/16019404/pokemon-go-fest-refunds-disaster-review">Niantic Pokemon Go Fest back in 2017</Anchor>. The Pokemon Go app was all the craze but couldn't live up to its hype. The highly anticipated event, for which users traveled to New York, rapidly turned into a nightmare. The app was crashing, unable to get past the login flow and fans were disappointed, some even angered. The CEO was left to flounder with excuses on stage in front of thousands of upset users. Not a good look!

Anyways, back to Big O Notation.

## Where can we apply Big O Notation?
Understand that every line of code has a cost to it. The code we write takes up resources like CPU, memory, and network.

Typically, we use Big O Notation to describe

* Time Complexity (CPU usage)
* Space Complexity (Memory usage)

For the purposes of this article, I will focus on Time Complexity given it is the more focused subject, especially for interview purposes.

What I will say about the two, however, is know that time complexity and space complexity are two concepts always at war with each other. We as developers have to examine our end goal when writing our algorithms and make a compromise, time complexity versus space complexity.

I plan to write more on the time complexity vs space complexity challenges in another article, subscribe to my newsletter for when that next article comes!

## Common Time Complexities
Let's focus on the most important complexities to understand, as well as learn how we can determine which complexity our algorithms fall into.

The most common Big O Notations are:

* O(1) or <Italics>Constant time complexity</Italics>
* O(log n) or <Italics>Logarithmic complexity</Italics>
* O(n) or <Italics>Linear time complexity</Italics>
* O(n²) or <Italics>Quadratic time complexity</Italics>

This list of complexities starts from the BEST and goes to the worst.

How about we go through each of them?

### O(1) or Constant Time Complexity
When we say that something is written as <Bold>O(1), this means that it will always execute in constant time</Bold>. There is no improvement beyond O(1) time complexity (aside from doing nothing at all).

An O(1) Big O Notation time complexity typically falls under array indexing, or operations like push and pop to an array because they are simply adding/removing an item from the tail end of the array. 

Array indexing and appending/removing from the end are not operations that can be improved, therefore they fall under O(1) time complexity.

Retrieval of keys from Javascript objects also are of O(1) time complexity.

This knowledge is very important to retain, because many algorithms can be improved by storing data in arrays/objects and the retrieval can be done in constant time (at the expense of space/memory of course, see the tradeoffs?).

Note that O(log n) is indeed faster than O(n), but it is a little more complex to understand. I want to discuss O(n) and O(n²) time complexity first and then we will lastly review how O(log n) is even better than both!

### O(n) or Linear Time Complexity

<Bold>O(n) time complexity is strictly proportional to the size of our input data.</Bold>

Let's say we have an array of size 5.

`const arr = [1, 2, 3, 4, 5];`

If we wanted to print all of the contents of the array, we would have to iterate through it in a for loop. We would see 5 console logs for each item in the array, which is of O(5) complexity. If the array were of size 10, then we would see 10 logs that make for O(10), and we can keep going with this pattern.

The key takeaway note for this exercise is that the amount of execution is strictly proportional to the size of our array. To abstractly define the number of items in our arrays, we can refer to them as n items.

This leads us to generalize the time complexity, where we could say an algorithm/function that runs through all the data in a linear fashion has a time complexity of O(n).

Let's look at an example of a function with O(n) Big O Notation time complexity.

![Array Printing function with O(n) time complexity](https://res.cloudinary.com/bytesizedpieces/image/upload/v1656883423/article/analyze-big-o-notation-and-save-your-valuable-reputation/o_n_s5mq53.png)

The following printArray function has a time complexity of O(n) because it can take an array of any arbitrary length and always iterates through it in a for loop to print every value.

<BigQuotes>When do we typically see algorithms/functions with O(n) time complexity?</BigQuotes>

Now I gave away the circumstances in which we would have an algorithm/function with a runtime of O(n). <Bold><Italics>Typically we observe time complexity of O(n) when we iterate through a single array, or if we are using recursion to go through every single item in a data structure, object or array,</Italics></Bold> what have you. Think of recursion as an array.

Recursive functions leverage the "the call stack." <Bold>When a program calls a function, that function goes on top of the call stack.</Bold> And a stack behind the scenes is a glorified array, represented by this data structure with added functionality.

Now, this algorithm works if our input size is small. Like my earlier example, 5 or 10 items would be quick to iterate through. However, the time duration gets longer as our list of items grows.

O(n) Big O Notation means that <Bold>our algorithms take proportionally longer to complete as our input grows</Bold>.

Remember, our job is to understand the implications of the code we write in the worst-case scenarios. Imagine if we had a million items. We would have to iterate through each one! That can be pretty demanding.

Sometimes we have no choice but to do the O(n) solution, other times we can do better. It's up to the engineer to find a better solution if it is out there.

Now you might at this point be wondering about the code written inside of our for loops or recursive functions. Don't they have a time complexity as well? Absolutely they do!

<Bold><Italics>It's worth mentioning when evaluating Big O Notation that we want to generalize our analysis strictly to the worst-case scenario.</Italics></Bold> Unless the code written in the for loop is WORSE than O(n), the time complexity of the inner for loop logic can effectively be ignored for a time complexity deduction.

### O(n²) or Quadratic time complexity
Now that we understand O(n) Big O Notation a little bit better, we can see how we might get an algorithm that is O(n²) or even O(n³).

We know that for loops that iterate through all n items have a time complexity of O(n). So ask yourself this, what happens if we iterate through the array twice, through a nested for loop?

Following the thought process for O(n), we know we have an array of arbitrary length that was generalized as n. Now what we are saying is that for each item `i` in that array of arbitrary length n, we are going to iterate through each item again n times!

This is how we reach the time complexity deduction O(n*n) or better known as O(n²).

Let's look at another example to reach better clarity. Square matrices are the perfect example to demonstrate this time complexity. <Bold>A matrix is a set of values laid out in tabular form (in rows and columns)</Bold>. We represent a matrix with an array comprised of nested arrays.

In the following code, we define a function that will log the values found in a square matrix of arbitrary size n*n.

![O(n²) time complexity](https://res.cloudinary.com/bytesizedpieces/image/upload/v1656884408/article/analyze-big-o-notation-and-save-your-valuable-reputation/printMatrixNxN_ahclhd.png)

I want to raise the following point that I'm iterating through a series of arrays that are guaranteed to be the same length. This is how we can confidently say our time complexity is of O(n²).

If we were to say iterate through one array of a specific size, and have a nested for loop for an array of a different potential size, then technically our time complexity is different. Let's say our first array is of length n, but the second that could be a different size is m.

Our runtime would then be O(m*n).

Here is an example of an algorithm with runtime O(mn) to bring better clarity.

![O(mn) time complexity](https://res.cloudinary.com/bytesizedpieces/image/upload/v1656883427/article/analyze-big-o-notation-and-save-your-valuable-reputation/o_mn_b63d3k.png)

The time complexity for `printNestedArraysInOrderis` O(mn) Big O Notation because the array `DAYS_OF_THE_WEEK` is different in length than WEEKS .
We provide this time complexity because `printNestedArraysInOrder` is written in such a way that it *accepts arrays of different lengths and iterates through them in a nested for loop.*

Typically we do not want to accept algorithms or functions with a time complexity of O(n²) unless we know that the number of items cannot go to infinity. In an interview setting, we often find that we can easily determine an algorithm of O(n²), and these such answers are known as Brute Force algorithms.

<Bold>
    A Brute Force algorithm is a straightforward solution to a problem that heavily relies on computing power. The computer's capability to try every possibility before arriving at an answer gets taken advantage of when instead one could derive more advanced solutions to reduce compute strain.
</Bold>

Brute force solutions typically are not necessary! Rather there exist more advanced techniques to dramatically improve efficiency. Time complexity serves as the tool to help us understand just how drastic that change can be.

We have not yet discussed time complexity O(log n). However, I want to briefly look again at this chart I attached earlier. Observe just how many steps an O(n²) time complexity algorithm takes if n is of length 1,024.

![Big O Complexities with Number of Computations by n](https://res.cloudinary.com/bytesizedpieces/image/upload/v1656883388/article/analyze-big-o-notation-and-save-your-valuable-reputation/big_o_zmqza6.png)

For an O(n²) time complexity we observe over 1 million rounds to arrive to a conclusion! Furthermore, we see how O(n³) is absolutely atrocious. The amount of iterations required to arrive at a solution quickly gets out of hand.

But, looking at O(log n) the results are incredible! For the same 1,024 value, we see that only 10 steps at most are required to arrive at a solution. This is as close as we can get to a time complexity of O(1), better known as the best time complexity possible.

### O(log n) or Logarithmic complexity
We finally arrive to the last time complexity, which can be among the more difficult to understand.

The O(log n) Big O Notation which we will be considering for these examples is that of the <Bold><Italics>binary logarithm</Italics></Bold>.

<Bold>The binary logarithm is of base number 2. Binary logarithms are the basis for the binary numeral system and are critical to computer science</Bold>. <Italics>The binary logarithm is the basis for all binary code used in computing systems. It allows us to count using zero and one numbers only.</Italics>

With that, let's dive in!

The way I like to explain the O(log n) complexity is by example of a famous algorithm.

<Bold><Italics>Let's explain the problem statement and solution for the binary search algorithm.</Italics></Bold>

#### Binary Search Problem Statement
Imagine we have an array of arbitrary length. We want to find if a particular value exists in said array.

The lack of awareness of the actual values in the array is a plausible real scenario. When dealing with data we often do not necessarily know all the contents of said data. So, how do we find this desired value in the most optimal way?

#### Binary Search Approaches for a Solution
Our brute force solution could be to simply iterate through the entire array, and see if we observe this value. This time complexity at its worst, as we discussed earlier is O(n). Data often however is comprised of millions of entries, so this is not a practical solution.

This is where for binary search, a more advanced algorithm comes into play to save the day.

Binary search starts by assuming that we sorted the array. Note that sorting can be done in O(log n) time. Knowing this, we can rest assured that so far we are not harming the integrity of the time complexity of our solution by starting off with sorting.

Now we get to the general idea of the binary search algorithm. Let's say our sorted array looks like the following example:

`const arr = [1, 4, 7, 11, 20, 22];`

Let's say we want to find out if the number 4 is in our array. The idea behind a binary search involves asking the question: What we can do is split the sorted array in half, take the middle number and observe if it is smaller, or bigger than our desired number. If the middle value is equal to 4 then great, we found our desired number and can return as it is indeed in the array. If we find the middle is a number that is smaller than what we are looking for, we can disregard the left half of the array from that selected midpoint. Why? Because we know the array is sorted! *Any number further to the left will guaranteed to be smaller than the middle and we already know the middle is smaller than the value we are looking for. So we can safely proceed to the right for the rest of our search. We can likewise apply the same logic for numbers larger.* If we see that the middle is larger than what we are looking for, we know the numbers to the right are sorted and also larger! So we can proceed to the left for the *rest of the binary search.* After we choose a direction, we split the problem in half again and continue on until we find our desired value.

The strategy behind the binary search solution involves splitting subsets of the problem in half repeatedly until we arrive at an answer. Each iteration results in elimination of many values we would have otherwise been forced to waste a check on should we have performed an O(n) linear search solution!

The binary search approach utilizes the <Bold>Divide and Conquer strategy</Bold>. Most Divide and Conquer capable questions involve time complexities of O(log n).

<Bold>A divide and conquer algorithm is a strategy of solving a large problem by breaking the problem into smaller sub-problems, solving those sub-problems and combining them to get the desired output.</Bold>

If you want to better understand how we arrive to O(log n) for this solution, let's dive in.
What does log n do?

Let's evaluate values where:

n = 2^x, and x = {1, 2, 3, 4, 10} (Note that I skipped values in the x set for sake of example, from 4  - > 10)

Our resultant values for n are:

*n = {1, 2, 4, 8, 16, 1024}*

When we put n into our log(n) function, we arrive to values

*log (n) = {0, 1, 2, 3, 4, 10}*

Notice the results are not exactly half. If you think back to the divide and conquer algorithm this might make a little more sense. We only divide the problem in half once, then we divide a subset in half, and so on. We aren't necessarily halving the whole problem, we are halving halves repeatedly, so it's even *better* than halving our solution.

Now we can hopefully see why the binary search problem can be tackled by a divide and conquer algorithm.

![Common time complexities represented in a graph](https://res.cloudinary.com/bytesizedpieces/image/upload/v1656901709/article/analyze-big-o-notation-and-save-your-valuable-reputation/log_qtq0qi.jpg)

Now we can maybe start to see how dramatically different log (n) performs against the other time complexities we went over.

We saw that O(n) Big O Notation is strictly equal to the number of elements. That is why we see the diagonal line. For every x, we see the same y.

O(n²) however we saw earlier in our chart gets worse as n grows bigger, and O(n³) gets out of hand even quicker. Looking at the graph, we see this in the visual representation as the line races vertically high up when given much smaller values on the x-axis of this graph.

Now O(log n) however, stretches out nicely as the values along our x-axis gradually get larger. Yes, it is moving vertically upwards, but at a *much* slower rate.

This is why a time complexity of O(log n) is much better than the other solutions we reviewed.

Finally, observe how O(1) time complexity is unbeatable. It can't get any better than that!

Hopefully, now you can see how critical it is to be able to evaluate time complexities in the code we write. It is invaluable to write algorithms that spend less computing power as it inevitably results in a faster response.

---

We all know that <Bold><Italics>Fast = Sleek</Italics></Bold>!

<Bold>Ultimately, understanding Big O and the capacity to optimize algorithms make for the difference between an acceptable engineer who can do the job and a phenomenal engineer who can excel at the job.</Bold>

Happy coding everyone!

---

Remember, developers are creatures that turn coffee into code. So I'd very much appreciate if you <Anchor slug="overcome-imposter-syndrome" action="buy_coffee_overcome-imposter-syndrome_click" href={"https://www.buymeacoffee.com/stefanagloginic"} styles={{ 'display': 'inline-flex', 'alignItems': 'center' }}>bought me a coffee! <TinyIcon alt="buy me a coffee icon" styles={{
    width: '23px',
    height: '23px',
    marginLeft: '3px'
}} src={"https://res.cloudinary.com/bytesizedpieces/image/upload/v1639952578/assets/buymeacoffee_udskx4.png"} /></Anchor> I’m a new writer and I will be posting very frequently on my findings and learnings in the tech industry and beyond. Join my newsletter if you would like to stay tuned!

Thanks for reading again! ❤️

Big O Notation understanding is just one of those things a Software Developer has to have in their toolkit. Big O Notation starts off easy and can feel understandable, then BAM the complexity comes in and it leaves you reeling. Let's do a dive into Big O Notation, and discuss how

Article summarizing Big O Notation importance for software engineering interviews. Covers constant time complexity, linear time complexity, logarithmic time complexity, and quadratic time complexity.

Analyze Big O' Notation

Analyze Big O' Notation and save your valuable reputation


import { FormattedMessage } from 'react-intl';

import Anchor from '../components/article/Anchor';
import Bold from '../components/article/Bold';
import BigQuotes from '../components/article/BigQuotes';
import Image from '../components/article/Image';
import TinyIcon from '../components/article/TinyIcon';

Leetcode leetcode leetcode! That's what you hear every software engineer insist on when you ask the infamous question:

<BigQuotes>How should I study for my interviews?</BigQuotes>

![Leetcode Strategy Question from Engineer on Blind](https://res.cloudinary.com/bytesizedpieces/image/upload/v1647427073/article/how-to-leetcode-effectively-and-find-success-in-your-coding-interview/leetcode_zqijg1.jpg)

I see questions that express confusion around Leetcode strategy daily!

These questions come from students fresh out of college looking for their first SWE job and even from more senior developers. Maybe you recently tried interviewing at a company and it didn't go so well…you might've even tried more than one interview and found all of them haven't gone well. When you ask your coding community that same frustrating response keeps coming back.

<BigQuotes>You probably didn't leetcode enough</BigQuotes>

Ok... But I did 200+ problems! How can this be? What is this magic number I need to hit before I start nailing my interviews?

Unfortunately, the study strategy behind Leetcode falls through for many. The Leetcode studying process does not discriminate when it comes to who it intimidates! I noticed the tendency of engineers to tackle an exorbitant number of questions in a short range of time and they would still struggle in their interviews. I'm here to share the strategy that helped me ensure that I nailed any coding interview I took on with the companies I was interested in.

Let me keep this short and simple.

<Bold>It's not so much about the <Italics>number</Italics> of Leetcode questions you complete, it's the <Italics>content</Italics> you cover!</Bold>

Sure, after some point the number of questions you go over helps you get better at solving questions faster. <Bold><Italics> But the path to success at interviews lies in a well-targeted overview of the computer science fundamentals.</Italics></Bold>

## Content

The 2 fundamental blocks to target when studying are:

* Data Structures
* Algorithms

That's really it. The high level of your strategy is to target a well-rounded study set oriented around those two topics.

![Strategy on paper highlighted by pencils](https://res.cloudinary.com/bytesizedpieces/image/upload/v1647427085/article/how-to-leetcode-effectively-and-find-success-in-your-coding-interview/strategy_dw2vih.jpg)

Leetcode has thankfully worked to address this lack of strategy engineers would have when studying for interviews.

<Bold>With Leetcode premium, you get access to <Anchor href="https://leetcode.com/explore/learn/">study sets</Anchor> that give you an overview of fundamental data structures, supplemented with questions and answers that require the usage of relevant data structures and algorithms. You also will be able to reference a tagged set of questions that were asked by your company of interest.</Bold>

Know that this article is *not* paid promotion. Take on Leetcode premium for 2 months then cancel it when you nail your dream job.

When you are going over the study sets and tackling the integrated questions, I implore you to write down your observations. Always pause and ask yourself. *Why does this data structure work for this question?*

## Look for patterns

These patterns will represent the strategy you will employ when faced with a question you've never seen before. After solving a question in your own way, if you spend so much as an extra 30 minutes analyzing the question and answer provided by Leetcode, you'll be golden. Closely evaluate your solution versus the provided solution from Leetcode. Write down the data structures their solution uses and what makes their solution elegant. Most of these questions are implemented with shorter easy read code. Try to pick up the strategy behind these provided solutions and begin to utilize them on your own.

## Company question curation

After completing the study sets (and I implore you to review all of them) you can further use Leetcode to search for questions asked by the company. If you know you are going to interview with Lyft for instance, <Bold>filter the LeetCode questions repository by the company.</Bold> Make sure that you leverage the LeetCode community! Individuals who were interviewed recently tend to return to the platform and mark which questions were asked by which company. This is an amazing resource for your interview preparation that you must take advantage of. <Anchor href="https://leetcode.com/company/hulu"><Bold>Here's a sample link of tagged Leetcode questions asked by Hulu.</Bold></Anchor>

Finally, when studying make sure to attempt medium to hard range questions on Leetcode. When you filter by your desired company you can see their level of difficulty (whether or not they ask questions that are in the medium range, or if they tend to target the hard LC range). If you see Leetcode hard questions asked by your desired company, don't ignore that level! Ensure you've done enough hard questions until you are able to tackle them with ease.

And there you have it! <Bold>Leetcode has already compiled an effective study set that when studied proactively will dramatically increase your chances of interview success.</Bold>

Many tend to study Leetcode passively and at random, and as a result, lose out on learning the underlying patterns to these questions. Once these patterns are unveiled, you will realize that unfamiliar questions are no longer as intimidating!

Best of luck in your studying adventures, go out there and nail it in your interviews!

---

Remember, developers are creatures that turn coffee into code. So I'd very much appreciate if you <Anchor slug="overcome-imposter-syndrome" action="buy_coffee_overcome-imposter-syndrome_click" href={"https://www.buymeacoffee.com/stefanagloginic"} styles={{ 'display': 'inline-flex', 'alignItems': 'center' }}>bought me a coffee! <TinyIcon alt="buy me a coffee icon" styles={{
    width: '23px',
    height: '23px',
    marginLeft: '3px'
}} src={"https://res.cloudinary.com/bytesizedpieces/image/upload/v1639952578/assets/buymeacoffee_udskx4.png"} /></Anchor> I’m a new writer and I will be posting very frequently on my findings and learnings in the tech industry and beyond. Join my newsletter if you would like to stay tuned!

Thanks for reading again! ❤️

Leetcode leetcode leetcode! That's what you hear every software engineer insist on when you ask the infamous question: "How should I study for my interviews?" ... I'm here to share the strategy that helped me ensure that I nailed any coding interview I took on with the companies I was interested in.

Article that explains how to use leetcode to study for software engineer interviews. It goes over how to filter data structures and algorithm interview questions asked by companies to cover as well as what to look for while studying such as patterns.

How to Leetcode Effectively and Succeed in Coding Interview

How to Leetcode Effectively and Find Success in Your Coding Interview


import { FormattedMessage } from 'react-intl';

import Anchor from '../components/article/Anchor';
import Bold from '../components/article/Bold';
import BigQuotes from '../components/article/BigQuotes';
import TinyIcon from '../components/article/TinyIcon';

It’s no secret that the job market is quite hot these days. Along with the status of the job market, there is a mass exodus currently taking over the tech industry. Every company is experiencing a lot of change, with a great amount of talent leaving while simultaneously incoming talent joins.
Excitement is in the air, it is enticing to say the least!

![interview ready excited girl with laptop](https://res.cloudinary.com/bytesizedpieces/image/upload/v1641450281/article/get-an-interview-with-any-company-you-want/victory_hzmnsd.jpg)

I recently engaged in the exodus. I decided to test the waters and interview with some tech companies and I’m on the other side of that journey now. After a multitude of interviews, many offers, a lot of negotiating and internal debating of my own priorities, I’ve accepted an offer with a company I am *thrilled* about. As I was interviewing, and even now still, one question keeps coming up from peers and friends.

<BigQuotes>How did you get so many interviews with all of these companies?</BigQuotes>

After some investigating, my impression is that the *how* of getting interviews with companies, is a topic that has lacked discussion. I intend to break the silence and share my strategies for getting the attention of companies when I was ready for them to look my way.

## Job forms are dated

![interview job form illustration](https://res.cloudinary.com/bytesizedpieces/image/upload/v1641450294/article/get-an-interview-with-any-company-you-want/jobForm_fizlp3.jpg)

We add our resume, then despite having just added our resume, we are asked to fill out fields to describe our entire work history and all of that redundant jazz. Sure, it still works but by filling these resume forms out, you leave things to chance. When you’re looking to make a big change in your life, such as changing your work, you want to have a little bit more control.
Who even knows if your job application and resume will make it to an actual person? You might end up having your submission you just spent hours on thrown out because a machine learning algorithm didn’t find enough keywords from the job description in your resume. *You are deemed a bad match before you even have a chance.*


I didn’t want that to happen, I wanted a person to see if I seemed like a match. Therefore, I chose not to fill out online forms. *Not a single one.*

I used <Bold>three key components</Bold> to get into the spotlight with the companies I wanted:

* Referred to my immediate network
* Blind
* LinkedIn Premium

After dusting off my resume, making it shiny and nice (a dear friend of mine <Anchor href={"https://www.buymeacoffee.com/stefanagloginic"}>Anup Deb</Anchor>, an incredibly talented web apps designer helped me out with the template) I was ready to cast my line and see what bites I can get!

## First: my network

I reached out to my immediate network. I let them know I was planning to interview soon and was hoping to get a <Bold>referral</Bold> if I could find a role where my professional experience was a match. Bear in mind, people are happy to give referrals, and companies are happy to get referrals! Referrals save time and if an employee (who passed the interviews and is performant within the company) testifies to your ability, then even better, it’s a <Bold>win-win scenario</Bold>!

## Second: Blind

*Blind is an excellent resource to get referrals* if you don’t have someone in your immediate network who is employed at a company you wish to interview with. Not in tech? Don’t fret, I’ve come across many applications with the same purpose as Blind. Fishbowl is one other example of a professional community shrouded with anonymity served to you in a mobile application!

If anything, Blind is an excellent resource for transparency on the company culture and packages. You can utilize Blind to make a posting for unbiased responses. Blind users being anonymous leaves the door wide open for the answers you seek.

## Third: LinkedIn Premium

Finally, I bought LinkedIn Premium to unlock the InMail access I needed to grab the attention of recruiters. I had a list of companies I was interested in and sought out technical recruiters at the companies while sending them an *about me* message with the role I was interested in with my resume attached. And *this works*, as long as you are persistent on LinkedIn Premium.

Make sure not to settle for messaging one recruiter at the company. Remember, these are people-living, breathing human beings. And what do we have a tendency of doing when we receive a ton of notifications or incoming messages?

*We swipe away*, we disregard. It’s not you. It’s just human nature.

<Bold>*The effectiveness comes with the number of people you reach out to on LinkedIn Premium-your persistence.*</Bold> Reach out to more than one recruiter per company on LinkedIn Premium, make sure to attach your resume and you should be golden.

Of course, it always helps to have some solid experience to your resume, something that when you put it in front of others, they really will say wow! This person *would* be an awesome addition to the team. You want them to be sold on you. <Bold>A recruiter who is excited about you will fight for you.</Bold>

<Bold>Keep moving forward, keep in mind you are successful and talented.</Bold> This is the way to step into the spotlight and <Bold>*begin the journey in which you wow the crowd.*</Bold>

Remember, developers are creatures that turn coffee into code. So I'd very much appreciate if you <Anchor slug="overcome-imposter-syndrome" action="buy_coffee_overcome-imposter-syndrome_click" href={"https://www.buymeacoffee.com/stefanagloginic"} styles={{ 'display': 'inline-flex', 'alignItems': 'center' }}>bought me a coffee! <TinyIcon alt="buy me a coffee icon" styles={{
    width: '23px',
    height: '23px',
    marginLeft: '3px'
}} src={"https://res.cloudinary.com/bytesizedpieces/image/upload/v1639952578/assets/buymeacoffee_udskx4.png"} /></Anchor> I’m a new writer and I will be posting very frequently on my findings and learnings in the tech industry and beyond. Join my newsletter if you would like to stay tuned!

Thanks for reading again! ❤️

It’s no secret that the job market is quite hot these days. Along with the status of the job market, there is a mass exodus currently taking over the tech industry. Every company is experiencing a lot of change, with a great amount of talent leaving while simultaneously incoming talent joins.

Article summarizing the steps a job seeker can take to land interviews with any company they would like. Describes how to use your network, Blind, and LinkedIn to seek out recruiters or potential job opportunities that are otherwise hidden.

INTERVIEW

How best to negotiate your salary when given a job offer

One short window of time can make all the difference for the future outlook of the position you're thinking of taking...Read more

Analyze Big O' Notation and save your valuable reputation

Big O Notation understanding is just one of those things a Software Developer has to have in their toolkit. Big O Notation starts off easy and can feel understandable, then BAM the complexity comes in and it leaves you reeling. Let's do a dive into Big O Notation, and discuss how...Read more

How to Leetcode Effectively and Find Success in Your Coding Interview

Get An Interview With Any Company You Want

Join our newsletter to read delightful bytesizedpieces every Monday!

How best to negotiate your salary when given a job offer

One short window of time can make all the difference for the future outlook of the position you're thinking of taking....css-1ncj5p5{color:var(--theme-ui-colors-red-color);}Read more

Analyze Big O' Notation and save your valuable reputation

Big O Notation understanding is just one of those things a Software Developer has to have in their toolkit. Big O Notation starts off easy and can feel understandable, then BAM the complexity comes in and it leaves you reeling. Let's do a dive into Big O Notation, and discuss how...Read more

How to Leetcode Effectively and Find Success in Your Coding Interview

Get An Interview With Any Company You Want

Join our newsletter to read delightful bytesizedpieces every Monday!

One short window of time can make all the difference for the future outlook of the position you're thinking of taking...Read more