[Question]
  [
Given a fraction in the format `m/n` (where m and n are coprime integers), output the corresponding Unicode fraction. Your program/function will not be expected to take in any input that does not correspond to a Unicode character. Arrays, e.g. `[2, 3]` as opposed to `2/3`, are accepted. `m / n` as opposed to `m/n` is also fine. Two separate inputs `m` and `n` are also valid.
The Unicode fractions that must be handled are as follows:
```
½, ⅓, ⅔, ¼, ¾, ⅕, ⅖, ⅗, ⅘, ⅙, ⅚, ⅐, ⅛, ⅜, ⅝, ⅞, ⅑, ⅒
```
Thus, the possible inputs are as follows:
```
1/2, 1/3, 2/3, 1/4, 3/4, 1/5, 2/5, 3/5, 4/5, 1/6, 5/6, 1/7, 1/8, 3/8, 5/8, 7/8, 1/9, 1/10
```
The Unicode codepoints of the characters are as follows:
```
188 ¼
189 ½
190 ¾
8528 ⅐
8529 ⅑
8530 ⅒
8531 ⅓
8532 ⅔
8533 ⅕
8534 ⅖
8535 ⅗
8536 ⅘
8537 ⅙
8538 ⅚
8539 ⅛
8540 ⅜
8541 ⅝
8542 ⅞
```
## Test Cases
```
1/2 -> ½
1/3 -> ⅓
2/3 -> ⅔
1/4 -> ¼
3/4 -> ¾
3/8 -> ⅜
1/10 -> ⅒
```
Make your code as short as possible; this is code golf.
  
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~78~~ 77 bytes
*Saved 1 byte thanks to @HermanLauenstein*
Takes input in currying syntax `(m)(n)`.
```
m=>n=>'¾⅗  ⅜    ⅞⅘½⅓¼⅕⅙⅐⅛⅑⅒⅚⅔⅝⅖'[(m*9+n)%31]
```
[Try it online!](https://tio.run/##HcpLbsIwEIDhfU8xQqqwi0MxIQVUJbueIvLCCaQPQVxB1RvMvoU@gfYklEWOMhdJ7dl8M/NrHuyzXZer@8enqHazeVul7TLN6jTrNifCTwDCA0AYv4RfzR/htjkSvhN@E74Q7glfCTeEO8I3wh/Cj24ulhfTXi3PY23a6zzXamiUN/YOWa1G3pjVKuGecAmOWK2uvAmr1Zid8M@Ee3DMajVl9cCYs37lVje2vBMitwoKIyHNoHT12i3m/YW7FRZ60LnseIuwQRRlEK5KWCkKKWX7Dw "JavaScript (Node.js) – Try It Online")
[Answer]
# [Perl 6](https://perl6.org), ~~48~~ 43 bytes
```
{chr first *.unival==$^m/$^n,(|^191,|(8528..*))}
```
[Try it](https://tio.run/##Hc5ha4MwEAbg7/kVBytTS0i8GDUiGfslQrGWOVodWgsy99tdXr88cPfeHffTTfdif6OYXUUuzxgYYueIqxRFBizIQQFK4AIGZNi0GLZYtwbBcS0VYpk7ehWqrcVjpfd2vHbk99/2a6JbP81POqtl6F@Xu/en5qFPzSDjreGK5RbjvFLnJPnbw@7nc1rJE2sjA5kkA1hbSRlgnaOXowxYwLqQlAPWJXBIHXqBErCuAKe1EPNlJTUs1059j/0QRzpKJEXkPyiSdLy@HTHdxun4p97/AQ "Perl 6 – Try It Online")
```
{chr first *.unival==$_,(|^191,|(8528..*))}
```
[Try it](https://tio.run/##Hc7taoMwFAbg/7mKAytTS0g8JtGIOHYlK8Va5uh0xFqQddfu8vrngfPxHs5PH27l9kIp@5q8MwwKYu@J6xyFARY4UIIK@EgBDJIWyxZxW2CwX8uFWOaeHqXqGvG90ms3XXpqt9/uM9B1CPOdjmoZh8f51raHk0yfH1yzfKa4rNQxy/62GHu/h5VaYl3IiJFUANZWkgGsHXoOZcQC1qUkB1hXwGPq0YtUgHUNOG@EmM8rqXG59OprGsY00UkmKaH2jRJJ@9eHE12nsP/SbP8 "Perl 6 – Try It Online")
## Expanded:
```
{  # bare block lambda with implicit parameter ｢$_｣
  chr
    first               # find the first value
      *.unival ==       # which has a unicode value that matches
          $_,           # the input fraction (as a Rational)
      (
        |^191,     # ¼(189) ½(188) ¾(190)
        |(8528..*) # all of the rest
      )
}
```
Note that the search has to be split up so that it doesn't return other Unicode characters that have the same unival. (otherwise it would be `(1..*)`)
[Answer]
## JavaScript (ES6), ~~88~~ ~~86~~ ~~84~~ ~~81~~ 79 bytes
*Saved 2 bytes thanks to @Arnauld*
```
m=>n=>String.fromCharCode((4%n?8528:188)|"  130470912"[n]*1.3+~-m/-~"3 1"[n-6])
```
Not quite as short as the other JS answer, but it was fun to calculate the code-point of each fraction mathematically.
### Test snippet
```
let f =
m=>n=>String.fromCharCode((4%n?8528:188)|"  130470912"[n]*1.3+~-m/-~(n-6?n==8:3))
document.body.innerText = [
  [1,2],
  [1,3], [2,3],
  [1,4], [3,4],
  [1,5], [2,5], [3,5], [4,5],
  [1,6], [5,6],
  [1,7],
  [1,8], [3,8], [5,8], [7,8],
  [1,9],
  [1,10]
].map(([m,n])=>m+"/"+n+": "+f(m)(n)).join('\n')
```
Old method (82 bytes):
```
m=>n=>String.fromCharCode((4%n?8539:189)-("0x"+"  08162b0a9"[n])+~-m/-~"3 1"[n-6])
```
Saved 4 bytes on this one thanks to @Arnauld.
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), ~~88~~ 64 bytes
```
{⎕UCS(⌊(⍺-1)÷(1+⍵≡8)⌈4×⍵≡6)-(291194049⊤⍨10⌿12)[⍵]-189⌈8539××⍵|4}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P@1R24TqR31TQ52DNR71dGk86t2la6h5eLuGofaj3q2POhdaaD7q6TA5PB3CM9PU1TCyNDS0NDEwsXzUteRR7wpDg0c9@w2NNKOBKmJ1DS0sgeotTI0tD08Ha6oxqf3/31AhTcGIC0Qag0kTMGkKJs3ApDmYtACTlmDS0IDLCKzBCKzUGKzNGM624DIBs03BRpiCRcxBJAA "APL (Dyalog Unicode) – Try It Online")
-3 thanks to [dzaima](https://codegolf.stackexchange.com/users/59183/dzaima).
Using ETHproductions's 84-byte approach.
The `f←` included on TIO isn't counted, since it's put there just to be able to test the function.
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGLOnline), 51 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
5*+'æ%'⁵%"∫}ΣS“LI─{"#!“+ζ}¹"¾ŗŗŗŗŗŗ⅛ŗ⅜½⅝ŗ⅞ ⅓⅔ŗ  ¼”W
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=NSorJTI3JUU2JTI1JTI3JXUyMDc1JTI1JTIyJXUyMjJCJTdEJXUwM0EzUyV1MjAxQ0xJJXUyNTAwJTdCJTIyJTIzJTIxJXUyMDFDKyV1MDNCNiU3RCVCOSUyMiVCRSV1MDE1NyV1MDE1NyV1MDE1NyV1MDE1NyV1MDE1NyV1MDE1NyV1MjE1QiV1MDE1NyV1MjE1QyVCRCV1MjE1RCV1MDE1NyV1MjE1RSUyMCV1MjE1MyV1MjE1NCV1MDE1NyUyMCUyMCVCQyV1MjAxRFc_,inputs=OCUwQTM_,v=0.12)
uses the mapping `(m + n*5)%33%22`
Explanation:
```
5*                        multiply the 1st input by 5
  +                       add to the 2nd input
   'æ%                    modulo 33
      '⁵%                 module 22
"∫}ΣS“                    push 2153527158
      LI─                 base 11 decode that - [10 0 5 6 7 8 9 1 2]
         {     }          for each of that
          "#!“+             add 8528
               ζ            and convert to a character
                "...”     push "¾ŗŗŗŗŗŗ⅛ŗ⅜½⅝ŗ⅞ ⅓⅔ŗ  ¼", replacing ŗ with each character of the above array
                     W    and get the (m + n*5)%33%22th item from that
```
[Answer]
# Clojure, 127 bytes
```
(comp{2/3\⅔ 4/5\⅘ 1/3\⅓ 1/2\½ 5/6\⅚ 1/5\⅕ 1/4\¼ 3/5\⅗ 1/7\⅐ 3/4\¾ 2/5\⅖ 1/6\⅙ 1/9\⅑ 1/8\⅛ 3/8\⅜ 1/10\⅒ 5/8\⅝ 7/8\⅞}read-string)
```
An anonymous function that takes input as `"1/2"`, and returns the corresponding character.
A straight mapping from a Clojure `Ratio` to a fraction character. `comp`, and the fact that Clojure maps are functions really helped here. I needed to pass the string input through `read-string` to evaluate it as a ratio type, since that allows me to discard all the bloating quotes in the map. `comp` let me do that point-free, which was nice. The "full" code would be:
```
(defn to-unicode-fraction [frac]
  (get {2/3\⅔ 4/5\⅘ 1/3\⅓ 1/2\½ 5/6\⅚ 1/5\⅕ 1/4\¼ 3/5\⅗ 1/7\⅐,
        3/4\¾ 2/5\⅖ 1/6\⅙ 1/9\⅑ 1/8\⅛ 3/8\⅜ 1/10\⅒ 5/8\⅝ 7/8\⅞}
       (read-string frac)))
```
After looking over the other answers, I realized that this approach is pretty naïve. I'm looking for ways of improving it.
[Answer]
# [Swift](https://swift.org), ~~106~~ 82 bytes
*Port of [@Arnaulds JavaScript answer](https://codegolf.stackexchange.com/a/150809/70894)*
*Saved 24 bytes thanks to @Mr.Xcoder*
```
{Array("¾⅗  ⅜    ⅞⅘½⅓¼⅕⅙⅐⅛⅑⅒⅚⅔⅝⅖")[($0*9+$1)%31]}
```
[Try it online!](https://tio.run/##Vcy9CsIwFIbh3asIpUKiDk3T2nZw8DrEoUuhi0gsiojj2f3/1ytRh1zKuZEYt5wpPHznzWxRV01i7bzUrBqshlqXSx6YL8KZMYQHY//nhXAxH4S9eSMcEa4IG4Q7whZhh3BDOCA8EU6BGPEw6hTdUIq2kuO1nep60vCKyx6LhWh5VB5jSrcmHhWlW1PapvTYZ0Lp2r7HlNKtGWVOf85p6zOjdG1BKSMh7A8 "Swift 4 – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~77~~ ~~48~~ 46 bytes
```
Ｆ§§⪪“YW³⦄Ｅν~vγ@⊖Ｘμ～?Iw⸿Ｍ➙b℅¦⦃”,ＮＮ℅⁺℅ι×⁹⁰∨№βι⁹⁴
```
[Try it online!](https://tio.run/##ZU3JCsIwFLz7FY@cXuAJHhQsnqRudWnr8gNpWjGQpiVNxL@P6cWLcxlmY@RLWNkJHcKzs4Brl5m6@fz43mvlkN1ou5P7KrtsCjrAkU4AZU1nyuFKDIAR4wSZ6b3LfVs1Fvmf5lBaZRym8VBIF71S@wELWysjNKo4eKi2GTCZERQW087HdkUwJsmcj1iFsJgsw/Stvw "Charcoal – Try It Online") Link is to verbose version of code. Edit: Saved ~~29~~ 31 bytes by mapping from ASCII chars to multibyte chars. Explanation:
```
    “....”                  Compressed string `R,EFcGbIMDO,H J,K  Pd,L,N Q,`
   ⪪      ,                 Split on commas
           Ｎ                First input
  §                         Circularly index
            Ｎ               Second input
 §                          Circularly index
Ｆ                           "Loop over" character (loop variable `i`)
                     №βι    Count of `i`s in lowercase letters
                    ∨   ⁹⁴  Replace zero result with 94
                 ×⁹⁰        Multiply by 90
               ℅ι           Take ordinal of `i`
              ⁺             Sum
             ℅              Convert back to character
                            Implicitly print
```
[Answer]
# [Python 3](https://docs.python.org/3/), 87 bytes
```
lambda n:'⅛⅑⅜¾⅗⅔⅚⅖⅝⅘⅞⅒½⅓¼⅕⅙⅐'[int(n[::2])%50%36%31%18]
```
[Try it online!](https://tio.run/##Lcw9CsIwHIbx3VNkCWlBaNOolIAnqR0qEixoWkoXD/Dufn/rSdShR/lfJNbi8hue4SlX9bywypnxxC2y5XSWMasF4UbYEO7Nh3Ai7AlXwpHwIJwJT8K2eRN2zYtwIFwIa5HktvZsonWU@nwYcjXiSnIZp84UFbMst0zIIBL9VtUadcpg0Kr@xl2RodA9xsrqdzSe9X33BQ "Python 3 – Try It Online")
or
```
lambda n:'⅝⅔⅜⅖__⅞¾⅗⅘_⅒½⅓¼⅕⅙⅐⅛⅑⅚'[int(n[::2])%36%27%22]
```
[Try it online!](https://tio.run/##LcxLCsIwFIXhuavIpKQFoTYRlYArqaVUpFjQtJROXMCd@37rStRBlnI2EmNx8vFzBqdaNfNSS5uPJ3aRLaezjGnFQQ/QHnQHHdMU9DQf0Al0dr01b9DOvEAH0AW0Bt1AG9CVx4VufB0rJZLAkwNPDD0hEpuXNdOs0IxHoeBdp3SK1ijsO@XfUbtEPa46jFX17y73dRDYLw "Python 3 – Try It Online")
[Answer]
# Python 3, 97 bytes
```
lambda m,n:'½ ⅓⅔ ¼_¾ ⅕⅖⅗⅘ ⅙___⅚ ⅐ ⅛_⅜_⅝_⅞ ⅑ ⅒'.split()[n-2][m-1]
```
[Answer]
# Vim Script, 67 bytes
```
fu!F(m,n)
if a:n==10|norm a⅒ 
else|exe'norm a'.a:m.a:n
endif
endfu
```
The function works with Vim's *digraphs* which are entered after starting them iwth `ctrl-k.` Apparently, the relevant `ctrl-k` character after the `exe'norm` is not rendered in the code block above.
]