Trò chơi BattleBlock Theater thỉnh thoảng có một câu đố là phiên bản tổng quát của Lights Out . Bạn đã có ba khối liền kề, mỗi khối chỉ ra một mức từ 1 đến 4 bao gồm các thanh, ví dụ:

|
||||
||

Nếu bạn chạm vào một khối, thì khối đó cũng như bất kỳ khối liền kề nào sẽ tăng cấp độ của nó (gói lại từ 4 đến 1). Câu đố được giải quyết khi cả ba khối thể hiện cùng một cấp độ (không quan trọng là cấp độ nào). Vì, thứ tự bạn chạm vào các khối không quan trọng, chúng tôi biểu thị một giải pháp bằng tần suất mỗi khối được chạm vào. Giải pháp tối ưu cho đầu vào trên sẽ là 201:

|    --> || --> |||     |||
||||     |      ||      |||
||       ||     ||  --> |||

Trò chơi rất dễ dàng khái quát bất kỳ số khối nào, mặc dù đối với một số số, không phải tất cả các cấu hình đều có thể giải được.

Các thách thức

Đưa ra một chuỗi các cấp độ khối, trả về tần suất mỗi khối cần được chạm để giải câu đố. Ví dụ, ví dụ trên sẽ được đưa ra 142và có thể mang lại 201kết quả. Nếu không có giải pháp, hãy trả về một số đầu ra nhất quán mà bạn chọn, có thể phân biệt với tất cả các giải pháp tiềm năng, ví dụ -1hoặc một chuỗi trống.

Bạn có thể viết một hàm hoặc chương trình, nhận đầu vào thông qua STDIN, đối số dòng lệnh hoặc đối số hàm, trong bất kỳ danh sách thuận tiện hoặc định dạng chuỗi nào, và đầu ra tương tự thông qua giá trị trả về hoặc bằng cách in ra STDOUT.

Mã của bạn sẽ trả về kết quả chính xác cho tất cả các trường hợp thử nghiệm trong vòng một phút trên một máy hợp lý. (Đây không phải là một giới hạn hoàn toàn nghiêm ngặt, vì vậy nếu giải pháp của bạn mất một phút và mười giây, thì tốt thôi, nhưng nếu mất 3 phút thì không. Một thuật toán tốt sẽ dễ dàng giải quyết chúng trong vài giây.)

Đây là mã golf, vì vậy câu trả lời ngắn nhất (tính bằng byte) sẽ thắng.

Ví dụ

Các giải pháp không phải là duy nhất, vì vậy bạn có thể nhận được kết quả khác nhau.

Input                          Output

1                              0
11                             00
12                             No solution
142                            201
434                            101
222                            000
4113                           0230
32444                          No solution
23432                          10301
421232                         212301
3442223221221422412334         0330130000130202221111
22231244334432131322442        No solution
111111111111111111111222       000000000000000000000030
111111111111111111111234       100100100100100100100133
412224131444114441432434       113013201011001101012133

Theo tôi biết, có chính xác 4 giải pháp cho mỗi đầu vào trong đó số khối là 0 mod 3 hoặc 1 mod 3 và có 0 hoặc 16 giải pháp trong đó có 2 mod 3.

Python 2, 115 byte

n=input()
for F in range(4):
 t=[F];b=0;exec"x=(-n[b]-sum(t[-2:]))%4;t+=x,;b+=1;"*len(n)
 if x<1:print t[:-1];break

Đây là phiên bản golf của chương trình tôi đã viết trong khi thảo luận về vấn đề với Martin.

Đầu vào là một danh sách thông qua STDIN. Đầu ra là một danh sách đại diện cho giải pháp cuối cùng được tìm thấy nếu có giải pháp hoặc bằng 0 nếu không có. Ví dụ:

>>>
[1, 4, 2]
[2, 1, 1]
>>>
[1, 2]
0
>>>
map(int,"3442223221221422412334")
[2, 3, 3, 2, 1, 3, 2, 0, 0, 2, 1, 3, 2, 2, 0, 0, 2, 2, 3, 1, 1, 3]

Bình thường, 32 29 byte

V4J]NVQaJ%_+s>J_2@QN4)I!eJPJB

Các cảng bắt buộc. Cảm ơn @Jakube đã tiết kiệm 3 byte.

Phương thức nhập giống như trên, thử trực tuyến .

Giải thích (dài và đầy logic!)

Đầu tiên, hai quan sát cơ bản:

• Quan sát 1: Không quan trọng bạn chạm vào khối nào

• Quan sát 2: Nếu bạn chạm vào một khối 4 lần, nó tương đương với chạm vào một lần

