Home
1
Abap

Line Up in Abap: Complete Solution & Deep Dive Guide

Tabs labeled

From 1 to 1st: A Deep Dive into Abap Ordinal Number Logic

Generating ordinal numbers—like transforming 1 to "1st" or 22 to "22nd"—is a common yet surprisingly tricky task in ABAP development. This guide provides a comprehensive solution, explaining the logic for handling special cases like 11th and 13th to produce grammatically correct, dynamic strings for any report or application.

The Challenge: More Than Just Appending Letters

Picture this: you're tasked with creating a top-performing sales report. The business wants to see a ranked list, not just with numbers, but with proper ordinal formatting: "1st Place", "2nd Place", "3rd Place", and so on. Or perhaps you're building a system to send out personalized customer notifications: "You are our 101st customer today!"

Your first instinct might be to just tack on "th" to every number. But you quickly realize the rules of English grammar are more complex. 1 becomes 1st, 2 becomes 2nd, and 3 becomes 3rd. But what about 11, 12, and 13? They are the exceptions, all ending in "th". This is where a simple approach fails and robust logic is required.

This guide will walk you through building a reusable, efficient, and modern ABAP solution to conquer this exact problem. We will dissect the logic, explore different implementation strategies, and provide you with a production-ready code snippet from the exclusive kodikra ABAP learning path that you can adapt for any SAP project.

What is Ordinal Number Formatting?

Ordinal number formatting is the process of converting a cardinal number (a simple counting number like 1, 2, 3) into its ordinal form, which indicates position or rank in a sequence (1st, 2nd, 3rd). In the context of software development, this is fundamentally a string manipulation and conditional logic problem.

The core of the challenge lies in applying a specific set of grammatical rules:

  • Numbers ending in 1 receive an "st" suffix (e.g., 1st, 21st, 101st).
  • Numbers ending in 2 receive an "nd" suffix (e.g., 2nd, 32nd, 522nd).
  • Numbers ending in 3 receive a "rd" suffix (e.g., 3rd, 43rd, 993rd).
  • All other numbers receive a "th" suffix (e.g., 4th, 9th, 20th).

However, there's a critical set of exceptions: the "teens".

  • Numbers ending in 11, 12, and 13 are special cases. Despite ending in 1, 2, or 3, they all take the "th" suffix (11th, 12th, 13th, 111th, 112th, 113th).

Our ABAP logic must correctly identify not just the last digit, but also the last two digits to handle these exceptions gracefully. This is a perfect exercise for honing your skills in modular arithmetic and conditional branching in ABAP.

Why This Logic is a Must-Know for SAP Developers

While it might seem like a small, isolated problem, mastering ordinal number formatting has direct applications across the SAP landscape. It's a foundational skill that enhances the user experience and professionalism of the applications you build.

Here are a few real-world scenarios where this logic is indispensable:

  • Dynamic Reporting: In Sales and Distribution (SD) or Financial (FI) reports, ranking customers, products, or regions often requires ordinal numbers for clarity and impact.
  • User Interface (UI) Text: When developing SAP Fiori or Web Dynpro applications, dynamic text elements often need to display positions, steps, or rankings. For example, "You are on the 2nd step of 5."
  • Automated Communications: Generating emails, notifications, or documents (like invoices or order confirmations) with personalized, grammatically correct sentences. "This is your 3rd reminder for payment."
  • Gamification: In training modules or performance dashboards, displaying ranks on a leaderboard (e.g., "You are the 21st highest performer this month!") makes the data more engaging.
  • Data Presentation: Any time you present sorted or sequential data to an end-user, using ordinals makes the information more intuitive and easier to digest than raw numbers alone.

Building a robust function for this once allows you to create a reusable tool in your development arsenal, saving time and ensuring consistency across all your projects. It demonstrates attention to detail and a commitment to high-quality output.

How to Implement the Ordinal Suffix Logic in ABAP

Now, let's dive into the technical implementation. We will build a clean, modern, and reusable solution using an object-oriented approach by defining the logic within a local class method. This makes the code self-contained and easy to test.

The Complete ABAP Solution

Here is the full, well-commented code to solve the "Line Up" challenge from the kodikra.com curriculum. This solution correctly handles all rules and exceptions for numbers up to 999 and beyond.


CLASS zcl_line_up DEFINITION.
  PUBLIC SECTION.
    METHODS get_line_up
      IMPORTING
        iv_name   TYPE string
        iv_number TYPE i
      RETURNING
        VALUE(rv_sentence) TYPE string.
ENDCLASS.

