---

Everything You Need to Know About Counting Bits in Ballerina

To count the number of set bits (1s) in a number's binary representation using Ballerina, you can create a loop that iteratively checks the number. In each iteration, use the modulo operator (number % 2) to check the last bit and a right bit shift (or integer division) to discard it, incrementing a counter until the number becomes zero.

Have you ever looked at a simple number on your screen, like 867, and wondered what it truly represents deep down in the machine's core? It's not just three digits; it's a sequence of electrical on/off switches, a pattern of 1s and 0s. Understanding and manipulating these individual bits is a fundamental skill that separates a good programmer from a great one, especially in performance-critical applications.

Many developers feel a sense of unease when faced with tasks involving bitwise operations. It can seem like a cryptic, low-level world far removed from the high-level abstractions we work with daily. But what if you could master this skill with a simple, elegant approach? This guide will walk you through the "Eliud's Eggs" problem from the exclusive kodikra.com learning curriculum. We'll demystify the process of counting set bits, providing you with a powerful tool for your programming arsenal, all within the modern, cloud-native context of Ballerina.

---

What is Bit Counting (Hamming Weight)?

At its heart, bit counting is the process of determining how many '1's exist in the binary representation of a given number. In computer science and information theory, this count has a formal name: Hamming weight or population count (popcount). It's a measure of the "weight" or "distance" of a binary string from a string of all zeros.

For example, let's take the decimal number 13. To find its Hamming weight, we first need to convert it to its binary form.

• The number 13 in binary is 1101.
• Now, we simply count the number of 1s: 1101.
• There are three 1s. Therefore, the Hamming weight of 13 is 3.

This concept seems simple, but its applications are vast and crucial. The challenge, as presented in the kodikra module, is to perform this calculation manually without relying on any built-in library functions like Integer.bitCount() that might exist in other languages. This forces you to understand the underlying mechanics, which is an invaluable learning experience.

---

Why is Counting Bits a Critical Skill?

You might wonder why you'd ever need to count bits manually when modern hardware and libraries are so powerful. The answer lies in efficiency, control, and a deeper understanding of data structures. Mastering this skill unlocks capabilities in several advanced domains.

• Cryptography: Many cryptographic algorithms rely on bitwise operations for data scrambling, key generation, and implementing functions like XOR ciphers. The properties of binary data, including Hamming weight, are fundamental to ensuring security and randomness.
• Error Detection and Correction: In data transmission, Hamming distance (the number of positions at which corresponding bits are different) is used to detect and correct errors. Calculating this often involves XORing two bitstrings and then finding the Hamming weight of the result.
• Data Compression: Algorithms like Huffman coding and run-length encoding often analyze the bit-level patterns in data. Efficiently counting and manipulating bits can lead to better compression ratios.
• Bioinformatics: When comparing massive DNA sequences, researchers might represent them as bit arrays. Finding similarities and differences can be accelerated by calculating the Hamming weight of the resulting bitmasks.
• Database Systems: High-performance databases sometimes use bitmap indexes, where a bit vector represents the presence or absence of a particular property for a set of records. Querying this data involves rapid bit counting to determine how many records match a criterion.

By learning to solve this problem, you're not just solving a puzzle; you're building a foundational block for tackling complex, real-world engineering challenges.

---

How to Count Bits in Ballerina: The Core Logic

Our goal is to create a Ballerina function, let's call it eggCount, that takes an integer and returns the number of set bits. We'll use a simple and intuitive algorithm based on two core arithmetic operations: modulo and division.

The strategy is as follows:

1. Initialize a count variable to 0.
2. Take the input number and enter a loop that continues as long as the number is greater than 0.
3. Inside the loop, check if the number is odd. We can do this by checking if number % 2 equals 1. If it is, it means its last (least significant) bit is a 1, so we increment our count.
4. After checking, we need to get rid of the last bit to inspect the next one. We achieve this by performing an integer division of the number by 2 (number = number / 2). This effectively performs a "right bit shift."
5. The loop repeats until the number becomes 0, at which point we have checked all the bits.
6. Finally, return the total count.

Visualizing the Logic Flow

