三位毫秒数产生随机数方法

#1 三位随机数是获取电子硬件的毫秒级时间戳，从后到前的读取三个数字，把它们组合成三位数。

（例如毫秒级时间戳1672673902720，获得的三位数是027。

毫秒级时间戳是一个十多位的数字。由于前部分的数字过于固定，因此舍弃，只取后三位数字，越是后面的数字变化速度越快，因此把它放在数字的前面来获得变化性更大的数。）

#2 平均修正值是获取电子硬件的毫秒级时间戳的最后一个数，如果它是0或能被2整除则把平均修正值设置成假，否则是真。每次它被使用后改变它的值。

（可以用相反的顺序。）

#3 随机取数法是获取一个三位随机数，读取它的第一个数字并且把它从数字中移除，名为位数值，目标数的第一个数字的位数是0，如果平均修正值是真则按照从左到右的顺序读取目标数的第位数值个数字，否则用相反的顺序读取，如果目标数的位数是0则结果是000，如果位数值大于目标数的位数减1则用它除以目标数的位数获得余数作为它，直到读取三个数字，把读取的三个数字组合成三位数。获取一个平均修正值，如果它是假则把读取的数字从目标数中删除。

#4 平均取数法是把目标数作为结果，如果目标数的位数大于需求位数，则如果平均修正值是假则从左边移除第一个数字，否则从右边移除第一个数字，直到目标数的位数等于需求位数，如果平均修正值是假则把它的顺序反过来。把获取的数字从目标数中删除。

#5 取数法是先使用随机取数法从目标数中获取一个三位数，如果需求位数小于三则从左到右获取需求位数个数字，如果需求位数大于三则再使用平均取数法从相同目标数中获取一个差值位数的数字，然后把它们组合成需求位数的数字。

#6 结果边界修复法是如果结果小于随机数最小值，如果结果与随机数最小值的差值大于随机数范围差值则用它除以范围差值先加1获得余数，用范围最大值减余数再加1获得结果，如果结果大于范围最大值则改成范围最小值，如果结果与随机数最小值的差值不大于随机数范围差值则用范围最大值减它再加1获得结果；如果结果大于随机数最大值，如果结果与随机数最大值的差值大于随机数范围差值则用它除以范围差值先加1获得余数，用范围最小值加余数再减1获得结果，如果结果小于范围最小值则改成范围最大值，如果结果与随机数最大值的差值不大于随机数范围差值则用范围最小值加它再减1获得结果。

