C#，实用新型加强版的整数数组

疫苗要打加强针！数组要用加强版！

三连发

加强版整数数组源代码icon-default.png?t=N7T8https://mp.csdn.net/mp_blog/creation/editor/124151056

加强版实数数组源代码icon-default.png?t=N7T8https://mp.csdn.net/mp_blog/creation/editor/124151110 加强版泛型数组源代码icon-default.png?t=N7T8https://mp.csdn.net/mp_blog/creation/editor/124151190

源代码

1 文本格式

using System;
using System.Collections;
using System.Collections.Generic;

namespace Legalsoft.Truffer.Algorithm
{
    /// <summary>
    /// 加强版（整数）数组
    /// 数组只是数组，
    /// 如果需要Insert,Delete等操作，建议使用List
    /// </summary>
    public class IArray
    {
        /// <summary>
        /// 随机数发生器
        /// </summary>
        private Random rnd { get; set; } = new Random((int)DateTime.Now.Ticks);
        /// <summary>
        /// 保存数组数据
        /// </summary>
        private int[] Value { get; set; } = null;
        /// <summary>
        /// 保存数组的原始数据
        /// </summary>
        private int[] Original { get; set; } = null;
        /// <summary>
        /// 数组的长度
        /// </summary>
        private int Length { get; set; } = Int16.MaxValue;

        /// <summary>
        /// 默认构造函数
        /// </summary>
        public IArray()
        {
            Value = new int[Length];
            Original = new int[Length];
        }
        /// <summary>
        /// 指定长度的构造函数
        /// </summary>
        /// <param name="n"></param>
        public IArray(int n)
        {
            Length = n;
            Value = new int[Length];
            Original = new int[Length];
        }
        /// <summary>
        /// 以 x 为样板的构造函数（克隆）
        /// </summary>
        /// <param name="x"></param>
        public IArray(IArray x)
        {
            Length = x.Length;
            Value = new int[Length];
            Original = new int[Length];
            for (int i = 0; i < Length; i++)
            {
                Value[i] = x[i];
                Original[i] = x[i];
            }
        }
        /// <summary>
        /// 以数组 v 为数据的构造函数
        /// </summary>
        /// <param name="v"></param>
        public IArray(int[] v)
        {
            Length = v.Length;
            Value = new int[Length];
            Original = new int[Length];
            for (int i = 0; i < Length; i++)
            {
                Value[i] = v[i];
                Original[i] = v[i];
            }
        }
        /// <summary>
        /// 以数组 x 为数据的赋值型构造函数
        /// </summary>
        /// <param name="x"></param>
        public static implicit operator IArray(int[] x)
        {
            return new IArray(x);
        }
        /// <summary>
        /// 以字符串为数据的赋值型构造函数
        /// IArray a = "1,2,3,4";
        /// </summary>
        /// <param name="s"></param>
        public static implicit operator IArray(string s)
        {
            string[] sa = s.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
            List<int> list = new List<int>();
            foreach (string sx in sa)
            {
                if (Int32.TryParse(sx.Trim(), out int x))
                {
                    list.Add(x);
                }
            }
            return new IArray(list.ToArray());
        }
        /// <summary>
        /// 第一个数据
        /// </summary>
        public int Left
        {
            set
            {
                Value[0] = value;
            }
            get
            {
                return Value[0];
            }
        }
        /// <summary>
        /// 最后一个数据
        /// </summary>
        public int Right
        {
            set
            {
                Value[Length - 1] = value;
            }
            get
            {
                return Value[Length - 1];
            }
        }
        /// <summary>
        /// 最小数据
        /// </summary>
        public int Min
        {
            get
            {
                Array.Sort(Value);
                return Value[0];
            }
        }
        /// <summary>
        /// 最大数据
        /// </summary>
        public int Max
        {
            get
            {
                Array.Sort(Value);
                return Value[Length - 1];
            }
        }
        /// <summary>
        /// 提取数组数据
        /// </summary>
        public int[] GetValues
        {
            get { return Value; }
        }
        /// <summary>
        /// 提取指定下标数据
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public int this[int index]
        {
            get { return Value[index]; }
            set { Value[index] = value; }
        }
        /// <summary>
        /// 加号重载（两个IArray相加）
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public static IArray operator +(IArray a, IArray b)
        {
            if (a.Length != b.Length)
            {
                throw new Exception("");
            }
            IArray c = new IArray(a);
            for (int i = 0; i < a.Length; i++)
            {
                c[i] = a[i] + b[i];
            }
            return c;
        }
        /// <summary>
        /// 加号重载（a的每个元素加上数值b）
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        public static IArray operator +(IArray a, int b)
        {
            IArray c = new IArray(a);
            for (int i = 0; i < a.Length; i++)
            {
                c[i] = a[i] + b;
            }
            return c;
        }
        /// <summary>
        /// 减号重载（两个IArray相减）
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public static IArray operator -(IArray a, IArray b)
        {
            if (a.Length != b.Length)
            {
                throw new Exception("Not same array size!");
            }
            IArray c = new IArray(a);
            for (int i = 0; i < a.Length; i++)
            {
                c[i] = a[i] - b[i];
            }
            return c;
        }
        /// <summary>
        /// 减号重载（a的每个元素减去数值b）
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        public static IArray operator -(IArray a, int b)
        {
            IArray c = new IArray(a);
            for (int i = 0; i < a.Length; i++)
            {
                c[i] = a[i] - b;
            }
            return c;
        }
        /// <summary>
        /// 乘号重载（两个IArray的元素一一对应相乘）
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public static IArray operator *(IArray a, IArray b)
        {
            if (a.Length != b.Length)
            {
                throw new Exception("Not same array size!");
            }
            IArray c = new IArray(a);
            for (int i = 0; i < a.Length; i++)
            {
                c[i] = a[i] * b[i];
            }
            return c;
        }
        /// <summary>
        /// 乘号重载（a的每个元素乘以数值b）
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        public static IArray operator *(IArray a, int b)
        {
            IArray c = new IArray(a);
            for (int i = 0; i < a.Length; i++)
            {
                c[i] = a[i] * b;
            }
            return c;
        }
        /// <summary>
        /// 除号重载（两个IArray的元素一一对应相除）
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public static IArray operator /(IArray a, IArray b)
        {
            if (a.Length != b.Length)
            {
                throw new Exception("Not same array size!");
            }
            IArray c = new IArray(a);
            for (int i = 0; i < a.Length; i++)
            {
                if (b[i] == 0)
                {
                    throw new Exception("Divided by zero!");
                }
                c[i] = a[i] / b[i];
            }
            return c;
        }
        /// <summary>
        /// 除号重载（a的每个元素除以数值b）
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public static IArray operator /(IArray a, int b)
        {
            if (b == 0)
            {
                throw new Exception("divided by zero");
            }
            IArray c = new IArray(a);
            for (int i = 0; i < a.Length; i++)
            {
                c[i] = a[i] / b;
            }
            return c;
        }
        /// <summary>
        /// 排序（正序）
        /// </summary>
        public void Sort()
        {
            Array.Sort(Value);
        }
        /// <summary>
        /// 倒排序
        /// </summary>
        public void Reverse_Sort()
        {
            Array.Sort(Value, (a, b) => b.CompareTo(a));
        }
        /// <summary>
        /// 以数组数据为参数的方程式
        /// F(x) = a[0] + a[1] * x + a[2]* x^2 ...
        /// 计算 F(x) 函数值
        /// </summary>
        /// <param name="x"></param>
        /// <returns></returns>
        public double Compute_Equation(double x)
        {
            double v = Value[0];
            for (int i = 1; i < Length; i++)
            {
                v += Value[i] * Math.Pow(x, i);
            }
            return v;
        }