Here is an ASCII art diagram illustrating the step-by-step flow of our algorithm for an input like 13 (binary 1101).

    ● Start (number = 13, count = 0)
    │
    ▼
  ┌──────────────────┐
  │ Loop: number > 0?│ (13 > 0 is True)
  └─────────┬────────┘
            │
            ▼
    ◆ Is number % 2 == 1?
   ╱      (13 % 2 == 1 is True)
  Yes
  │
  ▼
┌──────────────────┐
│ count = count + 1│ (count becomes 1)
└─────────┬────────┘
          │
          ▼
┌──────────────────┐
│ number = number/2│ (number becomes 6)
└─────────┬────────┘
          │
          └───────────────────────────┐
                                      │
    ● Next Iteration (number = 6, count = 1)
    │                                 │
    ▼                                 │
  ┌──────────────────┐                │
  │ Loop: number > 0?│ (6 > 0 is True)│
  └─────────┬────────┘                │
            │                         │
            ▼                         │
    ◆ Is number % 2 == 1?             │
   ╱      (6 % 2 == 1 is False)       │
  No ────────────────────────┐        │
                             │        │
                             ▼        │
┌──────────────────┐       ┌─────────┴─────────┐
│ number = number/2│       │ Loop: number > 0? │ (1 > 0 is True)
└─────────┬────────┘       └─────────┬─────────┘
          │                          │
          ▼                          ▼
    ● (number becomes 3)   ◆ Is number % 2 == 1?
                               (1 % 2 == 1 is True)
                               Yes
                               │
                               ▼
                             ┌──────────────────┐
                             │ count = count + 1│ (count becomes 3)
                             └─────────┬────────┘
                                       │
                                       ▼
                             ┌──────────────────┐
                             │ number = number/2│ (number becomes 0)
                             └─────────┬────────┘
                                       │
                                       ▼
                             ┌──────────────────┐
                             │ Loop: number > 0?│ (0 > 0 is False)
                             └─────────┬────────┘
                                       │
                                       ▼
                                   ● End (return count: 3)

The Ballerina Solution

Now, let's translate this logic into clean, executable Ballerina code. This solution is designed for clarity and directly implements the algorithm described above.

import ballerina/io;

// This function calculates the Hamming weight (number of set bits)
// for a non-negative integer, as required by the kodikra.com module.
//
// # Parameters
// + number - The non-negative integer to analyze.
//
// # Returns
// The total count of '1' bits in the number's binary representation.
public function eggCount(int number) returns int {
    // According to the problem's constraints, we typically handle
    // non-negative integers. A robust production function might
    // raise an error for negative inputs.
    if number < 0 {
        io:println("Warning: Input is negative. This function is designed for non-negative integers.");
        return 0;
    }

    int bitCounter = 0;
    int processingNumber = number;

    // The loop continues as long as there are bits left to check.
    // When the number becomes 0, all its '1' bits have been shifted out.
    while processingNumber > 0 {
        // Step 1: Check the least significant bit (LSB).
        // The modulo operator (%) gives the remainder of a division.
        // For division by 2, the remainder is 1 if the number is odd, and 0 if even.
        // An odd number always has its LSB as '1'.
        if processingNumber % 2 == 1 {
            bitCounter = bitCounter + 1;
        }

        // Step 2: Discard the LSB we just checked.
        // Integer division by 2 effectively performs a logical right bit shift.
        // For example, 13 (1101) divided by 2 is 6 (0110).
        processingNumber = processingNumber / 2;
    }

    return bitCounter;
}

// Main function to demonstrate the usage and test a few cases.
public function main() {
    int number1 = 13; // Binary: 1101
    int result1 = eggCount(number1);
    io:println("The number of set bits in ", number1, " is: ", result1); // Expected: 3

    int number2 = 16; // Binary: 10000
    int result2 = eggCount(number2);
    io:println("The number of set bits in ", number2, " is: ", result2); // Expected: 1

    int number3 = 255; // Binary: 11111111
    int result3 = eggCount(number3);
    io:println("The number of set bits in ", number3, " is: ", result3); // Expected: 8
}

Detailed Code Walkthrough

Let's dissect the eggCount function line by line to ensure every part is crystal clear.

1. public function eggCount(int number) returns int { ... }
   This defines a public function named eggCount that accepts one parameter, number of type int, and is declared to return a value of type int. In Ballerina, int represents a 64-bit signed integer.
