Line Up in Arturo: Complete Solution & Deep Dive Guide

From 1 to 1st: The Ultimate Guide to Ordinal Number Formatting in Arturo

Learn to convert integers into ordinal numbers (1st, 2nd, 3rd, 4th) in Arturo. This guide covers the logic for handling special cases like 11th, 12th, and 13th, using modulo arithmetic and conditional statements to format strings correctly for any given name and number.

You've just built a sleek new feature—a leaderboard for your application. The data is flowing in, the rankings are correct, but something feels off. Displaying "UserA is rank 1" and "UserB is rank 2" is functional, but it lacks the professional polish of "UserA is rank 1st" and "UserB is rank 2nd". This seemingly small detail in string formatting is a common hurdle for developers. How do you programmatically add the correct "st", "nd", "rd", or "th" suffix to a number, especially when accounting for tricky exceptions like 11th, 12th, and 13th?

This challenge, a core part of the kodikra.com learning curriculum, isn't just about strings; it's a perfect exercise in mastering conditional logic and arithmetic operators. In this comprehensive guide, we will dissect this problem from the ground up using the elegant and expressive Arturo programming language. We'll explore the logical flow, build a robust solution, and provide a line-by-line explanation, ensuring you not only solve the problem but deeply understand the principles behind it. By the end, you'll be able to handle any ordinal number conversion with confidence.

What Exactly Are Ordinal Numbers?

Before diving into the code, it's crucial to establish a clear understanding of the core concept. In linguistics and mathematics, numbers come in two primary forms: cardinal and ordinal.

Cardinal Numbers: These are the numbers you use for counting. They answer the question "How many?". Examples include one (1), two (2), five (5), and one hundred (100). They represent quantity.
Ordinal Numbers: These numbers indicate position, rank, or order within a sequence. They answer the question "Which one?". Examples include first (1st), second (2nd), fifth (5th), and one hundredth (100th). They represent position.

In programming, especially when building user interfaces, reports, or any text-based output, the distinction is vital. Simply printing a cardinal number where an ordinal is expected can make an application feel unpolished or even confusing to the end-user. The task is to create a function that can programmatically bridge this gap, converting a cardinal integer into its proper ordinal string representation.

The Rules of the Game

The logic for determining the correct suffix isn't arbitrary. It follows a specific set of rules in English:

Numbers ending in 1 receive an "st" suffix (e.g., 1st, 21st, 31st).
Numbers ending in 2 receive an "nd" suffix (e.g., 2nd, 22nd, 42nd).
Numbers ending in 3 receive an "rd" suffix (e.g., 3rd, 23rd, 53rd).
All other numbers receive a "th" suffix (e.g., 4th, 9th, 20th).

However, there's a critical exception to these rules: the "teen" numbers. Numbers ending in 11, 12, and 13 uniformly use the "th" suffix. This means 11 becomes 11th (not 11st), 12 becomes 12th (not 12nd), and 13 becomes 13th (not 13rd). This exception must be handled with priority in our logic.

Why is This Logic So Important in Modern Development?

This might seem like a simple academic exercise, but the logic behind ordinal number formatting is incredibly practical and appears in numerous real-world applications. Mastering this concept in Arturo or any language is a building block for creating more dynamic, human-readable, and professional software.

Real-World Use Cases:

Leaderboards & Rankings: The most obvious application. Displaying a player's rank as "1st Place" is standard in gaming and competitive platforms.
Queueing Systems: Notifying a user, "You are the 3rd person in the queue," provides clear and natural feedback.

Calendars and Date Formatting:

Search Engine Results Pages (SERPs): Pagination often uses text like, "You are on the 2nd page of results."
Automated Reporting: Generating reports that might state, "The 4th quarter showed the highest growth," requires this logic.
User Onboarding: A welcome message could say, "Congratulations, you are our 1000th user!"

In essence, any time a program needs to communicate a position or rank in a sequence to a human, ordinal number logic is the key to doing it effectively. It's a fundamental aspect of creating a great user experience (UX).

How to Build the Ordinal Suffix Logic in Arturo

Now, let's translate the rules into a concrete algorithm and then into Arturo code. The key is to handle the exceptions first. Our logical flow must prioritize the "teen" numbers (11, 12, 13) before applying the general rules for the last digit.

The Logical Algorithm

To determine the suffix for any given number, we will use modulo arithmetic. The modulo operator (% in Arturo and many other languages) gives us the remainder of a division. This is perfect for isolating the last one or two digits of a number.