Nói cách khác, nếu có một giải pháp thì có một giải pháp trong đó số lần chạm là từ 0 đến 3.

Vì modulo 4 rất đẹp, chúng ta cũng hãy làm điều đó với các khối. Đối với phần còn lại của lời giải thích này, khối cấp 0 tương đương với khối cấp 4.

Bây giờ hãy biểu thị a[k]là mức khối hiện tại kvà x[k]là số lần chúng ta chạm kvào khối trong một giải pháp. Cũng hãy để ntổng số khối. Như @Jakube đã lưu ý, một giải pháp phải đáp ứng:

  a[0]   + x[0] + x[1]
= a[1]   + x[0] + x[1] + x[2]
= a[2]          + x[1] + x[2] + x[3]
= a[3]                 + x[2] + x[3] + x[4]
...
= a[n-1]                                     ...  + x[n-2] + x[n-1] + x[n]
= a[n]                                       ...           + x[n-1] + x[n]
= C

trong đó Ccấp độ cuối cùng là tất cả các khối kết thúc, bao gồm từ 0 đến 3 (hãy nhớ rằng chúng ta coi cấp 4 là cấp 0) và tất cả các phương trình trên thực sự là đồng đẳng modulo 4.

Bây giờ đây là phần thú vị:

• Quan sát 3 : Nếu một giải pháp tồn tại, một giải pháp tồn tại cho bất kỳ cấp độ khối cuối cùng 0 <= C <= 3.

Có ba trường hợp dựa trên số khối modulo 3. Giải thích cho từng khối là như nhau - đối với bất kỳ số khối nào, sẽ tồn tại một tập hợp con của khối, nếu bạn chạm vào từng khối một, sẽ tăng tất cả các cấp khối chính xác 1.

0 mod 3 (touch every third block starting from the second):
    .X. / .X. / .X.

1 mod 3 (touch every third block starting from the first):
    X. / .X. / .X. / .X

2 mod 3 (touch every third block starting from either the first or second):
    X. / .X. / .X. / .X.
    .X. / .X. / .X. / .X

Điều này giải thích tại sao có 4 giải pháp cho 0 mod 3và 1 mod 3, và thường là 16 giải pháp cho 2 mod 3. Nếu bạn đã có giải pháp, chạm vào các khối như trên sẽ đưa ra giải pháp khác kết thúc ở cấp khối cao hơn (bao quanh).

Vì vậy, điều này có nghĩa là gì? Chúng tôi có thể chọn bất kỳ cấp khối cuối cùng Cmà chúng tôi muốn! Hãy chọn C = 0, vì điều này tiết kiệm byte.

Bây giờ phương trình của chúng tôi trở thành:

0 = a[0] + x[0] + x[1]
0 = a[1] + x[0] + x[1] + x[2]
0 = a[2] + x[1] + x[2] + x[3]
0 = a[3] + x[2] + x[3] + x[4]
...
0 = a[n-1] + x[n-2] + x[n-1] + x[n]
0 = a[n] + x[n-1] + x[n]

Và sắp xếp lại:

x[1] = -a[0] - x[0]
x[2] = -a[1] - x[0] - x[1]
x[3] = -a[2] - x[1] - x[2]
x[4] = -a[3] - x[2] - x[3]
...
x[n] = a[n-1] - x[n-2] - x[n-1]
x[n] = a[n] - x[n-1]

Vì vậy, những gì chúng ta có thể thấy là, nếu chúng ta có x[0], thì chúng ta có thể sử dụng tất cả các phương trình ngoại trừ phương trình cuối cùng để tìm hiểu nhau x[k]. Phương trình cuối cùng là một điều kiện bổ sung chúng ta phải kiểm tra.

Điều này cho chúng ta một thuật toán:

• Hãy thử tất cả các giá trị cho x[0]
• Sử dụng các phương trình trên để tìm ra tất cả các phương trình khác x[k]
• Kiểm tra nếu điều kiện cuối cùng được thỏa mãn. Nếu vậy, lưu giải pháp.

Điều đó đưa ra giải pháp trên.

Vậy tại sao đôi khi chúng ta không có giải pháp cho 2 mod 3? Chúng ta hãy xem xét hai mẫu này một lần nữa:

X. / .X. / .X. / .X.
.X. / .X. / .X. / .X

Bây giờ hãy xem xét các phương trình tại các vị trí đó, tức là cho vị trí đầu tiên:

0 = a[0] + x[0] + x[1]
0 = a[3] + x[2] + x[3] + x[4]
0 = a[6] + x[5] + x[6] + x[7]
0 = a[9] + x[8] + x[9] + x[10]

