背景

是的，位串物理是真实的东西。这个想法是用仅在概率规则或某些规则下演化的比特串来构造新的物理学理论。尽管阅读了几篇有关它的论文，但我还是很困惑。但是，比特串世界使高尔夫成为一个不错的小代码。

程序宇宙

位串物理发生在所谓的程序宇宙中。在宇宙的演化的每个步骤中，存在有限列表L一些长度的位串的k，首先是两个元素的列表[10,11]，其中k = 2。一个时间步的处理如下（使用类似Python的伪代码）。

A := random element of L
B := random element of L
if A == B:
    for each C in L:
        append a random bit to C
else:
    append the bitwise XOR of A and B to L

所有随机选择都是一致随机的，并且彼此独立。

例

4个步骤的示例演变如下所示。从初始列表开始L：

10
11

我们随机选择A := 10和B := 10，它们在同一行，这意味着我们需要L使用随机位来扩展每个字符串：

101
110

接下来，我们选择A := 101和B := 110，由于它们不相等，因此将它们的XOR添加到L：

101
110
011

然后，我们选择A := 011和B := 110，然后再次附加其XOR：

最后，我们选择A := 101（最后一行）和B := 101（第一行），它们相等，因此我们使用随机位扩展：

任务

您的任务是将一个非负整数t作为输入，模拟程序Universe的t时间步长，并返回或打印结果列表L。请注意，t = 0结果将出现在初始列表中[10,11]。您可以输出L为整数列表，布尔值列表或字符串列表。如果输出到STDOUT，则还可以以某种合理的格式每行打印一位。位串的顺序很重要。特别是，初始列表不能[11,10]，[01,11]或者类似的东西。函数和完整程序都可以接受，不允许标准漏洞，并且最低字节数为准。

code-golf array-manipulation random

— 兹加布
source

我们可以限制位字符串的长度（即：我可以使用32位数字和位操作）吗？

— edc65

1

@ edc65不，字符串的长度可以任意增加。

— Zgarb 2015年

3

@ edc65超过32位的预期时间和内存要求是天文数字，但这很合适，因为我们正在模拟Universe。;）

— Zgarb

5

这是Bit-string Physics的骗子吗？我还没有读完整篇论文，但是我们使用位串物理这一短语 来提供一种理论，在该理论中，hbar的近似值c / e2 = 22-1 + 23-1 + 27-1 = 137在以下方面有意义计算机算法和信息论让我有些吃惊。

— xebtl

1

@xebtl在我看来也很疯狂。我记得在某处读过该算法的论证，听起来更像是伪哲学，而不是物理学。另外，您对算法的描述似乎与我的版本相符，也许我在某种程度上误解了您。

— Zgarb 2015年

7

Pyth，27 26字节

u?+RO2GqFKmOG2aGxVFKQ*]1U2

在线试用：演示

说明：

                              implicit: Q = input number
                     *]1U2    the initial list [[1,0], [1,1]]
u                   Q         reduce, apply the following expression Q times to G = ^
          mOG2                  take two random elements of G
         K                      store in K
       qF                       check if they are equal
 ?                              if they are equal:
  +RO2G                           append randomly a 0 or 1 to each element of G
                                else:
              aG                  append to G
                xVFK              the xor of the elements in K

— 雅库比
source

xVFK等同于xMK。

— isaacg 2015年

@isaacg否，xVFK等于xMCK，相同字节数。

— 2015年

11

CJam，42 40 38 37字节

Sp3000保存了1个字节。

B2b2/q~{:L_]:mR_~#L@~.^a+L{2mr+}%?}*p

说明

将初始状态创建为以2为底的数字：

B2b e# Push the the binary representation of 11: [1 0 1 1]
2/  e# Split into chunks of 2 to get [[1 0] [1 1]]

然后执行主循环，并在最后漂亮打印结果：

q~       e# Read and eval input t.
{        e# Run this block t times.
  :L     e#   Store the current universe in L.
  _]     e#   Copy it and wrap both copies in an array.
  :mR    e#   Pick a random element from each copy.
  _~     e#   Duplicate those two elements, and unwrap them.
  #      e#   Find the second element in the first. If they are equal, it will be found at
         e#   index 0, being falsy. If they are unequal, it will not be found, giving
         e#   -1, which is truthy.

         e#   We'll now compute both possible universes for the next step and then select
         e#   the right one based on this index. First, we'll build the one where they were
         e#   not equal.

  L@~    e#   Push L, pull up the other copy of the selected elements and unwrap it.
  .^     e#   Take the bitwise XOR.
  a+     e#   Append this element to L.

  L      e#   Push L again.
  {      e#   Map this block onto the elements in L.
    2mr+ e#     Append 0 or 1 at random. 
  }%     
  ?      e#   Select the correct follow-up universe.
}*
p        e# Pretty-print the final universe.