        /// <summary>
        /// 左转（一格）
        /// </summary>
        public void Left_Rotate()
        {
            int v = Left;
            for (int i = 0; i < (Length - 1); i++)
            {
                Value[i] = Value[i + 1];
            }
            Value[Length - 1] = v;
        }

        /// <summary>
        /// 右转（一格）
        /// </summary>
        public void Right_Rotate()
        {
            int v = Right;
            for (int i = (Length - 1); i > 0; i--)
            {
                Value[i] = Value[i - 1];
            }
            Value[0] = v;
        }

        /// <summary>
        /// 左转（前） num 个数（递归方式）
        /// input:  1，2，3，4，5，6，7
        /// output: 3，4，5，6，7，1，2
        /// </summary>
        /// <param name="num"></param>
        public void Left_Rotate(int num)
        {
            if (num == 0)
            {
                return;
            }
            num = (num % Length);
            Reverse(0, num - 1);
            Reverse(num, Length - 1);
            Reverse(0, Length - 1);
        }

        /// <summary>
        /// 下标 start 到 end 反转
        /// </summary>
        /// <param name="start"></param>
        /// <param name="end"></param>
        public void Reverse(int start, int end)
        {
            while (start < end)
            {
                int temp = Value[start];
                Value[start] = Value[end];
                Value[end] = temp;
                start++;
                end--;
            }
        }

        /// <summary>
        /// 左转 num 个数（非递归方式）
        /// input:  1，2，3，4，5，6，7
        /// output: 3，4，5，6，7，1，2
        /// </summary>
        /// <param name="num"></param>
        public void Left_Rotate_No_Recurse(int num)
        {
            if (num == 0 || num == Length)
            {
                return;
            }
            num = num % Length;
            int i = num;
            int j = Length - num;
            while (i != j)
            {
                if (i < j)
                {
                    Swap(num - i, num + j - i, i);
                    j -= i;
                }
                else
                {
                    Swap(num - i, num, j);
                    i -= j;
                }
            }
            Swap(num - i, num, i);
        }

        /// <summary>
        /// 从指定下标开始左转d个数
        /// </summary>
        /// <param name="i">开始下标</param>
        /// <param name="d">左转数</param>
        /// <param name="n"></param>
        public void Left_Rotate_Recurse(int i, int d, int n)
        {
            if (d == 0 || d == n)
            {
                return;
            }
            if ((n - d) == d)
            {
                Swap(i, n - d + i, d);
                return;
            }
            if (d < (n - d))
            {
                Swap(i, n - d + i, d);
                Left_Rotate_Recurse(i, d, n - d);
            }
            else
            {
                Swap(i, d, n - d);
                Left_Rotate_Recurse(n - d + i, 2 * d - n, d);
            }
        }

        /// <summary>
        /// 将从下标fi开始的d个元素与从下标si开始的d个元素交换
        /// </summary>
        /// <param name="fi"></param>
        /// <param name="si"></param>
        /// <param name="d"></param>
        public void Swap(int fi, int si, int d)
        {
            for (int i = 0; i < d; i++)
            {
                int temp = Value[fi + i];
                Value[fi + i] = Value[si + i];
                Value[si + i] = temp;
            }
        }

        /// <summary>
        /// 应用标准二分法快速查找数值
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public int Pivoted_Binary_Search(int key)
        {
            int pivot = Find_Pivot(0, Length - 1);
            if (pivot == -1)
            {
                return Binary_Search(0, Length - 1, key);
            }
            if (Value[pivot] == key)
            {
                return pivot;
            }
            if (Value[0] <= key)
            {
                return Binary_Search(0, pivot - 1, key);
            }
            return Binary_Search(pivot + 1, Length - 1, key);
        }

        /// <summary>
        /// 递归当时快速搜索转轴数（）
        /// 转轴是第一个后面的数小于自己的数的下标
        /// 比如：数组 3, 4, 5, 6, 1, 2 的转轴下标是 3 （6的下标）
        /// </summary>
        /// <param name="low"></param>
        /// <param name="high"></param>
        /// <returns></returns>
        private int Find_Pivot(int low, int high)
        {
            if (high < low)
            {
                return -1;
            }
            if (high == low)
            {
                return low;
            }

            int mid = (low + high) / 2;
            if (mid < high && Value[mid] > Value[mid + 1])
            {
                return mid;
            }

            if (mid > low && Value[mid] < Value[mid - 1])
            {
                return (mid - 1);
            }

            if (Value[low] >= Value[mid])
            {
                return Find_Pivot(low, mid - 1);
            }

            return Find_Pivot(mid + 1, high);
        }

