Son zamanlarda gerçekten garip bir satranç tahtası aldım. Kareler her yerde ve hatta bağlı değil. En azından hala düzenli bir ızgaraya yerleştirilmişler. Satranç kurallarını tahtada oynayabilmek için uyarlamak istiyorum, ancak başlangıçta tahtada herhangi bir yere gidebilecek bir parçaya ihtiyacım var ve bunun için en iyi bahse girerim.

Leapers , şövalyelerin peri satrancı genellemesidir. Leapers iki m ve n tamsayısı ile parametrelendirilir ve m karelerini bir yönde ve sonra başka bir n karesini her iki dikey yönde hareket ettirebilir . Standart şövalye için (m, n) = (2, 1) var . Tüm hareket, tek bir atlama olarak kabul edilir, böylece hedefe giden yoldaki karelerin hiçbiri boş veya hatta mevcut olmaz.

Meydan okuma

Size, tahtanın parçası olan kareleri temsil eden pozitif 2B tam sayı koordinatları listesi şeklinde bir "satranç tahtası" verilir. Göreviniz, yeterli hamle verildiğinde, tahtadaki herhangi bir kareye ulaşabilen bir leaper bulmaktır.

Bazı örneklere bakalım. Standart satranç tahtası 8x8 karelik düzenli bir ızgara kullanır (bu meydan okuma için beyaz ve siyah kareler arasında ayrım yapmadığımızı unutmayın):

########
########
########
########
########
########
########
########

Standart şövalye hepsine ulaşabilir, bu yüzden (2, 1)geçerli bir çıktı olacaktır. Ancak, (1, 1)örneğin geçerli olmaz, çünkü böyle bir parça nerede başlarsa başlasın karelerin yarısına ulaşabilir. (1, 0)Öte yandan, tüm kareler dikey olarak bağlandığından, geçerli bir çıktı da olacaktır.

Şimdi şöyle bir düzensiz kurulumuz varsa:

#   #
 # # #
  # # #
 # #
    #

O zaman olası çözümler (1, 1)ve (3, 1). Ayrıca tamamen bağlantısı kesilmiş bölgeleri olan bir tahtaya sahip olabiliriz:

#### ####
#### ####
#### ####
#### ####

Standart şövalye (2, 1), hala tek çözüm olan buradaki tüm karelere hala ulaşabilir.

Ve son olarak, aşağıdaki basit tahtaya herhangi bir hakem tarafından tamamen ulaşılamaz:

#
 ##

Giriş biçiminin bir ASCII temsili olarak değil bunun yerine koordinatların bir listesi olacağını unutmayın. Örneğin, yukarıdaki ikinci örnek şu şekilde verilebilir:

[[1, 1], [5, 1], [2, 2], [4, 2], [6, 2], [3, 3], [5, 3], [7, 3], [2, 4], [4, 4], [5, 5]]

kurallar

STDIN (veya en yakın alternatif), komut satırı bağımsız değişkeni veya işlev bağımsız değişkeni ile girdi alarak ve sonucu STDOUT (veya en yakın alternatif), işlev dönüş değeri veya işlev (çıkış) parametresi aracılığıyla çıktı alarak bir program veya işlev yazabilirsiniz.

Giriş koordinatları herhangi bir uygun liste formatında (düz liste, çift listesi, karmaşık tamsayıların listesi, tutarlı ayırıcılı dize, vb.) Alınabilir.

Çıktı, bir çözüm varsa, sıçramacıyı tanımlayan iki m ve n tamsayısı olmalıdır (iki ayrı tamsayı, bir liste, sayısal olmayan sınırlayıcıya sahip bir dize vb.). Herhangi bir çözüm yoksa, geçerli bir leaper olabilecek tutarlı bir değer çıktısı alabilirsiniz. Bu, (0, 0)normal biçiminizdeki tamsayı çiftinin yanı sıra negatif olmayan bir tam sayı olmayan bir çift içerir.

Programınızın test durumlarından herhangi birini bir dakika içinde ele alması gerekir . Bu biraz bulanık bir kısıtlamadır, ancak sağduyunuzu kullanın: makinenizde 2 dakika sürerse, başka birinin üzerinde 1 içinde çalışabileceğini varsayabiliriz, ancak 20 tane alırsa bu daha az olasıdır. Her bir test vakasını saniyeler içinde çözmek zor olmamalı, bu nedenle bu kural sadece saf kaba kuvvetin dışlanmasıdır.

Standart kod golf kuralları geçerlidir.

Test Durumları

Her test durumu formdadır board => all valid leapers. Bunlardan yalnızca birini vermeniz gerektiğini unutmayın. Sıçrama listesi boşsa, geçerli bir sıçramacı olmayan bir şey döndürdüğünüzden emin olun .

