If you are wondering why you should take an algorithmic coding test, the answer is simple: skills matter. By taking the test, you will:

- know where you stand in the community of AI practitioners
- review your performance to learn about your strengths and weaknesses
- access personalized study plan to prepare for interviews
- fast track to job opportunities within our network
- get a certificate

And, it’s free. Your results are only ever shared with your permission to refer you to a company. Let’s go over the algorithmic coding test.

# I What is the algorithmic coding test

The algorithmic coding test is one of six standardized tests that were developed by a team of AI and assessment experts at Workera to evaluate the skills of people working as a Data Scientist (DS), Data Analyst (DA), Machine Learning Engineer (MLE), Deep Learning Engineer (DLE), Software Engineer-Machine Learning (SE-ML), Software Engineer-Deep Learning (SE-DL), Software Engineer (SE), Machine Learning Researcher (MLR), or Deep Learning Researcher (DLR). It is comprised of multiple choice questions selected from a large database^{}, so that different test takers get different questions, and takes 16 minutes to complete.

You can learn more about these roles in our AI Career Pathways report and about the other tests in The Skills Boost^{}.

# II What to expect in the algorithmic coding test

Before taking a test, it is important to understand what it evaluates and how it is graded. The grading rubric for the algorithmic coding test includes four categories:

*Solving algorithmic problems*, which covers classic algorithms and their complexities including sorting (e.g., insertion sort, bubble sort, quick sort, merge sort, etc.), searching (e.g., binary search, breadth-first search, depth-first search, Dijkstra’s algorithm, and A-star), and other computer science problems (e.g., matching, permutation, counting, tree traversal, etc.).*Using data structures*, which encompasses ubiquitous data structures (e.g., lists/arrays, sets, maps/dictionaries, trees, graphs, linked lists, tuples, queues, stacks, and heaps) and formats (e.g., string, integers, floats, and the like). and objects used in computer science.*Applying coding methods*, which spans coding methods used by engineers and scientists in their work. This includes algorithmic techniques (e.g., recursion, backtracking, divide & conquer, etc.), mechanisms like classes and inheritance, and miscellaneous practices such as decorator pattern, list comprehensions, exception handling, function composition, bit manipulation, plotting, importing packages, debugging, and the like.

You will be evaluated and assigned to a skill level in each category: beginning, developing, or accomplished, depending on your mastery of the skill at hand. Your skill level in algorithmic coding will be determined using a combination of your scores across all three categories.

You can learn about the categories and performance levels in the table below.

Category | Beginning | Developing | Accomplished |
---|---|---|---|

Solving algorithmic problems | Demonstrates limited understanding of classic algorithms such as sorting and searching algorithms. | Demonstrates ability to understand classic algorithms and solve new algorithmic problems with some effectiveness. | Demonstrates ability to find algorithmic solutions to novel problems. |

Using data structures | Demonstrates limited understanding of classic data structure such as lists/arrays, maps/dictionaries, trees, queues, stacks, and the like. | Demonstrates ability to implement and manipulate data structures with some effectiveness. | Demonstrates ability to choose and implement appropriate data structures to solve a novel problem. |

Applying coding principles | Demonstrates limited understanding of coding methods. | Demonstrates ability to apply coding methods with some effectiveness. | Demonstrates ability to use appropriate coding methods to solve novel problems. |

At the end of the test, you’ll see your overall skill category in algorithmic coding.

You will also receive feedback for every skills evaluated (e.g., *Understanding the implementation of depth-first search* or *Understanding multiple tree traversal algorithms*).

# III Algorithmic coding practice questions

Nothing beats practice! Here are examples of questions you might encounter in the algorithmic coding test. Think carefully before selecting your answer. Then, click submit to see the answer and get feedback.

### Question 1: Understanding insertion sort

### Question 2: Permutations with recursion

### Question 3: Time complexity

### Question 4: Intersection of arrays

# IV Tips for the algorithmic coding test

Now that you know what to expect in our algorithmic coding test, it’s time to take it! You can take the test up to three times in a 90-day period (unless the test is being administered to you by a company for a job) and your results are only ever shared with your permission. The first test is simply meant to act as a baseline to show you where to start studying. So why wait? Sign up here to take the algorithmic coding test.

Given the following sorting algorithm, how many swaps of elements are performed when *array = [4, 3, 5, 1, 6]* is passed as an argument?

2

3

4

5

Permuting an array of characters means reordering its characters. For example, the permutations of *[“c”, “a”, “t”]* are *[“c”, “t”, “a”]*, *[“a”, “c”, “t”]*, *[“a”, “t”, “c”]*, *[“t”, “a”, “c”]*, *[“t”, “c”, “a”]* and *[“c”, “a”, “t”]*. Select the best option for the missing line in the function *permutations*, so that *permutations(chars)* prints all the permutations of *chars*.

`permutations(chars, i)`

`permutations(chars, i+1)`

`permutations(chars, j)`

`permutations(chars, j+1)`

Consider the function *search* which finds the index corresponding to the value *number* in a sorted *array* of length $n$, starting with *left_index* = $0$ and *right_index* = $n-1$. What is the time complexity of this algorithm, in terms of $n$?

$O(1)$

$O(\log(\log(n)))$

$O(\log(n))$

$O(n)$

Complete the missing line in the following implementation of the function *intersection*, so that it returns an array which contains only the elements that are common to *array_1* and *array_2*, without duplicates.

Here is an example$:$

- Input$:$
*array_1 = [1, 2, 3, 4, 5, 4, 6], array_2 = [4, 2, 6, 7]* - Output$:$
*intersected = [4, 2, 6]*.

`already_added.add(array_1[j])`

`already_added.add(array_2[j])`

`already_added.add(array_1[i])`

`already_added.add(array_2[i])`