[Question]
  [
There have of course been challenges to render ASCII art fonts [here](https://codegolf.stackexchange.com/q/99913/72726) and [there](https://codegolf.stackexchange.com/q/80940/72726). This challenge doesn't add anything to those. In contrary, it subtracts from them for a good reason. If you allow all characters,
1. it's a lot of boring work
2. the task is mainly about clever compression of the font and short extraction
This one shall be different, because it is restricted to only five letters to be rendered: `BDIOP`
```
####   #   ###   ####   ####   
#   #  #  #   #  #   #  #   #  
####   #  #   #  ####   #   #  
#   #  #  #   #  #      #   #  
####   #   ###   #      ####   
```
Those are obviously chosen for a reason, they share some symmetry, some common elements, but not all of them:
* They are vertically symmetrical, except for the `P`
* The start with a vertical bar, except for the `O`
* The second line is the same, except for the `I`
I think these subtile differences open the field for a lot of possible golfing improvements.
**The input** is a sequence of up to 13 uppercase characters out of those five (put as extended regex `[BDIOP]{,13}`) in a form that fits your language.
**The output** is the ASCII art output of the string with the given 5\*x variable width font, using a whitespace for the background and a character of your choice for the letters, with two whitespaces between the letters. Trailing whitespaces on the lines are allowed, as well as one trailing newline.
**The shortest code** for each language wins.
  
[Answer]
# JavaScript (ES6), 110 bytes
Expects an array of ASCII codes.
```
a=>[759,4,55,5,757].map(p=>a.map(c=>"#   ##     ### #### ".substr((p>>c%31%9&3)*5,4>>c-9^5)).join`  `).join`
`
```
[Try it online!](https://tio.run/##LU7dCoIwGL3vKT4cxhZzFDpEYoN@brqqeylcS0sxN5z1@kurA@fv6pxGvZXTfW2HqDO30lfCKyHzlGc0oZxTTlOentlTWWyFVN@ghQwQAKBJJkMTEQTMva5u6DG2UuowXoXZPCYLTpOxRtmFE8IaU3cFQPFPs8Jr0znTlqw1d1zhnDEWbA@n4z74rWoQEjTTD9XvxoObAS/JiLX/AA "JavaScript (Node.js) ‚Äì Try It Online")
Or **[102 bytes](https://tio.run/##JU7dCoIwGH2VsWFsMT8KHSKxQT83XdW9FK6lpZgbznr9pXXg/F2d0@qP9mZo3Bj39l6FWgYtVZGJnKdcCC54JrILvLSjTir9C0YqTBBCZJbZyEyCMPj3zY8DpU4pEyXrKF8kbCl4OtU4vwrGoLVNXyJUsmBs721XQWcftKYFAODd8Xw64P@aQVIhA@aph/10bDvSFZuwCV8)** if we can output an array of strings.
### Method
Only 4 distinct patterns are needed to build all letters. We store them into a single lookup string.
```
0: #...#      #...##.....###.####.
1: #....      \___/\___/\___/\___/
2: .###.        0    1    2    3
3: ####.
```
The letters are encoded per row, using 2 bits per pattern. By converting from base 4 to base 10, we eventually get the array `[759, 4, 55, 5, 757]`.
```
2: .###. | 3: ####. | 3: ####. | 1: #.... | 3: ####. -> 23313 -> **759**
0: #...# | 0: #...# | 0: #...# | 1: #.... | 0: #...# -> 00010 -> **4**
0: #...# | 0: #...# | 3: ####. | 1: #.... | 3: ####. -> 00313 -> **55**
0: #...# | 0: #...# | 0: #...# | 1: #.... | 1: #.... -> 00011 -> **5**
2: .###. | 3: ####. | 3: ####. | 1: #.... | 1: #.... -> 23311 -> **757**
```
By reducing each ASCII code modulo \$31\$ and modulo \$9\$, we get the shift amount that must be applied to extract the relevant bits from the above values. (This formula is the reason why the letters are encoded in the order `ODBIP`.)
| Letter | ASCII code | modulo 31 | modulo 9 |
| --- | --- | --- | --- |
| **O** | 79 | 17 | **8** |
| **D** | 68 | 6 | **6** |
| **B** | 66 | 4 | **4** |
| **I** | 73 | 11 | **2** |
| **P** | 80 | 18 | **0** |
Finally, we have to adjust to the correct character width. The expression `4 >> c - 9 ^ 5` used as the 2nd parameter of `substr()` gives \$1\$ for `I` and \$5\$ for all other letters. (The simpler `c - 73 ? 5 : 1` is just as long ... but not as cool. ^^)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 37 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
‚Ä¢1b¬ß‚Ä¶¬£U(Œ≥¬∞xƒÅxK¬≤‚Ä¢‚Äû# √Ö–≤5√¥5√¥I√áH<√®‚Ç¨√∏J√∏√∞¬´¬ª
```
[Try it online.](https://tio.run/##AVYAqf9vc2FiaWX//@KAojFiwqfigKbCo1UozrPCsHjEgXhLwrLigKLigJ4jIMOF0LI1w7Q1w7RJw4dIPMOo4oKsw7hKw7jDsMKrwrv//0JPRERJUE9QSURPQg)
Just uses `#` and spaces like the challenge description, and has a single trailing column of spaces. Using a different character (`0`) would be the same byte-count, by replacing `‚Äû# √Ö–≤` with `b1√∞:S`:  
[try it online](https://tio.run/##AVMArP9vc2FiaWX//@KAojFiwqfigKbCo1UozrPCsHjEgXhLwrLigKJiMcOwOlM1w7Q1w7RJw4dIPMOo4oKsw7hKw7jDsMKrwrv//0JPRERJUE9QSURPQg).
**Explanation:**
```
‚Ä¢1b¬ß‚Ä¶¬£U(Œ≥¬∞xƒÅxK¬≤‚Ä¢ # Push compressed integer 22122550664723003622970748254752
 ‚Äû#              # Push string "# "
    √Ö–≤           # Convert the large integer to a base-2 list, and index it into "# "
5√¥               # Split the list of characters into parts of size 5
  5√¥             # Split the list of quintuplets into parts of (up to) size 5 as well
    I            # Push the input-string
     √á           # Convert it to a list of codepoint-integers
      H          # Convert them from hexadecimal to base-10
       <         # Decrease each by 1
        √®        # Modular 0-based index each into the earlier list of matrices
‚Ç¨                # Map over each matrix:
 √∏               #  Zip/transpose; swapping rows/columns
  J              # Join each inner list together to a string
   √∏             # Zip/transpose; swapping rows/columns
    √∞¬´           # Append a space to each line
      ¬ª          # Join each inner list by a space, and then each string by newlines
                 # (after which the result is output implicitly)
```
| letter | `√á` | `H` | `<` | modular 0-based index |
| --- | --- | --- | --- | --- |
| B | 66 | 102 | 101 | 1 |
| D | 68 | 104 | 103 | 3 |
| I | 73 | 115 | 114 | 4 |
| O | 79 | 121 | 120 | 0 |
| P | 80 | 128 | 127 | 2 |
[See this 05AB1E tip of mine (section *How to compress large integers?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `‚Ä¢1b¬ß‚Ä¶¬£U(Œ≥¬∞xƒÅxK¬≤‚Ä¢` is `22122550664723003622970748254752`.  
This number has been generated by [the program in this ASCII-art tip](https://codegolf.stackexchange.com/a/120966/52210) using the transposed flattened rendered letters as input-string.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 34 bytes
```
OD¬ß·ªã‚Äú¬°x%·∫∏»•pF·∫†·∫ä·∫ì~·ªç√ò¬¢‚ÄôBs5$‚Å∫¬§j√ò1z1a‚Å∂Y
```
[Try it online!](https://tio.run/##AVAAr/9qZWxsef//T0TCp@G7i@KAnMKheCXhurjIpXBG4bqg4bqK4bqTfuG7jcOYwqLigJlCczUk4oG6wqRqw5gxejFh4oG2Wf///0JJUE9ET1BJQg "Jelly ‚Äì Try It Online")
A full program taking a string argument and printing the desired output, using 0 and space to make up the letters. In the end, a simple binary encoding of the five letters was most the shortest I could come up with.
## Explanation
```
O                                   # Convert to codepoints
 D                                  # Convert to decimal digits
  ¬ß                                 # Sum inner lists
   ·ªã                     ¬§          # (Modular) index into the following:      
    ‚Äú¬°x%·∫∏»•pF·∫†·∫ä·∫ì~·ªç√ò¬¢‚Äô                # - Base-250 integer 22122550664723003622970748254752
                    B               # - ‚Äé‚Å¢Convert to binary
                     s5$‚Å∫           # - ‚Äé‚Å£Split into lists of length 5 twice (last one will only have length 1 - corresponds to I)
                          j√ò0       # ‚Äé‚Å¢‚Å£Join with two ones between each list of lists
                              z1    # ‚Äé‚Å¢‚Å§Zip, filling with ones
                                a‚Å∂  # ‚Äé‚Å£‚Å°And with a space (replaces 1 with space)
                                  Y # ‚Äé‚Å£‚Å¢Join with newlines
üíé
```
# [Jelly](https://github.com/DennisMitchell/jelly), previous version, 35 bytes
```
‚Äú¬¢·∏Ñ·∫∏·∫è√ü≈ª¬¶·π†Ai;$∆à∆¨‚ÄôBs5s5‚ÅΩ√¶¬£,·∏•‚±Æj√ò0z0o‚Å∂Y
```
[Try it online!](https://tio.run/##AVMArP9qZWxsef//4oCcwqLhuIThurjhuo/Dn8W7wqbhuaBBaTskxojGrOKAmUJzNXM14oG9w6bCoyzhuKXisa5qw5gwejBv4oG2Wf///0JJUE9ET1BJQg "Jelly ‚Äì Try It Online")
A full program taking a string argument and printing the desired output, using 1 and space to make up the letters.
## Explanation
```
‚Äú¬¢·∏Ñ·∫∏·∫è√ü≈ª¬¶·π†Ai;$∆à∆¨‚ÄôBs5s5‚ÅΩ√¶¬£,·∏•‚±Æj√ò0z0o‚Å∂Y¬≠‚Å°‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å°‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å§‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å°‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å¢‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å£‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å§‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å°‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å¢‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å£‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å§‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å§‚Å°‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å§‚Å¢‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å§‚Å£‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å§‚Å§‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å¢‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å°‚Å°‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å£‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å°‚Å¢‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å°‚Å£‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å§‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å°‚Å§‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å¢‚Å°‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å¢‚Å°‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å¢‚Å¢‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å¢‚Å£‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å¢‚Å§‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å£‚Å°‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å¢‚Å¢‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å£‚Å¢‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å£‚Å£‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å¢‚Å£‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å£‚Å§‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å§‚Å°‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å§‚Å¢‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å¢‚Å§‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å§‚Å£‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å§‚Å§‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å£‚Å°‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å°‚Å°‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å°‚Å¢‚Å™‚Äè‚Å†‚Å™‚Å™‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å£‚Å¢‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å°‚Å£‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå¬≠
‚Äú¬¢·∏Ñ·∫∏·∫è√ü≈ª¬¶·π†Ai;$∆à∆¨‚Äô                     # ‚Äé‚Å°Base-250 integer 40155886737228810123461877351903
                B                    # ‚Äé‚Å¢Convert to binary
                 s5                  # ‚Äé‚Å£Split into lists of length 5
                   s5                # ‚Äé‚Å§Split into lists of length 5 (last one will only have length 1 - corresponds to I)
                     ‚ÅΩ√¶¬£,            # ‚Äé‚Å¢‚Å°Pair 6503 with this
                         ·∏•‚±Æ          # ‚Äé‚Å¢‚Å¢Use 6503 as the salt for the Jelly hash function for each of the input letters (will return  the first list of lists for B, the second for P, the third for O, the fourth for D and the fifth for I)
                           j√ò0       # ‚Äé‚Å¢‚Å£Join with two zeros between each list of lists
                              z0     # ‚Äé‚Å¢‚Å§Zip, filling with zeros
                                o‚Å∂   # ‚Äé‚Å£‚Å°Or with a space (replaces 0 with space)
                                  Y  # ‚Äé‚Å£‚Å¢Join with newlines
üíé
```
Created with the help of [Luminespire](https://vyxal.github.io/Luminespire)
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~41~~ ~~39~~ ~~36~~ ~~35~~ 33 bytes
```
‚ÜëÔº•Ôº≥‚ü¶‚™™¬ß‚™™‚Äù{‚à®'ÔºÆ4Ôº¥‚âï‚äûÔΩú"¬≥√ºÔºµr‚Å∏mÔº©‚Äù¬≤‚Å¥‚äñŒ£‚ÑÖŒπ‚Åµ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMMqtEBHwTexQMMzr6C0JLgEKJiuoamjEB1ckJNZouFY4pmXklqhAeEpKSgrKysoKygAaTgBEoMAMBtOwGXAapAJmA4c5ijpKBiZAJ3gkppclJqbmleSmqIRXJqr4V@UkpmXmKORqQkEOgqmmrGamtb//zt5Bvi7/NctywEA "Charcoal ‚Äì Try It Online") Link is to verbose version of code. Explanation: Mainly clever compression of the font and short extraction.
```
  Ôº≥                 Input string
 Ôº•                  Map over letters
       ‚Äù...‚Äù        Compressed rotated font
      ‚™™     ¬≤‚Å¥      Split into letters
     ¬ß              Indexed by
                 Œπ  Current character
                ‚ÑÖ   Ordinal
               Œ£    Digital sum
              ‚äñ     Decremented
    ‚™™             ‚Åµ Split into columns
   ‚ü¶                Doubly nest the list
‚Üë                   Output rotated
```
The mapping of the characters to the font index is as follows (note that the modulo 5 is automatic due to the use of cyclic indexing):
| Character | Ordinal | Digital Sum | Decremented | Modulo 5 |
| --- | --- | --- | --- | --- |
| O | 79 | 16 | 15 | 0 |
| B | 66 | 12 | 11 | 1 |
| P | 80 | 8 | 7 | 2 |
| D | 68 | 14 | 13 | 3 |
| I | 73 | 10 | 9 | 4 |
The nested map would normally result in a list of lists so the extra list wrapper makes a doubly nested list which results in the desired output spacing.
[Answer]
# GNU [sed](https://www.gnu.org/software/sed/) `-E`, 218 bytes
There are only four or five different lines to compose the characters, but seems expensive to use this knowledge in `sed`, so I a column-based approach. First, replace each character by a lower letter representing the type of column, from `a` for `a`ll set to `z` for `z`ero set. The I build row after row, inheriting the type of column. Simple for `a` and `z`, slightly more complicated for `e`very `o`ther row set and really long logical chains for others.
```
s/./a&zz/g
s/^/xy:kl:ghia:zzoe \
fglmnzaawxyzeo#\n_/
s/I//g
s/B/eeo/g
s/P/wwx/g
s/D/ffk/g
s/aO/kffk/g
G
:1
s/_([ #]*\n)(.*)/\1_\2\n/
s/((.)([a-z])\S*(.)\n.*_[ #]*)\2(.*)/\1\4\5\3/
#x;p;x
/.*#\n((.*\n){5})_.*/!b1
s//\1/
```
Who can beat that one with `sed` with a different approach?
[Try it online!](https://tio.run/##LY5BasMwEEX3OkWKoUgCa0jabJxdcSlZ2ZBlJhEKld1gVzK4xYpKrh5FVrN7M7z/Z0b9mbfmN4QRBKhn76ElIxzBXYquL9qvsyq8t3qBpGn7b@OVmtzFa5uhkRDNLaTAG2htE9UwTS5RCU3TJVIVdP/8QYplXEi6X2QHjoZRwRngUuIKzdxHqWB0r3J/YLjjcUAjuEw2w9XDxldc4wuQzG2GjSMgeHwnJufCv/WVScHh6TQfijKEUFdlua2rmx1@ztaMIX@/Aw "sed ‚Äì Try It Online")
[And easily scalable](https://tio.run/##Pc5BS8MwFAfwez7FpCBJoHlsukt3c@1kpw7cbW@GiGkdncmgStOIX92YxuHtl8f//156/Zq35jOEHgSoW@@hJT08gxuL7ly0bydVeG/1DEnTnt@NV2pwo9c2QyMhJreQCmoPoxoTH0Brm1RF6aQdDINL2kQNSSU0TfdXrqH793pyE/1IinkcSHqYZUeOhlHBGeBc4gLNdJpSwehB5f7I8InHBxrBZUozXFzTeI9LvAOSudVl5QgIHn8em9PCr@U3k4LDzct0KIYhhF1dbuuy2lTr/Y@9fJys6UNe/QI "sed ‚Äì Try It Online")
[Answer]
# [Vyxal 3](https://github.com/Vyxal/Vyxal/tree/version-3), ~~45~~ 37 bytes
```
O·π†v"·µáVO·∂†4ZG%|‚àµ‚ÇÅŒπf‚Ä†‚Äúb5·∫Ü5·∫Ü$i√∞5Y2YjT√∞‚àß·πÑ·πÖ
```
[Try it Online!](https://vyxal.github.io/latest.html#WyIiLCIiLCJP4bmgdlwi4bWHVk/htqA0WkclfOKIteKCgc65ZuKAoOKAnGI14bqGNeG6hiRpw7A1WTJZalTDsOKIp+G5hOG5hSIsIiIsIkJJUE9ET1BJQiIsIjMuMS4wIl0=)
This is a translation of my [Jelly answer](https://codegolf.stackexchange.com/a/266960/42248) to Vyxal 3, mainly as an exercise in learning an alternative language. It‚Äôs ~~11~~ 3 bytes longer, partly reflecting my inexperience with the language.
The lost bytes reflect two bytes to manually output as ASCII art rather than a representation of lists, 0-indexing (so one byte for decrementing the index).
*Thanks to @lyxal for saving eight bytes, including by fixing some bugs in the language!*
[Answer]
# APL+WIN, 80 bytes
Prompts for character string. Can be any length:
```
' #'[(5‚ç¥2)‚ä§‚àä(¬Ø9+(‚äÇ‚éïav)‚ç≥¬®('xnnnc' 'xjjjg' 'x' 'gjjjg' 'hmmma')['BDIOP'‚ç≥‚éï]),¬®‚äÇ0 0]
```
[Try it online! Thanks to Dyalog Classic](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v@ob6qvz6O2CcZcQJanP5BlwPWooz3tv7qCsnq0humj3i1Gmo@6ljzq6NI4tN5SW@NRVxNQZWKZ5qPezYdWaKhX5OXlJasrqFdkZWWlg2ggToeyM3JzcxPVNaPVnVw8/QPUgTqAWmM1dQ6tAJpioGAQ@x9oFdf/NC51oLSLk5Onp6e/f0CAOhcA "APL (Dyalog Classic) ‚Äì Try It Online")
[Answer]
# [Python](https://www.python.org), 118 bytes
```
s=input()
*z,=b"|b|b||bbb|\\bbb\``|b|"
for z[:0]in[[6]]*5:print(*(bin(z[ord(c)%9//2*5])[3:].replace(*'0 ')for c in s))
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72soLIkIz9vwYKlpSVpuhY3y4ptM_MKSks0NLm0qnRsk5RqkoCwJikpqSYmBkjGJCQA-UpcaflFClXRVgaxmXnR0WaxsVqmVgVFmXklGloaSZl5GlXR-UUpGsmaqpb6-kZaprGa0cZWsXpFqQU5icmpGlrqBgrqmiAjkhUy8xSKNTUhtkMdsWBNgKeTi7-_p5O_Z0AARAwA)
Uses spaces and `1`s for output.
Encodes the font in binary. Lookup uses `%9//2` which maps the code points to `0...4`, in particular, sending `I` to `0` which allows us to abuse the simple structure of `I`.
[Answer]
# [Uiua](https://uiua.org) 0.3.1, 62 [bytes](https://codegolf.stackexchange.com/questions/247669/i-want-8-bits-for-every-character/265917#265917)
```
/‚äê‚â°(‚äÇ‚äÇ:"  ")‚äê‚â°(+@ √ó3‚ãØ)‚äè:[¬±.‚çú‚Üò¬±3.‚çú‚äô‚ä°-.2.‚äÉ+‚àò+14√ó3¬¨.‚ãØ17]‚äó:"IPBDO"
```
## Explanation
```
Rndr ‚Üê (                        # Define a function
  ‚äó:"IPBDO"                     # Convert letters to indices
  [¬±.‚çú‚Üò¬±3.‚çú‚äô‚ä°-.2.‚äÉ+‚àò+14√ó3¬¨.‚ãØ17] # Encode bit masks for letters as integer arrays
  ‚äè:                            # Convert indices to masks
  ‚â°(‚ñ°+@ √ó3‚ãØ)                    # Render each row as a letter,
                                #   box them to accommodate for different width
  /‚äê‚â°(‚äÇ‚äÇ:"  ")                  # Join letters together, add spaces between them
  # ‚â°&p # Uncomment to print to stdout
)
Rndr "IDBIPOPD"                 # Call the function on a value
```
[Try it out!](https://uiua.org/pad?src=0_3_1__Um5kciDihpAgKAogIOKKlzoiSVBCRE8iCiAgW8KxLuKNnOKGmMKxMy7ijZziipniiqEtLjIu4oqDK-KImCsxNMOXM8KsLuKLrzE3XQogIOKKjzoKICDiiaEo4pahK0Agw5cz4ouvKQogIC_iipDiiaEo4oqC4oqCOiIgICIpCiAgIyDiiaEmcCAjIFVuY29tbWVudCB0byBwcmludCB0byBzdGRvdXQKKQpSbmRyICJJREJJUE9QRCIK)
]