একটি গ্রেকো-ল্যাটিন স্কোয়ার তৈরি করুন


24

অস্বীকৃতি: আমি কোনও অ-ব্রুটফোর্স সমাধান সম্পর্কে সচেতন নই

একটি গ্রাইকো-ল্যাটিন বর্গক্ষেত্র, একই দৈর্ঘ্যের n এর দুটি সেটের জন্য , কোষের একটি n×n বিন্যাসের জন্য, প্রত্যেকটিই প্রথম সেটের একটি উপাদানের একটি অনন্য (পুরো বর্গক্ষেত্র জুড়ে) এবং দ্বিতীয় সেটটির একটি উপাদান যুক্ত করে, যেমন সমস্ত প্রথম উপাদান এবং জোড়াগুলির সমস্ত দ্বিতীয় উপাদানগুলি তাদের সারি এবং কলামে অনন্য। ব্যবহার করা সর্বাধিক সাধারণ সেটগুলি হ'ল গ্রীক এবং লাতিন বর্ণমালার প্রথম এন বর্ণগুলি gu

এখানে একটি 4x4 গ্রিকো-লাতিন বর্গের একটি ছবি দেওয়া হয়েছে:এখানে চিত্র বর্ণনা লিখুন

গ্রীকো-ল্যাটিন স্কোয়ারগুলি যেমন শোনা যায় ততই দরকারী ( উইকিপিডিয়া প্রবন্ধে "পরীক্ষার নকশা, টুর্নামেন্টের শিডিউলিং এবং ম্যাজিক স্কোয়ারগুলি তৈরি" উল্লেখ করা হয়েছে)। আপনার টাস্কটি একটি ধনাত্মক পূর্ণসংখ্যা এন দেওয়া হয়, একটি এন gene n তৈরি করতেn×এন গ্রেকো-লাতিন বর্গ তৈরি করতে।

ইনপুট

একটি ধনাত্মক পূর্ণসংখ্যা n>2 ; এটা নিশ্চিত করা হয় যে একটি n×এন (যে Graeco-ল্যাটিন বর্গ বিদ্যমান এন6 )।

আউটপুট

দ্বি-মাত্রিক অ্যারে হিসাবে পাশের দৈর্ঘ্য n সহ একটি গ্রেোকো-ল্যাটিন বর্গক্ষেত্র, অ্যারের অ্যারে, একটি সমতল অ্যারে বা আউটপুটযুক্ত।

নোট

  • আপনাকে গ্রীক এবং লাতিন বর্ণমালা বিশেষভাবে ব্যবহার করতে হবে না; উদাহরণস্বরূপ, ধনাত্মক পূর্ণসংখ্যার জোড় আউটপুট করার পাশাপাশি অনুমোদিত।
  • যদি আপনি এমন বর্ণমালা ব্যবহার করতে চান যা নির্বিচারে বাড়ানো যায় না, আপনাকে (তাত্ত্বিকভাবে; মহাবিশ্বের তাপ মৃত্যুর আগে আপনার কোডটি শেষ করতে হবে না) কমপক্ষে 20 এর সর্বাধিক দিকের দৈর্ঘ্য সমর্থন করতে হবে।

এটি , তাই সংক্ষিপ্ততম কোডটি জয়ী!



আমাদের কি একটি একক বর্গক্ষেত্র আউটপুট করতে হবে, বা তালিকা হিসাবে সমস্ত সম্ভাব্য স্কোয়ার আউটপুট করা ঠিক আছে?
নিক কেনেডি

উত্তর:


2

জেলি ,  21  20 বাইট

