14

ধরুন আমরা একটি অসীম ম্যাট্রিক্স সংজ্ঞায়িত 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দশম পদ 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), যা হয় হয় 0বা হয় 1।

আপনার কোডটি যে কোনও ভাষায় লিখিত হতে পারে তবে সোর্স কোডের আকারের 64 কিলোবাইট (65,536 বাইট) বা মোট মেমরি ব্যবহারের 2 এমবি (2,097,152 বাইট) অতিক্রম করা উচিত নয়। আপনার প্রোগ্রামটি অবশ্যই খালি মেমরি দিয়ে শুরু করতে হবে (অর্থাত্ এটি অন্য কোথাও থেকে ডেটা লোড করতে পারে না) এবং প্রতিটি ইনপুটের জন্য স্বাধীনভাবে চালানো হয় (এটি একাধিক রানের জন্য সাধারণ ডেটা সংরক্ষণ নাও করতে পারে)। আপনার প্রোগ্রামটি অবশ্যই 8192x8192যুক্তিসঙ্গত সময়ে উপরের-বাম স্কোয়ারের সমস্ত এন্ট্রিগুলি মূল্যায়ন করতে সক্ষম হতে হবে ।

উপরের-বাম 8192 x 8192স্কোয়ারে সর্বাধিক এন্ট্রিগুলি সঠিকভাবে মূল্যায়ন করে এমন প্রোগ্রামটি বিজয়ী হবে, সংক্ষিপ্ত কোডটি টাই-ব্রেকার হিসাবে অভিনয় করবে।

code-challenge binary-matrix

— জো জেড
সূত্র

আমি সম্ভবত এক মুহুর্তে কিছুটা আরও মার্জিত কিছুতে টেস্টিং কেস আপডেট করতে যাচ্ছি, সুতরাং আমি আবার প্রশ্নটি সম্পাদনা না করা অবধি টেস্টিংয়ের সাথে থাকব।

— জো জে।

@ এমবুয়েটনার হ্যাঁ, এটি হয়।

— জো জে।

1

"নির্ভুলতা" এর জন্য আমাদের কীভাবে একটি নতুন ট্যাগ দরকার তা দেখতে আমি ব্যর্থ হয়েছি। এটি কেবল একটি [কোড-চ্যালেঞ্জ]। দয়া করে প্রথমে মেটাটির মাধ্যমে নতুন চ্যালেঞ্জ জেনার আইডিয়াগুলি চালান (আমরা [কোড-ট্রোলিং] থেকে একটি জিনিস শিখেছি)।

— ডোরকনবব

^ লক্ষণীয়। আমি সেই ট্যাগটি সরিয়ে ফেলব।

— জো জে।

1

@ ডক্টর এটি খুব সাধারণ বিষয় নয়। গৃহীত উত্তর সময়ের সাথে সাথে পরিবর্তন হয়।

— জো জে।

9

জে - 42 38 চর

খুব দ্রুত, 100% নির্ভুল এবং মেমরির সীমাবদ্ধতার মধ্যে রয়েছে।

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

কৌশলটি নিম্নরূপ: আমরা এই ম্যাট্রিক্সের ক্রমাগত অ্যান্টিডিজোনালগুলি গণনা করব, পাশাপাশি চলতে একজোড়া XOR সম্পাদন করব এবং বর্তমান থু-মর্স এবং প্রাইম বিটগুলি শেষ প্রান্তে যুক্ত করব। তারপরে আমরা সেখানে পৌঁছলে প্রয়োজনীয় অ্যান্টিডিজোনাল থেকে বের করে আনি digit

বিস্ফোরণ দ্বারা ব্যাখ্যা:

(                                 )&<:  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ক্রিয়াটি কোথায় ।

   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

কী-স্ট্রোকগুলি সংরক্ষণ করতে আমরা আমাদের আরও প্রাইম বা থু-মর্স বিটের প্রয়োজন কিনা তা জানার চেষ্টা করি না, তাই আমরা যে বিটটি চেয়েছি তা পেতে সম্পূর্ণ অ্যান্টিডিজোনালটি গণনা করি। যাইহোক, 8192 m 8192এখনও আমার পরিমিত ল্যাপটপে 0.07 s এর কম এবং প্রায় 100 কিবিতে চলে।

— algorithmshark
সূত্র

6

গণিত - 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)মেমরির মধ্যবর্তী ফলাফল পর্যন্ত একটি অ্যারে ব্যবহার করে । সুতরাং নিজেই অ্যালগরিদমের জন্য প্রায় 32 কে (32-বিট ইন্টিজার ধরে ধরে) বেশি ব্যবহার করার প্রয়োজন নেই (ম্যাথমেটিকা যা ব্যবহার করে)। প্রকৃতপক্ষে, গাণিতিক আমার সিস্টেমে 31M নিজে থেকে ব্যবহার করে তবে এটি কোনও সমস্যা ছাড়াই কাজ করে:
```
MemoryConstrained[f[8192, 8192], 2^21]
```

— মার্টিন ইন্ডার
সূত্র

ভাল, দেখে মনে হচ্ছে আপনি এটি পেয়েছেন। ভবিষ্যতে আমি আরও কঠিন করে তুলছি, যদিও: পি

— জো জেড

