protected override string HandleData(string data)
        {
            int width  = DefaultWidth;
            int height = DefaultHeight;

            if (!string.IsNullOrWhiteSpace(data))
            {
                var splitedData = data.Trim().Split().Where(s => !string.IsNullOrEmpty(s)).ToList();

                if (splitedData.Count() != 2 ||
                    !int.TryParse(splitedData[0], out width) ||
                    !int.TryParse(splitedData[1], out height))
                {
                    throw new ArgumentException($"parse \"{ data }\" failed", nameof(data));
                }
            }

            StringBuilder result = new StringBuilder();

            result.Append($"Generated array:{ Environment.NewLine }");
            var array = ArraysUtils.GenerateArray(new[] { width, height }, () => _rnd.Next(ValueDownLimit, ValueUpLimit));

            Add2DArrayToStringBilder(result, array);

            result.Append($"Sum even elements:{ Environment.NewLine }");
            result.Append($"{ CalcEvenElements(array, (int a, int b) => a + b) }{ Environment.NewLine }");

            return(result.ToString());
        }
        protected override string HandleData(string data)
        {
            StringBuilder result = new StringBuilder();

            result.Append($"Inicializing array:{ Environment.NewLine }");
            var array = ArraysUtils.GenerateArray(_degreesLengths, () => _rnd.Next(ValueDownLimit, ValueUpLimit + 1));

            AddCubicArrayToStringBilder(result, array);

            result.Append($"Replacement values:{ Environment.NewLine }");
            ArraysUtils.ReplaceElements(array, val => val > 0, 0);
            AddCubicArrayToStringBilder(result, array);

            return(result.ToString());
        }
        protected override string HandleData(string data)
        {
            int length = DefaultLength;

            if (!string.IsNullOrWhiteSpace(data))
            {
                if (!int.TryParse(data, out length))
                {
                    throw new ArgumentException($"parse \"{ data }\" failed", nameof(data));
                }
            }

            try
            {
                StringBuilder result = new StringBuilder();

                result.Append($"Inicializing collection:{ Environment.NewLine }");
                var elements = (from int val in ArraysUtils.GenerateArray(new[] { length }, () => _rnd.Next(ValueUpLimit))
                                select val)
                               .ToList();
                elements.ForEach(element => result.Append($"{ element } "));
                result.Append(Environment.NewLine);

                var max = HeaviestElementUtil.GetHeaviestElement(elements, (a, b) => a.CompareTo(b));
                result.Append($"Max element searching:{ Environment.NewLine }max = { max }{ Environment.NewLine }");

                var min = HeaviestElementUtil.GetHeaviestElement(elements, (a, b) => b.CompareTo(a));
                result.Append($"Mix element searching:{ Environment.NewLine }min = { min }{ Environment.NewLine }");

                result.Append($"Sorting collection:{ Environment.NewLine }");
                SortUtil.Sort(elements);
                elements.ForEach(element => result.Append($"{ element } "));
                result.Append(Environment.NewLine);

                return(result.ToString());
            }
            catch
            {
                throw;
            }
        }
        protected override string HandleData(string data)
        {
            var result = new StringBuilder();

            result.Append($"Generated collection:{ Environment.NewLine }");
            var collection = (from int element in ArraysUtils
                              .GenerateArray(new[] { DefaultLength }, () => _rnd.Next(ValueDownLimit, ValueUpLimit))
                              select element)
                             .ToList();

            foreach (var element in collection)
            {
                result.Append($"{ element } ");
            }
            result.Append(Environment.NewLine);

            result.Append($"Calculated summ:{ Environment.NewLine }");
            result.Append(SummByPredicate(collection, element => element > 0, (a, b) => a + b));

            return(result.ToString());
        }