Görev

N girişi göz önüne alındığında, her satır, sütun ve iki köşegenin 1'den 1'e N(veya daha Nkolaysa 0'dan −1'e) sayıları içerdiği bir NxN ızgarası oluşturur ve çıkar .

Giriş

Giriş pozitif bir tamsayıdır N. Izgaradaki sütun ve satır sayısını gösterir. Bu sorun için, Nmakul bir boyut olacağını varsayabilir 4 ≤ N ≤ 8veya ( 1 ≤ N ≤ 8aşağıdaki bonusa giderseniz).

Çıktı

Çıktı N× Nızgara olacaktır. Izgarada, her satır yalnızca 1 ila sayıları içerir N, her sütun yalnızca 1 ila sayıları içerir ve Nuzunluktaki iki köşegen N(bir (0,0)ila (N-1,N-1)diğer arasında (0,N-1)olan (N-1, 0)) yalnızca 1 ila sayıları içerir N. 0 ila arasındaki rakamları kullanabilirsiniz N−1. Her biri Niçin birçok olası çözüm var, yalnızca bulduğunuz ilkini yazdırmanız gerekir. Sayılar arasında boşluk bırakmanıza gerek yoktur.

Kısıtlamalar

Kodunuz, tekrarlamak için sonuçlar üretebilmelidir N >= 7. Diğer bir deyişle, N = 7her seferinde kodunuzdan gerçekten bir çözüm bulabilmeniz ve çözüm elde edebilmeniz durumunda , iyisinizdir. Mutlak sınırlama açısından, kodunuz N = 7her çalıştırışınızda 10 dakikadan daha az bir sürede çözebilmelidir (yani, rasgele sayılara bağlıysanız, en kötü durum için, kodunuz hala 10 dakikadan daha az bir sürede bitmelidir N = 7) .

Örnekler

• Giriş: 4

  Bir olası çıktı:

  1 2 3 4
  3 4 1 2
  4 3 2 1
  2 1 4 3
  

• Giriş: 5

  Bir olası çıktı:

  1 2 3 4 5
  5 3 1 2 4
  2 5 4 3 1
  4 1 2 5 3
  3 4 5 1 2
  

• Giriş: 8

  Bir olası çıktı:

  1 2 3 4 5 6 7 8
  2 3 1 5 4 8 6 7
  4 1 2 3 7 5 8 6
  6 4 7 8 1 2 3 5
  7 5 8 2 6 3 4 1
  5 8 4 6 2 7 1 3
  8 7 6 1 3 4 5 2
  3 6 5 7 8 1 2 4
  

puanlama

Bu kod golf , yani bayt cinsinden en kısa kod bir istisna dışında kazanıyor. Girdiler N = 2, 3için geçerli bir çözüm yoktur. Eğer kodunuz bunu yönetebilirse (bu durumlar için herhangi bir şey çıkarmadan bitimine kadar koşmak ya da boş bir dize çıkarmak) ve yine de tutacakları N = 1( 1bunun için çıkışlar ), bayt sayınızdan% 20 indirim alın.

Python 3, 275 260 Bayt * 0.8 = 220 208 Bayt

Özyinelemeli / geri izleme yaklaşımı. Rözyinelemeli fonksiyon, lsütun, wsatır, Ksonraki giriş.

İndeksleri daha basit hale getirmek için 1d dizisine yerleştirmeyi ve sonunda yazdırmayı seçtim.

r=range
n=(int)(input())
def R(A,I):
 l=I%n;w=I//n
 if I==n*n:[print(A[i*n:i*n+n])for i in r(n)];exit()
 for K in r(n):
  if all([all([A[i*n+l]!=K,w!=l or A[i+n*i]!=K,w!=n-1-l or A[n*i+n-i-1]!=K])for i in r(w)]+[A[w*n+i]!=K for i in r(l)]):R(A+[K],I+1)
R([],0)

Ungolfed versiyonu:

def Recurse(A,I,n):
 column=I%n
 row=I//n
 if I==n*n:
     [print(*A[i*n:i*n+n])for i in range(n)] # output
     exit() #end recursion
 for K in range(n):
    # try every possibility. Test if they satisfy the constraints:
    # if so, move the index on. If none of them do, we'll return None.
    # if a child returns None, we'll move onto the next potential child:
    # if all of them fail it will backtrack to the next level.
    if all([
        all([
            A[i*n+column]!=K, # column constraint
            row!=column or A[i+n*i]!=K, # diagonal constraint
            row!=n-1-column or A[n*i+n-i-1]!=K # antidiagonal constraint
            ]) for i in range(row)
        ]+[
            A[row*n+i]!=K for i in range(column) # row constraint
            ]):
        Recurse(A+[K],I+1,n)

Recurse([],0,(int)(input()))

Eğlence , rekabetçi olmayan

GÜNCELLEŞTİRME! Büyük performans iyileştirme! n = 7 şimdi 10 dakikadan kısa sürede tamamlanıyor! Dipteki açıklamaya bakınız!

Bu yazmak çok eğlenceliydi. Bu, Funciton'da yazılmış bu problem için kaba kuvvet çözücüdür. Bazı factoids:

• STDIN'de bir tamsayı kabul eder. Herhangi bir yabancı boşluk, tamsayıdan sonraki yeni satır da dahil olmak üzere onu kırar.
• 0 - n - 1 (1 - n değil ) sayılarını kullanır .
• Izgarayı “geriye doğru” doldurur, böylece en üst satırın okumak 3 2 1 0yerine en alt satırın okuduğu bir çözüm elde edersiniz 0 1 2 3.
• N = 1 0için doğru çıktı (tek çözüm) .
• N = 2 ve n = 3 için boş çıktı .
• Bir exe'ye derlendiğinde, n = 7 için yaklaşık 8 takes dakika sürer (performans geliştirmeden yaklaşık bir saat önceydi). Derleme olmadan (tercüman kullanarak) yaklaşık 1,5 kat daha uzun sürer, bu nedenle derleyiciyi kullanmak buna değer.
• Kişisel bir dönüm noktası olarak, ilk kez bir sözde kod dilinde yazmadan önce bütün bir Funciton programını yazdım. İlk önce gerçek C # ile yazdım.
• (Ancak, bu ilk kez Funciton'daki bir şeyin performansını toplu olarak iyileştirmek için bir değişiklik yapmamı değildi. Bunu ilk kez faktoring fonksiyonunda yaptım. Çarpma işlemlerinin sırasını değiştirmek büyük bir fark yarattı. Çarpma algoritması nasıl çalışır ? Sadece merak ediyorsanız diye.)

Daha fazla uzatmadan:

            ┌────────────────────────────────────┐           ┌─────────────────┐
            │                                  ┌─┴─╖ ╓───╖ ┌─┴─╖   ┌──────┐    │
            │                    ┌─────────────┤ · ╟─╢ Ӂ ╟─┤ · ╟───┤      │    │
            │                    │             ╘═╤═╝ ╙─┬─╜ ╘═╤═╝ ┌─┴─╖    │    │
            │                    │               └─────┴─────┘   │ ♯ ║    │    │
            │                  ┌─┴─╖                             ╘═╤═╝    │    │
            │     ┌────────────┤ · ╟───────────────────────────────┴───┐  │    │
          ┌─┴─╖ ┌─┴─╖   ┌────╖ ╘═╤═╝ ┌──────────┐         ┌────────┐ ┌─┴─╖│    │
          │ ♭ ║ │ × ╟───┤ >> ╟───┴───┘        ┌─┴─╖       │ ┌────╖ └─┤ · ╟┴┐   │
          ╘═╤═╝ ╘═╤═╝   ╘══╤═╝          ┌─────┤ · ╟───────┴─┤ << ╟─┐ ╘═╤═╝ │   │
    ┌───────┴─────┘ ┌────╖ │            │     ╘═╤═╝         ╘══╤═╝ │   │   │   │
    │     ┌─────────┤ >> ╟─┘            │       └───────┐      │   │   │   │   │
    │     │         ╘══╤═╝            ┌─┴─╖   ╔═══╗   ┌─┴─╖ ┌┐ │   │ ┌─┴─╖ │   │
    │     │           ┌┴┐     ┌───────┤ ♫ ║ ┌─╢ 0 ║ ┌─┤ · ╟─┤├─┤   ├─┤ Ӝ ║ │   │
    │     │   ╔═══╗   └┬┘     │       ╘═╤═╝ │ ╚═╤═╝ │ ╘═╤═╝ └┘ │   │ ╘═╤═╝ │   │
    │     │   ║ 1 ╟───┬┘    ┌─┴─╖       └───┘ ┌─┴─╖ │   │      │   │   │ ┌─┴─╖ │
    │     │   ╚═══╝ ┌─┴─╖   │ ɓ ╟─────────────┤ ? ╟─┘   │    ┌─┴─╖ │   ├─┤ · ╟─┴─┐
    │     ├─────────┤ · ╟─┐ ╘═╤═╝             ╘═╤═╝   ┌─┴────┤ + ╟─┘   │ ╘═╤═╝   │
  ┌─┴─╖ ┌─┴─╖       ╘═╤═╝ │ ╔═╧═╕ ╔═══╗ ┌───╖ ┌─┴─╖ ┌─┴─╖    ╘═══╝     │   │     │
┌─┤ · ╟─┤ · ╟───┐     └┐  └─╢   ├─╢ 0 ╟─┤ ⌑ ╟─┤ ? ╟─┤ · ╟──────────────┘   │     │
│ ╘═╤═╝ ╘═╤═╝   └───┐ ┌┴┐   ╚═╤═╛ ╚═╤═╝ ╘═══╝ ╘═╤═╝ ╘═╤═╝                  │     │
│   │   ┌─┴─╖ ┌───╖ │ └┬┘   ┌─┴─╖ ┌─┘           │     │                    │     │
│ ┌─┴───┤ · ╟─┤ Җ ╟─┘  └────┤ ? ╟─┴─┐   ┌─────────────┘                    │     │
│ │     ╘═╤═╝ ╘═╤═╝         ╘═╤═╝   │   │╔════╗╔════╗                      │     │
│ │       │  ┌──┴─╖ ┌┐   ┌┐ ┌─┴─╖ ┌─┴─╖ │║ 10 ║║ 32 ║    ┌─────────────────┘     │
│ │       │  │ << ╟─┤├─┬─┤├─┤ · ╟─┤ · ╟─┘╚══╤═╝╚╤═══╝ ┌──┴──┐                    │
│ │       │  ╘══╤═╝ └┘ │ └┘ ╘═╤═╝ ╘═╤═╝     │ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖                  │
│ │     ┌─┴─╖ ┌─┴─╖  ┌─┴─╖  ┌─┴─╖ ╔═╧═╕     └─┤ ? ╟─┤ · ╟─┤ % ║                  │
│ └─────┤ · ╟─┤ · ╟──┤ Ӂ ╟──┤ ɱ ╟─╢   ├───┐   ╘═╤═╝ ╘═╤═╝ ╘═╤═╝                  │
│       ╘═╤═╝ ╘═╤═╝  ╘═╤═╝  ╘═══╝ ╚═╤═╛ ┌─┴─╖ ┌─┴─╖   │     └────────────────────┘
│         └─────┤      │            └───┤ ‼ ╟─┤ ‼ ║   │        ┌──────┐
│               │      │                ╘═══╝ ╘═╤═╝   │        │ ┌────┴────╖
│               │      │                      ┌─┴─╖   │        │ │ str→int ║
│               │      └──────────────────────┤ · ╟───┴─┐      │ ╘════╤════╝
│               │          ┌─────────╖        ╘═╤═╝     │    ╔═╧═╗ ┌──┴──┐
│               └──────────┤ int→str ╟──────────┘       │    ║   ║ │ ┌───┴───┐
│                          ╘═════════╝                  │    ╚═══╝ │ │ ┌───╖ │
└───────────────────────────────────────────────────────┘          │ └─┤ × ╟─┘
           ┌──────────────┐                                  ╔═══╗ │   ╘═╤═╝
╔════╗     │ ╓───╖ ┌───╖  │                              ┌───╢ 0 ║ │   ┌─┴─╖ ╔═══╗
║ −1 ║     └─╢ Ӝ ╟─┤ × ╟──┴──────┐                       │   ╚═╤═╝ └───┤ Ӂ ╟─╢ 0 ║
╚═╤══╝       ╙───╜ ╘═╤═╝         │                       │   ┌─┴─╖     ╘═╤═╝ ╚═══╝
┌─┴──╖ ┌┐ ┌───╖ ┌┐ ┌─┴──╖ ╔════╗ │                       │ ┌─┤   ╟───────┴───────┐
│ << ╟─┤├─┤ ÷ ╟─┤├─┤ << ║ ║ −1 ║ │                       │ │ └─┬─╜ ┌─┐ ┌─────┐   │
╘═╤══╝ └┘ ╘═╤═╝ └┘ ╘═╤══╝ ╚═╤══╝ │                       │ │   └───┴─┘ │   ┌─┴─╖ │
  │         └─┘      └──────┘    │                       │ └───────────┘ ┌─┤ ? ╟─┘
  └──────────────────────────────┘         ╓───╖         └───────────────┘ ╘═╤═╝
                               ┌───────────╢ Җ ╟────────────┐                │
      ┌────────────────────────┴───┐       ╙───╜            │
      │                          ┌─┴────────────────────┐ ┌─┴─╖
    ┌─┴─╖                      ┌─┴─╖                  ┌─┴─┤ · ╟──────────────────┐
    │ ♯ ║ ┌────────────────────┤ · ╟───────┐          │   ╘═╤═╝                  │
    ╘═╤═╝ │                    ╘═╤═╝       │          │     │              ┌───╖ │
┌─────┴───┘    ┌─────────────────┴─┐   ┌───┴───┐    ┌─┴─╖ ┌─┴─╖          ┌─┤ × ╟─┴─┐
│              │                 ┌─┴─╖ │   ┌───┴────┤ · ╟─┤ · ╟──────────┤ ╘═╤═╝   │
│              │ ┌───╖ ┌───╖  ┌──┤ · ╟─┘ ┌─┴─┐      ╘═╤═╝ ╘═╤═╝        ┌─┴─╖ │     │
│         ┌────┴─┤ ♭ ╟─┤ × ╟──┘  ╘═╤═╝   │ ┌─┴─╖ ┌───╖└┐ ┌──┴─╖      ┌─┤ · ╟─┘     │
│         │      ╘═══╝ ╘═╤═╝ ┌───╖ │     │ │ × ╟─┤ Ӝ ╟─┴─┤ ÷% ╟─┐    │ ╘═╤═╝ ┌───╖ │
│   ┌─────┴───┐     ┌────┴───┤ Ӝ ╟─┴─┐   │ ╘═╤═╝ ╘═╤═╝   ╘══╤═╝ │    │   └───┤ Ӝ ╟─┘
│ ┌─┴─╖ ┌───╖ │     │ ┌────╖ ╘═╤═╝   │   └───┘   ┌─┴─╖      │   │    └────┐  ╘═╤═╝
│ │ × ╟─┤ Ӝ ╟─┘     └─┤ << ╟───┘   ┌─┴─╖ ┌───────┤ · ╟───┐  │ ┌─┴─╖ ┌───╖ │    │
│ ╘═╤═╝ ╘═╤═╝         ╘══╤═╝   ┌───┤ + ║ │       ╘═╤═╝   ├──┴─┤ · ╟─┤ × ╟─┘    │
└───┤     └────┐ ╔═══╗ ┌─┴─╖ ┌─┴─╖ ╘═╤═╝ │ ╔═══╗ ┌─┴─╖ ┌─┴─╖  ╘═╤═╝ ╘═╤═╝      │
  ┌─┴─╖ ┌────╖ │ ║ 0 ╟─┤ ? ╟─┤ = ║  ┌┴┐  │ ║ 0 ╟─┤ ? ╟─┤ = ║    │     │ ┌────╖ │
  │ × ╟─┤ << ╟─┘ ╚═══╝ ╘═╤═╝ ╘═╤═╝  └┬┘  │ ╚═══╝ ╘═╤═╝ ╘═╤═╝    │     └─┤ << ╟─┘
  ╘═╤═╝ ╘═╤══╝ ┌┐     ┌┐ │     │     └───┘       ┌─┴─╖   ├──────┘       ╘═╤══╝
    │     └────┤├──┬──┤├─┘     ├─────────────────┤ · ╟───┘                │
    │          └┘┌─┴─╖└┘       │     ┌┐   ┌┐     ╘═╤═╝ ┌┐   ┌┐            │
    └────────────┤ · ╟─────────┘   ┌─┤├─┬─┤├─┐     └───┤├─┬─┤├────────────┘
                 ╘═╤═╝             │ └┘ │ └┘ │         └┘ │ └┘
                   └───────────────┘    │    └────────────┘

İlk versiyonun açıklaması

İlk sürüm n = 7'yi çözmek için yaklaşık bir saat sürdü . En altta 10 dakikanın altında bir değişiklik yapmak için ne gibi değişiklikler yaptığımı açıklayacağım.

Bitlere bir gezi

Bu programın bitlere ihtiyacı var. Çok fazla bit gerektiriyor ve doğru yerlere ihtiyaç duyuyor. Tecrübeli Funciton programcıları zaten n bit ihtiyacınız olursa , bu formülü kullanabileceğinizi biliyorlar.

hangi Funciton olarak ifade edilebilir

Performans optimizasyonumu yaparken, bu formülü kullanarak aynı değeri daha hızlı hesaplayabildiğimi farkettim:

Umarım bu yazıdaki tüm denklem grafiklerini buna göre güncellemediğim için beni affedersiniz.

Şimdi, bitişik bir bit bloğu istemediğinizi varsayalım; Aslında, her k- bit bitinde düzenli aralıklarla n bit istersiniz , bunun gibi:

                                 LSB
                                  ↓
00000010000001000000100000010000001
                            └──┬──┘
                               k

Bunun formülü, bildikten sonra oldukça açık:

Kodda, işlev n ve kӜ değerlerini alır ve bu formülü hesaplar.

Kullanılan sayıları takip etmek

Vardır , n nihai ızgara ² numaraları, ve her sayı herhangi biri olabilir , n olası değerler. Her hücrede hangi sayılara izin verildiğini takip etmek için , belirli bir değerin alındığını göstermek üzere bir bitin ayarlandığı n ³ bitlerden oluşan bir sayı tutarız. Başlangıçta, bu sayı kesinlikle 0'dır.

Algoritma sağ alt köşede başlar. "Tahmin" işleminden sonra ilk sayı 0'dır, aynı satır, sütun ve köşegen boyunca hiçbir hücrede 0'a artık izin verilmediğini izlememiz gerekir:

LSB                               (example n=5)
 ↓
 10000 00000 00000 00000 10000
 00000 10000 00000 00000 10000
 00000 00000 10000 00000 10000
 00000 00000 00000 10000 10000
 10000 10000 10000 10000 10000
                             ↑
                            MSB

Bu amaçla, aşağıdaki dört değeri hesaplıyoruz:

• Şu anki satır: Her n. Bit'de (hücre başına bir tane) n bite ihtiyacımız var ve ardından her sıranın n ² bit içerdiğini hatırlatarak geçerli sıra r'ye kaydırmalıyız :

  

• Geçerli sütun: Her n ²-bit biti (satır başına bir) n bite ihtiyacımız var ve sonra her sütunun n bit içerdiğini hatırlatarak geçerli sütuna c kaydırın :

  

• İleri diyagonal: Her bir bit için n bit gerekir ... (dikkat ettiniz mi? Çabuk, anlayın!) ... n ( n + 1) -th bit (iyi iş!) ileri çapraz:

  

• Geri çapraz: Burada iki şey var. İlk önce, geriye doğru diyagonal olup olmadığımızı nasıl bilebiliriz? Matematiksel olarak, koşul c = ( n - 1) - r'dir , bu da c = n + (- r - 1) ile aynıdır . Hey, bu sana bir şey hatırlatıyor mu? Bu doğru, ikisinin tamamlayıcısıdır, bu yüzden düşüş yerine bitsel olumsuzlamayı (Funciton'da çok verimli) kullanabiliriz. İkincisi, yukarıdaki formül en az anlamlı bitin ayarlanmasını istediğimizi varsayıyor, ancak geriye doğru diyagonalde bunu yapmıyoruz, bu yüzden onu yukarı kaydırmamız gerekiyor ... biliyor musunuz? ... Bu doğru, n ( n - 1).

  

  Bu, n = 1 ise potansiyel olarak 0'a bölündüğümüz tek yer bu . Ancak, Funciton umrunda değil. 0 ÷ 0 sadece 0'dır, bilmiyor musunuz?

