[Question]
  [
*EDIT (Jan 19, 2022, 18:00 UTC): This challenge is now over. The winner is [Citty](https://codegolf.stackexchange.com/users/75429/citty) with [this Pyth answer](https://codegolf.stackexchange.com/a/223147/58563). Congratulations!*
---
This is an [answer-chaining](/questions/tagged/answer-chaining "show questions tagged 'answer-chaining'") challenge where each answer must take an integer \$N\$ as input and return the **1-indexed ID** of the answer which was written by the user whose ID is \$N\$.
You may want to [sort by oldest](https://codegolf.stackexchange.com/questions/217748/which-answer-did-this-user-write?answertab=oldest#tab-top) to get the answers in the logical order.
## Rules
1. I will post the first answer.
2. You are only allowed to post one answer, so that a user ID is linked to one and only one answer ID.
3. You are only supposed to support user IDs that were used in the previous answers and your own user ID. (So your code may return anything or crash when given an unknown user ID.)
4. **The maximum code size is set to 50 bytes**. So the challenge will end when nobody is able to add a new ID without exceeding this size.
5. You may use any language, no matter which ones were used before. It is recommended to use verbose languages early in the chain, while they still have a chance to compete.
6. The last valid answer in the chain on January 19, 2022 at 18:00 UTC wins the challenge.
Please include in your post the list of ID pairs, updated with your new entry:
```
[your_user_ID] -> [your_answer_ID]
```
Also make sure to include the ID of your answer in the header.
## Examples
The first answer is written by user **Arnauld (58563)**:
### 1. JavaScript (ES6), 4 bytes
```
_=>1
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/e1s7wf3J@XnF@TqpeTn66RpqGqYWpmbGm5n8A "JavaScript (Node.js) – Try It Online")
Updated list:
```
58563 -> 1
```
This code returns **1** when given **58563** ([my user ID](https://codegolf.stackexchange.com/users/58563/arnauld)) ... or any other input. That's fine because **1** is the only possible output at this point (see rule #3).
The second answer is written by user **JohnDoe (123456)** (who actually doesn't exist yet):
### 2. Python 2, 14 bytes
```
lambda n:2-n%2
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUSHPykg3T9Xof0FRZl6JQpqGoSYXjGmh@R8A "Python 2 – Try It Online")
Updated list:
```
58563 -> 1
123456 -> 2
```
This code returns **1** when given **58563** or **2** when given **123456**.
  
[Answer]
# 7. [Julia](http://julialang.org/), 17 bytes
works due to `Int64` overflowing to negative numbers
```
x->(x-8479)^6%5+5
```
[Try it online!](https://tio.run/##DcZBCoMwEAXQ/T/FbARDUYxmMjOLeBFpoRvBEqSIQm4ffav3u/L29aWuqZZubkunQcx9YsMvrpkSLWDlOEGH0QcYi41Qs2mARh8EJspCMOXg8Qb@x7afee/bTH2aaX3iXL0B "Julia 1.0 – Try It Online")
**Updated list:**
```
58563 -> 1
80214 -> 2
95792 -> 3
89930 -> 4
86147 -> 5
97857 -> 6
98541 -> 7
```
**I found those numbers by guessing and brute-forcing :**
```
for i in Iterators.product(-9999:9999,1:20,1:20)
    d = diff(((L.+i[1]) .^ i[3]) .% i[2])
    if all(==(-1), d) || all(==(1),d)
        println(i)
        println(((L.+i[1]) .^ i[3]) .% i[2])
        break
    end
end
```
[Try it online!](https://tio.run/##hY3BCoMwEETv@xV7KURqxaipieAHFPoHYsEahW0lljRCD/13G5WeeuiDHWaHgblNAzX8NbejeTo8Y4kVCCmOKcg44RkokasEpFJpDPLIsxxULkWOoKTIONRzP1okJIMn19nGjfYZPeyop9axg/IUi4S8SOJVAkCP9jua@p4xdo72VPE6wOiCVKWL2XmT1FuTemyGgZUlO/AgRB3g@/1NfKC31sLDknGDYfQb/V1ZuNquua9fZzT4m@cP "Julia 1.0 – Try It Online")
[Answer]
# 2. [Ruby](https://www.ruby-lang.org/), 11 bytes
```
->x{1+~x%2}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf166i2lC7rkLVqPZ/gUJatKmFqZlxLBeIaWFgZGgS@x8A "Ruby – Try It Online")
Updated list:
```
58563 -> 1
80214 -> 2
```
[Answer]
# 1. JavaScript (ES6), 4 bytes
```
_=>1
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/e1s7wf3J@XnF@TqpeTn66RpqGqYWpmbGm5n8A "JavaScript (Node.js) – Try It Online")
Updated list:
```
58563 -> 1
```
[Answer]
# 6. [Zsh](https://www.zsh.org/), ~~26~~ 25 bytes
```
a=80596
<<<$a[(i)${1[2]}]
```
[Try it online!](https://tio.run/##qyrO@J@moanB9T/R1sLA1NKMy8bGRiUxWiNTU6XaMNootjb2vyYXV5qCqYWpmTGQtjAwMjQB0pam5pZGIL6lpbEBiDYzNDEHiZtbmJr/BwA "Zsh – Try It Online")
Boring.
*-1 by @GammaFunction*
Updated list:
```
58563 -> 1
80214 -> 2
95792 -> 3
89930 -> 4
86147 -> 5
97857 -> 6
```
[Answer]
# 8. [J](http://jsoftware.com/), 46 bytes
Last time this works, here to grab the boring answer!
```
1+58563 80214 95792 89930 86147 97857 98541&i.
```
`95594` doesn't need to be included as J's index-of-operator `i.` returns the length of the array in the case the item was not found. But as it is 0-based, the index gets incremented `1+`.
[Try it online!](https://tio.run/##jYu9DkAwFEZ3T/HF4CdoWnr1XmKSmEx2k2iweP@p@giGc5aT84RU5R7TgBw1NIZIozBv6xJMRUx9B9atsRBy0oJFOg3ujXUQxxTNZE12q1AmyXlcL4rRl6nGvv@@YyWx4QM "J – Try It Online")
Update list:
```
58563 -> 1
80214 -> 2
95792 -> 3
89930 -> 4
86147 -> 5
97857 -> 6
98541 -> 7
95594 -> 8
```
[Answer]
# 9. [Perl 5](https://www.perl.org/) `-p`, ~~46~~, 37 bytes
```
$_=(a74a298635=~/./g)[$_%26%20%12]||1
```
[Try it online!](https://tio.run/##DcmxCsJADADQPd/RAx20l1xySYZ@iUi5QUQo9lDH4qcbu7zl9dtrkYhhng5NuZFbLTJ9x/N4P16GOVFNlBPSddswQkxqAcuEDC7qBOZeMlhFVnA12TVh3FecQbOy/Nb@eazPd5za0v8 "Perl 5 – Try It Online")
Updated list:
```
58563 -> 1
80214 -> 2
95792 -> 3
89930 -> 4
86147 -> 5
97857 -> 6
98541 -> 7
95594 -> 8
70745 -> 9
```
Explanation:
```
$_=$_%26%20%12 gives
58563 -> 11
80214 -> 4
95792 -> 8
89930 -> 2
86147 -> 9
97857 -> 7
98541 -> 1
95594 -> 6
70745 -> 5
(a74a298635=~/./g) because shorter than (a,7,4,a,2,9,8,6,3,5)
```
[Answer]
# 13. [Python 3](https://docs.python.org/3/), 45 bytes
```
lambda n:ord('ehlkacfbdgimj'[n%209%80%13])-96
```
[Try it online!](https://tio.run/##LY7NboMwEITvPMVekG0JJBv/o5IXSXIgYAJNMJEhhwrRV6cm6l5mv9WsZl4/Sz95vnfVZX/W462twZdTaDFy/fNRN92tvQ/jNzr7tKA2NTRl/Epyq/ahnaECLI1UPANDCyYysFLbIpK1nEZRTOh41EYeYqRgh0Xa6NRUC5mBkIrFdyuoUpGEZuYgw0jS9K55uHCEoMu70KJBGXw2xhFJuimAy8DD4MH59@hCvTgcW5EygThHuw578oFXGPyCO7T68iQ3yE@wzuVXscH6n3LOf11VzdcNkf0P "Python 3 – Try It Online")
Updated list:
```
58563 -> 1
80214 -> 2
95792 -> 3
89930 -> 4
86147 -> 5
97857 -> 6
98541 -> 7
95594 -> 8
70745 -> 9
45613 -> 10
94066 -> 11
44718 -> 12
 9481 -> 13
```
[Answer]
# 15. [05AB1E](https://github.com/Adriandmen/05AB1E), 42 bytes
This is based on the Chinese remainder theorem. Since all divisors need to be pairwise coprime, we use the `n`th prime for each user id `n`.
```
•3hy₁Ω=”Ó6™≠ò“êS’>₄?Θ¢9?Âγ”J4 %œ~ª‰fÃα•IØ%
```
[Try it online!](https://tio.run/##DYwtDgIxEEavgsGN6Gyn7VTAarBIgoAEAgqBwpCyYNAYSCAh61jFzw22we4h5iJLzZeXvJdvvZnOVvO2lVDq5VaKffPsSbjHs5VjKadH/Ei4xWok4dqX4pg3l7r0eSyab6qG1On@zru6kvBaxEPzTi@DeOm27diwsRpYZUjgjfMZsPdaAVskB96xScuGMFnjCZxyZICMRQ2elLVA5JATM4JjzDRYwgwnfw "05AB1E – Try It Online")
`•3hy...fÃα•` is the large compressed integer `1369130535064223821413376960561972089702936948491908270885271972462351716275011314738309`.  
`I` pushes the input, `Ø` takes the n-th prime and `%` takes the large compressed integer modulo the prime number.
The big constant is generated with the [ChineseRemainder](https://reference.wolfram.com/language/ref/ChineseRemainder.html) builtin from the Wolfram Language: [Try it online!](https://tio.run/##DY6xCsMwDET3foX3arBsyZYLhUJ/oGQNGUxjGg/xkHgr/XZXy/HgHtztuW9lz72@8xh1Pc3tbr4sHDyIdUiQOCYHkpK3IAEpQorCmsKE2nIiiDYSA3FAD4lsCEAUUZQFIQo6D4HQ4e/yOmrr5mGeW23lLJNO17aWY55y@5QZeQGjzq5orkb/LMsYfw "Wolfram Language (Mathematica) – Try It Online")
Updated list:
```
58563 -> 1
80214 -> 2
95792 -> 3
89930 -> 4
86147 -> 5
97857 -> 6
98541 -> 7
95594 -> 8
70745 -> 9
45613 -> 10
94066 -> 11
44718 -> 12
 9481 -> 13
78123 -> 14
64121 -> 15
```
---
By using the closest prime to `n/349` instead of the `n`th prime this can be golfed to 24 bytes:
```
•1RMζ)šÙ&KxγŸÏäí•IƵù/Ån%
```
[Try it online!](https://tio.run/##DcktCkJBFEDh1SgIF5w7c3@XIA@LVQwKBosGi9FiNht9WE2iaB6e8S3CjYxTDge@3X652qxL@R1bnE3716i75suwOfSP7p3P@ZbvVSbfZ/6M82k7KGXOxpLAQkQCZ/UI5p4CmCApuBrXGhNWZSfQoMRALJjAKYgAkaLVNwQ1jAmEMOLiDw "05AB1E – Try It Online")
```
•1R...äí•         # compressed integer 5437583563235532232480395276083021
         I        # push the input
          Ƶù/     # divide by 349
             Ån   # find the nearest prime
               %  # modulo the large integer with the prime
```
[Answer]
# 20. [Charcoal](https://github.com/somebody1234/Charcoal), 30 bytes
```
Ｉ⁺²⌕⪪”)¶q⁹1＆¡⍘DλＫ⟦l∧NＨz¿”²…⮌Ｓ²
```
[Try it online!](https://tio.run/##Fc3RCoMgFIDhV4mujuDAc1IrdikMdhfrCcTJEsTCLNjTu/Vff/C7xWa32ljrlEMqYOxeYIrHDsSbR0hvmLcYCrQSaRRdL3uFUo5Kdqj1gDh0hKS0wFGTItHyhhhvzNdFb5Z1g5c/fd49PNN2lLn8Hx9g7FJX91qx14Lq7Yw/ "Charcoal – Try It Online") Link is to verbose version of code. Works by taking the last two digits of the user ID and looking it up in a table generated by splitting a compressed string into pairs of characters. (Taking the first two digits doesn't work because there are several repeats.) A few variants are possible by spending an extra byte or two on the table which are offset by the saving from not having to offset the resulting index. Unfortunately there are overlaps between adjacent user IDs which means that the string has to be split into pairs of characters to find the index accurately, although one byte of this is offset by not having to halve the resulting index. Updated list:
```
58563 -> 1
80214 -> 2
95792 -> 3
89930 -> 4
86147 -> 5
97857 -> 6
98541 -> 7
95594 -> 8
70745 -> 9
45613 -> 10
94066 -> 11
44718 -> 12
 9481 -> 13
78123 -> 14
64121 -> 15
41565 -> 16
52210 -> 17
91569 -> 18
 3852 -> 19
17602 -> 20
```
[Answer]
# 3. [APL (Dyalog Unicode)](https://www.dyalog.com/), 7 bytes
```
4|∘⍎3⊃⍕
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P/1R2wSTmkcdMx719hk/6mp@1DsVKKhgamFqZsyVrmBhYGRoAqQtTc0tjQA "APL (Dyalog Unicode) – Try It Online")
Updated list:
```
58563 -> 1
80214 -> 2
95792 -> 3
```
Explanation:
```
4|∘⍎3⊃⍕
       ⍕  ⍝ Convert to string
     3⊃   ⍝ Pick the third digit (5, 2, or 7)
   ⍎      ⍝ Execute (make the digit a number again)
4|        ⍝ Mod 4
```
[Answer]
# 12. [C (gcc)](https://gcc.gnu.org/), 50 bytes
```
int f(int n){return"DJHABILFCGKE"[n%60%50%12]-64;}
```
[Try it online!](https://tio.run/##RY1da8IwFIbv@ytCJdCAHUnNyQcOYZvVTb2zd@qFNK0GtmzUFgrib@/qRuPNgYf3Pe@Tx6c87zrralRG9@vItSrqpnLhfPX@8vqxWbwt12m4c1hQDBSz5BALPr11I@vyz8YU6PlSG/v9dJ4FI1OU1hUoS7dZ1BL0U/WLZRRig@IZwmbvwjFqx72pJSS4276O1kXkGvx9gAIxIdN/UDRhfAANUic@0XpCPQjGpa9JBQ9QwNljALRfk1RyGICDYF6qORXCJ1wy1cOt@wU "C (gcc) – Try It Online")
This code could be golfable. But this question is not taged [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"). So let's leave it warning free.
```
58563 -> 1
80214 -> 2
95792 -> 3
89930 -> 4
86147 -> 5
97857 -> 6
98541 -> 7
95594 -> 8
70745 -> 9
45613 -> 10
94066 -> 11
44718 -> 12
```
[Answer]
# 21. [Pyth](https://github.com/isaacg1/pyth), 49 50 bytes
`(answer ID & 753) % 38` happens to be unique for every answer so I just use that to make a lookup table.
```
C@" \r	     
 
    
     "%.&753Q38
```
The string in python repr format:
`' \r\x14\x01\x02\t\x04\x06 \n \x05\x0b\x0f\x13 \x08 \x10 \x12\x0c \x03 \x11 \x0e \x07'`
Updated list:
```
58563 -> 1
80214 -> 2
95792 -> 3
89930 -> 4
86147 -> 5
97857 -> 6
98541 -> 7
95594 -> 8
70745 -> 9
45613 -> 10
94066 -> 11
44718 -> 12
 9481 -> 13
78123 -> 14
64121 -> 15
41565 -> 16
52210 -> 17
91569 -> 18
 3852 -> 19
17602 -> 20
75429 -> 21
```
+1 byte because Python doesn't like carriage returns on their own apparently
[Try it online!](https://tio.run/##K6gsyfj/39lBSSGmSISRiZOFTQEEuBRYufmFFTgUFAQUhHgUmBUEFRT4FNiVVPXUzE2NA40t/v@3NLEwBAA "Pyth – Try It Online")
[Answer]
# 17. [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/math_golf.txt#L196), ~~41~~ 40 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py)
```
☼+░╞╪2<W48R087`9H4957V6984♂Y☻5405]y2/├=)
```
[Try it online.](https://tio.run/##DYo9DoFBFAD7dxNR2Pf2/Sb0agVRSGhQEI1G6wYSn3wScQBX4DR7kbXNZJKZ4@a8350O21pL/xuWx61079J9aLxgnyW3dUw5xOYazuV5XZb@K5xkdaFRub8mg1rFRTN4ImRoZxB4RE7gimwQ5tLowtiqBIMlYwEWxQzBSRWYDb25I5gjZVBGQmAUFRAiTH8)
Updated list:
```
58563 -> 1
80214 -> 2
95792 -> 3
89930 -> 4
86147 -> 5
97857 -> 6
98541 -> 7
95594 -> 8
70745 -> 9
45613 -> 10
94066 -> 11
44718 -> 12
 9481 -> 13
78123 -> 14
64121 -> 15
41565 -> 16
52210 -> 17
```
**Explanation:**
```
☼+           # Add 100000 to the (implicit) input-integer
  ░          # Convert it to a string
   ╞         # Remove the first digit (the 1)
             # (the `☼+░╞` is used to convert the input 9481 to "09481",
             #  and at the same time convert any other input-integer to a string)
╪            # Rotate it once towards the right
 2<          # Leave only the first two characters
   W48R087`9H4957V6984♂Y☻5405
             # Push the following integers to the stack
             # (where ` duplicates the top two items, thus 8,7):
             #  35,4,8,29,0,8,7,8,7,9,19,4,9,5,7,34,6,9,8,4,10,37,16,5,4,0,5
    ]y       # Wrap the stack in a list, and join it together
      2/     # Split it into parts of size 2
        ├    # Pop the left item from the list, and push it to the stack
             # (which is the value we calculated at first)
         =   # Get its 0-based index in the list
          )  # And increase it by 1 to make it a 1-based index
             # (after which the entire stack is output implicitly as result)
```
[Answer]
# 4. [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 16 bytes
```
n=>2-n%2+n%100%7
```
[Try it online!](https://tio.run/##LY/BasMwDIbP9VPoEkhYsiZOszZkyWWw0waDHXooPRjXyQStDZZbKCXPntnedBB86PuRJKmQxqrlSqgn@L6TU5eOybMggi9rJisu8GArcsKhhJvBE3wK1Ck56wOHIwg7URYU1M4jngh6eDS75qXOYVfyapND22xb7qlt63Lu2Gq9hihAMUAVMYoBecQYCFj/TUMw4IbBf71ftXz1K3PwbYAR@kX3Ay90wp90UpVlsl06NvrXhPyB1EuAXg33xWvfjCZzVs97i059oFbpmGKWdWye5@UX "C# (.NET Core) – Try It Online")
```
58563 -> 1
80214 -> 2
95792 -> 3
89930 -> 4
```
Lucky coincidence that
* All IDs except the first are even
* Last 2 digits of the first 2 IDs are divisible by 7
* Last 2 digits of the second 2 IDs are 1 and 2 mod 7 respectively
[Answer]
# 5. [Zsh](https://www.zsh.org/), 25 bytes
```
<<<$[$1&7?(4+${1:4})%6:3]
```
[Try it online!](https://tio.run/##qyrO@J@moanB9d/GxkYlWsVQzdxew0RbpdrQyqRWU9XMyjj2vyYXV5qCqYWpmTGQtjAwMjQB0pam5pZGIL6lpbEBiDYzNDH/DwA "Zsh – Try It Online")
`(4 + ${1:4}) % 6` works for every ID but 95792. But, 95792 is the only ID divisible by 8, so a ternary with `$1 % 8` as the condition works.
```
58563  ->  3 ? (4 + 3) % 6 : 3  ->  7 % 6  ->  1
80214  ->  6 ? (4 + 4) % 6 : 3  ->  8 % 6  ->  2
95792  ->  0 ? (4 + 2) % 6 : 3  ->             3
89930  ->  2 ? (4 + 0) % 6 : 3  ->  4 % 6  ->  4
86147  ->  3 ? (4 + 7) % 6 : 3  -> 11 % 6  ->  5
```
The more boring **24 byte** answer, based off of [@pxeger's](https://codegolf.stackexchange.com/a/217759/86147)
```
a=8059
<<<$a[(i)${1[2]}]
```
[Answer]
# 18. [05AB1E](https://github.com/Adriandmen/05AB1E), 45 bytes
```
•1ααāš®‚wA%|ʒη¦%áYζ”€…FKΘćRÉ±nG’*AÂÉζ•5ôíÌskÌ
```
[Try it online!](https://tio.run/##FYqxagJBEED7@QoRbCSBnb2Z3ZlGsTGFXbqUCaQIgVgIimCx2ohglSoRLLSwSgIHIelvTZNiP2J/5HJpHg/eG09u7x7u68V03m@3Lnutdn9e53DEVKbyvPw5VB857GaDzuL3OX1Xp0483KSvHPZ59ZbDaThKL@f1ddxU5dNVDq/dQVzFzf9w5PgZ3@N28hi39UXNwq4AMRYJlL1aENXCgDgkD@qFGwoTNpWVwBtPDMQOC1AyzgGRR2lcELygLcARWgRCdgxsLRrQxvUP "05AB1E – Try It Online")
```
58563 -> 1
80214 -> 2
95792 -> 3
89930 -> 4
86147 -> 5
97857 -> 6
98541 -> 7
95594 -> 8
70745 -> 9
45613 -> 10
94066 -> 11
44718 -> 12
 9481 -> 13
78123 -> 14
64121 -> 15
41565 -> 16
52210 -> 17
91569 -> 18
```
The compressed number is each user ID minus 2, reversed, and joined together (except `9481` which is changed into `97490`, and `58563` which is not included). `5ô` splits it, `εR}` reverses it, `sk` returns the index of the input in the list, and `Ì` adds 2.
[Answer]
# 14. [Stax](https://github.com/tomtheisen/stax), 48 bytes
```
"&,R>&N_QbmO.%:VUVh5m@x~|LVju(bWJij<$"%98542|EI^
```
[Run and debug it](https://staxlang.xyz/#c=%22%26,R%3E%26N_QbmO.%25%3AVUVh5m%40x%7E%7CLVju%28bWJij%3C%24%22%2598542%7CEI%5E&i=58563%0A80214%0A95792%0A89930%0A86147%0A97857%0A98541%0A95594%0A70745%0A45613%0A94066%0A44718%0A+9481%0A78123&a=1&m=2)
You thought the time for trivial solutions was over? Fool!
Well, maybe not entirely trivial. But the nontrivial part was generated by Stax's array literal generator. The only thing I added is the `I^`, which means "find the index of the input number in the array and increment it".
The code could be packed, but this is not [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'").
Updated list:
```
58563 -> 1
80214 -> 2
95792 -> 3
89930 -> 4
86147 -> 5
97857 -> 6
98541 -> 7
95594 -> 8
70745 -> 9
45613 -> 10
94066 -> 11
44718 -> 12
 9481 -> 13
78123 -> 14
```
[Answer]
# 16. [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 47 bytes
Not creative... just a basic mapping. Constants came from experimentation
```
x=>" +$Q2('%OINFA;4@0".IndexOf((char)(x%49+35))
```
[Try it online!](https://tio.run/##NZJRb4IwEMef9VNczMwgolJsSxun2bLExGSbW/awh2UPBFCbKCSAm4vhs7ve0fFQ8vtfOX5HSetxWlb59VSbYgfvv3WTH@f99JDUNbxW5a5KjnDp9@omaUwK36XJ4Dkxhedj2vtOKjBZDQso8p/PL8p6Qgk5C0CFEeMBaBHryJLWszAArCvJeGwLsRJ4U4Iz3CY07@pxGHMRABeS2Taah1Ja4jFTAZY1V3Y/xIpFtiw5iyxyJqTAcju3y3QKJAHjJbCOyQY56pi0kGeujn7I3DFKIgu3H22RpWPURo7/@1l/ZNUxDYGsO6ZpyCd0D@BcFDhDmpACpwg4KQXOkUamwEnS8BQ4S/oMFMg@uKu3OhXpnSmaAOyyhC0srufFcgCjm7fIux1u1i@rhzm/DweTdZHl583W89J9Uvneecj1aCZ8/4ofdWt/kyTdg9cdum2GR@/jkTyWRV0e8slHZZr8yRS5N7iEgWjR5MLagX1zFsDWM5nv21Ztv73@AQ "C# (.NET Core) – Try It Online")
Updated list:
```
58563 -> 1
80214 -> 2
95792 -> 3
89930 -> 4
86147 -> 5
97857 -> 6
98541 -> 7
95594 -> 8
70745 -> 9
45613 -> 10
94066 -> 11
44718 -> 12
 9481 -> 13
78123 -> 14
64121 -> 15
41565 -> 16
```
[Answer]
# 10. [Python 3](https://docs.python.org/3/), 44 bytes
```
lambda x:'973.84.612..5a'[int(x[0]+x[4])%15]
```
[Try it online!](https://tio.run/##FYvNCoMwEITvfYpcikohJGY32Qh9kjSHlGIr1B@iFH36bbwMwzffLMf2mSfDw7jMeRPrsV76@4O/aXy@kti7yjsjCaTVrZSYqjBMW70HFW97gNhcNUbu5yxSfothOv@y1F/QXezEkk@7rwtpGmYktIZJtRrYo/Mtk/dGMVkNjr0jLEkIuqzogZ1ygAxotfkD "Python 3 – Try It Online")
Input is taken as a decimal string and returned as a hexadecimal string
Updated list:
```
58563 -> 1
80214 -> 2
95792 -> 3
89930 -> 4
86147 -> 5
97857 -> 6
98541 -> 7
95594 -> 8
70745 -> 9
45613 -> 10  (displayed as `a` in this case)
```
## Explanation
Takes the first and last digits, mod 15 and indexes into a string lookup table. This approach won't work for too much longer, but could probably be stretched to 20 or so in a language with more flexible string->int conversion, like Javascript, PHP, or Perl.
[Answer]
# 11. [05AB1E](https://github.com/Adriandmen/05AB1E), 30 bytes
```
•γ¤š×Pγ…þiðþ–
çô&`)½c©2è•5ôsk>
```
[Try it online!](https://tio.run/##AUMAvP9vc2FiaWX//@KAos6zwqTFocOXUM6z4oCmw75pw7DDvuKAkwrDp8O0JmApwr1jwqkyw6jigKI1w7Rzaz7//zk0MDY2 "05AB1E – Try It Online")
Updated list:
```
58563 -> 1
80214 -> 2
95792 -> 3
89930 -> 4
86147 -> 5
97857 -> 6
98541 -> 7
95594 -> 8
70745 -> 9
45613 -> 10
94066 -> 11
```
---
```
•...•5ôsk>  # trimmed program
        k   # get 0...
         >  # plus 1...
        k   # -based index of...
       s    # implicit input...
        k   # in...
•...•       # 5856380214957928993086147978579854195594707454561394066...
      ô     # split in pieces of...
     5      # literal
            # implicit output
```
[Answer]
# 19. [Befunge-93](https://github.com/catseye/Befunge-93), 45 bytes
```
"0$>K"&\%\%\%\%1g\-.@
/1C274=B8?A5>:/@;3</96
```
[Try it online!](https://tio.run/##S0pNK81LT/3/X8lAUsXOW0ktRhUCDdNjdPUcuPQNnY3MTWydLOwdTe2s9B2sjW30Lc3@/ze2MDUCAA "Befunge-93 – Try It Online")
Updated list:
```
58563 -> 1
80214 -> 2
95792 -> 3
89930 -> 4
86147 -> 5
97857 -> 6
98541 -> 7
95594 -> 8
70745 -> 9
45613 -> 10
94066 -> 11
44718 -> 12
 9481 -> 13
78123 -> 14
64121 -> 15
41565 -> 16
52210 -> 17
91569 -> 18
 3852 -> 19
```
There's a raw low-ASCII byte (decimal 25) between the `0` and the `$`.
This computes `str[input%75%62%36%25] - '0'`, where `str` is the string on the second line of the program.
]