        /// <summary>
        /// 标准二分搜索算法
        /// </summary>
        /// <param name="low"></param>
        /// <param name="high"></param>
        /// <param name="key"></param>
        /// <returns></returns>
        private int Binary_Search(int low, int high, int key)
        {
            if (high < low)
            {
                return -1;
            }

            int mid = (low + high) / 2;
            if (key == Value[mid])
            {
                return mid;
            }
            if (key > Value[mid])
            {
                return Binary_Search((mid + 1), high, key);
            }
            return Binary_Search(low, (mid - 1), key);
        }

        /// <summary>
        /// 搜索数组中是否有“对和值（两个数的和）”等于 x
        /// </summary>
        /// <param name="x"></param>
        /// <returns></returns>
        public bool PairSum_Insort(int x)
        {
            int i;
            for (i = 0; i < Length - 1; i++)
            {
                if (Value[i] > Value[i + 1])
                {
                    break;
                }
            }
            int l = (i + 1) % Length;
            int r = i;
            while (l != r)
            {
                if (Value[l] + Value[r] == x)
                {
                    return true;
                }
                if (Value[l] + Value[r] < x)
                {
                    l = (l + 1) % Length;
                }
                else
                {
                    r = (Length + r - 1) % Length;
                }
            }
            return false;
        }

        /// <summary>
        /// 返回下标乘积最大数
        /// i*Value[i]
        /// </summary>
        /// <returns></returns>
        public int Maximum_Multipled_Sum()
        {
            int res = int.MinValue;
            for (int i = 0; i < Length; i++)
            {
                int curr_sum = 0;
                for (int j = 0; j < Length; j++)
                {
                    int index = (i + j) % Length;
                    curr_sum += j * Value[index];
                }
                res = Math.Max(res, curr_sum);
            }
            return res;
        }

        /// <summary>
        /// 二分法搜索 low ... high 之间的最小数
        /// </summary>
        /// <param name="low"></param>
        /// <param name="high"></param>
        /// <returns></returns>
        public int Min_Between(int low, int high)
        {
            if (high < low)
            {
                return Value[0];
            }
            if (high == low)
            {
                return Value[low];
            }
            int mid = low + (high - low) / 2;
            if (mid < high && Value[mid + 1] < Value[mid])
            {
                return Value[mid + 1];
            }
            if (mid > low && Value[mid] < Value[mid - 1])
            {
                return Value[mid];
            }
            if (Value[high] > Value[mid])
            {
                return Min_Between(low, mid - 1);
            }
            return Min_Between(mid + 1, high);
        }

        /// <summary>
        /// 计算（回转）数组的最大哈明距离
        /// </summary>
        /// <returns></returns>
        public int Maximum_Hamming_Distance()
        {
            int[] brr = new int[2 * Length + 1];
            for (int i = 0; i < Length; i++)
            {
                brr[i] = Value[i];
            }
            for (int i = 0; i < Length; i++)
            {
                brr[Length + i] = Value[i];
            }
            int maxHam = 0;
            for (int i = 1; i < Length; i++)
            {
                int currHam = 0;
                for (int j = i, k = 0; j < (i + Length); j++, k++)
                {
                    if (brr[j] != Value[k])
                    {
                        currHam++;
                    }
                }
                if (currHam == Length)
                {
                    return Length;
                }
                maxHam = Math.Max(maxHam, currHam);
            }
            return maxHam;
        }

        /// <summary>
        /// 移动所有的 0 到数组末尾
        /// </summary>
        public void Push_Zeros_To_End()
        {
            int count = 0;
            for (int i = 0; i < Length; i++)
            {
                if (Value[i] != 0)
                {
                    Value[count++] = Value[i];
                }
            }
            while (count < Length)
            {
                Value[count++] = 0;
            }
        }

        /// <summary>
        /// Fisher-Yates洗牌算法，听起来很高大上 ：P
        /// Fisher–Yates shuffle Algorithm
        /// </summary>
        public void Randomize()
        {
            for (int i = Length - 1; i > 0; i--)
            {
                int j = rnd.Next(0, i + 1);
                int temp = Value[i];
                Value[i] = Value[j];
                Value[j] = temp;
            }
        }

        /// <summary>
        /// 计算第 k 个最小数
        /// </summary>
        /// <param name="k"></param>
        /// <returns></returns>
        public int Kth_Smallest(int k)
        {
            Array.Sort(Value);
            return Value[k - 1];
        }

        /// <summary>
        /// 下标 low ... high 之间的和值
        /// </summary>
        /// <param name="low"></param>
        /// <param name="high"></param>
        /// <returns></returns>
        public int Sum_Between(int low, int high)
        {
            int sum = 0;
            for (int i = low; i < high; i++)
            {
                sum += Value[i];
            }
            return sum;
        }

        /// <summary>
        /// 均值
        /// </summary>
        /// <returns></returns>
        public double Mean()
        {
            double sum = 0.0;
            for (int i = 0; i < Length; i++)
            {
                sum += Value[i];
            }
            return (double)sum / (double)Length;
        }

        /// <summary>
        /// 中值（不是均值哦）
        /// </summary>
        /// <returns></returns>
        public double Median()
        {
            Array.Sort(Value);
            if ((Length % 2) != 0)
            {
                return (double)Value[Length / 2];
            }

            return (double)(Value[(Length - 1) / 2] + Value[Length / 2]) * 0.5;
        }

        /// <summary>
        /// 和值查找表
        /// </summary>
        private int[,] lookup { get; set; } = null;

        /// <summary>
        /// 构建和值稀疏表
        /// </summary>
        public void Build_Sparse_Table()
        {
            lookup = new int[Length + 1, Length + 1];
            for (int i = 0; i < Length; i++)
            {
                lookup[i, 0] = Value[i];
            }

            for (int j = 1; (1 << j) <= Length; j++)
            {
                for (int i = 0; (i + (1 << j) - 1) < Length; i++)
                {
                    if (lookup[i, j - 1] < lookup[i + (1 << (j - 1)), j - 1])
                    {
                        lookup[i, j] = lookup[i, j - 1];
                    }
                    else
                    {
                        lookup[i, j] = lookup[i + (1 << (j - 1)), j - 1];
                    }
                }
            }
        }

