text:
How much is my dice matrix worth?
Input
A non-empty binary matrix consisting of 3x3 sub-matrices put side by side.
Task
Your task is to identify valid dice patterns (as described below) among the 3x3 sub-matrices. Each valid pattern is worth the value of the corresponding dice. Invalid patterns are worth 0.
Output
The sum of the valid dice values.
Dice patterns
$$\begin{align}
&1:\pmatrix{\color{gray}0,\color{gray}0,\color{gray}0\\\color{gray}0,1,\color{gray}0\\\color{gray}0,\color{gray}0,\color{gray}0}
&&2:\pmatrix{1,\color{gray}0,\color{gray}0\\\color{gray}0,\color{gray}0,\color{gray}0\\\color{gray}0,\color{gray}0,1}\text{or}\pmatrix{\color{gray}0,\color{gray}0,1\\\color{gray}0,\color{gray}0,\color{gray}0\\1,\color{gray}0,\color{gray}0}\\
&3:\pmatrix{1,\color{gray}0,\color{gray}0\\\color{gray}0,1,\color{gray}0\\\color{gray}0,\color{gray}0,1}\text{or}\pmatrix{\color{gray}0,\color{gray}0,1\\\color{gray}0,1,\color{gray}0\\1,\color{gray}0,\color{gray}0}
&&4:\pmatrix{1,\color{gray}0,1\\\color{gray}0,\color{gray}0,\color{gray}0\\1,\color{gray}0,1}\\
&5:\pmatrix{1,\color{gray}0,1\\\color{gray}0,1,\color{gray}0\\1,\color{gray}0,1}
&&6:\pmatrix{1,\color{gray}0,1\\1,\color{gray}0,1\\1,\color{gray}0,1}\text{or}\pmatrix{1,1,1\\\color{gray}0,\color{gray}0,\color{gray}0\\1,1,1}
\end{align}$$
Example
The expected output for the following matrix is 14 because it contains the dice 5, 6 and 3, followed by an invalid pattern (from left to right and from top to bottom).
$$\pmatrix{1,0,1,1,1,1\\
0,1,0,0,0,0\\
1,0,1,1,1,1\\
1,0,0,0,0,0\\
0,1,0,0,1,0\\
0,0,1,0,1,0}$$
Rules

Both the width and the height of the matrix are guaranteed to be multiples of 3.
You must ignore sub-matrices that are not properly aligned on the grid (see the 3rd test case). More formally and assuming 0-indexing: the coordinates of the top-left cell of each sub-matrix to be considered are of the form \$(3x, 3y)\$.
This is code-golf.

Test cases
// 0
[ [ 1,0,0 ],
  [ 0,0,1 ],
  [ 1,0,0 ] ]

// 2
[ [ 0,0,1 ],
  [ 0,0,0 ],
  [ 1,0,0 ] ]

// 0 (0 + 0)
[ [ 0,0,1,0,1,0 ],
  [ 0,0,0,1,0,0 ],
  [ 0,0,1,0,1,0 ] ]

// 9 (3 + 3 + 3)
[ [ 1,0,0,0,0,1,1,0,0 ],
  [ 0,1,0,0,1,0,0,1,0 ],
  [ 0,0,1,1,0,0,0,0,1 ] ]

// 6 (6 + 0)
[ [ 1,0,1 ],
  [ 1,0,1 ],
  [ 1,0,1 ],
  [ 1,0,1 ],
  [ 1,0,0 ],
  [ 1,0,1 ] ]

// 14 (5 + 6 + 3 + 0)
[ [ 1,0,1,1,1,1 ],
  [ 0,1,0,0,0,0 ],
  [ 1,0,1,1,1,1 ],
  [ 1,0,0,0,0,0 ],
  [ 0,1,0,0,1,0 ],
  [ 0,0,1,0,1,0 ] ]

// 16 (1 + 2 + 3 + 4 + 0 + 6)
[ [ 0,0,0,1,0,0,1,0,0 ],
  [ 0,1,0,0,0,0,0,1,0 ],
  [ 0,0,0,0,0,1,0,0,1 ],
  [ 1,0,1,1,1,1,1,0,1 ],
  [ 0,0,0,1,0,1,1,0,1 ],
  [ 1,0,1,1,1,1,1,0,1 ] ]