Check the "Teens" Exception: First, check if the last two digits of the number form 11, 12, or 13. We can do this by calculating number % 100. If the result is 11, 12, or 13, the suffix is always "th".
Check the Last Digit: If the number is not a "teen" exception, we then proceed to check its last digit. We can get the last digit by calculating number % 10.
Apply General Rules:
- If the last digit is 1, the suffix is "st".
- If the last digit is 2, the suffix is "nd".
- If the last digit is 3, the suffix is "rd".
The Default Case: If none of the above conditions are met, the suffix is "th".

This top-down approach ensures that a number like 112 is correctly identified as "112th" (because `112 % 100` is 12, which triggers the "teen" rule) and that 21 is correctly identified as "21st" (because `21 % 100` is not a teen, so we check `21 % 10`, which is 1).

Visualizing the Logic Flow

Here is an ASCII art diagram that illustrates our decision-making process. This vertical flow shows how we prioritize the exception case before moving to the general rules.

    ● Start with a number (e.g., 22)
    │
    ▼
  ┌──────────────────────┐
  │ Get last two digits  │
  │ `number % 100`       │
  └──────────┬───────────┘
             │
             ▼
    ◆ Is it 11, 12, or 13?
   ╱                       ╲
  Yes (e.g., 112 -> 12)     No (e.g., 22 -> 22)
  │                         │
  ▼                         ▼
┌───────────┐         ┌───────────────────┐
│ Suffix is │         │ Get last digit    │
│  "th"     │         │ `number % 10`     │
└───────────┘         └─────────┬─────────┘
  │                             │
  └───────────┐                 ▼
              │            ◆ Case for last digit?
              │           ╱         │         ╲
              │       is 1?      is 2?       is 3?
              │         │           │           │
              │         ▼           ▼           ▼
              │      [Suffix]    [Suffix]    [Suffix]
              │       "st"        "nd"        "rd"
              │         │           │           │
              └───────┬─┴───────────┴──┬────────┘
                      │                │
                      ▼                ▼
                  [Combine]         Default Case
                                       │
                                       ▼
                                    [Suffix]
                                      "th"

Where to Implement: The Complete Arturo Solution

With our logic defined, we can now implement it within a reusable Arturo function. The kodikra module asks us to create a function that takes a name and a number, and returns a complete, formatted sentence. We will name our main function lineUp.

First, let's create a helper function specifically for getting the ordinal suffix. This promotes code modularity and readability.

Step 1: The `getOrdinalSuffix` Helper Function

This function will encapsulate the core logic we just designed. It takes one argument, a number, and returns the correct two-letter suffix string.


; getOrdinalSuffix [number] -> string
; A helper function to determine the correct ordinal suffix ("st", "nd", "rd", "th")
; for a given integer. It correctly handles the special cases for 11, 12, and 13.
getOrdinalSuffix: function [num][
    ; First, handle the special 'teen' cases (11, 12, 13) which always end in 'th'.
    ; We use modulo 100 to check the last two digits.
    if or? or? num % 100 = 11 num % 100 = 12 num % 100 = 13 [
        return "th"
    ]

    ; If not a 'teen' exception, use a 'case' statement on the last digit (modulo 10).
    ; This is a clean way to handle multiple conditions.
    case num % 10 [
        1 -> return "st"
        2 -> return "nd"
        3 -> return "rd"
        else -> return "th" ; Default case for all other numbers (0, 4, 5, 6, 7, 8, 9)
    ]
]

Step 2: The Main `lineUp` Function

Now, we'll create the primary function as required by the kodikra module. This function will call our helper to get the suffix and then use Arturo's powerful string interpolation to construct the final sentence.


; Import the 'getOrdinalSuffix' function if it's in a separate file.
; For this example, we assume it's in the same scope.

; lineUp [name, number] -> string
; Constructs a sentence using a name and an ordinal number.
; Example: "Mary", 1 -> "Mary, you are the 1st customer we serve today. Thank you!"
lineUp: function [name, number][
    ; 1. Get the correct ordinal suffix by calling our helper function.
    suffix: getOrdinalSuffix number

    ; 2. Construct the final sentence using string interpolation.
    ; Arturo's `~` syntax with `|...|` placeholders is clean and readable.
    sentence: ~"|name|, you are the |number||suffix| customer we serve today. Thank you!"

    ; 3. Return the fully constructed sentence.
    return sentence
]

