---

Arturo Allergies Score: The Complete Guide to Bitwise Logic

Master the art of decoding a numeric allergy score in Arturo using powerful bitwise operations. This comprehensive guide explains how a single integer can efficiently represent multiple allergies, providing a complete solution to map a score to a full list of allergens and mastering a fundamental computer science concept.

Imagine you're building a health application. A requirement comes in: you must store a patient's allergies, but the legacy system provides only a single number, like `25`. How can one number possibly represent allergies to both tomatoes and strawberries, but not peanuts? It feels cryptic, almost like a secret code. This is a classic programming puzzle that stumps many developers, but it hides an elegant and incredibly efficient solution.

This isn't just an abstract problem; it's a gateway to understanding how computers manage complex sets of states—like file permissions, configuration flags, or user roles—using the fundamental language of binary. In this deep-dive tutorial, we will unravel this mystery using the Arturo programming language. You will learn not just how to solve the allergy score challenge from the kodikra.com curriculum, but also grasp the core principles of bitwise logic, a skill that will elevate your problem-solving abilities across any language.

---

What is the Allergy Score Problem?

The allergy score problem is a challenge designed to test a developer's understanding of data representation and bit manipulation. The core idea is that a list of boolean (true/false) states can be encoded into a single integer. Each potential allergen is assigned a unique value that is a power of two.

Here is the standard list of allergens and their associated numeric values as defined in the Kodikra learning path:

• eggs: 1 (2^0)
• peanuts: 2 (2^1)
• shellfish: 4 (2^2)
• strawberries: 8 (2^3)
• tomatoes: 16 (2^4)
• chocolate: 32 (2^5)
• pollen: 64 (2^6)
• cats: 128 (2^7)

The patient's total allergy score is the sum of the values for all items they are allergic to. For example, if a person is allergic to chocolate (32) and peanuts (2), their total score would be `32 + 2 = 34`. The task is to write a program that can take any score and perform two main operations:

1. Determine if a person is allergic to a specific item.
2. Generate a complete list of all allergies for a given score.

This encoding scheme is incredibly efficient. Instead of storing an array of strings or a dictionary of booleans, all the information is packed into a single, compact integer.

---

Why is Bitwise Logic the Perfect Solution?

At first glance, you might think of solving this with complex math, loops, and subtractions. But the real power lies in thinking in binary. Every integer is represented in the computer's memory as a sequence of bits (0s and 1s). The choice of powers of two for allergen values is deliberate and brilliant.

Let's look at the binary representation of our allergen values:

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

Notice a pattern? Each allergen corresponds to a single "on" bit (a `1`) in a unique position. When we sum the values, we are essentially setting multiple bits to `1` in the final score. For a score of `34` (chocolate + peanuts):

  32 (chocolate)  ->  00100000
+  2 (peanuts)    ->  00000010
--------------------------------
= 34 (score)      ->  00100010

This structure makes checking for an allergy incredibly fast. We can use a bitwise AND operation. The AND operator (& in Arturo and many other languages) compares two numbers bit by bit. If both bits in the same position are `1`, the resulting bit is `1`; otherwise, it's `0`.

To check for a "peanuts" (value 2) allergy in a score of 34, we do:

  34 (score)   ->  00100010
&  2 (peanuts)  ->  00000010
--------------------------------
=  2 (result)  ->  00000010

Since the result is not zero, it means the "peanuts" bit was set in the original score. The person is allergic! This is the fundamental concept that makes the bitwise approach the most efficient and elegant solution.

---

How to Implement the Allergy Solution in Arturo

Now, let's translate this theory into a practical, working solution using the Arturo programming language. Arturo's expressive and concise syntax makes it a great tool for this task. We will structure our code into logical parts: data definition, the allergy check function, and the full list generation function.

The Complete Arturo Solution Code

Here is the full, well-commented code. We will break it down in detail in the next section.

#!/usr/bin/env arturo

; Allergies Module from the kodikra.com curriculum
; This script decodes a numeric allergy score to determine a person's allergies.

