যাদু কি সম্ভব?

একটি যাদু বর্গক্ষেত্র একটি হল N-দ্বারা-এন বর্গক্ষেত্র গ্রিড, সীমার মধ্যে স্বতন্ত্র ধনাত্মক পূর্ণসংখ্যা ভরা 1,2 ^ 2, ... এন , এই ধরনের প্রতিটি সেল প্রতিটি সারির একটি ভিন্ন পূর্ণসংখ্যা এবং পূর্ণসংখ্যার যোগফল রয়েছে, কলাম এবং তির্যক সমান।

আপনার কাজটি হ'ল এন-বাই-এন ম্যাট্রিক্স সহ ধনাত্মক সংখ্যার সমন্বিত স্থান এবং খালি ঘরগুলির জন্য একটি স্থানধারক চরিত্র (আমি 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

— স্টিও গ্রিফিন
সূত্র

হুম। আমি মনে করি আমি কোথাও একটি সমাধান দেখেছি ..

— ম্যাথু রোহ

প্রস্তাবিত পরীক্ষা ক্ষেত্রে নিশ্চিত করতে যে কর্ণ সঠিকভাবে পরীক্ষিত হয়: [ [ 1, 5, 9 ], [ 6, 7, 2 ], [ 8, 3, 4 ] ](falsy)

— Arnauld

আমরা কি স্থানধারীদের সংখ্যা (যেমন [[8, X1, 6], [X2, 5, X3], [X4, 9, 2]]) করতে পারি ?

— স্কট মিলনার

@Scott নিশ্চিত, বিনা দ্বিধায় ...

— Stewie গ্রিফিন

উত্তর:

জাভাস্ক্রিপ্ট (ES6), 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 ]
]));

স্নিপেট প্রসারিত করুন

— Arnauld
সূত্র

05 এ বি 1 ই , 45 বাইট

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

$0$ $0$ $n^2$ $0$ $0$

4 বাইট কম থাকতে পারত তবে বর্তমানে বিল্টিনে .;2 ডি তালিকা সহ একটি বাগ রয়েছে । :এবং .:প্রত্যাশিত হিসাবে কাজ করুন, তবে .;এখনই 2 ডি তালিকায় কিছুই করেন না .. সুতরাং ম্যাট্রিক্সের চারপাশে ˜এবং ¹gôসমতল করার জন্য; .;তালিকায় ব্যবহার করুন; এবং এটিকে আবার ম্যাট্রিক্সে রূপান্তর করুন।

এটি অনলাইনে চেষ্টা করুন বা আরও কিছু পরীক্ষার কেস যাচাই করুন । (দ্রষ্টব্য: চ্যালেঞ্জের বর্ণনার শেষ পরীক্ষার কেসটি অন্তর্ভুক্ত করা হয়নি, কারণ এতে অনেকগুলি 0s রয়েছে ..)

ব্যাখ্যা:

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)˜Ë ব্যবহৃত হয় , সুতরাং কোডটির সেই অংশটি সম্পর্কে আরও গভীরতর ব্যাখ্যাের জন্য সেই উত্তরটি দেখুন।

— কেভিন ক্রুইজসেন
সূত্র