-1 নিক কেনেডি ধন্যবাদ (ফ্ল্যাট আউটপুট বিকল্প একটি বাইট সংরক্ষণ করতে দেয় ż"þ`ẎẎQƑ$Ƈ F€p`Z€QƑƇ )

Œ!ṗ⁸Z€Q€ƑƇF€p`Z€QƑƇḢ

এটি অনলাইন চেষ্টা করুন! (4টিআইও-তে 60 এর দশকেরজন্য খুব ধীর গতিতে, তবে আমরা কার্বিটেশিয়ান শক্তি,সংমিশ্রণগুলির সাথেপ্রতিস্থাপন করলেœc, এটি সম্পূর্ণ হবে) - যদিও 5 অবশ্যই তা করবে না!)

কিভাবে?

Œ!ṗ⁸Z€Q€ƑƇF€p`Z€QƑƇḢ - Link: integer, n
Œ!                   - all permutations of [1..n]
   ⁸                 - chain's left argument, n
  ṗ                  - Cartesian power (that is, all ways to pick n of those permutations, with replacement, not ignoring order)
    Z€               - transpose each
         Ƈ           - filter, keeping those for which:
        Ƒ            -   invariant under:
      Q€             -     de-duplicate each
          F€         - flatten each  
             `       - use this as both arguments of:
            p        -   Cartesian product
              Z€     - transpose each
                  Ƈ  - filter, keeping those for which:
                 Ƒ   -   invariant under:   
                Q    -     de-duplicate (i.e. contains all the possible pairs)
                   Ḣ - head (just one of the Latin-Greaco squares we've found)

এখানে একটি 20 । আমি মূলত এটি আপনার সম্পর্কে স্বাধীনভাবে লিখেছিলাম, তবে বেশ কিছু অনুরূপ কিছু দিয়ে শেষ করেছি, এবং তারপরে কোনও পারমিটেশন ডায়ডের জায়গায় আপনার কার্টেসিয়ান শক্তি ব্যবহার থেকে কিছুটা অনুপ্রেরণা নিয়েছি, তাই এটি সম্ভবত আপনার উন্নতির জন্য ব্যবহার করা ভাল। আপনার ব্যাখ্যায় আপনি গ্রাইকোকে ভুল বানান লিখেছেন।
নিক কেনেডি

ধন্যবাদ নিক, আমি লক্ষ্য করিনি যে আমাদের সমতল সংস্করণ আউটপুট করার অনুমতি দেওয়া হয়েছিল।
জোনাথন অ্যালান

3

05 এ বি 1 ই , 26 23 22 বাইট

-3 বাইট ধন্যবাদ এমিগিনার কাছে

-1 বাইট কেভিন ক্রুইজসেনকে ধন্যবাদ

Lãœ.ΔIôDζ«D€í«ε€нÙgQ}P

এটি অনলাইন চেষ্টা করুন!


1
n<ÝI‰হতে পারে<Ýã
এমিগনা

... এবং হতে পারে L। ধন্যবাদ!
গ্রিমি

1
ê}DIùQÙgQ}Pএকটি বাইট সংরক্ষণ করা যেতে পারে ।
কেভিন ক্রুইজসেন

@ কেভিন ক্রুজসেন ধন্যবাদ! । আমি যে সম্পাদনা
Grimmy

3

আর , 164 148 বাইট

- জিউসেপিকে অনেকগুলি বাইটস ধন্যবাদ

n=scan()
`!`=function(x)sd(colSums(2^x))
m=function()matrix(sample(n,n^2,1),n)
while(T)T=!(l=m())|!(g=m())|!t(l)|!t(g)|1-all(1:n^2%in%(n*l+g-n))
l
g

এটি অনলাইন চেষ্টা করুন!

নাটকীয়ভাবে অদক্ষ - আমি মনে করি এটি অন্যান্য বর্বর বলের পদ্ধতির চেয়েও খারাপ। এমনকি n=3, এটি সম্ভবত টিআইওরও সময় শেষ হবে। এখানে একটি বিকল্প সংস্করণ (155 বাইট) যা n=3প্রায় 1 সেকেন্ডের জন্য কাজ করে ।

m1এনএনlg । তারপরে আমরা যাচাই করি:

  1. all(1:n^2%in%(n*l+g-n))এন2l × g ?
  2. হয় lএবং gল্যাটিন স্কোয়ার?

!এনlg2^l2এন+ +1-2lt(l)lgsdএন=0এন=1

একটি চূড়ান্ত নোট: প্রায়শই আর কোড গল্ফে, আমি কয়েকটি বাইট অর্জনের Tজন্য ভেরিয়েবলটি ব্যবহার করেছিলাম , যা হিসাবে আরম্ভ হয় TRUE। তবে এর অর্থ হ'ল আমার যখন (প্যারামিটার ইন ) TRUEসংজ্ঞাটিতে আসল মানটির প্রয়োজন হয়েছিল তখন আমাকে তার পরিবর্তে ব্যবহার করতে হয়েছিল । একইভাবে, যেহেতু আমি প্রত্যাখ্যানের চেয়ে আলাদা কোনও ফাংশন হিসাবে পুনরায় সংজ্ঞা দিচ্ছি, তার পরিবর্তে আমাকে ব্যবহার করতে হয়েছিল ।mreplacesample1T!1-all(...)!all(...)


2

জাভাস্ক্রিপ্ট (ES6),  159 147  140 বাইট

এর সমতল অ্যারেটি দেয়এন×এনঅ -ণাত্মক পূর্ণসংখ্যার জোড়ার ।

এটি একটি সাধারণ উদ্দীপনা অনুসন্ধান, এবং অতএব খুব ধীর।

n=>(g=(m,j=0,X=n*n)=>j<n*n?!X--||m.some(([x,y],i)=>(X==x)+(Y==y)>(j/n^i/n&&j%n!=i%n),g(m,j,X),Y=X/n|0,X%=n)?o:g([...m,[X,Y]],j+1):o=m)(o=[])

এটি অনলাইন চেষ্টা করুন!(পূর্বনির্ধারিত আউটপুট সহ)

মন্তব্য

n => (                      // n = input
  g = (                     // g is the recursive search function taking:
    m,                      //   m[] = flattened matrix
    j = 0,                  //   j   = current position in m[]
    X = n * n               //   X   = counter used to compute the current pair
  ) =>                      //
    j < n * n ?             // if j is less than n²:
      !X-- ||               //   abort right away if X is equal to 0; decrement X
      m.some(([x, y], i) => //   for each pair [x, y] at position i in m[]:
        (X == x) +          //     yield 1 if X is equal to x OR Y is equal to y
        (Y == y)            //     yield 2 if both values are equal
                            //     or yield 0 otherwise
        >                   //     test whether the above result is greater than:
        ( j / n ^ i / n &&  //       - 1 if i and j are neither on the same row
          j % n != i % n    //         nor the same column
        ),                  //       - 0 otherwise
                            //     initialization of some():
        g(m, j, X),         //       do a recursive call with all parameters unchanged
        Y = X / n | 0,      //       start with Y = floor(X / n)
        X %= n              //       and X = X % n
      ) ?                   //   end of some(); if it's falsy (or X was equal to 0):
        o                   //     just return o[]
      :                     //   else:
        g(                  //     do a recursive call:
          [...m, [X, Y]],   //       append [X, Y] to m[]
          j + 1             //       increment j
        )                   //     end of recursive call
    :                       // else:
      o = m                 //   success: update o[] to m[]
)(o = [])                   // initial call to g with m = o = []

144 ? (আমার ফোনে, তাই এটি নিশ্চিতভাবে কাজ করে না)
শেগি

আমারও মনে oহয় না আপনার দরকার আছে ; আপনি কেবল 141m
শেগি

@ শেগি উভয় সংস্করণ জন্য ব্যর্থ হবেএন=5

2

হাস্কেল , 207 143 233 বাইট

(p,q)!(a,b)=p/=a&&q/=b
e=filter
f n|l<-[1..n]=head$0#[(c,k)|c<-l,k<-l]$[]where
	((i,j)%p)m|j==n=[[]]|1>0=[q:r|q<-p,all(q!)[m!!a!!j|a<-[0..i-1]],r<-(i,j+1)%e(q!)p$m]
	(i#p)m|i==n=[[]]|1>0=[r:o|r<-(i,0)%p$m,o<-(i+1)#e(`notElem`r)p$r:m]

এটি অনলাইন চেষ্টা করুন!

ঠিক আছে, আমি মনে করি অবশেষে আমি এটি পেয়েছি। এটি টিআইওতে এন = 5, এন = 6 বার আউট জন্য দুর্দান্ত কাজ করে তবে আমি মনে করি যে এটি কেবল কারণ হতে পারে কারণ এই নতুন অ্যালগরিদমটি অত্যন্ত অকার্যকর এবং মূলত সমস্ত সম্ভাবনাগুলি পরীক্ষা করে যতক্ষণ না এটি কার্যকর হয় finds আমি এখন ল্যাপটপে n = 6 চালিয়ে যাচ্ছি আরও কিছু সময়ের সাথে এটি বন্ধ হয়ে যায় কিনা তা দেখার জন্য।

আমার আগের সংস্করণগুলিতে বাগগুলি নির্দেশ করার জন্য আবার @ সোমনকে ধন্যবাদ


1
আমি হাস্কেলকে চিনি না, তবে পাদলেখের "4" পরিবর্তন করে 5 এ পরিবর্তন করা আমার পক্ষে ত্রুটি বলে মনে হচ্ছে আমি কি এটিকে সঠিকভাবে প্রার্থনা করছি?
আমার সর্বনাম

@ সোমোন ভাল ক্যাচ, আমার এটি পরীক্ষা করা উচিত ছিল I আমি এখানে ঠিক কী ঘটছে তা নিশ্চিত নয়, এটি ডিবাগ করতে কিছুটা সময় নিতে পারে
user1472751

1
আমি মনে করি এটি এখনও একটি বাগ আছে; যখন এন = 5 এর জন্য চালানো হয় তখন টিপল (1,1) দু'বার উপস্থিত হয়।
আমার সর্বনাম

@ সোমন ম্যান, এই সমস্যাটি আমি যা ভাবি তার থেকে অনেক বেশি শক্ত। আমি একবারে সমস্ত প্রতিবন্ধকতাগুলি লক করার কোনও নির্ভরযোগ্য উপায় খুঁজে পাচ্ছি না। আমি একে অপরের দিকে মনোনিবেশ করার সাথে সাথেই আমার আঁকড়ে পড়ে যায়। আমি এই মুহূর্তে অ-প্রতিযোগী হিসাবে চিহ্নিত করতে যাচ্ছি যতক্ষণ না আমি এই বিষয়ে কাজ করার জন্য আরও কিছু সময় খুঁজে পাই। আমার যেমনটি করা উচিত তত ভালোভাবে পরীক্ষা না করায় দুঃখিত
user1472751

1

সি #, 520 506 494 484 বাইট

class P{static void Main(string[]a){int n=int.Parse(a[0]);int[,,]m=new int[n,n,2];int i=n,j,k,p,I,J;R:for(;i-->0;)for(j=n;j-->0;)for(k=2;k-->0;)if((m[i,j,k]=(m[i,j,k]+ 1) % n)!=0)goto Q;Q:for(i=n;i-->0;)for(j=n;j-->0;){for(k=2;k-->0;)for(p=n;p-->0;)if(p!=i&&m[i,j,k]==m[p,j,k]||p!=j&&m[i,j,k]==m[i,p,k])goto R;for(I=i;I<n;I++)for(J=0;J<n;J++)if(I!=i&&J!=j&&m[i,j,0]==m[I,J,0]&&m[i,j,1]==m[I,J,1])goto R;}for(i=n;i-->0;)for(j=n;j-->0;)System.Console.Write(m[i,j,0]+"-"+m[i,j,1]+" ");}}

একটি বর্গক্ষেত্র ফাইন্ড ইনফের অ্যালগরিদম খুব সহজ। এটা ... ব্রুটফোর্স। হ্যাঁ, এটি বোকা, তবে কোড গল্ফ কোনও প্রোগ্রামের গতি সম্পর্কে নয়, তাই না?

এটি সংক্ষিপ্ত করার আগে কোড:

using System;

public class Program
{
    static int[,,] Next(int[,,] m, int n){
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                for (int k = 0; k < 2; k++)
                {
                    if ((m[i, j, k] = (m[i, j, k] + 1) % n) != 0)
                    {
                        return m;
                    }
                }
            }
        }
        return m;
    }
    static bool Check(int[,,] m, int n)
    {
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                for (int k = 0; k < 2; k++)
                {
                    for (int p = 0; p < n; p++)
                    {
                        if (p != i)
                            if (m[i, j, k] == m[p, j, k])
                                return false;
                    }
                    for (int p = 0; p < n; p++)
                    {
                        if (p != j)
                            if (m[i, j, k] == m[i, p, k])
                                return false;
                    }
                }
            }
        }

        for (int i_1 = 0; i_1 < n; i_1++)
        {
            for (int j_1 = 0; j_1 < n; j_1++)
            {
                int i_2 = i_1;
                for (int j_2 = j_1 + 1; j_2 < n; j_2++)
                {
                    if (m[i_1, j_1, 0] == m[i_2, j_2, 0] && m[i_1, j_1, 1] == m[i_2, j_2, 1])
                        return false;
                }
                for (i_2 = i_1 + 1; i_2 < n; i_2++)
                {
                    for (int j_2 = 0; j_2 < n; j_2++)
                    {
                        if (m[i_1, j_1, 0] == m[i_2, j_2, 0] && m[i_1, j_1, 1] == m[i_2, j_2, 1])
                            return false;
                    }
                }
            }
        }
        return true;
    }
    public static void Main()
    {
        int n = 3;
        Console.WriteLine(n);
        int maxi = (int)System.Math.Pow((double)n, (double)n*n*2);
        int[,,] m = new int[n, n, 2];
        Debug(m, n);
        do
        {
            m = Next(m, n);
            if (m == null)
            {
                Console.WriteLine("!");
                return;
            }
            Console.WriteLine(maxi--);
        } while (!Check(m, n));


        Debug(m, n);
    }

    static void Debug(int[,,] m, int n)
    {
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                Console.Write(m[i, j, 0] + "-" + m[i, j, 1] + " ");
            }
            Console.WriteLine();
        }
        Console.WriteLine();
    }
}

এখন, আপনি যদি এটি এন = 3 দিয়ে পরীক্ষা করতে চান তবে আপনাকে এক ঘন্টার মতো অপেক্ষা করতে হবে, সুতরাং এখানে অন্য একটি সংস্করণ রয়েছে:

public static void Main()
{
    int n = 3;
    Console.WriteLine(n);
    int maxi = (int)System.Math.Pow((double)n, (double)n*n*2);        
    int[,,] result = new int[n, n, 2];
    Parallel.For(0, n, (I) =>
    {
        int[,,] m = new int[n, n, 2];
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
            {
                m[i, j, 0] = I;
                m[i, j, 1] = I;
            }
        while (true)
        {
            m = Next(m, n);
            if (Equals(m, n, I + 1))
            {
                break;
            }
            if (Check(m, n))
            {
                Debug(m, n);
            }
        }
    });
}

আপডেট: "সর্বজনীন" অপসারণ করতে ভুলে গেছেন।

আপডেট: ব্যবহৃত "সিস্টেম"। পরিবর্তে "সিস্টেম ব্যবহার;"; এছাড়াও কেভিন ক্রুইজসেনকে ধন্যবাদ , "আরগস" এর পরিবর্তে "এ" ব্যবহার করেছেন।

আপডেট: গ্যাস্ট্রোপনার এবং কাউকে ধন্যবাদ ।


argsহতে পারে a:)
কেভিন ক্রুইজসেন

লুপ জন্য প্রতিটি থেকে রুপান্তরিত করা যায়নি for(X = 0; X < Y; X++)করার for(X = Y; X-->0; ), যা লুপ প্রতি একটি বাইট সংরক্ষণ করা উচিত।
গ্যাস্ট্রোপনার

1
আপনি কি ভিজ্যুয়াল সি # ইন্টারেক্টিভ সংকলক চেষ্টা করেছেন ? এটি বাইট সংরক্ষণ করতে পারে। আপনি একটি বেনামী ফাংশনও জমা দিতে পারেন। আপনি বরাদ্দ করতে পারেনi = 0 এর defininion মধ্যে iএবং একটি বাইট সংরক্ষণ।
আমার সর্বনাম

@ কারও পরামর্শের ভিত্তিতে 405 বাইট অবশ্যই এটি টিআইওতে 60 সেকেন্ড পরে বেরিয়ে যায় তবে এটি ল্যাম্বদা এবং ইন্টি্যাকটিভ সহ ইন্টারেক্টিভ কম্পাইলার ব্যবহার করে বাইটগুলি সংরক্ষণ করে System। এছাড়াও, if((m[i,j,k]=(m[i,j,k]+ 1) % n)!=0)হতে পারে if((m[i,j,k]=-~m[i,j,k]%n)>0)
কেভিন ক্রুইজসেন

@ কেভিন আমাকে এই কোডটি গল্ফ দেওয়ার চেষ্টা করে দেখতে পারা সত্যিই মনে হচ্ছে না। আপনি কি নিশ্চিত যে মুদ্রণ অংশটি সঠিকভাবে কাজ করে? দেখে মনে হচ্ছে এটি হয় Writeবা ব্যবহার করা উচিত বা \nকলের অভ্যন্তরে স্ট্রিং যুক্ত করে বাইটগুলি বাঁচাতে পারে বা অন্যথায় ভাঙ্গা। আমি মনে করি আপনি সরাসরি অ্যারেও ফিরিয়ে দিতে পারবেন।
আমার সর্বনাম

1

অষ্টক , 182 বাইট

নিষ্ঠুর বল পদ্ধতি, টিআইও সময় নির্ধারণ করে রাখে এবং এন = 3 এর আউটপুট পেতে আমাকে বেশ কয়েকবার চালাতে হয়েছিল, তবে তাত্ত্বিকভাবে এটি ঠিক থাকতে হবে। (1,2) এর মতো জোড়ার পরিবর্তে এটি 1 + 2i এর মতো জটিল কনজুগেটের ম্যাট্রিক্সকে আউটপুট করে। এটি নিয়মটি কিছুটা প্রসারিত হতে পারে তবে আমার মতে এটি আউটপুট প্রয়োজনীয়তার সাথে খাপ খায়। ফান্টিনো ঘোষণার আওতায় দুটি লাইন করার আরও ভাল উপায় অবশ্যই থাকতে হবে তবে আমি এই মুহুর্তে নিশ্চিত নই।

function[c]=f(n)
c=[0,0]
while(numel(c)>length(unique(c))||range([imag(sum(c)),imag(sum(c.')),real(sum(c)),real(sum(c.'))])>0)
a=fix(rand(n,n)*n);b=fix(rand(n,n)*n);c=a+1i*b;
end
end

এটি অনলাইন চেষ্টা করুন!


0

ওল্ফ্রাম ভাষা (গণিত) , 123 বাইট

P=Permutations
T=Transpose
g:=#&@@Select[T[Intersection[x=P[P@Range@#,{#}],T/@x]~Tuples~2,2<->4],DuplicateFreeQ[Join@@#]&]&

এটি অনলাইন চেষ্টা করুন!

আমি TwoWayRuleস্বরলিপি ব্যবহারTranspose[...,2<->4] একটি অ্যারের দ্বিতীয় এবং চতুর্থ মাত্রা অদলবদল ; অন্যথায় এটি মোটামুটি সোজা।

Ungolfed:

(* get all n-tuples of permutations *)
semiLSqs[n_] := Permutations@Range@n // Permutations[#, {n}] &;

(* Keep only the Latin squares *)
LSqs[n_] := semiLSqs[n] // Intersection[#, Transpose /@ #] &;

isGLSq[a_] := Join @@ a // DeleteDuplicates@# == # &;

(* Generate Graeco-Latin Squares from all pairs of Latin squares *)
GLSqs[n_] := 
  Tuples[LSqs[n], 2] // Transpose[#, 2 <-> 4] & // Select[isGLSq];

0

পাইথন 3 , 271 267 241 বাইট

ব্রুট-ফোর্স পদ্ধতির: গ্রেইকো-ল্যাটিন বর্গক্ষেত্র না পাওয়া পর্যন্ত জোড়গুলির সমস্ত ক্রিয়াকলাপ তৈরি করুন। এর চেয়ে বড় কিছু উত্পন্ন করতে খুব ধীরn=3টিআইও-র ।

26 বাইট এবং সিলিংক্যাট গল্ফ করার জন্য অ্যালেক্সজ02 কে ধন্যবাদ 4 বাইট golfing জন্য।

এটি অনলাইন চেষ্টা করুন!

from itertools import*
def f(n):
 s=range(n);l=len
 for r in permutations(product(s,s)):
  if all([l({x[0]for x in r[i*n:-~i*n]})*l({x[1]for x in r[i*n:-~i*n]})*l({r[j*n+i][0]for j in s})*l({r[j*n+i][1]for j in s})==n**4for i in s]):return r

ব্যাখ্যা:

from itertools import *  # We will be using itertools.permutations and itertools.product
def f(n):  # Function taking the side length as a parameter
 s = range(n)  # Generate all the numbers from 0 to n-1
 l = len  # Shortcut to compute size of sets
 for r in permutations(product(s, s)):  # Generate all permutations of all pairs (Cartesian product) of those numbers, for each permutation:
  if all([l({x[0] for x in r[i * n : (- ~ i) * n]})  # If the first number is unique in row i ...
        * l({x[1] for x in r[i * n:(- ~ i) * n]})  # ... and the second number is unique in row i ...
        * l({r[j * n + i][0] for j in s})  # ... and the first number is unique in column i ...
        * l({r[j * n + i][1] for j in s})  # ... and the second number is unique in column i ...
        == n ** 4 for i in s]):  # ... in all columns i:
   return r  # Return the square

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.