---

The Complete Guide to Bash Bitwise Operations: Solving the Allergy Score Challenge

Master Bash scripting by solving the classic allergy scoring problem. This guide explains how to use bitwise AND operations and arithmetic to decode an allergy score, determine specific allergies, and list all potential allergens from a single numeric value—a fundamental skill in data manipulation and systems programming.

---

Imagine you're building a health monitoring system or a DevOps tool that needs to manage complex configurations. You receive a single, compact number—a status code, a permissions set, or in our case, a patient's entire allergy profile. How do you efficiently unpack this number into a human-readable list like "allergic to peanuts and shellfish" using only a Bash script? It sounds complex, but it's the perfect showcase for one of computing's most powerful and efficient tools: bitwise operations.

Many developers, especially those working in high-level languages, rarely touch bitwise logic. It can seem arcane or low-level. But in the world of shell scripting, system administration, and performance-critical applications, understanding how to manipulate data at the bit level is a superpower. It allows you to store multiple boolean states (true/false flags) in a single integer, saving space and enabling incredibly fast checks.

This guide will demystify bitwise operations by walking you through a practical, real-world problem from the exclusive kodikra.com curriculum. We will build a complete Bash script from scratch that can decode an allergy score, teaching you a technique that's directly applicable to tasks like interpreting file permissions, managing feature flags, or configuring network protocols.

---

What is the Allergy Scoring Problem?

The core of this challenge lies in a clever data compression technique. Instead of storing a long list of allergies for a person, the system assigns a unique numerical value to each potential allergen. These values aren't sequential (1, 2, 3...); they are powers of two.

Here is the list of allergens and their corresponding values as defined in the kodikra module:

• eggs: 1 (which is 2⁰)
• peanuts: 2 (which is 2¹)
• shellfish: 4 (which is 2²)
• strawberries: 8 (which is 2³)
• tomatoes: 16 (which is 2⁴)
• chocolate: 32 (which is 2⁵)
• pollen: 64 (which is 2⁶)
• cats: 128 (which is 2⁷)

A person's total allergy score is the sum of the values for all the items they are allergic to. For example, if someone is allergic to peanuts (2) and chocolate (32), their total score would be 2 + 32 = 34. The challenge is to take a score like 34 and work backward to determine the original list of allergies.

The Magic of Binary Representation

The choice of powers of two is deliberate and brilliant. In binary, each of these numbers corresponds to a single "on" bit in a specific position. Let's look at the 8-bit binary representation:

• eggs (1): 00000001
• peanuts (2): 00000010
• shellfish (4): 00000100
• strawberries (8): 00001000
• tomatoes (16): 00010000
• chocolate (32): 00100000
• pollen (64): 01000000
• cats (128): 10000000

Notice how each allergen occupies its own unique bit position. When we sum their values, their bits combine without overlapping. A score of 34 (peanuts + chocolate) in binary is 00100010. You can clearly see the bit for chocolate (32) and the bit for peanuts (2) are both set to 1. This structure is what allows us to use bitwise operations to efficiently "query" the score.

---

Why Use Bitwise Operations in Bash?

Bitwise operations work directly on the binary representation of numbers. They are fundamental to low-level programming and are executed extremely quickly by the CPU. For tasks involving flags or sets of boolean states, they are vastly more efficient than alternative approaches.

The key operator for our solution is the Bitwise AND, represented in Bash and many other languages by the ampersand symbol (&). A bitwise AND compares two numbers bit by bit. If both bits in the same position are 1, the resulting bit in that position is 1; otherwise, it's 0.

Let's see how this helps us. To check if a person with a score of 34 is allergic to chocolate (value 32), we perform a bitwise AND:

  00100010  (Score: 34)
& 00100000  (Allergen: chocolate, 32)
-----------------
  00100000  (Result: 32)

The result of the operation is 32 (which is not zero). This non-zero result confirms that the bit for "chocolate" was indeed set in the original score. Therefore, the person is allergic to chocolate.

Now, let's check for an allergy they don't have, like shellfish (value 4):

  00100010  (Score: 34)
& 00000100  (Allergen: shellfish, 4)
-----------------
  00000000  (Result: 0)

The result is 0. This tells us the bit for "shellfish" was not set in the score, meaning no allergy. This simple, lightning-fast check is the foundation of our entire script.

---

How to Implement the Allergy Decoder in Bash

Now, let's translate this logic into a functional Bash script. Our script will be named allergies.sh and will accept two main commands: is_allergic_to and list.

The Complete Bash Solution

Here is the full, well-commented code. We use an associative array (available in Bash 4.0+) for a clean mapping between allergen names and their values.

#!/usr/bin/env bash

# allergies.sh - A script to decode an allergy score using bitwise operations.
# Part of the exclusive kodikra.com learning path.

