Scala - Having trouble with filter & vals - scala

Question

Working on an exercism.io exercise in Scala. Here is my current code:
case class Allergies() {
def isAllergicTo(allergen:Allergen.Allergen, score:Int) = {
if (score < allergen.value || score == 0) false
else true
}
def allergies(score:Int) = {
val list = List(Allergen.Cats, Allergen.Pollen, Allergen.Chocolate, Allergen.Tomatoes,
Allergen.Strawberries, Allergen.Shellfish, Allergen.Peanuts, Allergen.Eggs)
list.filter(isAllergicTo(_, score)).sortBy(v => v.value)
}
}
object Allergen {
sealed trait Allergen { def value: Int }
case object Eggs extends Allergen { val value = 1 }
case object Peanuts extends Allergen { val value = 2 }
case object Shellfish extends Allergen { val value = 4 }
case object Strawberries extends Allergen { val value = 8 }
case object Tomatoes extends Allergen { val value = 16 }
case object Chocolate extends Allergen { val value = 32 }
case object Pollen extends Allergen { val value = 64 }
case object Cats extends Allergen { val value = 128 }
}
Due to the way the tests are formatted, a few of these strange constructs are just simple ways of passing syntactical issues in the tests. With that aside, a quick overview of what you are seeing...
Allergies takes a score and returns all of the allergens that could add to this score. So, if a person has a score of 34, they must be allergic to Chocolate and Peanuts. isAllergicTo takes an allergen and a score and determines if it is possible that there is an allergen present.
The problem I am running into is my filter logic is sort of correct, but right now for the example of 34 as input, it will return not only Chocolate and Peanuts, but everything with a score less than Chocolate. I am not really sure how to go about solving this issue with a score that is changing to reflect a match found, partly because score is a val and can't be reassigned without using an intermediate variable.
I know my problem is vague, but I'm not sure where to continue on this one and would appreciate any suggestions.

Answer 1

The issue is simply that isAllergicTo is implemented incorrectly. If you fix it, you won't need to change score at all. As a hint: think about binary representation of score.

Answer 2

"Bitmasking" is often used to represent a set of items as an integer value.
If you have a collection of items (e.g. Allergens), you assign a value to it equal to some power of 2. Eggs is 2^0, Peanuts is 2^1, and so on. To create a set of these items, you take the bitwise "OR" of the items in that set. By using different powers of 2, when the value is represented in binary, the 1 in each item's value goes in a different place.
For example:
Peanuts: 00000010 (2)
OR Chocolate: 00100000 (32)
----------------------------
= (combined): 00100010 (34)
To check if an item is in a set (value), you use bitwise "AND" to compare the item's value with the set's value, e.g.
Set: 00100010 (34)
AND Peanuts: 00000010 (2)
---------------------------
result: 00000010 (2)
Set: 00100010 (34)
AND Shellfish: 00000100 (4)
-----------------------------
result: 00000000 (0)
If Peanuts had not been in the set, the result value would be 0.
looks like I'm a bit late, but I'm posting this anyway

Answer 3

Using a tail recursive function :
def allergies(score:Int) = {
val list = List(Allergen.Cats, Allergen.Pollen, Allergen.Chocolate, Allergen.Tomatoes,
Allergen.Strawberries, Allergen.Shellfish, Allergen.Peanuts, Allergen.Eggs)
def inner(maybeSmaller: List[Allergen.Allergen], score: Int, allergies: List[Allergen.Allergen]) : List[Allergen.Allergen] =
if (score == 0 || maybeSmaller.length == 0) allergies.reverse
else {
val smaller = maybeSmaller.filter(isAllergicTo(_, score))//(_.value < score)
inner(smaller.tail, score - smaller.head.value, smaller.head :: allergies)
}
inner(list.sortBy(- _.value), score, Nil)
}