เมทริกซ์ Pauliเป็นชุดของ 2x2 เมทริกซ์ที่ปรากฏบ่อยมากในฟิสิกส์ควอนตัม (ไม่คุณไม่จำเป็นต้องรู้ฟิสิกส์ควอนตัมใด ๆ สำหรับความท้าทายนี้) ถ้าเรารวมตัวตนในเซตเมทริกซ์ทั้งสี่คือ:

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

คูณสองเหล่านี้มักจะให้อีกเมทริกซ์ Pauli แม้ว่ามันอาจจะคูณด้วยหนึ่งในขั้นตอนที่ซับซ้อน1, i, ,-1 ยกตัวอย่างเช่น-iσ1σ3 = -iσ2

งานของคุณคือการคูณเมทริกซ์ Pauli จำนวนหนึ่งและส่งกลับเมทริกซ์และเฟสผลลัพธ์ การป้อนข้อมูลจะได้รับเป็นสตริงที่ไม่ว่างเปล่าของตัวเลข0ที่จะ3เป็นตัวแทนของการฝึกอบรมเพื่อ เอาท์พุทควรจะเป็นสตริงที่มีหลักเดียวสำหรับเมทริกซ์ที่เกิดขึ้นนำโดยเลือก, หรือเพื่อระบุเฟส ( สำหรับ)σ0σ3i--i--1

คุณสามารถเขียนโปรแกรมหรือฟังก์ชั่น, รับอินพุตผ่าน STDIN (หรือทางเลือกที่ใกล้เคียงที่สุด), อาร์กิวเมนต์บรรทัดคำสั่งหรืออาร์กิวเมนต์ของฟังก์ชันและส่งผลลัพธ์ผ่าน STDOUT (หรือทางเลือกที่ใกล้เคียงที่สุด), ค่าส่งคืนของฟังก์ชันหรือพารามิเตอร์

คุณต้องไม่ใช้คุณสมบัติในตัว (หรือบุคคลที่สาม) ใด ๆ ที่เกี่ยวข้องกับการฝึกอบรมของ Pauli

นี่คือรหัสกอล์ฟคำตอบที่สั้นที่สุด (เป็นไบต์) ชนะ

กรณีทดสอบ

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

Pyth, 47 ไบต์

ฉันเดาว่านี่ยังคงสามารถเล่นกอล์ฟได้ แต่มันเต้น CJam ได้มาก

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

ลองใช้ออนไลน์: การสาธิตหรือชุดทดสอบ

คำอธิบาย

การกำหนดเมทริกซ์ที่ได้นั้นเป็นเพียงการคำนวณจำนวนทั้งหมด

ในขณะที่การคูณ 2 การฝึกอบรมA*Bการเปลี่ยนแปลงขั้นตอนถ้าไม่ใช่ของเมทริกซ์คือและσ0A != 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 ไบต์

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`

(ขอบคุณ @grc และ @xnor สำหรับความช่วยเหลือ)

คำอธิบาย

ลองแยกสัมประสิทธิ์และเมทริกซ์ฐาน หากเรามุ่งเน้นที่เมทริกซ์ฐานเท่านั้นเราจะได้รับตารางการคูณนี้ (เช่น13คือ-i2เราจึงใส่2):

  0123

0 0123
1 1032
2 2301
3 3210

ซึ่งเพิ่งเกิดขึ้นเป็นสิ่งเดียวกับการทำ bitor xor

ทีนี้มาดูที่สัมประสิทธิ์ หากเรา0123แสดงว่า1,i,-1,-iตามลำดับเราจะได้:

  0123

0 0000
1 0031
2 0103
3 0310

สำหรับสิ่งนี้เราต้องตรวจสอบก่อนว่าตัวเลขใดเป็น 0 ด้วยm*yการดูแลคอลัมน์ซ้ายและแถวบนสุด เพิ่มใน(m-y)%3แล้วให้:

  0123

0 0000
1 0021
2 0102
3 0210

ซึ่งอยู่ใกล้ยกเว้นว่าเรามีแทน2 เราบัญชีสำหรับการนี้โดยการดำเนินการ3*3/2

สำหรับการทำดัชนีเราสังเกตเห็นว่าถ้าเราใช้เวลาสตริง"--i"และเลือกตัวละครทุกตัวที่สองเริ่มต้นจากดัชนีที่เราได้รับ0123"-i","-","i",""

เรติน่า , 77 ไบต์

ฉันคิดว่าฉันจะใช้โอกาสนี้เพื่อแสดงคุณลักษณะใหม่ของ Retina: ลูปหลายขั้นตอน สิ่งนี้จะสั้นลงหลาย ๆ งานมาก (โดยเฉพาะการเปลี่ยนตามเงื่อนไข)

ii
-
+`(.)\1|0

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

