C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.Linq;

public class ArrayOperations
{
    /// <summary>
    /// Perform array operations
    /// </summary>
    /// <param></param>
    /// <returns></returns>
    public static void PerformArrayOperations()
    {
        try
        {
            Console.WriteLine("Enter the size of the array:");
            if (!int.TryParse(Console.ReadLine(), out int size) || size <= 0)
            {
                Console.WriteLine("Invalid input. Array size must be a positive integer.");
                return;
            }

            int[] arr = new int[size];

            Console.WriteLine($"Enter {size} elements for the array:");
            for (int i = 0; i < size; i++)
            {
                if (!int.TryParse(Console.ReadLine(), out int element))
                {
                    Console.WriteLine("Invalid input. Please enter integers only.");
                    return;
                }
                arr[i] = element;
            }

            while (true)
            {
                Console.WriteLine("\nChoose an operation:");
                Console.WriteLine("1. Sum");
                Console.WriteLine("2. Average");
                Console.WriteLine("3. Min");
                Console.WriteLine("4. Max");
                Console.WriteLine("5. Add");
                Console.WriteLine("6. Remove");
                Console.WriteLine("7. Find Duplicates");
                Console.WriteLine("8. Display Array");
                Console.WriteLine("9. Exit");

                Console.WriteLine("Enter your choice (1-9):");

                if (!int.TryParse(Console.ReadLine(), out int choice))
                {
                    Console.WriteLine("Invalid input. Please enter a number between 1 and 9.");
                    continue;
                }

                switch (choice)
                {
                    case 1:
                        Console.WriteLine($"Sum: {CalculateSum(arr)}");
                        break;
                    case 2:
                        Console.WriteLine($"Average: {CalculateAverage(arr)}");
                        break;
                    case 3:
                        Console.WriteLine($"Min: {FindMin(arr)}");
                        break;
                    case 4:
                        Console.WriteLine($"Max: {FindMax(arr)}");
                        break;
                    case 5:
                        Console.WriteLine("Enter the element to add:");
                        if (!int.TryParse(Console.ReadLine(), out int elementToAdd))
                        {
                            Console.WriteLine("Invalid input. Please enter an integer.");
                            break;
                        }

                        if (arr.Length >= size)
                        {
                            Console.WriteLine($"Invalid Input! Please enter a number between 1 and {size}.");
                            break;
                        }

                        arr = AddElement(arr, elementToAdd);
                        Console.WriteLine("Element added.");
                        break;
                    case 6:
                        if (arr.Length == 0)
                        {
                            Console.WriteLine("No elements found in an array.");
                            break;
                        }
                        Console.WriteLine("Enter the element to remove:");
                        if (!int.TryParse(Console.ReadLine(), out int elementToRemove))
                        {
                            Console.WriteLine("Invalid input. Please enter an integer.");
                            break;
                        }
                        try
                        {
                            arr = RemoveElement(arr, elementToRemove);
                        }
                        catch (ArgumentException ex)
                        {
                            Console.WriteLine(ex.Message);
                            break;
                        }

                        Console.WriteLine("Element removed.");
                        break;
                    case 7:
                        FindDuplicates(arr);
                        break;
                    case 8:
                        DisplayArray(arr);
                        break;
                    case 9:
                        Console.WriteLine("Exiting...");
                        return;
                    default:
                        Console.WriteLine("Invalid choice. Please enter a number between 1 and 9.");
                        break;
                }
                if (arr.Length == 0 && choice != 9 && choice != 5)
                {
                    Console.WriteLine("No elements found in an array.");
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
    }

    public static int CalculateSum(int[] arr)
    {
        if (arr == null || arr.Length == 0)
        {
            return 0;
        }

        return arr.Sum();
    }

    public static double CalculateAverage(int[] arr)
    {
        if (arr == null || arr.Length == 0)
        {
            return 0;
        }

        return arr.Average();
    }

    public static int FindMin(int[] arr)
    {
        if (arr == null || arr.Length == 0)
        {
            return int.MinValue; // Or throw an exception
        }

        return arr.Min();
    }

    public static int FindMax(int[] arr)
    {
        if (arr == null || arr.Length == 0)
        {
            return int.MaxValue; // Or throw an exception
        }

        return arr.Max();
    }

    public static int[] AddElement(int[] arr, int element)
    {
        if (arr == null)
        {
            return new int[] { element };
        }

        int[] newArr = new int[arr.Length + 1];
        Array.Copy(arr, newArr, arr.Length);
        newArr[arr.Length] = element;
        return newArr;
    }

    public static int[] RemoveElement(int[] arr, int element)
    {
        if (arr == null || arr.Length == 0)
        {
            throw new ArgumentException("No elements found in an array.");
        }

        int index = Array.IndexOf(arr, element);
        if (index == -1)
        {
            throw new ArgumentException("Invalid Input! There's no such element found to remove.");
        }

        int[] newArr = new int[arr.Length - 1];
        Array.Copy(arr, 0, newArr, 0, index);
        Array.Copy(arr, index + 1, newArr, index, arr.Length - index - 1);
        return newArr;
    }

    public static void FindDuplicates(int[] arr)
    {
        if (arr == null || arr.Length == 0)
        {
            Console.WriteLine("No elements found in an array.");
            return;
        }

        var duplicates = arr.GroupBy(x => x)
                          .Where(g => g.Count() > 1)
                          .Select(g => g.Key)
                          .ToList();

        if (duplicates.Count == 0)
        {
            Console.WriteLine("No duplicates found.");
        }
        else
        {
            Console.WriteLine("Duplicates: " + string.Join(", ", duplicates));
        }
    }

    public static void DisplayArray(int[] arr)
    {
        if (arr == null || arr.Length == 0)
        {
            Console.WriteLine("No elements found in an array.");
            return;
        }

        Console.WriteLine("Array: " + string.Join(", ", arr));
    }
}

[TestFixture]
public class ArrayOperationsTests
{
    [Test]
    public void CalculateSum_ValidArray_ReturnsCorrectSum()
    {
        int[] arr = { 1, 2, 3, 4, 5 };
        Assert.That(ArrayOperations.CalculateSum(arr), Is.EqualTo(15));
    }

    [Test]
    public void CalculateSum_EmptyArray_ReturnsZero()
    {
        int[] arr = { };
        Assert.That(ArrayOperations.CalculateSum(arr), Is.EqualTo(0));
    }

    [Test]
    public void CalculateSum_NullArray_ReturnsZero()
    {
        int[] arr = null;
        Assert.That(ArrayOperations.CalculateSum(arr), Is.EqualTo(0));
    }

    [Test]
    public void CalculateAverage_ValidArray_ReturnsCorrectAverage()
    {
        int[] arr = { 1, 2, 3, 4, 5 };
        Assert.That(ArrayOperations.CalculateAverage(arr), Is.EqualTo(3));
    }

    [Test]
    public void CalculateAverage_EmptyArray_ReturnsZero()
    {
        int[] arr = { };
        Assert.That(ArrayOperations.CalculateAverage(arr), Is.EqualTo(0));
    }

    [Test]
    public void CalculateAverage_NullArray_ReturnsZero()
    {
        int[] arr = null;
        Assert.That(ArrayOperations.CalculateAverage(arr), Is.EqualTo(0));
    }

    [Test]
    public void FindMin_ValidArray_ReturnsCorrectMin()
    {
        int[] arr = { 5, 2, 8, 1, 9 };
        Assert.That(ArrayOperations.FindMin(arr), Is.EqualTo(1));
    }

    [Test]
    public void FindMin_EmptyArray_ReturnsMinValue()
    {
        int[] arr = { };
        Assert.That(ArrayOperations.FindMin(arr), Is.EqualTo(int.MinValue));
    }

    [Test]
    public void FindMin_NullArray_ReturnsMinValue()
    {
        int[] arr = null;
        Assert.That(ArrayOperations.FindMin(arr), Is.EqualTo(int.MinValue));
    }

    [Test]
    public void FindMax_ValidArray_ReturnsCorrectMax()
    {
        int[] arr = { 5, 2, 8, 1, 9 };
        Assert.That(ArrayOperations.FindMax(arr), Is.EqualTo(9));
    }

    [Test]
    public void FindMax_EmptyArray_ReturnsMaxValue()
    {
        int[] arr = { };
        Assert.That(ArrayOperations.FindMax(arr), Is.EqualTo(int.MaxValue));
    }

    [Test]
    public void FindMax_NullArray_ReturnsMaxValue()
    {
        int[] arr = null;
        Assert.That(ArrayOperations.FindMax(arr), Is.EqualTo(int.MaxValue));
    }

    [Test]
    public void AddElement_ValidArray_ReturnsNewArrayWithElementAdded()
    {
        int[] arr = { 1, 2, 3 };
        int[] expected = { 1, 2, 3, 4 };
        Assert.That(ArrayOperations.AddElement(arr, 4), Is.EqualTo(expected));
    }

    [Test]
    public void AddElement_NullArray_ReturnsNewArrayWithElementAdded()
    {
        int[] arr = null;
        int[] expected = { 4 };
        Assert.That(ArrayOperations.AddElement(arr, 4), Is.EqualTo(expected));
    }

    [Test]
    public void RemoveElement_ValidArray_ReturnsNewArrayWithElementRemoved()
    {
        int[] arr = { 1, 2, 3, 4 };
        int[] expected = { 1, 3, 4 };
        Assert.That(ArrayOperations.RemoveElement(arr, 2), Is.EqualTo(expected));
    }

     [Test]
    public void RemoveElement_ElementNotFound_ThrowsArgumentException()
    {
        int[] arr = { 1, 2, 3 };
        Assert.Throws<ArgumentException>(() => ArrayOperations.RemoveElement(arr, 4), "Invalid Input! There's no such element found to remove.");
    }

    [Test]
    public void RemoveElement_NullArray_ThrowsArgumentException()
    {
        int[] arr = null;
        Assert.Throws<ArgumentException>(() => ArrayOperations.RemoveElement(arr, 4), "No elements found in an array.");
    }

    [Test]
    public void RemoveElement_EmptyArray_ThrowsArgumentException()
    {
        int[] arr = { };
        Assert.Throws<ArgumentException>(() => ArrayOperations.RemoveElement(arr, 4), "No elements found in an array.");
    }
}

public class Program
{
    public static void Main()
    {
        new NUnitLite.AutoRun().Execute(["--noc" /*no colored output for .Net Fiddle*/]);
    }
}

​x
 
using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.Linq;
​
public class ArrayOperations
{
    /// <summary>
    /// Perform array operations
    /// </summary>
    /// <param></param>
    /// <returns></returns>
    public static void PerformArrayOperations()
    {
        try
        {
            Console.WriteLine("Enter the size of the array:");
            if (!int.TryParse(Console.ReadLine(), out int size) || size <= 0)
            {
                Console.WriteLine("Invalid input. Array size must be a positive integer.");
                return;
            }
​
            int[] arr = new int[size];
​
            Console.WriteLine($"Enter {size} elements for the array:");
            for (int i = 0; i < size; i++)
            {
                if (!int.TryParse(Console.ReadLine(), out int element))
                {
                    Console.WriteLine("Invalid input. Please enter integers only.");
                    return;
                }
                arr[i] = element;
            }
​
            while (true)
            {
                Console.WriteLine("\nChoose an operation:");
                Console.WriteLine("1. Sum");
                Console.WriteLine("2. Average");
                Console.WriteLine("3. Min");
                Console.WriteLine("4. Max");
                Console.WriteLine("5. Add");
                Console.WriteLine("6. Remove");
                Console.WriteLine("7. Find Duplicates");
                Console.WriteLine("8. Display Array");
                Console.WriteLine("9. Exit");
​
                Console.WriteLine("Enter your choice (1-9):");
​
                if (!int.TryParse(Console.ReadLine(), out int choice))
                {
                    Console.WriteLine("Invalid input. Please enter a number between 1 and 9.");
                    continue;
                }
​
                switch (choice)
                {
                    case 1:
                        Console.WriteLine($"Sum: {CalculateSum(arr)}");
                        break;
                    case 2:
                        Console.WriteLine($"Average: {CalculateAverage(arr)}");
                        break;
                    case 3:
                        Console.WriteLine($"Min: {FindMin(arr)}");
                        break;
                    case 4:
                        Console.WriteLine($"Max: {FindMax(arr)}");
                        break;
                    case 5:
                        Console.WriteLine("Enter the element to add:");
                        if (!int.TryParse(Console.ReadLine(), out int elementToAdd))
                        {
                            Console.WriteLine("Invalid input. Please enter an integer.");
                            break;
                        }
​
                        if (arr.Length >= size)
                        {
                            Console.WriteLine($"Invalid Input! Please enter a number between 1 and {size}.");
                            break;
                        }
​
                        arr = AddElement(arr, elementToAdd);
                        Console.WriteLine("Element added.");
                        break;
                    case 6:
                        if (arr.Length == 0)
                        {
                            Console.WriteLine("No elements found in an array.");
                            break;
                        }
                        Console.WriteLine("Enter the element to remove:");
                        if (!int.TryParse(Console.ReadLine(), out int elementToRemove))
                        {
                            Console.WriteLine("Invalid input. Please enter an integer.");
                            break;
                        }
                        try
                        {
                            arr = RemoveElement(arr, elementToRemove);
                        }
                        catch (ArgumentException ex)
                        {
                            Console.WriteLine(ex.Message);
                            break;
                        }
​
                        Console.WriteLine("Element removed.");
                        break;
                    case 7:
                        FindDuplicates(arr);
                        break;
                    case 8:
                        DisplayArray(arr);
                        break;
                    case 9:
                        Console.WriteLine("Exiting...");
                        return;
                    default:
                        Console.WriteLine("Invalid choice. Please enter a number between 1 and 9.");
                        break;
                }
                if (arr.Length == 0 && choice != 9 && choice != 5)
                {
                    Console.WriteLine("No elements found in an array.");
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
    }
​
    public static int CalculateSum(int[] arr)
    {
        if (arr == null || arr.Length == 0)
        {
            return 0;
        }
​
        return arr.Sum();
    }
​
    public static double CalculateAverage(int[] arr)
    {
        if (arr == null || arr.Length == 0)
        {
            return 0;
        }
​
        return arr.Average();
    }
​
    public static int FindMin(int[] arr)
    {
        if (arr == null || arr.Length == 0)
        {
            return int.MinValue; // Or throw an exception
        }
​
        return arr.Min();
    }
​
    public static int FindMax(int[] arr)
    {
        if (arr == null || arr.Length == 0)
        {
            return int.MaxValue; // Or throw an exception
        }
​
        return arr.Max();
    }
​
    public static int[] AddElement(int[] arr, int element)
    {
        if (arr == null)
        {
            return new int[] { element };
        }
​
        int[] newArr = new int[arr.Length + 1];
        Array.Copy(arr, newArr, arr.Length);
        newArr[arr.Length] = element;
        return newArr;
    }
​
    public static int[] RemoveElement(int[] arr, int element)
    {
        if (arr == null || arr.Length == 0)
        {
            throw new ArgumentException("No elements found in an array.");
        }
​
        int index = Array.IndexOf(arr, element);
        if (index == -1)
        {
            throw new ArgumentException("Invalid Input! There's no such element found to remove.");
        }
​
        int[] newArr = new int[arr.Length - 1];
        Array.Copy(arr, 0, newArr, 0, index);
        Array.Copy(arr, index + 1, newArr, index, arr.Length - index - 1);
        return newArr;
    }
​
    public static void FindDuplicates(int[] arr)
    {
        if (arr == null || arr.Length == 0)
        {
            Console.WriteLine("No elements found in an array.");
            return;
        }
​
        var duplicates = arr.GroupBy(x => x)
                          .Where(g => g.Count() > 1)
                          .Select(g => g.Key)
                          .ToList();
​
        if (duplicates.Count == 0)
        {
            Console.WriteLine("No duplicates found.");
        }
        else
        {
            Console.WriteLine("Duplicates: " + string.Join(", ", duplicates));
        }
    }
​
    public static void DisplayArray(int[] arr)
    {
        if (arr == null || arr.Length == 0)
        {
            Console.WriteLine("No elements found in an array.");
            return;
        }
​
        Console.WriteLine("Array: " + string.Join(", ", arr));
    }
}
​
[TestFixture]
public class ArrayOperationsTests
{
    [Test]
    public void CalculateSum_ValidArray_ReturnsCorrectSum()
    {
        int[] arr = { 1, 2, 3, 4, 5 };
        Assert.That(ArrayOperations.CalculateSum(arr), Is.EqualTo(15));
    }
​
    [Test]
    public void CalculateSum_EmptyArray_ReturnsZero()
    {
        int[] arr = { };
        Assert.That(ArrayOperations.CalculateSum(arr), Is.EqualTo(0));
    }
​
    [Test]
    public void CalculateSum_NullArray_ReturnsZero()
    {
        int[] arr = null;
        Assert.That(ArrayOperations.CalculateSum(arr), Is.EqualTo(0));
    }
​
    [Test]
    public void CalculateAverage_ValidArray_ReturnsCorrectAverage()
    {
        int[] arr = { 1, 2, 3, 4, 5 };
        Assert.That(ArrayOperations.CalculateAverage(arr), Is.EqualTo(3));
    }
​
    [Test]
    public void CalculateAverage_EmptyArray_ReturnsZero()
    {
        int[] arr = { };
        Assert.That(ArrayOperations.CalculateAverage(arr), Is.EqualTo(0));
    }
​
    [Test]
    public void CalculateAverage_NullArray_ReturnsZero()
    {
        int[] arr = null;
        Assert.That(ArrayOperations.CalculateAverage(arr), Is.EqualTo(0));
    }
​
    [Test]
    public void FindMin_ValidArray_ReturnsCorrectMin()
    {
        int[] arr = { 5, 2, 8, 1, 9 };
        Assert.That(ArrayOperations.FindMin(arr), Is.EqualTo(1));
    }
​
    [Test]
    public void FindMin_EmptyArray_ReturnsMinValue()
    {
        int[] arr = { };
        Assert.That(ArrayOperations.FindMin(arr), Is.EqualTo(int.MinValue));
    }
​
    [Test]
    public void FindMin_NullArray_ReturnsMinValue()
    {
        int[] arr = null;
        Assert.That(ArrayOperations.FindMin(arr), Is.EqualTo(int.MinValue));
    }
​
    [Test]
    public void FindMax_ValidArray_ReturnsCorrectMax()
    {
        int[] arr = { 5, 2, 8, 1, 9 };
        Assert.That(ArrayOperations.FindMax(arr), Is.EqualTo(9));
    }
​
    [Test]
    public void FindMax_EmptyArray_ReturnsMaxValue()
    {
        int[] arr = { };
        Assert.That(ArrayOperations.FindMax(arr), Is.EqualTo(int.MaxValue));
    }
​
    [Test]
    public void FindMax_NullArray_ReturnsMaxValue()
    {
        int[] arr = null;
        Assert.That(ArrayOperations.FindMax(arr), Is.EqualTo(int.MaxValue));
    }
​
    [Test]
    public void AddElement_ValidArray_ReturnsNewArrayWithElementAdded()
    {
        int[] arr = { 1, 2, 3 };
        int[] expected = { 1, 2, 3, 4 };
        Assert.That(ArrayOperations.AddElement(arr, 4), Is.EqualTo(expected));
    }
​
    [Test]
    public void AddElement_NullArray_ReturnsNewArrayWithElementAdded()
    {
        int[] arr = null;
        int[] expected = { 4 };
        Assert.That(ArrayOperations.AddElement(arr, 4), Is.EqualTo(expected));
    }
​
    [Test]
    public void RemoveElement_ValidArray_ReturnsNewArrayWithElementRemoved()
    {
        int[] arr = { 1, 2, 3, 4 };
        int[] expected = { 1, 3, 4 };
        Assert.That(ArrayOperations.RemoveElement(arr, 2), Is.EqualTo(expected));
    }
​
     [Test]
    public void RemoveElement_ElementNotFound_ThrowsArgumentException()
    {
        int[] arr = { 1, 2, 3 };
        Assert.Throws<ArgumentException>(() => ArrayOperations.RemoveElement(arr, 4), "Invalid Input! There's no such element found to remove.");
    }
​
    [Test]
    public void RemoveElement_NullArray_ThrowsArgumentException()
    {
        int[] arr = null;
        Assert.Throws<ArgumentException>(() => ArrayOperations.RemoveElement(arr, 4), "No elements found in an array.");
    }
​
    [Test]
    public void RemoveElement_EmptyArray_ThrowsArgumentException()
    {
        int[] arr = { };
        Assert.Throws<ArgumentException>(() => ArrayOperations.RemoveElement(arr, 4), "No elements found in an array.");
    }
}
​
public class Program
{
    public static void Main()
    {
        new NUnitLite.AutoRun().Execute(["--noc" /*no colored output for .Net Fiddle*/]);
    }
}

View IL Code