# Importing the threading and time modules
import threading
import time

# Defining the matrix to be transposed
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# Printing the original matrix
print("Original matrix:")
for row in matrix:
    print(row)

# Defining a function to transpose a matrix using a single thread
def single_threaded_transpose(matrix):
    # Creating an empty list to store the transposed matrix
    transposed = []
    # Iterating over the columns of the matrix
    for i in range(len(matrix[0])):
        # Creating an empty list to store the current column
        column = []
        # Iterating over the rows of the matrix
        for j in range(len(matrix)):
            # Appending the element at row j and column i to the column list
            column.append(matrix[j][i])
        # Appending the column list to the transposed list
        transposed.append(column)
    # Returning the transposed list
    return transposed

# Defining a function to transpose a matrix using multiple threads
def multi_threaded_transpose(matrix):
    # Creating an empty list to store the transposed matrix
    transposed = []
    # Creating a lock object to synchronize the access to the transposed list
    lock = threading.Lock()
    # Defining a function to transpose a single column of the matrix
    def transpose_column(i):
        # Creating an empty list to store the current column
        column = []
        # Iterating over the rows of the matrix
        for j in range(len(matrix)):
            # Appending the element at row j and column i to the column list
            column.append(matrix[j][i])
        # Acquiring the lock to prevent other threads from modifying the transposed list
        lock.acquire()
        # Appending the column list to the transposed list
        transposed.append(column)
        # Releasing the lock to allow other threads to access the transposed list
        lock.release()
    # Creating a list to store the thread objects
    threads = []
    # Iterating over the columns of the matrix
    for i in range(len(matrix[0])):
        # Creating a thread object that executes the transpose_column function with the current column index
        thread = threading.Thread(target=transpose_column, args=(i,))
        # Starting the thread
        thread.start()
        # Appending the thread object to the threads list
        threads.append(thread)
    # Iterating over the threads list
    for thread in threads:
        # Waiting for the thread to finish
        thread.join()
    # Returning the transposed list
    return transposed

# Measuring the execution time of the single-threaded solution
start_time = time.time()
single_threaded_result = single_threaded_transpose(matrix)
end_time = time.time()
single_threaded_time = end_time - start_time

# Measuring the execution time of the multi-threaded solution
start_time = time.time()
multi_threaded_result = multi_threaded_transpose(matrix)
end_time = time.time()
multi_threaded_time = end_time - start_time

# Printing the results
print("Single-threaded solution:")
for row in single_threaded_result:
    print(row)
print(f"Execution time: {single_threaded_time} seconds")

print("Multi-threaded solution:")
for row in multi_threaded_result:
    print(row)
print(f"Execution time: {multi_threaded_time} seconds")

# Comparing the results
if single_threaded_time < multi_threaded_time:
    print("The single-threaded solution is faster than the multi-threaded solution.")
elif single_threaded_time > multi_threaded_time:
    print("The multi-threaded solution is faster than the single-threaded solution.")
else:
    print("The single-threaded and multi-threaded solutions have the same execution time.")