        /// <summary>
        /// 稀疏查表法求 low high 之间的最小值
        /// </summary>
        /// <param name="low"></param>
        /// <param name="high"></param>
        /// <returns></returns>
        public int Sparse_Min_Between(int low, int high)
        {
            int j = (int)Math.Log(high - low + 1);
            if (lookup[low, j] <= lookup[high - (1 << j) + 1, j])
            {
                return lookup[low, j];
            }
            else
            {
                return lookup[high - (1 << j) + 1, j];
            }
        }

        /// <summary>
        /// 转为 M x N 的矩阵
        /// </summary>
        /// <param name="m"></param>
        /// <param name="n"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public int[,] ToMatrix(int m, int n)
        {
            if (m * n != Length)
            {
                throw new Exception("Error matrix size!");
            }
            int[,] matrix = new int[m, n];
            for (int i = 0; i < m; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    matrix[i, j] = this[i * n + j];
                }
            }
            return matrix;
        }

        /// <summary>
        /// ToString函数的重写
        /// 1 overload 重载
        /// 2 override 重写
        /// 3 new 覆写
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            string r = "";
            foreach (int x in Value)
            {
                r += x + ", ";
            }
            if (r.Length == 0) return "";
            return r.Trim().Substring(0, r.Length - 1);
        }
    }
}
 

2 代码格式

using System;
using System.Collections;
using System.Collections.Generic;

namespace Legalsoft.Truffer.Algorithm
{
    /// <summary>
    /// 加强版（整数）数组
    /// 数组只是数组，
    /// 如果需要Insert,Delete等操作，建议使用List
    /// </summary>
    public class IArray
    {
        /// <summary>
        /// 随机数发生器
        /// </summary>
        private Random rnd { get; set; } = new Random((int)DateTime.Now.Ticks);
        /// <summary>
        /// 保存数组数据
        /// </summary>
        private int[] Value { get; set; } = null;
        /// <summary>
        /// 保存数组的原始数据
        /// </summary>
        private int[] Original { get; set; } = null;
        /// <summary>
        /// 数组的长度
        /// </summary>
        private int Length { get; set; } = Int16.MaxValue;

        /// <summary>
        /// 默认构造函数
        /// </summary>
        public IArray()
        {
            Value = new int[Length];
            Original = new int[Length];
        }
        /// <summary>
        /// 指定长度的构造函数
        /// </summary>
        /// <param name="n"></param>
        public IArray(int n)
        {
            Length = n;
            Value = new int[Length];
            Original = new int[Length];
        }
        /// <summary>
        /// 以 x 为样板的构造函数（克隆）
        /// </summary>
        /// <param name="x"></param>
        public IArray(IArray x)
        {
            Length = x.Length;
            Value = new int[Length];
            Original = new int[Length];
            for (int i = 0; i < Length; i++)
            {
                Value[i] = x[i];
                Original[i] = x[i];
            }
        }
        /// <summary>
        /// 以数组 v 为数据的构造函数
        /// </summary>
        /// <param name="v"></param>
        public IArray(int[] v)
        {
            Length = v.Length;
            Value = new int[Length];
            Original = new int[Length];
            for (int i = 0; i < Length; i++)
            {
                Value[i] = v[i];
                Original[i] = v[i];
            }
        }
        /// <summary>
        /// 以数组 x 为数据的赋值型构造函数
        /// </summary>
        /// <param name="x"></param>
        public static implicit operator IArray(int[] x)
        {
            return new IArray(x);
        }
        /// <summary>
        /// 以字符串为数据的赋值型构造函数
        /// IArray a = "1,2,3,4";
        /// </summary>
        /// <param name="s"></param>
        public static implicit operator IArray(string s)
        {
            string[] sa = s.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
            List<int> list = new List<int>();
            foreach (string sx in sa)
            {
                if (Int32.TryParse(sx.Trim(), out int x))
                {
                    list.Add(x);
                }
            }
            return new IArray(list.ToArray());
        }
        /// <summary>
        /// 第一个数据
        /// </summary>
        public int Left
        {
            set
            {
                Value[0] = value;
            }
            get
            {
                return Value[0];
            }
        }
        /// <summary>
        /// 最后一个数据
        /// </summary>
        public int Right
        {
            set
            {
                Value[Length - 1] = value;
            }
            get
            {
                return Value[Length - 1];
            }
        }
        /// <summary>
        /// 最小数据
        /// </summary>
        public int Min
        {
            get
            {
                Array.Sort(Value);
                return Value[0];
            }
        }
        /// <summary>
        /// 最大数据
        /// </summary>
        public int Max
        {
            get
            {
                Array.Sort(Value);
                return Value[Length - 1];
            }
        }
        /// <summary>
        /// 提取数组数据
        /// </summary>
        public int[] GetValues
        {
            get { return Value; }
        }
        /// <summary>
        /// 提取指定下标数据
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public int this[int index]
        {
            get { return Value[index]; }
            set { Value[index] = value; }
        }
        /// <summary>
        /// 加号重载（两个IArray相加）
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public static IArray operator +(IArray a, IArray b)
        {
            if (a.Length != b.Length)
            {
                throw new Exception("");
            }
            IArray c = new IArray(a);
            for (int i = 0; i < a.Length; i++)
            {
                c[i] = a[i] + b[i];
            }
            return c;
        }
        /// <summary>
        /// 加号重载（a的每个元素加上数值b）
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        public static IArray operator +(IArray a, int b)
        {
            IArray c = new IArray(a);
            for (int i = 0; i < a.Length; i++)
            {
                c[i] = a[i] + b;
            }
            return c;
        }
        /// <summary>
        /// 减号重载（两个IArray相减）
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public static IArray operator -(IArray a, IArray b)
        {
            if (a.Length != b.Length)
            {
                throw new Exception("Not same array size!");
            }
            IArray c = new IArray(a);
            for (int i = 0; i < a.Length; i++)
            {
                c[i] = a[i] - b[i];
            }
            return c;
        }
        /// <summary>
        /// 减号重载（a的每个元素减去数值b）
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        public static IArray operator -(IArray a, int b)
        {
            IArray c = new IArray(a);
            for (int i = 0; i < a.Length; i++)
            {
                c[i] = a[i] - b;
            }
            return c;
        }
        /// <summary>
        /// 乘号重载（两个IArray的元素一一对应相乘）
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public static IArray operator *(IArray a, IArray b)
        {
            if (a.Length != b.Length)
            {
                throw new Exception("Not same array size!");
            }
            IArray c = new IArray(a);
            for (int i = 0; i < a.Length; i++)
            {
                c[i] = a[i] * b[i];
            }
            return c;
        }
        /// <summary>
        /// 乘号重载（a的每个元素乘以数值b）
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        public static IArray operator *(IArray a, int b)
        {
            IArray c = new IArray(a);
            for (int i = 0; i < a.Length; i++)
            {
                c[i] = a[i] * b;
            }
            return c;
        }
        /// <summary>
        /// 除号重载（两个IArray的元素一一对应相除）
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public static IArray operator /(IArray a, IArray b)
        {
            if (a.Length != b.Length)
            {
                throw new Exception("Not same array size!");
            }
            IArray c = new IArray(a);
            for (int i = 0; i < a.Length; i++)
            {
                if (b[i] == 0)
                {
                    throw new Exception("Divided by zero!");
                }
                c[i] = a[i] / b[i];
            }
            return c;
        }
        /// <summary>
        /// 除号重载（a的每个元素除以数值b）
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public static IArray operator /(IArray a, int b)
        {
            if (b == 0)
            {
                throw new Exception("divided by zero");
            }
            IArray c = new IArray(a);
            for (int i = 0; i < a.Length; i++)
            {
                c[i] = a[i] / b;
            }
            return c;
        }
        /// <summary>
        /// 排序（正序）
        /// </summary>
        public void Sort()
        {
            Array.Sort(Value);
        }
        /// <summary>
        /// 倒排序
        /// </summary>
        public void Reverse_Sort()
        {
            Array.Sort(Value, (a, b) => b.CompareTo(a));
        }
        /// <summary>
        /// 以数组数据为参数的方程式
        /// F(x) = a[0] + a[1] * x + a[2]* x^2 ...
        /// 计算 F(x) 函数值
        /// </summary>
        /// <param name="x"></param>
        /// <returns></returns>
        public double Compute_Equation(double x)
        {
            double v = Value[0];
            for (int i = 1; i < Length; i++)
            {
                v += Value[i] * Math.Pow(x, i);
            }
            return v;
        }

