Python Program to convert a list into matrix with size of each row increasing by a number

Given a list and a number N, the task here is to write a python program to convert it to matrix where each row has N elements more than previous row elements from list.

Input : test_list = [4, 6, 8, 1, 2, 9, 0, 10, 12, 3, 9, 1], N = 3
Output : [[4, 6, 8], [4, 6, 8, 1, 2, 9], [4, 6, 8, 1, 2, 9, 0, 10, 12], [4, 6, 8, 1, 2, 9, 0, 10, 12, 3, 9, 1]]
Explanation : Each row has 3 elements more than previous row.

Input : test_list = [4, 6, 8, 1, 2, 9, 0, 10, 12, 3, 9, 1], N = 4
Output : [[4, 6, 8, 1], [4, 6, 8, 1, 2, 9, 0, 10], [4, 6, 8, 1, 2, 9, 0, 10, 12, 3, 9, 1]]
Explanation : Each row has 4 elements more than previous row.

Method 1: Using loop and slicing

In this, we perform the task of getting chunks using slicing, and the conversion of the list into a Matrix is done using a loop.

Program:

# Initializing list
test_list = [4, 6, 8, 1, 2, 9, 0, 10, 12, 3, 9, 1]

# Printing original list
print("The original list is : " + str(test_list))

# initializing N
N = 3

# Empty list
res = []

for idx in range(0, len(test_list) // N):

    # Getting incremented chunks
    res.append(test_list[0: (idx + 1) * N])

# Printing result
print("Constructed Chunk Matrix : " + str(res))

The original list is : [4, 6, 8, 1, 2, 9, 0, 10, 12, 3, 9, 1]
Constructed Chunk Matrix : [[4, 6, 8], [4, 6, 8, 1, 2, 9], [4, 6, 8, 1, 2, 9, 0, 10, 12], [4, 6, 8, 1, 2, 9, 0, 10, 12, 3, 9, 1]]

Time Complexity: O(m*n), where m is the row and n is the column of the matrix
Auxiliary Space: O(k), where k is the size of the matrix

Method 2: Using list comprehension and list slicing 

In this, we perform the task of setting values using list comprehension as a shorthand. Rest all the operations are done similarly to the above method.

Program:

# initializing list
test_list = [4, 6, 8, 1, 2, 9, 0, 10, 12, 3, 9, 1]

# printing original list
print("The original list is : " + str(test_list))

# initializing N
N = 3

# getting incremented chunks
# using list comprehension as shorthand
res = [test_list[0: (idx + 1) * N] for idx in range(0, len(test_list) // N)]

# printing result
print("Constructed Chunk Matrix : " + str(res))

The original list is : [4, 6, 8, 1, 2, 9, 0, 10, 12, 3, 9, 1]
Constructed Chunk Matrix : [[4, 6, 8], [4, 6, 8, 1, 2, 9], [4, 6, 8, 1, 2, 9, 0, 10, 12], [4, 6, 8, 1, 2, 9, 0, 10, 12, 3, 9, 1]]

Time Complexity: O(m*n)
Auxiliary Space: O(k)

Method 3: Using the numpy library's reshape() method.

Here's the step-by-step approach:

1. Import the numpy library.
    
2. Initialize the input list and the chunk size.
    
3. Convert the input list to a numpy array.
    
4. Reshape the array to have N columns and as many rows as necessary.
    
5. Convert the chunk matrix back to a Python list.
    
6. Print the result.

import numpy as np

# initializing list
test_list = [4, 6, 8, 1, 2, 9, 0, 10, 12, 3, 9, 1]

# printing original list
print("The original list is : " + str(test_list))

# initializing N
N = 3

# convert list to numpy array
arr = np.array(test_list)

# reshape array into chunk matrix
chunk_matrix = arr.reshape(-1, N)

# convert chunk matrix back to list
res = chunk_matrix.tolist()

# printing result
print("Constructed Chunk Matrix : " + str(res))

OUTPUT:

The original list is : [4, 6, 8, 1, 2, 9, 0, 10, 12, 3, 9, 1]
Constructed Chunk Matrix : [[4, 6, 8], [1, 2, 9], [0, 10, 12], [3, 9, 1]]

Time complexity: O(n), where n is the size of the input list. 
Auxiliary space: O(n) for the numpy array, but it is converted back to a Python list, so the overall space complexity is also O(n).

Method 4: Using a recursive function

1. Create a list called test_list containing 12 integers.
2. Initialize a variable called N to 3, which will be used as the chunk size.
3. Define a function called chunk_list 
   • In the chunk_list function, check if the length of the list is less than or equal to the chunk size. If so, return a list containing the original list.
   • If the length of the list is greater than the chunk size, slice the list from the beginning to the chunk size and append it to a new list using the + operator. Then recursively call the chunk_list function with the remaining part of the list until the sublist is less than or equal to the chunk size.
4. Call the chunk_list function with test_list and N as arguments and assign the result to a variable called res.
5. Print the constructed chunk matrix using the print() function, the string "Constructed Chunk Matrix: ", and the str() function to convert the result to a string.

# Initializing list
test_list = [4, 6, 8, 1, 2, 9, 0, 10, 12, 3, 9, 1]

# Printing original list
print("The original list is : " + str(test_list))

# Initializing N
N = 3

def chunk_list(lst, n):
    if len(lst) <= n:
        return [lst]
    else:
        return [lst[:n]] + chunk_list(lst[n:], n)

res = chunk_list(test_list, N)

# Printing result
print("Constructed Chunk Matrix : " + str(res))

The original list is : [4, 6, 8, 1, 2, 9, 0, 10, 12, 3, 9, 1]
Constructed Chunk Matrix : [[4, 6, 8], [1, 2, 9], [0, 10, 12], [3, 9, 1]]

Time complexity: O(N * (L/N)) = O(L), where L is the length of the original list and N is the chunk size. 
Auxiliary space: O(L), as it creates a new list for each chunk of the original list. 

Method 5: Using the itertools module

 can use the zip_longest function from the itertools module to chunk the list into sublists of size N. This method fills the last sublist with a specified value (in this case, None) if its length is less than N.

from itertools import zip_longest

# Initializing list
test_list = [4, 6, 8, 1, 2, 9, 0, 10, 12, 3, 9, 1]

# printing original list
print("The original list is: " + str(test_list))

# Initializing N
N = 3


def chunk_list(lst, n):
    return [list(filter(None, sublist)) for sublist in zip_longest(*[iter(lst)] * n)]


res = chunk_list(test_list, N)

# Printing result
print("Constructed Chunk Matrix: " + str(res))

The original list is: [4, 6, 8, 1, 2, 9, 0, 10, 12, 3, 9, 1]
Constructed Chunk Matrix: [[4, 6, 8], [1, 2, 9], [10, 12], [3, 9, 1]]

Time Complexity: O(N * M), where N is the length of the list and M is the chunk size.
Auxiliary Space: O(N), where N is the length of the list, as the result is stored in a new list.