Các ma trận Pauli là một tập hợp của 2x2 ma trận mà xuất hiện rất phổ biến trong vật lý lượng tử (không, bạn không cần phải biết bất kỳ vật lý lượng tử cho thách thức này). Nếu chúng ta bao gồm danh tính trong tập hợp, bốn ma trận là:

 σ0 =      σ1 =      σ2 =      σ3 = 
[1  0]    [0  1]    [0 -i]    [1  0]
[0  1]    [1  0]    [i  0]    [0 -1]

Nhân hai số này sẽ luôn luôn cung cấp cho một ma trận Pauli, mặc dù nó có thể được nhân với một trong những giai đoạn phức tạp 1, i, -1, -i. Ví dụ , .σ1σ3 = -iσ2

Nhiệm vụ của bạn là nhân một số ma trận Pauli và trả về ma trận và pha kết quả. Đầu vào sẽ được cung cấp dưới dạng một chuỗi các chữ số không trống 0để 3biểu diễn các ma trận tới . Kết quả phải là một chuỗi có chứa một chữ số duy nhất cho ma trận kết quả, tùy chọn trước bởi , hoặc để chỉ giai đoạn ( là ).σ0σ3i--i--1

Bạn có thể viết chương trình hoặc hàm, lấy đầu vào qua STDIN (hoặc thay thế gần nhất), đối số dòng lệnh hoặc đối số hàm và xuất kết quả qua tham số STDOUT (hoặc thay thế gần nhất), tham số trả về hàm hoặc tham số hàm (out).

Bạn không được sử dụng bất kỳ tính năng tích hợp (hoặc bên thứ 3) nào liên quan đến ma trận Pauli.

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

Các trường hợp thử nghiệm

1 => 1
13 => -i2
000 => 0
123 => i0
03022 => 3
02132230 => -i3
1320130100032 => i2
311220321030322113103 => -2
0223202330203313021301011023230323 => -i0
1323130203022111323321112122313213130330103202032222223 => -1

Bình thường, 47 byte

Tôi đoán đây vẫn là golf. Nhưng nó đánh bại CJam rất nhiều.

p.U&-=T*q3l{[0bZ)^_1%-Zb3xbZmvdz@+c"i - -i")khT

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

Giải trình

Xác định loại ma trận kết quả chỉ đơn giản là xored tất cả các số.

Trong khi nhân 2 ma trận A*B, pha thay đổi, nếu không phải là ma trận là σ0và A != B.

                                                 implicit: T=10, z=input string
                            mvdz                 evaluate each char of the input 
 .U                                              reduce: b=first value, for Y in mvdz[1:]
    -=T                                            T -= ...
        q3l{[0bZ)                                     (3 == len(set([0,b,Z])))
       *         ^_1%-Zb3                             * (-1)^((Z-b)%3)
   &                                               and
                         xbY                       update b by (b xor Y)
                                 +c"i - -i")k    the list ["i", "-", "-i", ""]
                                @            hT  take the element at index T+1 (modulo wrapping)
p                                                print phase and matrix

Python 2, 108 89 87 86 byte

x=y=0
for m in map(int,raw_input()):x+=m*y and(m-y)%3*3/2;y^=m
print"--i"[~x%4::2]+`y`

(Cảm ơn @grc và @xnor vì sự giúp đỡ)

Giải trình

Chúng ta hãy phân chia hệ số và ma trận cơ sở. Nếu chúng ta tập trung vào các ma trận cơ sở chỉ, chúng tôi nhận bảng cửu chương này (ví dụ 13là -i2, vì vậy chúng tôi đặt 2):

  0123

0 0123
1 1032
2 2301
3 3210

điều tương tự xảy ra giống như làm xor bitwise.

Bây giờ hãy tập trung vào các hệ số. Nếu chúng ta để 0123biểu thị 1,i,-1,-itương ứng, chúng ta nhận được:

  0123

0 0000
1 0031
2 0103
3 0310

Đối với điều này, trước tiên chúng tôi kiểm tra xem một trong hai số có bằng 0 hay không m*y, quan tâm đến cột bên trái và hàng trên cùng. Thêm vào (m-y)%3sau đó cho:

  0123