在这里测试。

— 马丁·恩德
source

6

朱莉娅141个 129字节

t->(L=Any[[1,0],[1,1]];for i=1:t r=1:length(L);A=L[rand(r)];B=L[rand(r)];A==B?for j=r L[j]=[L[j],rand(0:1)]end:push!(L,A$B)end;L)

没什么聪明的。创建一个未命名函数，该函数接受整数作为输入并返回一个数组数组。要给它起个名字，例如f=t->...。

取消+说明：

function f(t)
    # Start with L0
    L = Any[[1,0], [1,1]]

    # Repeat for t steps
    for i = 1:t
        # Store the range of the indices of L
        r = 1:length(L)

        # Select 2 random elements
        A = L[rand(r)]
        B = L[rand(r)]

        if A == B
            # Append a random bit to each element of L
            for j = r
                L[j] = [L[j], rand(0:1)]
            end
        else
            # Append the XOR of A and B to L
            push!(L, A $ B)
        end
    end

    # Return the updated list
    L
end

例子：

julia> f(4)
4-element Array{Any,1}:
 [1,0,1,0]
 [1,1,1,1]
 [0,1,1,0]
 [0,1,0,0]

julia> f(3)
3-element Array{Any,1}:
 [1,0,1,1]
 [1,1,1,0]
 [0,1,0,1]

多亏了ML，节省了12个字节！

— 亚历克斯·A
source

如果使用ternay运算符而不是if / else并更改，则可以将其缩减为133个字符A=something;B=something else to A,B=something,something else：

t->(L=Any[[1,0],[1,1]];for i=1:t r=1:length(L);A,B=L[rand(r)],L[rand(r)];A==B?(for j=r L[j]=[L[j],rand(0:1)]end):(push!(L,A$B))end;L)

— ML

@ML：好的，谢谢。我没想到要使用三元运算符。但是您实际上并不需要三元括号，这比您的建议节省了另外4个括号。实际上A，B分别分配和的长度与将它们分配在一起的长度相同，因此我将该部分保留了下来。再次感谢您的建议！

— Alex A.

别客气。知道了是的，不需要括号。

— ML 2015年

4

Python 2，141

我尝试了几种不同的方法，但是我能得到的最好的方法是相对简单的。感谢@ Sp3000提供15个字符左右的字符（并告诉我有关的存在int.__xor__）。

from random import*
L=[[1,0],[1,1]];C=choice
exec"A=C(L);B=C(L);L=[L+[map(int.__xor__,A,B)],[x+[C([1,0])]for x in L]][A==B];"*input()
print L

— 沙伯
source

这是141：链接

— Sp3000

4

Python 2中，127 122

假设形式'0b1'等的python位字符串是可以的：

from random import*
C=choice
L=[2,3]
exec"x=C(L)^C(L);L=L+[x]if x else[a*2+C([0,1])for a in L];"*input()
print map(bin,L)

这里只有轻微的细微差别是利用XOR（A，B）= 0且A = B的事实。

感谢@ Sp300缩短了封闭for循环

— 约克
source

不过，请看一下评论，我认为需要保留前导零

— Sp3000，2015年

我现在无法测试此答案，但是很遗憾，如果它不保留前导零，那的确是错误的。

— Zgarb 2015年

3

珀斯，34岁