Retina เป็นภาษาการเขียนโปรแกรมที่อิงจาก regex ของฉันเอง ซอร์สโค้ดสามารถจัดกลุ่มเป็นสเตจได้: แต่ละสเตจประกอบด้วยสองบรรทัดโดยที่แรกประกอบด้วยเรกซ์ (และอาจมีการกำหนดค่าบางอย่าง) และบรรทัดที่สองคือสตริงการแทนที่ ขั้นตอนจะถูกนำไปใช้กับ STDIN ตามลำดับและผลลัพธ์สุดท้ายจะถูกพิมพ์ไปยัง STDOUT

คุณสามารถใช้ข้อมูลด้านบนโดยตรงเป็นไฟล์ต้นฉบับด้วย-sสวิตช์บรรทัดคำสั่ง อย่างไรก็ตามฉันไม่ได้นับสวิตช์เพราะคุณสามารถใส่แต่ละบรรทัดในไฟล์แยกกันได้ (จากนั้นคุณจะสูญเสีย 15 ไบต์สำหรับบรรทัดใหม่ แต่เพิ่ม +15 สำหรับไฟล์เพิ่มเติม)

คำอธิบาย

สิ่งใหม่เกี่ยวกับการแก้ปัญหานี้คือ)ในขั้นตอนสุดท้าย นี่เป็นการปิดลูปแบบหลายขั้นตอน ไม่มีการจับคู่(ซึ่งหมายความว่าการวนซ้ำเริ่มต้นในระยะแรก ดังนั้น 7 ขั้นตอนแรกจะถูกทำซ้ำจนกว่าจะผ่านเต็มทั้ง 7 ของพวกเขาหยุดการเปลี่ยนแปลงผล 7 ขั้นตอนเหล่านี้ทำการแปลงแบบต่าง ๆ ซึ่งค่อย ๆ ลดจำนวนเมทริกซ์ในสตริงและรวมเฟส เมื่อเราไปถึงผลลัพธ์สุดท้ายแล้วไม่มีรูปแบบใดในเจ็ดรูปแบบที่ตรงกันอีกต่อไปและลูปจะสิ้นสุดลง หลังจากนั้นเราจะเพิ่ม 0 หากไม่มีผลลัพธ์ในหลัก

นี่คือสิ่งที่แต่ละขั้นตอนทำ:

ii
-

รวมคู่ทั้งหมดiเข้าด้วยกัน-เพื่อลดอักขระเฟส

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

ตอนนี้ถ้ามีตัวอักขระที่เหมือนกันสองตัวที่เหลืออยู่มันเป็น--เมทริกซ์ที่เหมือนกันหนึ่งหรือสองตัว ไม่ว่าในกรณีใดการทวีคูณพวกมันจะทำให้เกิดอัตลักษณ์ แต่เราไม่ต้องการข้อมูลเฉพาะตัวดังนั้นเราจึงลบข้อมูลทั้งหมดและข้อมูลเฉพาะตัวที่ชัดเจน0ออกไป ขั้นตอนนี้ซ้ำแล้วซ้ำอีกในตัวเองด้วย+จนกว่าผลจะหยุดการเปลี่ยนแปลง สิ่งนี้ทำให้มั่นใจได้ว่าสิ่งต่าง ๆ123321ได้รับการแก้ไขอย่างสมบูรณ์เช่นว่าขั้นตอนต่อไปสามารถสันนิษฐานได้ว่าตัวเลขทุกคู่มีความแตกต่างกัน

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

นี่คือการแปลงสองแบบแยกกันในหนึ่งเดียว (สำหรับ golfitude) โปรดทราบว่าหากการจับคู่ทางเลือกแรก$2และ$3ว่างเปล่าและหากการจับคู่ที่สอง$1ว่างเปล่า ดังนั้นสามารถแบ่งย่อยเป็นสองขั้นตอนเหล่านี้:

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

เพียงแค่สลับตัวเลขทุกคู่และเพิ่มเครื่องหมายลบ เนื่องจากเราเอาออกทั้งหมด0และคู่ที่เหมือนกันทั้งหมดนี้จะตรงกับ12, 23, 31, 21, ,32 13ขั้นตอนนี้อาจดูแปลก แต่ช่วยให้ฉันตรวจสอบเพียงครึ่งหนึ่งของกรณีเหล่านี้ในภายหลังเพราะสิ่งที่ฉันไม่สามารถประมวลผลได้จะถูกสลับที่นี่ในการทำซ้ำครั้งถัดไป

อีกส่วนหนึ่งของเวทีด้านบนคือ:

(.)-
-$1

สิ่งนี้จะค่อย ๆ เคลื่อน-สัญญาณไปทางซ้าย (หนึ่งตำแหน่งต่อการวนซ้ำ) ฉันทำเช่นนี้ในที่สุดพวกเขาทั้งหมดอยู่ติดกันและได้รับการแก้ไขในขั้นตอนก่อนหน้า

12
i3
23
i1
31
i2

สามขั้นตอนเหล่านี้สามารถแก้ไขผลิตภัณฑ์สามคู่ได้อย่างง่ายดาย ดังที่ฉันได้กล่าวไว้ข้างต้นนี่จะจับได้เพียงครึ่งหนึ่งของคดีที่เกี่ยวข้อง แต่อีกครึ่งหนึ่งจะได้รับการดูแลในการทำซ้ำครั้งถัดไปหลังจากขั้นตอนก่อนหน้าสลับคู่ทั้งหมด

)`(\d)i
i$1

นี่คือขั้นตอนสุดท้ายของการวนซ้ำ มันคล้ายกับหนึ่งที่เปลี่ยนแปลงไปทางซ้ายยกเว้น- iความแตกต่างที่สำคัญคืออันนี้สลับiกับตัวเลขเท่านั้น หากฉันใช้(.)iในกรณีที่ฉันได้รับหนึ่ง-iหรือi-สองจะถูกสลับไปเรื่อย ๆ และโปรแกรมจะไม่ยุติ ดังนั้นนี่แค่เปลี่ยนพวกมันไปทางขวาของ-เครื่องหมาย นี้ก็เพียงพอ - ตราบใดที่ทุกคน-และiปรากฏร่วมกันในบางจุดที่พวกเขาสามารถได้รับการแก้ไขอย่างถูกต้อง

^\D*$
$&0

ขั้นตอนสุดท้าย (นอกวง) โปรดจำไว้ว่าเราลบข้อมูลเฉพาะตัวทั้งหมดเสมอดังนั้นหากผลลัพธ์นั้นเป็นตัวตนจริง (คูณเฟส) ดังนั้นเราจะไม่ต้องการตัวเลขหลักในผลลัพธ์อีกต่อไปดังนั้นเราจึงเพิ่มกลับ

ตัวอย่างเช่นนี่คือรูปแบบกลางทั้งหมดของ0223202330203313021301011023230323(การข้ามขั้นตอนที่ไม่ทำการเปลี่ยนแปลงใด ๆ ):

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 ไบต์

ฉันแน่ใจว่านี่สามารถเล่นกอล์ฟได้มาก แต่ที่นี่จะไป:

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

ลองออนไลน์ได้ที่นี่หรือเรียกใช้ชุดสมบูรณ์ที่นี่