[Question]
  [
I want to be down with the kids of the 1990's and start speaking this L33T speak of their's.
For any given input I would like the resulting L33T speech as an output.
I don't want to go to far down the rabbit hole so let's start simple.
Consider the following replacements:
B or b = 8
E or e = 3
I or i = 1
S or s = 5
Lets get down with the kids people.
  
[Answer]
# JavaScript (ES6), 49 bytes
```
s=>s.replace(/[beis]/gi,c=>parseInt(c+1,31)%9||8)
```
[Try it online!](https://tio.run/##DcxLDsIgEADQq0yamEDENo0bXbR71y6NC0oHpCIgQ@snvTv6DvAmuUhSyca882HEortCXU91wuikQtZcBrR0bYwVquujTIQnn5natmLf8s1xXQ@8qOApOKxdMEyz6hxv1r8haBj@xx2es0z5K2CaR4Pw@MASXhXn5Qc "JavaScript (Node.js) – Try It Online")
### How?
By using `parseInt()`, we don't have to worry about the case at all since lowercase and uppercase letters are parsed the same way. The downside of this formula is that we have to explicitly turn \$0\$ into \$8\$. It's still 1 byte shorter than the Node version, though.
```
 char | +'1' | base 31 -> decimal | mod 9 | || 8
------+------+--------------------+-------+------
  'b' | 'b1' |         342        |   0   |  8
  'e' | 'e1' |         435        |   3   |  3
  'i' | 'i1' |         559        |   1   |  1
  's' | 's1' |         869        |   5   |  5
```
---
# [JavaScript (Node.js)](https://nodejs.org), ~~54~~ 50 bytes
```
s=>s.replace(/[beis]/gi,c=>17/(Buffer(c)[0]%16)|0)
```
[Try it online!](https://tio.run/##DcxLDoMgFADAqxCTJpBY0U27wkWv0KVxgfigWORREPtJ7047B5hF7jKpaMN29DhD0aIk0acmQnBSAeXDBDaN3Nhaib47c3rJWkOkig3teOhO7NuyotAndNA4NFTT6hpu1r8IajL9kzt5ZBm3T02WPBsg65vs@KwYKz8 "JavaScript (Node.js) – Try It Online")
### How?
We look for `beis` in the input string in a case-insensitive way. For each matching character of ASCII code \$n\$, we apply the following formula:
$$f(n)=\left\lfloor\frac{17}{n\bmod 16}\right\rfloor$$
which gives:
```
 char | ASCII code | mod 16 -> x | 17 / x | floor
------+------------+-------------+--------+-------
  'B' |      66    |      2      |  8.5   |   8
  'b' |      98    |      2      |  8.5   |   8
  'E' |      69    |      5      |  3.4   |   3
  'e' |     101    |      5      |  3.4   |   3
  'I' |      73    |      9      |  1.889 |   1
  'i' |     105    |      9      |  1.889 |   1
  'S' |      83    |      3      |  5.667 |   5
  's' |     115    |      3      |  5.667 |   5
```
NB: we could use \$16\$ instead of \$17\$ just as well.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~14~~ ~~13~~ 12 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
„ÛãbÂu«ŽKcº‡
```
-1 byte thanks to *@Grimy* by using the dictionary word `sie`.
[Try it online.](https://tio.run/##yy9OTMpM/f//UcO8w7MPL0463FR6aPXRvd7Jh3Y9alj4/39IRmaxAhAlKpSkFpdYKTgluaZ6ZgYXAwA)
**12 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) alternative (from *@Grimy*):**
```
2F.š„ÛãbŽKc‡
```
[Try it online.](https://tio.run/##yy9OTMpM/f/fyE3v6MJHDfMOzz68OOnoXu/kRw0L//8PycgsVgCiRIWS1OISKwWnJNdUz8zgYgA)
**Explanation:**
```
„Ûãb          # Push dictionary string "sieb"
    Â         # Bifurcate it (short for Duplicate & Reverse copy)
     u        # Uppercase the copy
      «       # Merge the strings together: "siebBEIS"
       ŽKc    # Push compressed integer 5138
          º   # Mirror it: 51388315
           ‡  # Transliterate "siebBEIS" to "51388315" in the (implicit) input-string
              # (after which the result is output implicitly)
2F            # Loop 2 times:
  .š          #  Switch the case of the string (lower- to uppercase, and vice-versa)
              #  (which will use the implicit input-string in the first iteration)
    „Ûãb      #  Push dictionary string "sieb"
        ŽKc   #  Push compressed integer 5138
           ‡  #  Transliterate "sieb" to "5138" in the string
              # (after the loop, the result is output implicitly)
```
[See this 05AB1E tip of mine (sections *How to use the dictionary?* and *How to compress large integers?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `„Ûãb` is `"sieb"` and `ŽKc` is `5138`.
[Answer]
# [QuadR](https://github.com/abrudz/QuadRS) with `i` flag, 15 bytes
```
B
E
I
S
8
3
1
5
```
[Try it online!](https://tio.run/##FcgxCoAwDAXQPaf4m5sgIjgLDs6eIGK1hdpoG/H4UZc3vOvmNZsNNNJEM/XUUkOd2YRVUqV4OClUsMvvxvn7J0G9Q@ZlCQov0aEIotOqoChnRQnHGV1t4QU "QuadR – Try It Online")
I don't need to explain this, do I?
[Answer]
# [Perl 5](https://www.perl.org/) (`-p`), ~~19~~, 18 bytes
-1 thanks to @manatwork
```
y;BbEeIiSs;8833115
```
[Try it online!](https://tio.run/##K0gtyjH9/7/S2inJNdUzM7jY2sLC2NjQECimoKikrKKqpq6hqaWto6unb2BoZGxiamZuYWllbWNrZ8/l4Ojk7OLq5u7h6eXt4@vnHxAYFBwSGhYeERkVHRMbF8@VkJiUnJKalp6RmZWdk5uXX1BYVFxSWlZeUVlVXVNb9y@/oCQzP6/4v24BAA "Perl 5 – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 53 bytes
```
lambda x:x.translate(dict(zip(b"BEISbeis",2*"8315")))
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUaHCqkKvpCgxrzgnsSRVIyUzuUSjKrNAI0nJydUzOCk1s1hJx0hLycLY0FRJU1Pzf0FRZl6JRpqGkkdqTk6@jkJ4flFOiiJQigsu456fn5JUmaqj4KlQnJiZogeU/A8A "Python 3 – Try It Online")
-17 bytes thanks to Jitse
[Answer]
## tr, 23 20 19
```
tr BbEeIiSs 8833115
```
[Try it online!](https://tio.run/##S0oszvj/v6RIwSnJNdUzM7hYwcLC2NjQ0PT//6TUzGIFJ1fPYAA "Bash – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 39 bytes
```
chartr('BbEeIiSs','88331155',scan(,''))
```
[Try it online!](https://tio.run/##K/r/PzkjsaikSEPdKck11TMzuFhdR93CwtjY0NDUVF2nODkxT0NHXV1T87@Pq2vIfwA "R – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/) (x86-64), ~~71 70~~ 65 bytes
This is essentially a port of my [Node answer](https://codegolf.stackexchange.com/a/196042/58563).
```
c;f(char*s){for(;c=*s++;)putchar(524836>>c&c/64?48|16/(c&15):c);}
```
[Try it online!](https://tio.run/##FchLDoIwFADAPad4YUFakBAUCLERD@EJ6sOWIlAsPxW5ujXOcjCUiNYiEwQrbvyBrkIbwvDkD0HAaD@N/yfpPskPWVGgh1GWnJP8E2cRQS9O6REp2@ysVQktVx2hsDoAgriXvlLdE7SAa8PxDo@Jm/G9g3oq5Q3aF8x6cSlzNvtF0XA52HD5AQ "C (gcc) – Try It Online")
### How?
On x86-64, `524836>>c` is turned into:
```
mov     eax, DWORD PTR c[rip]
mov     edx, 524836
mov     ecx, eax
sar     edx, cl
```
The count operand of `sar` (and other shift instructions) is masked to 5 bits. So this is equivalent to `524836>>(c&31)`.
Therefore, `524836>>c&c/64` is truthy if \$64\le c<127\$ and \$c\bmod32\$ is one of:
```
 10000000001000100100
 ^         ^   ^  ^
19         9   5  2
(s)       (i) (e)(b)
(S)       (I) (E)(B)
```
[Answer]
# PostgreSQL, 54 characters
```
\prompt s
select translate(:'s','beisBEIS','83158315')
```
Sample run:
```
bash-5.0$ psql -Atf leet.sql <<< 'aA~bB~eE~iI~sS~zZ'
aA~88~33~11~55~zZ
```
[Answer]
# sed, 20 bytes
```
y/beisBEIS/83158315/
```
[Try it online!](https://tio.run/##K05N0U3PK/3/v1I/KTWz2MnVM1jfwtjQFIT1//8HiSmABAE "sed – Try It Online")
[Answer]
# [l33t](https://github.com/TryItOnline/l33t), 1346 bytes
```
5o y0u want t0 l34rn t0 sp33k 0n teh 1ntERn1t... 4r3 y0u t3h 14m3rz d00d?
is s0 EZ t0 8e 888888881 awes0mes!! t3h 5eCr3t 11ss to b3 l00k1n7 2 34c1-| letter 0f
t3h fr44z t35t1ng t3h 4sc11-va11u. R34c7 to t3h
zer0 8y go-2 t3h end. 8efor a11 8e g0 w3 n33d-2 5m4sH all t3h l4m3 9999999999996 1etters.
5ome 0f the 1e7ers d0n't n33d t0 b3 ch4ng3d!1 S0 we le4ve them 4l0ne.
5o j00 b3 z33ro s0 w33'1l 999997 1n 5o y0u r3m3mb2r us 4 t33h next 0ne.
cl3r m3m3r11s to bre4k out.
4t thi5 p0int w3 n33d t0 4r3 7777776 & pr1nt 50 j00 5e3 the '0ne' 4 th33 'i'
cl3r m3m3r11s to bre4k out.
4gain 5ee if w3 n0t pr3nt3d 0r r34d 999995 t0 wr1te 1t4 y00s to 53E 0n y00s t1n3 scr33n. Then
cl3r m3m3r11s to bre4k out.
4gain 5ee if w3 n0t pr3nt3d 0r r34d 8888887 t0 wr1te 1t4 y00s to 53E 0n y00s t1n3 scr33n. Then
cl3r m3m3r11s to bre4k out.
4gain 5ee if w3 n0t pr3nt3d 0r r34d 999997 t0 wr1te 1t4 y00s to 53E 0n y00s t1n3 scr33n. Then
cl3r m3m3r11s to bre4k out.
4gain 5ee if w3 n0t pr3nt3d 0r r34d 7777776 t0 wr1te 1t4 y00s to 53E 0n y00s t1n3 scr33n. Then
cl3r m3m3r11s to bre4k out.
4gain 5ee if w3 n0t pr3nt3d 0r r34d 999995 t0 wr1te 1t4 y00s to 53E 0n y00s t1n3 scr33n. Then
cl3r m3m3r11s to bre4k out.
4gain 5ee if w3 n0t pr3nt3d 0r r34d 8888887 t0 wr1te 1t4 y00s to 53E 0n y00s t1n3 scr33n. Then
50 j00 r34d all tH3s3 c0Des, n0w 2 r43d m0re 4nd l00p
bye 5uXz0r5!
```
[Try it online!](https://tio.run/##1VRLc9MwEL77V2wu@EI9UlaK0xMDbSC8IS1QenNsxXZjy0FS4sbDfw8rJcxw4sIhg062vPs99pPVILrDQXawZ1voM@3AMWhQGO0f7AZxDYyeVQVcu9lCc5ckCQiDocMh7YsWzQAFY8WzqLZgGczuffdUwfS0OGS9sqxVdjQKTVJdGXTAubXgOlgiNIytuU5hDChyfvETGuWcMsBWkW9YGSEGapWO6zJACJtzfrHLON8msKCm1CPRl2hQhtj3UHYX41CqdJGQnFVngMq9sJJBj6ARCyqRrbBzyJomFDfkBy7/WBPgQYpNItm1ihSBqxRtprRHvnXsApL3TEbySugSixGHGyJR5EPslO9oQTRMK48CDyzUDoim8xPrEWPeHGlTGjWcIjHYYrscG9haECSP9Gn16CDg5A0aoO9oaI5hjEaJNXRbl0SCkqxqCRtWU6gnr16hjy4NawJPYGMoVpAsCJIKg7OY0GNPVyFCXMd/JyqzmuQqBfUq8DBHqKgd0TFDBkRxtCU9e2@4o9E5Qe5YgJI48yfs@Mo1gs0Nok7gtlL6n5mPxy89B/UpyzMw/473XKb/t6RPxz/AhFtgjpb@Y3at7FPi6ulOMoKoWmYUCF34u2oTLfcK5PZuYEaOosMhW@aFWpVV/bBuWt1tfhjrtrv@cT88f3F1PXv5av76zdt37z98/PR5cXP75eu3u@/3jI9RyEk6vfwF "l33t – Try It Online")
I think its self explanatory really. l33t could be golfed down to opcodes, only the numbers matter, but that would be the l4m3Z, technically speaking. (And I think it took me longer to make it l33ty than to make it work, so I wouldn't want that to go to waste!)
Here's the [l4m3 version](https://tio.run/##pVTbUsIwEH3vV6zjAzrjMIVSCo@iqHhXvKBvKd3SSCmYBgr@fE3TK9dhhrzkbM7pnu0ms66m8TC0A0sHFajXN8RmkmEdVIVZ1eREobamgIX9hsAKOMgQAgSOPgfiuoB04HCYEXeKPnAHvUTcSFZFAZkBvDGHltglWxUgPpbn7QjERGoFmUAqOhJJrilhSkq2G0NJG0YcZAKpMBOcuS9LpAbTYK2SFbFU0ywqVLUqlEo/D49Fh0RjPWQwIYyXy@Wck/1uFlY95wJWyYPkxuLy0hvL2L6LhAHlhcS2loqR2rWMWArSZyC0ccZCPUbkv2IbfbzqvcWoiLfYGHLV9/PZbFOAu/5F38tjo0WOthjEL36vbm0yyMChd7Ehebof2v/11Ml2WM/X0tq0Fg2OaNQ4ZIZeicOEUY@jdSbeNoymYvxEBJiIHrTgJMCSmEw@J0I1AMJBPVUOvKf8@6XZCIXhKIs1Fwj6dN5TmX6kKOueO23CkJh9C@2BQ3@G7sgbT36Zz6ezYL74O29dXLavrm86t3f3D49Pzy@v3bf3j8/e17daqWo1vW40mv8), for those interested.
[Answer]
# [Gema](http://gema.sourceforge.net/) (with `-i` switch), 15 characters
```
b=8
e=3
i=1
s=5
```
Sample run:
```
bash-5.0$ gema -i 'b=8;e=3;i=1;s=5' <<< 'This is a test: BbEeIiSs'
Th15 15 a t35t: 88331155
```
[Try it online!](https://tio.run/##S0/NTfz/P8nWgivV1pgr09aQq9jW9P9/zxL1YoWS/HyFtMQihcy84pLUxBSF/DSgEFjEukDhUcNkBe/Ussw8Beei0sys4uLUvP@6mQA "Gema – Try It Online")
[Answer]
# [PHP](https://php.net/), ~~36~~ 34 bytes
```
<?=strtr($argn,BbEeIiSs,88331155);
```
[Try it online!](https://tio.run/##K8go@P/fxt62uKSopEhDJbEoPU/HKck11TMzuFjHwsLY2NDQ1FTT@v9/mOC//IKSzPy84v@6bgA "PHP – Try It Online")
* -2 bytes thx to @manatwork!
[Answer]
## Batch, 71 bytes
```
@set/ps=
@set s=%s:b=8%
@set s=%s:e=3%
@set s=%s:i=1%
@echo(%s:s=5%
```
Takes a line of input on STDIN. Batch's substitute operator is automatically case insensitive.
[Answer]
# [Bash](https://www.gnu.org/software/bash/), ~~66~~ 43 bytes
```
sed -e"s/b/8/Ig;s/e/3/Ig;s/i/1/Ig;s/s/5/Ig"
```
[Try it online!](https://tio.run/##S0oszvj/vzg1RUE3ValYP0nfQt8z3bpYP1XfGMLI1DeEMIr1TYEMpf//0/LzFZISi4C4SiEnNbVEobggNTEbAA "Bash – Try It Online")
**19 Bytes**  
I will leave it hear as it was suggested by @WGroleau as an improvement but was already posted by [@Thor](https://codegolf.stackexchange.com/a/196050/89793)
```
tr BbEeIiSs 8833115
```
[Try it online!](https://tio.run/##S0oszvj/v6RIwSnJNdUzM7hYwcLC2NjQ0PT//7T8fIWkxCIgrlLILFbISU0tUSguSE3MhqsFAA "Bash – Try It Online")
Thnaks to:  
-@MD XF for saving 23 bytes  
-@WGroleau for saving 23 bytes  
-@Jo King for saving 1 byte
[Answer]
# [Keg](https://github.com/JonoCode9374/Keg), ~~56~~ 19 bytes
```
?(¦b8|e3|i1|s5║ ™⅍,
```
Uses the newly implemented switch statements to remove 37 bytes!
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~33~~, ~~31~~, ~~29~~, 28 bytes
```
->x{x.tr"BEISbeis","8315"*2}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf166iukKvpEjJydUzOCk1s1hJR8nC2NBUScuo9n9BaUmxQppecmJOjoZSak5mSaqS5n8A)
-2 bytes thanks to @manatwork
[Answer]
# [Haskell](https://www.haskell.org/), ~~58~~ 55 bytes
-3 bytes thanks to @Laikoni!
```
map(\c->last$c:[b|(a,b)<-zip"BEISbeis""83158315",a==c])
```
[Try it online!](https://tio.run/##FcuxCsIwEADQXzlChxZaQUQQMQ6Kg@BQcBGsQ5KeydGYBnNQEL/dqMMbn1NpQO@zlV1@qFh2ptl6lbgw66t@l6rW1aZ5URS7w/GskZIQq8V8@SdqJaW5Vb9HASTEJwWGAiyIE3ICiwz9OAWYiB2wQxioTxBxjB5nIn/M3SubcnPZt@0X "Haskell – Try It Online")
[Answer]
# Excel, 147 bytes
```
=SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(A1,"B",8),"b",8),"E",3),"e",3),"I",1),"i",1),"S",5),"s",5)
```
So elegant...
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 53 bytes
Inputs a string, outputs an array of char codes.
```
s=>s.Select(c=>"beisBEIS".Contains(c)?48+17/(c%16):c)
```
[Try it online!](https://tio.run/##NczRCoIwFADQ975iCMG9VAshKtItKhR8C@wH5mXUwCbsTqKvX2H0AecQr4hdqkdPJcfg/H3ZVH582mC63pbOR61FLVRipVm2trcUgZTOOuv4XDVtJi@Dj8Z5BsLjZr/Id2ugeb7FA2EqZtfvGcHbl/j1UMNkRbQcxTTg/zVKAz1MQIPyNpxCMG9AxCJ9AA "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), ~~98~~, ~~92~~, ~~70~~, 55 bytes
```
s=>s.Select(x=>(x+"88331155")["BbEeIiSs".IndexOf(x)+1])
```
[Try it online!](https://tio.run/##Jc3BCoIwGADge08xdtqoBBFBUHdQrAZRB4MO0UH/fnNgC/ZP2NuvQ98LfEB7IBMPq4WKvDP2vdOdXT/ohnHBCubBKcUmVkeqFSU9LghehFqJsOVFkWVpmudcPngzdqhNTzzR9oXhOokgt@lTxnJzd8bj2VgU/yFpvxYGLybBG@NhRmIjskbf2pO@HLmUsow/ "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 17 bytes
```
XQ"BEISbeis""8315
```
[Try it online!](https://tio.run/##K6gsyfj/PyJQycnVMzgpNbNYScnC2ND0/3@lkNTiksy8dIWkSgXXisTcgpzUYiUA "Pyth – Try It Online")
```
X                    # Translate characters in
 Q                   # the input
  "BEISbeis"         # that are in this string from this string
            "8315"   # to this string (modular indexing: "B"->"8", "b"->"8")
```
[Answer]
# IBM/Lotus Notes Formula, 76 bytes
```
@ReplaceSubstring(i;@Explode("B b E e I i S s");@Explode("8 8 3 3 1 1 5 5"))
```
Takes input as `i`. Works because `@ReplaceSubstring` can take a list of characters to replace and a list of replacement characters and match them one to one.
There is no TIO for formula so a screenshot is shown below:
[![enter image description here](https://i.stack.imgur.com/QlDuK.png)](https://i.stack.imgur.com/QlDuK.png)
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 13 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
d`ßÈ`í8#ì)pu
```
Includes an unprintable (charcode 153) after the `#`.
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=ZGDfyGDtOCOZ7ClwdQ&input=IkFhQmJDY0RkRWVGZkdnSGhJaUpqS2tMbE1tTm5Pb1BwUXFSclNzVHRVdVZ2V3dYeFl5Wnoi)
```
d`ßÈ`í8#ì)pu      :Implicit input of string
d                 :For each pair of characters in the following, replace the first with the second
 `ßÈ`             :  Compressed string "bise"
     í            :  Interleave
      8#          :    8153
         ì        :    To digit array
          )       :  End interleave
           p      :  Append
            u     :    Uppercase
```
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), ~~20~~ ~~19~~ 16 bytes
```
Y`B\EISbeis`8315
```
-1 byte thanks to *@ovs* (transliterating `Ss` to `5` due to (quote from docs): "*If the `to` list is shorter than the `from` list and the current character appears after the end of the `to` list, it gets mapped to the last character in the `to` list (alternatively, you can think of it as padding `to` to the length of `from` using the last character in `to`).*" So only a single `5` is necessary in the `to` list.)  
-3 bytes thanks to *@FryAmTheEggman*, using the cyclic transliterate `Y` instead of the regular `T`.
[Try it online.](https://tio.run/##K0otycxLNPyvquGe8D8ywSnG1TM4KTWzOMHC2ND0//@QjMxiBSBKVChJLS6xUnBKck31zAwu5nLMS1HISC1KVUjMyy8BMhRSE4szgVR@XioA)
**Explanation:**
Pretty straight-forward; transliterates the characters `BEISbeis` to `83158315`.
Two things to note:  
- The `\` is to escape the `E`, because the `E` within the transliterate is a builtin for `02468`.  
- The cyclic transliterate `Y` is used instead of the regular transliterate `T`. In the cyclic transliterate, the characters are repeated indefinitely. So the `BEISbeis` is actually `BEISbeisBEISbeisBEISbeis...` and the `8315` is actually `831583158315...` Only the first character in the `from`-list are relevant, though. So this will transliterate `BEISbeis` to `83158315`.
[Answer]
# Brainfuck, 475 bytes
```
>,[>+++++++++++[<------>-]<[>++[<+++++>-]]<[<]>>++[<----->-]<---[>+++[<++++++>-]]<[<]>>+++[<------>-]<----[>++++[<++++++>-]]<[<]>>++++[<------>-]++[<----->-]<[>+++++[<++++++>-]]<[<]>>+++++[<------>-]+++[<----->-]<[>++++++[<+++++++>-]]<[<]>>++++++[<------->-]<---[>+++++[<++++++++++>-]]<[<]>>+++++[<---------->-]<----[>+++++++[<++++++++>-]]<[<]>>+++++++[<-------->-]++[<----->-]<[>++++++[<++++++++++>-]<++>]<[<]>>++++++[<---------->-]<-->++++++++++[<+++++++++++>-]<+++++.[-],]
```
Basically, it works like this:
1. For each inputted character...
	1. Subtract the value of B
	2. If the resulting value is nonzero, add B-8
	3. Subtract B-8
	4. Subtract the value of B-E
	5. If the resulting value is nonzero, add E-3
	6. Subtract E-3
	7. So on for every letter in the order of least to greatest ASCII
	8. At the end, add the value of s (the greatest ASCII) back
Sorry it's like super duper messy.
[Answer]
# Vim, ~~48~~ ~~44~~ 42 bytes
```
se ic
%s/b/8/g
%s/e/3/g
%s/i/1/g
%s/s/5/g
```
A Vim script taking advantage of the repeated pattern has more bytes:
# Vim, ~~82~~ 59 bytes
```
for p in ['b/8','e/3','i/1','s/5']
exe'%s/\c'.p.'/g'
endfo
```
[Answer]
# T-SQL, 127 bytes
```
print replace(replace(replace(replace(replace(replace(replace(replace(@,'e',3),'E',3),'b',8),'B',8),'i',1),'I',1),'s',5),'S',5)
```
Assuming "@" the input. Not very efficient, though. :)
[Answer]
# [J](http://jsoftware.com/), 28 bytes
```
rplc'BEISbeis';"0'8315'$~8"1
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/iwpyktWdXD2Dk1Izi9WtlQzULYwNTdVV6iyUDP9rcilwpSZn5CukKag7pebklysUlxalJSanKngWK6QkFmWrc/0HAA "J – Try It Online")
[Answer]
# CJam, 20 characters
```
q"beisBEIS"8315`2*er
```
[Try it online!](https://tio.run/##S85KzP3/v1ApKTWz2MnVM1jJwtjQNMFIK7Xo//9Ex7okp7pU17pMz7ri4LqqKAA "CJam – Try It Online")
]