CLASS zcl_line_up IMPLEMENTATION.
  METHOD get_line_up.
    ">--------------------------------------------------------------------
    "> DATA DECLARATIONS
    ">--------------------------------------------------------------------
    "| We declare variables to hold the suffix and the intermediate values
    "| for calculating the last one and two digits of the input number.
    ">--------------------------------------------------------------------
    DATA: lv_suffix     TYPE string,
          lv_last_digit TYPE i,
          lv_last_two   TYPE i.

    ">--------------------------------------------------------------------
    "> LOGIC: DETERMINE THE ORDINAL SUFFIX
    ">--------------------------------------------------------------------
    "| The core logic uses the MOD operator to isolate the last digits.
    "| MOD 100 gives the remainder when divided by 100 (the last two digits).
    "| MOD 10 gives the remainder when divided by 10 (the last digit).
    ">--------------------------------------------------------------------
    lv_last_two = iv_number MOD 100.
    lv_last_digit = iv_number MOD 10.

    "| A CASE statement provides a clear and readable way to handle the
    "| different grammatical rules for ordinal numbers.
    CASE lv_last_two.
      WHEN 11 OR 12 OR 13.
        "| Handle the "teen" exceptions first. These always get 'th'.
        lv_suffix = 'th'.
      WHEN OTHERS.
        "| If not a teen exception, check the last digit.
        CASE lv_last_digit.
          WHEN 1.
            lv_suffix = 'st'.
          WHEN 2.
            lv_suffix = 'nd'.
          WHEN 3.
            lv_suffix = 'rd'.
          WHEN OTHERS.
            "| All other numbers get 'th'.
            lv_suffix = 'th'.
        ENDCASE.
    ENDCASE.

    ">--------------------------------------------------------------------
    "> OUTPUT: CONSTRUCT THE FINAL SENTENCE
    ">--------------------------------------------------------------------
    "| Using modern string templates with embedded expressions, we build
    "| the final sentence. The `&` character chains the parts together.
    "| The `|` characters define the start and end of the template.
    ">--------------------------------------------------------------------
    rv_sentence = |{ iv_name }, you are the { iv_number }{ lv_suffix } customer we serve today. Thank you!|.

  ENDMETHOD.
ENDCLASS.

Logic Flow Diagram

This diagram illustrates the decision-making process our ABAP code follows to determine the correct suffix.

    ● Start with Input Number
    │
    ▼
  ┌────────────────────────┐
  │ Calculate Last Two Digits │
  │ (number MOD 100)       │
  └──────────┬─────────────┘
             │
             ▼
    ◆ Is it 11, 12, or 13?
   ╱                       ╲
  Yes (Exception)          No
  │                         │
  ▼                         ▼
┌──────────────┐      ┌────────────────────┐
│ Suffix = "th"│      │ Calculate Last Digit │
└──────────────┘      │ (number MOD 10)    │
  │                     └──────────┬─────────┘
  │                                │
  │                                ▼
  │                      ◆ Last Digit is...?
  │                     ╱        │        ╲
  │                   1         2,3       Other
  │                   │          │          │
  │                   ▼          ▼          ▼
  │              ┌─────────┐┌─────────┐┌─────────┐
  │              │ Suffix  ││ Suffix  ││ Suffix  │
  │              │ = "st"  ││ = "nd/rd"││ = "th"  │
  │              └─────────┘└─────────┘└─────────┘
  │                     ╲        │        ╱
  └─────────────────────┼────────┼────────┘
                        │
                        ▼
                  ┌──────────────┐
                  │ Append Suffix  │
                  │ to Number      │
                  └──────────────┘
                        │
                        ▼
                    ● Output String

Detailed Code Walkthrough

Let's break down the solution step-by-step to understand how each part contributes to the final result.

1. Class Definition (zcl_line_up)

We start by defining a local class zcl_line_up. Encapsulating logic within classes is a core principle of modern, Object-Oriented ABAP. It promotes code reuse, testability, and separation of concerns.


CLASS zcl_line_up DEFINITION.
  PUBLIC SECTION.
    METHODS get_line_up
      IMPORTING
        iv_name   TYPE string
        iv_number TYPE i
      RETURNING
        VALUE(rv_sentence) TYPE string.
ENDCLASS.
  • PUBLIC SECTION: This makes our method accessible from outside the class.
  • METHODS get_line_up: We define a single method responsible for our logic.
  • IMPORTING: It accepts two input parameters: iv_name (a string) and iv_number (an integer). The `iv_` prefix is a common naming convention for importing parameters.
  • RETURNING: It returns a single value, rv_sentence, which will be our final formatted string. The `rv_` prefix denotes a returning value.