; --- Example Usage ---
; Let's test our function with various inputs to verify the logic.

print lineUp "Mary" 1        ; Expected: Mary, you are the 1st...
print lineUp "David" 2       ; Expected: David, you are the 2nd...
print lineUp "Susan" 3       ; Expected: Susan, you are the 3rd...
print lineUp "Peter" 4       ; Expected: Peter, you are the 4th...
print lineUp "John" 11       ; Expected: John, you are the 11th...
print lineUp "Jane" 12       ; Expected: Jane, you are the 12th...
print lineUp "Alex" 13       ; Expected: Alex, you are the 13th...
print lineUp "Chris" 21      ; Expected: Chris, you are the 21st...
print lineUp "Zoe" 112       ; Expected: Zoe, you are the 112th...

Running the Code

To execute this Arturo script, save the code into a file named lineup_solution.art. Then, open your terminal and run the following command:


arturo lineup_solution.art

The output will be a series of formatted sentences, confirming that our logic correctly handles all cases, including the tricky "teen" numbers and numbers ending in 1, 2, and 3.

Detailed Code Walkthrough

Understanding what the code does is good, but understanding why it does it that way is better. Let's break down the key components of our solution.

The `getOrdinalSuffix` Function

getOrdinalSuffix: function [num][ ... ]: This defines a function named getOrdinalSuffix that accepts a single argument, num.
if or? or? num % 100 = 11 num % 100 = 12 num % 100 = 13 [ ... ]: This is the most critical line. In Arturo, logical operators like or? are prefix functions. This line reads as: "if (num % 100 equals 11) OR (num % 100 equals 12) OR (num % 100 equals 13)". This structure efficiently checks for all three "teen" exceptions at once. If this condition is true, we immediately return "th" and the function stops executing.
case num % 10 [ ... ]: If the "teen" check fails, we move to the case statement. This is Arturo's equivalent of a switch statement in other languages. It evaluates the expression num % 10 (the last digit of the number).
1 -> return "st": This is a case block. If the result of num % 10 is 1, the function will execute the code after the arrow ->, which is return "st". The same logic applies for 2 -> "nd" and 3 -> "rd".
else -> return "th": The else block in a case statement is the default. If the value doesn't match any of the preceding cases (i.e., it's 0, 4, 5, 6, 7, 8, or 9), this block is executed, returning "th".

The `lineUp` Function

lineUp: function [name, number][ ... ]: Defines our main function, accepting two arguments: name (a string) and number (an integer).
suffix: getOrdinalSuffix number: Here, we call our helper function, passing the number to it. The returned value ("st", "nd", etc.) is stored in a new variable called suffix. This is a great example of code reuse.
sentence: ~"...": This line showcases Arturo's string interpolation. The tilde ~ before the string indicates that it's an interpolated string. Any variable name enclosed in pipes |...| will be replaced by its value. So, |name| becomes the value of the name variable, and |number||suffix| concatenates the number and its suffix directly into the string.
return sentence: The function returns the final, beautifully formatted string.

Alternative Approaches and Considerations

While our solution using a helper function and a case statement is clean and highly readable, there are other ways to approach this problem. Exploring alternatives can deepen your understanding of the language's features.

Alternative: Using a Dictionary (Map)

For the general rules, one could use a dictionary (or map) to store the suffixes for the last digit. This can sometimes feel more declarative.


getOrdinalSuffixAlt: function [num][
    ; Handle the teen exception first, as always.
    if contains? [11 12 13] num % 100 -> return "th"

    ; Define a dictionary for the last-digit suffixes.
    suffixes: #[
        1: "st"
        2: "nd"
        3: "rd"
    ]

    ; Look up the suffix for the last digit.
    ; Use `get` with a default value of "th".
    return get suffixes (num % 10) "th"
]

; --- Example Usage ---
print getOrdinalSuffixAlt 21 ; => st
print getOrdinalSuffixAlt 4  ; => th
print getOrdinalSuffixAlt 11 ; => th

This approach separates the data (the suffixes) from the logic. The get function on the dictionary is particularly useful, as it allows us to provide a default value ("th") if the key (the last digit) is not found. The logic remains the same, but the implementation style is different.

Pros and Cons of Different Approaches

Let's compare our primary solution with the dictionary-based alternative.

