सभी 3 को 3 मजबूत वर्गों में प्रिंट करें

Question

एक मजबूत वर्ग (एक जादू वर्ग के समान ) एन ग्रिड द्वारा एन पर एन पर 1 से एन ² के पूर्णांक की व्यवस्था है जैसे कि प्रत्येक 2 बाय 2 सबग्रिड में एक ही राशि होती है।

उदाहरण के लिए, एन = 3 के लिए एक मजबूत वर्ग है

1 5 3
9 8 7
4 2 6

क्योंकि चार 2 बाय 2 सबग्रिड

1 5
9 8

5 3
8 7

9 8
4 2

8 7
2 6

सभी को समान राशि, 23:

23 = 1 + 5 + 9 + 8 = 5 + 3 + 8 + 7 = 9 + 8 + 4 + 2 = 8 + 7 + 2 + 6

अब एन के उच्च मूल्यों और यहां तक ​​कि आयताकार संस्करणों के लिए मजबूत वर्ग हैं, लेकिन इस चुनौती में आपका एकमात्र कार्य सभी 3 से 3 मजबूत वर्गों का उत्पादन करना है। 3 मजबूत वर्गों द्वारा वास्तव में 376 अलग-अलग 3 हैं, जिनमें वे भी शामिल हैं जो दूसरों के प्रतिबिंब या घुमाव हैं, और उन सभी में 23 की समान राशि नहीं है।

एक प्रोग्राम या फ़ंक्शन लिखें जो कोई इनपुट नहीं लेता है लेकिन प्रिंट या किसी भी क्रम में सभी 376 मजबूत वर्गों की एक स्ट्रिंग लौटाता है, दो वैकल्पिक अनुगामी न्यूलाइन्स के साथ, खाली लाइनों द्वारा अलग किया जाता है। प्रत्येक वर्ग में तीन अलग-अलग तीन रेखाएं होती हैं, जो गैर-अंकीय दशमलव अंकों से अलग होती हैं।

यहाँ एक मान्य आउटपुट उदाहरण है:

1 5 3
9 8 7
4 2 6

1 5 6
8 7 3
4 2 9

1 5 6
8 9 3
2 4 7

1 5 7
9 6 3
2 4 8

1 6 2
8 9 7
4 3 5

1 6 2
9 7 8
4 3 5

1 6 3
9 8 7
2 5 4

1 6 7
8 5 2
3 4 9

1 6 7
9 4 3
2 5 8

1 7 2
9 4 8
5 3 6

1 7 2
9 6 8
3 5 4

1 7 4
8 3 5
6 2 9

1 7 4
9 2 6
5 3 8

1 7 6
9 2 4
3 5 8

1 8 2
5 9 4
6 3 7

1 8 3
6 5 4
7 2 9

1 8 3
9 2 7
4 5 6

1 8 4
5 7 2
6 3 9

1 8 4
6 9 3
2 7 5

1 8 4
9 3 6
2 7 5

1 8 6
7 3 2
4 5 9

1 9 2
5 6 4
7 3 8

1 9 2
6 4 5
7 3 8

1 9 2
6 8 5
3 7 4

1 9 2
8 3 7
4 6 5

1 9 3
7 2 5
6 4 8

1 9 3
7 6 5
2 8 4

1 9 4
5 8 2
3 7 6

1 9 4
6 7 3
2 8 5

1 9 4
8 2 5
3 7 6

1 9 5
7 2 3
4 6 8

1 9 5
7 4 3
2 8 6

2 3 5
9 8 6
4 1 7

2 3 6
9 7 5
4 1 8

2 4 3
8 9 7
5 1 6

2 4 3
9 7 8
5 1 6

2 4 6
7 8 3
5 1 9

2 4 7
8 9 3
1 5 6

2 4 8
9 6 3
1 5 7

2 5 3
9 4 8
6 1 7

2 5 4
9 3 7
6 1 8

2 5 4
9 8 7
1 6 3

2 5 7
6 8 1
4 3 9

2 5 7
6 9 1
3 4 8

2 5 8
7 6 1
3 4 9

2 5 8
9 4 3
1 6 7

2 6 1
7 9 8
5 3 4

2 6 1
8 7 9
5 3 4

2 6 3
5 9 4
7 1 8

2 6 4
5 8 3
7 1 9

2 6 7
9 1 4
3 5 8

2 6 8
7 4 1
3 5 9

