Allergen Assessment

X = the number of times that each ingredient provably unable to contain any allergens appears amongst all ingredient lists

mxmxvkd kfcds sqjhc nhms (contains dairy, fish)
trh fvjkl sbzzf mxmxvkd (contains dairy)
sqjhc fvjkl (contains soy)
sqjhc mxmxvkd sbzzf (contains fish)

mxmxvkd kfcds sqjhc nhms (contains dairy, fish)
sqjhc mxmxvkd sbzzf (contains fish)

mxmxvkd kfcds sqjhc nhms (contains dairy, fish)
trh fvjkl sbzzf mxmxvkd (contains dairy)

sqjhc fvjkl (contains soy)

Input
mxmxvkd kfcds sqjhc nhms (contains dairy, fish)
trh fvjkl sbzzf mxmxvkd (contains dairy)
sqjhc fvjkl (contains soy)
sqjhc mxmxvkd sbzzf (contains fish)

Knowledge
mxmxvkd sqjhc (are dairy, fish)
fvjkl mxmxvkd (are soy and dairy)
fvjkl (is soy)
sqjhc (is fish)

Process of elimination
kfcds nhms (are irrelevant)
trh sbzzf (are irrelevant)
...
sbzzf (is irrelevant again)

Step 1: Parse the input
Split the input into an array of strings
For each string in the array
  Split the string at the phrase ' (contains ' to create an array with two elements, each a string
    Split each string at the space character to create an array of single-word strings
      By now, the first array contains each ingredient, and the second array contains each allergen, but with a few quirks:
        If there were more than one allergen, the all but the last has a , as the last character
        The last allergen as a ) as the last character
      Update each string in the second array to remove any , and ) characters from the end

Step 2: Aggregate each ingredient list grouped with an individual allergen
Create an object - called mappings - that will map allergens with ingredient lists
For each parsed ingredients and allergens list from the input
  For each allergen
    Create a key in the object whose value is an empty array
    Add the ingredients list to the allergen key's array

Step 3: Do an initial pass to determine which ingredients are in every list associated with any single allergen
Create an object with keys for each allergen and values initialized as empty arrays
For each allergen key in the object
  Set the value equal to the result of the following operations:
    For each string in the first ingredient list associated with this allergen, accumulate an array - starting as empty -  of strings that can be found in all ingredient lists associated with the current allergen
      Create an empty array that will contain booleans representing whether the current string is in any subsequent ingredient lists associated with the current allergen
      For each ingredients list - excluding the first one - associated with the current allergen
        If the list contains the current string
          Add the boolean true to the array
        Else, add the boolean false to the array
      If the array contains all true booleans, add the current string to the accumulating array

Step 4: Process of elimination to determine each ingredient-to-allergen pairing
Assuming that Step 3 resulted in at least one ingredient-to-allergen match - meaning one of the resulting arrays contains only one value...
...and assuming that each iteration of the following loop generates a new single-ingredient allergen:
Do the following operations until every allergen's associated array contains only one value:
  For each single-ingredient allergen newly discovered after a prior iteration
    For all allergens
      If their associated array of possible matching ingredients has two or more items remaining, and it includes the ingredient associated with the current single-ingredient allergen
        Update that array of that allergen so that the current ingredient is removed from that array

By now, the program should have an object associating each known allergen to a single ingredient

Step 5: Calculate the count of irrelevant ingredient instances across all ingredient list
For each identified ingredient associated with each allergen
  Accumulate a shrinking list of ingredients - starting with a combined and flattened list of each ingredient list
    Return a filtered list such that all instances of the current ingredient have been removed

Return the length of the accumulated, filtered list

Generate an array of each allergen
Sort it alphabetically
Change each allergen to its matching ingredient
Concatenate each string in the array using a , character
Return the full string