Examples above:
[[1, 1], [1, 2], [1, 3], [1, 4], [1, 5], [1, 6], [1, 7], [1, 8], [2, 1], [2, 2], [2, 3], [2, 4], [2, 5], [2, 6], [2, 7], [2, 8], [3, 1], [3, 2], [3, 3], [3, 4], [3, 5], [3, 6], [3, 7], [3, 8], [4, 1], [4, 2], [4, 3], [4, 4], [4, 5], [4, 6], [4, 7], [4, 8], [5, 1], [5, 2], [5, 3], [5, 4], [5, 5], [5, 6], [5, 7], [5, 8], [6, 1], [6, 2], [6, 3], [6, 4], [6, 5], [6, 6], [6, 7], [6, 8], [7, 1], [7, 2], [7, 3], [7, 4], [7, 5], [7, 6], [7, 7], [7, 8], [8, 1], [8, 2], [8, 3], [8, 4], [8, 5], [8, 6], [8, 7], [8, 8]] => [[0, 1], [1, 2], [1, 4], [2, 3], [3, 4]]
[[1, 1], [5, 1], [2, 2], [4, 2], [6, 2], [3, 3], [5, 3], [7, 3], [2, 4], [4, 4], [5, 5]] => [[1, 1], [1, 3]]
[[1, 1], [2, 2], [3, 2]] => []
[[1, 1], [1, 2], [1, 3], [1, 4], [2, 1], [2, 2], [2, 3], [2, 4], [3, 1], [3, 2], [3, 3], [3, 4], [4, 1], [4, 2], [4, 3], [4, 4], [6, 1], [6, 2], [6, 3], [6, 4], [7, 1], [7, 2], [7, 3], [7, 4], [8, 1], [8, 2], [8, 3], [8, 4], [9, 1], [9, 2], [9, 3], [9, 4]] => [[1, 2]]

Square boards:
[[1, 1], [1, 2], [2, 1], [2, 2]] => [[0, 1]]
[[1, 1], [1, 2], [1, 3], [2, 1], [2, 2], [2, 3], [3, 1], [3, 2], [3, 3]] => [[0, 1]]
[[1, 1], [1, 2], [1, 3], [1, 4], [2, 1], [2, 2], [2, 3], [2, 4], [3, 1], [3, 2], [3, 3], [3, 4], [4, 1], [4, 2], [4, 3], [4, 4]] => [[0, 1], [1, 2]]
[[1, 1], [1, 2], [1, 3], [1, 4], [1, 5], [2, 1], [2, 2], [2, 3], [2, 4], [2, 5], [3, 1], [3, 2], [3, 3], [3, 4], [3, 5], [4, 1], [4, 2], [4, 3], [4, 4], [4, 5], [5, 1], [5, 2], [5, 3], [5, 4], [5, 5]] => [[0, 1], [1, 2]]
[[1, 1], [1, 2], [1, 3], [1, 4], [1, 5], [1, 6], [2, 1], [2, 2], [2, 3], [2, 4], [2, 5], [2, 6], [3, 1], [3, 2], [3, 3], [3, 4], [3, 5], [3, 6], [4, 1], [4, 2], [4, 3], [4, 4], [4, 5], [4, 6], [5, 1], [5, 2], [5, 3], [5, 4], [5, 5], [5, 6], [6, 1], [6, 2], [6, 3], [6, 4], [6, 5], [6, 6]] => [[0, 1], [1, 2], [2, 3]]
[[1, 1], [1, 2], [1, 3], [1, 4], [1, 5], [1, 6], [1, 7], [2, 1], [2, 2], [2, 3], [2, 4], [2, 5], [2, 6], [2, 7], [3, 1], [3, 2], [3, 3], [3, 4], [3, 5], [3, 6], [3, 7], [4, 1], [4, 2], [4, 3], [4, 4], [4, 5], [4, 6], [4, 7], [5, 1], [5, 2], [5, 3], [5, 4], [5, 5], [5, 6], [5, 7], [6, 1], [6, 2], [6, 3], [6, 4], [6, 5], [6, 6], [6, 7], [7, 1], [7, 2], [7, 3], [7, 4], [7, 5], [7, 6], [7, 7]] => [[0, 1], [1, 2], [2, 3]]

Miscellaneous:
[[1, 1], [2, 1]] => [[0, 1]]
[[1, 1], [1, 2]] => [[0, 1]]
[[1, 1], [12, 35]] => [[11, 34]]
[[1, 1], [1, 2], [2, 1], [2, 2], [6, 1], [6, 2], [6, 3], [6, 4], [7, 1], [7, 2], [7, 3], [7, 4], [8, 1], [8, 2], [8, 3], [8, 4], [9, 1], [9, 2], [9, 3], [9, 4]] => []
[[1, 1], [1, 2], [1, 3], [1, 4], [1, 5], [1, 6], [2, 1], [2, 2], [2, 3], [2, 4], [2, 5], [2, 6], [3, 1], [3, 2], [3, 5], [3, 6], [4, 1], [4, 2], [4, 5], [4, 6], [5, 1], [5, 2], [5, 3], [5, 4], [5, 5], [5, 6], [6, 1], [6, 2], [6, 3], [6, 4], [6, 5], [6, 6]] => [[0, 1], [1, 2], [1, 4]]
[[2, 2], [2, 4], [2, 6], [2, 8], [4, 2], [4, 4], [4, 6], [4, 8], [6, 2], [6, 4], [6, 6], [6, 8], [8, 2], [8, 4], [8, 6], [8, 8]] => [[0, 2], [2, 4]]

