क्या जादू संभव है?

Question

एक जादू वर्ग एक n-by-n वर्ग ग्रिड है, जो कि 1,2, ... n ^ 2 की सीमा में अलग-अलग धनात्मक पूर्णांक से भरा होता है , जैसे कि प्रत्येक कोशिका में एक अलग पूर्णांक और प्रत्येक पंक्ति में पूर्णांक का योग होता है। स्तंभ और विकर्ण समान है।

आपका कार्य सकारात्मक संख्याओं से मिलकर एक n-by-n मैट्रिक्स लेना है, और खाली कोशिकाओं के लिए एक प्लेसहोल्डर चरित्र (मैं 0 का उपयोग करूंगा , लेकिन आप किसी भी गैर-संख्यात्मक चरित्र या डेटाटाइप का उपयोग कर सकते हैं), और यह निर्धारित करें कि क्या है लापता संख्याओं को भरकर एक जादुई वर्ग बनाना संभव है

मैट्रिक्स कम से कम 2-बाय -2 , और अधिकतम 10-बाय -10 होगा । सबसे छोटा संभव गैर-तुच्छ जादू वर्ग 3-बाय -3 है । इनपुट मैट्रिक्स में संख्या n ^ 2 से अधिक हो सकती है , और यह संभव है कि सभी सेल भरे हुए हों।

परीक्षण के मामलों:

2   2
2   0
False

8   0   6
0   5   0
0   9   2
True

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

10   0   1
 0   5   9
 3   7   5
False

99    40    74     8    15    51     0    67     0     1
 0    41    55    14     0    57    64     0    98     0
81    47    56    20    22    63    70    54     0    88
 0    28     0    21     0    69    71    60    85    19
 0    34     0     2     9    75    52    61     0    25
24    65    49     0    90    26    33    42    17    76
 0     0    30    89    91     0    39    48     0    82
 6    72    31    95     0    38    45    29     0    13
12    53     0    96    78     0     0     0    10    94
18    59    43    77     0     0    27    36     0   100
True

Comments

हम्म। मुझे लगता है कि मैंने कहीं एक समाधान देखा है ..

— मैथ्यू रो

सुझाए गए परीक्षण का मामला सुनिश्चित करने के लिए कि विकर्णों सही ढंग से जांच की जाती है: [ [ 1, 5, 9 ], [ 6, 7, 2 ], [ 8, 3, 4 ] ](falsy)

— Arnauld

क्या हम प्लेसहोल्डर्स (यानी [[8, X1, 6], [X2, 5, X3], [X4, 9, 2]]) को नंबर दे सकते हैं ?

— स्कॉट मिलनर

@ निश्चित रूप से, स्वतंत्र महसूस करें ...

— स्टिव ग्रिफ़िन

Answer 1

जावास्क्रिप्ट (ईएस 6), 270 268 बाइट्स

मैट्रिक्स को 2 डी सरणी के रूप में लेता है। लौटाता है 0या 1।

a=>(g=(x,y=0,w=a.length,p,R=a[y])=>[0,1,2,3].some(d=>a.some((r,y)=>(p=s)^(s=r.reduce((p,v,x)=>(o|=1<<(v=[v,(b=a[x])[y],b[x++],b[w-x]][d]),p+v),0))&&p),s=o=0)||o/2+1!=1<<w*w?R&&[...Array(w*w)].map((_,n)=>(p=R[x])==++n|!p&&(R[x]=n,g(z=(x+1)%w,y+!z),R[x]=p)):r=1)(r=0)&&r

परीक्षण के मामलों

यह निश्चित रूप से अंतिम परीक्षण मामले के लिए बहुत धीमा है। :-(

let f =

a=>(g=(x,y=0,w=a.length,p,R=a[y])=>[0,1,2,3].some(d=>a.some((r,y)=>(p=s)^(s=r.reduce((p,v,x)=>(o|=1<<(v=[v,(b=a[x])[y],b[x++],b[w-x]][d]),p+v),0))&&p),s=o=0)||o/2+1!=1<<w*w?R&&[...Array(w*w)].map((_,n)=>(p=R[x])==++n|!p&&(R[x]=n,g(z=(x+1)%w,y+!z),R[x]=p)):r=1)(r=0)&&r

console.log(f([
  [ 2,  2 ],
  [ 2,  0 ]
]));

console.log(f([
  [ 8,  0,  6 ],
  [ 0,  5,  0 ],
  [ 0,  9,  2 ]
]));

console.log(f([
  [ 16,   2,   3,  13 ],
  [  5,  11,  10,   8 ],
  [  9,   7,   6,  12 ],
  [  4,  14,  15,   1 ]
]));

console.log(f([
  [ 10,  0,  1 ],
  [  0,  5,  9 ],
  [  3,  7,  5 ]
]));

Answer 2

05AB1E , 45 बाइट्स

Zsgn©>‹®L¹˜Kœ0ªε\¹˜0y.;¹gô©O®øO®Å\O®Å/O)˜Ë}à*

$0$$0$$n^2$$0$$0$ एस के )।

