Saya baru-baru ini mendapat papan catur tidak teratur yang sangat aneh. Kotak itu ada di semua tempat dan bahkan tidak semuanya terhubung. Setidaknya mereka masih ditata di grid biasa. Saya ingin mengadaptasi aturan catur agar dapat bermain di papan, tetapi untuk memulainya, saya membutuhkan bagian yang benar-benar bisa pergi ke mana saja di papan, dan sepertinya leaper adalah taruhan terbaik saya untuk itu.

Leapers adalah generalisasi catur para ksatria. Leapers yang parameterised oleh dua bilangan bulat m dan n dan dapat bergerak m kuadrat dalam satu arah dan kemudian lain n kotak di kedua arah tegak lurus. Untuk knight standar, kita memiliki (m, n) = (2, 1) . Seluruh langkah dianggap lompatan tunggal sehingga tidak ada kotak dalam perjalanan ke target harus kosong atau bahkan ada.

Tantangan

Anda diberikan "papan catur" dalam bentuk daftar koordinat bilangan bulat positif 2D yang mewakili kotak yang merupakan bagian dari papan. Tugas Anda adalah untuk menemukan leaper yang, dengan gerakan yang cukup, dapat mencapai kotak mana pun di papan tulis.

Mari kita lihat beberapa contoh. Papan catur standar menggunakan kotak biasa 8x8 kotak (perhatikan bahwa kami tidak membedakan antara kotak putih dan hitam untuk tantangan ini):

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

Knight standar bisa mencapai semua itu, jadi itu (2, 1)akan menjadi output yang valid. Namun, (1, 1)misalnya tidak akan valid, karena bidak seperti itu hanya dapat mencapai setengah dari kotak di mana pun itu dimulai. (1, 0)di sisi lain juga akan menjadi output yang valid, karena semua kotak terhubung secara orthogonal.

Sekarang jika kita memiliki papan tidak teratur seperti:

#   #
 # # #
  # # #
 # #
    #

Maka solusi yang mungkin adalah (1, 1)dan (3, 1). Kami juga dapat memiliki papan dengan daerah yang benar-benar terputus seperti:

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

Ksatria standar (2, 1)masih bisa mencapai semua kotak di sini, yang sebenarnya satu-satunya solusi.

Dan akhirnya, papan sederhana berikut ini tidak dapat sepenuhnya dijangkau oleh leaper sama sekali:

#
 ##

Perhatikan bahwa format input tidak akan menjadi representasi ASCII tetapi daftar koordinat sebagai gantinya. Misalnya contoh kedua di atas dapat diberikan sebagai:

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

Aturan

Anda dapat menulis sebuah program atau fungsi, mengambil input melalui STDIN (atau alternatif terdekat), argumen baris perintah atau argumen fungsi dan mengeluarkan hasilnya melalui STDOUT (atau alternatif terdekat), nilai pengembalian fungsi atau parameter function (out).

Koordinat input dapat diambil dalam format daftar yang mudah digunakan (daftar datar, daftar pasangan, daftar bilangan bulat kompleks, string dengan pemisah yang konsisten, dll.).

Output harus berupa dua bilangan bulat m dan n yang mengidentifikasi leaper jika ada solusi (sebagai dua bilangan bulat terpisah, daftar, string dengan pembatas non-numerik, dll.). Jika tidak ada solusi, Anda dapat menampilkan nilai konsisten apa pun yang tidak mungkin menjadi leaper yang valid. Ini termasuk sepasang bilangan bulat (0, 0)dalam format normal Anda, serta apa pun yang bukan pasangan bilangan bulat non-negatif.

Program Anda perlu menangani semua kasus uji dalam satu menit . Ini adalah pembatasan yang agak kabur, tetapi gunakan akal sehat: jika butuh 2 menit pada mesin Anda, saya pikir kita bisa berasumsi bahwa itu mungkin berjalan dalam 1 pada orang lain, tetapi jika dibutuhkan 20 itu kurang mungkin. Seharusnya tidak sulit untuk menyelesaikan setiap kasus uji dalam hitungan detik, jadi aturan ini hanya bertindak untuk menyingkirkan kekuatan kasar yang naif.

Aturan standar kode-golf berlaku.

Uji Kasus

Setiap test case berbentuk formulir board => all valid leapers. Ingatlah bahwa Anda hanya perlu menampilkan salah satunya. Jika daftar leaper kosong, pastikan untuk mengembalikan sesuatu yang bukan leaper yang valid.

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]]

Sebagai kasus khusus, perhatikan bahwa untuk papan yang hanya terdiri dari satu sel, setiap leaper berfungsi, tetapi output Anda harus sesuai dengan leaper yang sebenarnya, jadi [0, 0]ini bukan output yang valid.

Pyth, 41 35

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

Keluar dari kesalahan jika tidak ada leaper yang valid, memberikan string kosong jika STDERR diabaikan.

Cobalah di sini atau jalankan Test Suite

Disimpan 6 byte berkat isaacg ! Pada dasarnya hanya menemukan semua kandidat leaper dengan memilih setiap leaper yang valid dari ubin pertama ke ubin lainnya. Kemudian untuk masing-masing, ini membuat delapan konfigurasi [x, y]offset yang bisa diambil oleh leaper. Itu kemudian menemukan semua gerakan mulai dari ubin pertama yang mengikuti setelah pindah, dan membuang yang tidak ada dalam input. Itu terus melakukan ini sampai hasilnya tidak berubah. Jika daftar akhir ini sama dengan input maka leaper itu valid.

Papan catur standar memakan waktu paling lama ketika saya menguji, butuh sekitar 3 detik pada komputer saya yang tidak terlalu mengesankan.