Practice Problems and Detailed Solutions

Explanation:

1. First, we check if the array has fewer than 2 elements. If so, we return -1.
2. We initialize two variables, largest and second_largest, to negative infinity.
3. We iterate through each number in the array.
   • If the current number is greater than the largest, we update the second largest to be the previous largest, and update the largest.
   • If the current number is not greater than the largest but is greater than the second largest and not equal to the largest, we update the second largest.
4. After the iteration, if the second largest is still negative infinity, it means all elements in the array are equal, so we return -1.
5. Otherwise, we return the second largest value.

Example Usage:

print(find_second_largest([5, 2, 9, 7, 3, 6]))  # Output: 7print(find_second_largest([1, 2]))                # Output: 1print(find_second_largest([5]))                   # Output: -1print(find_second_largest([8, 8, 8, 8]))          # Output: -1

Time Complexity:

The algorithm runs in O(n) time, where n is the number of elements in the array, as we only need to iterate through the array once.

Space Complexity:

The algorithm uses O(1) additional space, as we only use a constant amount of extra memory.

Explanation:

1. First, we preprocess the string by converting it to lowercase and removing all non-alphanumeric characters. This ensures that our function works with phrases and ignores spaces and punctuation.
2. We then check if the cleaned string equals its reverse. In Python, [::-1] is a slicing technique that reverses a string.
3. The function returns True if the string is a palindrome and False otherwise.

Alternative Approach (Two-pointer method):

def is_palindrome_two_pointer(s):    # Convert the string to lowercase and remove non-alphanumeric characters    cleaned = ''.join(char.lower() for char in s if char.isalnum())        # Initialize two pointers    left = 0    right = len(cleaned) - 1        # Move pointers toward each other    while left < right:        if cleaned[left] != cleaned[right]:            return False        left += 1        right -= 1        return True

Example Usage:

print(is_palindrome("racecar"))           # Output: Trueprint(is_palindrome("A man, a plan, a canal: Panama"))  # Output: Trueprint(is_palindrome("hello"))             # Output: Falseprint(is_palindrome("Was it a car or a cat I saw"))     # Output: True

Time Complexity:

Both implementations run in O(n) time, where n is the length of the input string. The two-pointer approach might have a slight advantage in practice as it doesn't need to create a reversed string.

Space Complexity:

Both implementations use O(n) space to store the cleaned string. This could be optimized to O(1) by processing the original string directly, but would make the code more complex.

Analysis:

The expression (p q) (q r) evaluates to true in the following cases:

1. When both p and q are true (regardless of r)
2. When q is false, and r is true (regardless of p)

We can simplify the expression by noticing a pattern:

• When q is true, the expression reduces to: p F = p
• When q is false, the expression reduces to: F (T r) = r

This shows that the expression is equivalent to (q p) (q r), which is a form of a conditional statement.