Code Golf：MSM 随机数生成器

Question

挑战：

按字符数计算的最短代码将使用 中方法。

（伪）随机数生成的中方法由 John Von Neumann 于 1946 年首次提出，定义如下：

R_n+1 = mid ((R_n)², m)

例如：

3456² = 11943936

中(11943936) = 9439

9439² = 89094721

中(89094721) = 0947

947² = 896809

中(896809) = 9680

9680² = 93702400

中(93702400) = 7024

另一个例子：

843² = 710649

中（710649）= 106

106² = 11236

中（11236）= 123

123² = 15129

中(15129) = 512

512² = 262144

中(262144) = 621

621² = 385641

中（385641）= 856

856² = 732736

中(732736) = 327

327² = 106929

中(106929) = 069

69² = 4761

中（4761）= 476

476² = 226576

中(226576) = 265

mid 的定义：

显然对于 mid 的确切定义存在一些混乱。出于本次挑战的目的，假设您正在提取与起始种子相同数量的数字。这意味着，如果起始种子有 4 位数字，您将从中间提取 4 位数字。如果起始种子有 3 位数字，您将从中间提取 3 位数字。

关于在无法找到精确中间位置时提取数字的问题，请考虑数字710649。如果要提取中间的 3，则存在一些歧义（106 或 064）。在这种情况下，提取最接近字符串开头的 3。因此，在本例中，您将提取 106。

一种简单的思考方法是，如果数字位数不正确，则在数字中填充零。例如，如果将前导零填充到 710649，则会得到 0710649，中间的 3 位数字现在变为 106。

测试用例：

不对种子的长度做出任何假设。例如，您不能假设种子始终是 4 位数字

生成 4 位随机数的起始种子 3456 应生成以下序列（前 10 个）：

9439、947、9680、7024、3365、3232、4458、8737、3351、2292

生成 4 位随机数的起始种子 8653 应生成以下序列（前 10 个）：

8744、4575、9306、6016、1922、6940、1636、6764、7516、4902

生成 3 位随机数的 843 起始种子应生成以下序列（前 10 个）：

106、123、512、621、856、327、69、476、265、22

生成 5 位随机数的起始种子 45678 应生成以下序列（前 10 个）：

86479、78617、80632、1519、30736、47016、10504、3340、11556、35411

就前导零而言，答案是不应显示前导零:)。

Answer 1

Google 文档 - 电子表格：42 个字符

=MID(C2^2,LEN(C2^2)/2-LEN(C2)/2+1,LEN(C2))

用法：

• 将初始种子放入单元格 C2 中，然后拖动所有序列的公式。

测试用例：

• 共享文档：所有测试用例的实时预览。

屏幕截图：

Code Golf：MSM 随机数生成器 http://img59.imageshack.us/ img59/6830/golfo.png

限制：

• 此公式保留前导零，但可以使用另一列并对结果应用 INT() 来修剪它们。

Answer 2

dc 26/37 chars

26 chars 单个数字的函数：

?dZsl2^dZ1+ll-2/Ar^/All^%p

37 chars 10 个循环循环：

?dZsl[2^dZ1+ll-2/Ar^/All^%pdzB>L]dsLx

函数说明：

?            Input n
dZ           calculate number of digits
sl           store in register l
2^           calculate n^2
dZ           calculate number of digits of square
1+ll-2/Ar^/  n/(10^((squaredigits+1-l)/2)) int division truncates last digits 
All^%        n%(10^l) modulus truncates first digits
p            print the number

测试：

dc msml.dc
45678
86479
78617
80632
1519
30736
47016
10504
3340
11556
35411

Answer 3

Python（86 个字符）

r=input()
l=len(str(r))
while 1:
 x=str(r*r)
 y=(len(x)-l)/2
 r=int(x[y:y+l])
 print r

在标准输出上生成无限序列。请注意，反引号技巧至少在 long 类型的旧版本上不起作用，因为表示形式中以 L 结尾。 Python 3 print 作为函数会添加 1 个以上的字符来结束括号。

Answer 4

C#（96 81 79 85 84 个字符）

更改日志

