Choose appropriate data structures and algorithms to optimize computational complexity and performance. Consider the specific use case and access patterns when selecting between different approaches. Key optimization opportunities: 1. **Use efficient data structures for lookups**: Replace linear searches with constant-time operations where possible. For example, convert `ArrayContains` operations on literal arrays to `InSet` operations for O(1) lookup instead of O(n). 2. **Choose appropriate collection types**: Use `Set[String]` with `contains()` for simple string matching instead of `Set[Regex]` when regex functionality isn't needed. This avoids unnecessary regex compilation overhead. 3. **Leverage built-in collection methods**: Use `Array.tabulate(size)(constructor)` instead of manual loops for array initialization, and `collection.zip(other).toMap` for efficient map construction. 4. **Consider algorithmic properties**: Be aware of algorithm limitations like XOR checksums having issues with duplicate values. Consider alternatives like combining sum + XOR or using hash functions like Fowler–Noll–Vo when order-independence and duplicate-handling are required. 5. **Select semantic-appropriate data structures**: Use `ExpressionSet` for deduplicating expressions by semantics rather than object equality when the logical meaning matters more than object identity. Example transformation: ```scala // Instead of O(n) array search: case ArrayContains(arrayParam: Literal, col) => // Linear search through array elements // Use O(1) set lookup: case ArrayContains(arrayParam: Literal, col) if arrayParam.value != null => InSet(col, arrayParam.value.asInstanceOf[GenericArrayData].array.toSet) ``` This approach reduces computational complexity and improves performance, especially for frequently executed operations or large datasets.