[Question]
  [
For a while now, I've been running into a problem when counting on my fingers, specifically, that I can only count to ten. My solution to that problem has been to count in binary on my fingers, putting up my thumb for one, my forefinger for two, both thumb and forefinger for three, etc. However, we run into a bit of a problem when we get to the number four. Specifically, it requires us to put up our middle finger, which results in a rather unfortunate gesture, which is not typically accepted in society. This type of number is a *rude number*. We come to the next rude number at 36, when we raise the thumb on our second hand and the middle finger of our first hand. The definition of a rude number is any number that, under this system of counting, results in us putting up *only* the middle finger of any hand. Once we pass 1023 (the maximum number reachable on one person, with two hands of five fingers each), assume we continue with a third hand, with additional hands added as required. 
## Your Task:
Write a program or function that receives an input and outputs a truthy/falsy value based on whether the input is a rude number. 
## Input:
An integer between 0 and 109 (inclusive). 
## Output:
A truthy/falsy value that indicates whether the input is a rude number. 
## Test Cases:
```
Input:    Output:
0   --->  falsy
3   --->  falsy
4   --->  truthy
25  --->  falsy
36  --->  truthy
127 --->  falsy
131 --->  truthy
```
## Scoring:
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the lowest score in bytes wins. 
  
[Answer]
# [APL (dzaima/APL)](https://github.com/dzaima/APL), 5 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")
```
4∊32⊤
```
[Try it online!](https://tio.run/##SyzI0U2pSszMTfz/P@1R2wSTRx1dxkaPupb8f9Q3Fch/1DYx7dAKAwVjBRMFI1MFYzMFQyNzBUNjw/8A "APL (dzaima/APL) – Try It Online")
`4∊` is 4 a member of
`32⊤` to-base-32?
[Answer]
# Regex (ECMAScript), 37 bytes
Input is in unary, as the length of a string of `x`s.
```
^((?=(x+)(\2{31}x*))\3)*(x{32})*x{4}$
```
[Try it online!](https://tio.run/##Tc/PT8IwGMbxO38FLgbed3Oj@yEm1MLJAxcOehRNGihbtXRNW2Ay9rdPOJh4/jzJk@8XP3K3sdL42Bm5FXZf62/x01umxWn4KsqXxgCc2XwS9p8ACwZNhLDO2jztmhBxnWMITZtnHYZNW3T3fTg5Y@LrN2@lLgETp@RGwPQhLhCpY4SeKqkEgGJW8K2SWgDiHdMHpbAtmUqcUdLDOB4jlTsAzcpECV36CufZ5SLdiq9AMsOtE0vtoXwnH4h/IP6DnqeLdHZj9JWtT8FSH7mS26HluhSzYRApuqstUPnMBJVRhNfDoAkSK4zgHiQme@43FVjE1o1G5prk4VaRUnPwztvrhHZdT@KUTB8HBSEkLlJCBmmekqfsFw "JavaScript (SpiderMonkey) – Try It Online")
```
^
(
    (?=(x+)(\2{31}x*))    # \2 = floor(tail / 32); \3 = tool to make tail = \2
    \3                    # tail = \2
)*                        # Loop the above as many times as necessary to make
                          # the below match
(x{32})*x{4}$             # Assert that tail % 32 == 4
```
[Answer]
# [JavaScript (SpiderMonkey)](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/Releases/45), 23 bytes
```
f=x=>x&&x%32==4|f(x>>5)
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNEtLshMSS3Kzc/LTq38/z/NtsLWrkJNrULV2MjW1qQmTaPCzs5U839JanFJcmJxqoKtQrSBjrGOiY6RqY6xmY6hkbmOobFhLBdMgV5afpFrYnKGRoWCrZ1CQVFmXolGgkp1RW1MCUhApRpoomZtgqbmfwA "JavaScript (SpiderMonkey) – Try It Online")
This is a trivial solution, you just want to convert to base 32 and check if there is a 4 in it.
---
# [JavaScript (SpiderMonkey)](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/Releases/45), 26 bytes
```
x=>x.toString(32).match(4)
```
[Try it online!](https://tio.run/##NYyxDsIgFAB3v4KhAyRIBKpOdPMLHNWkBEGpaSHwYjBNvx3r4Hq5u0G/dTbJR9jm6O82jWF62U91qhbVFQbhDMlPDywFYaMG88QtqWAzGJ0tUuiyo5K2VOypPFAujpRLftv8BeZCOuk1Kkh1KK4nwH0zl@UKP9DMDhey9ITULw "JavaScript (SpiderMonkey) – Try It Online")
It's interesting that `/4/.test(...)` cost one more byte than `....match(4)`.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 5 bytes
```
sH ø4
```
[Try it online!](https://tio.run/##y0osKPn/v9hD4fAOk///ow10jHVMdIxMdYzNdAyNzHUMjQ1juXRzAQ "Japt – Try It Online")
### Explanation
```
      // Implicit input
sH    // To a base-H (=32) string
   ø  // Contains
    4 // 4 (JavaScript interprets this as a string)
```
[Answer]
## Ruby, ~~36~~ 19 bytes
```
->n{n.to_s(32)[?4]}
```
[Try it online!](https://tio.run/##BcFJDkAwFADQvVN8bEg@0QErHKRpxNRY/YphIdWz13vnM7/BQBeKnhyVtx2vTPBcDVL7oCoUKJHXKBpkvEUmmC63adlhtfDRFwEcz31Bkjry0PWQujg2irRPoo3W8AM)
Saved 17 bytes with [@tsh](https://codegolf.stackexchange.com/users/44718/tsh)'s method.
[Answer]
# APL+WIN, 10 bytes
Prompts for input of integer
```
4∊(6⍴32)⊤⎕
```
Noting six hands are required to represent 10^9 converts to vector of 6 elements of the base 32 representation and checks if a 4 exists in any element.
[Answer]
# [Python 2](https://docs.python.org/2/), ~~34~~ 32 bytes
```
f=lambda a:a%32==4or a>0<f(a/32)
```
[Try it online!](https://tio.run/##DcfNCkBAEADgM08xF6Gm2Bk/JbsvIoeRNooh7cXTL9/tu9@wXUoxenvIuawCMkjGZG1zPSCuHn0hFVMZ/X@FXWGqkbFBapE7NNSjYTMPaXI/uwZQzK3L0Rdaxg8 "Python 2 – Try It Online")
2 bytes thanks to [tsh](https://codegolf.stackexchange.com/users/44718/tsh)
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 16 bytes
```
{.base(32)~~/4/}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/Wi8psThVw9hIs65O30S/9r81V1p@kYJGTmZearGmQjUXZ3FipUKahrZeeX5RSnG0QawmV@1/AwUFBV1dXTsFhbTEnOJKLmM0vgmcX1JUWpJRyWVkiqbBDE2BoZE5igJDY0MUBQA "Perl 6 – Try It Online")
Checks if there is a `4` in the base 32 representation of the number. Returns either Nil as false or a Match containing a `4`.
You can prove this by the fact that \$2^5 = 32\$ so each digit is the state of each hand.
[Answer]
# x86 Machine Code, 17 bytes
```
6A 20 59 85 C0 74 09 99 F7 F9 83 FA 04 75 F4 91 C3
```
The above bytes define a function that takes the number as input in the `EAX` register, and returns the result as a Boolean value in the `EAX` register (`EAX` == 0 if the input is *not* a rude number; `EAX` != 0 if the input *is* a rude number).
In human-readable assembly mnemonics:
```
; Determines whether the specified number is a "rude" number.
; Input:    The number to check, in EAX
; Output:   The Boolean result, in EAX (non-zero if rude; zero otherwise)
; Clobbers: ECX, EDX
IsRudeNumber:
    push    32           ; \ standard golfing way to enregister a constant value
    pop     ecx          ; /  (in this case: ECX <= 32)
CheckNext:
    test    eax, eax     ; \ if EAX == 0, jump to the end and return EAX (== 0)
    jz      TheEnd       ; /  otherwise, fall through and keep executing
    cdq                  ; zero-out EDX because EAX is unsigned (shorter than XOR)
    idiv    ecx          ; EAX <= (EAX / 32)
                         ; EDX <= (EAX % 32)
    cmp     edx, 4       ; \ if EDX != 4, jump back to the start of the loop
    jne     CheckNext    ; /  otherwise, fall through and keep executing
    xchg    eax, ecx     ; store ECX (== 32, a non-zero value) in EAX
TheEnd:
    ret                  ; return, with result in EAX
```
**[Try it online!](https://tio.run/##jVJdT8IwFH3fr7ipkGyKX@BHAqIxxgdfjCE@@EBCRldYtWvJ2pFFw1933nYDBKfYl7bnntN77@mlh1NKiz0uqcgiBlfaRGOlxFF87W2AXCFU2BA86AGij1kyZqnPpYF5KDIWeB8e4HKUlOlMmJ4DRqNQJ6ORT4ZmlukYkUanPZTEBZfLBtXMnppNRvMf4buY0bdHlptujdIwbYRThnmr3GpYr@/V@Tlm9zKqYVBh6mAe8bn4vTTUJTMXh8aZSx/VppdV/lUrNaScxtN1qt96KRvYdqILpB8S8EvvA4DjfVAZem7wO6ZcG5YC13B/@wL7x1tCqyt/0QIo5NLqdgtts6Rld5oTK1wpqFBjHBAQeIUtYVBORspMlsrVsCyKueJR6c96wm5l9JTilA0c6@e8zWxw4pMmH5r@NTQ12tIqKS3wN2a16vAGSIogsfVLhe7YS4A1LTzPPp@EXPrL5ycqBZeUQx9OerhdwUUPDg544OIfq7521F31vPB2c9vnFflvWufiX7TT9uX/eJ1T5H3/mBNrSfFJJyKc6uIw6bS/AA "C (gcc) – Try It Online")**
[Answer]
# [J](http://jsoftware.com/), 12 bytes
```
4 e.32#.inv]
```
[Try it online!](https://tio.run/##DcqxDkAwFEbhvU/xBwkSubnFomLxAN7AUE0bRBgqYvHs1eRMX84enB8IDAUOLSw1dUrb@cyhFAkhdwPlqPApOC/ENMaVqOugPSS/knHr5bDCmvWKEMuK3pWw2qzYSDIj/A "J – Try It Online")
[Answer]
# [Julia 1.0](http://julialang.org/), 25 bytes
```
f(n)=n%32==4||n>0<f(n>>5)
```
[Try it online!](https://tio.run/##yyrNyUw0rPj/P00jT9M2T9XYyNbWpKYmz87ABihiZ2eq@b@gKDOvJCdPIzexQCNP1w6kUEch2kBHwVhHwURHwcgUyDLTUTA0MgcSxoaxmpr/AQ "Julia 1.0 – Try It Online")
### [Julia 1.0](http://julialang.org/), 26 bytes
Alternative that is 1 character shorter, but 1 byte longer, too bad that `∈` takes 3 bytes in unicode.
```
n->'4'∈string(n,base=32)
```
[Try it online!](https://tio.run/##yyrNyUw0rPifZvs/T9dO3UT9UUdHcUlRZl66Rp5OUmJxqq2xkeb/AqBASU6eRm5igQZQWZpGnqaOQrSBjoKxjoKJjoKRKZBlpqNgaGQOJIwNYzU1/wMA "Julia 1.0 – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 5 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
32B4å
```
Port of [*@Adám*'s APL (dzaima/APL) answer](https://codegolf.stackexchange.com/a/180494/52210).
[Try it online](https://tio.run/##yy9OTMpM/f/f2MjJ5PDS//8NjQ0B) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfeV/YyMnk8NL/@v8jzbQMdYx0TEy1TE20zE0MtcxNDaMBQA).
**Explanation:**
```
32B    # Convert the (implicit) input to Base-32
   4å  # And check if it contains a 4
       # (output the result implicitly)
```
[Answer]
# [Catholicon](https://github.com/okx-code/Catholicon), 4 bytes
```
ǔ?QǑ
```
Takes a number as a base-256 string.
[Try it online!](https://tio.run/##S04sycjPyUzOz/v///gU@8DjE///t7ExNDa0swMA "Catholicon – Try It Online")
[Test suite](https://tio.run/##S04sycjPyUzOz/v///gU@8DjE///j7axMbCz01GwsTGGUCYQysgUKmoGoQ2NzKEMY0OoQiCws4sFAA "Catholicon – Try It Online")
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 31 bytes
```
n=>{for(;n>0;n/=n%32==4?0:32);}
```
Outputs by throwing an exception. The way you convert one number from decimal to another base is to divide the decimal number by that base repeatedly and take the remainder as a digit. That is what we do, and we check if any of the digits have a value of 4 in base-32;
[Try it online!](https://tio.run/##XY4xD4IwEIV3f8VJYoQQtQKTtRg3BzdNnLEUucGraY@oIf52BJ10ecl99@XlaT/THrvGI13g8PRsrvNj7UxR9kCOtprR0hqJ80p1pPK2si6UlAtJC0WTNFEq24hVmkTy1cnR8O1lQCUkrhMhlhLjOGL3bE8O2YQYyWqIz7VHMmEA6GnKUIBrSgPUXM/GzYO@Txes6/bX/NNgZ@9fYCtABrbAtetZQWAe2tyG@eOhrMve "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# [R](https://www.r-project.org/), ~~50~~ 48 bytes
```
any(2^(0:4)%*%matrix(scan()%/%2^(0:34)%%2,5)==4)
```
[Try it online!](https://tio.run/##K/r/PzGvUsMoTsPAykRTVUs1N7GkKLNCozg5MU9DU1VfFSxjDJRSNdIx1bS1NdH8b/IfAA "R – Try It Online")
Uses a neat matrix-based approach now (courtesy of @Giueseppe). It generates a 5x7 matrix of bits, converts this to a series of base 32 integers, and checks for any 4s.
[Answer]
# ES6, ~~31~~ ~~30~~ 26 bytes
```
b=>b.toString(32).match`4`
```
Feel free to say ideas on how to reduce this further, if any.
[Answer]
# [Python 3](https://docs.python.org/3/), 43 bytes
Checks every 5-bit chunk to see if it is rude (equal to 4).
```
lambda n:any(n>>5*i&31==4for i in range(n))
```
[Try it online!](https://tio.run/##VY9PC4JAEMXP7qcYPMRuLJH/CgQ99gGiW3XYcssFHcVdCRE/@2YZoZfh9@YNjzd1Z/IKA6v0sc1kcrGFKG@ZAIwFdhTTNFqrVeAlSfioGlCgEBqBT0mRMWukNnehpYYEzsShWw4HUWjJ@CiCuQg5nJp2Yj9anO1mlufv554XeD@TXAn5FsC6NRwE6pf8KPhXiIlTNwoNdfsBdF61RQadkuPsBz6RHtHdjDGlMHSRxGH6f9oyxoh9Aw "Python 3 – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 34 bytes
```
f(i){return i?i&31^4?f(i/32):1:0;}
```
[Try it online!](https://tio.run/##LY7NTsMwEITveYqRUZGtOjQ/BaS4NA8CRapSm1oKG2Q7hxLl2cNG5bKanZ35tF3@1XXLg6euHy8Wh5gufni6HhcnvZqCTWMg@NY/1uXnvmVzV1eqKZvCzMv32ZNU2ZQBnhKSjen9hDdMKDRqjb1G9czqRaOsXnnUJWaN3hKHov@1g5NrSe3@F6YoDTIMdEOAXHOFAeGwlgy2W1J8A34CR50UG488P2ITP0jo@wN00rhjWaoWIoUxXW8CDYQ79/EmlMnmbPkD "C (gcc) – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 6 bytes
```
№⍘Ｎ³²4
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM5vxRIOiUWpwaXAAXSNTzzCkpL/Epzk1KLNDR1FIyNgISSiZKmpvX//4ZGlv91y3IA "Charcoal – Try It Online") Link is to verbose version of code. Outputs `-`s according to how rude the number is. Explanation:
```
  Ｎ     Input as a number
 ⍘      Convert to base as a string
   ³²   Literal 32
№       Count occurrences of
     4  Literal string `4`
```
I use string base conversion to avoid having to separate the numeric literals for `32` and `4`.
[Answer]
# [Tidy](https://github.com/ConorOBrien-Foxx/Tidy), 18 bytes
```
{x:4∈base(32,x)}
```
[Try it online!](https://tio.run/##FYtBDoIwFAX3nOKFVZt0YQBdYLwCZwDrb2iibWw/ocaw55xepJbdy7wZto9PNuhv@Zv67rfv9ymSaBuV5Jb9wqJgLZIyIkm5wTtocVJoFTqF5lzWRcqqZooMXdJYV9WRGZjgXxjKF2e/wthQDEMryHGwFGEdeLYRkd4LOU1XjEcyorCp@E@mUOc/ "Tidy – Try It Online") Checks if `4` is an element of `base(32,x)` (base conversion).
[Answer]
# [Haskell](https://www.haskell.org/), 31 bytes
```
elem 9.(mapM(:[6..36])[0..5]!!)
```
[Try it online!](https://tio.run/##DcpRCoQgEADQq0ywHwazQ2a5bOAROoH5IaFtrIZU52/qfb@fP/4hJY5m4pBChi@J7MsoBquJlHa1bYh6V1U1Z79uYKDs63bCC54GEWyDCjtse1QaZftBqaQDvuaY/HLwey7lBg "Haskell – Try It Online")
[Answer]
# [Cubix](https://github.com/ETHproductions/cubix), 26 bytes
```
u!@-W14;OIS%/\;;,p;?wO@u/s
```
[Try it online!](https://tio.run/##Sy5Nyqz4/79U0UE33NDE2t8zWFU/xtpap8DavtzfoVS/@P9/Q2NDAA "Cubix – Try It Online")
Wraps onto a cube with edge length 3 as follows
```
      u ! @
      - W 1
      4 ; O
I S % / \ ; ; , p ; ? w
O @ u / s . . . . . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .
```
[Watch it run](https://ethproductions.github.io/cubix/?code=ICAgICAgdSAhIEAKICAgICAgLSBXIDEKICAgICAgNCA7IE8KSSBTICUgLyBcIDsgOyAsIHAgOyA/IHcKTyBAIHUgLyBzIC4gLiAuIC4gLiAuIC4KLiAuIC4gLiAuIC4gLiAuIC4gLiAuIC4KICAgICAgLiAuIC4KICAgICAgLiAuIC4KICAgICAgLiAuIC4K&input=MzY=&speed=20)
A fairly basic implementation, without all the redirects it does :
* `IS` initiates the program by pushing the input and 32 to the stack
* `%4-!` gets the remainder and checks if it is 4 by subtraction
* `1O@` output 1 if it was 4 and halt
* `;;,` clean up the stack and do integer divide
* `p;?` clean up bottom of the stack and check div result for 0
* `O@` if div result zero output and halt
* `s` swap the top of stack and start back at step 2 above
[Answer]
# [MATL](https://github.com/lmendo/MATL), 8 bytes
```
32YA52=a
```
[Try it online!](https://tio.run/##y00syfn/39go0tHUyDYRyDIDAA "MATL – Try It Online")
[Answer]
## Batch, ~~77~~ 45 bytes
```
@cmd/cset/a"m=34636833,n=%1^m*4,(n-m)&~n&m*16
```
Based on [these bit twiddling hacks](https://graphics.stanford.edu/~seander/bithacks.html#ZeroInWord). Explanation: Only 6 hands need to be checked due to the limited range (30 bits) of the input that's required to be supported. The magic number `m` is equivalent to `111111` in base 32, so that the first operation toggles the rude bits in the input number. It then remains to find which of the 6 hands is now zero.
[Answer]
# x86 machine code, 14 bytes
(same machine code works in 16-bit, 32-bit, and 64-bit. In 16-bit mode, it uses AX and DI instead of EAX and EDI in 32 and 64-bit mode.)
Algorithm: check low 5 bits with `x & 31 == 4`, then right-shift by 5 bits, and repeat if the shift result is non-zero.
Callable from C with `char isrude(unsigned n);` according to the x86-64 System V calling convention. 0 is truthy, non-0 is falsy (this is asm, not C1).
```
 line   addr    code bytes
  num
     1                             ; input:  number in EDI
     2                             ; output: integer result in AL: 0 -> rude, non-zero non-rude
     3                             ; clobbers: RDI
     4                         isrude:
     5                         .check_low_bitgroup:
     6 00000000 89F8               mov    eax, edi
     7 00000002 241F               and    al, 31          ; isolate low 5 bits
     8 00000004 2C04               sub    al, 4           ; like cmp but leaves AL 0 or non-zero
     9 00000006 7405               jz    .rude            ; if (al & 31 == 4) return 0;
    10                         
    11 00000008 C1EF05             shr    edi, 5
    12 0000000B 75F3               jnz   .check_low_bitgroup
    13                             ;; fall through to here is only possible if AL is non-zero
    14                         .rude:
    15 0000000D C3                 ret
    16          0E             size:  db $ - isrude
```
This takes advantage of the short-form `op al, imm8` encoding for AND and SUB. I could have used `XOR al,4` to produce 0 on equality, but SUB is faster because it can macro-fuse with JZ into a single sub-and-branch uop on Sandybridge-family.
Fun fact: using the flag-result of a shift by more than 1 will be slow on P6-family (front-end stalls until the shift retires), but that's fine.
---
Footnote 1: This is an assembly language function, and x86 asm has both `jz` and `jnz`, so [as per meta](https://codegolf.meta.stackexchange.com/questions/2190/interpretation-of-truthy-falsey#comment9441_2194) I can choose either way. I'm not intending this to match C truthy/falsy.
It happened to be convenient to return in AL instead of EFLAGS, so we can describe the function to a C compiler without a wrapper, but my choice of truthy/falsy isn't constrained by using a C caller to test it.
[Answer]
# [Nibbles](http://golfscript.com/nibbles/index.html), 4.5 bytes
```
?`@32$4
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m708LzMpKSe1eMGCpaUlaboWy-0THIyNVEwgPKjggs0GXMZcJlxGplzGZlyGRuZchsaGECkA)
```
?`@32$4
?        Find the first index of
      4  4
 `@32    in the base 32 representation of
     $   input
```
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 31 bytes
```
.+
$*
+`(1+)\1{31}
$1;
\b1111\b
```
[Try it online!](https://tio.run/##K0otycxL/K@q4Z7wX0@bS0WLSztBw1BbM8aw2tiwlkvF0JorJskQCGKS/v834DLmMuEyMuUyNuMyNDLnMjQ2BAA "Retina 0.8.2 – Try It Online") Link includes test cases. Outputs zero unless the number is rude. Works by converting the input to unary and then to unary-encoded base 32 and counting the number of `4`s in the result.
[Answer]
# Java 8, ~~40~~ 33 bytes
```
n->n.toString(n,32).contains("4")
```
Port of [*@Adám*'s APL (dzaima/APL) answer](https://codegolf.stackexchange.com/a/180494/52210).
[Try it online.](https://tio.run/##hZA9D4IwEIZ3fsXFqU20UfBjILo7yOJoHEqppAhXQw8SY/jtWMXVdLnk8rzP3eUq2ctFVdxHVUvn4CQNviIAg6Tbm1Qask8LkFtba4mg2NGjUreAPPVkiHxxJMkoyABhDyMuDijInqk1WDKcJzEXyiL50Y7N1jM@ph/p0eW1l35ub00BjY@wybtcQfJp9fnpSDfCdiQeHlGNDIViS/494C9PAnwd4PEmtGAbCKziXSiRrPjvjcP4Bg)
**Explanation:**
```
n->                 // Method with Integer parameter and boolean return-type
  n.toString(n,32)  //  Convert the input to a base-32 String
   .contains("4")   //  And check if it contains a "4"
```
[Answer]
# [><>](https://esolangs.org/wiki/Fish), 28 bytes
Outputs **4** for rude numbers throws an exception for non-rude numbers.
```
:1(?^:" ":\
,&-v?=4:%&/
 ;n<
```
[Try it online!](https://tio.run/##S8sszvj/38pQwz7OSklBySqGS0dNt8ze1sRKVU2fS8E6z@b///@6ZQqGRuYA "><> – Try It Online")
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~37 bytes~~ ~~36 bytes~~ 29 bytes
*-2 bytes by [Jonathan Frech](https://codegolf.stackexchange.com/users/73111/jonathan-frech)*
```
#~IntegerDigits~32~MemberQ~4&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78H1CUmVcS7ZtYEP1fuc4zryQ1PbXIJTM9s6S4ztiozjc1Nym1KLDORO2/TrWBjrGOiY6RqY6xmY6hkbmOobFhbayCra1CtVtiTnGqDoQMKSrFwayN/Q8A "Wolfram Language (Mathematica) – Try It Online")
31-byte solution:
```
MemberQ[IntegerDigits[#,32],4]&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78/983NTcptSgw2jOvJDU9tcglMz2zpDhaWcfYKFbHJFbt////AA "Wolfram Language (Mathematica) – Try It Online")
]