; Define the allergens and their corresponding bitmask values
; Using a dictionary is a clean way to map string names to integer values.
allergens: #[
    "eggs":         1
    "peanuts":      2
    "shellfish":    4
    "strawberries": 8
    "tomatoes":     16
    "chocolate":    32
    "pollen":       64
    "cats":         128
]

; Function: allergicTo?
; Checks if a given score indicates an allergy to a specific item.
;
; @param score [Integer] The person's total allergy score.
; @param item [String] The name of the allergen to check.
;
; @returns [Boolean] True if allergic, False otherwise.
allergicTo?: function [score, item][
    ; Get the bitmask value for the given item from our dictionary
    itemValue: get allergens item

    ; Perform a bitwise AND operation.
    ; If the result is greater than 0, it means the corresponding bit was set in the score.
    ; The '&' symbol is the bitwise AND operator in Arturo.
    (score & itemValue) > 0
]

; Function: list
; Generates a list of all allergens for a given score.
;
; @param score [Integer] The person's total allergy score.
;
; @returns [Block] A block (Arturo's list/array) of strings representing all allergies.
list: function [score][
    ; 'keys allergens' gets all the allergen names from our dictionary
    ; 'select' iterates over this list and keeps only the items
    ; for which the provided function returns true.
    select keys allergens 'item ->
        allergicTo? score item
]

; --- Example Usage ---

; A person with a score of 34
let patientScore 34

; Check for a specific allergy
print ["Allergic to peanuts? " allergicTo? patientScore "peanuts"]   ; Expected: true
print ["Allergic to cats? " allergicTo? patientScore "cats"]       ; Expected: false

; Get the full list of allergies
print ["Full allergy list for score" patientScore ":" list patientScore] ; Expected: ["peanuts" "chocolate"]

; Another example with a score of 255 (all allergies)
let allAllergiesScore 255
print ["Full allergy list for score" allAllergiesScore ":" list allAllergiesScore]

Running the Code

To execute this script, save it as `allergies.art` and run it from your terminal. Ensure you have Arturo installed on your system.

arturo allergies.art

You should see the following output, confirming our logic is correct:

Allergic to peanuts?  true
Allergic to cats?  false
Full allergy list for score 34 : [peanuts chocolate]
Full allergy list for score 255 : [eggs peanuts shellfish strawberries tomatoes chocolate pollen cats]

---

Where the Magic Happens: A Deep Code Walkthrough

Understanding the code is more important than just copying it. Let's dissect each part of the Arturo script to see how it works and why it's designed this way.

1. Defining the Allergen Data

allergens: #[
    "eggs":         1
    "peanuts":      2
    "shellfish":    4
    "strawberries": 8
    "tomatoes":     16
    "chocolate":    32
    "pollen":       64
    "cats":         128
]

• We start by defining a dictionary (hash map) named allergens. In Arturo, dictionaries are created with the #[...] syntax.
• This data structure is perfect for this problem because it provides a fast and readable way to map the string name of an allergen (e.g., "peanuts") to its integer value (e.g., 2).
• Using a dictionary makes the code self-documenting and easy to extend. If a new allergen needs to be added, we just add a new key-value pair.

2. The allergicTo? Function Logic

This function is the heart of our solution. It performs the core bitwise check.

    ● Start: allergicTo?(score, item)
    │
    ▼
  ┌────────────────────────┐
  │ Get itemValue from     │
  │ 'allergens' dictionary │
  └──────────┬─────────────┘
             │
             ▼
    ┌──────────────────┐
    │ Perform bitwise  │
    │ `score & itemValue`│
    └──────────┬─────────┘
               │
               ▼
    ◆ Is result > 0? ◆
   ╱                  ╲
  Yes                  No
  │                    │
  ▼                    ▼
┌─────────┐         ┌──────────┐
│ Return  │         │ Return   │
│ `true`  │         │ `false`  │
└─────────┘         └──────────┘
  │                    │
  └─────────┬──────────┘
            ▼
         ● End

Let's look at the implementation line by line:

allergicTo?: function [score, item][
    itemValue: get allergens item
    (score & itemValue) > 0
]