এইচ এম, পরিবর্তনের একটিতে আমি অবশ্যই রানটাইম পারফরম্যান্সকে ঘষামাজা করেছিলাম। অভ্যন্তরীণ লুপটিকে এখনও O(x*y)বার বলা হয়, তবে মোট মৃত্যুর সময় তার চেয়ে দ্রুত বৃদ্ধি পায়। আমি নিশ্চিত যে কি ঘটছে। যদি কোনও গণিত গুরু আমাকে আলোকিত করতে পারে তবে লুপের কোন ক্রিয়াকলাপটি O(1)খুব সহায়ক হবে না! :) (ভাল, PrimeQএবং Total@IntegerDigitsনা, তবে আমি তাদের প্রথম থেকেই সেখানে পেয়েছি এবং তারা কেবল যথাক্রমে ডেকেছিল O(y)এবং O(x)যথাক্রমে বার সময় ধরেছিল)

— মার্টিন এন্ডার

3

মতলব: 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

— intx13
সূত্র

1

এখন এখানে প্রশ্ন, আপনি কি আসলে এই প্রোগ্রামটি চালাতে এবং এটি পরীক্ষা করতে পারেন?

— জো জে।

আপনি যদি দৌড়াতে না পারেন M(8192, 8192), আমি এটি নিতে পারি না।

— জো জে।

@ জোজেড এটি এম-কোড, আপনি এটি মাতলাব বা অক্টেভে চালাতে পারেন।

— intx13

@ জোজেড এটি এম (8192, 8192) কে সঠিকভাবে গণনা করবে। চ্যালেঞ্জটি শেষ হওয়ার সময় সম্পর্কে কিছুই বলেনি;)

— ইন্টেক্স 13

1

@ জোজেড দেখে মনে হচ্ছে এম (২০,২০) আমি অপেক্ষা করতে ইচ্ছুক তার চেয়ে বেশি সময় নেয়। তবে আরে এটা "নির্ভুল"! : পি

— intx13

2

পাইথন, 192 টি অক্ষর

100% নির্ভুলতা, আমার মেশিনে 10 সেকেন্ডের মধ্যে এম (8192,8192) গণনা করে।

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]

— আলেক্সি তোড়হামো
সূত্র

0

হাস্কেল - 261 বাইট - 100% - 1 এমবি - আমি মনে করি না এটি শীঘ্রই যে কোনও সময় শেষ হতে চলেছে

জন্য 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]

হয়তো কিছু ভাল হাস্কেলর এটিকে অনুকূল করতে সক্ষম?

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

— TimWolla
সূত্র

আমি মনে করি অ্যালগরিদম নিজেই ত্রুটিযুক্ত। যাইহোক, এই গল্ফ করতে আপনি করতে পারেন অনেক কিছু আছে। বেশিরভাগ অতিরিক্ত বন্ধনী, তবে আরও f p|p=not|0<1=idভাল হওয়া উচিত। এছাড়াও, morse = False : concat $ iterate [True] (\a -> a ++ map not a)বর্ধিত অলসতার জন্য ব্যবহার করার চেষ্টা করুন । আমি আশ্চর্য হই যে এটি কীভাবে কার্য সম্পাদনকে প্রভাবিত করবে।

— গর্বিত হাসেল্লার

এছাড়াও, আপনি গলফ পারেন Trueকরতে 0<1এবং Falseকরতে 0>1।

— গর্বিত হাসেল্লার

0

পার্ল, 137

'জয়' করার জন্য নয় :-), তবে যেহেতু এখানে এখনও পার্ল নেই এবং কোড যেভাবেই লেখা হয়েছিল, এখানে এটি here

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 পূর্ণসংখ্যার অ্যারে (স্কেলার)), প্রায় 3.5 এমবি পুরো পার্ল প্রক্রিয়া। আমি অ্যারের পরিবর্তে স্ট্রিং দিয়ে এটি করার চেষ্টা করেছি (হয় রেগেক্সপস সহ বা সাবস্ট্রারের সাহায্যে অ্যাক্সেস করা), কম স্মৃতি লাগে এবং আরও গল্ফ করা যায় তবে অনেক ধীর গতিতে চলে।

ইন্ডেন্টযুক্ত:

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.
}

— user2846289
সূত্র

0

হাস্কেল, 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প্রহরী, যা তালিকাটিকে কঠোর করে তোলে। সমস্ত কিছুই বরং অকার্যকরভাবে প্রয়োগ করা হয় - বিভাগের জন্য সমস্ত কম সংখ্যার পরীক্ষা করে প্রাইম চেকিং করা হয়, মোর্স সিকোয়েন্সের উপাদানগুলি ক্রমাগত সংশোধন করা হয়। তবে এটি এখনও যথেষ্ট দ্রুত :-)।

— গর্বিত হাসেলেলার
সূত্র

এই উত্পন্ন বাইনারি ম্যাট্রিক্সে একটি নির্দিষ্ট মান মুদ্রণ করুন

জে - 42 38 চর

গণিত - 100% নির্ভুলতা, 223 193 189 বাইট

মতলব: 100% নির্ভুলতা, 120 টি অক্ষর, অযৌক্তিক প্রয়োগের সময়

পাইথন, 192 টি অক্ষর

হাস্কেল - 261 বাইট - 100% - 1 এমবি - আমি মনে করি না এটি শীঘ্রই যে কোনও সময় শেষ হতে চলেছে

পার্ল, 137

হাস্কেল, 223