Perl Programming and Regular Expressions

The regex /(\w+)$/ captures one or more word characters at the end of the string. In 'I am learning Perl', the last word is 'Perl', so $1 contains 'Perl' and it gets printed.

Quantifiers in Perl regex specify how many times the previous character or group must appear. Examples include *, +, ?, and {n,m} - these define repetition counts, not character classes or assertions.

The input string 'abdce' does not contain the substring 'abc', so the substitution operator s/abc/123/ fails and returns an empty (null) string. The original variable $input remains unchanged as 'abdce', while the result $output receives the null string.

splice(@array, -1) removes and returns the last element of @array, which is exactly what the pop function does. Negative indices count from the end.

push appends @sublist to the end of @array. splice(@array, scalar(@array), 0, @sublist) inserts @sublist at position equal to the array's length (the end), without removing any elements (0 elements removed).

unshift prepends @sublist to the beginning of @array. splice(@array, 0, 0, @sublist) inserts @sublist at position 0 (the beginning), removing 0 elements first.

The ++ operator on a string increments it with alphanumeric carryover. 'azz' increments to 'baa' - the 'z' wraps to 'a' and carries to the next position, then the second 'z' also wraps and carries to the first character.

The -- operator is only defined for numeric strings, not pure alphabetic strings. For 'abc', Perl's magical decrement returns 'minus 1' as a fallback behavior since it's not a valid numeric string for decrement.

The prefix increment ++$val changes $val from 26 to 27. The comma operator in scalar context evaluates the left expression, discards it, and returns the evaluation of the right expression, which is $val + 5, resulting in 27 + 5 = 32.

When assigning an array to a list of scalars, array elements are assigned left-to-right. $scalar1 gets the first element (1), but there are more scalars than elements, so remaining scalars get undef. The print shows 'Null value' (undef rendered as empty) and '5' ($scalar2 never got assigned, defaulting to undef/empty).

@array[@sublength] uses array slicing with indices from @sublength. Indices 1, 2, 3 select elements at those positions: 'two' (index 1), 'three' (index 2), and 'four' (index 3). Arrays are 0-indexed.

String increment on 'bc999' increments the last character: 9 becomes 0 with carry. This propagates through all three 9s, then 'c' increments to 'd'. Result is 'bd000'.

Perl is historically and primarily classified as an interpretive (interpreted) language, where scripts are compiled into an internal representation and executed by the Perl interpreter, rather than compiled directly to native machine code beforehand.

Left shifting by n bits multiplies by 2^n (each position shift is a power of 2). Right shifting divides by 2^n. This is fundamental to binary arithmetic.

The regex /de{3,}/ matches 'd' followed by 3 or more 'e' characters. 'deeef' has exactly 3 e's, and 'deeeef' has 4 e's - both satisfy the {3,} quantifier (minimum 3).

In Perl, when a 2-element array is assigned to 3 scalars, the third scalar receives undef (undefined). When printed, undef produces an empty string or an uninitialized value warning. 'Null value' is non-standard Perl terminology but refers to undef.

A list containing a null string ("") contains one element (the empty string), whereas an empty list () contains zero elements. Because their lengths and contents differ, they are not equivalent in Perl or general list operations.

Pattern delimiters in regular expressions are non-alphanumeric characters used to bound the pattern. Both double quote (") and percent (%) are valid delimiters in several regex implementations (particularly Perl-style), as long as the delimiter doesn't appear within the pattern itself. The caret (^) and dollar sign ($) are anchors, not delimiters.

The regex /abc(?=def)/ uses a positive lookahead (?=def), which matches "abc" only when followed immediately by "def". Both "abcdef" and "abcdefgh" satisfy this condition - they contain "abc" immediately followed by "def" - so the pattern matches in both cases. The lookahead doesn't consume characters.

The regex uses a negative lookahead (?!def) to match the string 'abc' only if it is not immediately followed by 'def'. Therefore, it successfully matches 'abc' (I) and 'abcd' (III) because 'abc' in 'abcd' is followed by 'd'. It fails on 'abcdef'.