4 बाइट्स कम हो सकती थी, लेकिन वर्तमान में .;2 डी सूचियों के साथ बिलिन में एक बग है । :और .:उम्मीद के .;मुताबिक काम करते हैं , लेकिन अभी 2 डी सूचियों पर कुछ भी नहीं करता है .. इसलिए काम के आसपास ˜और ¹gôमैट्रिक्स को समतल करने के लिए; .;सूची पर उपयोग ; और इसे फिर से एक मैट्रिक्स में बदल दें।

इसे ऑनलाइन आज़माएं या कुछ और परीक्षण मामलों को सत्यापित करें । (नोट: चुनौती विवरण का अंतिम परीक्षण मामला शामिल नहीं है, क्योंकि इसके पास बहुत सारे 0 हैं ..)

स्पष्टीकरण:

Z               # Get the maximum of the (implicit) input-matrix (implicitly flattened)
                # (and without popping the matrix)
                #  i.e. [[8,0,6],[0,5,0],[0,0,2]] → 8
 s              # Swap to get the input-matrix again
  g             # Get its length (amount of rows)
                #  i.e. [[8,0,6],[0,5,0],[0,0,2]] → 3
   n            # Square it
                #  i.e. 3 → 9
    ©           # Store it in the register (without popping)
     >‹         # Check if the maximum is <= this squared matrix-dimension
                #  i.e. 8 <= 9 → 1 (truthy)
®               # Push the squared matrix-dimension again
 L              # Create a list in the range [1, squared_matrix_dimension]
                #  i.e. 9 → [1,2,3,4,5,6,7,8,9]
  ¹             # Push the input-matrix
   ˜            # Flatten it
                #  i.e. [[8,0,6],[0,5,0],[0,0,2]] → [8,0,6,0,5,0,0,0,2]
    K           # Remove all these numbers from the ranged list
                #  i.e. [1,2,3,4,5,6,7,8,9] and [8,0,6,0,5,0,0,0,2] → [1,3,4,7,9]
œ               # Get all possible permutations of the remaining numbers
                # (this part is the main bottleneck of the program;
                #  the more 0s and too high numbers, the more permutations)
                #   i.e. [1,3,4,7,9] → [[1,3,4,7,9],[1,3,4,9,7],...,[9,7,4,1,3],[9,7,4,3,1]]
 0ª             # Add an item 0 to the list (workaround for inputs without any 0s)
                #  i.e. [[1,3,4,7,9],[1,3,4,9,7],...,[9,7,4,1,3],[9,7,4,3,1]] 
                #   → [[1,3,4,7,9],[1,3,4,9,7],...,[9,7,4,1,3],[9,7,4,3,1],"0"] 
   ε            # Map each permutation `y` to:
    \           #  Remove the implicit `y` which we don't need yet
    ¹˜          #  Push the flattened input again
      0         #  Push a 0
       y        #  Push permutation `y`
        .;      #  Replace all 0s with the numbers in the permutation one by one
                #   i.e. [8,0,6,0,5,0,0,0,2] and [1,3,4,7,9]
                #    → [8,1,6,3,5,4,7,9,2]
          ¹g    #  Push the input-dimension again
            ô   #  And split the flattened list into parts of that size,
                #  basically transforming it back into a matrix
                #   i.e. [8,1,6,3,5,4,7,9,2] and 3 → [[8,1,6],[3,5,4],[7,9,2]]
             ©  #  Save the matrix with all 0s filled in in the register (without popping)
    O           #  Take the sum of each row
                #   i.e. [[8,1,6],[3,5,4],[7,9,2]] → [15,12,18]
    ®øO         #  Take the sum of each column
                #   i.e. [[8,1,6],[3,5,4],[7,9,2]] → [18,15,12]
    ®Å\O        #  Take the sum of the top-left to bottom-right main diagonal
                #   i.e. [[8,1,6],[3,5,4],[7,9,2]] → 15
    ®Å/O        #  Take the sum of the top-right to bottom-left main diagonal
                #   i.e. [[8,1,6],[3,5,4],[7,9,2]] → 18
    )           #  Wrap everything on the stack into a list
                #   → [[15,12,18],[18,15,12],15,18]
     ˜          #  Flatten it
                #   i.e. [[15,12,18],[18,15,12],15,18] → [15,12,18,18,15,12,15,18]
      Ë         #  Check if all values are equal
                #   i.e. [15,12,18,18,15,12,15,18] → 0 (falsey)
}               # After the map:
                #  → [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
 à              # Check if any are truthy by taking the maximum
                #  → 1 (truthy)
  *             # And multiply the two checks to verify both are truthy
                #  i.e. 1 and 1 → 1 (truthy)
                # (and output the result implicitly)

वेरिफ़ मैजिक स्क्वायर चुनौती के लिए मेरे 05AB1E उत्तर©O®øO®Å\O®Å/O)˜Ë में भी भाग का उपयोग किया जाता है , इसलिए कोड के उस भाग के बारे में अधिक गहराई से स्पष्टीकरण के लिए उस उत्तर को देखें।