Thêm chúng lên:

0 = (a[0] + a[3] + a[6] + a[9]) + (x[0] + x[1] + ... + x[9] + x[10])

Đối với cái thứ hai:

0 = a[1] + x[0] + x[1] + x[2]
0 = a[4] + x[3] + x[4] + x[5]
0 = a[7] + x[6] + x[7] + x[8]
0 = a[10] + x[9] + x[10]

Thêm chúng một lần nữa:

0 = (a[1] + a[4] + a[7] + a[10]) + (x[0] + x[1] + ... + x[9] + x[10])

Vì vậy, nếu (a[1] + a[4] + a[7] + a[10])và (a[0] + a[3] + a[6] + a[9])không bằng nhau, thì chúng ta không có giải pháp. Nhưng nếu chúng bằng nhau, thì chúng ta nhận được 16 giải pháp. Đây là n = 11trường hợp, nhưng tất nhiên điều này khái quát cho bất kỳ số nào 2 mod 3- lấy tổng của mọi phần tử thứ ba bắt đầu từ phần tử thứ hai và so sánh với tổng của mọi phần tử thứ ba bắt đầu từ phần tử thứ nhất.

Cuối cùng, liệu có thể tìm ra cái gì x[0]phải thay vì thử tất cả các khả năng? Rốt cuộc, vì chúng tôi đã giới hạn mức mục tiêu của Cmình là 0, chỉ x[0]có một giải pháp đưa ra giải pháp trong trường hợp 0 mod 3hoặc 1 mod 3(như 4 solutions / 4 final levels = 1 solution for a specific final level).

Câu trả lời là ... có! Chúng tôi có thể làm điều này cho 0 mod 3:

 .X..X
.X..X.

Dịch ra:

0 = a[2] + x[1] + x[2] + x[3]   -> 0 = (a[2] + a[5]) + (x[1] + ... + x[5])
0 = a[5] + x[4] + x[5]          /


0 = a[1] + x[0] + x[1] + x[2]   -> 0 = (a[1] + a[4]) + (x[0] + x[1] + ... + x[5])
0 = a[4] + x[3] + x[4] + x[5]   /

Trừ đi cho:

x[1] = (a[2] + a[5]) - (a[1] + a[4])

Tương tự như vậy cho 1 mod 3chúng ta có thể làm mô hình này:

 .X..X.
X..X..X

Cung cấp cho:

x[0] = (a[2] + a[5]) - (a[0] + a[3] + a[6])

Tất nhiên những điều này khái quát bằng cách mở rộng các chỉ số theo mức tăng 3.

Vì 2 mod 3, vì chúng tôi có hai tập con bao gồm mọi khối, nên chúng tôi thực sự có thể chọn bất kỳ tập hợp nào x[0]. Trong thực tế, điều này đúng với x[0], x[1], x[3], x[4], x[6], x[7], ...(về cơ bản bất kỳ chỉ số nào không phù hợp 2 mod 3, vì chúng không nằm trong một tập hợp con).

Vì vậy, chúng tôi có cách chọn một x[0]thay vì thử tất cả các khả năng ...

... nhưng tin xấu là điều này không tiết kiệm được byte (124 byte):

def f(n):s=[];L=len(n);B=sum(n[~-L%3::3])-sum(n[-~L%3::3]);x=A=0;exec"s+=B%4,;A,B=B,-n[x]-A-B;x+=1;"*L*(L%3<2or B<1);print s

Pyth, 72 76 73 66 39 38 ký tự

Ph+f!eTmu+G%+&H@G_3-@QH@QhH4UtQd^UT2]Y

chỉnh sửa 4: Nhận ra rằng các tính toánQ[N]-Q[N+1]+solution[-3] và Q[-2]-Q[-1]+solution[-3]được xác định. Do đó, tôi tính toán quá mức cho giải pháp bằng 1 và lọc các giải pháp, trong đó mục cuối cùng là 0. Sau đó tôi bật mục cuối cùng. May mắn thay, các trường hợp đặc biệt không cần điều trị thêm bằng phương pháp này. -27 ký tự

chỉnh sửa 3: Áp dụng một số thủ thuật đánh gôn từ FryAmTheEggman: -7 ký tự

chỉnh sửa 2: Sử dụng bộ lọc, thu nhỏ và ánh xạ: -3 ký tự

chỉnh sửa 1: Trong phiên bản đầu tiên của tôi, tôi đã không in bất cứ thứ gì, nếu không có giải pháp. Tôi không nghĩ rằng điều đó được cho phép, do đó, ký tự +4.