• 已添加Yuliy 对 81 的建议
• 删除了 79 的额外括号。
• 增加计数，因为我最初没有计算必要的空格（仅字符）。
• 根据 Camerons 的建议，将 1.0 替换为 1d。

---

我的代码：

    int F(int s, int l)
    {
        var r = "" + 1d*s*s;

        return int.Parse(r.Substring((r.Length - l) / 2, l));
    }

---

使用示例：

    int s = 8653;
    int l = 4;
    for(int i = 0; i< 10; i++)
    {
        s = F(s, l);
        Console.WriteLine(s);
    }

---

结果

---8653---
8744
4575
9306
6016
1922
6940
1636
6764
7516
4902

---843---
106
123
512
621
856
327
69
476
265
22

---45678---
86479
78617
80632
1519
30736
47016
10504
3340
11556
35411

Answer 5

Perl (102 96 95 93 92 79 个字符)

$s =$_;$d=长度$s;map{$s*=$s;print 0+($s=substr$s,($s=~y///c-$d)/2,$d ),$/}0..9

echo -n 3456 | perl -ne '$s=$_;$d=length$s;map{$s*=$s;print 0+($s=substr$s,($s=~y///c-$d)/2,$d),$/}0..9'
9439
947
9680
7024
3365
3232
4458
8737
3351
2292

Answer 6

Groovy -

s=args[0]as int;def r(){f=s*s;g=f as String;t=g.size()/2;g=g[t-2..t+1];s=g as int}

使用第一个参数作为种子的 82 个字符，并由 4 个 base10 数字组成的输出，如您的示例中所示。

Answer 7

Perl，80 个字符

（来自命令行）

$n=pop;$l=length$n;map{$n*=$n;print 0+($n=substr$n,(length($n)-$l)/2,$l),$/}0..9

Answer 8

Ruby，85 76 69 个字符（生成并打印 10 个数字）

n=gets
l=n.size
10.times{n=n.to_i;x=(n*n).to_s;p n=x[(x.size-l)/2,l]}

从标准输入读取。

输出

> ruby rand.rb < 3456
9439
947
9680
7024
3365
3232
4458
8737
3351
2292

> ruby rand.rb < 8653
8744
4575
9306
6016
1922
6940
1636
6764
7516
4902

> ruby rand.rb < 843
106
123
512
621
856
327
69
476
265
22

> ruby rand.rb < 45678
86479
78617
80632
1519
30736
47016
10504
3340
11556
35411

Answer 9

JavaScript：91 个字符

function a(s,n){m=(s+'').length;while(n--)c=''+s*s,s=1*c.substr((c.length-m)/2,m);return s}

用法：

a(3456, 4);     // 4th seed of 3456:   Returns: 7024
a(8653, 2);     // 2nd seed of 8653:   Returns: 4575
a(843, 10);     // 10th seed of 843:   Returns: 22
a(45678, 6);    // 6th seed of 45678:  Returns: 47016

完整测试用例：

var tests = [3456, 8653, 843, 45678];

for (var i = 0; i < tests.length; i++) {
   console.log('-------------');
   console.log('| Seed: ' + tests[i]);
   console.log('-------------');

   for(var j = 1; j <= 10; j++) {
      console.log('| ' +  a(tests[i], j));
   }

   console.log('~~~~~~~~~~~~~');
}

测试结果：

-------------         -------------
| Seed: 3456          | Seed: 8653
-------------         -------------
| 9439                | 8744
| 947                 | 4575
| 9680                | 9306
| 7024                | 6016
| 3365                | 1922
| 3232                | 6940
| 4458                | 1636
| 8737                | 6764
| 3351                | 7516
| 2292                | 4902
~~~~~~~~~~~~~         ~~~~~~~~~~~~~

-------------         -------------
| Seed: 843           | Seed: 45678
-------------         -------------
| 106                 | 86479
| 123                 | 78617
| 512                 | 80632
| 621                 | 1519
| 856                 | 30736
| 327                 | 47016
| 69                  | 10504
| 476                 | 3340
| 265                 | 11556
| 22                  | 35411
~~~~~~~~~~~~~         ~~~~~~~~~~~~~

Answer 10

Haskell

---

注意：生成一个包含 MSM 随机数的无限列表。

---

函数，81

l=length
m k n=take k$drop(div(l n-k)2)n
r n=iterate(read.m(l$show n).show.(^2))n

用法示例：

r 34562

输出示例：

[34562,94531,36109,3859,48918,92970,...

---

程序，103

l=length
m k n=take k$drop(div(l n-k)2)n
r n=iterate(read.m(l$show n).show.(^2))n
main=readLn>>=print.r

---

Answer 11

Haskell (97 99 chars)

可能仍然可以缩短。产生一个无限序列，或者至少遇到 0，在这种情况下它会崩溃。

i(f:l)x=x:i l(f x)
m n=head.filter((==n).length).i(cycle[init,tail])
b r n=n:b r(read$m r$show$n*n)

用法：b <数字长度>

*Main> b 5 45678
[45678,86479,78617,80632,1519,30736,47016,10504,3340,11556,35411...

解释

该程序不是应用子字符串并使用字符串长度算术，而是在删除最后一个字符 (init) 和删除第一个字符之间进行迭代(tail) 直到达到所需的长度。

正如迭代以及大多数 Haskell 函数一样，假设所使用的函数是常量。由于函数本身发生了变化，因此我们需要实现一个特殊版本的迭代。

Answer 12

Ruby（66 个字符）

假设整数输入：

def r s,l=s.to_s.size;x=(s*s).to_s;y=x.size;x[(y-l)/2,l].to_i;end

Answer 13

Lua (135 128 114 个字符)

function r(i)
l=string.len
b=i or b
s=i or s
p=s*s..""
e=(l(p)-l(b))/2
s=tonumber(p:sub(e+1,e+l(b)))
return s
end

带有一个参数的种子并返回第一个 MSM 随机整数；不带参数的后续调用将返回下一个 MSM 随机整数。调用另一个整数来重新播种。

测试：

> =r(3456)
9439
> =r()
947
> =r()
9680
> =r()
7024
> =r()
3365
> =r()
3232
> =r()
4458
> =r()
8737
> =r()
3351
> =r()
2292
> =r(8653)
8744
> =r()
4575
> =r()
9306
> =r()
6016
> =r()
1922
> =r()
6940
> =r()
1636
> =r()
6764
> =r()
7516
> =r()
4902
> =r(843)
106
> =r()
123
> =r()
512
> =r()
621
> =r()
856
> =r()
327
> =r()
69
> =r()
476
> =r()
265
> =r()
22
> =r(45678)
86479
> =r()
78617
> =r()
80632
> =r()
1519
> =r()
30736
> =r()
47016
> =r()
10504
> =r()
3340
> =r()
11556
> =r()
35411
> 

Answer 14

Perl - 112 - 现在，108 - 现在 95 （感谢 Zaid 的想法） - 字符没有空格，不包括测试驱动程序循环（例如，我只计算了生成 1 的代码） sequence) - foreach 循环体中的代码。

@s=(8653,843,45678,3456);
foreach $s (@s){
    for(0..9){$s*=$s;$l=length($s);$L||=($l+1)/2;$H=($l+$L+1)/2;
        $s=substr($s,-$H,$L)+0;
        print "$s,"
    }
    print "\n";
    $L=0; @S=(); # Reset for next loop
}

输出：

8744,4575,9306,6016,1922,6940,1636,6764,7516,4902,
106,123,512,621,856,327,69,476,265,22,
86479,78617,80632,1519,30736,47016,10504,3340,11556,35411,
9439,947,9680,7024,3365,3232,4458,8737,3351,2292,

压缩后的代码为 112：

for(0..9){$s*=$s;$l=length($s);$L||=($l+1)/2;$H=($l+$L+1)/2;$s=substr($s,-$H,$L)+0;print "$s,"}

Answer 15

Perl, 100 94 92 91 90 88 个字符

通过标准输入提供的种子。为了可读性而包含换行符：

@n=($n=pop)=~/./g;
for(0..9){
    @s=$n**2=~/./g;
    $n=join$\,splice@s,(@s-@n)/2,@n;
    print$/,$n+0
}