Approach	Pros	Cons
`if` / `case` Statement	Extremely readable and follows a clear logical flow. Standard control flow, easily understood by programmers from any background. Very performant for this small number of conditions.	Can become verbose if there were many more rules. Mixes logic and data (the suffix strings) together.
Dictionary / Map Lookup	Separates data (suffixes) from control logic. Can be more concise, especially with a `get` function that has a default value. Easily extensible if more special suffixes were needed.	Slightly higher overhead due to dictionary creation and lookup (negligible here). The logic for handling the default case might be slightly less explicit to a beginner.

Visualizing the Alternative Flow

The alternative approach still prioritizes the "teen" exception, but the subsequent step changes from a multi-way branch (case) to a direct lookup.

    ● Start with a number
    │
    ▼
  ┌──────────────────────┐
  │ Check `number % 100` │
  └──────────┬───────────┘
             │
             ▼
    ◆ In [11, 12, 13]?
   ╱                  ╲
  Yes                  No
  │                    │
  ▼                    ▼
[Suffix: "th"]      ┌──────────────────┐
                     │ Get `number % 10`  │
                     └─────────┬────────┘
                               │
                               ▼
                         ┌────────────────┐
                         │ Lookup in Map: │
                         │ {1:"st", 2:"nd", 3:"rd"}
                         └───────┬────────┘
                                 │
                                 ▼
                          ◆ Key Found?
                         ╱            ╲
                        Yes            No (Default)
                        │              │
                        ▼              ▼
                   [Use Value]    [Use "th"]

Frequently Asked Questions (FAQ)

1. What is the purpose of the modulo operator (%) in this solution?: The modulo operator (%) is essential for isolating the last digits of a number. number % 10 gives us the remainder when divided by 10, which is always the last digit. Similarly, number % 100 gives us the last two digits, which is perfect for checking for the special cases of 11, 12, and 13.
2. Why do 11, 12, and 13 end in "th" instead of "st", "nd", and "rd"?: This is an exception rooted in the history of the English language. The words "eleventh," "twelfth," and "thirteenth" evolved differently from other numbers. Our code must respect these linguistic rules to produce correct output, which is why we check for these cases first before applying the general rules.
3. Can this logic be adapted for other programming languages?: Absolutely. The core algorithm—check for the teen exception, then check the last digit—is language-agnostic. You can implement this same logic in Python, JavaScript, Java, Go, or any other language using their respective syntax for conditional statements and the modulo operator.
4. What happens if I pass a number like 111, 212, or 313 to the function?: Our logic handles these correctly. For 111, 111 % 100 is 11, which triggers the "teen" rule, resulting in "111th". For 212, 212 % 100 is 12, resulting in "212th". For 313, 313 % 100 is 13, resulting in "313th". This demonstrates the robustness of checking the last two digits first.
5. Is there a built-in library in Arturo for handling ordinal numbers?: As of the current version, Arturo's standard library does not include a specific function for ordinal number formatting. This is common for many languages, as it's considered a fundamental logic problem. Building it from scratch, as we've done here, is a valuable exercise from the kodikra learning path.
6. How could I make the output sentence more dynamic or customizable?: You could extend the lineUp function to accept the sentence template as another argument. For example: lineUp: function [name, number, template][ ... ]. This would allow you to reuse the core ordinal logic for many different output formats, making your code even more flexible.
7. What are the limitations of this function?: The function is designed based on the prompt which expects numbers up to 999. However, the logic we've implemented is mathematically sound and works correctly for any positive integer (e.g., 1021st, 5112th) because the modulo arithmetic correctly isolates the last one or two digits regardless of the number's total size.

Conclusion: Beyond Just a Suffix

We began with a simple formatting task and ended with a deep dive into conditional logic, modulo arithmetic, and function design in Arturo. The "Line Up" challenge from the kodikra.com curriculum is a perfect example of how a seemingly minor problem can be a gateway to mastering fundamental programming concepts that are applicable across countless real-world scenarios.

You have not only built a function to generate ordinal numbers but have also practiced writing modular, readable, and robust code. You've seen how to prioritize edge cases, use helper functions to keep your logic clean, and leverage language features like case statements and string interpolation for an elegant solution. These skills are the bedrock of effective software development.

Disclaimer: The code and concepts discussed are based on the latest stable versions of Arturo as of this writing. The core logic, however, is timeless and applicable to future versions and other programming languages.

Ready to apply these skills to new challenges? Continue your journey by exploring the next module in the Arturo Learning Roadmap or deepen your language expertise with our complete Arturo programming guide.

Published by Kodikra — Your trusted Arturo learning resource.

kodikra

Search this blog