2 7 1
8 4 9
6 3 5

2 7 1
8 6 9
4 5 3

2 7 3
5 6 4
8 1 9

2 7 3
6 4 5
8 1 9

2 7 3
9 1 8
5 4 6

2 7 5
4 8 1
6 3 9

2 7 5
6 9 3
1 8 4

2 7 5
9 3 6
1 8 4

2 8 1
4 9 5
7 3 6

2 8 4
7 6 5
1 9 3

2 8 5
4 9 1
3 7 6

2 8 5
6 7 3
1 9 4

2 8 6
7 4 3
1 9 5

2 9 1
4 6 5
8 3 7

2 9 1
5 4 6
8 3 7

2 9 1
5 8 6
4 7 3

2 9 1
7 3 8
5 6 4

2 9 3
6 1 5
7 4 8

2 9 4
3 7 1
6 5 8

2 9 4
3 8 1
5 6 7

2 9 5
4 7 1
3 8 6

2 9 5
7 1 4
3 8 6

2 9 6
5 3 1
4 7 8

2 9 6
5 4 1
3 8 7

3 2 5
9 8 7
4 1 6

3 2 6
8 9 5
4 1 7

3 2 7
9 6 5
4 1 8

3 4 2
7 9 8
6 1 5

3 4 2
8 7 9
6 1 5

3 4 5
9 2 7
6 1 8

3 4 8
6 9 1
2 5 7

3 4 9
7 6 1
2 5 8

3 4 9
8 5 2
1 6 7

3 5 1
7 8 9
6 2 4

3 5 2
8 4 9
7 1 6

3 5 4
9 1 8
6 2 7

3 5 4
9 6 8
1 7 2

3 5 8
9 1 4
2 6 7

3 5 8
9 2 4
1 7 6

3 5 9
7 4 1
2 6 8

3 6 1
7 8 9
4 5 2

3 6 2
4 9 5
8 1 7

3 6 8
7 1 2
4 5 9

3 7 2
4 6 5
9 1 8

3 7 2
5 4 6
9 1 8

3 7 2
8 1 9
6 4 5

3 7 4
6 1 5
8 2 9

3 7 4
6 8 5
1 9 2

3 7 6
4 9 1
2 8 5

3 7 6
5 8 2
1 9 4

3 7 6
8 2 5
1 9 4

3 8 1
4 5 6
9 2 7

3 8 1
7 2 9
6 5 4

3 8 4
2 9 1
6 5 7

3 8 6
4 7 1
2 9 5

3 8 6
7 1 4
2 9 5

3 8 7
5 4 1
2 9 6

3 9 1
5 2 7
8 4 6

3 9 1
5 6 7
4 8 2

3 9 2
5 1 6
8 4 7

3 9 4
2 6 1
7 5 8

3 9 4
2 8 1
5 7 6

3 9 6
4 2 1
5 7 8

3 9 6
5 1 2
4 8 7

4 1 6
9 8 7
3 2 5

4 1 7
8 9 5
3 2 6

4 1 7
9 8 6
2 3 5

4 1 8
9 6 5
3 2 7

4 1 8
9 7 5
2 3 6

4 2 6
9 8 7
1 5 3

4 2 7
6 9 3
5 1 8

4 2 7
9 3 6
5 1 8

4 2 8
7 6 3
5 1 9

4 2 9
8 7 3
1 5 6

4 3 5
8 9 7
1 6 2

4 3 5
9 2 8
6 1 7

4 3 5
9 7 8
1 6 2

4 3 7
5 8 2
6 1 9

4 3 7
8 2 5
6 1 9

4 3 7
9 1 6
5 2 8

4 3 9
6 8 1
2 5 7

4 5 2
7 3 9
8 1 6

4 5 2
7 8 9
3 6 1

4 5 3
8 1 9
7 2 6

4 5 3
8 6 9
2 7 1

4 5 6
3 8 1
7 2 9

4 5 6
9 2 7
1 8 3

4 5 9
7 1 2
3 6 8

4 5 9
7 3 2
1 8 6

4 6 2
3 8 5
9 1 7

4 6 5
2 9 1
7 3 8

4 6 5
8 3 7
1 9 2

4 6 8
7 2 3
1 9 5

4 7 1
5 3 8
9 2 6

4 7 1
6 2 9
8 3 5

4 7 3
5 1 6
9 2 8