(随机数最小值最小是0。）

#7 获取结果数池法是获取一个三位随机数，名为随机原参数，读取它的前二个数字组合成二位数，如果它小于2则改成9。把它复制给结果数池，重复用结果数池乘以它，如果平均修正值是假则把结果添加在结果数池的左边，否则添加在它的右边，直到结果数池的位数不小于十五，如果平均修正值是真则从左到右读取十五个它的数字，否则从右到左，把这些数字组合成十五位数。

（如果参数小于2则乘以自己无法增加它，把它修改成9的原因是9乘以任何数字获得的结果的数字分布最平均。）

#8 获取随机数法是用取数法分别从结果数池获取一个七位数和一个五位数，获取一个三位随机数，按顺序把三位数和七位数和五位数组合成一个十五位数作为结果数池，如果平均修正值是假则顺序相反。如果随机数最大值的位数不大于3则读取三位随机数的需求位数个数字，否则如果它不大于8则还读取五位数的需求位数减3个数字，否则还读取七位数的需求位数减8个数字，这一轮读取数字时如果平均修正值是真则从左到右读取，否则用相反的顺序，用结果边界修复法修复它。

（把三位随机数放在两边并且用较长的七位数来使它远离中心是因为间隔较短的获取它会获得接近相同的数字，这样会更容易使平均取数法的结果接近相同。记得把结果数池保留下来，否则就会重新获取，这样会严重影响分布平均度。）

实现代码：

class e_random
{
bool? averageRepairValue = null;
static string resultPool = null;
long mostSmall = 0;
long mostBig = 100;

// 设置最小值
public string setMostSmallValue(string _mostSmall)
{
try
{
mostSmall = long.Parse(_mostSmall);
if(mostSmall < 0)
{
return "2：最小值最小是0。";
}
if(mostSmall > mostBig)
{
return "3：最小值不能大于最大值。";
}
}
catch(Exception _e)
{
return "1：设置的值不正确。" + _e.Message;
}
return null;
}

// 设置最大值
public string setMostBigValue(string _mostBig)
{
try
{
mostBig = long.Parse(_mostBig);
if (mostBig < mostSmall)
{
return "2：最大值不能小于最小值。";
}
}
catch (Exception _e)
{
return "1：设置的值不正确。" + _e.Message;
}
return null;
}

// 获取随机数
public long getValue()
{
if (resultPool == null)
{
resultPool = getResultPool();
}
string _sevenString = getNumber(ref resultPool, 7);
string _fiveString = getNumber(ref resultPool, 5);
string _threeString = getThreeDigitRandomNumber();
resultPool = _fiveString + _threeString + _sevenString;
int _digit = mostBig.ToString().Length;
long _result;
StringBuilder _resultString = new StringBuilder();
if (readAverageRepairValue())
{
if (_digit <= 3)
{
for (int o_a = 0; o_a < _digit; o_a++)
{
_resultString.Append(_threeString[o_a]);
}
}
else if (_digit <= 8)
{
for (int o_a = 0; o_a < 3; o_a++)
{
_resultString.Append(_threeString[o_a]);
}
for (int o_a = 0; o_a < _digit - 3; o_a++)
{
_resultString.Append(_fiveString[o_a]);
}
}
else
{
for (int o_a = 0; o_a < 3; o_a++)
{
_resultString.Append(_threeString[o_a]);
}
for (int o_a = 0; o_a < 5; o_a++)
{
_resultString.Append(_fiveString[o_a]);
}
for (int o_a = 0; o_a < _digit - 8; o_a++)
{
_resultString.Append(_sevenString[o_a]);
}
}
}
else
{
if (_digit <= 3)
{
for (int o_a = 0; o_a < _digit; o_a++)
{
_resultString.Append(_threeString[_threeString.Length - 1 - o_a]);
}
}
else if (_digit <= 8)
{
for (int o_a = 0; o_a < 3; o_a++)
{
_resultString.Append(_threeString[_threeString.Length - 1 - o_a]);
}
for (int o_a = 0; o_a < _digit - 3; o_a++)
{
_resultString.Append(_fiveString[_fiveString.Length - 1 - o_a]);
}
}
else
{
for (int o_a = 0; o_a < 3; o_a++)
{
_resultString.Append(_threeString.Length - 1 - _threeString[o_a]);
}
for (int o_a = 0; o_a < 5; o_a++)
{
_resultString.Append(_fiveString.Length - 1 - _fiveString[o_a]);
}
for (int o_a = 0; o_a < _digit - 8; o_a++)
{
_resultString.Append(_sevenString.Length - 1 - _sevenString[o_a]);
}
}
}
_result = long.Parse(_resultString.ToString());
return resultBorderRepair(_result, mostSmall, mostBig);
}

// 获取结果数池
private string getResultPool()
{
string _threeString = getThreeDigitRandomNumber();
_threeString = _threeString.Substring(0, 2);
int _three = int.Parse(_threeString);
if(_three < 2)
{
_three = 9;
}
string _resultString = "";
long _result = _three;
while(_resultString.Length < 15)
{
_result = _result * _three;
if (readAverageRepairValue())
{
_resultString = _resultString + _result.ToString();
}
else
{
_resultString = _result.ToString() + _resultString;
}
}
if (!readAverageRepairValue())
{
_resultString.Reverse();
}
_result = long.Parse(_resultString.Substring(0, 15));
//_resultString = _result.ToString();
return _result.ToString();
}

// 参数修复法
private void repairParameter(List<string> _targetList)
{
List<char> _threeRandomList = getThreeDigitRandomNumber().ToList();
for (int o_a = 0; o_a < _targetList.Count; o_a++)
{
if(_targetList[o_a][0] != '0')
{
continue;
}
while(_threeRandomList[0] == '0')
{
_threeRandomList.RemoveAt(0);
if(_threeRandomList.Count == 0)
{
_threeRandomList = getThreeDigitRandomNumber().ToList();
}
}
string _repair = _threeRandomList[0] + _targetList[o_a].Substring(1);
_targetList[o_a] = _repair;
}
}

// 取数法
private string getNumber(ref string _target,int _needDigit)
{
string _result;
_result = randomGetNumber(ref _target);
if (_needDigit < 3)
{
List<char> _resultList = _result.ToList();
string _resultString = "";
for (int o_a = 0; o_a < _needDigit; o_a++)
{
_resultString = _resultString + _resultList[o_a];
}
_result = _resultString;
}
else
{
string _addNumber = averageGetNumber(ref _target, _needDigit - 3);
List<char> _resultList = _result.ToList();
List<char> _addNumberList = _addNumber.ToList();
for (int o_a = 0; o_a < _addNumberList.Count; o_a++)
{
_resultList.Add(_addNumberList[o_a]);
}
_result = _resultList.converToString();
}
return _result;
}

// 平均取数法
private string averageGetNumber(ref string _target,int _needDigit)
{
string _result = _target;
List<char> _resultList = _result.ToList();
if(_resultList.Count <= _needDigit)
{
return _result;
}
string _targetFront = "";
string _targetBack = "";
while(_resultList.Count > _needDigit)
{
if (readAverageRepairValue() == false)
{
_targetFront = _targetFront + _resultList[0];
_resultList.RemoveAt(0);
}
else
{
_targetBack = _targetBack + _resultList[_resultList.Count - 1];
}
}
string _targetRepair = _target;
_targetRepair = _targetFront + _targetBack;
_target = _targetRepair;
return _resultList.converToString();
}

// 随机取数法
private string randomGetNumber(ref string _target)
{
List<char> _targetList = _target.ToList();
string _threeDigitRandomNumber = getThreeDigitRandomNumber();
List<char> _randomList = _threeDigitRandomNumber.ToList();
int _currentDigit;
int _realDigit;
List<string> _resultList = new List<string>();
List<int> _didReadPosition = new List<int>();
for (int o_a = 0; o_a < 3; o_a++)
{
_currentDigit = int.Parse(_randomList[0].ToString());
if(_currentDigit > (_targetList.Count - 1))
{
if (_targetList.Count == 0)
{
return "000";
}
else { 
_currentDigit = _currentDigit % _targetList.Count; 
}
}
_randomList.RemoveAt(0);
if (readAverageRepairValue() == true)
{
_realDigit = _currentDigit;
}
else
{
_realDigit = _targetList.Count - _currentDigit - 1;
}
try
{
_resultList.Add(_targetList[_realDigit].ToString());
}
catch(Exception _e)
{
Debug.Print("位数：" + _realDigit + " 列表位数：" + _targetList.Count + "\n" + _e.StackTrace);
}
if (!_didReadPosition.Contains(_realDigit))
{
_didReadPosition.Add(_realDigit);
}
}
if (getAverageRepairValue() == false)
{
string _deleteTarget = "";
for (int o_a = 0; o_a < _targetList.Count; o_a++)
{
bool _exist = false;
for (int o_b = 0; o_b < _didReadPosition.Count; o_b++)
{
if(o_a == _didReadPosition[o_b])
{
_exist = true;
break;
}
}
if (!_exist)
{
_deleteTarget = _deleteTarget + _targetList[o_a].ToString();
}
}
_target = _deleteTarget;
}
return _resultList.convertToString();
}

// 读取平均修正值
private bool readAverageRepairValue()
{
bool _result;
if (averageRepairValue == null)
{
averageRepairValue = getAverageRepairValue();
_result = (bool)averageRepairValue;
}
else
{
_result = (bool)averageRepairValue;
if (averageRepairValue == true)
{
averageRepairValue = false;
}
else
{
averageRepairValue = true;
}
}
return _result;
}

// 获得毫秒级时间
private long getMillisecondTime()
{
return (long)((DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalMilliseconds);
}

// 获得平均修正值
private bool getAverageRepairValue()
{
bool _result = true;
string _millisecondTime = getMillisecondTime().ToString();
long _millisecondNumber = long.Parse(_millisecondTime.Substring(_millisecondTime.Length - 1));
if((_millisecondNumber % 2) == 0)
{
_result = false;
}
return _result;
}

// 获得三位随机数
private string getThreeDigitRandomNumber()
{
string _millisecond = getMillisecondTime().ToString();
string _treeDigitMillisecondMunber = "";
for (int o_a = 0; o_a < 3; o_a++)
{
_treeDigitMillisecondMunber = _treeDigitMillisecondMunber + _millisecond[_millisecond.Length - 1 - o_a];
}
return _treeDigitMillisecondMunber;
}

// 结果边界修复法
private long resultBorderRepair(long _result, long _mostSmall, long _mostBig)
{
if (_result >= _mostSmall && _result <= _mostBig)
{
return _result;
}
long _fixResult = _result;
// 修复最小值。
if (_result < _mostSmall)
{
if ((_mostSmall - _result) > (_mostBig - _mostSmall))
{
long _remain = (_mostSmall - _result) % ((_mostBig - _mostSmall) + 1);
_fixResult = _mostBig - _remain + 1;
if (_fixResult > _mostBig)
{
_fixResult = _mostSmall;
}
}
else
{
_fixResult = _mostBig - (_mostSmall - _result) + 1;
}
}
// 修复最大值。
else if(_result > _mostBig)
{
if ((_result - _mostBig) > (_mostBig - _mostSmall))
{
long _remain = (_result - _mostBig) % ((_mostBig - _mostSmall) + 1);
_fixResult = _mostSmall + _remain - 1;
if (_fixResult < _mostSmall)
{
_fixResult = _mostBig;
}
}
else
{
_fixResult = _mostSmall + (_result - _mostBig) - 1;
}
}
return _fixResult;
}
}

依赖代码：

public static class extendDight
{
public static string convertToString(this List<string> _stringList)
{
StringBuilder _sb = new StringBuilder();
for (int o_a = 0; o_a < _stringList.Count; o_a++)
{
_sb.Append(_stringList[o_a]);
}
return _sb.ToString();
}
public static string converToString(this List<char> _charList)
{
StringBuilder _sb = new StringBuilder();
for (int o_a = 0; o_a < _charList.Count; o_a++)
{
_sb.Append(_charList[o_a]);
}
return _sb.ToString();
}
}