# How to be Better at Algorithms? | Examples for Beginners

### What is a Computer Algorithm?

An algorithm is a list of instructions that a computer can use to solve a certain problem. Algorithms are used in all fields of computing, and they are designed to solve problems in an efficient way.

The design of an algorithm depends on the complexity of the problem it needs to solve. For simple problems, brute force might be viable. However, for more complex issues, more complicated algorithms are needed.

### Computer Algorithms are Everywhere

Algorithms are the backbone of all of our digital lives. They help us make decisions faster and more efficiently.

Examples of algorithms that are used in everyday life, such as Google search engine, Amazon’s recommendation system, and Netflix’s movie recommendation system, so algorithms are everywhere!

**Algorithm Efficiency and the Big O(n):**

The optimization process is also dependent on the type and complexity of the algorithm. In some cases, it can take days or weeks to optimize an algorithm while in others it can take only hours or minutes.

The time and space variables are the most important when it comes to Big O(n). Algorithms are an important part of software engineering and computing resources. One of the components that are crucial for their performance is the big O(n) notation. The letter O(n) in this phrase qualifies how many operations are being performed by a particular algorithm, where a lower number means faster execution times. Also, depending on how many (n)s we talking about. Big O focuses on the worst-case scenario.

The prominence of an operation is its efficiency in finding desired results. The size of an operation is its dependence on space to retrieve desired outcomes.

The more input on your operation the slower it will become. There are a few different common types of ‘Big O’ notation which represent how the input affects the efficiency of an operation. These include O(n), O(1) which is the most efficient algorithm, and O(log n) and more…

**How Do Algorithms Work?**

Algorithms are used to sort lists of instructions and find the best possible solution or optimal solution for a given problem. The sorting algorithms are the most common algorithms used in data processing. They help organize data points by keeping it sorted so that it can be easily accessed.

The list of different methods for sorting algorithms is not complete without mentioning the linear sort, which is not really an algorithm but a technique that can be used with any of the other sorting methods.

**Can be divided into simple and complex:**

- Simple sorting algorithms are called “bubble sort” and “insertion sort.”
- Complex sorting algorithms include “quick sort,” “merge sort,” and “heap sort.”

**The Complexity of an Algorithm**

The algorithm can be measured in two ways:

**Time Complexity for an Algorithms**

Time complexity is the upper bound of the time taken by an algorithm to run. It is expressed in terms of a function, asymptotic notation, and a constant value. This may be written in the form of an equation, graph, or table to show the function’s dependence on the independent variable. A time complexity of O(n) means that the algorithm will complete a series of logical steps correlated to the n number.

**Space Complexity for an Algorithms**

Space complexity is a measure of how much space is required to execute an algorithm. Space Complexity for algorithms can be measured in a number of ways, including number of iterations, the number of bits processed by each operation, or number of words processed for each iteration. The O(n) algorithm is linear in the input size. This means that it takes time correlated to the size of the input, up to some maximum amount of work.

**Multiple Techniques to Approach a Problem?**

There are a variety of approaches to solving a problem, which can be classified using different criteria. Please note that this is just my opinion to classify the type of problem I’m trying to solve.

The most common types are:

**Divide and Conquer:**this**Brute force:**involve trying all possible solutions until a satisfactory solution is found.**Randomized:**use a random number during the computation to find a solution to the problem.**Greedy:**looking for an efficient solution on the smaller part, then expanding this optimum solution to the rest of the parts**Recursive:**are used to tackle larger and more difficult versions of a problem by solving smaller, simpler variations.**Backtracking:**is computer programming technique that divide a problem into sub problems, then takes each to an attempted solution. If the desired solution is not reached it will work backwards by finding a path that moves it forward in the problem.**Dynamic Programming:**focuses on solving complex problems in a series of simpler problems that are solved only one time rather than re-computing for each single problem. After at least computing it for once then you need to store it somewhere to re-call it when necessary**Pointer Traversal or Pathfinding:**when searching a graph or network, it’s important to use a proven search algorithm. A pointer traversal is a type of search algorithm that can be used to find the shortest route from one node of the graph to another. For instance, if we want to find the shortest route from Node 1 to Node 2 using pointer traversal then we would start by looking for the nearest neighbor of Node 1 and then, if there is none, looking for the nearest neighbor of the node’s parent**Hash Table**: Hash table algorithms are used for a variety of purposes, such as collision detection and pathfinding. Collision detection is when you want to ensure that two objects don’t intersect with each other, while pathfinding is the process of calculating the shortest distance between two or more points.