4 7 3
5 8 6
2 9 1

4 7 5
2 6 1
8 3 9

4 7 8
5 3 1
2 9 6

4 8 1
2 7 5
9 3 6

4 8 1
3 9 6
5 7 2

4 8 1
6 3 9
5 7 2

4 8 2
5 6 7
3 9 1

4 8 3
1 9 2
7 5 6

4 8 6
3 2 1
7 5 9

4 8 7
5 1 2
3 9 6

4 9 1
2 8 5
6 7 3

4 9 1
3 7 6
5 8 2

4 9 1
5 2 8
6 7 3

4 9 2
1 7 3
8 5 6

4 9 2
1 8 3
7 6 5

4 9 3
1 6 2
8 5 7

4 9 3
1 8 2
6 7 5

4 9 5
2 3 1
7 6 8

4 9 5
3 1 2
7 6 8

4 9 6
3 2 1
5 8 7

5 1 6
8 9 7
2 4 3

5 1 6
9 7 8
2 4 3

5 1 8
6 9 3
4 2 7

5 1 8
9 3 6
4 2 7

5 1 9
7 6 3
4 2 8

5 1 9
7 8 3
2 4 6

5 2 3
7 8 9
6 1 4

5 2 8
7 3 4
6 1 9

5 2 8
9 1 6
4 3 7

5 3 2
6 8 9
7 1 4

5 3 4
7 9 8
2 6 1

5 3 4
8 2 9
7 1 6

5 3 4
8 7 9
2 6 1

5 3 6
9 4 8
1 7 2

5 3 8
4 7 1
6 2 9

5 3 8
7 1 4
6 2 9

5 3 8
9 2 6
1 7 4

5 4 3
7 2 9
8 1 6

5 4 6
3 7 2
8 1 9

5 4 6
9 1 8
2 7 3

5 6 4
1 9 2
8 3 7

5 6 4
7 3 8
2 9 1

5 6 7
3 8 1
2 9 4

5 7 2
1 8 4
9 3 6

5 7 2
3 9 6
4 8 1

5 7 2
6 3 9
4 8 1

5 7 4
1 6 2
9 3 8

5 7 6
2 3 1
8 4 9

5 7 6
2 8 1
3 9 4

5 7 6
3 1 2
8 4 9

5 7 8
4 2 1
3 9 6

5 8 2
1 9 4
6 7 3

5 8 2
3 7 6
4 9 1

5 8 7
3 2 1
4 9 6

5 9 1
3 2 7
8 6 4

5 9 1
3 4 7
6 8 2

5 9 2
1 7 4
6 8 3

5 9 2
4 1 7
6 8 3

5 9 4
1 3 2
8 6 7

5 9 4
2 1 3
8 6 7

6 1 4
7 8 9
5 2 3

6 1 5
7 9 8
3 4 2

6 1 5
8 7 9
3 4 2

6 1 7
9 2 8
4 3 5

6 1 7
9 4 8
2 5 3

6 1 8
9 2 7
3 4 5

6 1 8
9 3 7
2 5 4

6 1 9
5 8 2
4 3 7

6 1 9
7 3 4
5 2 8

6 1 9
8 2 5
4 3 7

6 2 3
5 9 8
7 1 4

6 2 4
7 8 9
3 5 1

6 2 7
9 1 8
3 5 4

6 2 8
5 4 3
7 1 9

6 2 9
4 7 1
5 3 8

6 2 9
7 1 4
5 3 8

6 2 9
8 3 5
1 7 4

6 3 2
5 7 9
8 1 4

6 3 5
8 4 9
2 7 1

6 3 7
5 2 4
8 1 9

6 3 7
5 9 4
1 8 2

6 3 9
4 8 1
2 7 5

6 3 9
5 7 2
1 8 4

6 4 2
3 8 7
9 1 5

6 4 5
2 7 3
9 1 8

6 4 5
8 1 9
3 7 2

6 4 8
7 2 5
1 9 3

6 5 1
3 7 8
9 2 4

6 5 1
3 9 8
7 4 2

6 5 4
1 8 3
9 2 7

6 5 4
7 2 9
3 8 1

6 5 7
2 4 1
8 3 9

6 5 7
2 9 1
3 8 4

6 5 8
3 2 1
7 4 9

6 5 8
3 7 1
2 9 4

6 7 1
4 2 9
8 5 3

6 7 3
1 9 4
5 8 2

