मैजिक स्क्वायर सत्यापित करें

10

एक जादू वर्ग अलग सकारात्मक पूर्णांक 1, 2, ... से मिलकर n के साथ संख्याओं का एक वर्ग सरणी है, n sum व्यवस्था की है कि किसी भी क्षैतिज, ऊर्ध्वाधर या मुख्य विकर्ण लाइन में n संख्याओं का योग हमेशा होता है वही संख्या, जिसे जादू स्थिरांक के रूप में जाना जाता है।

आपके प्रोग्राम को इनपुट करना चाहिए, std-in के माध्यम से, आपके वर्ग के किनारे की लंबाई निर्दिष्ट करने वाली संख्या, फिर वर्ग में संख्याएँ। किसी संख्या का एक से अधिक बार उपयोग नहीं किया जा सकता है, n may से अधिक संख्या का उपयोग नहीं किया जा सकता है, और सभी संख्याओं की संख्या 0. से अधिक होनी चाहिए। कार्यक्रम को यह निर्धारित करना होगा कि संख्याओं का संयोजन एक जादू वर्ग है।

code-golf  math 
— Wrzlprmft
स्रोत

जवाबों:

4

CJam, 47 39 35 33 31 बाइट्स

l~/{_1fb_,Y${\(_@=\}%:++\z}2*;=

जैसे इनपुट लेता है 

4 [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16]

1जादू वर्ग अगर आउटपुट , 0अन्यथा।

यह कैसे काम करता है :

l~/                               "Evaluates the input and split the array into chunks"
                                  "of size N where N is the first integer";
   {                      }2*     "Run this code block 2 times";
    _1fb                          "Copy the 2D array and calculate sum of each row of copy";
        _,                        "Copy the array containing sum of each row and get"
                                  "its length. This is equal to N";
          Y${      }%             "Run this code block for each array of the original"
                                  "2D array that we copied from stack";
             \(_                  "Put the length number to top of stack, decrement and"
                                  "copy that";
                @=\               "Take the element at that index from each row and put"
                                  "N back behind at second position in stack";
                     :+           "Take sum of elements of the array. This is sum of"
                                  "one of the diagonals of the 2D array";
                       +          "Push diagonal sum to row sum array";
                        \z        "Bring original array to top and transpose columns";
                             ;    "At this point, the stack contain 3 arrays:"
                                  "  Array with sum of rows and main diagonal,"
                                  "  Array with sum of columns and secondary diagonal and"
                                  "  The original array. Pop the original array";
                              =   "Check if sum of rows + main diagonal array is equal to ";
                                  "sum of columns + secondary diagonal array";

इसे और आगे बढ़ाया जा सकता है।

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत
6

पायथन 2: 132 चार्ट

n,l=input()
r=range
print r(1,n*n+1)==sorted(l)*len({sum(l[i::j][:n])for(i,j)in zip(r(n)+r(0,n*n,n)+[0,n-1],[n]*n+[1]*n+[n+1,n-1])})

एक उदाहरण रन:

STDIN: 4,[16,3,2,13,5,10,11,8,9,6,7,12,4,15,14,1]
Output: True

जाँच करने के लिए दो चीजें हैं:

  1. रकम पंक्तियाँ, स्तंभ, और विकर्ण सभी समान हैं
  2. तत्वों के क्रमपरिवर्तन हैं [1,2,...,n*n].

पहले इन सबसेटों के अनुरूप स्लाइसों को लेकर जाँच की जाती है। प्रत्येक पंक्ति, स्तंभ, या विकर्ण को इसके शुरुआती मूल्य और इसके विस्थापन द्वारा वर्णित किया जाता है। हम सूची को इसी स्लाइस में लेते nहैं, तत्वों को काटते हैं, और इसे जोड़ते हैं। पायथन [start:end:step]संकेतन में, पंक्तियाँ हैं [r*n::1], स्तंभ हैं [c::n]और दो विकर्ण हैं [0::n+1]और [n-1::n-1]। इनके 2*n+2द्वारा निर्मित जोड़े की सूची के रूप में संग्रहीत किया जाता है zip।

हम रकम के सेट लेते हैं और जाँचते हैं कि इसकी लंबाई 1 है। इसके अलावा, हम इनपुट को छाँटते हैं और जाँचते हैं कि यह सूची है। [1,2,...,n*n].वास्तव में, हम दोनों को एक-एक चेक में जोड़ते हैं, sorted(l)जो सम-सेट की लंबाई से गुणा करके, हमेशा एक चेक होता है। जब तक योग-सेट की लंबाई 1 नहीं होती है।

— XNOR
स्रोत
मैंने महसूस किया कि आप एक जोड़ी सांकेतिक शब्दों में बदलना कर सकते हैं (i,j)और अधिक कुशलता से एक भी संख्या के रूप में x, ले i=x%Cऔर j=x/Cकुछ बड़ा पर्याप्त के लिए C। बाद में एक शॉट दे सकते हैं।
— xnor
5

एपीएल, ३५

∧/2=/(+⌿x,⍉x),+/↑1 1∘⍉¨x(⌽x←⎕⍴⍨,⍨⎕)

स्पष्टीकरण
x←⎕⍴⍨,⍨⎕ इनपुट के लिए संकेत देता है, इसे एक मैट्रिक्स में आकार दें, और x
⌽मैट्रिक्स को बाएं-से-दाएं उलट करने के लिए असाइन करें: मैट्रिक्स की
x(...)एक सरणी बनाएं: xऔर xरिवर्स करें
1 1∘⍉¨प्रत्येक
+/↑मैट्रिक्स के लिए, उन पर संख्याओं के 2 × n मैट्रिक्स का विकर्ण रूप लें विकर्ण और पंक्तियों को जोड़ते हैं

⍉xपक्षांतरित x
x,तो साथ जोड़ xके रूप में एक × 2n मैट्रिक्स
+⌿और स्तंभों का योग

(+⌿x,⍉x),+/↑1 1∘⍉¨x(⌽x←⎕⍴⍨,⍨⎕)समसामयिकी की एक सरणी बनाने के लिए सहमति दें
2=/कि यदि लगातार जोड़े समान हैं
∧/और उन सभी परिणामों को एक साथ

— TwiNight
स्रोत
3

गणितज्ञ 128 125

d = Diagonal; r = Reverse; i = Input[];
Length@Union[Tr /@ Join[p = Partition[i[[2]], i[[1]]], 
t = Transpose@p, {d@p}, {d@t}, {d@r@p}, {d@r@t}]] == 1

जैसे इनपुट लेता है

{4,{16, 3, 2, 13, 5, 10, 11, 8, 9, 6, 7, 12, 4, 15, 14, 1}}

सच

— DavidC
स्रोत
निश्चित रूप से यहां बहुत सारे व्हॉट्सएप हैं जिन्हें यहां से हटाया जा सकता है
— बीटा डिके
सभी सफेद स्थान को हटाया जा सकता है। मैंने इसे पठनीयता के लिए वहाँ छोड़ दिया। और मैं अनावश्यक सफेद स्थान की गिनती नहीं करता था।
— डेविड
आप Input[r=Reverse]एक बाइट को बचाने के लिए कर सकते हैं । #&@@से एक बाइट कम है [[1]]। आप शायद Partitionएक और बाइट के लिए इसके अलावा इन्फिक्स नोटेशन का उपयोग कर सकते हैं । और के Threadबजाय काम करना चाहिए Transpose। वैकल्पिक रूप से, इस यूनिकोड चरित्र का उपयोग पोस्ट फिक्स ऑपरेटर के रूप में करें (गणितज्ञ इसका उपयोग ट्रांसस्क्रिप्ट के लिए सुपरस्क्रिप्ट टी के लिए करता है)।
— मार्टिन एंडर
3

APL 47 32

ट्विनइट के उत्कृष्ट समाधान का उपयोग करना और कुछ और ट्विकिंग लागू करना:

∧/2=/+⌿(1 1∘⍉∘⌽,1 1∘⍉,⍉,⊢)⎕⍴⍨,⍨⎕

स्पष्टीकरण:

यह फंक्शन ट्रेनों का उपयोग करता है, जिन्हें Dyalog दुभाषिया के v14 में पेश किया गया था। एपीएल को दाएं से बाएं, so के इनपुट से निष्पादित किया जाता है, इसलिए पहले आयाम, फिर संख्याओं के वेक्टर।

⍨⎕, matrix मैट्रिक्स NxN बनाता है

इसके बाद फ़ंक्शन ट्रेन आती है जो मूल रूप से सही तर्क के लिए लागू किए गए कार्यों (ब्रैकेट्स के बीच) का एक अनुक्रम है। कार्य हैं:

⊢ सही तर्क देता है (कि मैट्रिक्स है)

Matrix सही तर्क मैट्रिक्स को स्थानांतरित करता है

1 1 1 विकर्ण लौटाता है

1 1 1 उलट (क्षैतिज) मैट्रिक्स के विकर्ण को लौटाता है

सभी परिणाम समारोह के साथ सम्‍मिलित हैं ","

इस बिंदु पर, परिणाम एक मैट्रिक्स है जिसके कॉलम को फिर सारांशित किया जाता है (+ ⌿)। इस तरह से प्राप्त मूल्यों को = / 2 = / के साथ समान होने के लिए जाँच की जाती है

मैं अपना पुराना हल यहां भी छोड़ दूंगा:

{M←⍺ ⍺⍴⍵⋄d←M=⍉M⋄(⊃≡∪)((+/,+⌿)M),+/∘,¨d(⌽d)ר⊂M}

उदाहरण के लिए, बाएं तर्क के रूप में आयाम, सही तर्क के रूप में तत्वों का वेक्टर:

4{M←⍺ ⍺⍴⍵⋄d←M=⍉M⋄(⊃≡∪)((+/,+⌿)M),+/∘,¨d(⌽d)ר⊂M}16 3 2 13 5 10 11 8 9 6 7 12 4 15 14 1
1

यहां ऑनलाइन कोशिश की जा सकती है: www.tryapl.org

— मोरिस ज़ुक्का
स्रोत
2

जावास्क्रिप्ट (E6) 194

इनपुट पढ़ने और आउटपुट प्रदर्शित करने के लिए संकेत का उपयोग करना।
फ़ायरफ़ॉक्स> 31 (Array.fill बहुत नया है) के साथ कंसोल में टेस्ट करें

z=(p=prompt)(n=p()|0).split(' '),u=Array(2*n).fill(e=d=n*(n*n+1)/2),z.map((v,i)=>(r=i/n|0,u[r+n]-=v,u[c=i%n]-=v,d-=v*(r==c),e-=v*(r+c+1==n))),o=!(e|d|u.some(v=>v)),z.sort((a,b)=>a-b||(o=0)),p(o)

कम गोल्फ वाला

n = prompt()|0; // input side length
z = prompt().split(' '); // input list of space separeted numbers  
e = d = n*(n*n+1)/2; // Calc sum for each row, column and diagonal
u = Array(2*n).fill(e), // Init check values for n rows and n columns

z.map( (v,i) => { // loop on number array 
  r = i / n | 0; // row number
  c = i % n; // column number
  u[r+n] -= v; // subtract current value, if correct it will be 0 at loop end
  u[c] -= v; 
  if (r==c) d -= v; // subtract if diagonal \
  if (r+c+1==n) e -=v; // subtract if diagonal /
}),
o=!(e|d|u.some(v=>v)); // true if values for rows, cols and diags are 0
z.sort((a,b)=>a-b||(o=0)); // use sort to verify if there are repeated values in input
alert(o);
— edc65
स्रोत
2

पायथ, 24 30 बाइट्स

&q1l{sM++JcEQCJm.e@bkd_BJqSlQS

इसे यहाँ ऑनलाइन आज़माएँ ।

&q1l{sM++JcEQCJm.e@bkd_BJqSlQSQ   Implicit: Q = evaluated 1st input (contents), E = evaluated 2nd input (side length)
                                  Trailing Q inferred
          cEQ                     Chop E into pieces or length Q
         J                        Store in J
                      _BJ         Pair J with itself with rows reversed
               m                  Map the original and it's reverse, as d, using:
                .e   d              Map each row in d, as b with index k, using:
                  @bk                 Get the kth element of b
                                  The result of this map is [[main diagonal], [antidiagonal]]
        +J                        Prepend rows from J
       +     CJ                   Prepend columns from J (transposed J)
     sM                           Sum each
    {                             Deduplicate
   l                              Length
 q1                               Is the above equal to 1?
&                                 Logic AND the above with...
                          SlQ     ... is the range [1-length(Q)]...
                         q        ... equal to...
                             SQ   ... sorted(Q)

संपादित करें: एक बग तय किया, धन्यवाद @KevinCruijssen मुझे बताने के लिए: ओ)

— सोक
स्रोत
यह Trueसंख्याओं के साथ जादू वर्गों के लिए आउटपुट है जो बहुत बड़े हैं, या सभी अद्वितीय नहीं हैं। यानी 4और [12,26,23,13,21,15,18,20,17,19,22,16,24,14,11,25]या 4और [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]आउटपुट दोनों True। (लगभग सभी मौजूदा उत्तर में एक ही समस्या है, लेकिन जब से वे 4 साल पहले पोस्ट किए गए हैं, तब मैंने एक टिप्पणी में अपनी गलतियों को सुधारने के लिए परेशान नहीं किया।)
— केविन क्रूज़सेन
@KevinCruijssen अरे, मैं तो गया रकम है कि मैं अन्य आवश्यकताओं के बारे में भूल की पुष्टि करने पर ध्यान केंद्रित किया है ... मैं इस तरह के एक डोप हूँ
— सोक
1

LUA 186 चार्ट

s=io.read(1)v=io.read(2)d=0 r=0 for i=1,#s do t=0 for j = 1, #s do t=t+s[i][j]end d=d+s[i][i] r=r+s[i][#s-i+1]if t ~= v then o=true end end if d~=v and r~= v then o=true end print(not o)
— Jawo
स्रोत
1

05AB1E , 24 बाइट्स

ô©O®øO®Å\O®Å/O)˜Ë²{¹nLQ*

इनपुट प्रारूप: 4\n[2,16,13,3,11,5,8,10,7,9,12,6,14,4,1,15]। क्रमशः सत्य / असत्य के लिए आउटपुट 1/ 0।

इसे ऑनलाइन आज़माएं या कुछ और परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

ô       # Split the 2nd (implicit) input into parts of a size of the 1st (implicit) input
        #  i.e. [2,16,13,3,11,5,8,10,7,9,12,6,14,4,1,15] and 4
        #   → [[2,16,13,3],[11,5,8,10],[7,9,12,6],[14,4,1,15]]
 ©      # Store it in the register (without popping)
  O     # Take the sum of each row
        #  i.e. [[2,16,13,3],[11,5,8,10],[7,9,12,6],[14,4,1,15]] → [34,34,34,34]
®       # Push the matrix from the register again
 ø      # Zip/transpose; swapping rows/columns
        #  i.e. [[2,16,13,3],[11,5,8,10],[7,9,12,6],[14,4,1,15]]
        #   → [[2,11,7,14],[16,5,9,4],[13,8,12,1],[3,10,6,15]]
  O     # Sum each inner list again
        #  i.e. [[2,11,7,14],[16,5,9,4],[13,8,12,1],[3,10,6,15]] → [34,34,34,34]
®       # Push the matrix from the register again
 Å\     # Get the top-left to bottom-right main diagonal of it
        #  i.e. [[2,16,13,3],[11,5,8,10],[7,9,12,6],[14,4,1,15]] → [2,5,12,15]
   O    # Sum it together
        #  i.e. [2,5,12,15] → 34
®       # Push the matrix from the register again
 Å/     # Get the top-right to bottom-left main diagonal of it
        #  i.e. [[2,16,13,3],[11,5,8,10],[7,9,12,6],[14,4,1,15]] → [3,8,9,14]
   O    # Sum it together
        #  i.e. [3,8,9,14] → 34
)       # Wrap everything on the stack into a list
        #  → [[34,34,34,34],[34,34,34,34],34,34]
 ˜      # Flatten this list
        #  i.e. [[34,34,34,34],[34,34,34,34],34,34] → [34,34,34,34,34,34,34,34,34,34]
  Ë     # Check if all values are equal to each other
        #  i.e. [34,34,34,34,34,34,34,34,34,34] → 1 (truthy)
²       # Push the second input again
 {      # Sort it
        #  i.e. [2,16,13,3,11,5,8,10,7,9,12,6,14,4,1,15]
        #  → [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]
  ¹n    # Push the first input again, and take its square
        #  i.e. 4 → 16
    L   # Create a list in the range [1, squared_input]
        #  i.e. 16 → [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]
     Q  # Check if the two lists are equal
        #  i.e. [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]
        #   and [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16] → 1 (truthy)
*       # Check if both checks are truthy by multiplying them with each other
        #  i.e. 1 and 1 → 1
        # (and output the result implicitly)
— केविन क्रूज़सेन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.