• allergicTo?: function [score, item][...]: We define a function named allergicTo? that accepts two arguments: score and item. The question mark at the end is a common convention in many languages for functions that return a boolean value.
• itemValue: get allergens item: This line retrieves the integer value for the given item string from our allergens dictionary. For example, if item is "peanuts", itemValue becomes 2.
• (score & itemValue) > 0: This is the critical line. It performs the bitwise AND operation between the total score and the specific itemValue. The result is then compared to 0. In Arturo, the last expression evaluated in a function is implicitly returned, so this boolean result (true or false) is the function's output.

3. The list Function Logic

This function builds on allergicTo? to generate the complete list of allergies.

    ● Start: list(score)
    │
    ▼
  ┌────────────────────────┐
  │ Get all keys from the  │
  │ 'allergens' dictionary │
  │ e.g., ["eggs", ...]    │
  └──────────┬─────────────┘
             │
             ▼
  ┌────────────────────────┐
  │ For each `item` in keys: │
  ├────────────────────────┤
  │ Call `allergicTo?`     │
  │ with `score` and `item`│
  └──────────┬─────────────┘
             │
             ▼
    ◆ Does it return `true`? ◆
   ╱                       ╲
  Yes                       No
  │                         │
  ▼                         ▼
┌───────────┐           ┌────────┐
│ Keep item │           │ Discard│
│ in list   │           │ item   │
└───────────┘           └────────┘
  │                         │
  └───────────┬─────────────┘
              │
              ▼
  ┌────────────────────────┐
  │ Return the final list  │
  │ of kept items          │
  └──────────┬─────────────┘
             │
             ▼
          ● End

The Arturo implementation is remarkably elegant thanks to its functional programming features.

list: function [score][
    select keys allergens 'item ->
        allergicTo? score item
]

