Dikgen-Çapraz Greco-Latin Meydanı İnşa Etmek

NX Nbenzersiz öğeden oluşan bir ızgara düşünün . Her öğenin bir harfi (A'dan Nth'e, dahil) ve bir numarası (1'den N, dahil) vardır. Bu nedenle, her sayı / harf çifti ızgarada tam olarak bir kez bulunur.

İşiniz şu şekilde bir ızgara düzenlemektir:

Her satır, sütun ve köşegen (kaydırma dahil) her harf ve sayıyı tam olarak bir kez içerir.

Sarmakla, yani

* * * # *
* * # * * 
* # * * *
# * * * *
* * * * #

bir köşegen ve kenarlara çarpan benzer köşegenler.

Örnek bir 5x5tablo:

A1 B2 C3 D4 E5
C4 D5 E1 A2 B3
E2 A3 B4 C5 D1
B5 C1 D2 E3 A4
D3 E4 A5 B1 C2

Göreviniz, bir sayıyı kabul eden bir program yazmak Nve yukarıda açıklandığı gibi bir Nx Nızgarası yazdırmaktır . Programınız herhangi biri için çalışmalıdır 0 < N <= 26. Belirli bir ızgara mümkün değilse, yazdırmalısınız Impossible.

Herhangi bir yanıtın Nzor kodlanmasına izin verilmez. Bir program, ızgarayı herhangi biri için farklı bir şekilde (benim tarafımdan değerlendirildiği gibi) N > 26hesaplarsa (veya hesaplayamazsa) sabit olarak kodlanır . (Bu, önceden hesaplanmış geçersiz ızgaralar veya belirli ızgaralar için ofsetler dahil olmak üzere yeniden hesaplamayı önlemek içindir).

Bu en hızlı kod sorunudur ve puanınız, programımı Nbilgisayarımda mümkün olan her yerde çalıştırmak için harcanan sürelerin toplamıdır . Cevabınızda, lütfen programınızın tümünde çalışmasını sağlayın N(bu yüzden sadece bir kez zamanlamalıyım). Hiçbir program 60 saniyenin altında hesaplayamazsa, kazanan, N60 saniyede en büyük ızgarayı hesaplayabilen cevaptır . Birden fazla program aynı maksimum Ndeğere sahipse, tiebreaker en hızlı çözümdür.

(Yeterince güçlü bir Windows 8 makinem var ve gerekli derleyiciler veya tercümanlar bunun için serbestçe kullanılabilir olmalıdır).

Python 3

letters = []
numbers = []
for n in range(1,27): 
    if n%2==0 or n%3==0:
        offsets=False
    else:
        offsets = [x for x in range(0,n,2)]
        offsets.extend([x for x in range(1,n,2)])
    letters.append(chr(96+n))
    numbers.append(n)
    if offsets :
        for y in range(n):
            for x in range(n):
                let=letters[(x+offsets[y])%n]
                num=numbers[(offsets[y]-x)%n]
                print (let+str(num), end= "  " if num<10 else " ")
            print("\n")     
    else: 
        print("Impossible\n")

Nasıl çalışır?

Saf uygulama, bir NxN ızgarasındaki tüm olası harf ve sayı düzenlemelerini incelemek ve aynı zamanda Ortogonal-Çapraz Latin Meydanı (ODLS) olanı aramaktır (ve bazıları için sadece tüm yapılandırmaları ve dönüş imkansız). Böyle bir algoritma saçma zaman karmaşıklığı nedeniyle bu zorluğa uymayacaktır. Dolayısıyla, uygulamamda kullanılan ODLS yapılarına yönelik üç önemli basitleştirme ve gerekçelendirme (neden işe yaradığına dair kısmi kanıtlar ve bilgiler) var:

Birincisi, geçerli bir Diyagonal Latin Kare (her satır, sütun, sarılı diyagonal, N farklı elemanlar kümesinin her elemanını tam olarak bir kez içerecek şekilde bir NxN ızgarası) oluşturmamız gerektiğidir. alfabe. Böyle bir Diyagonal Latin Meydanı (DLS) oluşturabilirsek, uygun eleman değişimi ve çevirme ile DLS kullanılarak bir ODLS oluşturulabilir. Meşrulaştırma:

Let us first look at an example using the example grid
a1 b2 c3 d4 e5
c4 d5 e1 a2 b3
e2 a3 b4 c5 d1
b5 c1 d2 e3 a4
d3 e4 a5 b1 c2
Every ODLS can be separated into two DLS (by definition), so
we can separate the grid above into two DLS, one containing letters, the other - numbers
a b c d e
c d e a b
e a b c d
b c d e a
d e a b c
and
1 2 3 4 5 
4 5 1 2 3
2 3 4 5 1
5 1 2 3 4 
3 4 5 1 2
If we transform the number DLS by the mapping 1-->e, 2-->d, 3-->c, 4-->b, 5-->a,
1 2 3 4 5 --> e d c b a
4 5 1 2 3 --> b a e d c
2 3 4 5 1 --> d c b a e
5 1 2 3 4 --> a e d c b
3 4 5 1 2 --> c b a e d
Now if we put the transformed number grid next to the original letter grid,
Original  | Transformed
a b c d e | e d c b a
c d e a b | b a e d c
e a b c d | d c b a e
b c d e a | a e d c b
d e a b c | c b a e d
It can be clearly seen that the number grid is a horizontal flip of
the letter grid withminor letter to number substitutions.
Now this works because flipping guarantees that no two pairs occur more than once,
and each DLS  satisfies the requirements of the ODLS.

İkinci basitleştirme, bir öğenin uygun bir yapılandırmasını (SC) bulursak (her satır, sütun, sarılı diyagonal bu öğeyi tam olarak bir kez içerecek şekilde bir NxN ızgarası), öğeyi değiştirerek bir DLS oluşturulabileceği fikridir. ve SC'nin kaydırılması. Meşrulaştırma:

If "_" is an empty space and "a" the element then a valid SC of a 7x7 grid is
a _ _ _ _ _ _
_ _ a _ _ _ _
_ _ _ _ a _ _
_ _ _ _ _ _ a
_ a _ _ _ _ _ 
_ _ _ a _ _ _
_ _ _ _ _ a _
or
a _ _ _ _ _ _
_ _ _ a _ _ _
_ _ _ _ _ _ a
_ _ a _ _ _ _
_ _ _ _ _ a _ 
_ a _ _ _ _ _
_ _ _ _ a _ _
(the second one can actually be obtained from the first one via rotation)
now say we took the second SC, shifted it one unit to the right and 
replaced all "a" with "b"
a _ _ _ _ _ _       _ a _ _ _ _ _       _ b _ _ _ _ _
_ _ _ a _ _ _       _ _ _ _ a _ _       _ _ _ _ b _ _
_ _ _ _ _ _ a       a _ _ _ _ _ _       b _ _ _ _ _ _
_ _ a _ _ _ _  -->  _ _ _ a _ _ _  -->  _ _ _ b _ _ _
_ _ _ _ _ a _       _ _ _ _ _ _ a       _ _ _ _ _ _ b
_ a _ _ _ _ _       _ _ a _ _ _ _       _ _ b _ _ _ _
_ _ _ _ a _ _       _ _ _ _ _ a _       _ _ _ _ _ b _
Now if we overlaid the SC of "a" with the SC of "b" we get
a b _ _ _ _ _
_ _ _ a b _ _
b _ _ _ _ _ a
_ _ a b _ _ _
_ _ _ _ _ a b 
_ a b _ _ _ _
_ _ _ _ a b _
If we repeated these steps for the other five letters, we would arrive at a DLS
a b c d e f g
e f g a b c d
b c d e f g a
f g a b c d e
c d e f g a b 
g a b c d e f
d e f g a b c
This is a DLS, since each SC follows the general requirements of a DLS 
and shifting ensured that each element has its own cell.
Another thing to note is that each row contains the string "abcdefg" that is offset 
by some cells. This leads to another simplification: we only need to find the 
offsets of the string in every row and we are finished.

Son sadeleştirme aşağıdaki gibidir - N = 2 veya N = 3 hariç, N asalının tüm DLS'si oluşturulabilir ve N, uygun DLS'si oluşturulabilen iki sayıya katlanabilirse, o N'nin bir DLS'si inşa edilecek. Ben de bu muhabbetin tuttuğunu sanıyorum. (Başka bir deyişle, N için yalnızca 2 veya 3 ile bölünemeyen bir DLS oluşturabiliriz)

Pretty obvious why 2x2 or 3x3 cant be made. For any other prime this can be done
by assigning a each consecutive row a shift that is by two bigger than the previous, 
for N=5 and N=7 this looks like (with elements other than "a" ommited)
N=5
a _ _ _ _ offset = 0
_ _ a _ _ offset = 2
_ _ _ _ a offset = 4
_ a _ _ _ offset = 6 = 1 (mod 5)
_ _ _ a _ offset = 8 = 3 (mod 5)
N=7
a _ _ _ _ _ _ offset = 0
_ _ a _ _ _ _ offset = 2
_ _ _ _ a _ _ offset = 4
_ _ _ _ _ _ a offset = 6
_ a _ _ _ _ _ offset = 8 = 1 (mod 7)
_ _ _ a _ _ _ offset = 10 = 3 (mod 7)
_ _ _ _ _ a _ offset = 12 = 5 (mod 7
(Why this works on all prime N (actually all N that are not divisible
by 3 or 2) can probably be proven via some kind of induction but i will
omit that, this is just what my code uses and it works)
Now, the first composite number that is not
divisible by 2 or 3 is 25 (it also occurs in the range our program must test)
Let A denote the DLS of N = 5
a b c d e 
d e a b c 
b c d e a 
e a b c d 
c d e a b
Let F be the DLS A where each letter is substituted by the letter five postions after it 
a-->f, b-->g etc. So F is 
f g h i j 
j e f g h 
g h i j f 
j f g h i 
h i j f g
Let K be the DLS a where each letter is substituted by the letter ten postions after it
a-->k, b--> l etc.
Let P be defined likewise (so a-->p, b-->q etc)
Let U be defined likewise (so a-->u, b-->v etc)
Now, since the DLS A could be constructed, then by substituting a --> A, b--> F etc.
we get a DLS of N=5*5 (A has five rows and five columns and each is filled with a 
grid of five rows and five columns)
A F K P U
P U A F K
F K P U A
U A F K P
K P U A F
Now since smaller DLS in the big DLS satisfies the 
conditions of a DLS and the big one also satisfies the DLS conditions,
then the resulting grid is also a DLS 

Daha küçük - daha büyük DLS ile ne demek istediğimin bir resmi

Now this kind of thing works for all constructible N and can be proven similiarly.

I have a strong sense that the converse (if some N isnt constructible
(2 and 3) then no multiple of that N is constructible) is also true but have a hard time 
proving it (test data up to N=30 (took a veeery long time to calculate) confirm it though)