6 7 3
2 8 5
4 9 1

6 7 3
5 2 8
4 9 1

6 7 5
1 3 2
9 4 8

6 7 5
1 8 2
4 9 3

6 7 5
2 1 3
9 4 8

6 8 1
2 3 7
9 5 4

6 8 2
3 4 7
5 9 1

6 8 3
1 7 4
5 9 2

6 8 3
4 1 7
5 9 2

6 8 4
1 2 3
9 5 7

6 9 2
1 3 5
8 7 4

6 9 2
1 4 5
7 8 3

6 9 3
1 2 4
8 7 5

6 9 3
2 1 5
7 8 4

6 9 4
1 2 3
7 8 5

7 1 4
5 9 8
6 2 3

7 1 4
6 8 9
5 3 2

7 1 6
8 2 9
5 3 4

7 1 6
8 4 9
3 5 2

7 1 8
5 9 4
2 6 3

7 1 9
5 4 3
6 2 8

7 1 9
5 8 3
2 6 4

7 2 3
5 6 9
8 1 4

7 2 4
3 9 6
8 1 5

7 2 4
6 3 9
8 1 5

7 2 6
8 1 9
4 5 3

7 2 9
3 8 1
4 5 6

7 2 9
6 5 4
1 8 3

7 3 4
2 8 5
9 1 6

7 3 4
5 2 8
9 1 6

7 3 4
6 1 9
8 2 5

7 3 6
4 2 5
9 1 8

7 3 6
4 9 5
2 8 1

7 3 8
2 9 1
4 6 5

7 3 8
5 6 4
1 9 2

7 3 8
6 4 5
1 9 2

7 4 2
3 9 8
6 5 1

7 4 8
6 1 5
2 9 3

7 4 9
3 2 1
6 5 8

7 5 1
3 6 9
8 4 2

7 5 2
1 8 6
9 3 4

7 5 2
1 9 6
8 4 3

7 5 6
1 4 2
9 3 8

7 5 6
1 9 2
4 8 3

7 5 8
2 6 1
3 9 4

7 5 9
3 2 1
4 8 6

7 6 1
2 5 8
9 4 3

7 6 1
3 4 9
8 5 2

7 6 2
4 1 9
8 5 3

7 6 5
1 8 3
4 9 2

7 6 8
2 3 1
4 9 5

7 6 8
3 1 2
4 9 5

7 8 3
1 4 5
6 9 2

7 8 4
2 1 5
6 9 3

7 8 5
1 2 3
6 9 4

8 1 4
5 6 9
7 2 3

8 1 4
5 7 9
6 3 2

8 1 5
3 9 6
7 2 4

8 1 5
6 3 9
7 2 4

8 1 6
7 2 9
5 4 3

8 1 6
7 3 9
4 5 2

8 1 7
4 9 5
3 6 2

8 1 9
3 7 2
5 4 6

8 1 9
5 2 4
6 3 7

8 1 9
5 6 4
2 7 3

8 1 9
6 4 5
2 7 3

8 2 4
3 6 7
9 1 5

8 2 5
4 3 7
9 1 6

8 2 5
6 1 9
7 3 4

8 2 6
3 4 5
9 1 7

8 2 9
6 1 5
3 7 4

8 3 5
1 7 4
9 2 6

8 3 5
4 1 7
9 2 6

8 3 5
6 2 9
4 7 1

8 3 7
1 9 2
5 6 4

8 3 7
4 6 5
2 9 1

8 3 7
5 4 6
2 9 1

8 3 9
2 4 1
6 5 7

8 3 9
2 6 1
4 7 5

8 4 2
3 6 9
7 5 1

8 4 3
1 9 6
7 5 2

8 4 6
5 2 7
3 9 1

8 4 7
5 1 6
3 9 2

8 4 9
2 3 1
5 7 6

8 4 9
3 1 2
5 7 6

8 5 2
1 6 7
9 4 3

8 5 2
3 4 9
7 6 1

8 5 3
4 1 9
7 6 2

8 5 3
4 2 9
6 7 1

8 5 6
1 2 3
9 4 7

8 5 6
1 7 3
4 9 2

8 5 7
1 6 2
4 9 3

8 6 2
1 4 7
9 5 3

8 6 3
2 1 7
9 5 4

8 6 4
3 2 7
5 9 1

8 6 7
1 3 2
5 9 4

8 6 7
2 1 3
5 9 4

