Ruby and Perl Programming Fundamentals

In printf-style formatting, the format specifier %6.2f specifies a minimum field width of 6 characters in total (padding with spaces if necessary) and exactly 2 digits after the decimal point.

Perl has three standard file handles: STDIN (input), STDOUT (output), and STDERR (error output). Options A and B list fictitious handles. Options C and D show lowercase versions which are not the standard file handles (though Perl allows custom ones). Option E correctly identifies both C and D as actual file handles.

In single quotes, Perl does NOT interpret escape sequences except for \ and '. The string 'a\b\n' contains a literal backslash-backslash, 'b', and literal backslash-n. When printed, this outputs exactly: a\b\n (no newline character, just the characters). The double backslash becomes one backslash in output.

The regex match operator (=~) modifies special variables like $1, $2 etc., but does NOT modify the original variable. $txt still contains the original string 'I am learning Perl'. The pattern /(\w+)$/ matches 'Perl' and stores it in $1, not in $txt. This is a common misconception about regex behavior.

Perl uses 'elsif' for conditional chains (note the missing 'e'). This differs from C-style 'else if' and shell-style 'elif'. Option C shows the correct Perl syntax. This is a common point of confusion for programmers coming from other languages.

In Perl, variable names must start with $ or @ (or % for hashes), then optionally more letters, digits, or underscores. $10thLine is invalid because variable names cannot start with a digit. $_4x is valid (scalar with underscore). $line.No is valid (dot allowed). count without $ is not a scalar variable. $lineNo! is invalid (! not allowed).

Perl uses the 'x' operator (lowercase) for string repetition. 'TEST' x 10 repeats 'TEST' 10 times. The uppercase 'X' is not a valid repetition operator. Option b shows correct lowercase syntax. Options a and c use uppercase X which is wrong. Option d reverses the operand order incorrectly.

In Perl hashes, undef (as a key) and empty string '' are different keys. When both are set as keys with undef values, the hash has 2 distinct key-value pairs. The keys() function in scalar context returns the count of keys, which is 2. This tests understanding that undef and '' are distinct values as hash keys.

Perl's loop constructs include for, foreach, until, while, and do-while. The 'map' function is not a loop construct but a list processing function. The 'switch' statement (given/when in Perl 5.10+) is also not a traditional loop. Option e (switch) is correct as the non-loop answer. Note: Modern Perl has given/when for switch-like behavior.

In Ruby, both length and size are valid methods to get the number of elements in an array. They are aliases and return the same result. Options C and D are incorrect because size(name) and length(name) are not valid Ruby syntax - these methods must be called on the array object itself, not with the array as an argument.

In Ruby, the index method (also called find_index) returns the position of the first occurrence of the specified element in the array. For days.index("Saturday"), this would return 5 (zero-indexed) or 6 (one-indexed position), which is the correct way to find an element's index.

The code initializes i = 0, then uses 10.times do which executes the block 10 times. Each iteration increments i by 1 and prints it, producing output from 1 to 10. This is correct Ruby syntax and the claimed output matches the actual behavior.

The code has a critical error: it declares the block parameter as lowercase |i| but tries to use uppercase I in the puts statement. In Ruby, this would either raise an error for an undefined variable or print nothing useful. Additionally, 0.upto(10) includes 0, so even with correct syntax the output would start with 0, not 1. The claimed output is incorrect.

The upto method in Ruby is inclusive, meaning 0.upto(10) iterates from 0 through 10, printing each value. The output 0 1 2 3 4 5 6 7 8 9 10 is exactly correct. This demonstrates the inclusive nature of Ruby's range methods.

The code uses collect (also known as map) with do...end block syntax, which has lower precedence than method calls. This means puts my_array.collect do...end is parsed as puts(my_array.collect) do...end, which just outputs the original array without applying the transformation. The output alpha beta gamma is correct because the capitalize operation never executes.

Using braces {} for the block gives it higher precedence, so my_array.collect { |word| word.capitalize } is evaluated first, creating a new array with capitalized words. The puts then outputs Alpha Beta Gamma. This is correct behavior.

The range 1...10 uses three dots, which in Ruby means an exclusive range (excludes the end value). So the loop iterates from 1 to 9, printing each number followed by ' Hello'. The output 1 Hello 2 Hello ... 9 Hello is exactly correct. This tests understanding of Ruby's two range operators.

Starting with ss = 5, the while loop runs while ss > 0. Each iteration subtracts 2: 5→3→1. When ss becomes 1, the condition if ss == 1 adds 5, making it 6. Then 6→4→2→0 (exits). The sequence printed is 5, 3, 6, 4, 2. This is correct.