Question

Write list functions that carry out the following tasks for a list of integers. For each function, provide a test program. a. Swap the first and last elements in the list. b. Shift all clements by one to the right and move the last element into the first position. For example, 1491625 would be transformed into 2514916 . c. Replace all even clements with 0 . d. Replace each element except the first and last by the larger of its two neighbors. e. Remove the middle element if the list length is odd, or the middle two clements if the length is even. f. Move all even elements to the front, otherwise preserving the order of the elements. 9\. Return the second-largest element in the list. h. Return true if the list is currently sorted in increasing order. i. Return true if the list contains two adjacent duplicate clements. J. Return true if the list contains duplicate elements (which need not be adjacent).

Short answer

Implemented list functions for swaps, shifts, replacements, removals, sort checks, and duplicates.

Step-by-step solution

Swap First and Last Elements Function

To swap the first and last elements of a list, create a function `swap_first_last(lst)`. In this function, store the last element in a temporary variable, set the last element to the first element, and then set the first element to the temporary variable. Test the function with a sample list like `[1, 2, 3, 4, 5]`. After swapping, the list should be `[5, 2, 3, 4, 1]`. ```python def swap_first_last(lst): if len(lst) > 1: temp = lst[0] lst[0] = lst[-1] lst[-1] = temp return lst # Test program print(swap_first_last([1, 2, 3, 4, 5])) # Output: [5, 2, 3, 4, 1] ```

Shift Elements to the Right

To shift all elements to the right, define `shift_right(lst)`. The last element should become the first element, while all others shift right. Store the last element in a variable, and then iterate from the end to the start, shifting elements one position to the right, finally placing the last element at the start. Test this with `[1, 4, 9, 16, 25]`, expecting `[25, 1, 4, 9, 16]`. ```python def shift_right(lst): if len(lst) > 0: last_elem = lst.pop() lst.insert(0, last_elem) return lst # Test print(shift_right([1, 4, 9, 16, 25])) # Output: [25, 1, 4, 9, 16] ```

Replace Even Elements with Zero

Create `replace_evens(lst)`, which iterates over the list and sets each even number to 0 using a list comprehension. Test with `[1, 2, 3, 4, 5, 6]` and expect `[1, 0, 3, 0, 5, 0]`. ```python def replace_evens(lst): return [0 if x % 2 == 0 else x for x in lst] # Test print(replace_evens([1, 2, 3, 4, 5, 6])) # Output: [1, 0, 3, 0, 5, 0] ```

Replace by Larger of Neighbors

Build `replace_with_largest_neighbor(lst)` to replace each element except the first and last with the larger of its two neighbors. Use a loop to compare neighbors and update elements. Test this with `[1, 3, 2, 5, 3]` yielding `[1, 3, 5, 5, 3]`. ```python def replace_with_largest_neighbor(lst): if len(lst) < 3: return lst result = [lst[0]] for i in range(1, len(lst) - 1): result.append(max(lst[i-1], lst[i+1])) result.append(lst[-1]) return result # Test print(replace_with_largest_neighbor([1, 3, 2, 5, 3])) # Output: [1, 3, 5, 5, 3] ```

Remove Middle Element(s)

Implement `remove_middle(lst)` to remove the middle element if the length is odd, or the middle two if even. Calculate the middle index and slice the list accordingly. Testing `[1, 2, 3, 4, 5]`, expect `[1, 2, 4, 5]`; for `[1, 2, 3, 4]`, expect `[1, 4]`. ```python def remove_middle(lst): n = len(lst) if n == 0: return lst mid = n // 2 if n % 2 == 0: return lst[:mid-1] + lst[mid+1:] else: return lst[:mid] + lst[mid+1:] # Test print(remove_middle([1, 2, 3, 4, 5])) # Output: [1, 2, 4, 5] print(remove_middle([1, 2, 3, 4])) # Output: [1, 4] ```

Move Evens to the Front

For `move_evens_to_front(lst)`, create two lists: one for even numbers and one for odds. Merge the two lists with evens first to preserve order. Test this with `[1, 2, 3, 4, 5, 6]` producing `[2, 4, 6, 1, 3, 5]`. ```python def move_evens_to_front(lst): evens = [x for x in lst if x % 2 == 0] odds = [x for x in lst if x % 2 != 0] return evens + odds # Test print(move_evens_to_front([1, 2, 3, 4, 5, 6])) # Output: [2, 4, 6, 1, 3, 5] ```

Find Second Largest Element

To find the second-largest element, define `second_largest(lst)`. Sort the list and find the largest distinct element by scanning backwards from the end. Test with `[5, 1, 8, 7, 2]` where the output should be `7`. ```python def second_largest(lst): unique_lst = list(set(lst)) if len(unique_lst) < 2: return None unique_lst.sort() return unique_lst[-2] # Test print(second_largest([5, 1, 8, 7, 2])) # Output: 7 ```

Check Sorted in Increasing Order