2. if number < 0 { ... }
   This is a guard clause. The classic bit counting problem is defined for non-negative integers. This check ensures that if a negative number is passed, we handle it gracefully by returning 0, preventing unexpected behavior from the loop.
3. int bitCounter = 0;
   We initialize our accumulator. This variable will store the final count of '1' bits.
4. int processingNumber = number;
   It's good practice to work with a copy of the input parameter rather than modifying it directly. This preserves the original input value for any potential future use within the function.
5. while processingNumber > 0 { ... }
   This is the heart of our algorithm. The loop will execute as long as processingNumber is not zero. Once it becomes zero, it means all bits have been shifted out and processed.
6. if processingNumber % 2 == 1 { ... }
   Here, we inspect the least significant bit (LSB). If a number is odd, its binary representation must end in a '1'. The modulo operator is a perfect and highly readable way to check for oddness. If the condition is true, we found a set bit.
7. bitCounter = bitCounter + 1;
   Upon finding a set bit, we increment our counter.
8. processingNumber = processingNumber / 2;
   This is the crucial step that moves us along the binary string. Integer division by 2 discards the remainder, which is equivalent to shifting all bits one position to the right. For example, binary 1101 (13) becomes 0110 (6). The LSB is discarded, and the next bit moves into the LSB position, ready for the next iteration's check.
9. return bitCounter;
   After the loop terminates, bitCounter holds the total count of all the '1's we found, and we return it as the function's result.

---

Pros and Cons of the Modulo-Division Method

Every algorithm has its trade-offs. Understanding them is key to making informed decisions as an engineer. This simple approach is excellent for learning but has limitations.

Pros	Cons
Highly Readable: The logic is straightforward and easy for any developer to understand. It uses basic arithmetic, avoiding cryptic bitwise operators.	Inefficient for Sparse Numbers: The loop runs for every bit in the number up to the most significant '1'. For a number like 2^60 (a 1 followed by 60 zeros), the loop still runs 61 times.
No External Libraries: It's a self-contained solution that relies only on the language's most fundamental features.	Slower than Bitwise Operations: Division and modulo operations can be computationally more expensive than direct bitwise operations like AND (&) and bit shifts (>>).
Portable Logic: The exact same algorithm can be implemented in virtually any programming language (C, Python, Java, JavaScript, etc.) with minimal changes.	Not the Fastest Known Method: More advanced algorithms, like the one we'll see next, can significantly outperform this method.

---

An Advanced Alternative: Brian Kernighan's Algorithm

For those seeking more performance, there's a famously clever algorithm attributed to Brian Kernighan. Its genius lies in a simple bitwise trick that makes the loop run exactly as many times as there are set bits, no more.

The core of the algorithm is the expression: n & (n - 1).

This operation has a fascinating property: it always unsets (turns to 0) the least significant '1' bit of the number n. Let's see it in action with n = 12 (binary 1100):

• n is 1100 (12)
• n - 1 is 1011 (11)
• n & (n - 1) is 1100 & 1011 which results in 1000 (8).

Notice how the rightmost '1' in 1100 was flipped to '0'. By repeatedly applying this operation and counting how many times we can do it before the number becomes 0, we get the Hamming weight.

Visualizing Brian Kernighan's Algorithm

This flow is much more direct, as it jumps from one set bit to the next, ignoring all the zeros in between.

    ● Start (number = 13, count = 0)
    │         (binary 1101)
    ▼
  ┌──────────────────┐
  │ Loop: number > 0?│ (13 > 0 is True)
  └─────────┬────────┘
            │
            ▼
  ┌──────────────────┐
  │ count = count + 1│ (count becomes 1)
  └─────────┬────────┘
            │
            ▼
  ┌──────────────────┐
  │ n = n & (n - 1)  │ (13 & 12 -> 1101 & 1100 = 1100)
  └─────────┬────────┘ (number becomes 12)
            │
            └───────────┐
                        │
    ● Next Iteration (number = 12, count = 1)
    │                   (binary 1100)
    ▼
  ┌──────────────────┐
  │ Loop: number > 0?│ (12 > 0 is True)
  └─────────┬────────┘
            │
            ▼
  ┌──────────────────┐
  │ count = count + 1│ (count becomes 2)
  └─────────┬────────┘
            │
            ▼
  ┌──────────────────┐
  │ n = n & (n - 1)  │ (12 & 11 -> 1100 & 1011 = 1000)
  └─────────┬────────┘ (number becomes 8)
            │
            └───────────┐
                        │
    ● Next Iteration (number = 8, count = 2)
    │                   (binary 1000)
    ... and so on, until number becomes 0.
    The loop runs 3 times for the 3 set bits.