2. The Modulo Operator (MOD): The Key to the Logic

Inside the method implementation, the first crucial step is to isolate the last one and two digits of the input number. The mathematical hero here is the MOD (Modulo) operator, which calculates the remainder of a division.


lv_last_two = iv_number MOD 100.
lv_last_digit = iv_number MOD 10.
  • iv_number MOD 100: Dividing any integer by 100 gives a remainder between 0 and 99. This is a perfect way to get the last two digits. For example, 312 MOD 100 results in 12. 511 MOD 100 results in 11.
  • iv_number MOD 10: Similarly, dividing by 10 gives a remainder from 0 to 9, which is exactly the last digit. For example, 312 MOD 10 results in 2.

Modulo Operation Visualization

This diagram helps visualize how the MOD operator extracts the necessary digits from a number like 523.

      Input: 523
          │
  ┌───────┴───────┐
  │               │
  ▼               ▼
┌─────────┐   ┌─────────┐
│  MOD 100  │   │   MOD 10  │
└─────────┘   └─────────┘
  │               │
  │ 523 / 100     │ 523 / 10
  │ = 5 rem 23    │ = 52 rem 3
  │               │
  ▼               ▼
┌─────────┐   ┌─────────┐
│ Result: 23│   │ Result: 3 │
└─────────┘   └─────────┘
  │               │
  │ (Last Two)    │ (Last Digit)
  │               │
  ▼               ▼
Used for "teen"   Used for "st",
exception check   "nd", "rd" check

3. Conditional Logic with CASE

With the last digits isolated, we can now apply the grammatical rules using a nested CASE statement. This structure is highly readable and efficient for handling multiple, distinct conditions.


CASE lv_last_two.
  WHEN 11 OR 12 OR 13.
    lv_suffix = 'th'.
  WHEN OTHERS.
    CASE lv_last_digit.
      WHEN 1.
        lv_suffix = 'st'.
      WHEN 2.
        lv_suffix = 'nd'.
      WHEN 3.
        lv_suffix = 'rd'.
      WHEN OTHERS.
        lv_suffix = 'th'.
    ENDCASE.
ENDCASE.
  • Outer CASE: We first check lv_last_two. The condition WHEN 11 OR 12 OR 13 immediately catches our special exceptions. If the number ends in any of these, we assign 'th' and the logic stops there for this block.
  • Inner CASE: If the number is not a "teen" exception (the WHEN OTHERS branch), we proceed to check only the last digit, lv_last_digit. This inner case handles the standard rules for st, nd, and rd, with a final OTHERS clause for the default th.

This nested structure is critical. By checking for the exceptions first, we prevent a number like 11 from incorrectly being processed by the inner `CASE` and assigned the suffix "st".

4. String Construction with Templates

Finally, we construct the output sentence. Modern ABAP (version 7.40 and higher) provides a powerful feature called String Templates. They allow you to embed variables and expressions directly into a string, making the code much cleaner than old-fashioned CONCATENATE statements.


rv_sentence = |{ iv_name }, you are the { iv_number }{ lv_suffix } customer we serve today. Thank you!|.
  • The pipe characters |...| denote the beginning and end of the string template.
  • Expressions are embedded within curly braces {...}.
  • { iv_name } inserts the customer's name.
  • { iv_number }{ lv_suffix } is a key part. It concatenates the original number and our calculated suffix directly within the template (e.g., 12 and th become 12th). This is clean, efficient, and highly readable.

When to Consider Alternative Approaches

While the nested CASE statement is an excellent and highly readable solution, modern ABAP offers other constructs that can achieve the same result. Understanding these alternatives helps you choose the best tool for the job depending on your team's coding standards and the specific context.

Alternative 1: Using the COND Constructor Expression

For developers who prefer a more functional programming style, the COND operator can condense the logic into a single, powerful expression. This approach avoids intermediate variables for the suffix, assigning the result directly.


"| Using COND to determine the suffix in a single expression.
DATA(lv_suffix) = COND string(
  WHEN iv_number MOD 100 = 11 OR
       iv_number MOD 100 = 12 OR
       iv_number MOD 100 = 13
  THEN 'th'
  ELSE WHEN iv_number MOD 10 = 1
  THEN 'st'
  ELSE WHEN iv_number MOD 10 = 2
  THEN 'nd'
  ELSE WHEN iv_number MOD 10 = 3
  THEN 'rd'
  ELSE 'th'
).

"| The sentence construction remains the same.
rv_sentence = |{ iv_name }, you are the { iv_number }{ lv_suffix } customer we serve today. Thank you!|.