### We Got a Problem

**How to Solve it in Plain English?**

The first thing to do is read the problem and make sure that you understand what the instructions are asking you to do.

Next, identify possible values for all of the variables given in the problem, and try to come up with a logical solution for each variable.

Finally, try to write out an algorithm for, start with words not code, write what every programmer knows it’s called “Pseudo code“

**What is a Pseudo Code?**

When we think about programming, pseudo code is often seen. It is a descriptive words with your language used by programmers to design an algorithm or another system’s functions.

This programming language can use the structural conventions of normal languages, yet it is meant for human reading and not machine reading.

**Algorithm Example**

Here is an example of how we think when we face a problem and how we solve it.

Of course, this is just my opinion, but I hope you were able to take something from it. I’ll get this problem from leetcode

This problem about Anagrams, An anagram is a word created by rearranging the letters of another word. The new word will always have all the original letters from the original word, but not in the same sequence.

Example 1

**Input:** strs = [“eat”,”tea”,”tan”,”ate”,”nat”,”bat”]

**Output:** [[“bat”],[“nat”,”tan”],[“ate”,”eat”,”tea”]]

You’ve read the description, seen the example, and done your research on Google. All of this should prepare you in advance for what is requested and what to include in your code lines.

Sure thing you’re still trying to figure out how to put this on code, but now that you have a sense for the solution, you can work on it.

My thoughts step-by-step procedure would be as follow:

1. I could get one instance of each word from the input data.

2. This one instance should make it the default one, and it should be sorted.

3. Again, this default instance would be the key value that collects other instances.

4. This collection is an array that has these values coming from the sorted key value.

5. If I couldn’t find multiple instances then I will just return whatever instance I got.

Now let’s break it down even further by imagining that we write some lines of code. But this code is going to be a pseudo code.

So we need a kind of table that can store a key-value pair. The key would be the default sorted instance of a word and the values would be an array of these multiple instance values within the same characters of the same word. If we couldn’t find any other instances of the same word, then we put it in the array alone.

So,

loop through the input array

sort each string to make it the default key that we talked about above

Is the key exists in the hashTable then put the unsorted version into it’s values

If not then create an array with the current value in the loop

**Source Code in Javascript:**

```
function groupAnagrams(strs) {
//creating the Hash Table
const hashTable = {}
for (let i = 0; i < strs.length; i++){ //Loop through the input list
// Creating the default key by sorting out the value from each string
// To use the Sort method in JS, you need to use it on an array.
// By using the Split() method, you create an array from this current value that you standing on.
// By using the join() method, you recreate the string from the group of characters you created with the split() method above.
const defKey = strs[i].split('').sort().join('')
if (hashTable[defKey]){
//Checking if the hash table has this value if yes, push the current value which is in that case going to be different instance from the sorted default instance.
hashTable[defKey].push(strs[i])
} else {
// if not just initialize it with an array
hashTable[defKey] = [strs[i]]
}
}
//Another great method in JS to help you flat all arrays created in the values of hash Table into one array
return Object.values(hashTable)
};
```

**Source Code in Python:**

```
def groupAnagrams(strs):
hashTable = {}
for s in strs:
defKey = ''.join(sorted(s))
if defKey in hashTable:
hashTable[defKey].append(s)
else:
hashTable[defKey] = [s]
return hashTable.values()
```