0 0000
1 0021
2 0102
3 0210

đó là gần, ngoại trừ rằng chúng ta có 2thay vì 3. Chúng tôi giải thích cho điều này bằng cách thực hiện *3/2.

Để lập chỉ mục, chúng tôi nhận thấy rằng nếu chúng tôi lấy chuỗi "--i"và chọn mỗi ký tự thứ hai bắt đầu từ các chỉ số 0123chúng tôi nhận được "-i","-","i","".

Võng mạc , 77 byte

Tôi nghĩ rằng tôi sẽ sử dụng cơ hội này để thể hiện một tính năng Retina mới: các vòng lặp nhiều giai đoạn. Điều này sẽ rút ngắn nhiều nhiệm vụ đáng kể (đặc biệt là thay thế có điều kiện).

ii
-
+`(.)\1|0

(.)-|(\d)(\d)
-$1$3$2
12
i3
23
i1
31
i2
)`(\d)i
i$1
^\D*$
$&0

Retina là ngôn ngữ lập trình dựa trên regex của riêng tôi. Mã nguồn có thể được nhóm thành các giai đoạn: mỗi giai đoạn bao gồm hai dòng trong đó dòng đầu tiên chứa regex (và có khả năng một số cấu hình) và dòng thứ hai là chuỗi thay thế. Các giai đoạn sau đó được áp dụng cho STDIN theo thứ tự và kết quả cuối cùng được in thành STDOUT.

Bạn có thể sử dụng trực tiếp ở trên dưới dạng tệp nguồn với -scông tắc dòng lệnh. Tuy nhiên, tôi không tính công tắc, vì bạn cũng có thể chỉ đặt mỗi dòng vào một tệp riêng biệt (sau đó bạn mất 15 byte cho dòng mới, nhưng thêm +15 cho các tệp bổ sung).

Giải trình