• list: function [score][...]: Defines the function list which takes the total score as its only argument.
• keys allergens: This expression returns a block (Arturo's list type) containing all the keys from the allergens dictionary. The result is ["eggs", "peanuts", "shellfish", ...].
• select ... 'item -> ...: The select function is a higher-order function that iterates over a list (in this case, the list of allergen keys). It takes a function (a lambda) as its second argument.
• 'item -> allergicTo? score item: This is the lambda function. For each item in the list of keys, it calls our allergicTo? function. If allergicTo? returns true, select keeps the item in the final result. If it returns false, the item is discarded.

The result is a new block containing only the names of the allergens for which the bitwise check passed, which is exactly what we need.

---

Alternative Approaches and Performance Considerations

While the bitwise approach is standard and most efficient, it's useful for a developer to consider other methods. This helps in understanding trade-offs in software design. A common alternative is a mathematical approach using division and modulo.

The Mathematical (Non-Bitwise) Approach

You could solve the problem by repeatedly subtracting the largest possible allergen value from the score until the score becomes zero.

; Non-bitwise, mathematical approach (for comparison)
listMath: function [score][
    let remainingScore score
    let result []

    ; Iterate through allergens from largest value to smallest
    let sortedAllergens reverse sort.by: '[,v] -> v items allergens

    loop sortedAllergens 'allergen ->
        let name first allergen
        let value second allergen

        if remainingScore >= value [
            remainingScore: remainingScore - value
            'result ++ name
        ]

    reverse result
]

print ["Math approach for score 34:" listMath 34]

This approach works, but it has several drawbacks compared to the bitwise solution. Let's compare them directly.

Pros & Cons: Bitwise vs. Mathematical

Aspect	Bitwise Approach (&)	Mathematical Approach (-, >=)
Performance	Extremely fast. Bitwise operations are single CPU instructions, making them one of the fastest operations possible.	Slower. Involves looping, comparisons, and arithmetic subtractions, which require more CPU cycles.
Readability	Can be less intuitive for beginners unfamiliar with bit manipulation. However, for experienced developers, it's a clear and standard pattern.	Arguably more readable for those who don't think in binary. The logic of "subtracting the largest part" is easy to follow.
Conciseness	Very concise. The core logic is a single line: (score & itemValue) > 0.	More verbose. Requires managing a remaining score, sorting the allergens, and explicit looping logic.
Scalability	Highly scalable. The check for any single allergy is an O(1) operation, independent of the number of allergens.	Less scalable. The performance of the `list` function depends on the number of allergens to loop through (O(n)).
Idiomatic Solution	This is the idiomatic, canonical solution for this type of problem (flag management).	A valid but non-standard approach that misses the underlying computer science principle being taught.

Conclusion: The bitwise approach is superior in every technical metric—performance, conciseness, and scalability. While the mathematical method is a good thought experiment, mastering bitwise operations is essential for any serious programmer. It's a foundational skill you'll find applicable in areas like graphics programming, network protocols, embedded systems, and OS-level development. To truly grow as a developer, you should master the fundamentals of Arturo, including its powerful bitwise operators.

---

Frequently Asked Questions (FAQ)

1. Why must the allergen values be powers of two?

Using powers of two (1, 2, 4, 8, ...) ensures that each value corresponds to a unique, single bit in its binary representation. This prevents overlap. If we used values like 1, 2, 3, a score of 3 could mean "allergy 3" or "allergy 1 + allergy 2", creating ambiguity. The powers-of-two system guarantees that every possible sum of values produces a unique integer, which can be unambiguously decoded.

2. What is a "bitmask" or "bitfield"?

A "bitmask" or "bitfield" is the term for using an integer to store a set of boolean flags. The allergy score is a perfect example of a bitmask. Each bit position in the integer represents a specific flag (an allergen), and the bitwise AND operation is used to "mask" out the other bits and check the state of the one we care about.

3. How would I add a new allergen to the system?

It's very simple. You just need to add a new entry to the allergens dictionary. The value must be the next power of two. If the last allergen was cats at 128 (which is 2^7), the next one would be 256 (2^8). For example: "tree-nuts": 256. The rest of the code (the functions allergicTo? and list) will work automatically without any changes.

4. How does this relate to file permissions in Linux/Unix?

This is a fantastic real-world connection! Linux file permissions use the exact same principle. The permissions `read`, `write`, and `execute` are assigned values 4, 2, and 1, respectively. A file with `read` and `execute` permissions (4 + 1) has a permission value of 5. A file with all three (4 + 2 + 1) has a value of 7. The system uses bitwise operations to quickly check if a user has a specific permission for a file.

5. What happens if the score includes a value not in our list?

Our current list function will simply ignore it. For example, if the score is 512, which is a power of two we haven't defined, our program will produce an empty list because it only checks against the keys in our allergens dictionary. This is generally the desired behavior: ignore unknown allergies. If you wanted to handle this, you could add logic to detect if any bits are set beyond your highest known allergen value.

6. Is there a limit to how many allergies can be stored this way?

Yes, the limit is determined by the number of bits in the integer type used. A standard 32-bit integer can store 32 unique flags. A 64-bit integer can store 64 unique flags. For most applications, this is more than enough. If you needed to store hundreds of flags, you would typically switch to a different data structure, like an array of integers or a dedicated bitset library.

7. Why does the code walkthrough show the binary numbers as 8 bits?

For simplicity and readability. A standard integer is typically 32 or 64 bits long, which would mean writing out many leading zeros (e.g., `00000000000000000000000000000010` for the number 2). Using 8 bits (a byte) is sufficient to represent all the given allergens (up to 128) and makes the binary examples much easier to read and understand without losing the core concept.

---

Conclusion: More Than Just an Exercise

The allergy score problem, a key module in the Kodikra Arturo 5 roadmap, is far more than a simple coding challenge. It serves as a practical and memorable introduction to the world of bitwise operations—a fundamental topic in computer science that separates proficient programmers from novices. By solving this problem, you've learned how to encode and decode complex state information into a single, efficient integer.

You now understand the "why" behind using powers of two and the elegance of the bitwise AND operator as a high-performance filter. This knowledge is directly transferable to numerous real-world scenarios, from system configuration and network programming to game development and embedded systems. You've added a powerful tool to your problem-solving arsenal, enabling you to write code that is not only correct but also compact and lightning-fast.

Disclaimer: The code and explanations in this article are based on Arturo version 0.9.84. As the language evolves, some syntax or library functions may change. Always refer to the official Arturo documentation for the most current information.

---

Published by Kodikra — Your trusted Arturo learning resource.