02. Anonymous Threat

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

namespace _02.AnonymousThreat
{
    class Program
    {
        static void Main(string[] args)
        {
            var elements = Console.ReadLine().Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).ToList();

            var input = Console.ReadLine();

            while (input != "3:1")
            {

                var data = input.Split();

                string command = data[0];

                switch (command)
                {
                    case "merge":
                        var startIndex = int.Parse(data[1]);
                        var endIndex = int.Parse(data[2]);

                        startIndex = ValideteIndex(startIndex, elements.Count);
                        endIndex = ValideteIndex(endIndex, elements.Count);

                        var concatEelements = "";

                        for (int i = startIndex; i <= endIndex; i++)
                        {
                            concatEelements += elements[i];
                        }

                        for (int i = startIndex; i <= endIndex; i++)
                        {
                            elements.RemoveAt(startIndex);
                        }

                        elements.Insert(startIndex, concatEelements);
                        break;


                        break;

                    case "divide":

                        var index = int.Parse(data[1]);
                        var partitionsCount = int.Parse(data[2]);

                        var partitions = spitedEqually(elements[index], partitionsCount);

                        elements.RemoveAt(index);
                        elements.InsertRange(index, partitions);
                        break;
                }

                input = Console.ReadLine();
            }

            Console.WriteLine(string.Join(" ", elements));

        }

        private static List<string> spitedEqually(string word, int partitionsCount)
        {
            List<string> result = new List<string>();

            var part = word.Length / partitionsCount;

            while (word.Length >= part)
            {
                result.Add(word.Substring(0, part));
                word = word.Substring(part);
            }

            if (word != "")
            {
                result.Add(word);
            }

            if (result.Count == partitionsCount)
            {
                return result;
            }
            else
            {
                string concatLastTwoElements = result[result.Count - 2] + result[result.Count - 1];

                result.RemoveRange(result.Count - 2, 2);

                result.Add(concatLastTwoElements);
                return result;
            }

        }

        private static int ValideteIndex(int index, int length)
        {

            if (index < 0)
            {
                index = 0;
            }
            if (index > length - 1)
            {
                index = length - 1;
            }
            return index;
        }
    }
}