Baru-baru ini, saya diperkenalkan dengan permainan puzzle yang dikenal sebagai Catur Solitaire . Saya akan meringkas aturan di sini:
- Papan adalah kotak-kotak 4x4.
- Semua bagian memiliki warna yang sama (tidak ada tim) dan semua bagian dapat menangkap bagian lainnya.
- Setiap gerakan harus menjadi tangkapan. Tidak ada pindah ke kotak kosong.
- Pasti ada satu bagian tersisa di akhir.
- Semua potongan bergerak persis seperti yang mereka lakukan dalam catur, dengan satu modifikasi: pion dapat menangkap dalam arah diagonal apa pun (yang secara teknis membuatnya menjadi ferz ). Demi kepentingan mereka yang mungkin tidak tahu, saya telah memasukkan diagram gerakan.
- Tidak satu pun dari aturan catur lainnya (seperti cek, pemerasan, dll.) Berlaku di sini. Ini semua tentang penangkapan.
Raja (k)
K * . . | * K * . | * * * .
* * . . | * * * . | * K * .
. . . . | . . . . | * * * .
. . . . | . . . . | . . . .
Ratu (q)
Q * * * | * Q * * | * * * .
* * . . | * * * . | * Q * *
* . * . | . * . * | * * * .
* . . * | . * . . | . * . *
Benteng (R)
R * * * | * R * * | . * . .
* . . . | . * . . | * R * *
* . . . | . * . . | . * . .
* . . . | . * . . | . * . .
Uskup (B)
B . . . | . B . . | * . * .
. * . . | * . * . | . B . .
. . * . | . . . * | * . * .
. . . * | . . . . | . . . *
Knight (N)
N . . . | . N . . | . . . *
. . * . | . . . * | . N . .
. * . . | * . * . | . . . *
. . . . | . . . . | * . * .
Gadai (P)
P . . . | . P . . | * . * .
. * . . | * . * . | . P . .
. . . . | . . . . | * . * .
. . . . | . . . . | . . . .
Input output
Untuk referensi, puzzle sampel dari halaman web Catur Solitaire akan digunakan:
. . . .
. B . .
R P . .
. . . N
Solusinya adalah mengambil pion dengan ksatria, kemudian mengambil ksatria dengan benteng, dan akhirnya membawa uskup dengan benteng.
Memasukkan
Masukan harus dalam satu dari tiga bentuk; Anda bebas memilih yang paling nyaman untuk Anda.
- String karakter seperti
.....B..RP.....N
, dengan atau tanpa baris baru. Karakter yang mewakili ruang kosong dapat berupa karakter apa pun yang bukan salah satunyaKQRBNP
. - Daftar daftar (atau daftar yang diratakan) di mana elemen-elemennya adalah karakter atau angka, seperti:
[['.', '.', '.', '.'], ['.', 'B', '.', '.'], ['R', 'P', '.', '.'], ['.', '.', '.', 'N']]
atau[[0, 0, 0, 0], [0, 4, 0, 0], [3, 6, 0, 0], [0, 0, 0, 5]]
. Untuk yang pertama, karakter yang mewakili ruang kosong mungkin adalah sesuatu yang bukan salah satunyaKQRBNP
. Untuk yang terakhir, saya telah memberikan potongan nomor yang sesuai dengan pangkat mereka dalam daftar langkah saya sebelumnya (1
adalah seorang raja,4
adalah seorang uskup,6
adalah pion, dll). Anda bebas mengubah penomorannya. - Sebuah daftar koordinat di mana setiap elemen memiliki bentuk
[x, y, 'c']
, seperti jadi:[[1, 2, 'B'], [0, 1, 'R'], [1, 1, 'P'], [3, 0, 'N']]
.
Jika Anda memilih salah satu format input berbasis daftar, pemisah dan pembatas dapat berupa karakter yang masuk akal dan dapat dipahami.
Keluaran
Output harus berupa urutan gerakan atau urutan status papan. Beberapa teka-teki memiliki lebih dari satu solusi; Anda dapat menampilkan satu atau semuanya. Jika Anda memilih untuk menampilkan urutan status papan, setiap papan harus dalam salah satu dari tiga format input, dengan pemisah yang masuk akal (seperti baris baru) di antaranya.
Jika Anda memilih untuk output urutan bergerak, mereka harus dinyatakan sebagai daftar pasangan koordinat pasangan, seperti: [[[3,0], [1,1]], [[0,1], [1,1]], [[1,1], [1,2]]]
.[0,0]
mewakili sudut kiri bawah, dan sekali lagi, memisahkan dan membatasi karakter mungkin merupakan pilihan yang masuk akal.
Jika papan yang diberikan tidak dapat dipecahkan, output nilai falsy (0
, string kosong, dll.). Jika papan yang diberikan memiliki kurang dari dua potong, perilaku tidak ditentukan.
Uji Kasus
Catatan: output hanya diberikan sebagai daftar pasangan koordinat karena format lain seharusnya cukup mudah untuk memeriksa kebenarannya (dan saya tidak merasa ingin mengetik semua format output yang mungkin). Juga, untuk teka-teki yang memiliki lebih dari satu solusi, hanya satu kemungkinan yang disediakan.
Input 1:
. . . N
. . . .
. R . .
. . B .
...N.....R....B.
[['.', '.', '.', 'N'], ['.', '.', '.', '.'], ['.', 'R', '.', '.'], ['.', '.', 'B', '.']]
[[0, 0, 0, 5], [0, 0, 0, 0], [0, 3, 0, 0], [0, 0, 4, 0]]
[[3, 3, 'N'], [1, 1, 'R'], [2, 0, 'B']]
Output 1:
[[[2,0], [1,1]], [[1,1], [3,3]]]
Input 2:
. . . .
. B . .
R P . .
. . . N
.....B..RP.....N
[['.', '.', '.', '.'], ['.', 'B', '.', '.'], ['R', 'P', '.', '.'], ['.', '.', '.', 'N']]
[[0, 0, 0, 0], [0, 4, 0, 0], [3, 6, 0, 0], [0, 0, 0, 5]]
[[1, 2, 'B'], [0, 1, 'R'], [1, 1, 'P'], [3, 0, 'N']]
Output 2:
[[[3,0], [1,1]], [[0,1], [1,1]], [[1,1], [1,2]]]
Input 3:
. N R .
B . . .
N . . B
. . P .
.NR.B...N..B..P.
[['.', 'N', 'R', '.'], ['B', '.', '.', '.'], ['N', '.', '.', 'B'], ['.', '.', 'P', '.']]
[[0, 5, 3, 0], [4, 0, 0, 0], [5, 0, 0, 4], [0, 0, 6, 0]]
[[1, 3, 'N'], [2, 3, 'R'], [0, 2, 'B'], [0, 1, 'N'], [3, 1, 'B'], [2, 0, 'P']]
Output 3:
[[[2,0], [3,1]], [[0,1], [1,3]], [[0,2], [1,3]], [[2,3], [1,3]], [[3,1], [1,3]]]
Input 4:
. . . N
. . . R
R B B .
N P P .
...N...RRBB.NPP.
[['.', '.', '.', 'N'], ['.', '.', '.', 'R'], ['R', 'B', 'B', '.'], ['N', 'P', 'P', '.']]
[[0, 0, 0, 5], [0, 0, 0, 3], [3, 4, 4, 0], [5, 6, 6, 0]]
[[3, 3, 'N'], [3, 2, 'R'], [0, 1, 'R'], [1, 1, 'B'], [2, 1, 'B'], [0, 0, 'N'], [1, 0, 'P'], [2, 0, 'P']]
Output 4:
[[[2,1], [3,2]], [[1,1], [3,3]], [[3,2], [1,0]], [[3,3], [0,0]], [[0,1], [0,0]], [[0,0], [1,0]], [[1,0], [2,0]]]
Input 5:
P . . .
. R . .
R . R .
. R . .
P....R..R.R..R..
[['P', '.', '.', '.'], ['.', 'R', '.', '.'], ['R', '.', 'R', '.'], ['.', 'R', '.', '.']]
[[6, 0, 0, 0], [0, 3, 0, 0], [3, 0, 3, 0], [0, 3, 0, 0]]
[[0, 3, 'P'], [1, 2, 'R'], [0, 1, 'R'], [2, 1, 'R'], [1, 0, 'R']]
Output 5:
[[[0,3], [1,2]], [[1,2], [2,1]], [[2,1], [1,0]], [[1,0], [0,1]]]
Input 6:
. P . N
K . . .
. . B .
. . R Q
.P.NK.....B...RQ
[['.', 'P', '.', 'N'], ['K', '.', '.', '.'], ['.', '.', 'B', '.'], ['.', '.', 'R', 'Q']]
[[0, 6, 0, 5], [1, 0, 0, 0], [0, 0, 4, 0], [0, 0, 3, 2]]
[[1, 3, 'P'], [3, 3, 'N'], [0, 2, 'K'], [2, 1, 'B'], [2, 0, 'R'], [3, 0, 'Q']]
Output 6:
[[[3,0], [2,0]], [[2,0], [2,1]], [[3,3], [2,1]], [[2,1], [1,3]], [[0,2], [1,3]]]
[["R", [2, 0], [1, 1]], ["N", [1, 1], [3, 3]]]
Jawaban:
Haskell,
226195191188 byteMengembalikan daftar semua solusi. Setiap solusi adalah daftar langkah. Mengembalikan daftar kosong jika tidak ada solusi.
Disimpan 4 byte, Berkat Lynn.
Cobalah online
Pemakaian:
Keluaran:
sumber
!
menghemat beberapa byte:f l=[(i,j):r|(i@(s,t),a)<-l,(j@(u,v),_)<-l%i,r<-f$(j,a):l%i%j,(s-u)^2+(t-v)^2`elem`m a]
[[((2,0),(1,1)),((1,1),(3,3))]]
. Daftar solusi, di mana solusi adalah daftar gerakan, di mana suatu langkah berada((x1,y1),(x2,y2))
.m"P"=[1]
Bukankah seharusnya 2?Javascript (ES6),
372361358 byteItu (masih) perlu beberapa optimasi. Tapi di sini adalah
pertama23 upaya.Format output:
Contoh:
sumber