idioms/idiom/temp/programming/packer-driver/targets/editor/chunks/6b/6b45817391fda8032e9c3052f72099ae80b977e5.js

System.register(["cc"], function (_export, _context) {
  "use strict";

  var _cclegacy, ArrayUtil, _crd;

  _export("default", void 0);

  return {
    setters: [function (_cc) {
      _cclegacy = _cc.cclegacy;
    }],
    execute: function () {
      _crd = true;

      _cclegacy._RF.push({}, "83341COeitPRIHcw18VS7g3", "ArrayUtil", undefined);

      _export("default", ArrayUtil = class ArrayUtil {
        /**随机打乱一个数组 */
        static shuffleArray(array) {
          let currentIndex = array.length;
          let temporaryValue;
          let randomIndex; // While there remain elements to shuffle...

          while (currentIndex !== 0) {
            // Pick a remaining element...
            randomIndex = Math.floor(Math.random() * currentIndex);
            currentIndex--; // And swap it with the current element.

            temporaryValue = array[currentIndex];
            array[currentIndex] = array[randomIndex];
            array[randomIndex] = temporaryValue;
          }

          return array;
        } // Fisher-Yates 洗牌算法
        //const originalArray = [1, 2, 3, 4, 5];  
        //const shuffledArray = shuffleArray([...originalArray]);


        static shuffleArray2(array) {
          for (let i = array.length - 1; i > 0; i--) {
            // 生成一个随机索引  
            const j = Math.floor(Math.random() * (i + 1)); // 交换元素  

            [array[i], array[j]] = [array[j], array[i]];
          }

          return array;
        }
        /**合并两个数组元素，移除相同的 */


        static MergeAndRemoveDuplicates(arr1, arr2) {
          const merged = [...arr1, ...arr2]; // 合并两个数组

          const uniqueValues = Array.from(new Set(merged)); // 去重

          return uniqueValues;
        }
        /**排除数组1在数组2里有的元素，返回新数组*/


        static ExcludeElements(array1, array2) {
          const set = new Set(array2); // 将 array2 转换为 Set

          return array1.filter(item => !set.has(item));
        }
        /**检测数组元素是否能满足顺序的组合*/


        static checkSequentialCombination(arr) {
          const sortedArr = arr.slice().sort((a, b) => a - b);

          for (let i = 0; i < sortedArr.length - 1; i++) {
            if (sortedArr[i] + 1 !== sortedArr[i + 1]) {
              return [];
            }
          }

          return sortedArr;
        }
        /**从一个数组中找出是否有连续的组合*/


        static findSequentialCombinations(arr) {
          const result = [];
          arr.sort((a, b) => a - b);
          let currentSequence = [];

          for (let i = 0; i < arr.length; i++) {
            if (currentSequence.length === 0 || arr[i] === currentSequence[currentSequence.length - 1] + 1) {
              currentSequence.push(arr[i]);
            } else {
              if (currentSequence.length > 1) {
                result.push(currentSequence);
              }

              currentSequence = [arr[i]];
            }
          }

          if (currentSequence.length > 1) {
            result.push(currentSequence);
          }

          return result;
        }
        /*eg:const arr = [2, 4,2, 5, 3, 6, 9,9,10,11,];
        const combinations = this.findSequentialCombinations(arr);
        
        if (combinations.length > 0) {
            console.log("所有可能的连续顺序组合为:");
            combinations.forEach(combination => {
                console.log(combination);
            });
        } else {
            console.log("无法找到连续顺序组合");
        }*/

        /**数组中删除一个合条件的*/


        static DeleteOneItem(list, check) {
          let length = list.length;

          for (let i = 0; i < length; i++) {
            if (check(list[i])) {
              return list.splice(i, 1)[0]; //i--;
              //length--;
            }
          }

          return null;
        }
        /**插入排序(适用于差异不会很大，相对有序的数据)Array.sort() 快速排序 算法更适用于混乱无章的数据 */


        static InsertionSort(array) {
          const count = array.length;
          if (count <= 1) return;
          let t1;
          let t2;

          for (let i = 1; i < count; i++) {
            t1 = array[i];
            let j;

            for (j = i; j > 0 && t1.sortValue > (t2 = array[j - 1]).sortValue; j--) {
              array[j] = t2;
            }

            array[j] = t1;
          }
        } // 元素排序

        /*示例
         负数在前
        const checkMinusNumber = function (val: number) {
                return val > 0;
        };
        const arr = [2, 4, 5, 6, 7, -8, -10 - 12, -2];
        adjustArrayOrder.reorder(arr, checkMinusNumber);
        console.log(arr);
        */


        static reorder(arr, checkFun) {
          let end = arr.length - 1;
          let begin = 0;

          while (begin < end) {
            // 向后移动begin
            while (begin < end && !checkFun(arr[begin])) {
              begin++;
            } // 向前移动end


            while (begin < end && checkFun(arr[end])) {
              end--;
            } // begin与end都指向了正确的位置


            if (begin < end) {
              // 交换两个元素的顺序
              [arr[begin], arr[end]] = [arr[end], arr[begin]];
            }
          }
        } //冒泡排序
        /// <summary>
        /// 各种类型冒泡排序比
        /// </summary>/// 例子:
        /// CommonSort<int>(new int[]{2,3,1,45,123,4},compare)
        /// bool compare(int a,int b){
        ///    	 if(a>b)return true;
        ///   	 reutn false;
        /// }
        /// <param name="sortArray"></param>
        /// <param name="compareMethod"></param>
        /// <typeparam name="T"></typeparam>


        static CommonSort(sortArray, compareMethod) {
          let swapped = true;

          do {
            swapped = false;

            for (let i = 0; i < sortArray.length - 1; i++) {
              if (compareMethod(sortArray[i], sortArray[i + 1])) {
                let temp = sortArray[i];
                sortArray[i] = sortArray[i + 1];
                sortArray[i + 1] = temp;
                swapped = true;
              }
            }
          } while (swapped);
        }
        /**归并排序 */

        /*var arr: number[] = [];
        for (var i: number = 0; i < 1000; i++) {
         arr.push(Math.floor(1000 - i));//生成降序的数组
        }
        MergeSort(arr, 0, arr.length);//调用归并排序算法*/
        //拆分数组  分


        static MergeSort(arr, lo, hi) {
          if (hi - lo < 2) return; //单个元素无需考虑

          var mi = lo + hi >> 1; //已中点为界 或者改成Math.floor((lo + hi) / 2)

          this.MergeSort(arr, lo, mi); //对左边排序

          this.MergeSort(arr, mi, hi); //对右边排序

          this.merge(arr, lo, mi, hi); //归并
        } //归并算法实现 合


        static merge(arr, lo, mi, hi) {
          var A = arr.slice(lo, hi); //A[lo, hi)=arr[lo, hi)

          var lb = mi - lo;
          var B = new Array(lb);

          for (var i = 0; i < lb; B[i] = A[i++]); //复制左子向量B[0, lb) = arr[lo, mi)


          var lc = hi - mi;
          var C = arr.slice(mi, hi); //后子向量C[0,lc) = arr[mi, hi)

          for (var i = 0, j = 0, k = 0; j < lb;) {
            //反复冲B和C中取出更小者
            if (k < lc && C[k] < B[j]) {
              //将其归入A中
              A[i++] = C[k++];
            }

            if (lc <= k || B[j] <= C[k]) {
              A[i++] = B[j++];
            }
          }

          for (var i = 0; i < A.length; arr[lo + i] = A[i++]); //把A中的值赋给原来的数组


          B.length = 0;
          C.length = 0;
          A.length = 0;
        }

      });

      _cclegacy._RF.pop();

      _crd = false;
    }
  };
});
//# sourceMappingURL=6b45817391fda8032e9c3052f72099ae80b977e5.js.map