Question

Write a code segment that searches a two-dimensional array for a negative integer. The loop should terminate at the first instance of a negative integer in the array, and the variables row and col should be set to its position. Otherwise, if there are no negative integers in the array, the variables row and col should equal the number of rows and columns in the array (we assume that each row has the same number of columns).

Short answer

Use nested loops to search. Set row and col when a negative is found and terminate the loops.

Step-by-step solution

- Loop through the Array

Create a nested loop to iterate through each element of the two-dimensional array. Use one loop to iterate through rows and another to iterate through columns.

- Check for a Negative Integer

Inside the inner loop, check if the current element is a negative integer. If a negative integer is found, set the variables row and col to the current indices and terminate both loops.

- Handle No Negatives Found

If the loops complete without finding a negative integer, set the variables row and col to the number of rows and columns, respectively.

- Write Code

Combine all steps into a complete code segment. Here's a Python example:```pythonrows = len(array)cols = len(array[0])row, col = rows, colsfound = Falsefor i in range(rows): for j in range(cols): if array[i][j] < 0: row = i col = j found = True break if found: break```

Key concepts

Nested Loops

Nested loops are a fundamental concept in programming used to traverse multi-dimensional arrays. In the given problem, we have a two-dimensional array, which can be visualized as a grid. To search through every element of this grid, we use a loop within another loop.
The outer loop iterates over the rows, while the inner loop iterates over the columns of each row. Here's how it works:

• The outer loop starts with the first row and continues to the last row.
• For each row, the inner loop goes through each column element one by one.
• When the inner loop completes one full traversal of a row, the outer loop moves to the next row and the process repeats.

This looping structure ensures that we visit each element of the 2D array exactly once.

Negative Integer Detection

Detecting a negative integer within the 2D array is the primary goal of the exercise. During the traversal of the array, each element is checked to see if it is a negative integer. This can be done using an `if` statement inside the inner loop:

if array[i][j] < 0:

When a negative integer is found, the variables `row` and `col` are set to the current indices `i` and `j`, respectively. We also set a flag `found` to `True` to indicate that the search can stop. To exit both loops immediately when a negative number is found, we use the `break` statement. First, the `break` exits the inner loop, and another `if` statement checks the `found` flag and exits the outer loop:

• Set `row` and `col` to current indices.
• Set `found` to `True`.
• Use `break` to exit the inner loop.
• Exit the outer loop if `found` is `True`.

This method ensures the search stops as soon as a negative integer is detected, saving time by not checking unnecessary elements.

Python Programming

Python is a powerful programming language well-suited for handling tasks like 2D array traversal and negative integer detection. In our example, Python's easy-to-read syntax makes constructing nested loops straightforward. Some important points to consider in Python programming for this task include:

• Using `len()` to get the number of rows and columns in a 2D array.
• Initialising variables like `row`, `col`, and `found`.
• Using `break` statements to control the flow of loops effectively.

Here's a complete Python code segment for the given problem:

rows = len(array)cols = len(array[0])row, col = rows, colsfound = Falsefor i in range(rows):    for j in range(cols):        if array[i][j] < 0:            row = i            col = j            found = True            break    if found:        break

This code uses Python's capabilities to manage array dimensions, handle conditionals, and terminate loops efficiently.

Array Traversal

Array traversal refers to the process of visiting each element in an array systematically. For a 2D array, this involves nested loops. The goal is to inspect or manipulate each element, depending on the task.
Here are some key points about array traversal:

• Ensuring every element is accessed.
• Handling different array dimensions accurately.
• Processing elements as they are visited, such as checking for negative integers.

This traversal is crucial for performing a thorough search, whether for a negative integer in our example or any other specific condition. The nested loops provide a structured way to navigate through all elements without missing any, making it a cornerstone technique in array manipulation.