        /// <summary>
        /// 左转（一格）
        /// </summary>
        public void Left_Rotate()
        {
            int v = Left;
            for (int i = 0; i < (Length - 1); i++)
            {
                Value[i] = Value[i + 1];
            }
            Value[Length - 1] = v;
        }

        /// <summary>
        /// 右转（一格）
        /// </summary>
        public void Right_Rotate()
        {
            int v = Right;
            for (int i = (Length - 1); i > 0; i--)
            {
                Value[i] = Value[i - 1];
            }
            Value[0] = v;
        }

        /// <summary>
        /// 左转（前） num 个数（递归方式）
        /// input:  1，2，3，4，5，6，7
        /// output: 3，4，5，6，7，1，2
        /// </summary>
        /// <param name="num"></param>
        public void Left_Rotate(int num)
        {
            if (num == 0)
            {
                return;
            }
            num = (num % Length);
            Reverse(0, num - 1);
            Reverse(num, Length - 1);
            Reverse(0, Length - 1);
        }

        /// <summary>
        /// 下标 start 到 end 反转
        /// </summary>
        /// <param name="start"></param>
        /// <param name="end"></param>
        public void Reverse(int start, int end)
        {
            while (start < end)
            {
                int temp = Value[start];
                Value[start] = Value[end];
                Value[end] = temp;
                start++;
                end--;
            }
        }

        /// <summary>
        /// 左转 num 个数（非递归方式）
        /// input:  1，2，3，4，5，6，7
        /// output: 3，4，5，6，7，1，2
        /// </summary>
        /// <param name="num"></param>
        public void Left_Rotate_No_Recurse(int num)
        {
            if (num == 0 || num == Length)
            {
                return;
            }
            num = num % Length;
            int i = num;
            int j = Length - num;
            while (i != j)
            {
                if (i < j)
                {
                    Swap(num - i, num + j - i, i);
                    j -= i;
                }
                else
                {
                    Swap(num - i, num, j);
                    i -= j;
                }
            }
            Swap(num - i, num, i);
        }

        /// <summary>
        /// 从指定下标开始左转d个数
        /// </summary>
        /// <param name="i">开始下标</param>
        /// <param name="d">左转数</param>
        /// <param name="n"></param>
        public void Left_Rotate_Recurse(int i, int d, int n)
        {
            if (d == 0 || d == n)
            {
                return;
            }
            if ((n - d) == d)
            {
                Swap(i, n - d + i, d);
                return;
            }
            if (d < (n - d))
            {
                Swap(i, n - d + i, d);
                Left_Rotate_Recurse(i, d, n - d);
            }
            else
            {
                Swap(i, d, n - d);
                Left_Rotate_Recurse(n - d + i, 2 * d - n, d);
            }
        }

        /// <summary>
        /// 将从下标fi开始的d个元素与从下标si开始的d个元素交换
        /// </summary>
        /// <param name="fi"></param>
        /// <param name="si"></param>
        /// <param name="d"></param>
        public void Swap(int fi, int si, int d)
        {
            for (int i = 0; i < d; i++)
            {
                int temp = Value[fi + i];
                Value[fi + i] = Value[si + i];
                Value[si + i] = temp;
            }
        }

