1CONCRETE_DENSITY = 2500
  2BRICK_DENSITY = 2000
  3STONE_DENSITY = 1600
  4WOOD_DENSITY = 600
  5STEEL_DENSITY = 7700
  6
  7SHARED_CLASSES = {
  8    "Concrete": lambda mass: Concrete(mass),
  9    "Brick": lambda mass: Brick(mass),
 10    "Stone": lambda mass: Stone(mass),
 11    "Wood": lambda mass: Wood(mass),
 12    "Steel": lambda mass: Steel(mass),
 13}
 14
 15ALL_FACTORIES = []
 16
 17class Material:
 18    def __init__(self, mass: int, density: int):
 19        self.mass = mass
 20        self._is_valid = True
 21        self.base_densities = [density]
 22
 23    @property
 24    def is_valid(self) -> bool:
 25        return self._is_valid
 26
 27    def invalidate(self):
 28        self._is_valid = False
 29
 30    @property
 31    def density(self):
 32        return sum(self.base_densities) / len(self.base_densities)
 33
 34    @property
 35    def volume(self) -> float:
 36        return self.mass / self.density
 37
 38class Concrete(Material):
 39    def __init__(self, mass: int):
 40        super().__init__(mass, CONCRETE_DENSITY)
 41
 42class Brick(Material):
 43    def __init__(self, mass: int):
 44        super().__init__(mass, BRICK_DENSITY)
 45
 46class Stone(Material):
 47    def __init__(self, mass: int):
 48        super().__init__(mass, STONE_DENSITY)
 49
 50class Wood(Material):
 51    def __init__(self, mass: int):
 52        super().__init__(mass, WOOD_DENSITY)
 53
 54class Steel(Material):
 55    def __init__(self, mass: int):
 56        super().__init__(mass, STEEL_DENSITY)
 57
 58class Factory:
 59    _all_factories = []
 60
 61    def __init__(self):
 62        self.materials = []
 63        Factory._all_factories.append(self)
 64
 65    def __call__(self, *args, **kwargs):
 66        if args and kwargs:
 67            raise ValueError("Cannot mix positional and keyword arguments.")
 68        if not args and not kwargs:
 69            raise ValueError("Factory must be called with arguments.")
 70        if kwargs:
 71            return self._create_from_kwargs(kwargs)
 72        if args:
 73            return self._create_from_args(args)
 74
 75    def _create_from_kwargs(self, kwargs):
 76        result = []
 77        for material_name, mass in kwargs.items():
 78            if material_name not in SHARED_CLASSES:
 79                raise ValueError(f"Invalid material: {material_name}")
 80            material_creator = SHARED_CLASSES[material_name]
 81            material = material_creator(mass)
 82            self.materials.append(material)
 83            result.append(material)
 84        return tuple(result)
 85
 86    def _create_from_args(self, args):
 87        for arg in args:
 88            assert arg.is_valid, "Material has already been used and is invalid."
 89            arg.invalidate()
 90        material_classes = sorted(arg.__class__.__name__ for arg in args)
 91        class_name = "_".join(material_classes)
 92        if class_name in SHARED_CLASSES:
 93            alloy_class = SHARED_CLASSES[class_name]
 94        else:
 95            combined_densities = self._get_combined_densities(args)
 96            alloy_class = self._create_alloy_class(class_name, combined_densities)
 97        total_mass = sum(arg.mass for arg in args)
 98        alloy_instance = alloy_class(total_mass)
 99        self.materials.append(alloy_instance)
100        return alloy_instance
101
102    def _get_combined_densities(self, args):
103        combined_densities = []
104        for arg in args:
105            combined_densities.extend(arg.base_densities)
106        return combined_densities
107
108    def _create_alloy_class(self, class_name, combined_densities):
109        average_density = sum(combined_densities) / len(combined_densities)
110        class Alloy(Material):
111            def __init__(self, mass: int):
112                super().__init__(mass, average_density)
113        Alloy.__name__ = class_name
114        SHARED_CLASSES[class_name] = lambda mass: Alloy(mass)
115        return Alloy
116
117    def can_build(self, required_volume: int) -> bool:
118        total_volume = sum(material.volume for material in self.materials if material.is_valid)
119        return total_volume >= required_volume
120
121    @classmethod
122    def can_build_together(cls, required_volume: int) -> bool:
123        total_volume = sum(
124            material.volume
125            for factory in cls._all_factories
126            for material in factory.materials
127            if material.is_valid
128        )
129        return total_volume >= required_volume