Yêu cầu một danh sách các số nguyên làm đầu vào [1,4,2]và đầu ra một giải pháp hợp lệ [2,0,1]nếu có một, nếu không thì là một danh sách trống [].

Giải trình:

Hãy Qlà danh sách của 5 cấp độ và Ydanh sách các giải pháp. Các phương trình sau phải giữ:

  Q0 + Y0 + Y1 
= Q1 + Y0 + Y1 + Y2
= Q2      + Y1 + Y2 + Y3
= Q3           + Y2 + Y3 + Y4
= Q4                + Y3 + Y4

Do đó, nếu chúng ta sử dụng bất kỳ Y0và Y1, chúng ta có thể tính toán Y2, Y3và Y4theo cách sau.

Y2 = (Q0 - Q1     ) mod 4
Y3 = (Q1 - Q2 + Y0) mod 4
Y4 = (Q2 - Q3 + Y1) mod 4

Hơn tất cả các cấp ngoại trừ cấp cuối cùng bằng nhau (vì chúng tôi đã không sử dụng phương trình = Q4 + Y3 + Y4. Để kiểm tra, nếu cấp cuối cùng này cũng bằng các cấp khác, chúng tôi có thể kiểm tra đơn giản nếu (Q3 - Q4 + Y2) mod 4 == 0. Lưu ý, phần bên trái sẽ là giá trịY5 Nếu tôi tính phần 6 của giải pháp, tôi chỉ cần kiểm tra xem nó có bằng không.

Theo cách tiếp cận của tôi, tôi chỉ đơn giản lặp lại tất cả các khởi đầu có thể ( [0,0], đến [3,3]) và tính toán độ dài (đầu vào) -1 mục nhập khác và lọc tất cả các giải pháp kết thúc bằng 0.

mu+G%+&H@G_3-@QH@QhH4UtQd^UT2   generates all possible solutions

về cơ bản là như sau:

G = start value           //one of "^UT2", [0,0], [0,1], ..., [9,9]
                          //up to [3,3] would be enough but cost 1 char more
for H in range(len(Q)-1): //"UtQ"
   G+=[(H and G[-3])+(Q(H)-Q(H+1))%4] //"+G%+&H@G_3-@QH@QhH4"
   //H and G[-3] is 0, when H is empty, else G[-3]

sau đó tôi lọc các giải pháp có thể cho các giải pháp hợp lệ:

f!eT //only use solutions, which end in 0

vào danh sách các giải pháp này, tôi nối thêm một danh sách trống, để nó có ít nhất một mục trong đó

 +....]Y

và lấy giải pháp đầu tiên h, bật phần tử cuối cùng pvà in nó

 Ph

Lưu ý rằng điều này cũng hoạt động, nếu chỉ có một khối. Theo cách tiếp cận của tôi, tôi có được vị trí bắt đầu [0,0] và không mở rộng nó. Vì mục cuối cùng là 0, nên nó in giải pháp [0].

Trường hợp đặc biệt thứ hai (2 khối) rốt cuộc không phải là đặc biệt. Không chắc chắn, tại sao tôi quá phức tạp những thứ trước đó.

Ruby, 320 313 ký tự

m=gets.chop.chars.map{|x|x.to_i-1}
a=m.map{0}
t=->n{m[n]+=1
m[n-1]+=1if n>0
m[n+1]+=1if n<m.size-1
m.map!{|x|x%4}
a[n]=(a[n]+1)%4}
t[0]until m[0]==1
(2...m.size).map{|n|t[n]until m[n-1]==1}
r=0
while m.uniq.size>1&&m[-1]!=1
(0...m.size).each_with_index{|n,i|([1,3,0][i%3]).times{t[n]}}
(r+=1)>5&&exit
end
$><<a*''

Chắc chắn có thể được chơi golf nhiều hơn. Đầu ra không có gì cho các câu đố không thể giải được.

Phiên bản bị đánh cắp:

#!/usr/bin/ruby

nums = gets.chomp.chars.map {|x| x.to_i-1 }
touches = nums.map {0}

# our goal: make all the numbers 1
# utility function
touch = ->n {
    nums[n] += 1
    nums[n-1] += 1 if n > 0
    nums[n+1] += 1 if n < (nums.length-1)
    nums.map! {|x| x % 4 }
    touches[n] = (touches[n] + 1) % 4
}

# first, start with the very first number
touch[0] until nums[0] == 1

# then, go from index 2 to the end to make the previous index right
(2...nums.length).each {|n|
    touch[n] until nums[n-1] == 1
}

