इस उत्पन्न बाइनरी मैट्रिक्स में एक विशिष्ट मूल्य प्रिंट करें

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।

आपका कोड किसी भी भाषा में लिखा जा सकता है, लेकिन कुल मेमोरी उपयोग के स्रोत कोड आकार के 2 किलोबाइट (65,536 बाइट्स) या 2 एमबी (2,097,152 बाइट्स) से अधिक नहीं होना चाहिए। आपका प्रोग्राम खाली मेमोरी के साथ शुरू होना चाहिए (अर्थात यह कहीं और से डेटा लोड नहीं कर सकता है) और प्रत्येक इनपुट के लिए स्वतंत्र रूप से चलाएं (अर्थात, यह कई रनों के लिए सामान्य डेटा संग्रहीत नहीं कर सकता है)। आपका कार्यक्रम 8192x8192उचित समय में शीर्ष-बाएँ वर्ग में सभी प्रविष्टियों का मूल्यांकन करने में सक्षम होना चाहिए ।

प्रोग्राम जो शीर्ष-बाएँ 8192 x 8192वर्ग में सही ढंग से सबसे प्रविष्टियों का मूल्यांकन करता है , वह विजेता होगा, जिसमें टाई-ब्रेकर के रूप में कम कोड अभिनय होगा।

code-challenge  binary-matrix 
— जो जेड।
स्रोत
मैं शायद परीक्षण के मामले को कुछ पल के लिए और अधिक सुरुचिपूर्ण ढंग से अपडेट करने जा रहा हूं, इसलिए परीक्षण को तब तक लटकाए रखता हूं जब तक कि मैं प्रश्न को फिर से संपादित नहीं करता।
— जो जेड।
@mbuettner हाँ, यह करता है।
— जो जेड।
1
मैं यह देखने में विफल हूं कि "सटीकता" के लिए हमें एक नए टैग की आवश्यकता कैसे है। यह केवल एक [कोड-चुनौती] है। कृपया पहले मेटा के माध्यम से नई चुनौती शैली के विचारों को चलाएं ([कोड-ट्रोलिंग] से सीखी गई एक बात)।
— दरवाज़े
^ नोट किया गया। मैं उस टैग को हटा दूंगा।
— जो जेड।
1
@ TheDoctor यह बहुत असामान्य नहीं है। समय के साथ स्वीकृत उत्तर बदलता है।
— जो जेड।

जवाबों:

9

जे - ४२ ३ char चार

बहुत तेज, 100% सटीक और अच्छी तरह से स्मृति बाधाओं के भीतर।

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

रणनीति इस प्रकार है: हम इस मैट्रिक्स के क्रमिक एंटीडिओग्नल की गणना करेंगे, साथ में ले जाने के लिए एक जोड़ी XOR और वर्तमान थ्यू-मोर्स और प्राइम बिट्स जोड़कर प्रदर्शन करेंगे। जब हम वहां पहुंचते हैं, तब हम आवश्यक अंक को एंटीडिओगल से बाहर निकाल देते हैं।

विस्फोट से स्पष्टीकरण:

(                                 )&<:  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 yM (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

कीस्ट्रोक्स को बचाने के लिए हम यह बताने की कोशिश नहीं करते हैं कि क्या हमें अभी भी अधिक प्राइम या थ्यू-मोर्स बिट्स की आवश्यकता है, इसलिए हम उस बिट को प्राप्त करने के लिए पूरे एंटीडायंगल की गणना करते हैं। हालाँकि, 8192 m 8192अभी भी मेरे मामूली लैपटॉप पर 0.07 s और लगभग 100 KiB से कम में चलता है।

— 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)स्मृति में मध्यवर्ती परिणामों के लिए एक सरणी का उपयोग करता है । इसलिए एल्गोरिथ्म के लिए लगभग 32k (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) की सही गणना करेगा। चुनौती ने समय पूरा होने के बारे में कुछ नहीं कहा;)
— intx13
1
@ जो अच्छी तरह से ऐसा लगता है कि एम (20,20) प्रतीक्षा करने के लिए तैयार होने में अधिक समय लेता है। लेकिन हे, यह "सटीक" है! : P
— 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 एमबी - मुझे नहीं लगता कि यह जल्द ही कभी भी समाप्त होने वाला है

के m 16 16साथ के बारे में 10 सेकंड लेता है -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<1False0>1
— गर्वित हैकेलर
0

पर्ल, 137

नहीं 'जीत' :-), लेकिन चूंकि अभी तक यहाँ कोई पर्ल नहीं है और कोड वैसे भी लिखा गया था, यहाँ यह है।

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गार्ड, जो सूची को सख्त बनाता है। सब कुछ अक्षम रूप से कार्यान्वित किया जाता है - विभाजन के लिए सभी कम संख्याओं की जांच करके प्राइम चेकिंग की जाती है, मोर्स अनुक्रम के तत्वों को लगातार पुन: प्रतिष्ठित किया जाता है। लेकिन यह अभी भी काफी तेज है :-)।

— गर्वित हेकलर
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.