C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
using System.Collections.Generic;

public class MatrixTransposer
{
    /// <summary>
    /// Transposes a matrix entered by the user, handling mixed data types and transformations.
    /// </summary>
    public static void TransposeMatrix()
    {
        Console.WriteLine("Enter the number of rows:");
        if (!int.TryParse(Console.ReadLine(), out int numRows) || numRows <= 0)
        {
            Console.WriteLine("Invalid number of rows. Please enter a positive integer.");
            return;
        }

        List<object[]> matrix = new List<object[]>();

        for (int i = 0; i < numRows; i++)
        {
            Console.WriteLine($"Enter the elements for row {i + 1} (comma-separated, can include strings, numbers, true/false, or function names):");
            string rowInput = Console.ReadLine();
            if (string.IsNullOrWhiteSpace(rowInput))
            {
                matrix.Add(new object[0]); // Add an empty row
                continue;
            }

            string[] elements = rowInput.Split(',');
            object[] row = new object[elements.Length];

            for (int j = 0; j < elements.Length; j++)
            {
                string element = elements[j].Trim();
                if (string.IsNullOrEmpty(element))
                {
                    row[j] = null;
                    continue;
                }

                if (double.TryParse(element, out double number))
                {
                    row[j] = (float)number;
                }
                else if (bool.TryParse(element, out bool boolean))
                {
                    row[j] = boolean ? 1.0f : 0.0f;
                }
                else if (element.StartsWith("()=>")) // Function literal check
                {
                    string functionBody = element.Substring(4);
                    try
                    {
                        // Basic function execution (very limited and potentially unsafe)
                        // Consider using a safer scripting engine for more complex functions
                        if (functionBody.StartsWith("\"") && functionBody.EndsWith("\""))
                        {
                            row[j] = functionBody.Substring(1, functionBody.Length - 2); // String function
                        }
                        else
                        {
                            row[j] = Convert.ToSingle(new System.Data.DataTable().Compute(functionBody, null)); // Numeric function
                        }
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"Error executing function '{element}': {ex.Message}");
                        row[j] = null; // Handle function execution errors
                    }
                }
                else
                {
                    row[j] = element.ToUpper();
                }
            }
            matrix.Add(row);
        }

        // Transform and Print the Matrix
        List<object[]> transformedMatrix = TransformMatrix(matrix);
        Console.WriteLine("\nTransformed Matrix:");
        PrintMatrix(transformedMatrix);

        // Transpose and Print the Transposed Matrix
        List<object[]> transposedMatrix = Transpose(transformedMatrix);
        Console.WriteLine("\nTransposed Matrix:");
        PrintMatrix(transposedMatrix);
    }

    /// <summary>
    /// Transforms the input matrix, converting strings to uppercase, numbers to floats, and booleans to 1/0.
    /// </summary>
    /// <param name="matrix">The input matrix.</param>
    /// <returns>The transformed matrix.</returns>
    public static List<object[]> TransformMatrix(List<object[]> matrix)
    {
        List<object[]> transformedMatrix = new List<object[]>();
        foreach (object[] row in matrix)
        {
            object[] transformedRow = new object[row.Length];
            for (int i = 0; i < row.Length; i++)
            {
                if (row[i] == null)
                {
                    transformedRow[i] = null;
                }
                else if (row[i] is string)
                {
                    transformedRow[i] = ((string)row[i]).ToUpper();
                }
                else if (row[i] is int)
                {
                    transformedRow[i] = (float)(int)row[i];
                }
                else if (row[i] is double)
                {
                    transformedRow[i] = (float)(double)row[i];
                }
                else if (row[i] is bool)
                {
                    transformedRow[i] = ((bool)row[i]) ? 1.0f : 0.0f;
                }
                else
                {
                    transformedRow[i] = row[i];
                }
            }
            transformedMatrix.Add(transformedRow);
        }
        return transformedMatrix;
    }


    /// <summary>
    /// Transposes a given matrix.
    /// </summary>
    /// <param name="matrix">The matrix to transpose.</param>
    /// <returns>The transposed matrix.</returns>
    public static List<object[]> Transpose(List<object[]> matrix)
    {
        if (matrix == null || matrix.Count == 0)
        {
            return new List<object[]>();
        }

        int maxRowLength = 0;
        foreach (object[] row in matrix)
        {
            if (row != null && row.Length > maxRowLength)
            {
                maxRowLength = row.Length;
            }
        }

        List<object[]> transposedMatrix = new List<object[]>();
        for (int j = 0; j < maxRowLength; j++)
        {
            object[] newRow = new object[matrix.Count];
            for (int i = 0; i < matrix.Count; i++)
            {
                if (matrix[i] != null && j < matrix[i].Length)
                {
                    newRow[i] = matrix[i][j];
                }
                else
                {
                    newRow[i] = null;
                }
            }
            transposedMatrix.Add(newRow);
        }

        return transposedMatrix;
    }

    /// <summary>
    /// Prints a matrix to the console.
    /// </summary>
    /// <param name="matrix">The matrix to print.</param>
    public static void PrintMatrix(List<object[]> matrix)
    {
        Console.WriteLine("[");
        foreach (object[] row in matrix)
        {
            Console.Write("   ");
            if (row == null)
            {
                Console.WriteLine("null");
                continue;
            }
            for (int i = 0; i < row.Length; i++)
            {
                Console.Write(row[i] != null ? row[i].ToString() : "null");
                if (i < row.Length - 1)
                {
                    Console.Write(", ");
                }
            }
            Console.WriteLine();
        }
        Console.WriteLine("]");
    }

    public static void Main(string[] args)
    {
        TransposeMatrix();
    }
}

​x
 