Kodda, fonksiyon Җ(en alttaki) n'yi ve bir dizini alır (ondan r ve c'yi bölme ve geri kalanı ile hesaplar), bu dört değeri hesaplar ve orbunları birlikte s.

Kaba kuvvet algoritması

Kaba kuvvet algoritması Ӂ(üstteki işlev) tarafından uygulanır . O alır n (ızgara boyutu), endeksi (ızgara şu anda bir numara yerleştiriyoruz) ve alınan (ile sayı n bize hangi numaralar anlatan ³ bit biz her hücrede hâlâ yer).

Bu işlev bir dizi dizge döndürür. Her dize ızgaraya tam bir çözümdür. Bu tam bir çözücüdür; izin verirseniz tüm çözümleri iade eder, ancak tembel olarak değerlendirilmiş bir dizi olarak döndürür.

• Eğer endeks 0 ulaşmıştır biz boş bir dize içeren bir diziyi (tek çözüm olduğunu hücrelerin kapakları hiçbiri) dönmek böylece başarıyla, tüm ızgara doldurdum. Boş dize 0ve bunu ⌑tek elemanlı bir sıraya dönüştürmek için kütüphane işlevini kullanıyoruz .

• Aşağıda performans iyileştirmesi altında açıklanan kontrol burada gerçekleşir.

