สมมติว่าเรานิยามเมทริกซ์ที่ไม่มีที่สิ้นสุดMบนN^2 -> {0, 1}(โดยNเริ่มจาก1แทน0) ในลักษณะนี้:

• M(1, 1)= 0.

• ทุก ๆx > 1, M(x, 1)= 1ถ้าxเป็นสำคัญและ0เป็นอย่างอื่น

• ทุกy > 1, M(1, y)การ = yระยะ TH Thue-Morse sequenceใน

• ทุก ๆx, y > 1, =M(x, y)M(x, y-1) + M(x-1, y) mod 2

ส่วนด้านซ้าย16x16บนของเมทริกซ์นี้ดูเหมือนว่า ( xเป็นแถวและyเป็นคอลัมน์):

0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0
1 0 1 1 0 0 0 1 0 0 0 1 1 0 1 1
1 1 0 1 1 1 1 0 0 0 0 1 0 0 1 0
0 1 1 0 1 0 1 1 1 1 1 0 0 0 1 1
1 0 1 1 0 0 1 0 1 0 1 1 1 1 0 1
0 0 1 0 0 0 1 1 0 0 1 0 1 0 0 1
1 1 0 0 0 0 1 0 0 0 1 1 0 0 0 1
0 1 1 1 1 1 0 0 0 0 1 0 0 0 0 1
0 1 0 1 0 1 1 1 1 1 0 0 0 0 0 1
0 1 1 0 0 1 0 1 0 1 1 1 1 1 1 0
1 0 1 1 1 0 0 1 1 0 1 0 1 0 1 1
0 0 1 0 1 1 1 0 1 1 0 0 1 1 0 1
1 1 0 0 1 0 1 1 0 1 1 1 0 1 1 0
0 1 1 1 0 0 1 0 0 1 0 1 1 0 1 1
0 1 0 1 1 1 0 0 0 1 1 0 1 1 0 1
0 1 1 0 1 0 0 0 0 1 0 0 1 0 0 1

งานของคุณคือการสร้างโปรแกรมที่จะประเมินค่าของรายการโดยพลการในเมทริกซ์นี้อย่างถูกต้องที่สุด

โปรแกรมของคุณจะใช้จำนวนเต็มสองจำนวน xและyเป็นข้อมูลในรูปแบบใดที่คุณเลือกและผลตอบแทนM(x, y)ซึ่งจะเป็นอย่างใดอย่างหนึ่งหรือ01

รหัสของคุณอาจถูกเขียนในภาษาใด ๆ แต่ต้องมีขนาดไม่เกิน 64 กิโลไบต์ (65,536 ไบต์) ของรหัสต้นฉบับหรือ 2 MB (2,097,152 ไบต์) ของการใช้หน่วยความจำทั้งหมด โปรแกรมของคุณจะต้องเริ่มต้นด้วยหน่วยความจำว่าง (เช่นไม่สามารถโหลดข้อมูลจากที่อื่น) และทำงานแยกต่างหากสำหรับแต่ละอินพุต (นั่นคือมันอาจไม่เก็บข้อมูลทั่วไปสำหรับการทำงานหลายครั้ง) โปรแกรมของคุณจะต้องสามารถประเมินผลรายการทั้งหมดใน8192x8192ตารางด้านบนซ้ายในเวลาที่เหมาะสม

โปรแกรมที่ประเมินผลรายการส่วนใหญ่ได้อย่างถูกต้องใน8192 x 8192ตารางด้านบนซ้ายจะเป็นผู้ชนะด้วยรหัสที่สั้นลงทำหน้าที่เป็นตัวผูกไท

J - 42 38 ตัวอักษร

ค่อนข้างเร็วแม่นยำ 100% และอยู่ภายในข้อ จำกัด ด้านหน่วยความจำ