        /// <summary>
        /// 应用标准二分法快速查找数值
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public int Pivoted_Binary_Search(int key)
        {
            int pivot = Find_Pivot(0, Length - 1);
            if (pivot == -1)
            {
                return Binary_Search(0, Length - 1, key);
            }
            if (Value[pivot] == key)
            {
                return pivot;
            }
            if (Value[0] <= key)
            {
                return Binary_Search(0, pivot - 1, key);
            }
            return Binary_Search(pivot + 1, Length - 1, key);
        }

        /// <summary>
        /// 递归当时快速搜索转轴数（）
        /// 转轴是第一个后面的数小于自己的数的下标
        /// 比如：数组 3, 4, 5, 6, 1, 2 的转轴下标是 3 （6的下标）
        /// </summary>
        /// <param name="low"></param>
        /// <param name="high"></param>
        /// <returns></returns>
        private int Find_Pivot(int low, int high)
        {
            if (high < low)
            {
                return -1;
            }
            if (high == low)
            {
                return low;
            }

            int mid = (low + high) / 2;
            if (mid < high && Value[mid] > Value[mid + 1])
            {
                return mid;
            }

            if (mid > low && Value[mid] < Value[mid - 1])
            {
                return (mid - 1);
            }

            if (Value[low] >= Value[mid])
            {
                return Find_Pivot(low, mid - 1);
            }

            return Find_Pivot(mid + 1, high);
        }

        /// <summary>
        /// 标准二分搜索算法
        /// </summary>
        /// <param name="low"></param>
        /// <param name="high"></param>
        /// <param name="key"></param>
        /// <returns></returns>
        private int Binary_Search(int low, int high, int key)
        {
            if (high < low)
            {
                return -1;
            }

            int mid = (low + high) / 2;
            if (key == Value[mid])
            {
                return mid;
            }
            if (key > Value[mid])
            {
                return Binary_Search((mid + 1), high, key);
            }
            return Binary_Search(low, (mid - 1), key);
        }

        /// <summary>
        /// 搜索数组中是否有“对和值（两个数的和）”等于 x
        /// </summary>
        /// <param name="x"></param>
        /// <returns></returns>
        public bool PairSum_Insort(int x)
        {
            int i;
            for (i = 0; i < Length - 1; i++)
            {
                if (Value[i] > Value[i + 1])
                {
                    break;
                }
            }
            int l = (i + 1) % Length;
            int r = i;
            while (l != r)
            {
                if (Value[l] + Value[r] == x)
                {
                    return true;
                }
                if (Value[l] + Value[r] < x)
                {
                    l = (l + 1) % Length;
                }
                else
                {
                    r = (Length + r - 1) % Length;
                }
            }
            return false;
        }

        /// <summary>
        /// 返回下标乘积最大数
        /// i*Value[i]
        /// </summary>
        /// <returns></returns>
        public int Maximum_Multipled_Sum()
        {
            int res = int.MinValue;
            for (int i = 0; i < Length; i++)
            {
                int curr_sum = 0;
                for (int j = 0; j < Length; j++)
                {
                    int index = (i + j) % Length;
                    curr_sum += j * Value[index];
                }
                res = Math.Max(res, curr_sum);
            }
            return res;
        }

        /// <summary>
        /// 二分法搜索 low ... high 之间的最小数
        /// </summary>
        /// <param name="low"></param>
        /// <param name="high"></param>
        /// <returns></returns>
        public int Min_Between(int low, int high)
        {
            if (high < low)
            {
                return Value[0];
            }
            if (high == low)
            {
                return Value[low];
            }
            int mid = low + (high - low) / 2;
            if (mid < high && Value[mid + 1] < Value[mid])
            {
                return Value[mid + 1];
            }
            if (mid > low && Value[mid] < Value[mid - 1])
            {
                return Value[mid];
            }
            if (Value[high] > Value[mid])
            {
                return Min_Between(low, mid - 1);
            }
            return Min_Between(mid + 1, high);
        }

        /// <summary>
        /// 计算（回转）数组的最大哈明距离
        /// </summary>
        /// <returns></returns>
        public int Maximum_Hamming_Distance()
        {
            int[] brr = new int[2 * Length + 1];
            for (int i = 0; i < Length; i++)
            {
                brr[i] = Value[i];
            }
            for (int i = 0; i < Length; i++)
            {
                brr[Length + i] = Value[i];
            }
            int maxHam = 0;
            for (int i = 1; i < Length; i++)
            {
                int currHam = 0;
                for (int j = i, k = 0; j < (i + Length); j++, k++)
                {
                    if (brr[j] != Value[k])
                    {
                        currHam++;
                    }
                }
                if (currHam == Length)
                {
                    return Length;
                }
                maxHam = Math.Max(maxHam, currHam);
            }
            return maxHam;
        }

        /// <summary>
        /// 移动所有的 0 到数组末尾
        /// </summary>
        public void Push_Zeros_To_End()
        {
            int count = 0;
            for (int i = 0; i < Length; i++)
            {
                if (Value[i] != 0)
                {
                    Value[count++] = Value[i];
                }
            }
            while (count < Length)
            {
                Value[count++] = 0;
            }
        }

        /// <summary>
        /// Fisher-Yates洗牌算法，听起来很高大上 ：P
        /// Fisher–Yates shuffle Algorithm
        /// </summary>
        public void Randomize()
        {
            for (int i = Length - 1; i > 0; i--)
            {
                int j = rnd.Next(0, i + 1);
                int temp = Value[i];
                Value[i] = Value[j];
                Value[j] = temp;
            }
        }

        /// <summary>
        /// 计算第 k 个最小数
        /// </summary>
        /// <param name="k"></param>
        /// <returns></returns>
        public int Kth_Smallest(int k)
        {
            Array.Sort(Value);
            return Value[k - 1];
        }

        /// <summary>
        /// 下标 low ... high 之间的和值
        /// </summary>
        /// <param name="low"></param>
        /// <param name="high"></param>
        /// <returns></returns>
        public int Sum_Between(int low, int high)
        {
            int sum = 0;
            for (int i = low; i < high; i++)
            {
                sum += Value[i];
            }
            return sum;
        }