Python 3, 195 189 bytes
-6 bytes thanks to @Jo King
lambda m:sum({16:1,257:2,68:2,273:3,84:3,325:4,341:5,455:6,365:6}.get(int(''.join(str(e)for c in m[3*i:][:3]for e in c[3*j:][:3]),2),0)for i in range(len(m)//3)for j in range(len(m[0])//3))

Try it online! (189)
Try it online! (195)
Human readable version:
# 3x3 part matrix to dice, beginning at coordinates 3*i, 3*j
def single_matrix_to_dice(matrix, i, j):
    # Example: matrix = [[0, 0, 0], [0, 1, 0], [0, 0, 0]], i=0, j=0 (result is 1)

    matrix_string = ''.join(
        str(e) for column in matrix[3*i:3*i+3]
        for entry in column[3*j:3*j+3]
    ) # Slicing the matrix so that only the valid entries remain, here '000010000'

    # Interpreting the matrix string as binary number, here 16
    binary_number = int(matrix_string,2)

    # binary representations of all valid dice rolls
    dct = {16:1,257:2,68:2,273:3,84:3,325:4,341:5,455:6,365:6}

    return dct.get(binary_number, 0)

def f(matrix):
    return sum(
        single_matrix_to_dice(matrix, i, j) for i in range(len(m)//3)
        for j in range(len(m[0])//3))
    ) # len(m)/3 would generate a float, so len(m)//3 is used

I wonder if you could shorten this slightly by doing the same operation on the transpose of the matrix as well. That way you could remove all of the duplicate entries in your map that add 6 bytes each. Just need to add the transpose step in <18 bytes

188 bytes.

Get rid of both instances of //3 and use '0'+''.join... to save two bytes :)

...combine that with enumerate to save two more: here

165 bytes.

Possible 162 bytes.

R, 134 bytes
function(m,d=dim(m)/3-1){for(a in 0:d)for(b in 0:d[2])F=F+sum(y<-m[1:3+a*3,1:3+b*3])*sum(y*2^(8:0))%in%utf8ToInt("āDđTŅŕǇŭ");F}

Try it online!
I noticed I had the same idea of @Heteira
History :

171 : -10 bytes thanks to @JayCe !
161 : -3 bytes thanks to @Giuseppe !
158 : -13 bytes saved !
145 : -2 bytes thanks to @Giuseppe!
143 : -6 bytes saved !
137 : -3 bytes thanks to @JayCe!

save 5 bytes by compressing the list of numbers - link with examples too long to post as a comment

3 more bytes using dim

more black magic for two more bytes

Great idea reordering the values, thanks a lot !

you can save 3 bytes using a in 1:d instead of a in 1:d[1] although it will give a warning.

Another 13 bytes saved !

There's an extra pair of parentheses around (2^(8:0)) which can be removed.

Yup! Also another 6 bytes moving -1 to function arguments

I add forgotten to cat the output of intToUtf8: save 3 bytes

Perl 6, 113 105 97 94 bytes
{sum (|@_[*;^3+3*$_]for ^@_[0]).rotor(9).map:{"@āđŅŕǇ@@DT@@ŭ".ords.first(:2[$_],:k)%7}}

Try it online!
Splits up the matrix into sub matrices of 3x3, converts the nine 1s and 0s to base 2 and then indexes it into a list of integers for the value.
Explanation:
{  #Start anonymous code block
  sum   # Sum of all
     (|@_[*;^3+3*$_]   # Get the n*3 to n*3+3th elements in every sub-list
           for ^@_[0]) # For n in the range 0 to width (divide by 3 to avoid warnings)
     .rotor(9)  # Split this list into groups of 9 (split the dice up)
     .map:{     # And map each die to
        "@āđŅŕǇ@@DT@@ŭ".ords  # In the list of integers
           .first(      # The first appearance of
               :2[$_],  # The dice converted from a list of 0s and 1s to base 2
                 :k     # Returning the index
             )%7        # And modulo by 7 to get the alternate versions of 2, 3 and 6
          }
}

Jelly,  29 28 bytes
-1 thanks to Mr. Xcoder (use Ṁ to replace ṢṪ)
s€3ZẎs3µZU,ƊṀṙ1FḄ“°€⁼-Ḍ?‘i)S

A monadic link.
Try it online! Or run the tests.
How?
s€3ZẎs3µZU,ƊṀṙ1FḄ“°€⁼-Ḍ?‘i)S - Link: list of lists of 1s and 0s
s€3                          - split each into threes
   Z                         - transpose
    Ẏ                        - tighten
     s3                      - split into threes -> the sub-matrices in column-major order
       µ                  )  - for each sub-matrix, say D:
           Ɗ                 -   last three links as a monad:
        Z                    -     transpose D
         U                   -     reverse each -> D rotated a quarter turn clockwise
          ,                  -     pair with D
            Ṁ                -   get the maximum of the two orientations
             ṙ1              -   rotate left by one (to ensure FḄ will yield integers <256 for all non-zero valued D)
               F             -   flatten
                Ḅ            -   convert from binary
                         i   -   first 1-based index in (0 if not found):
                 “°€⁼-Ḍ?‘    -     code-page indices list = [128,12,140,45,173,63]
                           S - sum

For example when a sub-matrix is:
[[1,0,1],
 [1,0,1],
 [1,0,1]]

Then ZU,Ɗ yields:
[[[1, 1, 1],
  [0, 0, 0],
  [1, 1, 1]],   ...which has maximum (Ṁ):    ...and after ṙ1:
 [[1, 0, 1],                   [[1, 1, 1],         [[0, 0, 0],
  [1, 0, 1],                    [0, 0, 0],          [1, 1, 1],
  [1, 0, 1]]]                   [1, 1, 1]]          [1, 1, 1]]

...which flattens to [0, 0, 0, 1, 1, 1, 1, 1, 1], which, converting from binary, is 63 which is the sixth entry in the code-page index list “°€⁼-Ḍ?‘ (? being byte 3F in Jelly's code-page)

Ṁ might work instead of ṢṪ for -1.

...yes it will (I thought I was saving over using M >.<). Can something clever be done with ŒṪ I wonder...

Japt -x, 36 bytes
Now it's getting interesting. I'm sure can be golfed down even more
ò3 ®®ò3Ãy f@"0ıtŵġdťƍǧ"øºXm¬¬Í+H)d
c

Try it online!

Retina 0.8.2, 90 bytes
+`(...)(.+¶)(...)(.+¶)(...)
$1¶$3¶$5¶$2$4
¶

M!`.{9}
G`111000111|(101){3}|(.)0(.0).0\3\2
1

Try it online! Explanation:
+`(...)(.+¶)(...)(.+¶)(...)
$1¶$3¶$5¶$2$4

Repeatedly remove \$3\times 3\$ blocks from each \$3\times n\$ row until all rows have 3 columns.
¶

M!`.{9}

Join all the blocks together and then split back up into rows of 9 columns.
G`111000111|(101){3}|(.)0(.0).0\3\2

Only keep valid dice patterns (two patterns for 6, then one matches any number from 0 to 5, although 0 of course will not contribute to the count below.)
1

Count the pips on the valid dice.

Vyxal d, 34 bytes
3ẇƛƛ3ẇ;ÞTvf;f9ẇ'†B»@uS∨∪ċ#»b9ẇvB$c

Try it Online!
A mess.

Ruby, 151 bytes
->m{m.each_slice(3).flat_map{|r|r.transpose.each_slice(3).map{|d|" \x10āđŅŕǇ  DT  ŭ".chars.map(&:ord).index(d.flatten.join.to_i 2)&.%7}-[p]}.sum}

Try it online!
A lambda accepting a 2d array of ints (or strings, I guess). Takes inspiration from Jo King's answer. I feel like slicing the dice out of the input matrix took a lot of space, so I may well be outgolfed. Fortunately, dealing with nils only cost me a handful of bytes.
Ungolfed:
->m{
  m.each_slice(3).flat_map{|r|             # Split into groups of 3 rows
    r.transpose.each_slice(3).map{|d|      # Split into groups of 3 columns
      " \x10āđŅŕǇ  DT  ŭ".chars.map(&:ord) # [0,16,257,273,325,341,455,0,0,68,84,0,0,365]
        .index(                            # Find in that array
          d.flatten.join.to_i 2            #   the die flattened into a bitstring (nil if not found)
        )&.%7                              # Safe-modulo 7 (leaves nils as nil)
    }-[p]                                  # Remove nils
  }.sum                                    # Add 'em up
}

Clojure, 197 bytes
#(apply +(for[R[range]i(R 0(count %)3)j(R 0(count(% 0))3)](case(apply +(map *(iterate(partial * 2)1)(for[x(R 3)y(R 3)]((%(+ i x))(+ j y)))))16 1 257 2 68 2 273 3 84 3 325 4 3 4 1 5 455 6 365 6 0)))

I should have come up with something smarter.

Python 2, 159 bytes
f=lambda a:a>[]and sum(u'ȀāDđTŅȀŕȀǇŭ'.find(unichr(int(J(J(map(str,r[i:i+3]))for r in a[:3]),2)))/2+1for i in range(0,len(a[0]),3))+f(a[3:])
J=''.join

Try it online!
Hat tip to Jonathan Frech for the unicode encoding approach.


text:
Bridge Deal Scoring
Goal
Given a deal result from Duplicate Contract Bridge, calculate the deal score.
Basically the same as iBug's question, which was deleted. I figured out this scoring system while trying to answer that question.
Input
Input is a deal result, and whether or not the declaring side is vulnerable.
The deal result is a string in the following format:
[contract] [result]

The contract is defined as follows:
[tricks][suit][doubling]

The tricks is a number 1-7 (both inclusive),
The suitis one of C, H, S, D, or NT (Clubs, Hearts, Spades, Diamonds, and notrump)

Suits are grouped as follows: notrump: NT, Major suits: H, S and Minor suits: C, D.

doubling can be blank , X or XX (Undoubled, Doubled, Redoubled)

result is the resulting number of 'tricks' in relation to the contract. The value can be in the range [-13; +6], depending on the value (sign included).
The sum of contract number and result must be in the range[-6; 7], which means:

For tricks= 1, result must be [-7; +6]
For tricks= 2, result must be [-8; +5]
..
For tricks= 7, result must be [-13; 0]

Examples of valid deal results:
1S 0, 4NT -3, 7NTXX -13, 3HX +3

Vulnerability can be input as a boolean or any truthy/falsy value.
Output
Output is the scoring of the deal result.
The score is based on the number of tricks in a deal, and whether it reached the contract.

Scoring
The score is a measure of the result compared to the contract.
If the contract is made, the score for each such deal consists of:

Contract points, assigned to each trick bid and made
Overtrick points, assigned for each trick taken over the contracted number of tricks
A slam bonus for a small slam or grand slam contract
A doubling bonus
A game bonus

If the contract is defeated, the defenders receive

Penalty points, assigned for every undertrick (negative value of result)

Contract points:
Contract points are awarded for the tricks of the contract.
                                   Points per trick
Suit                      undoubled    doubled     redoubled
------------------------------------------------------------
 Notrump
  -first trick               40          80           160
  -subsequent tricks         30          60           120
 Major suits                 30          60           120
 Minor suits                 20          40           80

Overtrick points:
Overtrick points are awarded for the tricks made, more than the contract (result > 0)
                                Points per trick
Suit                      vulnerable    not vulnerable
 If undoubled:
  Notrump                     30             30
  Major suits                 30             30
  Minor suits                 20             20
 Doubled (per trick)          200            100
 Redoubled (per trick)        400            200

Slam bonus
If a large contract is made, it earns a slam bonus:

tricks = 6 earns a bonus of 500 if not vulnerable, and 750 if vulnerable
tricks = 7 earns a bonus of 1000 if not vulnerable, and 1500 if vulnerable

Doubled or redoubled bonus
If a doubled or redoubled contract is made, a bonus is earned:

50 points for a doubled contract
100 points for a redoubled contract

Game bonus
A game bonus is awarded based on the contract points.

Contract points below 100 earns a bonus of 50points.
Contract points >= 100 earns a bonus of 300 if not vulnerable, and 500 if vulnerable

Penalty
Each undertrick (negative result) gives a penalty point.
No points are ganied for the contract, as it was failed.
                                      Points per undertrick
                           vulnerable                        not vulnerable
                   undoubled  doubled   redoubled     undoubled  doubled   redoubled
1st undertrick        100       200        400           100       100        200
2nd and 3rd, each     100       300        600           100       200        400
4th and subsequent    100       300        600           100       300        600

Examples:
Deal result: 4DX +1, Vulnerable=true:

Contract points = 4*40 = 160
Overtrick points = 1*200 = 200
Slam bonus = no bonus
(re)doubled bonus = 50
Game bonus = 500 (140>=100and vulnerable)

Result = 160+200+50+500 = 910

Deal result: 6NTXX 0, Vulnerable=false:

Contract points = 4*40 = 160
Overtrick points = 1*200 = 200
Slam bonus = no bonus
(re)doubled bonus = 50
Game bonus = 500 (140>=100and vulnerable)

Result = 160+200+50+500 = 910

Deal result: 4SX -3, Vulnerable=false:

Penalty = 1*100 + 2*200 = 500

Result = -500

Deal result: 7SNTXX -13, Vulnerable=true:

Penalty = 1*400 + 2*600 + 10*600 = 7600

Result = -7600

Example Input/Output:
Input is guaranteed to be valid.
1S 0 (non-vul)    # => 80
3NT +1 (non-vul)  # => 430
3NT +1 (vul)      # => 630
6CX +1 (vul)      # => 1740
4D -1 (vul)       # => -100
7NTXX -13 (vul)   # => -7600

Results can be checked against these tables.
I've also included a TIO with all results hardcoded in python, to check against.

@PeterTaylor It is duplicate. I've edited that in, and updated the testcase

JavaScript (Node.js), 211 204 195 192 bytes
(r,v,[,c,s,d,t]=r.match(/(.)(.T?)(X*)(.*)/),l=d.length,m=s>'D',g=(c*(m+=2)+!!s[1])<<l)=>10*(t<0?10*(l*(v?3*t+1:-"13"[~t]||3*t+4)||t):g+(10*l*-~v||m)*t+5*l+25*(c>5&&(5-c)*~-~v)+5*(g>9?4*v+6:1))

Try it online! Link includes test cases. Edit: Saved 6 bytes by multiplying by 10 at the end. Saved 9 bytes thanks to @Arnauld. Explanation:
(r,v

Input the result as a string and the vulnerability as a boolean (or 1/0).
,[,c,s,d,t]=r.match(/(.)(.T?)(X*)(.*)/)

Split the string up into contract, suit, doubles and (over/under)tricks.
,l=d.length

Count the number of doubles.
,m=s>'D'

Track whether this is a major or minor suit.
g=(c*(m+=2)+!!s[1])<<l

Calculate the contract score. This is 3 per major suit or 2 per minor suit trick, plus 1 extra for no trump, and then doubled or redoubled as appropriate.
)=>10*

The score is always a multiple of 10. Subsequent comments take this multiplication into account.
(t<0

Do we have undertricks?
?10*

Undertricks are multiples of 100.
(l*(v?3*t+1:-"13"[~t]||3*t+4)

If they're doubled, then the potentially redoubled score depending on the vulnerability or number of undertricks.
||t)

But if they're not doubled, then just the number of undertricks.
:g

If the contract is made, then we start with the contract score.
+(10*l*-~v||m)*t

Add on overtricks; per trick, if doubled then 100 potentially redoubled and doubled again if vulnerable, otherwise 30 for major or 20 for minor suits.
+5*l

Add on the potentially redoubled doubled game bonus.
+25*(c>5&&(5-c)*~-~v)

Add on the slam bonus if applicable.
+5*(g>9?4*v+6:1))

Add on the game bonus.

@Arnauld Oh, of course, <<, I knew I was overlooking something but I just couldn't think of it. (I rearranged your answer slightly for ease of explanation.)

Python 2, 230 225 221 220 bytes
I've posted this answer, as I found out the rules while creating this answer to the other question.
def f(D,V):v,s=D[:2];d=D.count('X');m=int(D.split()[1]);v=int(v);C=3-(s<'E');P=(v*C+(s=='N'))*2**d;W=-~V;return[-~W*25*max(0,v-5)+P+m*[C,10*W,20*W][d]+5*d+[5,30+20*V][P>9],((m-W)*3+7+~-V*max(0,m+3))*d*10or+W*m*5][m<0]*10

Try it online!

Saved:

-4 bytes, thanks to Mr. Xcoder
-1 byte, thanks to Jonathan Frech

221?

Possible 220 bytes.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Make a Geiger Counter
A Geiger counter is a device that is used to detect radiation.
We will be making a Geiger counter program.
As we all know, when radiation hits a computer program it removes exactly 1 byte at random.  So a Geiger counter program is a program that itself does nothing, but when any byte is removed the modified program prints beep, to indicate the presence of radiation.
Answers will be scored in bytes with fewer bytes being better.  Answers must be at least 1 byte.
Your program may print beep with trailing a newline or print a single newline for empty output, so long as it does so consistently.  Your program may also use a different case for beep such as BEEP, bEEP, or Beep so long as it does so consistently.

Related, Related.

*Geiger-Muller Tube connected to a counter ;)

Can we use the BEL control character to output an actual beep?

@JoKing I toyed with the idea, it is amusing, but I have to say no.  It is too substantially different.

And much easier as well. (1 byte vs 4 byte)

I want to see a solution in Retina.

I'm trying to figure out how to do this in SMBF... but the only way to compare two cells involves changing them. And in SMBF, the cells you need to check are the cells the program is currently running on. So it's like the Heisenberg Uncertainty Principle. So you have to determine if anything changed using only control flow.

Are we allowed to read our own source code?

@pxeger you are free to. There Is no rule against.