8 7 4
1 3 5
6 9 2

8 7 5
1 2 4
6 9 3

9 1 5
3 6 7
8 2 4

9 1 5
3 8 7
6 4 2

9 1 6
2 8 5
7 3 4

9 1 6
4 3 7
8 2 5

9 1 6
5 2 8
7 3 4

9 1 7
3 4 5
8 2 6

9 1 7
3 8 5
4 6 2

9 1 8
2 7 3
6 4 5

9 1 8
4 2 5
7 3 6

9 1 8
4 6 5
3 7 2

9 1 8
5 4 6
3 7 2

9 2 4
3 7 8
6 5 1

9 2 6
1 7 4
8 3 5

9 2 6
4 1 7
8 3 5

9 2 6
5 3 8
4 7 1

9 2 7
1 8 3
6 5 4

9 2 7
4 5 6
3 8 1

9 2 8
5 1 6
4 7 3

9 3 4
1 8 6
7 5 2

9 3 6
1 8 4
5 7 2

9 3 6
2 7 5
4 8 1

9 3 8
1 4 2
7 5 6

9 3 8
1 6 2
5 7 4

9 4 3
1 6 7
8 5 2

9 4 3
2 5 8
7 6 1

9 4 7
1 2 3
8 5 6

9 4 8
1 3 2
6 7 5

9 4 8
2 1 3
6 7 5

9 5 3
1 4 7
8 6 2

9 5 4
2 1 7
8 6 3

9 5 4
2 3 7
6 8 1

9 5 7
1 2 3
6 8 4

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

बाइट्स में सबसे छोटा कोड जीतता है।