• Eğer endeks henüz 0 ulaşmadı biz şimdi bir numara yerleştirmek gerekir hangi indeksi (çağrı olsun 1 ile olarak azaltmak ix ).

  ♫0 - n - 1 arasındaki değerleri içeren tembel bir sekans oluşturmak için kullanıyoruz .

  Daha sonra ɓsırayla aşağıdakileri yapan lambda ile (monadik bağlama) kullanıyoruz :

  • İlgili biraz bakmak Önce alınan numara burada ya da değil geçerli olup olmadığına karar vermek. Biz bir numara yerleştirebilirsiniz i ancak ve ancak alınan & (1 << ( n × ix ) << i ) zaten ayarlı değil. Ayarlandıysa, geri dönün 0(boş sıralama).
  • ҖGeçerli satır, sütun ve köşegen (ler) e karşılık gelen bitleri hesaplamak için kullanın . Bunu Shift i ve daha sonra orda üzerine alınan .
  • Ardından Ӂkalan hücrelere ait tüm çözümleri geri almak için çağrısı yapın, yeni alınan ve azalan ix . Bu tamamlanmamış dizgelerin bir sırasını döndürür; Her dize, ix karakterlerine sahiptir ( ix dizinine kadar doldurulmuş ızgara ).
  • Kullanım ɱ(harita) thusly bulunan çözümlerin geçmesi ve kullanımı ‼bitiştirmek için i her sonuna. Eğer bir yeni satır ekleme endeksi bir katıdır n aksi bir alan.

