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?

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)

No. This would cause permutations to be called an infinite number of times with i = 0.

permutations(chars, i+1)

Yes. This code allows permutations to recursively find the permutations of chars. The recursive construction of the permutations of chars = [“c”, “a”, “t”] are represented in the tree below. Each circle is a call to the function permutations. Arrows represent the action of assigning a character to a position. Rectangles represent printing. Finally, the algorithm is executed in the order highlighted in dark.

permutations(chars, j)

No. This would cause permutations to be called an infinite number of times with i = j = 0.

permutations(chars, j+1)

No. This would only print some permutations. For example, for [“c”, “a”, “t”] only [“c”, “a”, “t”] and [“a”, “c”, “t”].

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))$

Yes. This algorithm recursively tries to find number in only one half or the input array, so it performs a maximum $\lfloor\log_2(n)\rfloor + 1$ calls to the function search. The number of operations involved in search other than the recursive call is constant.

$O(n)$

No. The runtime of this algorithm is asymptotically much faster than $O(n)$ because the number of comparisons done to find number, in the worst case, is proportional to $\log(n)$ which is smaller than $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])

No. This code introduces an error if array_2 has more elements than array_1. In addition, it doesn't prevent intersected from having repeated elements and can make it contain less elements than it should.

already_added.add(array_2[j])

Yes. array_2[j] needs to be added to already_added to prevent it from being repeated in intersected.

already_added.add(array_1[i])

No. This code adds the last element of array_1 to already_added. This action doesn't prevent intersected from having repeated elements and can make it contain less elements than it should.

already_added.add(array_2[i])

No. When this code runs, i = len(array_1) - 1. Thus, this code can produce an error if array_2 has less elements than array_1. In addition, it doesn't prevent intersected from having repeated elements and can make it contain less elements than it should.

Other tests include machine learning, deep learning, data science, mathematics, and software engineering.

Data scientists carry out data engineering, modeling, and business analysis tasks. They demonstrate solid scientific foundations as well as business acumen (see figure above). Communication skills are usually required, but the level depends on the team.

Data analysts carry out data engineering and business analysis tasks as shown in the figure above. Their skills complement those of people who train models, deploy them, and build software infrastructure. They demonstrate solid analytical skills as well as business acumen. They are accomplished in query languages such as SQL and commonly use spreadsheet software tools. However, they don’t need algorithmic coding skills. Communication skills are usually required, but the level depends on the team.

Machine learning engineers carry out data engineering, modeling, and deployment tasks. They demonstrate solid scientific and engineering skills (see figure above). Communication skills requirements vary among teams.

Deep learning engineers carry out data engineering, modeling, and deployment tasks. They demonstrate solid scientific and engineering skills. Communication skills requirements vary among teams. This role is a variant of machine learning engineer. It requires deep learning skills in addition to the skills profile presented in the figure above.

People who have the title software engineer-machine learning carry out data engineering, modeling, deployment and AI infrastructure tasks. They demonstrate solid engineering skills and are developing scientific skills. Communication skills requirements vary among teams. This role is a variant of software engineer-machine learning. It requires deep learning skills in addition to the skills profile presented in the figure above.

Software engineer carry out data engineering and AI infrastructure tasks. They work well with people in charge of modeling, deployment, business analyses. Software engineers demonstrate outstanding coding and software engineering skills (see figure above). Communication skills requirements vary among teams.

Machine learning researchers carry out data engineering and modeling tasks. They demonstrate outstanding scientific skills (see figure above). Communication skills requirements vary among teams.

Deep learning researchers carry out data engineering and modeling tasks. They demonstrate outstanding scientific skills (see figure above). Communication skills requirements vary among teams. This role is a variant of machine learning researcher. It requires deep learning skills in addition to the skills profile presented in the figure above.

Preparing for the algorithmic coding test