सुरक्षित दरार!

Question

Https://puzzling.stackexchange.com/questions/24334/to-catch-a-thief से प्रेरित

आपको s और s (या आपकी पसंद का कोई अन्य वर्ण ) से भरा एक nबाय n( nस्वयं वैकल्पिक इनपुट है) ग्रिड दिया जाता है । आप AIM हर कोशिका बनाने के लिए है एक ही (या तो या )। आप नीचे बताए अनुसार चाल की एक श्रृंखला बना सकते हैं (पज़्लिंग एसई लिंक के साथ नोट असमानता):0101

• एक सेल का चयन करें।
• एक ही पंक्ति और स्तंभ में प्रत्येक कोशिका (सेल को छोड़कर) इसके विपरीत में बदल जाती है। 0करने के लिए 1और 1करने के लिए 0।

कार्य को पूरा करने के लिए आवश्यक न्यूनतम चालों का आउटपुट। यदि असाध्य है, तो एक गैर-नकारात्मक पूर्णांक को छोड़कर कुछ भी आउटपुट। सबसे छोटा कोड जीतता है।

नमूना डेटा

1 0 0
0 0 0
0 0 0

-1

1 1 1
1 1 1
1 1 1

0

1 0 1
0 1 0
1 0 1

1

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

2

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

2

Comments

क्या करना है यदि पहेली असंगत है? जैसे 1000(एक वर्ग के रूप में पुन: व्यवस्थित किया जाता है, कोई फर्क नहीं पड़ता कि कैसे)।

— orlp

सम्बंधित।

— मार्टिन एंडर

@orlp कोई भी आउटपुट जो एक नंबर नहीं है वह करेगा।

— भूत_न_थे_कोड

क्या हमें इनपुट को पार्स करने की आवश्यकता है या क्या यह पहले से भरे हुए सरणी डेटाटाइप हो सकता है?

— coredump

पहले परीक्षण मामले का हल क्या है? मुझे इसका कोई समाधान नहीं मिल रहा है।

— कार्डबोर्ड_बॉक्स

Answer 1

मतलाब 171 बाइट्स

इनपुट 2d मैट्रिक्स होना चाहिए, इसलिए आप इसे कॉल करेंगे c([1,1,1,1;0,0,0,0;0,0,0,0;1,1,1,1])(अर्धविराम एक नई पंक्ति शुरू करें)। यह फ़ंक्शन केवल सभी संभावित चालों को सीमित करता है, इसलिए हमें एक रनटाइम मिलता है O(2^(n^2))।

कैसे किया जाता है

यह उसी आकार के एक और मैट्रिक्स को भरने के लिए सभी संभावित तरीकों को चुनकर किया जाता है और शून्य के साथ, यह मूल रूप से बाइनरी विच में गिना जाता है जहां मैट्रिक्स का प्रत्येक प्रवेश 2 की एक निश्चित शक्ति का प्रतिनिधित्व करता है।

फिर हम उन कोशिकाओं पर चाल करते हैं जो 1 हैं, यह आकार 1xn और nx1 वाले लोगों के वेक्टर के साथ दो दो आयामी कनवल्शन के योग (मॉड 2) द्वारा किया जाता है।

अंत में हम तय करते हैं कि क्या उन चालों ने सभी प्रविष्टियों पर मानक विचलन की गणना करके वास्तव में वांछित परिणाम का उत्पादन किया है। यदि सभी प्रविष्टियाँ समान हैं, तो मानक विचलन केवल शून्य है। और जब भी हमें वास्तव में वांछित परिणाम मिला, हम इसकी तुलना पिछले समाधानों की संख्या से करते हैं। infदी गई समस्या हल नहीं होने पर फ़ंक्शन वापस आ जाएगा ।

गणित?

यह वास्तव में ध्यान देने योग्य है कि वे सभी चालें एक एबेलियन समूह उत्पन्न करती हैं! अगर कोई वास्तव में उन समूहों को रद्द करने का प्रबंधन करता है तो कृपया मुझे बताएं।

गोल्फ संस्करण:

function M=c(a);n=numel(a);p=a;M=inf;o=ones(1,n);for k=0:2^n-1;p(:)=dec2bin(k,n)-'0';b=mod(conv2(p,o,'s')+conv2(p,o','s'),2);m=sum(p(:));if ~std(b(:)-a(:))&m<M;M=m;end;end

पूर्ण संस्करण (वास्तविक चाल के उत्पादन के साथ।)

function M = c(a)
n=numel(a);
p=a;
M=inf;                                               %current minimum of number of moves
o=ones(1,n);
for k=0:2^n-1;
    p(:) = dec2bin(k,n)-'0';                         %logical array with 1 where we perform moves
    b=mod(conv2(p,o,'same')+conv2(p,o','same'),2);   %perform the actual moves
    m=sum(p(:));                                     %number of moves;
    if ~std(b(:)-a(:))&m<M                           %check if the result of the moves is valid, and better
        M=m;
        disp('found new minimum:')
        disp(M)                                      %display number of moves of the new best solution (not in the golfed version)
        disp(p)                                      %display the moves of the new best solution                               (not in the golfed version)
    end
end

Answer 2

पर्ल 5, 498 बाइट्स

यह 'एन' और वांछित परिणाम को स्वीकार करता है, और यदि कोई नहीं है, तो गिनती, या 'एक्स' को आउटपुट करता है।

उदाहरण के लिए:

perl ./crack.golf.pl 3 000111111

देता है 2। यह केवल तभी काम करेगा जब n ^ 2 <= 64, इसलिए n <= 8। हालाँकि यह n से भी कम के साथ बहुत धीमा है। यह एक ^ 3 बिट एरे बनाता है, और पहले से 2 ^ (n ^ 2) एरे को सॉर्ट करता है, क्योंकि क्यों नहीं ?

मैंने पठनीयता के लिए यहां दो-दो लाइनफीड्स बर्बाद किए हैं :

$n=shift;$y=shift;$p=$n*$n;@m=(0..$n-1);@q=(0..$p-1);@v=(0..2**$p-1);@d=map{0}(@q);@b=map{$r=$_;map{$c=$_;$d[$r*$n+$_]^=1 for(@m);$d[$_*$n+$c]^=1 for(@m);$j=0;$k=1;
map{$j|=$k*$d[$_];$k<<=1;}@q;@d=map{0}(@q);$j;}@m}@m;for$k(sort{$a->[0]<=>$b->[0]}map{$z=0;map{$z+=$_}split(//,sprintf"%b",$_);[$z,$_]}@v){$l=sprintf"%0${p}b",$k->[1];
@m=map{$_}split(//,$l);$s=0;for(@q){$s^=$b[$_]if$m[$_];}$z=0;map{$z+=$_}split(//,sprintf"%b",$_);if($y eq sprintf"%0${p}b",$s){print"$k->[0]\n";exit 0;}}print"X\n";