[Question]
  [
Write a program or function that takes a character as input and outputs a character. Also, choose a list of 13 distinct ASCII printable characters (32-126). When a character from this list is passed into the program or function, it should output the character at the corresponding position in `Hello, world!`. This way, running your code on each element of the list in turn would produce `Hello, world!`.
**Example:**
If your chosen list is `Troublemaking`, you should produce a program or function that maps:
```
T -> H
r -> e
o -> l
u -> l
b -> o
l -> ,
e ->  
m -> w
a -> o
k -> r
i -> l
n -> d
g -> !
```
**Rules:**
* Your score is length of the program/function.
* You can't store any data between program/function runs.
* Include list of the characters you chose into the answer.
  
[Answer]
# [Perl 5](https://www.perl.org/), 8 bytes
‚àí1 byte by Sisyphus.
```
y;yav;ol
```
Input: `Heavy, world!` [Try it online!](https://tio.run/##K0gtyjH9/7/SujKxzDo/5/9/j9TEskodhfL8opwUxX/5BSWZ@XnF/3ULAA "Perl 5 ‚Äì Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 18 bytes
A function that inputs and outputs an ASCII code.
```
lambda c:c-954%c%3
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUSHZKlnX0tRENVnV@L@3a6SCrUKSukdqTm6@jlJlQVFeiqI6V2JxcWpRiUJOap5GcWqJBlCVpqaCra2CoTFXQVFmXolGUmVJarFGbmKBRpqOAlwabE5Ovo5CeX5RDtAczf8A "Python 3 ‚Äì Try It Online")
The chosen 13-byte string is: `Helmo,"yprnd!`, and was found using [brute force](https://tio.run/##lVTBbqMwEL37KyapSMyGtpBU2mpJctlL/6HLrgCbYBVMBEZBWvHt2bEJKSRN1fWBGZ6fn4dnxvH9Lo6Pxzsh46xmHNaVYkKqh3RLxlhxCZVC7jRG7hhPhOSQ0MYG2tw3rtVYjWcTUqPS8x8FsVSv3vI58EmchiUo3uD7UwAbmL7wLCscOBRlxiZTB0pe6SmfkMdH@Fnk@1rxCsLfEeQFg/yBoCTsc6pD6IAOURdyG/4SwKFfUAbVPd8Ah1RkHGjUEwwpQQBm4NknLs0KuQP96JBvEIIFuX9eEV6Qwp7iQATb7Xm31jxLrupSaiWftMRUnYdC0r6GpCjBfETjmkJ1XIPnuq5OF4thre9c78T13rnemKtHzvOKK4quO@A6gM7b/ohwFoxRb7X0MaLe8jsm12q9pWmVIjuh8YVY7ybWvzGk2cyEtdkYFgt9@npZMF7XkksFTZxn8wDQzJWWMUDRAcsz8IJAn/NB7syDcWH9BAxIh0FeDnI2yCfz4CMTTrbikXa2rj4w4r@d/Yq7I2GBNDx3oXVXGG/L9rYa6U3XdcJ85UR3mQg@W9j9w5qF@8X@p7yo5OHbbUpLvoZeI3u8Y1RCp0lRS/YDqMUci9nwalXBL4mXRYPH0Hjm0rBv/VztdVO6uiWPx38).
**Alternative Solutions**
```
lambda c:c^656%c%7    # 18b ('Mahim/!sntjd"')
lambda c:c^308268%c   # 19b ('Z{@HU 2I}B`Y5')
lambda c:c|2242944%c  # 20b ('HeLdi, AoblD!')
lambda c:c^c*2%54%21  # 20b ('Ngchb"+|i{lt,')
lambda c:c-c*c%60%11  # 20b ('Mjmpr-#|tvqe$')
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 14 bytes
```
c=>'lol'[c]||c
```
[Try it online!](https://tio.run/##BcExDoAgDADAryALkGij7jj7B@JAChhNpQaNLv4d73b/@AvLdt5d5hBrshXtpIhJOVy@DytyvpgiEK/aAYCcI/XcincoY2jkAoc/NQo7iaTRGNh5y1opY@oP "JavaScript (Node.js) ‚Äì Try It Online")
Input text is:
```
Hel0o, w1r2d!
```
lol
[Answer]
# JavaScript (ES6), 16 bytes
Expects and returns an ASCII code.
Produces `Hello, world!` when given `(a-IK*s]d5P/+`.
```
c=>28+c*c%389%96
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/Z1s7IQjtZK1nV2MJS1dLsf3J@XnF@TqpeTn66RrSenp6SRqKup7dWcWyKaYC@tlKsXm5igUaygq2dQnBJUWZeul5aUX6uc0ZikTPQRI00jWS9ZCjHsURDEwj0svIz8zTU1TU1/wMA "JavaScript (Node.js) ‚Äì Try It Online")
---
# JavaScript (ES6), 19 bytes
This version was built such that the output character is guaranteed to be in the range 32-126 as well. The OP has since clarified that this is not required.
Expects and returns an ASCII code.
Produces `Hello, world!` when given `,X=CI:YWx.~7-`.
```
c=>32+c*c*71%193%91
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/Z1s7YSDtZK1nL3FDV0NJY1dLwf3J@XnF@TqpeTn66RrSenp6SToSts6dVZHiFXp25rlKsXm5igUaygq2dQnBJUWZeul5aUX6uc0ZikTPQUI00jWS9ZCjHsURDEwj0svIz8zTU1TU1/wMA "JavaScript (Node.js) ‚Äì Try It Online")
### Full mapping
```
   | 0 1 2 3 4 5 6 7 8 9 A B C D E F
---+--------------------------------
20 | M < S B Y = I - 9 m y G H ! r @
30 | 6 T J h S f Q d D L , 4 d l 6 3
40 | c U z l + x 7 y - o # Z i : > u
50 | n ? 8 Y R s a w e   ^ i L W / /
60 | b b / / W L i ^   e w a s R Y 8
70 | ? n u > : i Z # o - y 7 x + l
```
[Answer]
# [Python](https://www.python.org), 31 bytes
```
lambda c:c.translate('ll !o'*8)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72soLIkIz9vweI025ilpSVpuhb7cxJzk1ISFZKtkvVKihLzinMSS1I11HNyFBTz1bUsNCGqbuoWFGXmlWgoKell5WfmaaRpJGsqpOUXKSQrZOYpqHuk5ijn6yiUKxWppCiqa0I1LVgAoQE)
Input characters to use are `Hel#o, w"r$d!`
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes
```
‚Äú¬Ω·π¨·πö¬ªy
```
[Try it online!](https://tio.run/##y0rNyan8//9Rw5xDex/uXPNw56xDu4H8/x6picl5OgrluUU5KYoA "Jelly ‚Äì Try It Online")
Takes `Heacn, wmrld!`. Searched with [this script](https://tio.run/##ZY5BasMwEEX3OsV001iuGnC6M3ifOxgTjC0nCspIjFSEG3J2R@OUYuhKw3/89@XneHH4tUzkbnDV1s5gbt5RhMGN@uT7s1YwmiEahz3N4heSXiZHkMDghu7DheHHNrIOz7UAM4HVWCT5XtVZjdHgtxYQoIHdMc86BcmRHd92AojTtvwxvkhtXR86ldqKX9kJ4FnPsxQy@6y6LF81YU/a237QRelfREEl/5bvZXjIpuEzSO7gWsrHxsj5C@BWly2sYfDvu2vFk8FYJBXksjwB).
```
     y    Transliterate the input by
‚Äú¬Ω·π¨·πö¬ª     "monoclinal".
```
Unless I [brute-forced something wrong](https://tio.run/##bVLLTsMwELznK5YLcUqImiIuUcOFC/8QVchNXDBNbWvXUVQQ3168TloqgXJZZR47O7I7@ndrHk47tAf4UH1/BH1wFj20tlOvTr6pHDrdem2NxGMORJTMDFTnSXuF3tqeTp3agVfkX2nYktd@YCGJrWz3o8Quh51FHrIqAYIa0pew0@YwWuy7mzRhHBxoA2dJIEYmFahcL1slFq6pqvtyk0OZJaB30Csjvhb0ndU1j8TmYKIoDBfHeTWDE2quPYNVuMgPaCL4JxpI0wW/hO2e2e5ydOHQdkPrxaWyplo9LkO@4K6kr1ccaOQ4ROL5N/OYwS2UnIfBNHx3MEY0tSkY63nN2JRVtdpAWDuPRWsH40XapxmsYcX61hqvzaASQD6sWXxqJ8aG2fmsyjYJONRBOGZTzQdJe96A0rwpUcJ6HVMhZbFAhlXHbpvrFpFigSFk1M8HnOmFNhRqEcscYqMT6emphjL2S0Pvg@U/T2TSh86IdcF@IkfzOXc@/4vGW1Ryfzr9AA), a 2-byte compressed string does not seem to be possible.
[Answer]
# x86 32-bit machine code, 7 bytes
```
A8 28 75 02 0C 6C C3
```
[Try it online!](https://tio.run/##TVFRa4MwEH42v@LqGCTTltiyPdR1DDrYXvayp0FbJGqiGRolRqor/etzSVlhJOS4@@6@@@6Ste28yLJpYl0NGD58jBZF1aSsAoHE2jO8M8CqEGhKaWQPpcj7Ut/AkdfoKxJF7lLE157mBhEfSIz4YLhW4G99OCUJM0bLtDc8STDWvGiZrnFECIGsZBoEvpiBxGeEbqTKqj7n8NiZXDaL8gkhqQzUTCpM0Al5zhtgAzSE0ZkYeZd6qdre7Jb3DwcbEQU3Hb6EQrCxEBydIg6y2nH8lz4eYhiDgCDPs67jwQJfIeLSW20bCuzv1TvLSqk4ZE3O177D8gZOVxxu6fLTt5o2GPeqk4Xi@WW@OyLIbgiCg50PjqWsOOARZlb5sF397wD4VkI62rWTvbJMdiHoPE1v/PnlNYRjo6t89pOJihXdNK9XS/vYn9vYYl79Ag "C++ (gcc) ‚Äì Try It Online")
Using the `regparm(1)` calling convention, this takes an ASCII code in AL and returns one in AL.
Chooses `He@DG, world!`.
In assembly:
```
f:  test al, 0b00101000 # Set flags based on bits 3 and 5 of the character.
    jnz e               # If they are not both 0 (true for all of "Hello, world!"),
                        #  jump to the end, to leave the character unchanged.
    or al, 0b01101100   # Otherwise, set bits 2, 3, 5, and 6 to 1.
                        # (These are the bits that are 1 in both 'l' and 'o'.)
e:  ret                 # Return.
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~7~~ 5 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
‚àû'≈∏‚Ñ¢‚Ä°
```
Uses `H2345, world!` as 13 characters.
[Try it online](https://tio.run/##yy9OTMpM/f//Ucc89aM7HrUsetSw8P9/DyNjE1MdhfL8opwURQA) or [verify each ASCII character separately](https://tio.run/##ASYA2f9vc2FiaWX/xb5Rdnk/IiDihpIgIj95/@KInifFuOKEouKAof8s/w).
**Explanation:**
```
‚àû      # Push an infinite positive list: [1,2,3,...]
 '≈∏‚Ñ¢  '# Push dictionary string "hello"
    ‚Ä°  # Transliterate the characters of the (implicit) input-string
       # (after which the result is output implicitly)
```
[See this 05AB1E tip of mine (section *How to use the dictionary?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `'≈∏‚Ñ¢` is `"hello"`.
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 7 bytes
```
T`d`o-l
```
[Try it online!](https://tio.run/##K0otycxL/P8/JCElIV835/9/j9Qc43wdhXKDIpMURQA "Retina 0.8.2 ‚Äì Try It Online") Explanation: Inspired by @loopywalt's Python answer, works by translating `0` to `o` and both `3` and `4` to `l`, so given the 13 distinct characters `Hel3o, w0r4d!` as input the output is `Hello, world!` as desired. (The full transliteration actually maps `0123456789` to `onmlllllll`.)
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 6 bytes
```
kakH¬°ƒø
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyJBIiwiIiwia2FrSMKhxL8iLCIiLCJhXG5iXG5jXG5kXG5lXG5mXG5nXG5oXG5pXG5qXG5rXG5sXG5tIl0=) Takes `a`, `b`, ... `m`
```
     ƒø # Transliterate
ka     # Lowercase alphabet
  kH¬°  # To corresponding chars of "Hello, world!"
```
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 9 bytes
* -1 byte thanks to [@Anders Kaseorg](https://codegolf.stackexchange.com/users/39242/anders-kaseorg)
```
tr 012 ol
```
Takes `Hel1o, w0r2d!`
[Try it online!](https://tio.run/##S0oszvj/v6RIwcDQSCE/5/9/j9Qcw3wdhXKDIqMURQA "Bash ‚Äì Try It Online")
[Answer]
# [Nibbles](http://golfscript.com/nibbles/index.html), ~~6.5~~ 6 bytes (12 nibbles)
```
=`r\$d:"lo"
```
`"Hel1o, w2r4d!"` becomes `"Hello, world!"`.
```
   \$d          # keep only digit characters
 `r             # and get the value
                # (so non-digits become zero)
=               # and use this to index into
        "lo"    # the string "lo"
       :        # with the input character appended
                # (wrapping around for index >3)
```
[![enter image description here](https://i.stack.imgur.com/b1eaS.png)](https://i.stack.imgur.com/b1eaS.png)
[Answer]
# [C (clang)](http://clang.llvm.org/), 23 bytes
```
f(c){return 656%c%7^c;}
```
[Try it online!](https://tio.run/##Jc1BDsIgEEDRNXMK1DSBRXVl1dR6A69gQgZaxlBqCuiiqUcXa1z@v3lYolO@y7kVKKfRxDR6Xu2rAovDDes5b8ijS9rwc4iahq29AJCP0Cvy4jmQljABWw7HGtjLkjNcvAXyhncmolWjkFICY4/0rx8ka5jzVVnqd6vg412vP9g61YVcLkqDx9MX "C (clang) ‚Äì Try It Online")
Takes `Mahim/!sntjd"`. Brute forced solution found using [this](https://tio.run/##bVLLboMwEDzjr9hSWbIDaUly6IGk5976AWkqGQPBEQFkSBOa8uulax55SOXgx@zsznpYOZWpyLZtq7IKYiZd5e74WUfVQWegqKS7T@k37aPKZHoII1iWVajyp@SV3EJaZVuDEaxC9kJl7CtXISdnYsW5BmaKn2AFMx@3Jcw8z/PBcU4ckHGl1D2lvqHUPcUyYY1hzzc3mQgNYr1BwH6L0jR34ZjrNHywXZgUV0qwLtV3lMcg4BnG49rbmMRz4xNDvKhLBBdzH3eUn7/gwXEG9b5ajgRjEZxcqHmnYqkYGCswsI/2MtFMuIDNDFLBVTVAVZjCjPOxpDUpLu@xrGBdYFiYxmQPNWRc7jr0@gb/f5dxTPIuXcPPCjG56aqZNtE@TO@jBf6xKmY2HFWVAC2B0RCCuopK/pHZbseB/gvubmMi@nAZExpSHBRKQzMqQ/LA75zqrMKXNKRpf2Wcim3ZTt8Xfw) program.
# [C++ (clang)](http://clang.llvm.org/), 22 bytes
```
[](int&c){c^=656%c%7;}
```
Port of the above.
[Try it online!](https://tio.run/##JcpLCsIwEADQdeYUo1LJgOLKuoj1Bp5AFMKkn5E0LTbVRalXjwW3j8d9v2dvQ53sGDussEi3u5YQt0wTP4r8mGecncycDGwksB9diWceopPuArBEaK0E/e7EEUygFkE2oD6N@BL1VzMWWJeRG/vSRARKVZpph/34NyYDc7raRtrDagjx6dY/ "C++ (clang) ‚Äì Try It Online")
[Answer]
# [Python](https://www.python.org), 32 bytes
```
lambda c:"Helo, wrd!"[ord(c)%10]
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72soLIkIz9vweI025ilpSVpuhY3FXISc5NSEhWSrZQ8UnPydRTKi1IUlaLzi1I0kjVVDQ1ioer0Cooy80o0lJT0svIz8zTSgLIKaflFCskKmXkKSm7uHkGeXt4-wb4xMX7-SpqaEF0LFkBoAA)
Takes in characters `[F,G,H,R,I,J,K,L,S,M,\,N,O]`.
## [Python](https://www.python.org), 35 bytes
```
lambda c:"Hello, world!"[ord(c)-97]
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72soLIkIz9vweI025ilpSVpuhY3lXMSc5NSEhWSrZQ8UnNy8nUUyvOLclIUlaLzi1I0kjV1Lc1joUp1C4oy80o0lJT0svIz8zTSgLIKaflFCskKmXkKSolJySmpaekZmVnZOblKmpoQTQsWQGgA)
Takes in `[a,b,c,d,e,f,g,h,i,j,k,l,m]`.
[Answer]
# [JavaScript (V8)](https://v8.dev/), 12 bytes
```
c=>c-954%c%3
```
[Try it online!](https://tio.run/##VYtBC4IwHMXvfYoliBvkn6CCQiaElw7dPEaHsaZOdLNtGvXll7QO9W7v/d6vZROz3MjBpdPeV9RzmvP0sNvGPN54rpV1yDojVY0oSk6i6/Uqeg5G3ZZJtgh8VPI@irNQtWvmlxIPVAqHg0bAypcIV90J6HSNfwXyjy4AEMQr9GzAHNEclZ8BKqP7omGm0DeBK8yBf8vR4TWZA62WCkcRIZl/Aw "JavaScript (V8) ‚Äì Try It Online")
Using the string `Helmo,"yprnd!`, ported from [dingledooper's answer](https://codegolf.stackexchange.com/a/250568/98937)
Expects input as a charcode and outputs as the charcode
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), ~~26~~ 21 bytes
```
"Hello world!"`i$-97+
```
*Down 5 bytes thanks to Razetime*
A port of [Adam's Python answer](https://codegolf.stackexchange.com/a/250558/107017). Takes in `[a..l]`.
[Try it online!](https://ngn.codeberg.page/k#eJxLs1LySM3JyVcozy/KSVFUSshU0bU01+biSlNKTEpOSU1Lz8jMys5RAgD84QyD)
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 9 bytes
```
‚≠ÜÔº≥¬ß‚Å∫ŒπloŒ£Œπ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRCO4BEil@yYWaHjmFZSWQLgamjoKjiWeeSmpFRoBOaXFGpk6Cko5@UpA4eDSXI1MTSCw/v/fI9XQxEhHoTy/KCdFkeu/blkOAA "Charcoal ‚Äì Try It Online") Link is to verbose version of code. Takes as input the 13 distinct characters `He142, world!`. Explanation: Works by mapping `147` to `l` and `258` to `o`.
```
 Ôº≥          Input string
‚≠Ü           Map over characters and join
    Œπ       Current character
   ‚Å∫        Concatenated with
     lo     Literal string `lo`
  ¬ß         Cyclically indexed by
        Œπ   Current character
       Œ£    Digit value (0 if not a digit)
```
[Answer]
## [Knight](https://github.com/knight-lang/knight-lang), 13 bytes
```
O-=cP%%954c 3
```
Port of @dingledooper's answer.
## [Knight](https://github.com/knight-lang/knight-lang), 16 bytes
```
O+28%%^P2 389 96
```
Port of @Arnauld's answer.
[Answer]
# [Headascii](https://esolangs.org/wiki/Headass#Headascii), 45 bytes
```
-----[]]]]]--[]]]][U-]()R-:-()R--:--()R-:R;P!
```
Takes a character and prints it, except for `m`, `n`, and `p`, which map to `l`, `l`, and `o` specifcially. Full chosen string therefore is `Helmo, wprnd!`
[Try It In Headass!](https://dso.surge.sh/#@WyJoZWFkYXNzIiwiIiwiLS0tLS1bXV1dXV0tLVtdXV1dW1UtXSgpUi06LSgpUi0tOi0tKClSLTpSO1AhIiwiIiwiMTEzIiwiIl0=), which is the same except that it takes character codes as input and returns character codes. Or, run it in Headascii [here](https://replit.com/@thejonymyster/HA23) by pasting this in:
```
erun("-----[]]]]]--[]]]][U-]()R-:-()R--:--()R-:R;P!","x")
```
and replacing `x` with the character input of your choice.
Or verify the whole thing at once like this lol:
```
> hellowarp="-----[]]]]]--[]]]][U-]()R-:-()R--:--()R-:R;P!"
'-----[]]]]]--[]]]][U-]()R-:-()R--:--()R-:R;P!'
> verify=x=>erun(hellowarp,x)
[Function: verify]
> "Helmo, wprnd!".split("").forEach(verify)
H
e
l
l
o
,
 
w
o
r
l
d
!
```
### Explanation
```
-----[]]]]]--[]]]][U-]()R-:-()R--:--()R-:R;P!  full program
-----[]]]]]--[]]]][                            r2 = -108
                   U                           i = input (charcode)
                   U-]()                       if(i - r2 - 1 == 0){       // m
                        R-:               ;P!    print i - 1              // m - 1 == l
                          :-()                 }else if(i - r2 - 2 == 0){ // n
                              R--:        ;P!    print i - 2              // n - 2 == l
                                 :--()         }else if(i - r2 - 4 == 0){ // p
                                      R-: ;P!    print i - 1              // p - 1 == o
                                        :      }else{
                                         R;P!    print i
                                               }
```
]