        /// <summary>
        /// 均值
        /// </summary>
        /// <returns></returns>
        public double Mean()
        {
            double sum = 0.0;
            for (int i = 0; i < Length; i++)
            {
                sum += Value[i];
            }
            return (double)sum / (double)Length;
        }

        /// <summary>
        /// 中值（不是均值哦）
        /// </summary>
        /// <returns></returns>
        public double Median()
        {
            Array.Sort(Value);
            if ((Length % 2) != 0)
            {
                return (double)Value[Length / 2];
            }

            return (double)(Value[(Length - 1) / 2] + Value[Length / 2]) * 0.5;
        }

        /// <summary>
        /// 和值查找表
        /// </summary>
        private int[,] lookup { get; set; } = null;

        /// <summary>
        /// 构建和值稀疏表
        /// </summary>
        public void Build_Sparse_Table()
        {
            lookup = new int[Length + 1, Length + 1];
            for (int i = 0; i < Length; i++)
            {
                lookup[i, 0] = Value[i];
            }

            for (int j = 1; (1 << j) <= Length; j++)
            {
                for (int i = 0; (i + (1 << j) - 1) < Length; i++)
                {
                    if (lookup[i, j - 1] < lookup[i + (1 << (j - 1)), j - 1])
                    {
                        lookup[i, j] = lookup[i, j - 1];
                    }
                    else
                    {
                        lookup[i, j] = lookup[i + (1 << (j - 1)), j - 1];
                    }
                }
            }
        }

        /// <summary>
        /// 稀疏查表法求 low high 之间的最小值
        /// </summary>
        /// <param name="low"></param>
        /// <param name="high"></param>
        /// <returns></returns>
        public int Sparse_Min_Between(int low, int high)
        {
            int j = (int)Math.Log(high - low + 1);
            if (lookup[low, j] <= lookup[high - (1 << j) + 1, j])
            {
                return lookup[low, j];
            }
            else
            {
                return lookup[high - (1 << j) + 1, j];
            }
        }

        /// <summary>
        /// 转为 M x N 的矩阵
        /// </summary>
        /// <param name="m"></param>
        /// <param name="n"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public int[,] ToMatrix(int m, int n)
        {
            if (m * n != Length)
            {
                throw new Exception("Error matrix size!");
            }
            int[,] matrix = new int[m, n];
            for (int i = 0; i < m; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    matrix[i, j] = this[i * n + j];
                }
            }
            return matrix;
        }

        /// <summary>
        /// ToString函数的重写
        /// 1 overload 重载
        /// 2 override 重写
        /// 3 new 覆写
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            string r = "";
            foreach (int x in Value)
            {
                r += x + ", ";
            }
            if (r.Length == 0) return "";
            return r.Trim().Substring(0, r.Length - 1);
        }
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/335096.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

这才是你应该了解的Redis数据结构！

这才是你应该了解的Redis数据结构！

Redis&#xff0c;作为一种高性能的内存数据库&#xff0c;支持多种数据结构&#xff0c;从简单的字符串到复杂的哈希表。在这篇博文中&#xff0c;我们将深入探讨Redis的一些主要数据结构&#xff0c;并通过详细的例子展示它们的使用。 1. 字符串 (String) 1.1 存储和获取 R…
阅读更多...
k8s资源介绍

k8s资源介绍

Kubernetes架构图 Kubernetes系统用于管理分布式节点集群中的微服务或容器化应用程序&#xff0c;并且其提供了零停机时间部署、自动回滚、缩放和容器的自愈&#xff08;其中包括自动配置、自动重启、自动复制的高弹性基础设施&#xff0c;以及容器的自动缩放等&#xff09;等…
阅读更多...
模糊数学在处理激光雷达的不确定性和模糊性问题中的应用

模糊数学在处理激光雷达的不确定性和模糊性问题中的应用

模糊数学是一种用于处理不确定性和模糊性问题的数学工具&#xff0c;它可以帮助我们更好地处理激光雷达数据中的不确定性和模糊性。激光雷达是一种常用的传感器&#xff0c;用于测量目标物体的距离、速度和方向等信息。然而&#xff0c;在实际应用中&#xff0c;激光雷达所获取…
阅读更多...
ITK + ANT，无法显示三维

ITK + ANT，无法显示三维

背景&#xff1a;之前用ANT保存ima格式的数据&#xff0c;选择的是保存所有的序列 用python将dicom转为nii的格式&#xff0c; import nibabel as nib import torch"""不管是nii还是nii.gz都是二维的&#xff0c;为啥呢"""fobj nib.load("…
阅读更多...
Linux编辑器---vim

Linux编辑器---vim

目录 1、vim的基本概念 2正常/普通/命令模式(Normal mode) 2、1命令模式下一些命令&#xff08;不用进入插入模式&#xff09; 3插入模式(Insert mode) 4末行/底行模式(last line mode) 4、1底行模式下的一些命令 5、普通用户无法进行sudo提权的解决方案 6、vim配置问题 6、1配…
阅读更多...
使用 Node 创建 Web 服务器

使用 Node 创建 Web 服务器

Node.js 提供了 http 模块&#xff0c;http 模块主要用于搭建 HTTP 服务端和客户端&#xff0c;使用 HTTP 服务器或客户端功能必须调用 http 模块&#xff0c;代码如下&#xff1a; var http require(http); 以下是演示一个最基本的 HTTP 服务器架构(使用 8080 端口)&#x…
阅读更多...
100天精通鸿蒙从入门到跳槽——第8天：TypeScript 知识储备：泛型

100天精通鸿蒙从入门到跳槽——第8天：TypeScript 知识储备：泛型

博主猫头虎的技术世界 &#x1f31f; 欢迎来到猫头虎的博客 — 探索技术的无限可能&#xff01; 专栏链接&#xff1a; &#x1f517; 精选专栏&#xff1a; 《面试题大全》 — 面试准备的宝典&#xff01;《IDEA开发秘籍》 — 提升你的IDEA技能&#xff01;《100天精通Golang》…
阅读更多...
学好UEFI，实现从工程师到架构师的跨越

学好UEFI，实现从工程师到架构师的跨越