Random boards:
[[1, 5], [1, 9], [2, 6], [2, 8], [2, 10], [2, 12], [3, 5], [3, 7], [3, 9], [3, 11], [3, 13], [4, 2], [4, 4], [4, 6], [4, 8], [4, 14], [5, 1], [5, 3], [5, 5], [5, 7], [6, 2], [6, 4], [7, 1], [8, 2]] => [[1, 1], [1, 3]]
[[1, 3], [1, 4], [1, 5], [1, 6], [1, 7], [2, 1], [2, 2], [2, 3], [2, 4], [2, 7], [3, 1], [3, 2], [3, 3], [3, 4], [3, 6], [3, 7], [4, 2], [4, 3], [4, 4], [4, 5], [4, 6], [5, 3], [5, 4], [5, 6]] => [[0, 1], [1, 2]]
[[1, 8], [2, 6], [2, 10], [3, 3], [3, 4], [3, 8], [4, 1], [4, 11], [5, 3], [5, 9], [6, 12], [8, 11], [10, 10], [11, 12], [12, 6], [12, 8], [13, 6], [13, 8], [13, 10], [13, 11], [14, 5], [14, 7], [14, 8], [14, 13], [14, 14], [15, 7], [15, 9], [15, 11], [15, 12], [16, 6], [16, 7], [16, 9], [16, 13], [16, 14], [17, 10], [17, 12], [18, 8], [18, 12], [20, 9], [21, 11], [22, 13], [23, 10], [23, 11], [23, 15], [24, 12]] => [[1, 2]]
[[1, 17], [1, 21], [3, 11], [3, 15], [3, 19], [3, 23], [5, 13], [5, 21], [7, 11], [7, 15], [7, 19], [9, 1], [9, 13], [9, 17], [11, 3], [11, 7], [11, 15], [11, 19], [13, 5], [13, 9], [13, 13], [13, 17], [13, 21], [15, 11], [15, 15], [15, 19], [17, 13], [17, 17]] => [[2, 2], [2, 6], [2, 10]]
[[1, 3], [2, 4], [2, 5], [3, 6], [4, 1], [5, 3], [5, 6], [5, 7], [6, 12], [6, 14], [6, 21], [7, 9], [7, 19], [8, 9], [8, 15], [8, 17], [8, 18], [8, 24], [9, 12], [9, 19], [10, 12], [10, 14], [10, 17], [10, 21], [11, 22], [12, 15], [12, 17], [12, 24], [13, 16], [14, 20], [14, 21], [14, 26], [15, 13], [15, 19], [16, 18], [16, 23], [17, 16], [17, 24]] => [[2, 3]]
[[1, 11], [3, 13], [4, 10], [6, 14], [8, 12], [9, 9], [9, 15], [12, 8], [13, 5], [13, 19], [13, 21], [14, 8], [15, 1], [15, 17], [16, 4], [16, 14], [16, 18], [16, 20], [17, 21], [18, 2], [18, 16], [18, 18], [19, 9], [19, 13], [19, 15], [20, 12], [21, 1], [21, 17], [22, 4], [22, 10], [23, 7]] => [[1, 3]]
[[1, 39], [6, 37], [8, 32], [10, 27], [11, 31], [11, 35], [12, 22], [16, 21], [16, 29], [16, 33], [18, 34], [21, 3], [21, 9], [21, 19], [23, 8], [23, 14], [23, 22], [23, 24], [23, 36], [24, 6], [25, 13], [25, 17], [26, 1], [26, 11], [28, 6], [28, 20], [28, 26], [28, 30], [28, 34], [30, 11], [30, 15], [30, 21], [32, 6], [33, 28], [33, 32], [35, 13], [35, 23]] => [[2, 5]]

Özel bir durum olarak, sadece bir hücreden oluşan bir kart için herhangi bir leaper'ın çalıştığını, ancak çıktınızın gerçek bir leaper'a karşılık gelmesi gerektiğini unutmayın, bu nedenle [0, 0]geçerli çıktı değildir.

Pyth, 41 35

hfqQu@+G+VM*s_BM*F_BMTGQ]hQ)maVhQdt

Geçerli leaper yoksa hatadan çıkar ve STDERR yoksayılırsa boş dize verir.

Buradan deneyin veya Test Paketi çalıştırın

İsaacg sayesinde 6 bayt tasarruf edildi ! Temel olarak sadece tüm karo adaylarını ilk karodan birbirlerine karoya kadar geçerli her bir kaçağı seçerek bulur. Daha sonra bunların her biri için [x, y], leaper'ın alabileceği sekiz ofset konfigürasyonunun tümünü yapar . Daha sonra, hareketten sonra gelen ilk döşemeden başlayarak tüm hareketleri bulur ve girdide olmayanları atar. Sonuç değişmeyene kadar bunu yapmaya devam eder. Bu son liste giriş ile aynı ise, birleştirici geçerliydi.

Standart satranç tahtası test yaparken en uzun sürdü, çok etkileyici olmayan bilgisayarımda yaklaşık 3 saniye sürdü.