([{+2&(~:/@#:@#@],~:/\,(p:>:)&#)0:)&<:

กลยุทธ์มีดังต่อไปนี้: เราจะคำนวณ antidiagonals ที่ต่อเนื่องของเมทริกซ์นี้โดยใช้ XOR แบบจับคู่เพื่อเลื่อนตามและเพิ่ม Thue-Morse ปัจจุบันและไพรม์บิตจนถึงจุดสิ้นสุด จากนั้นเราก็ดึงตัวเลขที่ต้องการออกจาก antidiagonal เมื่อเราไปถึงที่นั่น

คำอธิบายจากการระเบิด:

(                                 )&<:  NB. decrement each of x and y
     &(                        )        NB. apply the following function...
   +                                    NB. ... (x-1)+(y-1) times...
                                0:      NB. ... starting with a zero:
    2             ~:/\                  NB.   pairwise XOR on the argument
                      ,(p:>:)&#         NB.   append prime bit (is 1+length prime?)
       ~:/@#:@#@],                      NB.   prepend TM bit (XOR of binary)
 [{                                     NB. take the x-th bit (at index x-1)

การใช้กริยานี้ใช้x m yสำหรับ M (x, y) ตามที่ระบุในคำถามโดยที่mคำกริยาอยู่ตรงไหน

   5 ([{+2&(~:/@#:@#@],~:/\,(p:>:)&#)0:)&<: 8
0
   m =: ([{+2&(~:/@#:@#@],~:/\,(p:>:)&#)0:)&<:
   1+i.16
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
   m/~ 1+i.16
0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0
1 0 1 1 0 0 0 1 0 0 0 1 1 0 1 1
1 1 0 1 1 1 1 0 0 0 0 1 0 0 1 0
0 1 1 0 1 0 1 1 1 1 1 0 0 0 1 1
1 0 1 1 0 0 1 0 1 0 1 1 1 1 0 1
0 0 1 0 0 0 1 1 0 0 1 0 1 0 0 1
1 1 0 0 0 0 1 0 0 0 1 1 0 0 0 1
0 1 1 1 1 1 0 0 0 0 1 0 0 0 0 1
0 1 0 1 0 1 1 1 1 1 0 0 0 0 0 1
0 1 1 0 0 1 0 1 0 1 1 1 1 1 1 0
1 0 1 1 1 0 0 1 1 0 1 0 1 0 1 1
0 0 1 0 1 1 1 0 1 1 0 0 1 1 0 1
1 1 0 0 1 0 1 1 0 1 1 1 0 1 1 0
0 1 1 1 0 0 1 0 0 1 0 1 1 0 1 1
0 1 0 1 1 1 0 0 0 1 1 0 1 1 0 1
0 1 1 0 1 0 0 0 0 1 0 0 1 0 0 1

เพื่อบันทึกการกดแป้นเราไม่พยายามบอกว่าเรายังต้องการบิตที่สำคัญกว่าหรือ Thue-Morse ดังนั้นเราจึงคำนวณทั้ง antidiagonal เพื่อรับบิตที่เราต้องการ อย่างไรก็ตาม8192 m 8192ยังคงทำงานในเวลาน้อยกว่า 0.07 วินาทีและประมาณ 100 KiB บนแล็ปท็อปขนาดเล็กของฉัน

Mathematica - ความแม่นยำ 100%, 223 193 189 ไบต์

f=(r=Array[0&,Max@##];For[s=2,s<=#+#2,++s,For[i=Max[1,s-#2],i<=Min[s-1,#],++i,j=s-i;r[[j]]=Which[i==1,PrimeQ@j,j==1,OddQ@Total@IntegerDigits[i-1,2],0<1,Xor@@r[[j-1;;j]]]]];If[r[[#2]],1,0])&

นี่คือรุ่นที่อ่านง่าย:

f[x_,y_] := (
   r = Array[0 &, Max[x,y]];
   For[s = 2, s <= x + y, ++s,
    For[
     i = Max[1, s - y],
     i <= Min[s - 1, x],
     ++i,

     j = s - i;
     r[[j]] = Which[
       i == 1,
       PrimeQ@j,
       j == 1,
       OddQ@Total@IntegerDigits[i - 1, 2],
       0 < 1,
       r[[j - 1]]~Xor~r[[j]]
       ]
     ]
    ];
   If[r[[y]], 1, 0]
   );

โดยทั่วไปฉันคำนวณล่วงหน้าตามแนวทแยงมุมของค่าคงที่ x+yตามเส้นทแยงมุมคง

คุณสมบัติ:

• มันถูกต้อง
• มันวิ่งเข้า O(x*y)มันทำงานใน
• f[8192,8192]ใช้เวลาประมาณ 400 วินาที ฉันคิดว่ามีห้องพักสำหรับการปรับปรุง (อาจจะRotateLeftจะแทนที่วงด้านใน)

• มันใช้เพียงหนึ่งอาร์เรย์ของmax(x,y)ผลลัพธ์ในหน่วยความจำกลางถึงสูงสุด ดังนั้นจึงไม่มีความจำเป็นต้องใช้เกิน 32k (สมมติว่าเป็นจำนวนเต็ม 32 บิต) สำหรับอัลกอริธึมเอง (บวกสิ่งที่ Mathematica ใช้) อันที่จริง Mathematica ใช้ 31M ด้วยตัวเองบนระบบของฉัน แต่สิ่งนี้ใช้ได้โดยไม่มีปัญหา:

  MemoryConstrained[f[8192, 8192], 2^21]
  

Matlab: ความแม่นยำ 100%, 120 ตัวอักษร, เวลาดำเนินการที่ไม่สมเหตุสมผล

function z=M(x,y)
if y==1 z=(x>1)*isprime(x);elseif x==1 z=mod(sum(dec2bin(y-1)-48),2);else z=xor(M(x,y-1),M(x-1,y));end

ใช้:

> M(4,4)
ans =
      0
> M(1, 9)
ans =
      1

Python 192 ตัวอักษร

ความแม่นยำ 100% คำนวณ M (8192,8192) ใน ~ 10 วินาทีบนเครื่องของฉัน

R=range
def M(X,Y):
 X+=1;c=[1]*X;r=[0]
 while len(r)<Y:r+=[i^1 for i in r]
 for i in R(2,X):
  if c[i]:
   for j in R(i+i,X,i):c[j]=0
  r[0]=c[i]
  for i in R(1,Y):r[i]^=r[i-1]
 return r[Y-1]

Haskell - 261 bytes - 100% - 1MB - ฉันไม่คิดว่ามันจะจบลงเร็ว ๆ นี้

ใช้เวลาประมาณ 10 วินาทีในการm 16 16ใช้-O2แต่ตามที่ฉันได้เขียนไว้แล้วฉันสามารถแสดงได้แม้จะมีปัญหานี้:

m x y=if n x y then 1 else 0 where n x 1=b x;n 1 y=(a!!13)!!(y-1);n x y=(n x (y-1))`f`(n(x-1)y)
f True False=True
f False True=True
f _ _=False
a=[False]:map step a where step a=a++map not a
b x=x`elem`takeWhile(<=x)e
e=c [2..]where c(p:s)=p:c[x|x<-s,x`mod`p>0]

Haskeller ที่ดีบางคนสามารถเพิ่มประสิทธิภาพได้หรือไม่

m' x y = if m x y then 1 else 0
    where
        m x 1 = isPrime x
        m 1 y = morse' y
        m x y = (m x (y-1)) `xor` (m (x-1) y)

xor True False = True
xor False True = True
xor _ _ = False

morse' x = (morse !! 13) !! (x-1)
morse = [False] : map step morse where step a = a ++ map not a

isPrime x = x `elem` takeWhile (<=x) primes
primes :: [Integer]
primes = sieve [2..] where sieve (p:xs) = p : sieve [x|x <- xs, x `mod` p > 0]

main = putStrLn $ show $ m' 16 16

Perl, 137

เพื่อไม่ให้ 'ชนะ' :-) แต่เนื่องจากยังไม่มี Perl ที่นี่และมีการเขียนรหัสอยู่แล้วนี่คือ

sub f{($n,$m)=@_;@a=0;@a=(@a,map{0+!$_}@a)while@a<$n;for$k(2..$m){$p=0;O:{$k%$_?1:last O for 2..sqrt$k;$p=1}$p=$a[$_]^=$p for 1..$n-1}$p}

ใช้เวลาหลายวินาทีถ้าเรียกว่า print f(8192,8192)เก็บเมทริกซ์บรรทัดเดียวในหน่วยความจำ (อาร์เรย์จำนวนเต็ม 8192 (สเกลาร์)) กระบวนการ Perl ทั้งหมดประมาณ 3.5 Mb ฉันพยายามทำด้วย string แทนที่จะเป็น array (ไม่ว่าจะเป็น regexps หรือการเข้าถึง substr) ใช้หน่วยความจำน้อยกว่าและสามารถเล่นกอล์ฟต่อไปได้ แต่ทำงานช้ากว่ามาก

เยื้อง:

sub f{
    ($n,$m)=@_;
    @a=0;                                  # @a will be current line.
    @a=(@a,map{0+!$_}@a)while@a<$n;        # Fill it with Thue-Morse sequence.
    for$k(2..$m){                          # Repeat until required line number.
        $p=0;                              # Find out if current line number 
        O:{                                # is a prime.
            $k%$_?1:last O for 2..sqrt$k;
            $p=1                           # Store result (0 or 1) in $p.
        }
        $p=$a[$_]^=$p for 1..$n-1          # XOR previous value in current position
    }                                      # with $p and store in $p.
    $p                                     # Return $p.
}

Haskell, 223

g n=div(filter(>=n)(iterate(*2)1)!!0)2
1%1=0>1
1%n=not$1%(n-g n)
n%1=and[rem n x>0|x<-[2..n-1]]
a%b=g[0<1]where g s|foldr seq(0>1)s=0<1|n==a+b=s!!(b-1)|0<1=g$n%1:zipWith x s(tail s)++[1%n]where n=length s+1
x p|p=not|0<1=id

นี้มีรันไทม์ที่รวดเร็ว (5.7 วินาทีด้วย-O3) ยังไม่ได้ตรวจสอบหน่วยความจำแม้ว่ามันควรจะเป็นเชิงเส้น

นี่ใช้อัลกอริธึมทแยงมุมที่เห็นมาก่อนหน้านี้

เท่าที่เกี่ยวข้องกับความเร็วสิ่งเดียวที่สำคัญคืออัลกอริธึมแนวทแยงมุม-O3และ|foldr seq(0>1)s=0<1การ์ดซึ่งทำให้รายการเข้มงวด ทุกอย่างถูกนำมาใช้ค่อนข้างไม่มีประสิทธิภาพ - การตรวจสอบยอดเยี่ยมทำได้โดยการตรวจสอบจำนวนที่น้อยกว่าสำหรับการหารองค์ประกอบของลำดับมอร์สจะคำนวณซ้ำอย่างต่อเนื่อง แต่ก็ยังเร็วพอ :-)