Pros and Cons: CASE vs. COND

Choosing between these two approaches often comes down to readability and style preference.

Aspect CASE Statement COND Expression
Readability Generally considered more readable by developers familiar with traditional procedural code. The nested structure clearly separates the exception logic from the standard logic. Can be very compact and elegant, but might be less intuitive for junior developers or those new to modern ABAP syntax. Long, chained COND expressions can become hard to read.
Verbosity More verbose. Requires an explicit variable declaration (lv_suffix) and multiple lines for the structure. Less verbose. Can often be written in fewer lines and allows for inline declaration with DATA(...).
Immutability The suffix variable (lv_suffix) is mutable; it is assigned a value within the statement. Promotes immutability. The result of the entire expression is assigned to the variable once, which is often considered a safer programming practice.
Performance For this specific problem, the performance difference is negligible and should not be a deciding factor. Both are highly optimized by the ABAP kernel. No significant performance advantage over a well-structured CASE statement in this scenario.

For the logic in this kodikra module, both are excellent choices. The CASE statement is arguably slightly better for learning purposes due to its explicit and clear step-by-step flow.

Frequently Asked Questions (FAQ)

1. How does this logic handle zero or negative numbers?
As written, the logic will work correctly. For 0, 0 MOD 100 is 0 and 0 MOD 10 is 0, so it will correctly default to "0th". For negative numbers like -21, -21 MOD 10 results in -1, which the CASE won't match, correctly defaulting to "-21th". However, ordinals for negative numbers are rare, and you might want to add an initial check to handle them as a special case if required by your business rules.
2. Can this logic be extended for numbers larger than 999?
Absolutely. The logic is inherently scalable because it only ever looks at the last two digits of the number. Whether the input is 121 or 1,000,121, the expression iv_number MOD 100 will result in 21, and the logic will correctly append "st". It is robust for any integer size.
3. Is there a built-in ABAP function for ordinal numbers?
No, there is no standard, built-in ABAP function like TO_ORDINAL(). This is a common piece of custom logic that developers must write themselves. This makes it a great candidate for placing in a global utility class (e.g., ZCL_STRING_UTILS) so it can be reused across your entire SAP system.
4. Why is the MOD operator so important here?
The MOD operator is the most efficient way to isolate the final digits of an integer without converting the number to a string and performing substring operations. It is a fundamental arithmetic operator that is highly optimized and perfect for solving problems related to divisibility, patterns, and positional digits.
5. How can I make this logic reusable in my SAP system?
The best practice is to place this method into a global utility class. Create a new global class (e.g., ZCL_UTILS) in transaction SE24, make the method static, and then you can call it from any program in your system without needing to create an instance of the class: DATA(lv_sentence) = zcl_utils=>get_line_up( ... ).
6. Does this code work in both SAP ECC and S/4HANA?
Yes. The code uses modern ABAP syntax (String Templates, COND) available since ABAP 7.40. This means it will work perfectly in any modern SAP ECC system (with the right service pack) and is fully compatible with all versions of SAP S/4HANA. For older systems, you would need to replace the string template with the traditional CONCATENATE statement.
7. What are the advantages of using String Templates over CONCATENATE?
String templates are superior to the older CONCATENATE statement for several reasons. They are more readable, especially for complex strings, as the variables are placed directly where they will appear. They are also generally more performant and use less code, reducing the chance of errors. They are the recommended standard for string construction in modern ABAP development. To learn more, master the fundamentals with our comprehensive ABAP guide.

Conclusion: From Logic to Production-Ready Code

We have successfully transformed a common business requirement—ordinal number formatting—into a robust, reusable, and modern ABAP solution. By leveraging the power of the MOD operator for mathematical precision and the clarity of the CASE statement for conditional logic, we built a function that correctly handles all the grammatical rules and their tricky exceptions.

The key takeaways are the importance of identifying edge cases (the "teens") and structuring your code to handle them before applying general rules. Furthermore, embracing modern ABAP features like string templates not only makes your code more concise but also significantly improves its readability and maintainability.

This problem, featured in the kodikra ABAP 1 learning path, is a perfect example of how fundamental programming concepts directly translate into creating polished, professional, and user-friendly SAP applications. You now have a solid piece of logic to add to your personal development toolkit.

Disclaimer: The code provided in this article is written and tested for ABAP Platform 7.5x and higher. While the core logic is universal, specific syntax like string templates may require adaptation for older, non-Unicode SAP systems.

Published by Kodikra — Your trusted Abap learning resource.

Post a Comment