Ballerina Implementation of Kernighan's Method

Here is how you would implement this more efficient version in Ballerina. Note the use of the bitwise AND operator &.

// An optimized version using Brian Kernighan's algorithm.
// The loop iterates only as many times as there are set bits.
public function eggCountOptimized(int number) returns int {
    if number < 0 {
        return 0;
    }

    int count = 0;
    int currentNumber = number;

    while currentNumber > 0 {
        // This clever trick unsets the rightmost '1' bit.
        currentNumber = currentNumber & (currentNumber - 1);
        
        // Since we successfully unset a '1' bit, we increment the count.
        count = count + 1;
    }

    return count;
}

This version is often preferred in performance-sensitive code due to its efficiency, especially for numbers with few set bits (sparse numbers).

---

Frequently Asked Questions (FAQ)

1. What is the binary representation of a number?

The binary numeral system is a base-2 system that represents numeric values using only two symbols: 0 and 1. Each digit is referred to as a bit. Computers use this system at their most fundamental level for storing and processing data.

2. Why can't I use a built-in bit count function for this kodikra module?

The goal of this specific module in the kodikra.com learning path is to build your foundational understanding of how numbers work at the bit level. By implementing the logic yourself, you gain a much deeper appreciation for the underlying mechanics than you would by simply calling a pre-built function.

3. How does the modulo operator (%) help in counting bits?

The modulo operator (%) gives you the remainder of a division. When you calculate number % 2, the result is 1 if the number is odd and 0 if it's even. In binary, a number is odd if and only if its last bit (the least significant bit) is 1. This makes it a perfect tool for inspecting the last bit.

4. What's the difference between integer division and bitwise right shift for this problem?

For non-negative integers, integer division by 2 (n / 2) and a logical right bit shift by one place (n >> 1) produce the exact same result. The bit shift operation is often closer to the machine instruction and can be marginally faster, but the division approach is sometimes considered more readable by those less familiar with bitwise operators.

5. Is the provided solution efficient for negative numbers?

The solutions provided are designed for non-negative integers. Negative numbers in most languages (including Ballerina) are represented using a format called Two's Complement. Applying these algorithms directly to a negative number would produce a count of bits in its two's complement representation, which might be very large and is usually not the intended behavior for this type of problem.

6. What is Hamming Weight again?

Hamming weight is the formal academic and industry term for the number of symbols that are different from the zero-symbol of the alphabet used. For binary numbers, it's simply the count of '1's in the binary string. It's also known as population count or popcount.

7. Can this logic be applied to other programming languages?

Absolutely. The core logic of both the modulo-division method and Brian Kernighan's algorithm is language-agnostic. You can implement these same patterns in Python, Java, C++, JavaScript, Go, Rust, and almost any other imperative programming language with minimal syntax changes.

---

Conclusion: From Bits to Mastery

We've journeyed from a simple integer to its fundamental binary core, learning not just one, but two robust methods for counting set bits in Ballerina. The modulo-division approach provided a clear, readable entry point, while Brian Kernighan's algorithm offered a glimpse into the world of clever, performance-oriented bitwise optimizations.

Mastering concepts like bit manipulation is what empowers you to write highly efficient code, understand data at its lowest level, and tackle complex problems in fields like cryptography and systems programming. The "Eliud's Eggs" challenge is more than just a puzzle; it's a gateway to a deeper, more profound understanding of software engineering.

Disclaimer: The code and explanations in this article are based on Ballerina Swan Lake 2201.x.x. While the fundamental computer science principles are timeless, specific language features may evolve. Always refer to the official Ballerina documentation for the latest standards.

Ready to continue your journey and tackle the next challenge? Keep progressing through the Ballerina learning roadmap on kodikra.com. For a broader overview of the language, don't forget to check out our complete Ballerina language guide.

---

Published by Kodikra — Your trusted Ballerina learning resource.