# Exit immediately if a command exits with a non-zero status.
set -o errexit
# Treat unset variables as an error when substituting.
set -o nounset

# --- Data Structures ---
# Use an associative array to map allergen names to their bitwise values.
# This requires Bash 4.0 or newer.
declare -A ALLERGENS=(
    ["eggs"]=1
    ["peanuts"]=2
    ["shellfish"]=4
    ["strawberries"]=8
    ["tomatoes"]=16
    ["chocolate"]=32
    ["pollen"]=64
    ["cats"]=128
)

# --- Functions ---

# Function to check for a specific allergy.
# Usage: is_allergic_to  
is_allergic_to() {
    local score=$1
    local allergen=$2

    # Check if the provided allergen exists in our map.
    if [[ ! -v "ALLERGENS[$allergen]" ]]; then
        echo "error: invalid allergen '$allergen'" >&2
        exit 1
    fi

    local allergen_value=${ALLERGENS[$allergen]}

    # Perform the bitwise AND operation.
    # In Bash, arithmetic expansion is done inside ((...)).
    if (( (score & allergen_value) != 0 )); then
        echo "true"
    else
        echo "false"
    fi
}

# Function to list all allergies for a given score.
# Usage: list_allergies 
list_allergies() {
    local score=$1
    local result_list=()

    # Iterate through all known allergens.
    # We must sort the keys to ensure a consistent output order.
    for allergen in $(echo "${!ALLERGENS[@]}" | tr ' ' '\n' | sort); do
        local allergen_value=${ALLERGENS[$allergen]}
        
        # Check if the bit for this allergen is set in the score.
        if (( (score & allergen_value) != 0 )); then
            # If it is, add it to our results array.
            result_list+=("$allergen")
        fi
    done

    # Join the array elements with a space for clean output.
    echo "${result_list[*]}"
}

# --- Main Script Logic ---