u?+RO`TGqJOGKOG+Gsm`s!dqVJKQ[`T`11

使用reduce来应用每个迭代。我会在打高尔夫球时解释。

在这里尝试

— 弗莱姆·埃格曼
source

2

K，46 53 46字节

{x{:[~/t:2?x;{x,*1?2}'x;x,,,/~=/t]}/(1 0;1 1)}

这个大小的很大一部分（大约7个字节）是因为K没有xor运算符，所以我必须自己实现。最初，我使用了一个字符串列表，然后意识到这是非常愚蠢的。所以现在我又切断了7个字节！

之前：

{x{:[~/t:2?x;{x,*$1?2}'x;x,,,/$~=/(0$')'t]}/$:'10 11}

@JohnE在评论中指出，应该对初始状态进行硬编码，这会增加7个字节。：/

— kirbyfan64sos
source

我对问题规范的阅读是，您必须始终以硬编码的“ Universe”开头(1 0;1 1)-您的程序接受此作为输入。

— JohnE

@JohnE固定。但是，由于我没有测试这些更改，因此无法保证这将起作用。我刚刚尝试了您的

— rek

似乎在Kona也能正常工作。

— JohnE

2

JavaScript（ES6）152

一个使用字符串的函数（带数字的字符串应更短一些，但在javascript中，位操作限于32位整数）。

使用以下代码段在Firefox中进行测试。

F=(t,L=['10','11'],l=2,R=n=>Math.random()*n|0,a=L[R(l)],b=L[R(l)])=>
   t--?a==b
     ?F(t,L.map(x=>x+R(2)),l)
     :F(t,L,L.push([...a].map((x,p)=>x^b[p]).join('')))
  :L
  
test=_=>O.innerHTML=F(+I.value).join('\n')

#I{width:3em}

<input id=I value=10><button onclick=test()>-></button><pre id=O></pre>

展开摘要

— edc65
source

1

K，45 41 38字节

{x{(x,,~=/t;{x,1?2}'x)@~/t:2?x}/1,'!2}

我的答案的结构与@ kirbyfan64sos的结构非常相似，但是我使用1/0向量代替了字符串，并且:[ ; ; ]通过索引到列表中来避免了有条件的（）。

一些运行：

  {x{(x,,~=/t;{x,1?2}'x)@~/t:2?x}/1,'!2}3
(1 0 0 0
 1 1 1 1
 0 1 1 1)

  {x{(x,,~=/t;{x,1?2}'x)@~/t:2?x}/1,'!2}3
(1 0 0
 1 1 0
 0 1 0
 1 0 0)

  {x{(x,,~=/t;{x,1?2}'x)@~/t:2?x}/1,'!2}3
(1 0 0
 1 1 0
 0 1 0
 1 1 0)

编辑：

使用更紧凑的方式保存了四个字节来构建初始Universe：

1,'!2     / new
(1 0;1 1) / old

编辑2：

我忘记了“选择”可以将列表作为其正确的参数：

  2?"abcd"
"dc"
  2?"abcd"
"cc"
  2?"abcd"
"ca"

因此，我可以简化其中的一部分。值得一提的是，柯比（Kirby）在我这样做之前就掌握了这个技巧。

2?x    / new
x@2?#x / old

— 约翰
source

1

当，有时候我想我知道K，然后我就会看到你的答案...：O

— kirbyfan64sos 2015年

我认为该解决方案绝对是团队合作的结晶！

— JohnE 2015年

1

的Javascript，241个 233字节

太长了。

a=[[1,0],[1,1]];for(b=prompt();b--;)if(c=a.length,d=a[c*Math.random()|0],e=a[c*Math.random()|0],d+""==e+"")for(f=0;f<c;f++)a[f].push(2*Math.random()|0);else{g=[];for(h=0;h<d.length;h++)g.push(d[h]^e[h]);a.push(g)}alert(a.join("\n"));

— 超级绝地224
source

Closure Compiler压缩它节省了8个字节。

— 古斯塔沃·罗德里格斯

216个字节：

for(b=prompt(a=[[1,0],[1,1]]),R=Math.random;b--;){c=a.length;d=a[c*R()|0];e=a[c*R()|0];if(d+""==e+"")for(f=0;f<c;f++)a[f].push(2*R()|0);else{for(h=0,g=[];h<d.length;)g.push(d[h]^e[h++]);a.push(g)}}alert(a.join("\n"))

，在3/5的时间内产生所需的输出。

— Ismael Miguel

217位元组：

for(b=prompt(a=[[1,0],[1,1]]),R=Math.random;b--;){c=a.length;d=a[c*R()|0];e=a[c*R()|0];if(d+""==e+"")for(f=0;f<c;f++)a[f].push(2*R()|0);else{g=[];for(h=0;h<d.length;h++)g.push(d[h]^e[h]);a.push(g)}}alert(a.join("\n"))

，有90％的时间能运作。

— Ismael Miguel

1

T-SQL（2012+），1019

我真的很抱歉，这几乎没有竞争力，但是老实说，我认为我无法将其付诸实践，必须在发布后再发布。我确实尝试过一点:)

为了处理二进制/整数转换，我必须创建几个标量函数（513个字节）。A从整数到位字符串。B相反。

CREATE FUNCTION A(@ BIGINT)RETURNS VARCHAR(MAX)AS
BEGIN
DECLARE @S VARCHAR(MAX);
WITH R AS(SELECT @/2D,CAST(@%2 AS VARCHAR(MAX))M
UNION ALL
SELECT D/2,CAST(D%2 AS VARCHAR(MAX))+M
FROM R
WHERE D>0)SELECT @S=M FROM R WHERE D=0
RETURN @S
END
CREATE FUNCTION B(@ VARCHAR(MAX))RETURNS BIGINT AS
BEGIN
DECLARE @I BIGINT;
WITH R AS(SELECT CAST(RIGHT(@,1)AS BIGINT)I,1N,LEFT(@,LEN(@)-1)S
UNION ALL 
SELECT CAST(RIGHT(S,1)AS BIGINT)*POWER(2,N),N+1,LEFT(S,LEN(S)-1)
FROM R
WHERE S<>''
)SELECT @I=SUM(I)FROM R
RETURN @I
END

然后是过程。 @C是步骤数

DECLARE @C INT=9
DECLARE @ TABLE(S VARCHAR(MAX))
DECLARE @R VARCHAR(MAX)
INSERT @ VALUES('10'),('11')
WHILE(@C>=0)
BEGIN
SET @C-=1
SELECT @R=CASE WHEN MAX(S)=MIN(S)THEN''ELSE RIGHT(REPLICATE('0',99)+dbo.A(dbo.B(MAX(S))^dbo.B(MIN(S))),LEN(MAX(S)))END
FROM(SELECT TOP 2S,ROW_NUMBER()OVER(ORDER BY(SELECT\))N FROM @,(VALUES(1),(1),(1))D(D)ORDER BY RAND(CAST(NEWID()AS VARBINARY(50))))A
IF @R=''UPDATE @ SET S=CONCAT(S,ROUND(RAND(CAST(NEWID() AS VARBINARY(50))),0))
ELSE INSERT @ VALUES(@R)
END
SELECT * FROM @

万次迭代耗时约2分钟，返回了9991行

1001001100110
1101001001110
0111100100101
1111100001011
1111001010011
0110101001101
...
1110101000100
1111011101100
1100001100010
0110010001001
1110100010100

— 米奇
source

0

Pyth-37个字节

很明显，只是遵循psuedocode。大概可以打很多球。

KPP^,1Z2VQ=K?m+dO1KqFJ,OKOKaKxVhJeJ;K

在这里在线尝试。

— 马尔蒂森
source

3

您需要O2代替O1。O1给您一个范围内的随机数U1 = [0]。

— Jakube

2

因此，您总是会附加一个0。

— Jakube 2015年

0

Mathematica，106个字节

Nest[If[Equal@@#,Map[#~Append~RandomInteger[]&],Append[BitXor@@#]]&[#~RandomChoice~2]@#&,{{1,0},{1,1}},#]&

— Alephalpha
source

0

Perl，102岁

#!perl -p
@l=qw(10 11);$_=$l[rand@l]^$l[rand@l],$_|=y//0/cr,@l=/1/?(@l,$_):map{$_.~~rand 2}@l for 1..$_;$_="@l"

试试我。

— 坚果
source

0

R，186

L=list(0:1,c(1,1))
if(t>0)for(t in 1:t){A=sample(L,1)[[1]]
B=sample(L,1)[[1]]
if(all(A==B)){L=lapply(L,append,sample(0:1, 1))}else{L=c(L,list(as.numeric(xor(A,B))))}}
L

这里没什么神奇的。t在R控制台中输入的值，然后运行脚本。很难“寻找” R代码，但这是一个更具可读性的版本：

L <- list(0:1, c(1, 1))
if(t > 0) {
  for(t in 1:t) {
    A <- sample(L, 1)[[1]]
    B <- sample(L, 1)[[1]]
    if (all(A == B)) {
      L <- lapply(L, append, sample(0:1, 1))
    } else {
      L <- c(L,list(as.numeric(xor(A, B))))
    }
  }
}
L

— 暗语者
source

您可以通过分配sample变量来保存许多字符。例如s=sample，然后使用s而不是sample。不幸的是，我认为您在方法中添加随机位的方法lapply最终将一个随机样本添加到列表中的所有项目。lapply(L,function(x)append(x,sample(0:1,1)))似乎可以工作，但是要付出一定的代价。您可以将其替换as.numeric为1*应该得到的补偿。

— MickyT 2015年

这两点都有不错的收获，也有很好的强制技巧

— Shadowtalker 2015年

也只是注意到您的数量已用完。我让168使用本

— MickyT

0

露比（82）

非常简单。与其他非高尔夫语言相比，ruby的大型标准库似乎表现出色。

->t{l=[2,3]
t.times{a,b=l.sample 2
a.equal?(b)?l.map!{|x|x*2+rand(2)}:l<<(a^b)}
l}

t = 101010的样本输出：

[9, 15, 6, 13, 5, 12, 10, 11, 5, 4, 15, 13, 2, 7, 11, 9, 3, 3, 8, 6, 3, 13, 13, 12, 10, 9, 2, 4, 14, 9, 9, 14, 15, 7, 10, 4, 10, 14, 13, 7, 15, 7]

— 蓝橙
source