Sonuç üretiliyor

Ana program n'yi çağırır Ӂ(kaba kırıcı) n , index = n ² (ızgarayı geriye doğru doldurduğumuzu unutmayın) ve alınmış = 0 (başlangıçta hiçbir şey alınmaz). Bunun sonucu boş bir sekanssa (çözüm bulunamadı), boş dizgeyi çıkartın. Aksi halde, dizideki ilk dizgiyi çıkar. Bunun, dizinin yalnızca ilk öğesini değerlendireceği anlamına geldiğine dikkat edin, bu nedenle çözücü tüm çözümleri bulana kadar devam etmiyor.

Performans iyileştirme

(Açıklamanın eski sürümünü zaten okuyanlar için: program artık çıktı için ayrı olarak bir dizgeye dönüştürülmesi gereken bir dizi dizisi oluşturmaz; sadece doğrudan bir dizi dizisi oluşturur. Açıklamayı buna göre düzenledim. (Ama bu ana gelişme değildi. İşte geliyor.)

Makinemde, ilk sürümün derlenmiş exe'si n = 7'yi çözmek için tam olarak 1 saat sürdü . Bu 10 dakikalık verilen süre içinde değildi, bu yüzden dinlenmedim. (Aslında, dinlenmeme sebebim, bunu nasıl büyük ölçüde hızlandıracağım konusunda fikrim vardı.)

Yukarıda tarif edilen algoritma, araştırmasını durdurur ve alınan numaradaki tüm bitlerin ayarlandığı bir hücreyle her karşılaştığında , bu hücreye hiçbir şey koyamayacağına işaret eder.

Bununla birlikte, algoritma, ızgarayı , tüm bu bitlerin ayarlandığı hücreye kadar doldurmaya devam edecektir . Doldurulmuş olan herhangi bir hücrede, en son doldurulmuş hücrelerin tümü zaten ayarlanmış en kısa sürede durursa , bu, hangi numaraları koyduğumuz önemli değildir, şebekenin geri kalanını asla çözemeyeceğimizi gösterir. o. Ancak, herhangi bir hücrenin n bitlerinin hepsine bakmadan ayarlanmış olup olmadığını nasıl etkili bir şekilde kontrol edersiniz ?

Hile alınan numaraya hücre başına tek bir bit ekleyerek başlar . Yukarıda gösterilenler yerine, şimdi şuna benziyor:

LSB                               (example n=5)
 ↓
 10000 0 00000 0 00000 0 00000 0 10000 0
 00000 0 10000 0 00000 0 00000 0 10000 0
 00000 0 00000 0 10000 0 00000 0 10000 0
 00000 0 00000 0 00000 0 10000 0 10000 0
 10000 0 10000 0 10000 0 10000 0 10000 0
                                       ↑
                                      MSB

N ³ yerine, şimdi bu sayıda n ² ( n + 1) bit var. Geçerli satırı / sütunu / köşegeni dolduran işlev buna göre değiştirildi (aslında, dürüst olmak gerekirse tamamen yeniden yazıldı). Bu işlev yine de hücre başına yalnızca n bit doldurur , bu nedenle eklediğimiz ekstra bit her zaman olacaktır 0.

Şimdi, hesaplamanın yarısında olduğumuzu 1, orta hücreye yeni yerleştirdiğimizi ve alınan sayının şöyle göründüğünü varsayalım:

                 current
LSB              column           (example n=5)
 ↓                 ↓
 11111 0 10010 0 01101 0 11100 0 11101 0
 00011 0 11110 0 01101 0 11101 0 11100 0
 11111 0 11110 0[11101 0]11100 0 11100 0    ← current row
 11111 0 11111 0 11111 0 11111 0 11111 0
 11111 0 11111 0 11111 0 11111 0 11111 0
                                       ↑
                                      MSB

Gördüğünüz gibi, üst sol hücre (dizin 0) ve orta sol hücre (dizin 10) şimdi imkansız. Bunu en verimli şekilde nasıl belirleriz?

Her hücrenin 0'ıncı bitinin ayarlandığı, ancak yalnızca geçerli dizine kadar olan bir sayı düşünün. Böyle bir sayının, bilinen formülü kullanarak hesaplanması kolaydır:

Bu iki sayıyı birlikte eklesek ne alırız?

LSB                                               LSB
 ↓                                                 ↓
 11111 0 10010 0 01101 0 11100 0 11101 0           10000 0 10000 0 10000 0 10000 0 10000 0        ╓───╖
 00011 0 11110 0 01101 0 11101 0 11100 0     ║     10000 0 10000 0 10000 0 10000 0 10000 0            ║
 11111 0 11110 0 11101 0 11100 0 11100 0  ═══╬═══  10000 0 10000 0 00000 0 00000 0 00000 0  ═════   ╓─╜
 11111 0 11111 0 11111 0 11111 0 11111 0     ║     00000 0 00000 0 00000 0 00000 0 00000 0  ═════   ╨
 11111 0 11111 0 11111 0 11111 0 11111 0           00000 0 00000 0 00000 0 00000 0 00000 0          o
                                       ↑                                                 ↑
                                      MSB                                               MSB

Sonuç:

             OMG
              ↓
        00000[1]01010 0 11101 0 00010 0 00011 0
        10011 0 00001 0 11101 0 00011 0 00010 0
═════   00000[1]00001 0 00011 0 11100 0 11100 0
═════   11111 0 11111 0 11111 0 11111 0 11111 0
        11111 0 11111 0 11111 0 11111 0 11111 0

Gördüğünüz gibi, ekleme eklediğimiz ekstra bitin üzerine taşar, ancak bu hücrenin tüm bitleri ayarlanmışsa! Bu nedenle, yapılacak tek şey bu bitleri gizlemek (yukarıdakiyle aynı formül, ancak << n ) ve sonucun 0 olup olmadığını kontrol etmektir.

00000[1]01010 0 11101 0 00010 0 00011 0    ╓╖    00000 1 00000 1 00000 1 00000 1 00000 1         ╓─╖ ╓───╖
10011 0 00001 0 11101 0 00011 0 00010 0   ╓╜╙╖   00000 1 00000 1 00000 1 00000 1 00000 1        ╓╜ ╙╖    ║
00000[1]00001 0 00011 0 11100 0 11100 0   ╙╥╥╜   00000 1 00000 1 00000 0 00000 0 00000 0  ═════ ║   ║  ╓─╜
11111 0 11111 0 11111 0 11111 0 11111 0   ╓╜╙╥╜  00000 0 00000 0 00000 0 00000 0 00000 0  ═════ ╙╖ ╓╜  ╨
11111 0 11111 0 11111 0 11111 0 11111 0   ╙──╨─  00000 0 00000 0 00000 0 00000 0 00000 0         ╙─╜   o

Sıfır değilse, ızgara imkansız ve durabiliriz.

• N = 4 - 7 arasındakiçözüm ve çalışma zamanını gösteren ekran görüntüsü .

Haskell, 790 * 0.80 = 632 bayt

import Data.List
import Control.Monad
import Data.Array
s r=let{h as bs=[(a,b)|a<-as,b<-bs];(&)m k=(\(Just x)->x)$lookup k m;j=Just;n=Nothing;c=[1..r];q=delete;u=h[1..r]c;o=[(s,[u |u<-[h[1..r][c]|c<-c]++[h[r]c|r<-[1..r]]++[zip[1..r][1..r],zip[1..r][r,r-1..1]],s`elem`u])|s<-u];k=foldr(>=>)j;a p d g0=k[t p d2|d2<-q d(g0!p)]g0;t p d g0|not(d`elem`(g0!p))=j g0|[]<-v=n|[d2]<-v=k[t s2 d2|s2<-[(s,delete s$nub(concat(o&s)))|s<-u]&p]g1|True=k[l[s|s<-u,not(d`elem`v)]|u<-o&p]g1 where{v=q d(g0!p);g1=g0//[(p,v)];l[]_=n;l[d3]g=a d3 d g;l _ r=j r};w g0|and[case g0!s of{[_]->True;_->False}|s<-u]=j g0|True=msum[a s' d g0>>=w|d<-g0!s']where(_,s')=minimumBy(\(a,_)(b,_)->compare a b)[(l,s)|s<-u,let v=g0!s;l=length v,l>1]}in fmap(fmap(\[x]->x))$w$array((1,1),(r,r))[((i,j),[1..r])|i<-[1..r],j<-[1..r]]

Bu sorunun sudokuya çok benzer olduğunu fark ettim. Python’daki diğeri üzerine Haskell’de yazdığım eski bir sudoku çözücüyü hatırlıyorum . Bu benim ilk kod golf posta veya girişimi.

O verdiği için bu bonusu yerine getirir Nothingiçin n=2,3ve Just <result>için n>=4nerede, <result>ayrılmaz bir değerler 2D dizisidir.

Çevrimiçi tercüman için buraya bakın . Bu kod aslında postadaki koddan daha uzundur çünkü çevrimiçi tercüman tam bir programı neyin oluşturduğuna dair daha katı şartlara sahiptir (kurallar bir gönderimin bir fonksiyon olabileceğini söylüyor). Bu gönderi bir fonksiyon argümanı olarak girdi alır.

Pyth, 41 bayt

#Km.SQQI.AmqQl{d+.TK.Tm,@@Kdd@@Kt-QddQB;K

#                                      ;   # while(True)
 Km.SQQ                                    # K = random QxQ 2d list
       I                               ;   # if ...
        .A                                 # all of...
          m                          Q     # map(range(Q))...
                +                          # concat
                 .TK                       # transpose K
                    .Tm,@@Kdd@@Kt-Qdd      # diagonals of K
                      m             d      # map(range(d))
                       ,                   # 2-elem list of...
                        @@Kdd              # K[n][n]
                             @@Kt-Qd       # and K[len(K)-n-1][n]
                    .T                     # transpose
           qQl{d                           # subarrays have no dups...
                                      B;   # ... then, break
                                        K  # output final result

Kaba kuvvet ftw!

Bu temelde işe yarayana kadar rastgele karıştırmaları denemeye devam ettiğinden (iyi, denemeye devam ediyor n * [shuffle(range(n))]), gerçekten, çok uzun bir zaman alıyor. İşte size testin ne kadar sürdüğü hakkında bir fikir vermek için:

llama@llama:~$ time echo 4 | pyth <(echo '#Km.SQQI.AmqQl{d+.TK.Tm,@@Kdd@@Kt-QddQB;K')               
[[2, 1, 0, 3], [0, 3, 2, 1], [3, 0, 1, 2], [1, 2, 3, 0]]
echo 4  0.00s user 0.00s system 0% cpu 0.001 total
pyth <(echo '#Km.SQQI.AmqQl{d+.TK.Tm,@@Kdd@@Kt-QddQB;K')  0.38s user 0.00s system 96% cpu 0.397 total

Bu sadece 4x4 ve yarım saniyenin biraz altında çalışıyor. Aslında hile yapıyorum çünkü bu birkaç denemenin en iyisidir - çoğu iki veya iki saniyeyi alır.

Henüz 5x5'te zamanlama ayarlamamıştım (bir kere tamamlanmaya başladı, ama bu bir REPL'deydi ve zamanlamadım).

Zaman sınırı kuralının yalnızca bu cevap gönderildikten sonra soruya eklendiğini unutmayın.

SWI-Prolog, 326 * 0.80 = 260.8 bayt

:-use_module(library(clpfd)).
a(N):-l(N,R),m(l(N),R),append(R,V),V ins 1..N,transpose(R,C),d(0,R,D),maplist(reverse,R,S),d(0,S,E),m(m(all_distinct),[R,C,[D,E]]),m(label,R),m(p,R).
l(L,M):-length(M,L).
d(X,[H|R],[A|Z]):-nth0(X,H,A),Y is X+1,(R=[],Z=R;d(Y,R,Z)).
p([H|T]):-write(H),T=[],nl;write(' '),p(T).
m(A,B):-maplist(A,B).

Düzenleme: @Mat sayesinde 16 bayt kaydedildi

kullanım

a(5).Tercümanınızı arayın N=5. Bu veya falseiçin döner .N=2N=3

CLPFD kütüphanesini kullandığından, bu saf kaba güç değildir. Bu program N=20bilgisayarımda yaklaşık 15 saniye içinde bir çözüm bulabilir .

Ungolfed + açıklamalar:

Bu temelde bir Sudoku çözücüsü gibi çalışır, ancak blok kısıtlamalarının köşegen kısıtlamaları ile değiştirilmesi gerekir.

:-use_module(library(clpfd)).      % Import Constraints library

a(N):-
    l(N,R),                        % R is a list of length N
    maplist(l(N),R),               % R contains sublists, each of length N
    append(R,V),                   
    V ins 1..N,                    % Each value in the matrix is between 1 and N
    maplist(all_distinct,R),       % Values must be different on each row
    transpose(R,C),
    maplist(all_distinct,C),       % Values must be different on each column
    d(0,R,D),
    maplist(reverse,R,S),          
    d(0,S,E),
    all_distinct(D),               % Values must be different on the diagonal
    all_distinct(E),               % Values must be different on the "anti"-diagonal
    maplist(label,R),              % Affects actual values to each element
    maplist(p,R).                  % Prints each row

l(L,M):-length(M,L).               % True if L is the length of M

d(X,[H|R],[A|Z]):-nth0(X,H,A),Y is X+1,(R=[],Z=R;d(Y,R,Z)). % True if the third argument is the diagonal of the second argument

p([H|T]):-write(H),T=[],nl;write(' '),p(T).  % Prints a row separated by spaces and followed by a new line

CJam, 87 bayt -% 20 bonus = 69,6 bayt

qi__"@I/l
ŤˏūȻ
܀ᅀ൹৽჈͚
㑢鴑慚菥洠㬝᚜
"N/=:i0+\,m!f=`1LL](4e<=

Cevapları zor kodlar. Bazı yazdırılamaz içerir. İçin çalışır N = 1aracılığıyla N = 8.

Temel olarak, bu gizemli dizedeki her satır, range(N)Unicode karakterleri olarak kodlanan , permütasyon listesine endeksler içerir .

=:i0+\,m!f=En alt satırı temsil eden ilk önce, endeks listesinin sonuna 0 ekleyerek, permütasyonlar listesine endeksler 0 1 2 ... N-1. Çünkü N < 4, ortaya çıkan 2D dizi saçmalıktır.

`1LL]bir liste oluşturur [N, pretty output, 1, "", ""]. Ardından (4e<=, bu listenin dışında ilk elemanını çıkar Nve alır min(N, 4) % 4o geri kalanından inci elemanı. Çünkü N >= 4çıktı bu, aksi halde ilk üç durum için özel durum çıktıları.

Burada dene .

C ++, 672 * 0.80 645 * 0.80 = 516 bayt

#include <iostream>
int **b,**x,**y,*d,*a,n;
#define R(i) for(i=0;i<n;i++){
#define E(e) e=new int[n];
int f(int c,int r) {int i=0,p=c-1;if(r>=n)return 1;if(c == n + 1)return f(1,r+1);R(i)int m=r==i,s=r+i==n-1;if(!b[r][i]&&!x[r][p]&&!(m&&d[p])&&!(s&&a[p])&&!y[i][p]){b[r][i]=c;x[r][p]=1;y[i][p]=1;if(m)d[p]=1;if(s)a[p]=1;if(f(c+1,r))return 1;b[r][i]=0;x[r][p]=0;y[i][p]=0;if(m)d[p]=0;if(s)a[p]=0;}}return 0;}
int main(){std::cin>>n;int i=0,j=0;b=new int*[n];x=new int*[n];y=new int*[n];E(d);E(a);R(i)E(b[i]);E(x[i]);E(y[i]); d[i]=0;a[i]=0;R(j)b[i][j]=0;x[i][j]=0;y[i][j]=0;}}if(f(1,0)){R(i)R(j)std::cout<<b[i][j];}std::cout<<std::endl;}}}

Burada çevrimiçi deneyin

Birkaç cevap zaten gönderildiğinden, örnekler için çıktıyı oluştururken kullandığım kodun golf versiyonunu yayınlayacağımı düşündüm. Bu benim ilk kez bir kod-golf yanıtlıyor , bu yüzden tüm geri bildirimler memnuniyetle karşılandı. :)

Ungolfed + açıklamalar:

Temel olarak, kod kaba bir çözümü zorluyor. İlk satırda 0 ile başlar. İlk noktada başlar, eğer lekeler tüm kontrolleri geçerse bir sonraki sayıya geçer. Satırı doldurursa, bir sonraki satıra geçer. Tüm satırlar yapıldıysa, bu bir çözüm bulunduğu anlamına gelir. Spot tüm kontrolleri geçemezse, bir sonraki noktaya geçer. Satır bittiyse, önceki satırlardan birindeki bir sayı bir çözümün mümkün olmasını engellediğinden, geri izler.

#include <iostream>

// global variables to save bytes on passing these are function arguments
int **b, // this will store the state of the board
    **x, // if x[i][j] is true, row i of b contains the number j
    **y, // if y[i][j] is true, column i of b contains the number j
    *d,  // if d[i] the main diagonal of b contains i
    *a,  // if a[i] the antidiagonal of a contains i
    n;

// preprocessor to save bytes on repeated statements
#define R(i) for(i=0;i<n;i++){
#define E(e) e=new int[n];

// Recursively looks for a solution 
// c - the current number to insert in row r
// r - the current row to fill
int f (int c, int r) {
        int i=0,p=c-1;
        if (r >= n) return 1;             // we are done
        if (c == n + 1) return f(1,r+1);  // this row is full, move to the next row
        R(i)                              // go through the positions in this row,
                                                                            // trying to fill them with c
                int m=r==i, s=r+i==n-1;   // check if this position (r,i) is on ones
                                                                            // of the diagonals
                // if this spot isn't filled, and the row (r), column (i) and diagonals
                // (if it's on the diagonal) doesn't contain the number, fill the spot
                if (!b[r][i] && !x[r][p] && !(m&&d[p]) && !(s&&a[p]) && !y[i][p]) {
                        // fill the spot, and indicate that this row, column and diagonals 
                        // contain this number, c
                        b[r][i]=c; x[r][p]=1; y[i][p]=1;
                        if (m) d[p]=1; if (s)a[p]=1;

                        // move onto to the next number, if you find a solution, stop
                        if (f(c+1,r)) return 1;

                        // with this number in this spot, a solution is impossible, clear
                        // its, and clear the checks
                        b[r][i]=0; x[r][p]=0; y[i][p]=0;
                        if (m) d[p]=0; if (s) a[p]=0;
                }
        }

        return 0; // a solution wasn't found
}

int main() {
        std::cin >> n; // get n from STDIN

        // initialization 
        int i=0,j=0;
        b=new int*[n]; x=new int*[n]; y=new int*[n];
        E(d); E(a);
        R(i)
                E(b[i]); E(x[i]); E(y[i]); // initialization the inner arrays of b, x, y
                d[i]=0; a[i]=0;

                R(j)
                        b[i][j]=0; x[i][j]=0; y[i][j]=0; // ensure each point is initialized as 0
                }
        }

        // find a solution starting at the top-left corner and print it if it finds one
        if (f(1,0)) {
                R(i)
                        R(j)
                                std::cout<<b[i][j];
                        }
                        std::cout<<std::endl;
                }
        }
}

Clojure, (215 + 258) * 0.8 = 378.4 (174 + 255) * 0.8 = 343.2

İki bölüme ayırın: hata sayma Sve gerçek optimizasyonu Tabu arama ile yapan isimsiz bir işlev .

Güncelleme: daha kısa S(gruplar içindeki farklı değerleri sayar), daha az optimal başlangıç ​​durumu (karışık değil).

(defn S[I n](count(mapcat set(vals(apply merge-with concat(flatten(for[R[(range n)]i R j R v[[(I(+(* n i)j))]]][{[1 i]v}{[2 j]v}(if(= i j){3 v})(if(=(- n 1 i)j){4 v})])))))))
#(if-let[s({1[0]2()3()}%)]s(loop[I(vec(for[R[(range %)]i R j R]i))P #{}](let[[s I](last(sort-by first(for[R[(range(count I))]i R j R I[(assoc(assoc I i(I j))j(I i))]:when(not(P I))][(S I %)I])))](if(=(*(+(* % 2)2)%)s)(partition % I)(recur I(conj P I))))))

4, 5, 6 ve 7 için tek çekirdekli benchmarklar (milisaniye olarak) 3 kez çalıştırılır:

[[  131.855337   132.96267    138.745981]
 [ 1069.187325  1071.189488  1077.339372]
 [ 9114.736987  9206.65368   9322.656693]
 [36546.309408 36836.567267 36928.346312]]

Orijinal:

(defn S[I n](apply +(flatten(for[p(concat(partition n I)(for[p(apply map vector(partition n(range(count I))))](map I p))[(take-nth(inc n)I)][(rest(butlast(take-nth(dec n)I)))])](remove #{1}(vals(frequencies p)))))))
#(if-let[s({1[0]2()3()}%)]s(loop[I(vec(flatten(map shuffle(repeat %(range %)))))P #{}](let[[s I](first(sort-by first(for[R[(range(count I))]i R j R I[(assoc(assoc I i(I j))j(I i))]:when(not(P I))][(S I %)I])))](if(= s 0)(partition % I)(recur I(conj P I))))))

Keşke Sdaha kısa olsaydı , ancak yalnızca birden fazla / bölümün oluşumunu sayarsa durma kriteri basittir (= s 0).

Eğer takas eğer puanı iyileştirmez örnek için birçok CPU döngüsü olmayan kullanışlı takası için boşa 2ile 2ve hepsi başlamak için ayrı değerlere sahip olarak satırlar arasındaki takas numaralara gerek yoktur.

Intel 6700K ile Karşılaştırmalar (milisaniye olarak):

(defn S[I n]( ... )
(def F #( ... ))

(defmacro mytime[expr]
  `(let [start# (. System (nanoTime)) ret# ~expr]
     (/ (double (- (. System (nanoTime)) start#)) 1000000.0)))

(pprint(vec(for[n[4 5 6 7]](vec(sort(repeatedly 5 #(mytime (F n)))))))

[[  43.445902   45.895107   47.277399   57.681634    62.594037]
 [ 222.964582  225.467034  240.532683  330.237721   593.686911]
 [2285.417473 2531.331068 3002.597908 6361.591714  8331.809410]
 [3569.62372  4779.062486 5725.905756 7444.941763 14120.796615]]

Okuyuculu pmap:

[[   8.881905  16.343714   18.87262  18.9717890   22.194430]
 [  90.963870 109.719332  163.00299  245.824443  385.365561]
 [ 355.872233 356.439256 1534.31059 2593.482767 3664.221550]
 [1307.727115 1554.00260 2068.35932 3626.878526 4029.543011]]