iters = 0
if nums.uniq.length != 1
    # I have no idea why this works
    while nums[-1] != 1
        (0...nums.length).each_with_index {|n, i|
            ([1, 3, 0][i % 3]).times { touch[n] }
        }
        if (iters += 1) > 5
            puts -1
            exit
        end
    end
end

puts touches * ''

Được rồi, cái này rất vui. Đây là thuật toán cơ bản, {n}đại diện cho n "chạm" es vào số ở trên n, như được minh họa trên một trong các ví dụ:

we want each number to be a 1
first make the first number a 1
3442223221221422412334
2}
1242223221221422412334
 {3} now keep "touch"ing until the number to the left is a 1
1131223221221422412334
  {2}
1113423221221422412334
   {2}
1111243221221422412334
... (repeat this procedure)
1111111111111111111110

Tôi đã bối rối một chút ở đây. Làm thế nào tôi có thể biến 111...1110thành một chuỗi các số giống nhau? Vì vậy, tôi đã so sánh giải pháp của mình và giải pháp chính xác (lưu ý: tất cả số lần "chạm" đều lớn hơn một lần vì đầu vào là 1 chỉ mục, trong khi đầu ra là 0 chỉ mục):

3033233103233301320210
0330130000130202221111

Tôi nhận thấy rằng mỗi số cách một số chính xác mod 4, vì vậy tôi đã đánh dấu chúng bằng +s, -s và =s:

3033233103233301320210 original program output
+-=+-=+-=+-=+-=+-=+-=+ amount to modify by (+1, -1, or 0 (=))
4334534404534602621511 result (the correct answer)

0330130000130202221111 (the original solution, digits equal to result mod 4)

Điều đó đã làm việc trong một thời gian, cho đến khi tôi nhận thấy rằng đôi khi kết quả cuối cùng là 111...11112hoặc 11...1113là tốt! May mắn thay, liên tục áp dụng công thức ma thuật vô nghĩa nhưng công việc cũng sắp xếp những thứ này ra.

Vì vậy, có bạn có nó. Một chương trình bắt đầu có ý nghĩa, nhưng suy thoái thành ngày càng xấu hơn khi nó đi. Khá điển hình cho một giải pháp golf mã, tôi nghĩ. :)

Python 2, 294.289.285.281 273 byte

n=input();l=len(n);s=[0]*l
for i in range(2,l):
 a=(n[i-2]-n[i-1])%4;s[i]+=a;n[i-1]+=a;n[i]+=a
 if i+1<l:n[i+1]+=a
 n=[a%4for a in n]
if l%3>1 and n!=[n[0]]*l:print"x"
else:
 for i in range(l%3,l-1,3):s[i]+=(n[l-1]-n[l-2])%4
 m=min(s);s=[(a-m)%4 for a in s];print s

BẢN GIỚI THIỆU

Tôi chắc chắn rằng điều này có thể được đánh gôn hơn nữa ..

Dưới đây là kết quả từ các trường hợp thử nghiệm:

[1]
-> [0]

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

[1,2]
-> x

[1,4,2]
-> [2, 0, 1]

[4,3,4]
-> [1, 0, 1]

[2,2,2]
-> [0, 0, 0]

[4,1,1,3]
-> [0, 2, 3, 0]

[3,2,4,4,4]
-> x

[2,3,4,3,2]
-> [0, 0, 3, 3, 1]

[4,2,1,2,3,2]
-> [2, 0, 2, 3, 3, 1]

[3,4,4,2,2,2,3,2,2,1,2,2,1,4,2,2,4,1,2,3,3,4]
-> [0, 3, 3, 0, 1, 3, 0, 0, 0, 0, 1, 3, 0, 2, 0, 2, 2, 2, 1, 1, 1, 1]

[2,2,2,3,1,2,4,4,3,3,4,4,3,2,1,3,1,3,2,2,4,4,2]
-> x

[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2]
-> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0]

[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,3,4]
-> [1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 3, 3]

[4,1,2,2,2,4,1,3,1,4,4,4,1,1,4,4,4,1,4,3,2,4,3,4]
-> [1, 0, 3, 0, 0, 3, 2, 3, 1, 0, 0, 1, 0, 3, 1, 1, 3, 1, 0, 0, 2, 1, 2, 3]

Thuật toán trước tiên đảm bảo rằng các giá trị của tất cả các khối trừ khối cuối cùng giống nhau (bằng cách lặp qua và thêm vào "số lần chạm" của tất cả các khối trừ 2 khối đầu tiên). Sau đó, nếu số khối cho phép nó ( (num_of_blocks - 1) % 3 != 1), quay lại và đảm bảo các giá trị của các khối còn lại khớp với khối cuối cùng. In xnếu không có giải pháp.