Lý lịch

Vâng, vật lý bitcoin là một điều thực sự . Ý tưởng là xây dựng một lý thuyết vật lý mới chỉ sử dụng các chuỗi bit phát triển theo quy tắc xác suất ... hoặc một cái gì đó. Mặc dù đọc một vài bài báo về nó, tôi vẫn khá bối rối. Tuy nhiên, vũ trụ bitcoin tạo ra một golf golf nhỏ đẹp.

Chương trình vũ trụ

Vật lý bitcoin diễn ra trong một vũ trụ được gọi là chương trình . Ở mỗi bước tiến hóa của vũ trụ, có một danh sách hữu hạn Lcác bitstr có độ dài nào đó k, bắt đầu với danh sách hai yếu tố [10,11]trong đó k = 2. Một dấu thời gian được xử lý như sau (trong mã giả giống như 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

Tất cả các lựa chọn ngẫu nhiên là thống nhất ngẫu nhiên và độc lập với nhau.

Thí dụ

Một ví dụ tiến hóa của 4 bước có thể trông giống như sau. Bắt đầu với danh sách ban đầu L:

10
11

Chúng tôi chọn ngẫu nhiên A := 10và B := 10, là cùng một hàng, có nghĩa là chúng tôi cần mở rộng mỗi chuỗi Lbằng một bit ngẫu nhiên:

101
110

Tiếp theo, chúng tôi chọn A := 101và B := 110, vì chúng không bằng nhau, chúng tôi thêm XOR của chúng vào L:

101
110
011

Sau đó, chúng tôi chọn A := 011và B := 110, và một lần nữa thêm XOR của họ:

101
110
011
101

Cuối cùng, chúng tôi chọn A := 101(hàng cuối cùng) và B := 101(hàng đầu tiên) bằng nhau, vì vậy chúng tôi mở rộng với các bit ngẫu nhiên:

1010
1100
0111
1010

Nhiệm vụ

Nhiệm vụ của bạn là lấy một số nguyên không âm tlàm đầu vào, mô phỏng vũ trụ chương trình cho các dấu thời tgian và trả về hoặc in danh sách kết quả L. Lưu ý rằng t = 0kết quả trong danh sách ban đầu [10,11]. Bạn có thể xuất ra Ldưới dạng danh sách các số nguyên, danh sách danh sách các giá trị boolean hoặc danh sách các chuỗi; nếu đầu ra chuyển sang STDOUT, bạn cũng có thể in bitstrings một dòng trên một số định dạng hợp lý. Thứ tự của bitstrings là đáng kể; đặc biệt, danh sách ban đầu không thể [11,10], [01,11]hoặc bất cứ điều gì tương tự. Cả hai chức năng và chương trình đầy đủ đều được chấp nhận, các sơ hở tiêu chuẩn không được phép và số byte thấp nhất sẽ thắng.

Bình thường, 27 26 byte

u?+RO2GqFKmOG2aGxVFKQ*]1U2

Dùng thử trực tuyến: Trình diễn

Giải trình:

                              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

CJam, 42 40 38 37 byte

1 byte được lưu bởi Sp3000.

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

Giải trình

Tạo trạng thái ban đầu dưới dạng số cơ sở 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]]

Và sau đó thực hiện vòng lặp chính và in đẹp kết quả ở cuối:

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.

Kiểm tra nó ở đây.

Julia, 141 129 byte

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)

Không có gì thông minh. Tạo một hàm không tên chấp nhận một số nguyên làm đầu vào và trả về một mảng các mảng. Để gọi nó, đặt tên cho nó, vd f=t->....

Ungolfed + giải thích:

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

Ví dụ:

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]

Đã lưu 12 byte nhờ ML!

Con trăn 2, 141

