Secret“>” Stacking Challenge: การให้คะแนน
พื้นหลัง
Tetris แกรนด์มาสเตอร์ 3มีระบบการจัดลำดับที่ซ่อนอยู่บนพื้นฐานของรูปทรงของสแต็คในตอนท้ายของเกมซึ่งจะเรียกว่าที่ลับ ">" ซ้อนท้าทาย ประกอบด้วยการเติมแถวต่ำสุดทั้งหมดยกเว้นรูปแบบซิกแซกซึ่งเริ่มต้นที่เซลล์ล่างซ้ายและขยายความกว้างทั้งหมด:
#
.#########
#.########
##.#######
###.######
####.#####
#####.####
######.###
#######.##
########.#
#########.
########.#
#######.##
######.###
#####.####
####.#####
###.######
##.#######
#.########
.#########
กระดานจะให้คะแนนตามจำนวนบรรทัดตามรูปแบบที่แน่นอนนี้จากบรรทัดล่างสุด โปรดสังเกตว่ารูบนสุดในรูปแบบจะต้องถูกบล็อกโดยชิ้นส่วนพิเศษของบล็อก หากคุณถือว่า#s and .s เป็นรูปแบบบังคับ (ช่องว่างอาจเป็นอะไรก็ได้) คุณจะได้คะแนน 19 ก็ต่อเมื่อรูปแบบที่แน่นอนด้านบนนั้นตรงกันจากบรรทัดล่างสุด ถ้ากระดานตรงกับรูปแบบนี้
#
###.######
##.#######
#.########
.#########
แต่ไม่
#
####.#####
###.######
##.#######
#.########
.#########
แล้วคะแนนคือ 4
สำหรับความท้าทายนี้ให้พิจารณาบอร์ดที่มีขนาดตามอำเภอใจ (นอกเหนือจาก 20 เซลล์สูงและกว้าง 10 เซลล์) เราสามารถให้คะแนนรูปแบบเดียวกันได้เช่นถ้ากระดานมีความกว้าง 4 นี่คือรูปแบบสำหรับคะแนน 3:
#
##.#
#.##
.###
และนี่คือรูปแบบของคะแนน 10:
#
###.
##.#
#.##
.###
#.##
##.#
###.
##.#
#.##
.###
ท้าทาย
พิจารณาสถานะสุดท้ายของบอร์ด Tetris ตามขนาดโดยพลการให้จัดเกรดบอร์ดโดยใช้ระบบด้านบน
คุณสามารถนำกระดานโดยใช้รูปแบบที่เหมาะสมสำหรับเมทริกซ์สี่เหลี่ยมโดยที่ทุกเซลล์มีค่าที่แตกต่างกันหนึ่งในสองค่า (สำหรับค่าว่างและเติมตามลำดับ) คุณสามารถสมมติว่ากริดเป็นบอร์ด Tetris ที่ถูกต้อง (ไม่มีการเติมแถวทั้งหมด) นอกจากนี้ความกว้างของเส้นตารางอย่างน้อย 2
ใช้กฎรหัสกอล์ฟมาตรฐาน รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ
กรณีทดสอบ
เพื่อป้องกันความสับสนที่อาจเกิดขึ้นกรณีทดสอบที่นี่ใช้Oสำหรับบล็อกและ.สำหรับพื้นที่ว่าง
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
คำตอบ
JavaScript (ES6), 84 ไบต์
คาดว่าจะมีรายการสตริง1สำหรับช่องว่างและ0สำหรับบล็อก
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)
ลองออนไลน์!
อย่างไร?
แต่ละสตริงในอาร์เรย์อินพุตจะถูกเสริมด้วย0เลขฐานสองและตีความเป็นเลขฐานสอง ตัวแปรjเริ่มต้น2**Wที่Wความกว้างของบอร์ดอยู่ที่ไหน เราใช้มาสก์บิตiเริ่มต้นเพื่อjติดตามตำแหน่งที่คาดหวังของรูในรูปแบบ
หลังจากที่แต่ละซ้ำจะถูกคูณด้วยi kเราอัปเดตค่าของkเมื่อใดก็ตาม(i & j) != 0(ตีกลับทางด้านซ้ายสุด) หรือ(i & 2) != 0(ตีกลับทางด้านขวาสุด)
ตัวอย่างสำหรับ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
...
แสดงความคิดเห็น
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
แกลบ 18 ไบต์
Lδ↑€…¢ŀT¹↑εΨ↑-↔m¥0
ลองออนไลน์!
ใช้เมทริกซ์ 0-1
คำอธิบาย
มีเหตุการณ์ที่เกิดขึ้นสามครั้ง↑ในโปรแกรมนี้และทั้งหมดทำงานแตกต่างกันไปด้วยฟังก์ชันตัวปรับแต่งδและΨ. โดยค่าเริ่มต้น↑αคาดว่าαจะเป็นฟังก์ชันαยูนารีรับรายการและส่งกลับคำนำหน้าองค์ประกอบที่ยาวที่สุดซึ่งส่งคืนค่าที่แท้จริง Ψ↑αคาดว่าαจะเป็นไบนารีและส่งกลับคำนำหน้าที่ยาวที่สุดขององค์ประกอบxซึ่งα x yเป็นความจริงโดยที่yองค์ประกอบถัดไป δ↑αคาดว่าαจะเป็นไบนารีและรับสองรายการแทนที่จะเป็นรายการเดียว มันกลับคำนำหน้ายาวที่สุดของรายการที่สองที่มีองค์ประกอบที่yตอบสนองα x yที่xเป็นองค์ประกอบที่สอดคล้องกันของรายการแรก
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
ถ่าน 52 ไบต์
ＷＳ⊞υι≔⮌υυＰ⪫υ¶Ｗ∧⁼.O⪫ＫＤ²↓ω⁼¹№§υⅉ.Ｍ✳⁻⁷⊗÷﹪ⅉ⊗⊖Ｌθ⊖Ｌθ≔ⅉθ⎚Ｉθ
ลองออนไลน์! ลิงก์คือรหัสเวอร์ชันที่ละเอียด รับอินพุตเป็นรายการสตริง.และOอักขระที่สิ้นสุดการขึ้นบรรทัดใหม่ คำอธิบาย:
ＷＳ⊞υι
ป้อนรายการ
≔⮌υυ
ย้อนกลับรายการ
Ｐ⪫υ¶
พิมพ์รายการโดยไม่ต้องเลื่อนเคอร์เซอร์
Ｗ∧
ทำซ้ำในขณะที่ทั้งสอง ...
⁼.O⪫ＫＤ²↓ω
... อักขระที่อยู่ใต้เคอร์เซอร์คือ a .และอักขระด้านล่าง (เนื่องจากรายการถูกย้อนกลับ) คือOและ ...
⁼¹№§υⅉ.
... บรรทัดรายการปัจจุบันประกอบด้วย.:
Ｍ✳⁻⁷⊗÷﹪ⅉ⊗⊖Ｌθ⊖Ｌθ
เลื่อนเคอร์เซอร์ในแนวทแยงลงและไปทางขวาหรือซ้ายขึ้นอยู่กับแถว
≔ⅉθ⎚Ｉθ
จับดัชนีแถวแรกที่ไม่ถูกต้อง (ดัชนี 0 จึงเท่ากับจำนวนแถวที่ถูกต้อง) ล้างผ้าใบและพิมพ์เป็นสตริง
J , 57 42 ไบต์
ใช้ 0 สำหรับบล็อก 1 สำหรับค่าว่าง
[:#.~(|.@$2^|@}:@i:@<:)/@$=2#.[*[+_1|.!.2]
ลองออนไลน์!
มันทำงานอย่างไร
[*[+_1|.!.2]
เลื่อนกระดานลงทีละอัน (2 ถูกดันเข้าที่ด้านบนเพื่อให้แน่ใจว่าจุดสูงสุดจะไม่ถูกนับ) จากนั้นจะเพิ่มไปยังกระดานเดิมและคูณด้วยตัวมันเอง โดยทั่วไปแล้วสิ่งนี้จะลดลงถึง: จุดเปิดที่ถูกต้องจะอยู่ที่ 1 ในขณะที่จุดที่ไม่ถูกต้องกลายเป็น 2
(|.@$2^|@}:@i:@<:)/@$
ได้รับมิติที่ได้รับช่วงพิเศษ-x … x - 1สำหรับความกว้างสำหรับเช่น 4: และได้รับค่าแน่นอนของพวกเขา_3 _2 _1 0 1 2 3 2 1 0 1 2ปรับขนาดรายการนั้นให้มีความสูงของบอร์ดหมุนรายการเพื่อให้ 3 เริ่มต้นอยู่ในแนวแถวสุดท้ายและ2^xรายการ:8 4 2 1 2 4 8 4 2…
=2#.
แปลความหมายของแถวเป็นเลขฐาน 2 แล้วเปรียบเทียบกับรายการซิกแซก
[:#.~
และโดยการแปลงฐานแบบรีเฟลกซ์เราสามารถนับ 1 นำหน้าได้ดังนั้นแถวนำที่ถูกต้อง
เยลลี่ 25 ไบต์
ZJŒḄṖṁLW€⁻"ⱮṚT€,Ḋ$ƊZḄCTḢ’
monadic Link ยอมรับรายการของบรรทัดโดยแต่ละบรรทัดเป็นรายการของ1s (ว่าง) และ0s (เติมเต็ม) ซึ่งให้ผลจำนวนเต็มที่ไม่เป็นลบ (คะแนน)
ลองออนไลน์! หรือดูการทดสอบในตัว
อย่างไร?
สร้างรายการของดัชนีว่างที่คาดไว้สำหรับแต่ละบรรทัดจากด้านล่างและเปรียบเทียบกับแต่ละรายการสองรายการ (ก) ดัชนีว่างจริงและ (ข) ดัชนีว่างจริงที่ไม่จัดคิว จากนั้นผลของการเปรียบเทียบนี้จะถูกประมวลผลเพื่อหาคะแนน
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 ไบต์
R©εDgݨû¨NèDU._ƶO®N>èX.__н*Θ}γнO
อินพุตเป็นเมทริกซ์ของ 1s และ 0s โดยที่ 1s เป็นช่องว่างและ 0s จะเต็มไปด้วยเซลล์
ลองออนไลน์ หรือตรวจสอบกรณีทดสอบทั้งหมด
คำอธิบาย:
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)