NET 在一個數組中查找另一個數組所在起始位置（下標從0開始，未找到返回-1）

問題：

如果 search 在 dist 中順序出現而不要求連續出現，那代碼應該如何修改？如何計算這種匹配的可能性？

數組 search=[5,4,6],在數據 dist=[1,5,5,4,3,4,5,6]的起始位置是1

（因為dist下標{1,3,7}和下標{1,5,7}的元素都等於 search=[5,4,6]，故有兩種可能）

        /// <summary>
        /// 如果 search 在 dist 中順序出現而不要求連續出現，那代碼應該如何修改？如何計算這種匹配的可能性？
        /// 例如：
        /// 數組 search=[5,4,6],在數據 dist=[1,5,5,4,3,4,5,6]的起始位置是1
        /// （因為dist下標{1,3,7}和下標{1,5,7}的元素都等於 search=[5,4,6]，故有兩種可能）
        /// </summary>
        private static void indexOf()
        {
            var search = new int[] { 5, 4, 6 };
            Console.WriteLine($"連續出現的數組:{string.Join("-", search)}");
            var dist = new int[] { 1, 5, 5, 4, 3, 4, 5, 6 };
            Console.WriteLine($"需要比對的數組:{string.Join("-", dist)}");
            var dictionary = new Dictionary<object, List<int>>();
            //  按照數組順序初始化字典
            foreach (var item in search)
            {
                dictionary.Add(item, new List<int>());
            }
            //  把search中元素的下標記錄下來
            for (int i = 0; i < dist.Length; i++)
            {
                var key = dist[i];
                if (Array.IndexOf(search, key) > -1)
                {
                    if (dictionary.ContainsKey(key))
                    {
                        dictionary[key].Add(i);
                    }
                }
            }
            var group = new List<List<int>>();
            Console.WriteLine("分組前：");
            foreach (var key in dictionary.Keys)
            {
                Console.WriteLine($"Key:{key}\t下標集合:{string.Join("-", dictionary[key])}");
            }
            Add(new List<int>(), -1, 0, search, dictionary, group);
            Console.WriteLine("分組后：");
            foreach (var item in group)
            {
                Console.WriteLine($"下標集合:{string.Join("-", item)}");
            }
        }

        /// <summary>
        /// 遞歸添加
        /// </summary>
        /// <param name="list">需要添加的集合</param>
        /// <param name="parentKey">上一次的key，當前循環key要比上一次大</param>
        /// <param name="index">下標</param>
        /// <param name="search"></param>
        /// <param name="dictionary"></param>
        /// <returns></returns>
        private static void Add(List<int> list, int parentKey, int index, int[] search, Dictionary<object, List<int>> dictionary, List<List<int>> group)
        {
            if (search.Count() <= index)
            {
                //  匹配項超過數組長度，終止
                group.Add(list);
                return;
            }

            //  當前下標的值
            var key = search[index];
            if (dictionary.ContainsKey(key))
            {
                var itemList = dictionary[key];
                //  循環值
                for (int j = 0; j < itemList.Count(); j++)
                {
                    var itemKey = itemList[j];
                    //  當前循環key要比上一次大
                    if (itemKey < parentKey)
                    {
                        return;
                    }
                    var clone = Clone(list);
                    clone.Add(itemKey);
                    Add(clone, itemKey, index + 1, search, dictionary, group);
                }
            }
        }

        /// <summary>
        /// 克隆
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        private static List<int> Clone(List<int> list)
        {
            var clone = new List<int>();
            foreach (var item in list)
            {
                clone.Add(item);
            }
            return clone;
        }