main() {
    # Ensure at least two arguments are provided.
    if (( $# < 2 )); then
        echo "Usage: $0   [allergen]" >&2
        echo "Commands: is_allergic_to, list" >&2
        exit 1
    fi

    local command=$1
    local score=$2

    # Use a case statement to route to the correct function.
    case "$command" in
        is_allergic_to)
            if (( $# != 3 )); then
                echo "Usage: $0 is_allergic_to  " >&2
                exit 1
            fi
            local allergen_to_check=$3
            is_allergic_to "$score" "$allergen_to_check"
            ;;
        list)
            list_allergies "$score"
            ;;
        *)
            echo "error: unknown command '$command'" >&2
            exit 1
            ;;
    esac
}

# Pass all script arguments to the main function.
main "$@"

Code Walkthrough and Explanation

Let's break down the script section by section to understand its inner workings.

1. Shebang and Script Settings

#!/usr/bin/env bash
set -o errexit
set -o nounset

• #!/usr/bin/env bash: This is the recommended shebang line. It makes the script more portable by finding the bash executable in the user's environment path.
• set -o errexit (or set -e): This is a crucial safety measure. It causes the script to exit immediately if any command fails, preventing unexpected behavior.
• set -o nounset (or set -u): This causes the script to exit if it tries to use an uninitialized variable, helping to catch typos and logic errors.

2. The Allergen Data Structure

declare -A ALLERGENS=(
    ["eggs"]=1
    # ... and so on
)

We use declare -A ALLERGENS to create an associative array. This is like a dictionary or hash map in other languages. It allows us to store key-value pairs, which is perfect for mapping allergen names (strings) to their integer values. This is far more readable and maintainable than managing two separate indexed arrays.

3. The is_allergic_to Function

is_allergic_to() {
    local score=$1
    local allergen=$2
    local allergen_value=${ALLERGENS[$allergen]}

    if (( (score & allergen_value) != 0 )); then
        echo "true"
    else
        echo "false"
    fi
}

This is the heart of the single-allergy check. The most important line is (( (score & allergen_value) != 0 )). In Bash, the double parentheses ((...)) create an arithmetic evaluation context. Inside, we can perform C-style integer arithmetic, including bitwise operations like &. The logic is exactly as we described before: if the bitwise AND is not zero, the flag is set.

4. The list_allergies Function

list_allergies() {
    local score=$1
    local result_list=()

    for allergen in $(echo "${!ALLERGENS[@]}" | tr ' ' '\n' | sort); do
        local allergen_value=${ALLERGENS[$allergen]}
        if (( (score & allergen_value) != 0 )); then
            result_list+=("$allergen")
        fi
    done

    echo "${result_list[*]}"
}

This function iterates through all known allergens and checks each one against the score.

• "${!ALLERGENS[@]}": This special syntax expands to a list of all the keys (allergen names) in our associative array.
• tr ' ' '\n' | sort: We pipe the keys through tr to replace spaces with newlines, and then through sort. This ensures our output is always in a predictable, alphabetical order, which is good practice.
• result_list+=("$allergen"): If an allergy is detected, its name is appended to the result_list array.
• echo "${result_list[*]}": Finally, this prints all elements of the array, separated by spaces.

Running the Script from the Terminal

First, save the code as allergies.sh and make it executable:

$ chmod +x allergies.sh

Now you can test it with various scores and commands:

# Check for a specific allergy (score 34, check for peanuts)
$ ./allergies.sh is_allergic_to 34 peanuts
true

# Check for an allergy that isn't present (score 34, check for eggs)
$ ./allergies.sh is_allergic_to 34 eggs
false

# List all allergies for score 34 (peanuts + chocolate)
$ ./allergies.sh list 34
chocolate peanuts

# List all allergies for score 201 (cats + pollen + strawberries + eggs)
$ ./allergies.sh list 201
cats eggs pollen strawberries

Logic Flow Diagram: Listing All Allergies

This diagram illustrates the process the list_allergies function follows.

    ● Start (Input: score)
    │
    ▼
  ┌───────────────────┐
  │ Initialize Empty  │
  │  `result_list`    │
  └─────────┬─────────┘
            │
            ▼
  ┌───────────────────┐
  │ Get & Sort All    │
  │ Allergen Names    │
  └─────────┬─────────┘
            │
            ▼
    ◆ Loop through each `allergen`?
   ╱           ╲
  Yes           No (End of list)
  │              │
  ▼              ▼
┌─────────────────┐  ┌───────────────────┐
│ Get value for   │  │ Print items in    │
│ current allergen│  │ `result_list`     │
└────────┬────────┘  └─────────┬─────────┘
         │                     │
         ▼                     ▼
   ◆ (score & value) != 0?     ● End
  ╱           ╲
 Yes           No
  │              │
  ▼              │
┌─────────────────┐  │
│ Add `allergen`  │  │
│ to `result_list`├──┘
└─────────────────┘

---

Where Else Is This Logic Used? Beyond Allergies

The pattern of using bits as flags is a cornerstone of systems programming. Once you understand it, you'll see it everywhere.

1. Linux File Permissions

The most classic example is the permission system in Linux/Unix. When you see permissions like 755, you're looking at bit flags in action. Each digit represents three bits for User, Group, and Others.

• Read (r) = 4 (binary 100)
• Write (w) = 2 (binary 010)
• Execute (x) = 1 (binary 001)

A permission of 7 (4+2+1) is 111 in binary, meaning Read, Write, and Execute are all enabled. A permission of 5 (4+1) is 101, meaning Read and Execute are enabled, but Write is not. The chmod command is essentially a tool for manipulating these permission bits.

2. Feature Flags in Software

In large applications, developers use feature flags to enable or disable features for certain users or environments without deploying new code. A single integer in a user's profile could store dozens of flags. A check like if ((user_flags & CAN_EXPORT_PDF)) is an extremely fast way to verify if a user has a specific feature enabled.

3. Network Protocols

In network packets, the header often contains a "flags" field. For example, in the TCP header, flags like SYN, ACK, FIN, and RST are all individual bits within a single byte. Network devices perform bitwise operations to quickly understand the purpose of a packet.

Logic Flow Diagram: Checking a Single Allergy

This diagram shows the simpler, more direct logic of the is_allergic_to function.

    ● Start (Input: score, allergen_name)
    │
    ▼
  ┌───────────────────┐
  │ Look up value for │
  │ `allergen_name`   │
  └─────────┬─────────┘
            │
            ▼
  ┌───────────────────┐
  │ Perform Bitwise   │
  │ `result = score & value` │
  └─────────┬─────────┘
            │
            ▼
    ◆ Is `result` != 0?
   ╱           ╲
  Yes           No
  │              │
  ▼              ▼
┌───────────┐  ┌────────────┐
│ Print "true"│  │ Print "false"│
└───────────┘  └────────────┘
      │              │
      └──────┬───────┘
             ▼
            ● End

---

Pros and Cons of the Bitwise Approach

Like any technique, using bitwise flags has its trade-offs. It's important to understand when it's the right tool for the job.

Pros (Advantages)	Cons (Disadvantages)
Extreme Efficiency: Bitwise operations are single CPU instructions, making them incredibly fast. For performance-critical code, this is a significant benefit.	Limited Scalability: The number of flags is limited by the size of the integer (e.g., 64 flags for a 64-bit integer). Adding a 65th allergen would require a second integer.
Space Conservation: A single 64-bit integer can store 64 distinct boolean (on/off) states, which is far more memory-efficient than an array of 64 booleans or a list of strings.	Poor Readability: A score like `201` is meaningless to a human without the key to decode it. It's not self-descriptive and can make debugging harder if you're looking at raw data.
Atomic Operations: Updating multiple flags can often be done in a single, atomic write operation, which is beneficial in multi-threaded environments to avoid race conditions.	Rigid Structure: The values (1, 2, 4, 8...) are fixed. You cannot easily remove an allergen from the middle of the sequence without re-calculating all existing scores.
Language Agnostic: The concept is universal. An allergy score generated by a C++ backend can be perfectly interpreted by a Bash script, a Python service, or a JavaScript frontend.	Error-Prone for Beginners: It's easy to make mistakes with bitwise logic (e.g., using a logical AND `&&` instead of a bitwise AND `&`) if you're not familiar with it.

For the allergy problem, where we have a small, fixed set of allergens (8 in this case, well within the 64-bit integer limit), the bitwise approach is a perfect fit. It is the canonical and most efficient solution.

---

Frequently Asked Questions (FAQ)

1. What exactly is a bitwise AND operation?

A bitwise AND (&) is an operation that compares two numbers at the binary level. It looks at each pair of corresponding bits. If both bits in a position are 1, the resulting bit in that position is 1. In all other cases (1 and 0, 0 and 1, 0 and 0), the resulting bit is 0. It's a way to create a "mask" to check if specific bits are turned on in a number.

2. Why must the allergy scores be powers of two?

Using powers of two (1, 2, 4, 8, ...) ensures that each allergen corresponds to a unique, single bit in the binary representation. This prevents overlap. If peanuts were 2 and shellfish were 3, a score of 3 could mean "shellfish only" or "peanuts and eggs" (2+1). Using powers of two guarantees that every possible sum of allergen values produces a unique integer, which can be unambiguously decoded.

3. How can I add a new allergen to this script?

It's very straightforward. You simply need to add a new entry to the ALLERGENS associative array. The new value must be the next power of two. Since the highest value currently is cats at 128 (2⁷), the next allergen would have a value of 256 (2⁸). For example: ["mangoes"]=256. The rest of the script's logic will work without any changes.

4. What does declare -A mean in Bash?

The declare -A command is used to explicitly create an associative array in Bash (version 4.0 and newer). Unlike a standard indexed array which uses integers as keys (0, 1, 2...), an associative array allows you to use strings as keys, making it function like a hash map or dictionary.

5. Is there an alternative to bitwise operations for this problem?

Yes, but they are generally less efficient. One common alternative is repeated subtraction. You could start with the largest allergen value (128) and check if it's less than or equal to the score. If it is, you add "cats" to the list and subtract 128 from the score. You then repeat this process with the next largest value (64), and so on, until the score becomes zero. While this works, it involves more complex looping and arithmetic compared to a single, fast bitwise check for each allergen.

6. Why use ((...)) for arithmetic in Bash?

The double-parentheses construct ((...)) is Bash's modern mechanism for arithmetic evaluation. It offers several advantages over older methods like let or expr: it supports C-style syntax (including bitwise operators like &, |, ^), it's generally faster, and it returns an exit code (0 for true, 1 for false) which makes it perfect for use in if statements without needing brackets or the test command.

7. How does this concept relate to Object-Oriented Programming?

In OOP, this pattern is often encapsulated in an `Enum` type that supports flags. For example, in C# or Java, you can define a `[Flags]` enum where each member is assigned a power-of-two value. The language then provides built-in methods (like `HasFlag`) to perform the bitwise checks, offering a more type-safe and readable abstraction over the raw integer values.

---

Conclusion: From Bits to Scripts

We've journeyed from the fundamental theory of binary numbers to a practical, robust Bash script. The allergy scoring problem, while seemingly simple, is a perfect vehicle for teaching the power and elegance of bitwise operations. You've learned not just how to solve this specific challenge from the kodikra learning path, but also a core computer science concept that transcends any single programming language.

The key takeaway is that understanding how data is represented at its lowest level can unlock incredibly efficient and clever solutions. Whether you're a DevOps engineer optimizing a startup script, a systems administrator managing permissions, or a backend developer designing an API, the ability to manipulate bits is a valuable tool in your arsenal. This Bash script demonstrates that even a "simple" shell language has the power to execute these fundamental operations with ease.

Technology Disclaimer: This solution was developed and tested using Bash version 5.2. The use of associative arrays (declare -A) requires Bash version 4.0 or newer. The core bitwise logic, however, is compatible with nearly all versions of Bash.

Ready to tackle the next challenge? Continue your journey through our Bash Learning Roadmap to build on these skills. Or, for a broader overview, explore our complete Bash programming guide.

---

Published by Kodikra — Your trusted Bash learning resource.