Create `is_sorted_increasing(lst)` to return true if the list is sorted in increasing order. Compare pairs of elements to ensure the current element is not greater than the next. Try `[1, 2, 3, 4]` (true) and `[1, 3, 2]` (false). ```python def is_sorted_increasing(lst): return all(lst[i] <= lst[i + 1] for i in range(len(lst) - 1)) # Test print(is_sorted_increasing([1, 2, 3, 4])) # Output: True print(is_sorted_increasing([1, 3, 2])) # Output: False ```

Check for Adjacent Duplicates

Write `has_adjacent_duplicates(lst)` to determine if there are two same consecutive elements. Use a loop to compare each pair of neighboring elements. Testing `[1, 2, 2, 3]` should give `True`; `[1, 2, 3]` should give `False`. ```python def has_adjacent_duplicates(lst): return any(lst[i] == lst[i + 1] for i in range(len(lst) - 1)) # Test print(has_adjacent_duplicates([1, 2, 2, 3])) # Output: True print(has_adjacent_duplicates([1, 2, 3])) # Output: False ```

Check for Any Duplicates

For non-adjacent duplicates, use `has_duplicates(lst)`. Convert the list to a set and compare lengths to check for duplicates. With `[1, 2, 3, 2]`, expect `True`; with `[1, 2, 3]`, expect `False`. ```python def has_duplicates(lst): return len(lst) > len(set(lst)) # Test print(has_duplicates([1, 2, 3, 2])) # Output: True print(has_duplicates([1, 2, 3])) # Output: False ```

Key concepts

Python programming

Python is a versatile and widely-used programming language that is known for its simplicity and readability. One of the fundamental skills in Python programming is the ability to manipulate lists. Lists in Python are ordered collections that can hold different data types, like integers, strings, and even other lists. They are mutable, meaning you can change their content without changing their identity. Understanding list operations is crucial for performing a range of tasks, from basic data management to complex algorithm design.

To illustrate list operations, let's consider swapping the first and last elements of a list. In Python, this can be done using assignment operations to swap the elements' positions. Here's a quick overview of why this is useful:

• Maintaining data arrangement: Sometimes, data needs to be reordered for analysis or processing.
• Implementing algorithms: Swapping elements is a common operation in sorting algorithms.
• Optimizing performance: Position adjustments can lead to more efficient data access patterns.

To perform such operations, you define a function that modifies the list based on these requirements and uses simple Python syntax for assignments and element access.

algorithm design

Algorithm design lies at the heart of effective programming and involves crafting a step-by-step solution for a particular problem. When designing an algorithm, you consider efficiency, simplicity, and scalability. Let's look at an example of shifting elements in a list to the right—a typical problem in algorithm design.
In this problem, the last element of the list needs to become the first, with each element moving to the next index. This algorithm can be efficiently implemented by:

• Storing the last element temporarily.
• Iterating backward through the list to shift elements.
• Inserting the stored element at the first position.

Here’s why this approach is notable:

• Efficiency: The operation is completed in linear time with respect to the number of elements in the list.
• Modularity: The algorithm can be encapsulated in a function, providing modular and reusable code.

Designing algorithms like this fosters an understanding of how to manipulate data structures and helps develop skills to tackle more complex problem-solving tasks.

problem solving skills

Enhancing problem solving skills is one of the primary goals of engaging with exercises like these. Each function within the list operates on specific scenarios, demanding tailored solutions. Consider the task of replacing all even numbers with zero in a list.
This problem can be tackled using a list comprehension—a concise Python construct that allows transformation or filtering of list elements. By iterating over each element and checking if it is even, you can replace it with zero while leaving odd numbers intact. This method showcases how problem solving often leverages the versatile features of Python:

• Clear logic: Solving problems in Python can yield code that is both efficient and easy to understand.
• Conciseness: By using constructs like list comprehensions, you can write more structured and less error-prone code.
• Adaptability: The same problem-solving approach can be adjusted for other conditions or data types, demonstrating flexibility.

These exercises promote analytical thinking and expose students to considering performance and clarity when solving programming challenges.

test-driven development

Test-driven development (TDD) is a software development technique that involves writing tests before code implementation. Each function you create in Python for list operations should be backed by test programs verifying their correctness. Consider finding the second-largest element as a case for understanding TDD.
To ensure accuracy, a test program for this function might:

• Test with a list containing unique values to check basic functionality.
• Include edge cases like a list with all identical elements or fewer than two unique values.
• Verify it returns the correct second-largest value or handles exceptions gracefully.

By systematically writing tests and then implementing the function, you ensure:

• Reliability: Each piece of functionality is verified under different conditions.
• Maintainability: Future changes to the code will retain functionality as long as the tests pass.
• Confidence: You can be sure that your code performs correctly as expected.

Applying TDD principles ensures that your Python code is robust and resilient, making it an essential practice for improving problem-solving approaches in real-world applications.