Lost, 303 293 263 253 238 228 bytes
v^"peeb"<\>"beepvv"((>@@>>%%>>(((((([[[[[[\
>>>>>>>>>//>>>>>>>>>>>>>>/>>/>>>>>>>>>>>>>\\
>>>>>>>>//>>>>\>>>>>>>>>>/>>>>>>>>>>>>>>>>>\\
>/>>>>>>>/>>>>>>>>>>>>\>>>>>>>>>>>>>>>>>>>>>\\
>>>>>>>>>>>>>>>>>>>>>>\\>>>>\>>>>>>>>>>>>>>>>\

Try it online!
Verification script (borrowed from user 202729's answer). Unfortunately this can only test half of the code at a time, but rest assured I've tested the whole program.
Ouch, this was a tough one. I'll quote WW's deleted answer:

Lost is perhaps the most interesting language for this challenge. In
  Lost the start location and direction of the pointer is entirely
  random, thus to make deterministic programs you must account for every
  possible start location and direction. At the same time, by the nature
  of this challenge you must also account for any single byte being
  removed.

Unfortunately, his answer didn't take into account removing newlines, which screwed everything up.
Explanation:
(note that a few bytes might be off here and there)
First let's talk about the general structure of the code:
v^^"peeb"<<\/"beepvv"((>>>@@>>%%>>(((((([[[[[[[\       Processing line
>>>>>>>>>>>//>>>>>>>>>>>>>>>>>>>/>>>>>>>>>>>>>>\\      Beep line
>>>>>>>>>//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\\     Back-up beep line
>//>>>>>>>>>>>>>>>>>>>>\\>>>>>>>>>>>>>>>>>>>>>>>>\\    Back-up return line
>>>>>>>>>>>>>>>>>>>>>>>>\\>>>>>>\>>>>>>>>>>>>>>>>>\    Return line

Everything but the processing line must be entirely composed of either > or one of \/. Why? Well, as an example, let's remove a newline:
v^^"peeb"<<\/"beepvv"((>>>@@>>%%>>(((((([[[[[[[\>>>>>>>>>>>//>>>>>>>>>>>>>>>>>>>/>>>>>>>>>>>>>>\\
>>>>>>>>>//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\\
>//>>>>>>>>>>>>>>>>>>>>\\>>>>>>>>>>>>>>>>>>>>>>>>\\
>>>>>>>>>>>>>>>>>>>>>>>>\\>>>>>>\>>>>>>>>>>>>>>>>>\

The first line is now way longer than the rest of the block. If a pointer were to spawn on a non->\/ character with vertical movement, then it would get stuck in an infinite loop.

The biggest radiation detector part is the section at the end of each line.
 \
 \\
 >\\
 >>\\
 >>>\

Normally an IP passing through this from the first line would exit out the last line. However, if any character on the line is removed, then that line shifts down one, e.g:
 \
 \\
 >\\
 >\\
 >>>\

And the IP instead exits out the line that is missing a byte (with the exception of the last line, where it exits out the second to last).
From there, each of the first four lines will redirect to the second line:
v
>>>>>>>>>>
>>>>>>>>//
>/

Which will then lead into either one of the two beepers.
v^"peeb"<<\/"beepvv"((>
>>>>>>>>>>//

If any of the bytes in the first beeper have been removed, then it instead goes to the second:
v^^"peb"<<\/"beepvv"((>
>>>>>>>>>>>//

Both beepers then lead back to the first line and the terminating @.
Some other miscellaneous parts:
The (((((([[[[[[[ is used to clear the stack when the pointer starts inside a pair of quotes and ends up pushing the whole first line to stack. It has to be so unfortunately long because the first newline can be removed to make the first line twice the size. Experimenting in generating the beep using arithmetic instead of quotes ended up longer.
The \s and /s scattered across the lines are there to golf bytes in the top line of code by redirecting the pointer to the correct lines. As most of the bottom lines are just filler, only the top line is able to be golfed. If anyone has any ideas for a shorter radiation proof stack clearer then what I've got now, feel free to comment.

Just out of curiosity, how helpful was the partial answer I posted in chat? I saw some similarities in the earlier versions, and I'd like to know if I was on the right track.

@WW I had already been working on it by then, but the \/ to separate the beep pushes and the fact that only one of the quotes needed an exit clause helped

Hexagony, 38 bytes
.....;p;<>b;e;/<b;e;;p...@@.......;@..

Try it online!
Verification program.

Explanation
We make use of Hexagony's auto-detection of hexagon side-length here.
If no bytes are removed, the program has side length 4 and looks like this:

If however, a byte is removed. There are 2 cases.

The removed byte is after the second <.
The execution flow would be:

There are 2 consecutive @ on the 5th line, so even if one of them are removed, the IP will safely hit a @.
The removed byte is at or before the second <.
Then the second half will stay intact, and the IP is no longer redirected upwards by that <. Image of execution flow:

Klein  XXX, 144 136 128 122 114 bytes
This answer completes JoKing's challenge to make a Geiger counter that works in every Klein topology.
\..//!?......\
!>>>.>>>>>>>\\\
!.//@"peeb"(<.\.\
!\\\@"peeb"(<..//
>>>>>>>>>>>>////
\\>.>....(.////
>\....?!/1!!./

Try it online! Verification script
I don't believe it is really possible to make a perfectly satisfactory explanation.  There are definitely aspects of this that I'm not aware of.  It's just got too much going on.  So the explanation below is a bit rough. I just want to get the idea across even if I gloss over a lot of the details.
The obvious next step is to create a version of Lost that can run on different Klein topologies, and create a Geiger counter in Lost that works in every topology.  I don't know if really should be encouraging people to spend there time on such a awful and frustrating task, but I would certainly be willing to  give a 500 rep bounty to someone who does the above.
Explanation
The idea for this is to make a program with 2 parts.
The first is the path taken during normal execution.  This path doesn't cross any boundaries, so we can avoid having to deal with the topology, and most importantly is very, very fragile.  The idea here being that any disturbance to the program breaks the path and sends the ip flying off randomly.
The second part is a robust core.  This part is sort of the opposite, it's role is to catch pointers that have gone off the path and direct them to the beeper.  It needs to be impervious to radiation and it needs to catch as many stray pointers as possible.
The general strategy here was to build a program like this and just keep fixing the problems.
The Path
The path looks like this:
\   / ?......\
!   .        \\
    @         \.\
!              //
              //
\\           //
 \....?! 1! ./

Some important about this things are

We mostly use mirrors (\ and /) rather than hard redirects.  They are more fragile, and make it harder to get back on the path.
The last character of every line is part of the path.  This is required since removing them needs to break the path.
It is sort of hexagon shaped.  This is because a right angle turn can be simulated by a pole (e.g. the NE corner in 101) in the topology.  So if we try to make a right angle turn at the corner there will end up being a topology that doesn't even need the mirror to make the turn.
We have ?!/1 at the bottom and ? near the end.  This is to make sure that the bottom portion gets executed exactly once.  Sometimes the pointer ends up back on the path after getting knocked off.  This makes sure that if it hits the bottom portion of the path it doesn't get stuck in a loop there, and if it skips that portion it can't get to the end of the path.
It covers basically the entire perimeter of the program.  Hypothetically we only really need the left edge of the program but a full circuit is more fragile and we have to get to the other side anyway.

I experimented with both clockwise and anticlockwise paths.  Ultimately clockwise should be better since you can make a shorter path. But I could not get it to work and some earlier attempts using this approach just never worked out. I managed to make an anticlockwise path so that's what's here.  I might take some time with the lessons learned here to try clockwise again.
The Core
The core is nothing too special.  It is based off of the method used by pretty much every 2D Geiger counter we have two lines each which print beep, and we use the length of each to figure out which is damaged, so we can execute the other one.  We surround this with ton of >s to force ips where we want them, this is the classic strategy for Lost programs.

Hexagony, 34 29 bytes
//..>;e;<b@;p;/|/;e;;\.b@;p<@

Try it online! Verification!
Explanation:
Here is the normal code formatted into a proper hexagon using HexagonyColorer:

The double // at the beginning ensures that this path is always taken. If any character is removed, the @ is removed from the path, either being shifted one back or being removed itself:

In this case, we've removed a character after the |, which makes it follow this path, printing beep:

If we instead remove a character from before the | (or the | itself), we follow the other beep printer:

We've then accounted for all possibilities and we only beep using the un-irradiated parts of the program.

Self-modifying Brainfuck, 73 63 bytes
<<[[[[<<]]>[[.>>..>>.[,>]]]]   bbeepp+[<<<]>>[[>]>>>.>>..>>.,+]

Try it online! Verification!
The spaces in the middle of the code are actually representing NUL bytes.
Explanation:
The code is split into two sections by 3 NUL bytes in the middle. Both of them basically prints beep if the other section is irradiated (with a couple of exceptions).
First, the <<[[ at the beginning is to ensure that all ]s are matched at any time. [s won't attempt to look for a matching ] if the cell is positive, while ]s do. If any ] jumps back to one of these brackets it usually jumps back straight away because the cell is 0.
The next part, [[<<]]> then checks if the length of section 2 is even. If so, it executes the other half of section 1, which prints beep using the bbeepp at the start of section 2.
[[.>>..>>.[,>]]]]

It then clears all of section 2 so it doesn't execute.
In section 2, we check if the length of section 1 and the NUL bytes is divisible by 3 with +[<<<]>>.
[[>]>>>.>>..>>.,+]

Similarly, we print beep.

Z80Golf, 53 36 34 bytes
-16 bytes thanks to @Lynn
-2 byte thanks to @Neil
Since this is just Z80 machine code, there is a lot of unprintables in this one, so have a xxd -r-reversible hexdump:
00000000: ddb6 2120 10dd b615 280c 003e 62ff 3e65  ..! ....(..>b.>e
00000010: ffff 3e70 ff76 003e 62ff 3e65 ffff 3e70  ..>p.v.>b.>e..>p
00000020: ff76                                     .v

Try it online! (exhaustive tester in Python)
Explanation
z80golf is Anarchy Golf's hypothetical Z80 machine, where call $8000 is a putchar, call $8003 is a getchar, halt makes the interpreter exit, your program is placed at $0000, and all other memory is filled with zeroes. Making programs radiation-proof in assembly is pretty hard, but a generically useful technique is using one-byte idempotent instructions. For example,
or c        ; b1    ; a = a | c

is just one byte, and a | c | c == a | c, so it can be made radiation-proof by just repeating the instruction. On the Z80, an 8-bit immediate load is two bytes (where the immediate is in the second byte), so you can load some values into registers reliably too. This is what I originally did at the beginning of the program, so you can analyze the longer variants I archived at the bottom of the answer, but then I realized that there is a simpler way.
The program consists of two independent payloads, where one of them could have been damaged by radiation. I check whether a byte was removed, and whether the removed byte was before the second copy of the payload, by checking the values of some absolute memory addresses.
First, we need to exit if no radiation was observed:
    or a, (ix+endbyte) ; dd b6 21 ; a |= memory[ix+0x0021]
    jr nz, midbyte     ; 20 10    ; jump to a halt instruction if not zero

If any byte was removed, then all the bytes will shift and $0020 will contain the last 76, so $0021 will be a zero. We can afford radiating the beginning of the program, even though there is virtually no redundancy:

If the jump offset $10 is removed, then radiation will correctly be detected, the jump will not be taken, and the offset will not matter. The first byte of the next instruction will be consumed, but since it's designed to be resistant to byte removals, this doesn't matter.
If the jump opcode $20 is removed, then the jump offset $10 will decode as djnz $ffe4 (consuming the next instruction byte as the offset -- see above), which is a loop instruction -- decrement B, and jump if the result is not zero. Because ffe4-ffff is filled with zeroes (nops), and the program counter wraps around, this will run the beginning of the program 256 times, and then finally continue. I am amazed this works.
Removing the $dd will make the rest of the snippet decode as or (hl) / ld ($1020), hl, and then slide into the next part of the program. The or will not change any important registers, and because HL is zero at this point, the write will also cancel out.
Removing the $b6 will make the rest decode as ld ($1020), ix and proceed as above.
Removing the $21 will make the decoder eat the $20, triggering the djnz behavior.

Note that using or a, (ix+*) saves two bytes over ld a, (**) / and a / and a thanks to the integrated check for zero.
We now need to decide which of the two copies of the payload to execute:
    or (ix+midbyte)  ; dd b6 15
    jr z, otherimpl  ; 28 0c
    nop              ; 00
    ; first payload
    ld a, 'b'        ; 3e 62
    rst $0038        ; ff
    ld a, 'e'        ; 3e 65
    rst $0038        ; ff
    rst $0038        ; ff
    ld a, 'p'        ; 3e 70
    rst $0038        ; ff
midbyte:
    halt             ; 76
otherimpl:
    nop              ; 00
    ld a, 'b'        ; 3e 62
    ; ...            ; ...
    rst $0038        ; ff
endbyte:
    halt             ; 76

The two copies are separated by a nop, since a relative jump is used to choose between them, and radiation could have shifted the program in a way that would make the jump skip the first byte after the destination. Additionally, the nop is encoded as a zero, which makes it easy to detect shifted bytes. Note that it doesn't matter which payload is chosen if the switch itself is corrupted, because then both copies are safe. Let's make sure that it will not jump into uninitialized memory, though:

Deleting $dd will make the next two bytes decode as or (hl) / dec d. Clobbers D. No big deal.
Deleting $b6 will create an undocumented longer encoding for dec d. Same as above.
Deleting $15 will read the $28 instead as the offset, and execution will proceed at the $0c, as below.
When $28 disappears, the $0c is decoded as inc c. The payload does not care about c.
Deleting $0c - that's what the nop is for. Otherwise, the first byte of the payload would have been read as the jump offset, and the program would jump into uninitialized memory.

The payload itself is pretty simple. I think the small size of the string makes this approach smaller than a loop, and it's easier to make position-independent this way. The e in beep repeats, so I can shave off one ld a. Also, because all memory between $0038 and $8000 is zeroed, I can fall through it and use a shorter rst variant of the call instruction, which only works for $0, $8, $10 and so on, up to $38.
Older approaches
64 bytes
00000000: 2e3f 3f2e 3f3f 7e7e a7a7 201f 1e2b 2b1e  .??.??~~.. ..++.
00000010: 2b2b 6b00 7ea7 2814 003e 62cd 0080 3e65  ++k.~.(..>b...>e
00000020: cd00 80cd 0080 3e70 cd00 8076 003e 62cd  ......>p...v.>b.
00000030: 0080 3e65 cd00 80cd 0080 3e70 cd00 8076  ..>e......>p...v

58 bytes
00000000: 2e39 392e 3939 7e7e a7a7 2019 3a25 00a7  .99.99~~.. .:%..
00000010: 2814 003e 62cd 0080 3e65 cd00 80cd 0080  (..>b...>e......
00000020: 3e70 cd00 8076 003e 62cd 0080 3e65 cd00  >p...v.>b...>e..
00000030: 80cd 0080 3e70 cd00 8076                 ....>p...v

53 bytes
This one has an explanation in the edit history, but it's not too different.
00000000: 3a34 00a7 a720 193a 2000 a728 1400 3e62  :4... .: ..(..>b
00000010: cd00 803e 65cd 0080 cd00 803e 70cd 0080  ...>e......>p...
00000020: 7600 3e62 cd00 803e 65cd 0080 cd00 803e  v.>b...>e......>
00000030: 70cd 0080 76                             p...v

What if: any non-empty output was fine instead of beep
1 byte
v

halts the program normally, but if radiation removes it, then the memory will be full of zeroes, making $8000 execute an infinite number of times, printing a lot of null bytes.

Since a starts at zero, can you not use or a, (N); instead of ld a, (N); and a;? It looks as if you can save a couple of bytes that way.

@Neil Good question! Unfortunately, on the Z80, only load instructions can take addresses like this.

Ugh, it's been too long since I did any Z80 programming... maybe I was thinking of or a, (ix + N)?

@Neil actually, that exists, and IX starts at zero too... unfortunately, saving a byte in that area makes the bytes shift in such a way that the 20 19 at the beginning becomes 20 18, and removing the 20 creates an unconditional jump backwards, so a nop has to be added after the first jump in the program, reversing the byte save.

Ah, that's a shame. Thanks for checking though!

Could rst 38h (byte ff) work as a shorter version of call $8000 here?

@Lynn it probably will... let me check!

@Neil FYI, after Lynn's -16 bytes, your -1 byte could also be integrated.

Actually it's -2 bytes: Try it online!

@Neil oh, clever!

@Neil I've finally decided to integrate that byte save into my answer, and managed to remove the and a too.

><>, 23 bytes
<|o<"beep"/
>o<"beep"<\

Try it online! Verification.
It's honestly really surprising how short I got this. Ends with an error.
Non-erroring version, 29 bytes
<<;oooo"beep"/
 ;oooo"beep"<\

Try it online!

Klein, one of each topology, totaling 291 bytes
After seeing WW's answer using the 001 topology, I decided to see how hard it would be to do a Geiger Counter for each topology. (Spoiler: very hard. It's difficult to figure out where the pointer will go without hand gestures that make me look like I'm figuring out which hand is my left)
Verification!
(I also thought about writing a program that is a valid Geiger counter on all topologies, but that might have to wait. If anyone else wants to try though, I'm offering a 500 rep bounty)
000 and 010, 21 bytes
<<@"peeb"/
.@"peeb"<\

Try 000 online! and Try 010 online!
This is ported from my ><> solution. This obviously works in 000, since that's the default topology for most 2D languages, but I was surprised that it also works in 010.
001 and 011, 26 bytes
!.<<@"peeb"/
.@"peeb"..<..

Try 001 online! and Try 011 online!
This one is copied directly from WW's answer. Thanks!
100, 21 bytes
//@"peeb"\
@"peeb".</

Try it online!
101, 21 bytes
//@"peeb"/
@"peeb".<!

Try it online!
110, 26 bytes
<.<@"peeb"\\
.\@."peeb".\<

Try it online!
111, 24 bytes
<<@"peeb"<\
...@"peeb"//

Try it online!
200, 21 bytes
<<@"peeb"\
@"peeb".!/

Try it online!
201, 31 bytes
\\.\.@"peeb"</./
./...@"peeb"<\

Try it online!
By far the most annoying.
210, 26 bytes
/\\@"peeb"</\
/@.."peeb"<\

Try it online!
211, 27 bytes
\\."peeb"((</
!/@@<"peeb"<\

Try it online!
The only one where I had to handle entering the beeper through the right side.

I've done your challenge.

Klein 0X1, 26 bytes
Works in both 011, and 001.
!.<<@"peeb"/
.@"peeb"..<..

Try it online!
Verify!
Explanation
This program takes advantage of Klein's unique topologies in particular the 001 and 011 topology, which are the Klein bottle and the real projective plane.  This explanation will focus on 001, the klein bottle.
Unedited the program follows the execution path:

Removing a byte from the program can effect the program in 4 ways (each in a different color):

The first thing to note is that << will always deflect the ip to the left of the origin at the start.  If one of the <s is deleted the other takes its place.  So if any byte is removed from the red section the following execution path will be followed:

If the blue byte is removed we get the very simple path:

If the newline is removed we get the path:

The yellow path is a bit more complex.  Since the bottom line is one longer than the top line, when the program is squared at the beginning of execution a virtual character is added to the end of the first line to make them the same size.  If any byte on the second line is removed the line is shortened and that virtual character is not added.  This is important because ! normally jumps over the virtual character, but in its absence it jumps over / instead.

You could port my ><> solution in 000 for 21 bytes

@JoKing I think that would be better as its own answer.

Self-modifying Brainfuck, 144 102 bytes
Unprintables are displayed as escape sequence (for example \x01).
\xa8<<[[<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<[[[.<-]>[>-]\x01qffb\x00\x00beep\x00]]]<[>]<<[>[-<+>]+<<]>[[>]>>[.>]]\x01

Verification!

Runic Enchantments, 29 bytes
>>yyLL@"peeb"/
     @"peeb"L\

Try it online!
Essentially the same as the Klein 000 answer or ><> answer (I started with the Klein one). The only change really needed was to turn the < into L and . into  (translation of command symbols), inserting the IP entry points (need 2, otherwise a deletion would result in a non-compiling program) and the insertion of the delay command to get the two IPs to merge (thus printing only one beep), again, needing two. Also required inserting additional NOPs to keep line lengths the same. Klein conveniently also uses @ for "print and terminate."
No ability to utilize the whitespace in the lower left, as any reflectors to change direction inhibits the ability to detect radiation. e.g. (26 bytes, irradiated y):
/yLL@"peeb"/
\<<  @"peeb"L\

Prints no output, due to the bent entry segment causing a re-reflection back to the lower line's terminator.

Backhand, 25 21 bytes
vv""ppeeeebb""jjHH@

Try it online! Verification!
This uses Backhand's ability to change the pointer step value to skip an instruction every step and neatly solve the redunancy issue. It then uses the j command to check if the code is irradiated by jumping to the last character (@, halt) if not, and jumping to the second last (H, halt and output stack) if so.

Befunge-93, 55 bytes
<< >       vv
>,,@#"beep"<"
v  |   _ #-<_
>"peeb",,,,@>

Try it online! Verification!
I'd hoped to get it a little smaller than this, but the length of the beep printer is the bottleneck.

Wumpus, 37 34 32 31 bytes
777*7..@ $o&4"beep"|"@peeb"4&o@

Try it online! Verification!
This solution uses the fact that . jumps to a position modulus the length of the program.
Alternatively for the same amount of bytes

" @o&4"beep"}@
@o&4"beep"}$}

Try it online! Verification!
This one utilises the difference in the direction of the pointer for odd and even line lengths. (I don't really know how the first " actually works when the newline is removed)

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Optimal Caching
You will be given a sequence of memory requests and a cache size. You must return the least possible number of cache misses under any cache replacement strategy.
An optimal strategy is Belady's algorithm, which you can use if you want to.

A caching system works as follows: The cache starts out empty. Memory requests come in. If the request asks for a piece of data in the cache, all is well. If not, you incur a cache miss. At this point you may insert the data that  was request into the cache for future use. If the cache was full and you want to insert new data, you must evict data that was previously in the cache. You may never insert data that was not just in the cache.
Your goal is to find the minimum possible number of cache misses for a given memory request sequence and cache size.

You will be given the cache size, a positive integer, and the memory request sequence, which is a list of tokens. These tokens can be whatever kind of tokens you like, as long as at least 256 different tokens are possible (bytes are fine, bools are not). For instance, ints, strings, lists are all fine. Ask for clarification if needed.

Test  cases:
3
[5, 0, 1, 2, 0, 3, 1, 2, 5, 2]

6

See wikipedia for a replacement policy that achieves this.
2
[0, 1, 2, 0, 1, 0, 1]

3

Simply avoid adding 2 to the cache.
3
[0, 1, 2, 1, 4, 3, 1, 0, 2, 3, 4, 5, 0, 2, 3, 4]

9

One way to achieve this is by never evicting 0 and 2, and evicting 1 as soon as possible after its last use.

Scoring: This is code golf. Fewest bytes wins.

Can we assume that the list contains at least 2 tokens?

@Arnauld I'm going to say no, though if there's only 1 solution, the answer is of course always 1.

JavaScript (ES6), 128 bytes
Takes input as (size)(list).
s=>a=>a.map((x,i)=>c.includes(x)?0:c[e++,[x,...c].map(m=(x,j)=>(k=[...a,x].indexOf(x,i+1))<m||(p=j,m=k)),i<s?i:p-1]=x,e=c=[])&&e

Try it online!
Commented
This is an implementation of Belady's algorithm.
s => a =>                      // s = cache size; a[] = token list
  a.map((x, i) =>              // for each token x at position i in a[]:
    c.includes(x) ?            //   if x is currently stored in the cache:
      0                        //     do nothing
    :                          //   else:
      c[                       //     update the cache:
        e++,                   //       increment the number of errors (cache misses)
        [x, ...c]              //       we want to find which value among x and all current
                               //       cache values will be needed for the longest time in
                               //       the future (or not needed anymore at all)
        .map(m =               //       initialize m to a non-numeric value
                 (x, j) =>     //       for each x at position j in this array:
          ( k = [...a, x]      //         k = position of x in the array made of all values
            .indexOf(x, i + 1) //         of a[] followed by x, starting at i + 1
          ) < m                //         if it's greater than or equal to m, or m is
          || (p = j, m = k)    //         still non-numeric: set p to j and m to k
        ),                     //       end of inner map()
        i < s ?                //       if i is less than the cache size:
          i                    //         just fill the cache by using the next cache slot
        :                      //       else:
          p - 1                //         use the slot that was found above
                               //         special case: if p = 0, x was the best candidate
                               //         and we're going to store it at c[-1], which is
                               //         simply ignored (it will not trigger c.includes(x))
      ] = x,                   //     store x at this position
      e = c = []               //     start with e = [] (coerced to 0) and c = []
  ) && e                       // end of outer map; return e

Perl 5, 193 bytes
sub g{
  my($i,$m,$s,@a,%c)=(-1,0,@_);
  for(@a){
    $i++;
    next if $c{$_}++ || ++$m && keys%c <= $s;
    my($x,$d);
    for $k (sort keys %c){  #find which to delete, the one furtherst away
      my $n=0;
      ++$n && /^$k$/ && last for @a[$i+1..$#a];
      ($x,$d)=($n,$k) if $n>$x
    }
    delete $c{$d}
  }
  $m
}

Try it online!
print g(3,  5, 0, 1, 2, 0, 3, 1, 2, 5, 2),"\n";                     # 6
print g(2,  0, 1, 2, 0, 1, 0, 1),"\n";                              # 3
print g(3,  0, 1, 2, 1, 4, 3, 1, 0, 2, 3, 4, 5, 0, 2, 3, 4),"\n";   # 9

193 bytes without indentation, newlines, spaces, comments:
sub g{my($i,$m,$s,@a,%c)=(-1,0,@_);for(@a){$i++;next if$c{$_}++||++$m&&keys%c<=$s;my($x,$d);for$k(sort keys%c){my$n=0;++$n&&/^$k$/&&last for@a[$i+1..$#a];($x,$d)=($n,$k)if$n>$x}delete$c{$d}}$m}

05AB1E, 20 bytes
vI∍Dyå≠i¼yª¹N.$sÃÙ]¾

Try it online!

Haskell, 82 bytes
f n|let(d:t)#c=1-sum[1|elem d c]+minimum[t#take n e|e<-scanr(:)(d:c)c];_#_=0=(#[])

Try it online!
Explanation
Works by brute force: all cache strategies are tried and the best result is returned.
f n            Define a function f on argument n (cache size) and a list (implicit).
 |let(d:t)#c=  Define binary helper function #.
               Arguments are list with head d (current data) and tail t (remaining data), and list c (cache).
 1-            It returns 1 minus
 sum[1|        1 if
 elem d c]+    d is in the cache, plus
 minimum[      minimum of
 t#            recursive calls to # with list t
 take n e|     and cache being the first n values of e, where
 e<-           e is drawn from
 scanr(:)  c]  the prefixes of c
 (d:c)         with d and c tacked to the end.
 ;_#_=0        If the first list is empty, return 0.
 =(#[])        f then calls # with the list argument and empty cache.

Perl 6, 146 bytes
->\a,\b {$_=set();$!=0;for b.kv ->\i,\v {$_{v}&&next;++$!;v∈b[i^..*]||next;$_∖=.keys.max({(grep $_,:k,b[i^..*])[0]//Inf})if $_>=a;$_∪=v};$!}

Try it online!


text:
Decrypt the extended Wechsler format
This challenge is based on a sandbox post by user48538. Since he is no longer active on this site, I took over this challenge.

apgsearch, the distributed soup search program for Conway's Game of Life and the search results database, Catagolue use apgcodes to classify and denote patterns. apgcodes themselves use the extended Wechsler format, an extension of a pattern notation developed by Allan Wechsler in 1992.
The following examples and the images are taken from LifeWiki.

A string of n characters in the set matching the regex [0-9a-v] denotes a strip of five rows, n columns wide. Each character denotes five cells in a vertical column corresponding to the bitstrings [00000, 10000, 01000... 00010, 10010, 01010, 11010... 11111].
For instance, 27deee6 corresponds to a heavyweight spaceship:

$$ \begin{bmatrix}
{\color{Gray}0} & 1 & 1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
1 & 1 & {\color{Gray}0} & 1 & 1 & 1 & 1 \\
{\color{Gray}0} & 1 & 1 & 1 & 1 & 1 & 1 \\
{\color{Gray}0} & {\color{Gray}0} & 1 & 1 & 1 & 1 & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0}
\end{bmatrix} $$

The character z separates contiguous five-row strips.
For example, 0ca178b96z69d1d96 corresponds to a 31-bit still life:

$$ \begin{bmatrix}
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & 1 & 1 & {\color{Gray}0} & 1 & 1 & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & 1 & {\color{Gray}0} & 1 & {\color{Gray}0} & 1 & {\color{Gray}0} & 1 \\
{\color{Gray}0} & 1 & {\color{Gray}0} & {\color{Gray}0} & 1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & 1 \\
{\color{Gray}0} & 1 & 1 & {\color{Gray}0} & {\color{Gray}0} & 1 & 1 & 1 & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & 1 & 1 & 1 & 1 & 1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & 1 & {\color{Gray}0} & {\color{Gray}0} \\
1 & {\color{Gray}0} & 1 & {\color{Gray}0} & 1 & {\color{Gray}0} & 1 & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & 1 & 1 & {\color{Gray}0} & 1 & 1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0}
\end{bmatrix} $$

The characters w and x are used to abbreviate 00 and 000, respectively.
So w33z8kqrqk8zzzx33 corresponds to a trans-queen bee shuttle:

(10 blank rows omitted)

$$ \begin{bmatrix}
{\color{Gray}0} & {\color{Gray}0} & 1 & 1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & 1 & 1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & 1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & 1 & 1 & 1 & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & 1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & 1 & {\color{Gray}0} \\
1 & {\color{Gray}0} & 1 & 1 & 1 & {\color{Gray}0} & 1 \\
{\color{Gray}0} & 1 & 1 & 1 & 1 & 1 & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & 1 & 1 & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & 1 & 1 & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0}
\end{bmatrix} $$

Finally, the symbols matching the regex y[0-9a-z] correspond to runs of between 4 and 39 consecutive 0s.
A good example is 31a08zy0123cko, corresponding to a ship on quadpole:

$$ \begin{bmatrix}
1 & 1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
1 & {\color{Gray}0} & 1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & 1 & {\color{Gray}0} & 1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & 1 & {\color{Gray}0} & 1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & 1 & 1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & 1 & 1 & {\color{Gray}0} \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & 1 & {\color{Gray}0} & 1 \\
{\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & 1 & 1
\end{bmatrix} $$
The Challenge
Write a program or a function to parse a string of the extended Wechsler format, defined above, and print (or return) the pattern corresponding to this string.
You may assume that the string is nonempty, and does not start or end with z.
You may use any reasonable output format, e.g., a string, a matrix, a 2d array. You may use any two values to represent 0 and 1, given that you declare them in the answer.
You may omit the trailing zeroes lines in the output, or add extra trailing zeroes lines. You may also add/omit trailing zeroes on each line, as long as all lines have the same length in the output.
You may return the transpose of the array, if that is more convenient.
This is code-golf, so the shortest code wins.
Test cases
153 => [[1, 1, 1], [0, 0, 1], [0, 1, 0], [0, 0, 0], [0, 0, 0]]
27deee6 => [[0, 1, 1, 0, 0, 0, 0], [1, 1, 0, 1, 1, 1, 1], [0, 1, 1, 1, 1, 1, 1], [0, 0, 1, 1, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0]]
0ca178b96z69d1d96 => [[0, 0, 0, 1, 1, 0, 1, 1, 0], [0, 0, 1, 0, 1, 0, 1, 0, 1], [0, 1, 0, 0, 1, 0, 0, 0, 1], [0, 1, 1, 0, 0, 1, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 1, 1, 1, 1, 0, 0, 0], [1, 0, 0, 0, 0, 0, 1, 0, 0], [1, 0, 1, 0, 1, 0, 1, 0, 0], [0, 1, 1, 0, 1, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]]
w33z8kqrqk8zzzx33 => [[0, 0, 1, 1, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 1, 0, 0, 0, 1, 0], [1, 0, 1, 1, 1, 0, 1], [0, 1, 1, 1, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0], [0, 0, 0, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]]
31a08zy0123cko => [[1, 1, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0, 1], [0, 0, 0, 0, 0, 0, 0, 0, 1, 1]]
o5995ozes88sezw33 => [[0, 1, 1, 1, 1, 0], [0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 1, 0], [1, 0, 1, 1, 0, 1], [1, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, 1], [1, 1, 0, 0, 1, 1], [1, 1, 1, 1, 1, 1], [0, 1, 0, 0, 1, 0], [0, 0, 1, 1, 0, 0], [0, 0, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]
y3343x6bacy6cab6x343zkk8yy8kkzgo8gywg8ogz0123yw321zzgo4syws4ogzgh1yy1hgz221yy122zy3c2cx6d53y635d6xc2c => [[0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1], [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0], [1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1], [0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0], [0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0], [0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0], [1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1], [0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1], [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]

Will z ever occur at the very beginning?

@Mr.Xcoder The LifeWiki page does not say anything about that. But you can assume here that the string does not start or end with z.

Not really a Game of Life pattern, but just for fun: vv99f60vv99f60uv11320uv19rqz33y133y11322310132231

"You may return the transpose of the array" - if that's OK, what about other symmetries like upside-down etc...?

Two of the first three answers fail for some of these: 1yx1, 1yy1, 1yw1 and 1yz1. Maybe they should be tests.

Can the input be taken a upper case?

Charcoal, 50 bytes
ＵＢ0≔⁺⭆χιββＦＳ¿υ×0⁺⊟υ⌕βι≡ιz×⸿⁵y⊞υ⁴x×0³w¦00«Ｐ↓⮌⍘⌕βι²→

Try it online! Link is to verbose version of code. Uses 1 and 0. Explanation:
ＵＢ0

Set the background, i.e. any unprinted cells of the rectangle enclosing the output, to 0.
≔⁺⭆χιββ

Prefix the digits to the predefined lower case alphabet.
ＦＳ

Loop over the input string.
¿υ

If the predefined empty list is not empty...
×0⁺⊟υ⌕βι

... then print a number of 0s given by the sum of the number popped from the list and the index of the current character in the digits and letters. See below for what that number always is.
≡ι

Switch over the current character.
z×⸿⁵

If it's a z then output 5 carriage returns, taking us to the next output strip.
y⊞υ⁴

If it's a y, then push 4 to the predefined empty list, causing 4+n 0s to be output next time.
x×0³

If it's an x then output 3 0s. (This is done via repetition to avoid the literal 0 touching the x or the following literal.)
w¦00

If it's a w then output 2 0s. (The ¦ is needed to separate the two string literals.)
«Ｐ↓⮌⍘⌕βι²→

Otherwise, index the current character in the digits and letters, convert to binary, and print the result downwards least significant bit first; then move the cursor right for the next column.

JavaScript (ES8), 197 bytes
Takes input as a string. Returns an array of strings with '#' and spaces. The output may include extra (but consistent) trailing spaces on each line.
s=>[x='x',...s.replace(/w|x|y./g,s=>''.padEnd(s<x?2:s>x?P(s[1],36)+4:3),P=parseInt)].map(c=>[!++w,1,2,3,4].map(i=>c<x?o[y+i-5]+=' #'[P(c,36)>>i&1]:o=[...++y&&o,'']),w=y=o=[])&&o.map(r=>r.padEnd(w))

Try it online! (prettified output)
How?
Global variables

The character "x" is used several times, so it's worth storing it into the variable x.
The function parseInt is used twice, so it's worth storing it into the variable P.
y is the row index, initialized to 0.
w keeps track of an upper bound of the width which is used to pad the final output.
o[ ] is the output array, initially empty.

Pre-processing of repeated zeros
We first replace all patterns "w", "x" and "yX" in the input string with the appropriate number of spaces. These spaces will later be interpreted as "0".
s.replace(
  /w|x|y./g,
  s => ''.padEnd(
    // w --> 2
    s < x ? 2 :
    // yX --> value of X + 4
    s > x ? P(s[1], 36) + 4 :
    // x --> 3
    3
  )
)

Decoding
We split the resulting string, prepend an initial "x" and iterate 5 times (with i = 0 to 4) on each character c:

If c is lower than "x", we append the corresponding pattern to the next 5 rows.
o[y + i - 5] += ' #'[P(c, 36) >> i & 1]

If c is greater than or equal to "x", we allocate 5 new empty strings in o[ ] and add 5 to y. This is triggered by the initial "x" that was added at the beginning of the string, or by any "z" in the original content.
o = [...++y && o, '']

Padding
Finally, we pad each string in o[ ] with spaces so that they all have w characters.
o.map(r => r.padEnd(w))

05AB1E, 148 132 98 bytes
I'm a highschool student and this was my first time for both golfing and using 05AB1E, so comments are appreciated!
„YY¾38×:'Yð:žLRDUsð«#εNĀiDнXsk4+s¦sú]'W¾2×:'X¾3×:J'Z¶:.Bð¾:vNUyvDykDNX‚Š32VY‹iY+b¦RX_i¶ì}‚ˆ]¯{€¦˜J

Try it online!
Try it online!
Try it online!
Takes input as uppercase and outputs the transposed matrix as multiple output lines of 1s and 0s. May add extra zeros.
If you want to test with lowercase strings, add u in the TIO header.
If you want pretty-printed output, add '1'█:'0'.: in the TIO footer.
Explanation
(I'm calling "rows" and "columns" opposite of what you might expect because it generates the transposed matrix)
The basic algorithm is:

Replace "yy" with 38 0s
Split on "y" and and expand the 0-runs.
Replace "w" and "x"
Figure out the longest column (that is, the longest string between z's) and pad all the other columns so they are that length. (This is necessary because of how the algorithm below works)
Split on z
At this point, the input string is an array of columns where each column is a string of [0-9A-V], where each column is the same length.
The algorithm to get it into the output format is to

Convert the characters to numbers by using indexOf in a lookup string
Convert the characters to binary and then pad to length 5
If it is the first column, add a linebreak before the binary number
Add a prefix to the beginning of the binary string that stores the row and then the column of the character.
Push the binary string with prefix to 05AB1E's "global array" register/variable

Sort the global array. The prefix string, which determines the sort order, will make sure everything ends up in the right order and the linebreaks are in the right places.
Remove the prefix string from each element of the global array
Join the array with "" and print it.

There are some other minor details you can see below in the expanded code. Everything after the tabs at the end of a line is a comment and can be ignored. (This comment scheme is not part of 05AB1E, by the way. I did it this way because it looked nice.) Lines that have comments starting with "@" are for debugging purposes and can be omitted without changing the final output.
„YY¾38×:                                        Replace "YY" with 38 0's. (y is the 34th character in the index, so need to add 34+4 = 38). ¾ is initialized to zero, which saves one byte from typing '038
'Yð:                                            Replace "Y" with " "
"Replaced input Stage1 = "?D,                   @DEBUG

žLR                                             Pushes [0-9A-Za-z]
DU                                              Set X to [0-9A-Za-z] and leave [0-9A-Za-z] on the stack.
s                                               Swap top two elements. Now the stack is [0-9A-Za-z],input

ð«                                              Append a space so the below splitter works even if there are no other spaces.
#                                               Split input on " ", which "Y" has been replaced with
ε                                               Map. This map replaces the y runs
    "Element = "?D,                             @DEBUG
    "N = "?N,                                   @DEBUG
    NĀi                                         If N != 0
        "Replacing!",                           @DEBUG
        Dн                                      Get the first letter
        X                                       Push X
        s                                       Swap
        k                                       X (which is [0-9A-Za-z]) .indexOf(firstLetter)
        "indexOf run token = "?D,               @DEBUG
        4+                                      Add 4 to the index, now becoming the number of zeros to add
        s                                       Swap. Now top is the string between runs
        ¦                                       Remove the first character
        s                                       Swap again. Now the top is the number of zeros to add.
        ú                                       Add that many spaces (will be replaced with zeros later) to the start of the element.
        "Element Replaced = "?D,                @DEBUG
]
'W¾2×:                                          Need to do this replacement after the Y replacement so stuff like YW gets parsed properly. Again, ¾ is zero.
'X¾3×:
J                                               Join with ""
"Replaced input Stage2 = "?D,                   @DEBUG
'Z¶:                                            Replace "Z" with "¶".
.B                                              "Squarify" command. Splits on \n and appends spaces to the end of each element so each is the same length. In this case, that is equivalent to adding zeros to the end of each column, which is what we want.
ð¾:                                             Replace spaces (which we used for padding above) with zeros.
"Replaced input Stage3 = "?D,                   @DEBUG
"0 Stack top = "?D,                             @SDEBUG
"0 Stack top-1 = "?sD,s                         @SDEBUG
v                                               pop and loop over top element, which is array of column code
    NU                                          Store the column number in X
    yv                                          Loop over each character in the column
        "1 Stack top = "?D,                     @SDEBUG
        "1 Stack top = "?D,                     @SDEBUG
        D                                       Duplicate top element (which is now [0-9A-Za-z])
        y                                       Push y (special loop variable)
        "Character = "?D,                       @DEBUG
        k                                       Push indexOf y in [0-9A-Za-z]
        "Index = "?D,                           @DEBUG
        "2.1 Stack top = "?D,                   @SDEBUG
        "2.1 Stack top-1 = "?sD,s               @SDEBUG
        D                                       Duplicate index.
        NX‚                                     Push [rowNumber,columnNumber]. This result is used for sorting.
        Š                                       Triple swap. The top of the stack is now sortPrefix, index, index
        32V                                     Set Y to 32
        Y‹i                                     index < 32. This uses up one copy of index
            Y+                                  Add 32 to the index
            b                                   Push the index in binary. This uses the second copy of index.
            ¦                                   Remove the first character, which will be a 1 because we added 32. The result is now a padded binary string of length 5
            "Binary = "?D,                      @SDEBUG
            R                                   Reverse the binary string. This gives the proper transposed output.
            X_i                                 This will only run if X (which is set to the column number) == 0. (Runs !X)
                ¶ì                              Stick a linebreak at the beginning of the binary string
            }
            "2.5 Stack top = "?D,               @SDEBUG
            "2.5 Stack top-1 = "?sD,s           @SDEBUG
            ‚                                   At this point the top of the stack is sortPrefix,binaryString. This will combine the two into a list.
            "Pushing '"?D?"'",                  @DEBUG
            ˆ                                   Push [[rowNumber,columnNumber],binaryString] to global array
            "2.6 Stack top = "?D,               @SDEBUG
            "2.6 Stack top-1 = "?sD,s           @SDEBUG
        ]                                       Close all blocks
¯                                               Push global array

{                                               Sort global array.
"Sorted Data = "?D,                             @DEBUG
€¦                                              Remove the sort prefix
˜                                               Flatten. Before doing this, the array is in the format [[<binary string>],[<binary string>],[<binary string>],...]
J                                               Join with ""
'1'█:'0'.:                                      @DEBUG pretty print

Hello and welcome to PPCG; very nice first post! Regarding your byte count: you are right. TIO even handily displays that the 148 characters are represented by 148 bytes using the 05AB1E code page.

One small note: Most golfing languages implement implicit printing; I think you can ommit your last ,.

I looked it over and made some improvements. The behavior will only be different (theoretically) for things with more than 1000 rows or columns, at which point the smaller program will do something unexpected.

Not the easiest challenge to start on! Nice job, I imagine some of the 05AB1E stalwart will give some handy pointers when they come by.

Welcome to PPCG and the world of 05AB1E. I don't have that much time right now, and I've only started using 05AB1E a few months ago, so I'm not that much of a pro yet either, but here some small things to golf: "yy" can be „yy (05AB1E has both a 2-char and 3-char string builtin). >≠ can be Ā (truthified, basically 0 remains 0 and everything else becomes 1). }} can be ] (close all loops and if-elses). I'm sure some of the pro 05AB1E golfers are able to golf more substantial things than me, possibly even halving the byte-count.

If you haven't seen it yet, we have a Tips for golfing in 05AB1E, and there is also a 05AB1E chat where you could ask for help, tips, or have questions about certain behavior. Enjoy your stay here on PPCG and using 05AB1E! :)

Thanks for the comments! I incorporated them into the new version and also found a way to golf a lot of stuff.

APL (Dyalog Unicode), 87 80 77 67 63 bytes
thanks to H.PWiz for saving 7 bytes and ngn for another 13 17.
a←⎕D,⎕A⋄,⍉↓⊖(5/2)⊤↑35(≠⊆⊢)a⍳'Y.|W|X'⎕R{'0'/⍨30 36|a⍳2↑⍵.Match}⍞

Try it online!
NB: Takes the input as an upper case string.
With pretty printed output
Explanation
a←⎕D,⎕A a is the string '0123...89ABCD...XYZ'
'Y.|W|X'⎕R{'0'/⍨+/30 36|a⍳2↑⍵.Match} replaces X W and Yx with the corresponding number of '0's (explained more below)
35(≠⊆⊢)a⍳ converts the string into vector of indecies in a and splits on 35 (i.e.) 'Z' creating a nested vector
↑ converts the nested vector into a matrix padding ends with 0s
(5/2)⊤ converts each number into a binary vector resulting in a 3-dimensional matrix with binary vectors along the primary axis
⊖ reverses along the primary axis
↓ reduces the rank of the matrix so it is 2-dimensional
,⍉ reshapes the result to the appropriate output
'Y.|W|X'⎕R{'0'/⍨30 36|a⍳2↑⍵.Match}
'Y.|W|X'⎕R                         ⍝ Regular expression replace. mathing the string.
                        2↑⍵.Match  ⍝ Takes matching string (either 'X' 'W' or 'Y.') and pads with spaces to length 2
                      a⍳           ⍝ Returns the indecies of each charactor in a. on the spaces this is 36 (length of a)
                30 36|             ⍝ Takes the remainders of the indecies when divided by 30 and 36 respectively. Overall 'W' -> 'W ' -> 32 36 -> 2 0, 'Y2' -> 'Y2' -> 34 2 -> 4 2.
           '0'/⍨                   ⍝ Make vector of repeating '0's with length equal to the sum of the result. '0'/⍨4 2 ≡ '000000'

Here is a 7 byte saving: a←⎕D,⎕A⋄,↓↑{⊖(5/2)⊤a⍳⍵}¨'Z'(≠⊆⊢)('Y.|W|X'⎕R{'0'/⍨{0::2+'WX'⍳⍵⋄4+a⍳1⊃⍵}⍵.Match})⍞. The error catch also doesn't seem very golfy

Thanks @H.PWiz. Yeah I don't like the error catch either but otherwise I was using two regex replaces.

@jslip the parentheses around ⎕R and its operands are unnecessary

2+'WX'⍳⍵ -> 2+'X'=⍵

{0::2+'X'=⍵⋄4+a⍳1⊃⍵}⍵.Match -> 30 36|a⍳2↑⍵.Match

Oh wow. They keep coming.

@jslip m← and +/ in my last comment were unnecessary - last change for now, as I must cook dinner :)

@ngn I knew the m← was but didn't notice +/ was unecessary. Nice

Let us continue this discussion in chat.

Retina, 203 bytes
y(.)
#$1
{`#
0#
#0
000
)T`dl`_dl`#.
w
000
x
00
z
¶
%(`.+
$&¶$&¶$&¶$&¶$&
T`g-v`#`.+$
T`dl` `.+$
T`g-v`dl
T`89l`#`.+¶.+$
T`d` `.+¶.+$
T`89l`d
T`d`    #`.+¶.+¶.+$
T`4-7`d
T`d`  #`.+¶.+¶.+¶.+$
)T`d` # #
P`.+

Try it online! Link includes test cases. Alternative solution, also 203 bytes:
y(.)
#$1
{`#
0#
#0
000
)T`dl`_dl`#.
w
000
x
00
z
¶
%(`.+
$&¶$&
T`g-v`#`¶.+
T`dl` `¶.+
T`g-v`dl
^.+
$&¶$&
T`89l`#`¶.+
T`d` `¶.+
T`89l`d
^.+
$&¶$&
T`d`    #`¶.+
T`4-7`d
^.+
$&¶$&
T`d`  #`¶.+
)T`d` # #
P`.+

Try it online! Link includes test cases. Explanation:
y(.)
#$1

First handle the awkward case of the y command. Sadly the letter after this is allowed to be a y or even a z, so we have to be careful here. All the magic ys are first turned into #s.
{`#
0#
#0
000
)T`dl`_dl`#.

A loop then processes the #s. First, a 0 is prepended to the #. If this is a #0 then that is changed to 000 which completes the operation, otherwise the character after the # is decremented and the loop repeats until all of the #s have been processed.
w
000
x
00

Fix up the ws and xs.
z
¶

Split on new lines. (S`z also works for the same byte count.)
%(`.+
$&¶$&¶$&¶$&¶$&
T`g-v`#`.+$
T`dl` `.+$
T`g-v`dl
T`89l`#`.+¶.+$
T`d` `.+¶.+$
T`89l`d
T`d`    #`.+¶.+¶.+$
T`4-7`d
T`d`  #`.+¶.+¶.+¶.+$
)T`d` # #

Make 5 copies of each line, then perform binary conversion by mapping letters with the appropriate bit to # and clearing that bit, while other letters become spaces. The bits are processed in the order 16, 8, 4, 2, and then the last translation handles clearing the 2 bit and converting the 1 bit at the same time. (The alternative version makes each copy individually which costs more bytes but these are saved because the bit handling is simplified.)
P`.+

Pad all the lines to the same length.

Perl 6, 156 142 bytes
14 bytes saved thanks to Jo King. (Also fixed a little bug with parsing the y and added a prettifier.)
Fixed the buggy parsing of y[wxy].
{s:g/y(.)/000{0 x:36(~$0)}/;s:g/x/w0/;s:g/w/00/;s/$/z/;map {
.flatmap:{:32($_).fmt("%05b").flip.comb}},[Z] .split("z").map: (*~0 x.chars).comb}

Try it online!
The line break is there just to make the text fit on the screen. It is not a part of the program.
How does it work
It is an anonymous function that takes a mutable string. (This makes using the function a little bit peculiar, because you can give it only variables, not literals.) After some work, it returns a list of lists containing 0's and 1's, with the same meaning as in the original post.
The input string comes in in the variable $_. We start by using a series of substitution statements on it in order to get rid of all of those shorthands for various numbers of zeroes. First, we need to sort out the y, because in the case of yx or yw, the w (or x) does not constitute a shorthand by itself. We search for y(.) (y and one character, which it remembers) and replace it by 000{"0"x:36(~$0)}: the three zeroes are copied verbatim, then we convert the next character from base 36 to base 10 (:36(~$0)) and add that many more zeroes. Then, we replace the w's using s:g/w/00/, and the x's using s:g/x/000/. Finally, with s/$/z/, we add a z onto the end, adding a whole lot of empty lines to the bottom. (We'll see the reason later.)
The rest is just a big map statement. We're mapping over .split("z").map: (*~0 x.chars).comb}), which is the input string (without zero shorthands), splitted into lines at z, with each line being first padded with 0 x.chars (tons of zeroes, namely as many as is the total length of the input string) on the right and then broken down into a list of individual characters (.comb). Finally, we transpose it with [Z] (reduce with zip). Zipping ends as soon as the shortest list is depleted, which results in all lines having the same length. (The number of useless trailing zeroes on the right is equal to the length of the shortest line. Also, this transposition trick fails for a "matrix" with only one row. That's why we forcibly added another row at the end before.)
Now, we just map over the rows (columns of the original matrix) and replace each character encountered with the corresponding 5 bits. That is done using :32($_) (base 32 to base 10) .fmt("%05b") (format as a bitstring of width 5, padded with zeroes) .flip (reverse the string, because the LSB is in the top row, not the bottom) .comb (break the string into a list of characters). We have used .flatmap, which flattens the resulting list (otherwise we would get a list of lists in each column). The transpose of the result is then implicitly returned.
(I feel a little bit bad because of abusing the possibility of trailing zeroes so hard. But it reduced the bytecount quite considerably :—).)

142 bytes

@JoKing — Oh yes, thank you very much!

Fails for 1yx1 and 1yw1

@JonathanAllan, you're right, thank you. I'll fix it in a moment. (I first thought for some reason that there could be only y[0-9a-v] and when I found that it's not the case, I just added a quick (and wrong) fix.)

You can replace the 000 in the y substitution with x

Combining the regexes (among other things) for 131 bytes

Jelly, 66 bytes
Yowza!
ØBiⱮ+
Œuœṣ⁾YYj38Żṣ”YµḢç3;)Fṣ”Wj2ṣ”Xj3”0ẋ$¹OƑ?€Fṣ”Zµȯ”0ç31BḊ€UZ)Ẏz0

A monadic link which yields a transposed version as a list of lists (add Z to the end to transpose back).
Try it online! Or see the test-suite (with pretty printed output).

JavaScript (ES8), 192 bytes
s=>[...s,"z"].map(c=>{h=parseInt(c,36);k="wxy".search(c)+1;y?k=h-y--:h-35?y=h>33:m=m.map(P,z+=5,i=k--);for(h=k?0:h;~k--;m[i]=h.toString(2)+P(m[i++]||""));},P=d=>d.padStart(z,0),m=[i=z=y=0])&&m

Returns the transpose... which is then reflected across the vertical axis; let me
know if that invalidates this entry. Output is an array of strings containing
0s and 1s.
Try it online!
Explanation
For each character c, k+1 evaluates to the number of rows to modify.
k = "wxy".search(c) + 1;, where the search method returns the index or -1.
k is then decremented until it reaches -1 by checking ~k-- for a truthy
value.
If the current character is "y", set a flag so that the base-36 value of the next character - 1 becomes the value for k.
Upon encountering a "z", pad strings to the left, increment the pad amount by 5,
and reset the array index to 0.
s =>
    [...s, "z"].map(c => {                  // append a "z" to ensure final output is properly padded
        h = parseInt(c, 36);
        k = "wxy".search(c) + 1;            // note that "y" -> 4 zeroes
        y                                   // if previous char is "y"...
            ? k = h - y--                   //      decrement y after subtracting y=1 since k is decremented to -1 and the previous y already pushed 4 zeroes
        : h - 35                            // else if current char is not "z"...
            ? y = h > 33                    //      set y if current char = "y"
        : m = m.map(P, z += 5, i = k--);    // else if current char is "z", pad
        for (
            h = k ? 0 : h;                  // if k is truthy, push zeroes
            ~k--;
            m[i] = h.toString(2)            // convert to boolean representation
                + P(m[i++] || "")           // prepend to row or to a newly padded row
        );
    },
        P = d => d.padStart(z, 0),
        m = [i = z = y = 0]                 // the logical OR 4 lines above replaces this value with ""
    ) &&
    m

I think it would make more sense not to return the transpose of the input.

Haskell, 399 bytes
Install split package: cabal install split
import Data.Char
import Data.List.Split
import Data.List
p=map
r=replicate
a c|47<c&&c<58=c-48|96<c&&c<123=c-87
o=a.ord
m l n|l==0=[]|True=(mod n 2):m(l-1)(div n 2)
t a=p(\l->l++r((maximum$p length a)-length l)'0')a
y s|length s==0=""|h=='y'=(r(4+(o$s!!1))'0')++y(drop 2 s)|h=='w'="00"++y t|h=='x'="000"++y t|True=h:y t where h=head s;t=tail s
w=(p concat).transpose.(p$p$(m 5).o).t.(splitOn "z").y

Python 2, 249 244 bytes
def f(s,Z='0'):
 while'y'in s:i=s.find('y');s=s[:i]+4*Z+Z*int(s[i+1],36)+s[i+2:]
 t=s.replace('w',2*Z).replace('x',3*Z).split('z');return map(''.join,zip(*[[(Z*5+bin(int(c,32))[2:])[:-6:-1]for c in r]+[Z*5]*(max(map(len,t))-len(r))for r in t]))

Try it online!
5 bytes saved by Jonathan Frech.

There is a superfluous space in while 'y'in. I think the subscript [-5:][::-1] can be golfed to [:-6:-1]. The return statement can be put on the previous line.


text:
Make the super number hyper-pyramid
Challenge
Given a positive integer \$n\$, output the \$n\$-dimensional pyramidal list.
Example

\$n = 1\$:

Objects arranged in a 1D pyramid (line) with side length 1 is just by itself.
So, the output is {1}.

\$n = 2\$:

Objects arranged in a 2D pyramid (a triangle) with side length 2 would have one on the first row (cyan), and two on the second row (magenta).
Note, the first row is a 1D pyramid with side length 1 ({1}), and the second row is a 1D pyramid with side length 2 ({1, 1}).
So, the output is {{1}, {1, 1}}.

\$n = 3\$:

Objects arranged in a 3D pyramid with side length 3 would have 3 layers:

The first layer (cyan) is a 2D pyramid with side length 1. It has one row, which has one object. ({{1}})
The second layer (magenta) is a 2D pyramid with side length 2; It has two rows: the first row with one object and the second row with two objects. ({{1}, {1, 1}})
The third layer (yellow) is a 2D pyramid with side length 3; it has three rows: the first row with one object, second with two, and third with three. ({{1}, {1, 1}, {1, 1, 1}})

So, the output is {{{1}}, {{1}, {1, 1}}, {{1}, {1, 1}, {1, 1, 1}}}.

\$n = k\$
This is a \$k\$ dimensional pyramid with side length \$k\$. Each "layer" would be a \$k-1\$ dimensional pyramid, whose side length is its index (1-indexed).

Sample Outputs
n  output

1  {1}

2  {{1},
    {1, 1}}

3  {{{1}},
    {{1}, {1, 1}},
    {{1}, {1, 1}, {1, 1, 1}}}

4  {{{{1}}},
    {{{1}}, {{1}, {1, 1}}},
    {{{1}}, {{1}, {1, 1}}, {{1}, {1, 1}, {1, 1, 1}}},
    {{{1}}, {{1}, {1, 1}}, {{1}, {1, 1}, {1, 1, 1}},
     {{1}, {1, 1}, {1, 1, 1}, {1, 1, 1, 1}}}}

Rules

No standard loopholes as always.
The innermost values of your list may be anything (does not need to be consistent for all elements), as long as they are not lists.

This is code-golf, so shortest submissions in each language win!

Note: Graphics generated using Mathematica

I hammered this as a dupe since the only difference from the other challenge is that $a=b$. However, I upvoted this, since it was pretty hard to find the dupe and only managed to do so when I tried solving it, and this is a good challenge otherwise.

@EriktheOutgolfer you're right. Huh, I left this post in the Sandbox for 10 days in case this would happen. :(

Wolfram Language (Mathematica), 16 bytes
Ha! Of course it is biased towards Mathematica!
Nest[Range,#,#]&

Try it online!

When you have time, could you explain how this works? (the Listable attribute plays a key role here, and this feature is not common in other languages)

Sure, I will try to add an explanation tomorrow.


text:
Is the bus load legal?
I was in the bus today, and noticed this sign:
      seated    standing    wheelchairs
max1    37         30            00
max2    36         26            01
max3    34         32            00

The number of seated passengers, standees, and wheelchairs all have to be no larger than some row in the table. (See chat for details.)
For the purposes of this challenge we will generalise this idea: Given a non-negative integer list of a strictly positive length N (number of passenger types) and a non-negative integer matrix of strictly positive dimensions (N columns and one row per configuration, or the transpose of this), return a list of indices/truthy-falsies/two-unique-values indicating which configurations limits are fulfilled.
E.g. with the above matrix:
30,25,1 → [1] (0-indexed) [2] (1-indexed) or [false,true,false] (Boolean) or ["Abe","Bob","Abe"] (two unique values) etc.
The following test cases use the above matrix and the 0/1 for false/true:
[30,30,0] → [1,0,1]
[30,31,0] → [0,0,1]
[35,30,0] → [1,0,0]
[0,0,1] → [0,1,0]
[0,0,0] → [1,1,1]
[1,2,3] → [0,0,0]
The following test cases use the following matrix:
1 2 0 4
2 3 0 2
[1,2,1,2] → [0,0]
[1,3,0,1] → [0,1]
[1,2,0,3] → [1,0]
[1,2,0,1] → [1,1]

Am I misunderstanding this challenge or can [30,31,0] be [1, 1, 1] because it's covered by max3?

Is swapping truth values allowed? (e.g. any truthy value in place of 0 and any falsy one in place of 1?)

@Okx You're misunderstanding something. [x,31,z] rules out max1 and max2 because they don't allow 31 standees.

@Mr.Xcoder Is that usually allowed in challenges like this?

I used to think (see (2)) (also see Martin's comment) this is allowed by default, but I haven't found a meta consensus. I have proceeded by posting this meta question, whose conclusion that the OP should be asked first. I usually allow it, I don't see the reason why they shouldn't be swapped.

@Mr.Xcoder I think I'll leave it like this for now (several answers are already in), but I'll try to keep it in mind for next time.

@Mr.Xcoder To my understanding: If you are using the same truthy value / falsy value (always use 1 for thuthy, 0 for falsy), they are "two unique values" which is allowed by this post; If your truthy value / falsy value variance between testcases (sometime use 0 for falsy, but sometime use false for falsy), they are not allowed.

@tsh Right, that's correct with the current formulation of the OP.

I think Okx's misunderstanding could be avoided if the example matrix wasn't square.

@JiK Right. That's why I included the other test matrix as well.

APL (Dyalog Unicode), 5 3 bytes
∧.≤

Try it online!

∧.≤

Thanks @Adám. Don't know how I missed that.

It looks like emoji.  ^_^ >,< @.@

Haskell, 22 20 bytes
map.(or.).zipWith(>)

Returns False if legal and True if not.
Try it online!
Flipping True/False as return values saves 2 bytes (thanks @user202729!). With True for legal it's map.(and.).zipWith(<=) (22 bytes). Try it online!

Flipping true and false in the output results in a shorter solution.

Octave, 15 bytes
@(a,b)all(a>=b)

Try it online!
As per sundar's comment, omitting the transpose saves 2 bytes.

OP allows taking the matrix as the transpose of what's shown in the question, and you can take b as a column vector instead of a row vector (since it's just specified as a list), saving 2 bytes: Try it online!

Jelly, 3 bytes
<Ẹ€

Try it online!
0 = True, 1 = False.

If the values needn't be distinct, <§ would work

@Mr.Xcoder I don't think that option is given here. I guess I'll wait and see.

It is allowed.

@Mr.Xcoder Hm, it looks like <§ isn't exactly "truthy-falsy" but rather "falsy-truthy", which, unfortunately, isn't what the challenge asks for.

@Mr.Xcoder Jelly needs ≥.

Ohm v2, 3 bytes
>Σy

Try it online!
Algorithm: vectorized > (greater than), Σ sum each, y sign.

MATL, 3 bytes
<~A

Try it online!
Takes the input matrix as a transpose of the format in the question (as allowed by OP), with one column per configuration. Outputs boolean 0 and 1 for false and true.

R, 32 30 26 bytes
function(x,y)!colSums(x<y)

Try it online!
Accepts the matrix in transposed form as x, test config as y. Returns a vector of booleans.
Initial -2 bytes thanks to mnel, and further -4 by JayCe.

Save 2 bytes with a function body apply(x>=y,2,all)

save 4 bytes

JavaScript (ES6), 38 bytes
Takes input as (matrix)(vector). Returns a Boolean array.
m=>v=>m.map(r=>!r.some((t,x)=>v[x]>t))

Try it online!

Japt, 6 5 bytes
-1 bytes from @Shaggy
eÈ¨Vv

Try it online!

VgY -> Vv to save a byte.

Haskell, 30 bytes
map.((.).(==)<*>(zipWith min))

Try it online!

Retina 0.8.2, 57 bytes
\d+
$*
;(?=.*;(.*))
;$1¶
%(+`,1*(1*)(;.*),\1$
$2
(1*);\1$

Try it online! Link includes test cases, but the output is all run together. Explanation:
\d+
$*

Convert to unary.
;(?=.*;(.*))
;$1¶

Give each row of the matrix its own copy of the list.
%(

Operate separately on each row of the matrix.
+`,1*(1*)(;.*),\1$
$2

Repeatedly remove the last number of the row and list while the last number of the row is at least as big as that of the list.
(1*);\1$

There should then be one number left in the list and the number in the row should be at least as big as that.

Python 2, 38 bytes
lambda m,l:[l==map(min,l,r)for r in m]

Try it online!

05AB1E, 5 bytes
εs<›P

Try it online or verify all test cases.
Explanation:
Unfortunately 05AB1E v1 doesn't have a 1-char builtin for ≤ or ≥, so I decrease each value instead before using ›. 05AB1E v2 which is currently in development will have these builtins.
ε        # For-each row of the (implicitly input) matrix:
 s       #  Swap, so the (implicitly input) list is at the top of the stack
  <      #  Decrease every value in the input-list by 1
         #   i.e. [30,25,1] → [29,24,0]
   ›     #  Check for each value in the matrix-row if they're larger
         #  than the input-list value at the same index
         #   i.e. [37,30,0] and [29,24,0] → [1,1,0]
    P    #  Then take the product of these checks
         #   i.e. [1,1,0] → 0

Stax, 8 bytes
â ╤┘µrφî

Run and debug it
Explanation:
mx\{:vm|A Full program, unpacked, implicit input
m         Map over rows of the matrix:
 x\         Zip with input array
   {  m     Map over result:
    :v        Check if non-increasing, i.e. matrix element greater than or equal to array element
       |A   All.
            Implicit output

Brachylog, 14 bytes
zzᵐ{≥₁ᵐ∧1|∧0}ᵐ

Try it online!

Wolfram Language (Mathematica), 18 bytes
Inner[Less,##,Or]&

Returns a list of two unique values: True means falsy, False means truthy.
Try it online!