Rahasia “>” Stacking Challenge: penilaian
Latar Belakang
Tetris Grand Master 3 memiliki sistem penilaian tersembunyi berdasarkan bentuk tumpukan di akhir permainan, yang disebut Rahasia ">" Tantangan Susun . Ini terdiri dari sepenuhnya mengisi baris terendah kecuali untuk pola zigzag yang dimulai dari sel kiri bawah dan mencakup seluruh lebar:
#
.#########
#.########
##.#######
###.######
####.#####
#####.####
######.###
#######.##
########.#
#########.
########.#
#######.##
######.###
#####.####
####.#####
###.######
##.#######
#.########
.#########
Papan dinilai berdasarkan berapa banyak garis yang mengikuti pola yang tepat ini dari garis bawah. Perhatikan bahwa lubang paling atas pada pola harus diblokir oleh potongan balok tambahan. Jika Anda menganggap #s dan .s sebagai pola wajib (kosong bisa apa saja), Anda bisa mendapatkan skor 19 hanya jika pola yang tepat di atas cocok dari garis bawah. Secara analogi, jika papan cocok dengan pola ini
#
###.######
##.#######
#.########
.#########
tapi tidak
#
####.#####
###.######
##.#######
#.########
.#########
maka skornya adalah 4.
Untuk tantangan ini, pertimbangkan papan dengan ukuran sembarang (selain tinggi 20 sel dan lebar 10 sel). Kita dapat menilai papan untuk pola yang sama: misalnya, jika papan memiliki lebar 4, inilah pola untuk nilai 3:
#
##.#
#.##
.###
dan ini pola skor 10:
#
###.
##.#
#.##
.###
#.##
##.#
###.
##.#
#.##
.###
Tantangan
Mengingat keadaan akhir papan Tetris dengan ukuran yang berubah-ubah, nilai papan menggunakan sistem di atas.
Anda dapat menggunakan papan menggunakan format apa pun yang masuk akal untuk matriks persegi panjang, di mana setiap sel berisi salah satu dari dua nilai berbeda (masing-masing untuk kosong dan terisi). Anda dapat menganggap grid tersebut adalah papan Tetris yang valid (tidak ada baris yang terisi penuh). Juga, lebar bingkai minimal 2.
Aturan standar kode-golf berlaku. Kode terpendek dalam byte menang.
Kasus uji
Untuk mencegah kemungkinan kebingungan, kasus pengujian di sini digunakan Ountuk blok dan .ruang kosong.
Input:
..O.O
OOOO.
OOO..
OO.OO
O.OOO
.OOOO
Output: 3
Input:
..
O.
.O
.O
O.
.O
O.
.O
Output: 4
Input:
.OOO
O.OO
OO.O
OO.O
OO.O
O.OO
.OOO
Output: 2 (any lines above the first non-conforming line are ignored;
doesn't get 3 because 3rd line's hole is not capped)
Input:
OOO.
.OOO
O.OO
OO.O
OOO.
OO.O
O.OO
Output: 0 (Wrong starting hole)
Input:
.OOO
O.OO
OO.O
OOO.
Output: 0 (Wrong starting hole)
Input:
.OOO
.OOO
Output: 0 (Hole is not covered)
Input:
OOO...O..O
.OOOOOOOOO
O.OOOOOOOO
OO.OOOOOOO
OOO.OOOOOO
OOOO.OOOOO
OOOOO.OOOO
OOOOOO.OOO
OOOOOOO.OO
OOOOOOOO.O
OOOOOOOOO.
OOOOOOOO.O
OOOOOOO.OO
OOOOOO.OOO
OOOOO.OOOO
OOOO.OOOOO
OOO.OOOOOO
OO.OOOOOOO
O.OOOOOOOO
.OOOOOOOOO
Output: 19
Jawaban
JavaScript (ES6), 84 byte
Mengharapkan daftar string, dengan 1untuk ruang kosong dan 0untuk blok.
f=(a,i=j=1<<a[k=0].length)=>(v='0b'+a.pop()+0)^i?v&i/k&&-1:1+f(a,i*=k=i&j?.5:i&2||k)
Cobalah secara online!
Bagaimana?
Setiap string dalam larik input diisi dengan ekstra 0dan ditafsirkan sebagai bilangan biner. Variabel jdiinisialisasi ke 2**W, di mana Wlebar papan. Kami menggunakan sedikit mask yang idiinisialisasi untuk jmelacak posisi lubang yang diharapkan dalam pola.
Setelah setiap iterasi, idikalikan dengan k. Kami memperbarui nilai kkapan pun (i & j) != 0(memantul di sisi paling kiri) atau (i & 2) != 0(memantul di sisi paling kanan).
Contoh untuk W = 5:
j = 0b100000
i = 0b100000 // -> set k to 1/2
i = 0b010000 // \
i = 0b001000 // }-> leave k unchanged
i = 0b000100 // /
i = 0b000010 // -> set k to 2
i = 0b000100 // \
i = 0b001000 // }-> leave k unchanged
i = 0b010000 // /
i = 0b100000 // -> set k to 1/2
...
Berkomentar
f = ( // f is a recursive function taking:
a, // a[] = input array
i = j = // i = hole bit mask, initialized to ...
1 << a[k = 0] // ... j = 2 ** W, where W is the width of the board
.length // k = bit mask multiplier, initialized to 0
) => //
( v = // pop the last value from a[], append a '0' and interpret
'0b' + a.pop() + 0 // it as a binary number saved in v
) ^ i ? // if v is not equal to i:
v & i / k // use the previous bit mask i / k to test whether there's
&& -1 // a hole in v above the last hole of the pattern, in
// which case we subtract 1 from the final result
: // else:
1 + // add 1 to the final result
f( // do a recursive call:
a, // pass a[] unchanged
i *= // multiply i by:
k = // the new value of k:
i & j ? // if we've reached the leftmost side:
.5 // set k to 1/2
: // else:
i & 2 // set k to 2 if we've reached the rightmost side,
|| k // or leave k unchanged otherwise
) // end of recursive call
Husk , 18 byte
Lδ↑€…¢ŀT¹↑εΨ↑-↔m¥0
Cobalah secara online!
Membutuhkan matriks 0-1.
Penjelasan
Ada tiga kejadian ↑dalam program ini, dan semuanya bekerja secara berbeda berkat fungsi pengubah δdan Ψ. Secara default, ↑αmengharapkan αuntuk menjadi fungsi unary, mengambil daftar dan mengembalikan awalan elemen terpanjang yang αmengembalikan nilai kebenaran. Ψ↑αmengharapkan αmenjadi biner, dan mengembalikan awalan elemen terpanjang xyang α x ybenar, di mana yelemen berikutnya. δ↑αmengharapkan αuntuk menjadi biner dan mengambil dua daftar, bukan satu. Ini mengembalikan awalan terpanjang dari daftar kedua yang elemennya ymemenuhi α x y, di mana xelemen yang sesuai dari daftar pertama.
Input is a list of lists of integers.
Example: [[0,1,1],[1,0,1],[1,1,0],[1,0,1],[1,1,0],[0,0,1],[0,1,1]]
m Map
¥0 indices where 0 occurs:
[[1],[1,2],[3],[2],[3],[2],[1]]
↔ Reverse:
[[1],[2],[3],[2],[3],[1,2],[1]]
↑ Take while
Ψ this element and the next
- have nonempty set difference:
[[1],[2],[3],[2],[3],[1,2]]
↑ Take while
ε this element is a singleton:
[[1],[2],[3],[2],[3]]
Call this list X.
ŀT¹ Indices of input transposed:
[1,2,3]
¢ Cycle infinitely:
[1,2,3,1,2,3,..]
… Rangify:
[1,2,3,2,1,2,3,2,1,..]
↑ Take from X while
δ the corresponding integer in this list
€ is an element of it:
[[1],[2],[3],[2]]
L Length: 4
Arang , 52 byte
ＷＳ⊞υι≔⮌υυＰ⪫υ¶Ｗ∧⁼.O⪫ＫＤ²↓ω⁼¹№§υⅉ.Ｍ✳⁻⁷⊗÷﹪ⅉ⊗⊖Ｌθ⊖Ｌθ≔ⅉθ⎚Ｉθ
Cobalah secara online! Tautan adalah untuk verbose versi kode. Mengambil masukan sebagai daftar string .dan Okarakter yang diakhiri baris baru . Penjelasan:
ＷＳ⊞υι
Masukkan daftar.
≔⮌υυ
Balikkan daftarnya.
Ｐ⪫υ¶
Cetak daftar tanpa menggerakkan kursor.
Ｗ∧
Ulangi saat keduanya ...
⁼.O⪫ＫＤ²↓ω
... karakter di bawah kursor adalah a .dan karakter di bawah (karena daftar dibalik) adalah O, dan ...
⁼¹№§υⅉ.
... baris daftar saat ini hanya berisi satu .:
Ｍ✳⁻⁷⊗÷﹪ⅉ⊗⊖Ｌθ⊖Ｌθ
Gerakkan kursor secara diagonal ke bawah dan ke kanan atau ke kiri tergantung pada barisnya.
≔ⅉθ⎚Ｉθ
Tangkap indeks baris pertama yang tidak valid (diindeks 0, sehingga sama dengan jumlah baris yang valid), kosongkan kanvas, dan cetak sebagai string.
J , 57 42 byte
Dibutuhkan 0 untuk diblokir, 1 untuk kosong.
[:#.~(|.@$2^|@}:@i:@<:)/@$=2#.[*[+_1|.!.2]
Cobalah secara online!
Bagaimana itu bekerja
[*[+_1|.!.2]
Geser papan ke bawah satu per satu (2 didorong ke dalam di bagian atas untuk memastikan tempat teratas tidak dihitung.) Kemudian papan ditambahkan ke papan asli dan berkembang biak dengan sendirinya. Ini pada dasarnya bermuara pada: tempat terbuka yang valid tetap 1, sementara yang tidak valid menjadi 2.
(|.@$2^|@}:@i:@<:)/@$
Diketahui dimensinya, dapatkan kisaran eksklusif -x … x - 1untuk lebarnya, misalnya 4:, _3 _2 _1 0 1 2dan dapatkan nilai absolutnya 3 2 1 0 1 2. Ubah ukuran daftar itu ke tinggi papan, putar sehingga 3 awal sejajar dengan baris terakhir, dan 2^xdaftar:8 4 2 1 2 4 8 4 2…
=2#.
Tafsirkan baris-baris tersebut sebagai angka basis 2 dan bandingkan dengan daftar zig-zag.
[:#.~
Dan dengan konversi basis refleksif kita dapat menghitung 1 terdepan, sehingga baris terdepan yang valid.
Jeli , 25 byte
ZJŒḄṖṁLW€⁻"ⱮṚT€,Ḋ$ƊZḄCTḢ’
Tautan monadik menerima daftar baris di mana setiap baris adalah daftar 1s (kosong) dan 0s (terisi) yang menghasilkan bilangan bulat non-negatif (skor).
Cobalah secara online! Atau lihat rangkaian pengujian .
Bagaimana?
Membuat daftar indeks kosong yang diharapkan untuk setiap baris dari bawah dan membandingkannya dengan masing-masing dari dua daftar, (a) indeks kosong aktual dan (b) indeks kosong aktual yang diantrekan. Hasil perbandingan ini kemudian diolah untuk dicari skornya.
ZJŒḄṖṁLW€⁻"ⱮṚT€,Ḋ$ƊZḄCTḢ’ - Link: list of lines, A
Z - transpose
J - range of length -> [1,2,...,w=#Columns]
ŒḄ - bounce -> [1,2,...,w-1,w,w-1,...,2,1]
Ṗ - pop -> [1,2,...,w-1,w,w-1,...,2]
L - length (A) -> h=#Lines
ṁ - mould like (repeat Ṗ result such that it is length h)
W€ - wrap each of these integers in a list (call this x)
Ɗ - last three links as a monad - i.e. f(A):
Ṛ - reverse (A)
T€ - for each (line) get the list of truthy ("empty") indices
$ - last two links as a monad - i.e. f(z=that):
Ḋ - dequeue (drop the leftmost)
, - (z) pair (that)
Ɱ - map across (the two results of f(A)) applying:
" - (x) zip with (result) applying:
⁻ - not equal?
Z - transpose - now we have leading [0,1]'s for valid rows
from the bottom up
Ḅ - convert from binary - now leading 1s for valid rows
C - complement (subtract (each) from one)
T - truthy indices
Ḣ - head
’ - decrement
05AB1E , 32 byte
R©εDgݨû¨NèDU._ƶO®N>èX.__н*Θ}γнO
Input sebagai matriks 1s dan 0s, di mana 1s adalah ruang kosong dan 0s diisi sel.
Cobalah secara online. atau verifikasi semua kasus uji .
Penjelasan:
R # Reverse the rows of the (implicit) input-matrix
© # Store it in variable `®` (without popping)
ε # Map over each row:
Dg # Get the width of the matrix
Ý # Push a list in the range [0,width]
¨ # Remove the last element to change the range to [0,width-1]
û # Palindromize it: [0,1,2,...,w-2,w-1,w-2,...,2,1,0]
¨ # Remove the last value: [0,1,2,...,w-2,w-1,w-2,...,2,1]
Nè # Index the map-index into this list
DU # Store a copy in variable `X`
._ # Rotate the current row that many times to the left
ƶ # Multiply each value by its 1-based index
O # And sum this list
® # Push the reversed input-matrix again from variable `®`
N>è # Index the map-index + 1 into this to get the next row
X._ # Also rotate it `X` amount of times towards the left
_ # Invert all booleans (1s becomes 0s, and vice-versa)
н # And only leave the first value
* # Multiply both together
Θ # And check that it's equal to 1 (1 if 1; 0 otherwise)
}γ # After the map: split the list into groups of adjacent equivalent values
н # Only leave the first group
O # And take the sum of that
# (after which it is output implicitly as result)