^{मज़बूत वर्गों का विषय मेरी इस चैट संदेश से उत्पन्न हुआ, जिसके कारण उनके गुणों पर बड़ी मात्रा में चर्चा हुई और उन्हें कैसे उत्पन्न किया गया। करने के लिए रंगमंच की सामग्री पीटर टेलर , feersum , और Sp3000 चर्चा जारी रखने के लिए, और विशेष रूप से करने के लिए El'endia Starman के लिए मसौदा तैयार करने के लिए एक इसी OEIS अनुक्रम ।}

Comments

मुझे यकीन नहीं है कि मैंने अनुगामी न्यूलाइन नियम की सही व्याख्या की है। मेरे पिछले संशोधन का आउटपुट समाप्त हो गया है 5 7 3\n\n, इसलिए अंतिम वर्ग के बाद एक रिक्त रेखा है। क्या यह स्वीकार्य है?

— डेनिस

Yyyy मैं अतिरिक्त सहारा मिलता है! : पी

— एल'एंडिया स्ट्रैटन

हो सकता है कि आउटपुट को कहीं और होस्ट करें ताकि वह इस पृष्ठ पर बहुत लंबा न हो।

— रियान

Answer 1

पायथ, 38 34 33 32 बाइट्स

Vfq2l{sMX2.DR2.:T5b.pS9Vc3NjdH)k

जकुबे द्वारा 5 बाइट्स को प्रारूपण में सहेजा गया

1 बाइट की लंबाई पांच तक पीटर टेलर के सबस्ट्रिंग पर स्विच करके बचाई गई, मिडल दृष्टिकोण को हटा दें

मेरी मशीन पर चलने के लिए लगभग डेढ़ मिनट का समय लगता है।

यह उच्च स्तर पर कैसे काम करता है:

• सभी क्रमपरिवर्तन उत्पन्न करें ( .pS9)

• फॉर्म की लंबाई 5 सब्सट्रिंग ( .:T5)

• प्रत्येक का केंद्र तत्व निकालें ( .DR2)

• केंद्र तत्व में एक नई रेखा जोड़ें, इसे आवश्यक रूप से भिन्न राशि के साथ चिह्नित करें ( X2 ... b)

• वर्गों के लिए फ़िल्टर करें जहाँ इस तरह के सभी योग समान हैं ( fq2l{)

• प्रारूप और प्रिंट ( V ... Vc3NjdH)k)

Comments

Nलूप V...Vc3Nके पहले ( ) के बजाय लूप ( ) के अंदर जकड़ें VcL3...VN। एक अतिरिक्त बाइट बचाता है।

— जेकुब

Answer 2

सीजेएम, 40 38 बाइट्स

A,1>e!3f/{2{2few:::+z}*:|,1=},Ma*Sf*N*

2 बाइट बंद करने के लिए @PeterTaylor को धन्यवाद!

यह जावा दुभाषिया का उपयोग करके तुरंत समाप्त होता है। यह ऑनलाइन दुभाषिया का उपयोग करके भी काम करता है, लेकिन इसके लिए थोड़ा धैर्य चाहिए। इसे ऑनलाइन आज़माएं।

परीक्षण चालन

$ cjam sturdy-squares.cjam | head -n 8
1 5 3
9 8 7
4 2 6

1 5 6
8 7 3
4 2 9

$ cjam sturdy-squares.cjam | tail -n 8

9 5 4
2 3 7
6 8 1

9 5 7
1 2 3
6 8 4
$

यह काम किस प्रकार करता है

A,1>     e# Push [1 ... 9].
e!       e# Push the array of all permutations of that array.
3f/      e# Split each into rows of length 3.
{        e# Filter; push the permutation, then:
  2{     e#   Do the following twice:
    2few e#     Split each row into overlapping splices of length 2.
         e#       [a b c] -> [[a b] [b c]]
    :::+ e#     Reduce each innermost vector to its sum.
         e#       [[a b] [b c]] -> [a+b b+c]
    z    e#     Transpose rows with columns.
  }*     e#   The result is [[s t] [u v]], the sums of all 2x2 squares.
  :|     e#   Perform set union of the pairs of sums.
  ,1=    e#   Check if the length of the result is 1 (unique sum).
},       e# Keep the array if the result was 1.
{        e# For each kept array:
  Sf*    e#   Join the elements of its rows, separating by spaces.
  ~M     e#   Dump the resulting strings and an empty string on the stack.
}%       e# Collect everything in an array.
N*       e# Join the strings, separating by linefeeds.

Comments

+1 और मैं अपने उत्तर की संक्षिप्तता से खुश था!

— 1

अब जब कि मैं अपने उत्तर को एक चार से आगे रहने के लिए पर्याप्त रूप से हासिल करने में कामयाब रहा हूं: Ma*Sf*N*दो ओवर{Sf*~M}%N*

— पीटर टेलर

@PeterTaylor यह वास्तव में करता है। धन्यवाद!

— डेनिस

Answer 3

अजगर 3, 169 168 164 बाइट्स

मैं इन मजबूत वर्गों / आयतों की जांच करने के लिए इस्तेमाल किया कार्यक्रम ले लिया और इसे नीचे रास्ते पर लगाया। ओटाकुकोड के लिए 4 बाइट्स के लिए गोल्फ को बंद किया गया।

from itertools import*
r=range(1,10)
for p in permutations(r,6):
 x,y=p[0],p[5];q=p[:5]+(x+p[3]-p[2],y,y+p[1]-x,p[2]+y-x)
 if set(q)==set(r):print('%s %s %s\n'*3%q)

व्याख्या

इस तरह आंशिक रूप से भरे मजबूत वर्ग को देखते हुए,

a b c
d e ?
g ? ?

शेष तीन प्रविष्टियों विशिष्ट निर्धारित कर रहे हैं, और कर रहे हैं a+d-c, a+b-gऔरc+g-a । इसलिए मैं छह तत्वों के साथ 0..8 के सभी क्रमचय उत्पन्न करता हूं, बाकी की गणना करता हूं, और फिर यह देखने के लिए जांचता हूं कि क्या यह सेट 0..8 के सेट के समान है। यदि यह है, तो मैं ग्रिड का प्रिंट आउट लेता हूं।

---

संदर्भ के लिए, यहाँ मूल (टिप्पणियों और निकाले गए कोड के साथ):

from itertools import permutations as P

n = 3
m = 3
permutes = P(range(m*n), m+n)

counter = 0
for p in permutes:
    grid = [p[:n]]
    for i in range(m-1):
        grid.append([p[n+i]]+[-1]*(n-1))
    grid[1][1] = p[-1]

    s = p[0]+p[1]+p[n]+p[-1]

    has = list(p)

    fail = 0
    for y in range(1,m):
        for x in range(1,n):
            if x == y == 1: continue

            r = s-(grid[y-1][x-1] + grid[y-1][x] + grid[y][x-1])

            if r not in has and 0 <= r < m*n:
                grid[y][x] = r
                has.append(r)
            else:
                fail = 1
                break

        if fail: break

    if not fail:
        counter += 1

print(counter)

Comments

इस तकनीक से प्यार करें

— उज्ज्वल

बहुत अच्छा तरीका! आप अभी भी कुछ बाइट्स बचा सकते हैं ... लूप में, x, y = p [0], p [5] फिर q = p + (y + p [3] -p [2], y + p [1] ] -x, पी [2] + xy)

