Data Structures and Algorithms

Perl's sort function defaults to lexicographic (string) comparison, not numeric. The strings '10', '5', '1' sort as '1' < '10' < '5' because '1' < '5' alphabetically. So @b becomes (1, 10, 5). Option A is incorrect because it assumes numeric sorting.

In Informatica Lookup transformations, the columns used in the lookup condition are cached in the index cache for fast searching. Other columns go to the data cache. This optimization improves lookup performance by indexing on the join/condition columns.

Interval partitioning is an extension of range partitioning where Oracle automatically creates new partitions at specified intervals when data exceeds existing ranges. It inherits the range-based concept of partitioning data along a continuous spectrum (dates or numbers) but automates the partition boundary creation.

Perl uses the spaceship operator <=> inside a block to perform numerical comparisons for sorting, using the special package variables $a and $b. The default sort function performs ASCII-alphabetical sorting, while using $1 and $2 or $_[0] and $_[1] inside the sort block is syntactically incorrect.

Pivot tables are a powerful feature available in spreadsheet applications like Excel. They can definitely be created to summarize and analyze data. The statement 'cannot be created' is false.

SortedSet is an interface in Java. ConcurrentSkipListSet is a concrete class that implements the SortedSet interface, providing a thread-safe sorted set implementation based on a skip list data structure. HashMap and Queue are unrelated to SortedSet implementation.

The Normalizer transformation in Informatica is specifically designed to create multiple occurrences from a single input row. It denormalizes data by expanding columns into multiple rows, which is exactly what the question describes. Joiner transformations are for combining data from different sources, not for creating multiple occurrences.

The 'Sorted input' option in a Joiner transformation significantly improves performance because it allows Informatica to use a more efficient merge join operation instead of a nested loop join. The smaller table should be used as master, so option B is incorrect.

In SAS, the IN operator compares a variable to a list of target values. The list of character values must be enclosed in parentheses, separated by commas or spaces, and each string must be quoted individually. Other options either use invalid syntax or omit necessary quotes.

The average-case time complexity of Quick Sort is O(n log n), which occurs when the pivot consistently divides the array into reasonably balanced partitions. Distractors like O(n^2) represent the worst-case complexity, while O(log n) is too low and O(n^2 log n) is inefficient.

Bubble Sort has a time complexity of O(n^2) in both average and worst cases because it uses nested loops - each element may need to be compared with every other element. In the best case (already sorted), it can be O(n) with optimization, but its standard complexity is quadratic. Option A is for linear algorithms, B for logarithmic, and D for efficient sorts like merge sort.

PHP defines arrays and objects as compound data types because they contain multiple values or properties, unlike scalar types.

In DataStage, when you configure a join stage without specifying the join type, it defaults to a Left Outer Join. This means all records from the left input link are included, and matching records from the right link are included where available. Equi-join requires exact matches on both sides, Full Outer includes all records from both sides, and Right Outer prioritizes the right input.

Hash tables provide the fastest average-case data retrieval at O(1) time complexity, assuming a good hash function and minimal collisions. Binary trees are O(log n), while stacks and queues are O(n) for searching since you must traverse elements sequentially.

For the nearly-sorted array [1,2,3,5,4], Bubble Sort only needs one pass to swap 5 and 4, completing in O(n) time. More complex sorts like Quick Sort have overhead that makes them slower for small, nearly-sorted datasets. This illustrates that 'fastest' depends on initial data state.