学好UEFI&#xff0c; 实现从工程师到架构师的跨越 2024 / 01 / 19 统一可扩展固件接口 UEFI&#xff0c;是由英特尔、微软等众多全球知名 IT企业共同开发、管理与推进的全新一代 BIOS 体系规范&#xff0c;目前作为最先进最完善的固件架构&#xff0c;已占据绝大部分计算机市…
阅读更多...
基于Redisson的RAtomicLong实现全局唯一工单号生成器

基于Redisson的RAtomicLong实现全局唯一工单号生成器

最近几年&#xff0c;我一直从事的是运营平台业务开发。每天&#xff0c;我们都需要处理大量的工单配置工作。为了生成工单号&#xff0c;我们建立了一张专用的数据库表&#xff0c;用于记录和生成工单号。每次创建工单时&#xff0c;我们会查询这张表&#xff0c;根据年份字段…
阅读更多...
梁山泊国潮风礼盒，传承经典，贺礼新春

梁山泊国潮风礼盒，传承经典，贺礼新春

在春节来临之际&#xff0c;梁山泊隆重推出新年中国红礼盒酒&#xff0c;为您传递新年的祝福与关爱。这款酒以其独特的魅力&#xff0c;为您带来美好的祝愿和愉悦的享受。中国风国潮礼盒采用中国传统红色为主色调&#xff0c;象征着吉祥、喜庆和繁荣。红色的背景上&#xff0c;…
阅读更多...
appium连接手机进行启动失败 ，怎么办 ？检查下这几个地方 。

appium连接手机进行启动失败 ，怎么办 ？检查下这几个地方 。

在使用appium做app自动化&#xff0c;首先需要启动appium连接到手机&#xff0c;然后进行后续操作。 但是往往在启动的时候就会卡住&#xff0c;在点击start session后就会出现报错&#xff0c;具体如下图 &#xff1a; 那么&#xff0c;出现如上的情况该如何解决呢 &#xff1…
阅读更多...
（蓝桥杯每日一题）love

（蓝桥杯每日一题）love

问题描述 马上就要到七夕情人节了&#xff0c;小蓝在这天想要心爱得男神表白&#xff0c;于是她写下了一个长度为n仅由小写字母组成的字符串。 她想要使这个字符串有 1314个 love 子序列但是马虎的小蓝却忘记了当前已经有多少个子序列为 love。 请你帮小蓝计算出当前字符串有多…
阅读更多...
挑战杯参赛总结-时间序列预测

挑战杯参赛总结-时间序列预测

参赛任务&#xff1a; 目标&#xff1a;针对中国各个市区的不同年份二氧化碳排放量&#xff0c;预测未来年份的二氧化碳排放量。 不同与之前我学习过的波士顿房价预测机器学习-波士顿房价预测-CSDN博客 房价预测是通过学习与房价有关的很多特征&#xff0c;训练出一个模型来预…
阅读更多...
RabbitMQ-生产者可靠性

RabbitMQ-生产者可靠性

一、生产者重连 1、概念 由于网络波动导致客户端无法连接上MQ&#xff0c;这是可以开启MQ的失败后重连机制。 注意&#xff1a; 是连接失败的重试&#xff0c;而不是消息发送失败后的重试。 2、开启配置 spring:rabbitmq:template:retry:enabled: true # 是否启用重试机制ma…
阅读更多...
[python语言]数据类型

[python语言]数据类型

目录 知识结构​编辑 复数类型 整数类型、浮点数类型 1、整型 2、浮点型 字符与字符串 1、转义字符 2、字符串的截取 3、字符串的拼接级连 4、字符串的格式化 1、format格式化 2、字符格式化 3、f标志位格式化--(推荐) 5、字符串的常用属性 1、对字符串做出判断…
阅读更多...
Mat - 基本映像容器

Mat - 基本映像容器

目标 我们有多种方法可以从现实世界中获取数字图像&#xff1a;数码相机、扫描仪、计算机断层扫描和磁共振成像等等。在每种情况下&#xff0c;我们&#xff08;人类&#xff09;看到的都是图像。但是&#xff0c;当将其转换为我们的数字设备时&#xff0c;我们记录的是图像每…
阅读更多...
设计模式篇章（4）——十一种行为型模式

设计模式篇章（4）——十一种行为型模式

这个设计模式主要思考的是如何分配对象的职责和将对象之间相互协作完成单个对象无法完成的任务&#xff0c;这个与结构型模式有点像&#xff0c;结构型可以理解为静态的组合&#xff0c;例如将不同的组件拼起来成为一个更大的组件&#xff1b;而行为型更是一种动态或者具有某个…
阅读更多...
高级编程。JavaScript中有哪些类型转换机制？

高级编程。JavaScript中有哪些类型转换机制？

一、概述 前面我们讲到&#xff0c;JS中有六种简单数据类型&#xff1a;undefined、null、boolean、string、number、symbol&#xff0c;以及引用类型&#xff1a;object 但是我们在声明的时候只有一种数据类型&#xff0c;只有到运行期间才会确定当前类型 let x y ? 1 : …
阅读更多...
MCM备赛笔记——蒙特卡罗方法

MCM备赛笔记——蒙特卡罗方法

Key Concept 蒙特卡罗方法&#xff08;Monte Carlo Method&#xff09;&#xff0c;也称为统计模拟方法&#xff0c;是一种基于概率和统计的数值计算方法。该方法使用随机数&#xff08;或更常见的伪随机数&#xff09;来解决可能非常复杂的数学或物理问题。蒙特卡罗方法广泛应…
阅读更多...
用git bash调用md5sum进行批量MD5计算

用git bash调用md5sum进行批量MD5计算

对于非常大的文件或者很重要的文件&#xff0c;在不稳定的网络环境下&#xff0c;可能文件的某些字节会损坏。此时&#xff0c;对文件计算MD5即可以校验其完整性。比如本次的 OpenStreetMap 导出包&#xff0c;我的学弟反馈通过网盘下载无法解压&#xff0c;并建议我增加每个文…
阅读更多...
最新文章

Copyright @ 2022~2023