Python – Incremental K sized Row Matrix Initialization

Sometimes, while working with Python, we can have a problem in which we need to perform initialization of matrix with Incremental numbers. This kind of application can come in Data Science domain. Let’s discuss certain ways in which this task can be performed. 

Method #1: Using loop + list slicing This task can be performed in brute way using loop. In this, we run a loop skipping by K (size of row required), to adjust numbers addition ahead.

The Incremental Initialized Matrix is : [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Time Complexity: O(n) where n is the number of elements in the list “test_list”.  
Auxiliary Space: O(n), where n is the number of elements in the new res list 

Method #2: Using list comprehension This is just another way to perform this task. This performs in similar way as above, but in a shorter way. 

The Incremental Initialized Matrix is : [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Time complexity: O(N), where N is the number of rows in the resulting matrix. The list comprehension iterates over the range (1, 10, K), which generates N values, where N is equal to (10 – 1) // K + 1.
Auxiliary space: O(NK), where N is the number of rows and K is the number of columns in the resulting matrix. 

Method #3 : Using Numpy Library
We can perform this task using numpy library. Numpy is a library for mathematical operations. It can be used to perform matrix operations.

Output:

The Incremental Initialized Matrix is : 
[[1 2 3]
[4 5 6]
[7 8 9]]

Time complexity: O(N*K)
Auxiliary Space: O(N*K) where N is the number of rows and K is the number of elements in each row.

Method 4: Using itertools

The itertools.count() function creates an iterator that starts from the first argument (1 in this case) and increments by the second argument (1 in this case) each time next() is called on it.

The list comprehension creates a 3xK matrix by iterating over the range of 3 (i.e. creating 3 rows) and then using another list comprehension to create each row with K elements. The next(iter) function call inside the inner list comprehension gets the next value from the iterator created using itertools.count(). Finally, the initialized matrix is printed.

The Incremental Initialized Matrix is : [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Time complexity: O(N), where N is the number of elements in the matrix. 
Auxiliary space: O(N) because the entire matrix is stored in memory.

Method #5: Using list constructor and range function

Step-by-step approach:

• Set the value of K and num_rows to determine the size of the matrix to be created.
• Generate a list of values to be used in the matrix using a list comprehension and the range function. The values are generated incrementally starting from 1 up to K * num_rows.
• Create the matrix using another list comprehension. This creates a list of lists, with each inner list containing K elements from the matrix_values list. The range function is used to select the appropriate range of indices for each row.
• Print the final matrix using the print statement.

Below is the implementation of the above approach:

The Incremental Initialized Matrix is : [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Time complexity: O(Knum_rows)
Auxiliary space: O(Knum_rows), since it creates a list of values for the entire matrix before converting it into a list of lists.

Method 6: Using nested for loops and append()

Step-by-Step Approach:

• Set the row size K and the number of rows num_rows.
• Create an empty list called matrix.
• Use a for loop to iterate through each row of the matrix. The loop variable i goes from 0 to num_rows – 1.
• Inside the first loop, create another empty list called row.
• Use another for loop to iterate through each element of the current row. The loop variable j goes from 0 to K – 1.
• Inside the second loop, append the value i*K + j + 1 to the row list.
• After the second loop, append the row list to the matrix list.
• After the first loop, the matrix list will contain all the rows of the matrix.
• Print the matrix list.

Below is the implementation of the above approach:

The Incremental Initialized Matrix is : [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Time Complexity: O(Knum_rows)
Auxiliary Space: O(Knum_rows)

Method 7: Using map() and lambda function

The Incremental Initialized Matrix is : [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Time complexity: O(num_rows * K)
Auxiliary Space: O(num_rows * K)