Tôi đã thử một vài phương pháp khác nhau, nhưng cách tốt nhất tôi có thể nhận được là tương đối đơn giản. Cảm ơn @ Sp3000 cho 15 ký tự hoặc hơn (và đã dạy tôi về sự tồn tại của 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

Con trăn 2, 127 122

Giả sử các chuỗi bit python có dạng, '0b1'v.v.

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)

Chỉ có sắc thái nhẹ ở đây là sử dụng thực tế là XOR (A, B) = 0 iff A = B.

Cảm ơn @ Sp300 đã rút ngắn forvòng lặp kèm theo

Bình thường, 34

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

Sử dụng giảm để áp dụng mỗi lần lặp. Tôi sẽ giải thích khi tôi chơi golf.

Hãy thử nó ở đây

K, 46 53 46 byte

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

Một đoạn tốt về kích thước (khoảng 7 byte) này là do K không có xortoán tử, vì vậy tôi phải tự thực hiện một cái. Ban đầu, tôi đã sử dụng một danh sách các chuỗi, sau đó nhận ra rằng điều đó thật ngu ngốc. Vì vậy, bây giờ tôi cắt bỏ 7 byte một lần nữa!

Trước:

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

@JohnE đã chỉ ra trong các ý kiến ​​rằng trạng thái ban đầu được cho là được mã hóa cứng, có giá 7 byte thêm. : /

JavaScript ( ES6 ) 152

Một hàm, sử dụng các chuỗi (với các số nên ngắn hơn, nhưng trong các hoạt động bit javascript được giới hạn ở các số nguyên 32 bit).

Kiểm tra trong Firefox bằng đoạn mã dưới đây.

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>

K, 45 41 38 byte

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

Cấu trúc câu trả lời của tôi khá giống với cấu trúc của @ kirbyfan64sos, nhưng thay vì các chuỗi tôi đã sử dụng các vectơ 1/0 và tôi tránh sự cần thiết phải có điều kiện ( :[ ; ; ]) bằng cách lập chỉ mục vào danh sách.

Một vài lần chạy:

  {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)

Chỉnh sửa:

Đã lưu bốn byte với cách nhỏ gọn hơn để xây dựng vũ trụ ban đầu:

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

Chỉnh sửa2:

Tôi quên rằng "chọn" có thể lấy một danh sách làm đối số đúng:

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

Vì vậy, tôi có thể đơn giản hóa một phần của điều này. Tín dụng khi đến hạn, Kirby đã có được mánh khóe này trước khi tôi làm.

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

Javascript, 241 233 byte

Đó là loại dài.

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"));

T-SQL (2012+), 1019

Tôi thực sự xin lỗi vì đây không phải là nơi cạnh tranh, nhưng thành thật mà nói tôi đã không nghĩ rằng tôi có thể làm việc này và phải đăng nó một khi tôi đã làm. Tôi đã cố gắng để chơi nó một chút :)

Để xử lý các chuyển đổi nhị phân / số nguyên, tôi phải tạo một vài hàm vô hướng (513 byte). Ađi từ số nguyên đến một chuỗi bit. Bkhông ngược lại.

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

Sau đó là thủ tục. @Clà số bướ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 @

Mười nghìn lần lặp mất khoảng 2 phút và trả về 9991 hàng

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

Pyth - 37 byte

Rõ ràng, chỉ cần làm theo psuedocode. Có lẽ có thể chơi golf rất nhiều.

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

Hãy thử nó ở đây trực tuyến .

Toán học, 106 byte

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

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"

Hãy thử tôi .

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

Không có gì kỳ diệu ở đây. Nhập giá trị cho ttrong bảng điều khiển R và chạy tập lệnh. Thật khó để "đánh gôn" mã R nhưng đây là phiên bản dễ đọc hơn:

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

Ruby, 82

Khá nhiều thẳng về phía trước. So với các ngôn ngữ không chơi gôn khác, ruby ​​dường như làm tốt với thư viện tiêu chuẩn lớn của nó.

->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}

Sản lượng mẫu cho 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]