Điều mới về giải pháp này là )trong giai đoạn áp chót. Điều này đóng một vòng lặp nhiều giai đoạn. Không có kết quả khớp (, có nghĩa là vòng lặp ngầm bắt đầu ở giai đoạn đầu tiên. Do đó, 7 giai đoạn đầu tiên được lặp lại cho đến khi vượt qua tất cả 7 giai đoạn dừng thay đổi kết quả. 7 giai đoạn này chỉ đơn giản là thực hiện các phép biến đổi khác nhau làm giảm dần số lượng ma trận trong chuỗi và kết hợp các pha. Khi chúng tôi đạt được kết quả cuối cùng, không có mẫu nào trong bảy mẫu phù hợp nữa và vòng lặp kết thúc. Sau đó, chúng tôi sẽ thêm 0 nếu không có chữ số nào trong kết quả (vì các giai đoạn trên chỉ đơn giản là bỏ tất cả các danh tính, bao gồm cả kết quả).

Đây là những gì các giai đoạn cá nhân làm:

ii
-

Kết hợp tất cả các cặp ivào -để giảm các ký tự pha.

+`(.)\1|0
<empty>

Bây giờ nếu còn lại hai ký tự giống hệt nhau, thì đó là một --hoặc hai ma trận giống hệt nhau. Trong cả hai trường hợp, nhân chúng cho danh tính. Nhưng chúng tôi không cần danh tính, vì vậy chúng tôi chỉ cần xóa tất cả chúng, và cả danh tính rõ ràng 0. Giai đoạn này được lặp lại trong chính nó +cho đến khi kết quả ngừng thay đổi. Điều này đảm bảo rằng những thứ như 123321được giải quyết hoàn toàn, sao cho bước tiếp theo có thể giả định rằng tất cả các cặp chữ số là khác biệt.

(.)-|(\d)(\d)
-$1$3$2

Đây thực sự là hai biến đổi riêng biệt trong một (đối với sân gôn). Lưu ý rằng nếu trận đấu thay thế đầu tiên $2và $3trống, và nếu trận đấu thứ hai $1trống. Vì vậy, điều này có thể được phân tách thành hai bước sau:

(\d)(\d)
-$2$1

Điều này chỉ hoán đổi tất cả các cặp chữ số và thêm một dấu trừ. Kể từ khi chúng tôi loại bỏ tất cả 0s và tất cả các cặp giống hệt nhau, điều này sẽ chỉ phù hợp với 12, 23, 31, 21, 32, 13. Bước này có vẻ kỳ lạ, nhưng nó cho phép tôi chỉ kiểm tra một nửa các trường hợp này sau đó, vì những trường hợp tôi không thể xử lý sau đó sẽ được hoán đổi ở đây trong lần lặp tiếp theo.

Phần khác của giai đoạn trên là:

(.)-
-$1

Điều này dần dần di chuyển -các dấu hiệu cho đến bên trái (một vị trí trên mỗi lần lặp). Tôi làm điều này sao cho cuối cùng tất cả chúng nằm cạnh nhau và được giải quyết ở bước trước.

12
i3
23
i1
31
i2

Ba giai đoạn này bây giờ chỉ đơn giản là giải quyết ba cặp sản phẩm. Như tôi đã nói ở trên, điều này sẽ chỉ bắt được một nửa các trường hợp có liên quan, nhưng nửa còn lại sẽ được xử lý trong lần lặp tiếp theo, sau bước trước đó đã hoán đổi tất cả các cặp.

)`(\d)i
i$1

Đây là giai đoạn cuối cùng của vòng lặp. Nó tương tự như cái dịch chuyển -sang trái, ngoại trừ i. Sự khác biệt chính là cái này ichỉ hoán đổi với các chữ số. Nếu tôi sử dụng (.)ithì trong trường hợp tôi nhận được một -ihoặc i-hai cái sẽ bị tráo đổi vô thời hạn và chương trình sẽ không chấm dứt. Vì vậy, điều này chỉ hoán đổi họ ở bên phải của các -dấu hiệu. Điều này là đủ - miễn là tất cả -và ixuất hiện cùng nhau tại một số điểm, chúng có thể được giải quyết chính xác.

^\D*$
$&0

Bước cuối cùng (bên ngoài vòng lặp). Hãy nhớ rằng chúng tôi luôn xóa tất cả các danh tính, vì vậy nếu kết quả thực sự là danh tính (lần một pha), thì chúng tôi sẽ không có chữ số bắt buộc trong đầu ra nữa, vì vậy chúng tôi sẽ thêm lại.

Ví dụ, đây là tất cả các hình thức trung gian của 0223202330203313021301011023230323(bỏ qua các giai đoạn không thực hiện bất kỳ thay đổi nào):

0223202330203313021301011023230323

321321312        # Remove identities
-23-31-12-132    # Swap all pairs
-23-31-i3-132    # Resolve 12
-i1-31-i3-132    # Resolve 23
-i1-i2-i3-132    # Resolve 31
-i-1i-2i-3-312   # Move - to the left and swap pairs
-i-1i-2i-3-3i3   # Resolve 12
-i-i1-i2-3-i33   # Move i to the left
-i-i1-i2-3-i     # Remove identities
--ii-1i-2-3i     # Move - to the left
--ii-i1-2-i3     # Move i to the left
----i1-2-i3      # Resolve ii
i1-2-i3          # Remove identities
i-1-2i3          # Move - to the left
i-1-i23          # Move i to the left
-i-1i-32         # Move - to the left and swap pairs
-i-i1-32         # Move i to the left
--ii-1-23        # Move - to the left and swap pairs
--ii-1-i1        # Resolve 23
----1-i1         # Resolve ii
1-i1             # Remove identities
-1i1             # Move - to the left
-i11             # Move i to the left
-i               # Remove identities. Now the loop can't change this any longer.
-i0              # Fix the result by adding in the 0.

CJam, 58 56 byte

Tôi chắc chắn rằng điều này có thể được chơi golf rất nhiều, nhưng ở đây nó đi:

L'i'-"-i"]q{+:G$i:XA<X{GiB%_2m8%!+m<XB%gX3%3-z*}?s}*\0=o

Dùng thử trực tuyến tại đây hoặc chạy bộ hoàn chỉnh tại đây