using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        SparseMatrix matrix1 = new SparseMatrix(3, 5);

        matrix1.NotSparseMatrix += delegate { Console.WriteLine($"Matrix isnt sparse, because sparsity is lower than 0.5"); };

        matrix1[0, 0] = 1;
        matrix1[0, 1] = 2;
        matrix1[0, 2] = 0;
        matrix1[0, 3] = 0;
        matrix1[0, 4] = 3;
        matrix1[1, 0] = 4;
        matrix1[1, 1] = 0;
        matrix1[1, 2] = 0;
        matrix1[1, 3] = 0;
        matrix1[1, 4] = 0;
        matrix1[2, 0] = 0;
        matrix1[2, 1] = 5;
        matrix1[2, 2] = 0;
        matrix1[2, 3] = 6;
        matrix1[2, 4] = 0;
        Console.WriteLine(matrix1[0,1]);
        Console.WriteLine(matrix1);


        foreach(var item in matrix1)
        {
            Console.WriteLine(item);
        }

        var NotZeroElements = matrix1.GetNonzeroElements();
        foreach(var item in NotZeroElements)
        {
            Console.WriteLine(item);
        }

        Console.WriteLine(matrix1.GetCount(0));
        Console.WriteLine(matrix1.GetCount(1));
    }
}

class SparseMatrix: IEnumerable<int>
{

    public int N { get; }

    public int M { get; }

    private int _version;

    private List<(int, int, int)> NotZeroElements = new List<(int, int, int)> { };

    public SparseMatrix(int n = 0, int m = 0)
    {
        if (n > 0 && m > 0)
        {
            N = n;
            M = m;
        }
        else
        {
            throw new ArgumentException();
        }
    }

    public int this[int i, int j]
    {
        get
        {
            if (IsCorrect(i, j))
            {
                for (int k = 0; k < NotZeroElements.Count; k++)
                {
                    if (NotZeroElements[k].Item1 == i && NotZeroElements[k].Item2 == j)
                    {
                        return NotZeroElements[k].Item3;
                    }
                }
                return 0;
            }
            throw new IndexOutOfRangeException();
        }

        set
        {
            if (IsCorrect(i, j))
            {
                if (value != 0)
                {
                    NotZeroElements.Add((i, j, value));
                    _version++;
                }

                double Sparsity = 1 - ((double) NotZeroElements.Count / (N * M));


                if (Sparsity <= 0.5)
                {
                    OnNotSparseMatrix(new NotSparseMatrixEventArgs(Sparsity));
                }
            }
            else throw new IndexOutOfRangeException();
        }

    }
    public event EventHandler NotSparseMatrix;

    public delegate void EventHandler(object sender, NotSparseMatrixEventArgs e);

    public override string ToString()
    {
        var result = new StringBuilder();
        var k = 0;

        for (var i = 0; i < N; i++)
        {
            for (var j = 0; j < M; j++)
            {
                if(k==NotZeroElements.Count)
                {
                    result.Append("0");
                    continue;
                }
                for (; k < NotZeroElements.Count;)
                {
                    if (NotZeroElements[k].Item1 == i && NotZeroElements[k].Item2 == j)
                    {
                        result.Append(NotZeroElements[k].Item3.ToString());
                        k++;
                        break;
                    }
                    result.Append("0");
                    break;
                }
            }
            result.Append(Environment.NewLine);
        }
        return result.ToString();
    }

    protected virtual void OnNotSparseMatrix(NotSparseMatrixEventArgs e)
    {
        NotSparseMatrix?.Invoke(this, e);
    }

    private bool IsCorrect(int i, int j) => i >= 0 && j >= 0 && i < N && j < M;

    public IEnumerable<(int,int,int)> GetNonzeroElements()
    {
       for (int i = 0; i < NotZeroElements.Count; i++)
        {
            for (int j = 0; j < NotZeroElements.Count - 1; j++)
            {
                if (NotZeroElements[j].Item2 > NotZeroElements[j + 1].Item2)
                {
                    var tmp = NotZeroElements[j];
                    NotZeroElements[j] = NotZeroElements[j + 1];
                    NotZeroElements[j + 1]=tmp;
                }
            }
        }
        return NotZeroElements;
    }

    public string GetCount(int x)
    {
        if (x != 0)
        {
            int count = 0;
            for (int i = 0; i < NotZeroElements.Count; i++)
            {
                if (NotZeroElements[i].Item3 == x)
                {
                    count++;
                }
            }
            return $"The element {x} occurs {count} times";
        }
        return $"The element {x} occurs {N * M - NotZeroElements.Count} times";
    }

    public IEnumerator<int> GetEnumerator()
    {
        return new SparseMatrixEnumerator(this);
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    private class SparseMatrixEnumerator: IEnumerator<int>
    {
        private readonly SparseMatrix _matrix;
        private readonly int _capturedVersion;
        private int _position = -1;

        private readonly string str;
        private Regex _pattern = new Regex(@"\s+");

        public SparseMatrixEnumerator(SparseMatrix matrix)
        {
            _matrix = matrix;

            str = _pattern.Replace(matrix.ToString(), "");

            _capturedVersion = matrix._version;
        }
        public int Current => int.Parse(str[_position].ToString());

        object IEnumerator.Current => Current;

        public bool MoveNext()
        {
            if(_capturedVersion!=_matrix._version)
            {
                throw new InvalidOperationException();
            }

            if(_position<str.Length-1)
            {
                _position++;
                return true;
            }

            return false;
        }

        public void Reset()
        {
            _position = -1;
        }
        public void Dispose()
        {
            // :)
        }
    }
}


public class NotSparseMatrixEventArgs : EventArgs
{
    public double Sparsity { get; }

    public NotSparseMatrixEventArgs(double sparsity)
    {
        Sparsity = sparsity;
    }
}