— otakucode

@otakucode: टिप के लिए धन्यवाद!

— एल'एंडिया स्ट्रैटन

Answer 4

गणितज्ञ 147 166 155 149 बाइट्स

यह {1,2,3 ... 9} के क्रमपरिवर्तन उत्पन्न करता है और जिसके लिए मामलों का चयन करता है

({1,2,4,5} पदों पर अंकों का योग) =

({2,3,5,6} पदों पर अंकों का योग) =

({4,5,7,8} पदों पर अंकों का योग) =

({5,6,8,9} पदों पर अंकों का योग)

f@s_:=Length@Tally[Tr@Extract[s,#]&/@Table[{{0},{1},{3},{4}}+k,{k,{1,2,4,5}}]]>1;
Row[Grid/@(#~Partition~3&/@Select[Permutations@Range@9,f@#&]),"\n"]

आउटपुट (एक आंशिक रूप)

---

Length[%]

376

Answer 5

CJam ( 39 37 बाइट्स)

A,1>e!{5ew{2Mtz}2*::+)-!},3f/Ma*Sf*N*

ऑनलाइन डेमो (चेतावनी: चलाने में एक मिनट से अधिक समय लग सकता है, ट्रिगर "इस स्क्रिप्ट को निरस्त करें?" ब्राउज़र से संकेत देता है)।

5ewनक्शे का उपयोग करके सभी संभव ग्रिड को फ़िल्टर करके काम करता है

[a b c d e f g h i]

सेवा मेरे

[[a b c d e]
 [b c d e f]
 [c d e f g]
 [d e f g h]
 [e f g h i]]

और फिर पाने के लिए मध्य तत्व और एक दूसरे तत्व के मध्य तत्व को त्यागना

[[a b d e]
 [b c e f]
 [d e g h]
 [e f h i]]

जो चार वर्ग हैं।

Comments

वाह, यह शानदार है।

— एल'एंडिया स्ट्रैटन

Answer 6

पायथन 3.5, 135 बाइट्स

from itertools import*
for x in permutations(range(1,10)):eval((("=="+"+x[%s]"*3)*4)[2:]%(*"013125367578",))and print("%d %d %d\n"*3%x)

सीधे प्रत्येक वर्ग का योग चेक करता है, बीच में घटाता है। सबसे अधिक संभावना अभी भी " itertoolsअनावश्यक" नियम के अंगूठे द्वारा गोल्फ है ।

Answer 7

को Python2 327 271 270 263 260 बाइट्स

z,v,s={},3,range(1,10)
while len(z)<376:
 for i in range(8):v=hash(`v`);s[i],s[v%9]=s[v%9],s[i]
 m=map(lambda i:sum(s[i:i+5])-s[i+2],[0,1,3,4]);T=tuple(s)
 if all(x==m[0] for x in m) and not T in z:
  z[T]=1;print '%i %i %i\n'*3 % tuple(s[0:3]+s[3:6]+s[6:9])

------------

यह है ... इतना छोटा नहीं है लेकिन यह कोई पुस्तकालयों का उपयोग करता है। यह बेतरतीब ढंग से एक वर्ग की अनुमति देता है, जादू के लिए इसकी जांच करता है, इसे प्रिंट करता है, और डुप्लिकेट को रोकने के लिए इसे रिकॉर्ड करता है। 376 अद्वितीय मैजिक स्क्वायर मुद्रित करने के बाद, यह बंद हो जाता है।

मैंने कीथ रान्डल की गोल्फ से " रैंडम नंबर जेनरेटर बनाएँ जो डेथवूड टेस्ट पास करता है " के लिए छद्म रैंडम नंबर जनरेटर से उधार लिया।

z,v={},3
def R(x,y):global v;v=hash(`v`);return v
while len(z)<376:
 s=sorted(range(1,10),cmp=R)
 m=[sum(q) for q in map(lambda p:s[p[0]:p[1]+1]+s[p[2]:p[3]+1], [[i,i+1,i+3,i+4] for i in [0,1,3,4]] )]
 if all(x==m[0] for x in m) and not tuple(s) in z.keys():
  z[tuple(s)]=1;print '%i %i %i\n'*3 % tuple(s[0:3]+s[3:6]+s[6:9])

डी-golfed

# each magic square is an array of 9 numbers
#
#for example [1 9 3 7 2 5 6 4 8] 
#
#represents the following square
#
#1 9 3
#7 2 5
#6 4 8
#
# to generate a random square with each number represented only once,
# start with [1 2 3 4 5 6 7 8 9] and sort, but use a random comparison
# function so the sorting process becomes instead a random permutation.
# 
# to check each 2x2 subsquare for sums, look at the indexes into the
# array: [[0,1,3,4] = upper left,[1,2,4,5] = upper right, etc.
#
# to keep track of already-printed magic squares, use a dictionary    
# (associative array) where the 9-element array data is the key. 

from random import *
def magic(s):
 quads=[]
 for a,b,c,d in [[0,1,3,4],[1,2,4,5],[3,4,6,7],[4,5,7,8]]:
  quads+=[s[a:b+1]+s[c:d+1]]
 summ=[sum(q) for q in quads]
 same= all(x==summ[0] for x in summ)
 #print quads
 #print 'sum',summ
 #print 'same',same
 return same

magicsquares={}
while len(magicsquares.keys())<376:
        sq = sorted(range(1,10),key=lambda x:random())
        if magic(sq) and not magicsquares.has_key(tuple(sq)):
                magicsquares[tuple(sq)]=1
                print sq[0:3],'\n',sq[3:6],'\n',sq[6:9],'\n'

Comments

यादृच्छिक कुछ भी नहीं हो रहा है। वास्तव में 376 अलग-अलग वर्ग समाधान हैं और आपको उनमें से प्रत्येक को बिल्कुल एक बार आउटपुट करने की आवश्यकता है।

— केल्विन के शौक

मैं वास्तव में 376 अलग-अलग वर्ग समाधानों को प्रिंट करता था, और मैं उनमें से प्रत्येक को बिल्कुल एक बार आउटपुट करता था। विवरण में यादृच्छिकता पर प्रतिबंध नहीं लगाया गया है, और न ही इसे 'मानक कमियां' meta.codegolf.stackexchange.com/questions/1061/…

— उज्ज्वल

ठीक है, काफी साफ है।

— केल्विन के शौक

आप एक बदतर यादृच्छिक संख्या जनरेटर का उपयोग कर सकते हैं जब तक यह आपको उन सभी वर्गों को देता है जिनकी आपको आवश्यकता है।

— lirtosiast

Answer 8

रूबी 133

a=[]
[*1..9].permutation{|x|[0,1,3,4].map{|i|x[i]+x[i+1]+x[i+3]+x[i+4]}.uniq.size<2&&a<<x.each_slice(3).map{|s|s*' '}*'
'}
$><<a*'

'

सीधा जानवर बल दृष्टिकोण। इसका परीक्षण यहां करें ।

Answer 9

जे, 83 बाइट्स

([:;@,(<LF),.~[:(<@(LF,~":)"1@#~([:*/2=/\[:,2 2+/@,;._3])"2)(3 3)($"1)1+!A.&i.])@9:

यह एक फ़ंक्शन है जो 376 मजबूत वर्गों वाले स्ट्रिंग को आउटपुट करता है। ब्रूट-बल का उपयोग करता है, 1 थ्रू 9 के सभी क्रमपरिवर्तन को उत्पन्न करता है, प्रत्येक को एक 3x3 सरणी में आकार देता है, और यह जांच कर फ़िल्टर करता है कि क्या प्रत्येक 2x2 सबरे के योग समान हैं। आधा सेकंड में पूरा करता है।

प्रयोग

   f =: ([:;@,(<LF),.~[:(<@(LF,~":)"1@#~([:*/2=/\[:,2 2+/@,;._3])"2)(3 3)($"1)1+!A.&i.])@9:
   $ f ''  NB. A function has to take something to be invoked,
           NB. but in this case it is not used by the function
   37 {. f ''  NB. Take the first 37 characters
1 5 3
9 8 7
4 2 6

1 5 6
8 7 3
4 2 9

   _38 {. f ''  NB. Take the last 38 characters
9 5 4
2 3 7
6 8 1

9 5 7
1 2 3
6 8 4


   NB. The output string ends with two newlines