kata-ranks

title: Kata Ranks

slug: /curation/references/kata-ranks

warning

The rank definitions on this page are being updated, and are subject to change at any time.

White (Beginner)

8 Kyu

8 kyu kata are for coders at the beginning of their programming journey. At this level, tasks should only be challenging for users new to coding. For example:

• Defining a function, such as hello world or alternating case.
• Basic variable handling, including skills like type conversion, string manipulation, and array analysis.
• Fixing basic syntax issues.
• Trivial language features, such as basic if/else statements.

7 Kyu

7 kyu kata are tasks for programmers with more experience than total beginners but are still relatively new to computer science.
The kata on this level should generaly test the user's knowledge of the core language and API.

Some notable 7 kyu kata categories include:

• Iterating over arrays, numbers,or strings to return a specified quantity or subset.
• Algorithms that aren't performance-intensive.
• Basic logical, functional, or object-oriented concepts.
• Basic Regular Expressions.

Yellow (Intermediate)

6 Kyu

6 kyu kata represents the start of more complex problems and solutions. At this level, the kata will start to include more advanced algorithmic challenges and more complicated language features. Some examples of these include:

• A grasp of more lengthy descriptions and requirements.
• A complex functional concept or idea.
• Puzzles that some require research or experimentation.
• Basic Real World Design Patterns.
• Algorithms require some thinking, but usually don't expect efficiency.
• Competent use of Regular Expressions.

5 Kyu

5 kyu kata is when tasks start to challenge the programmers' logical reasoning through an increased level of difficulty and skill requirements. At this level, a trainee is expected to have a general grasp of the language they are coding in. 5 kyu kata include tasks requiring:

• Using several complex language concepts to achieve a goal.
• Advanced OOP concepts.
• Complex Design Patterns
• Advanced string manipulation and a strong knowledge of Regular Expressions.

Blue (Advanced)

4 Kyu

4 kyu kata represent experienced programming levels. At this level, the kata begins to take some serious thought to complete. They include tasks that may handle:

• Complex algorithms that require both speed and efficency.
• Advanced design patterns for real world applications
• Problem-solving katas that require thought investment.
• Understanding intricate project requirements.
• Tasks that require research of high-level math equations.

3 Kyu

3 kyu kata represent an advanced understanding of programming and contain tasks and difficulties to parallel the coder's skills. As the complexity of the challenges increases, the solutions to the kata tend to become significantly longer. Such challenges are:

• Performance-heavy tasks utilizing advanced algorithms.
• Ability to implement elaborate requirements in a scalable fashion.
• Programs for solving puzzles and games, such as sudoku or battleship.
• Detailed usage of advanced concepts such as metaprogramming, combinatorics and cryptography.

Purple (Expert)

2 Kyu

2 kyu kata represent a professional programming level. Tasks at these levels start to become mini-projects, as each of the requirements for the main solution becomes challanges of their own. At this level, kata requires a mature understanding of several intricate programming concepts - concepts such as:

• Extreme-performance, efficiency, or math heavy algorithms.
• Engineering complete games and puzzles with tricky or exacting rules and requirements.
• Basic interpreters, parsers, and compilers.
• A mature use of OOP and logic to accomplish a desired goal.

1 Kyu

1 kyu kata represents a general mastery of computer science. Tasks that achieve this level require a significant level of time and thought to complete, as the requirements are both demanding and sophisticated. At this level, kata requires experience, patience, and a wide range of skills ready to solve the problem. They may include concepts such as:

• Thorough performance algorithms that need to quickly untangle a multitude of large data values.
• Advanced games and puzzles that need to be constructed in a detailed fashion.
• Complex interpreters and compilers.
• Implementation of mini-programs with multiple feature requirements.