A. Incorrect.
sortBy() orders data and can trigger expensive shuffling. It does not specifically reduce excessive partition counts without a full shuffle.

B. Incorrect.
repartition() changes the partition count through a full shuffle. The question asks for a way to reduce partitions without a full shuffle.

C. Correct.
coalesce(n) reduces the number of partitions while avoiding a full shuffle in common down-partitioning cases. repartition() performs a full shuffle.

D. Incorrect.
distinct() removes duplicate rows and usually requires a shuffle. It does not reduce partition count in the controlled way that coalesce() does.

A. Incorrect.
Sorting descending returns the largest region_id values first, while the requirement asks for the smallest three.

B. Correct.
The correct code selects region first so it becomes the dictionary key, sorts ascending by region_id to get the smallest IDs, and takes exactly three rows.

C. Incorrect.
This reverses the desired dictionary mapping. dict() would use region_id as the key and region as the value, but the requirement is region -> region_id.

D. Incorrect.
This both selects the columns in the wrong order for the dictionary and uses limit(3) without sorting, so it does not guarantee the smallest three region_id values.

A. Correct.
A short processingTime trigger uses micro-batch execution, which supports exactly-once guarantees with low latency. Continuous processing has different guarantee limitations, and availableNow is batch-style.

B. Incorrect.
continuous=True chooses Spark continuous processing. It targets very low latency, but it does not provide the same exactly-once guarantees as the micro-batch processingTime trigger.

C. Incorrect.
continuous='1 second' is still continuous processing, not a one-second micro-batch trigger. The question needs processingTime='1 second' for low-latency micro-batches with exactly-once guarantees.

D. Incorrect.
availableNow is a finite, batch-style trigger for processing available data. It is not the best choice for continuously low-latency streaming.

A. Incorrect.
A Cartesian join is used when rows are combined without an appropriate join condition. The scenario is about AQE choosing an optimized equi-join strategy.

B. Incorrect.
Broadcast nested loop joins are used for different cases, often non-equi joins or when no better strategy applies. The threshold described points to shuffled hash join.

C. Incorrect.
Sort-merge join is common for large shuffled joins, but AQE can switch to shuffled hash join when post-shuffle partitions are small enough.

D. Correct.
AQE can prefer shuffled hash join when post-shuffle partitions are small enough for the configured local map threshold, avoiding a more expensive sort-merge join.

A. Incorrect.
explain() is not the best answer because it does not match the Databricks/Spark behavior being tested. The key point is: cache() and persist() mark a DataFrame for reuse across actions, reducing repeated computation when the same lineage is needed multiple times.

B. Incorrect.
printSchema() is not the best answer because it does not match the Databricks/Spark behavior being tested. The key point is: cache() and persist() mark a DataFrame for reuse across actions, reducing repeated computation when the same lineage is needed multiple times.

C. Correct.
cache() and persist() mark a DataFrame for reuse across actions, reducing repeated computation when the same lineage is needed multiple times.

D. Incorrect.
collect() is not the best answer because it does not match the Databricks/Spark behavior being tested. The key point is: cache() and persist() mark a DataFrame for reuse across actions, reducing repeated computation when the same lineage is needed multiple times.

A. Incorrect.
groupBy().drop("customer_id", "event_date") is not the best answer because it does not match the Databricks/Spark behavior being tested. The key point is: dropDuplicates with a column list removes duplicate rows based on the selected subset while keeping one record for each key combination.

B. Correct.
dropDuplicates with a column list removes duplicate rows based on the selected subset while keeping one record for each key combination.

C. Incorrect.
distinct() removes duplicate rows and usually requires a shuffle. It does not reduce partition count in the controlled way that coalesce() does.

D. Incorrect.
filterDuplicates("customer_id", "event_date") is not the best answer because it does not match the Databricks/Spark behavior being tested. The key point is: dropDuplicates with a column list removes duplicate rows based on the selected subset while keeping one record for each key combination.

A. Correct.
explain() prints the query plan so developers can inspect parsing, optimization, and physical execution choices.

B. Incorrect.
show() is not the best answer because it does not match the Databricks/Spark behavior being tested. The key point is: explain() prints the query plan so developers can inspect parsing, optimization, and physical execution choices.

C. Incorrect.
count() is not the best answer because it does not match the Databricks/Spark behavior being tested. The key point is: explain() prints the query plan so developers can inspect parsing, optimization, and physical execution choices.

D. Incorrect.
take() is not the best answer because it does not match the Databricks/Spark behavior being tested. The key point is: explain() prints the query plan so developers can inspect parsing, optimization, and physical execution choices.

A. Incorrect.
union() is not the best answer because it does not match the Databricks/Spark behavior being tested. The key point is: unionByName matches columns by name instead of position, which prevents values from being placed under the wrong columns when column order differs.

B. Incorrect.
join() is not the best answer because it does not match the Databricks/Spark behavior being tested. The key point is: unionByName matches columns by name instead of position, which prevents values from being placed under the wrong columns when column order differs.

C. Incorrect.
intersect() is not the best answer because it does not match the Databricks/Spark behavior being tested. The key point is: unionByName matches columns by name instead of position, which prevents values from being placed under the wrong columns when column order differs.

D. Correct.
unionByName matches columns by name instead of position, which prevents values from being placed under the wrong columns when column order differs.

A. Incorrect.
drop() is not the best answer because it does not match the Databricks/Spark behavior being tested. The key point is: withColumn adds or replaces a column while preserving the rest of the DataFrame unless later transformations remove them.

B. Incorrect.
coalesce() is not the best answer because it does not match the Databricks/Spark behavior being tested. The key point is: withColumn adds or replaces a column while preserving the rest of the DataFrame unless later transformations remove them.

C. Correct.
withColumn adds or replaces a column while preserving the rest of the DataFrame unless later transformations remove them.

D. Incorrect.
selectExpr() only with no existing columns is not the best answer because it does not match the Databricks/Spark behavior being tested. The key point is: withColumn adds or replaces a column while preserving the rest of the DataFrame unless later transformations remove them.

A. Incorrect.
mode="append" is not the best answer because it does not match the Databricks/Spark behavior being tested. The key point is: inferSchema=True tells Spark's CSV reader to sample and infer column data types instead of treating every field as a string.

B. Correct.
inferSchema=True tells Spark's CSV reader to sample and infer column data types instead of treating every field as a string.

C. Incorrect.
header=False is not the best answer because it does not match the Databricks/Spark behavior being tested. The key point is: inferSchema=True tells Spark's CSV reader to sample and infer column data types instead of treating every field as a string.

D. Incorrect.
multiLine=False is not the best answer because it does not match the Databricks/Spark behavior being tested. The key point is: inferSchema=True tells Spark's CSV reader to sample and infer column data types instead of treating every field as a string.