Tôi đang chơi xung quanh với máy tự động di động và tôi tìm thấy một trong đó có một số hành vi thú vị. Đây là cách nó hoạt động:

Nó đọc một chuỗi nhị phân từ trái sang phải, nếu nó gặp một giá trị 1tiếp theo, 2nó sẽ nối thêm 0vào kết quả và tiếp tục đọc. Nếu nó gặp một 0(hoặc còn ít hơn 3 giá trị), nó sẽ nối thêm giá trị hiện tại và a 1và tiếp tục đọc. Ở cuối chuỗi, nó sẽ nối thêm một 1kết quả.

Đây là một ví dụ về một thế hệ

01011111
^

Chúng tôi lần đầu tiên gặp phải 0vì vậy chúng tôi nối 01vào kết quả của chúng tôi

01011111
 ^
01

Bây giờ chúng tôi gặp phải 1vì vậy chúng tôi nối số 0 và bỏ qua hai giá trị tiếp theo

01011111
    ^
010

Chúng tôi gặp người khác 1nên chúng tôi cũng làm như vậy

01011111
       ^
0100

Bây giờ chúng ta có một 1khoảng trống khác nhưng không đủ để nhảy nên chúng ta nối thêm ô hiện tại và một 1(trong trường hợp này 11)

01011111
        ^
010011

Chúng tôi đang ở cuối nên chúng tôi nối thêm một 1và chấm dứt thế hệ này

01011111
        ^
0100111

Bài tập

Đưa ra đầu vào ở bất kỳ định dạng hợp lý nào, bạn phải tạo một hàm hoặc chương trình tính toán một thế hệ của máy tự động.

Đây là một câu hỏi golf-code vì vậy câu trả lời sẽ được tính bằng byte, với ít byte hơn sẽ tốt hơn.

Mẫu thực hiện

Dưới đây là một triển khai mẫu trong Haskell (xác định hàm d, nhưng chương trình in một lần lặp vô thời hạn):

d('1':_:_:x) = "0" ++ d x
d(a:x) = a:'1':d x
d x = "1"
r x = x:map d(r x)

Hãy thử trực tuyến!

V , 26 22 21 byte

Cảm ơn @CowsQuack cho 4 byte bằng cách kết hợp các biểu thức chính quy! Và @ rjanJohansen cho một byte khác với một số kết hợp regex.

Ó1../3
Ó./&1
Ó31/0
A1

Hãy thử trực tuyến!

Sử dụng thay thế nhiều lần và thêm 1 vào cuối. Không có gì quá lạ mắt. Tôi có một phiên bản ánh xạ lại 1và 0ở chế độ chèn để có được hiệu ứng mong muốn, nhưng nó dài hơn một chút.

(Nhiều phiên bản thay thế: Dùng thử trực tuyến! )

JavaScript (ES6), 56 byte

Đưa đầu vào như một mảng các ký tự. Trả về một chuỗi hoặc số 1nếu được cung cấp một mảng trống.

f=([v,...a])=>v?(+v&&a[1]?a.splice(0,2)&&'0':v+1)+f(a):1

Bản giới thiệu

f=([v,...a])=>v?(+v&&a[1]?a.splice(0,2)&&'0':v+1)+f(a):1

console.log(f([...'01011111']))
console.log(f([...'10']))

Phiên bản hoạt hình

Ví dụ về đầu vào ổn định: 0101, 010011111

f=([v,...a])=>v?(+v&&a[1]?a.splice(0,2)&&'0':v+1)+f(a):1

s = '1';
setInterval(_=>o.innerHTML=s=''+f([...s]), 200)

<input oninput="s=this.value" value="1" />
<pre id=o style="font-size:32px"></pre>

Python 2 , 88 byte

I,r=input(),[]
while I:a=I[0]and len(I)>2;b=a<1;r+=[I[0]]*b+[+b];I=I[a*2+1:]
print r+[1]

Hãy thử trực tuyến!

Python 2 , 89 byte

x=input()
y=0
k=[]
while x[y:]:v=1-x[y]*(y<len(x)-2);k+=[x[y]]*v+[v];y+=3-2*v
print k+[1]

Hãy thử trực tuyến!

-4 byte nhờ vào Rod
-6 byte nhờ
các byte -1 byte nhờ micsthepick

Swift 3 , 147 byte

-1 cảm ơn @ Mr.Xcoder

func g(i:[Int]){var r=[Int]();var s=ArraySlice(i);while let e=s.popFirst(){if 0<e&&2<s.count{r+=[0];s=s.dropFirst(2)}else{r+=[e,1]}};print(r+[1])}

Ung dung, trả lại giá trị thay vì in:

func iterate(state: [Int]) -> [Int] {
    var result = [Int]()

    var inputSlice = ArraySlice(state)

    while let element = inputSlice.popFirst() {
        if 0 < element && 2 < inputSlice.count { 
            result += [0]
            inputSlice = inputSlice.dropFirst(2)
        }
        else {
            result += [element, 1]
        }

        //debugPrint(result.map(String.init).joined(separator: ""))
    }

    return result + [1]
}

Python 2 , 81 byte

Cả đầu vào và đầu ra đều là danh sách (nhờ Erik the Outgolfer)

def f(Z):return Z and((1>Z[0]or 3>len(Z))and[Z[0],1]+f(Z[1:])or[0]+f(Z[3:]))or[1]

Hãy thử trực tuyến!

Một số trường hợp

[0,1,0,1,1,1,1,1] --> [0,1,0,0,1,1,1]
[0] ----------------> [0,1,1]
[1] ----------------> [1,1,1]
[] -----------------> [1]
[0,1] --------------> [0,1,1,1,1]
[1,0] --------------> [1,1,0,1,1]

Python 2 , 85 byte

Cả đầu vào và đầu ra là các chuỗi (giải pháp ban đầu)

def f(Z):return Z and(('0'==Z[0]or 3>len(Z))and Z[0]+'1'+f(Z[1:])or'0'+f(Z[3:]))or'1'

Hãy thử trực tuyến!

Một số trường hợp

'01011111'--> 0100111
'0'---------> 011
'1'---------> 111
''----------> 1
'01'--------> 01111
'10'--------> 11011

Giải thích Nó đơn giản là một golf của một phương pháp đệ quy.

Perl 5 , 62 + 2 ( -F) = 64 byte

$r.=$F[$i]&&$i+2<@F&&($i+=2)?0:"$F[$i]1";++$i<@F&&redo;say$r.1

Hãy thử trực tuyến!

Scala , 131 + 29 = 160 byte

Đây là bên trong một hàm lấy chuỗi alàm tham số và trả về đầu ra dưới dạng chuỗi.

var s=""
var k=0
for(c<-0 to a.length-1)breakable{if(k>0){k-=1
break}
if(a(c)==49&c<a.length-3){s+="0"
k+=2}else s+=a(c)+"1"}
s+"1"

Tôi phải làm import util.control.Breaks._vậy, vì vậy tôi cần thêm 28 byte đó cộng với một dòng cấp dữ liệu.

Hãy thử trực tuyến!

C # (.NET Core) , 108 byte

n=>{var t="";for(int i=0,b=n.Length;i<b;){if(n[i]>'0'&i+2<b){t+="0";i+=3;}else t+=n[i++]+"1";}return t+"1";}

Hãy thử trực tuyến!

Đầu vào được lấy dưới dạng một chuỗi và một chuỗi được trả về làm đầu ra.