using System;
using System.Collections.Generic;
​
public class MatrixTransposer
{
    /// <summary>
    /// Transposes a matrix entered by the user, handling mixed data types and transformations.
    /// </summary>
    public static void TransposeMatrix()
    {
        Console.WriteLine("Enter the number of rows:");
        if (!int.TryParse(Console.ReadLine(), out int numRows) || numRows <= 0)
        {
            Console.WriteLine("Invalid number of rows. Please enter a positive integer.");
            return;
        }
​
        List<object[]> matrix = new List<object[]>();
​
        for (int i = 0; i < numRows; i++)
        {
            Console.WriteLine($"Enter the elements for row {i + 1} (comma-separated, can include strings, numbers, true/false, or function names):");
            string rowInput = Console.ReadLine();
            if (string.IsNullOrWhiteSpace(rowInput))
            {
                matrix.Add(new object[0]); // Add an empty row
                continue;
            }
​
            string[] elements = rowInput.Split(',');
            object[] row = new object[elements.Length];
​
            for (int j = 0; j < elements.Length; j++)
            {
                string element = elements[j].Trim();
                if (string.IsNullOrEmpty(element))
                {
                    row[j] = null;
                    continue;
                }
​
                if (double.TryParse(element, out double number))
                {
                    row[j] = (float)number;
                }
                else if (bool.TryParse(element, out bool boolean))
                {
                    row[j] = boolean ? 1.0f : 0.0f;
                }
                else if (element.StartsWith("()=>")) // Function literal check
                {
                    string functionBody = element.Substring(4);
                    try
                    {
                        // Basic function execution (very limited and potentially unsafe)
                        // Consider using a safer scripting engine for more complex functions
                        if (functionBody.StartsWith("\"") && functionBody.EndsWith("\""))
                        {
                            row[j] = functionBody.Substring(1, functionBody.Length - 2); // String function
                        }
                        else
                        {
                            row[j] = Convert.ToSingle(new System.Data.DataTable().Compute(functionBody, null)); // Numeric function
                        }
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"Error executing function '{element}': {ex.Message}");
                        row[j] = null; // Handle function execution errors
                    }
                }
                else
                {
                    row[j] = element.ToUpper();
                }
            }
            matrix.Add(row);
        }
​
        // Transform and Print the Matrix
        List<object[]> transformedMatrix = TransformMatrix(matrix);
        Console.WriteLine("\nTransformed Matrix:");
        PrintMatrix(transformedMatrix);
​
        // Transpose and Print the Transposed Matrix
        List<object[]> transposedMatrix = Transpose(transformedMatrix);
        Console.WriteLine("\nTransposed Matrix:");
        PrintMatrix(transposedMatrix);
    }
​
    /// <summary>
    /// Transforms the input matrix, converting strings to uppercase, numbers to floats, and booleans to 1/0.
    /// </summary>
    /// <param name="matrix">The input matrix.</param>
    /// <returns>The transformed matrix.</returns>
    public static List<object[]> TransformMatrix(List<object[]> matrix)
    {
        List<object[]> transformedMatrix = new List<object[]>();
        foreach (object[] row in matrix)
        {
            object[] transformedRow = new object[row.Length];
            for (int i = 0; i < row.Length; i++)
            {
                if (row[i] == null)
                {
                    transformedRow[i] = null;
                }
                else if (row[i] is string)
                {
                    transformedRow[i] = ((string)row[i]).ToUpper();
                }
                else if (row[i] is int)
                {
                    transformedRow[i] = (float)(int)row[i];
                }
                else if (row[i] is double)
                {
                    transformedRow[i] = (float)(double)row[i];
                }
                else if (row[i] is bool)
                {
                    transformedRow[i] = ((bool)row[i]) ? 1.0f : 0.0f;
                }
                else
                {
                    transformedRow[i] = row[i];
                }
            }
            transformedMatrix.Add(transformedRow);
        }
        return transformedMatrix;
    }
​
​
    /// <summary>
    /// Transposes a given matrix.
    /// </summary>
    /// <param name="matrix">The matrix to transpose.</param>
    /// <returns>The transposed matrix.</returns>
    public static List<object[]> Transpose(List<object[]> matrix)
    {
        if (matrix == null || matrix.Count == 0)
        {
            return new List<object[]>();
        }
​
        int maxRowLength = 0;
        foreach (object[] row in matrix)
        {
            if (row != null && row.Length > maxRowLength)
            {
                maxRowLength = row.Length;
            }
        }
​
        List<object[]> transposedMatrix = new List<object[]>();
        for (int j = 0; j < maxRowLength; j++)
        {
            object[] newRow = new object[matrix.Count];
            for (int i = 0; i < matrix.Count; i++)
            {
                if (matrix[i] != null && j < matrix[i].Length)
                {
                    newRow[i] = matrix[i][j];
                }
                else
                {
                    newRow[i] = null;
                }
            }
            transposedMatrix.Add(newRow);
        }
​
        return transposedMatrix;
    }
​
    /// <summary>
    /// Prints a matrix to the console.
    /// </summary>
    /// <param name="matrix">The matrix to print.</param>
    public static void PrintMatrix(List<object[]> matrix)
    {
        Console.WriteLine("[");
        foreach (object[] row in matrix)
        {
            Console.Write("   ");
            if (row == null)
            {
                Console.WriteLine("null");
                continue;
            }
            for (int i = 0; i < row.Length; i++)
            {
                Console.Write(row[i] != null ? row[i].ToString() : "null");
                if (i < row.Length - 1)
                {
                    Console.Write(", ");
                }
            }
            Console.WriteLine();
        }
        Console.WriteLine("]");
    }
​
    public static void Main(string[] args)
    {
        TransposeMatrix();
    }
}

395

Last Run:	11:42:45 am
Compile:	0.171s
Execute:	0s
Memory:	0b
CPU:	0s

View IL Code