형식에서 분수가 주어지면 m/n(m과 n은 coprime 정수) 해당 유니 코드 분수를 출력하십시오. 프로그램 / 함수는 유니 코드 문자에 해당하지 않는 입력을받지 않습니다. 예 [2, 3]를 들어와는 반대로 배열 2/3이 허용됩니다. m / n반대로 m/n도 괜찮습니다. 두 개의 입력 m과 n도 유효합니다.

처리해야하는 유니 코드 분수는 다음과 같습니다.

½, ⅓, ⅔, ¼, ¾, ⅕, ⅖, ⅗, ⅘, ⅙, ⅚, ⅐, ⅛, ⅜, ⅝, ⅞, ⅑, ⅒

따라서 가능한 입력은 다음과 같습니다.

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

문자의 유니 코드 코드 포인트는 다음과 같습니다.

188 ¼
189 ½
190 ¾
8528 ⅐
8529 ⅑
8530 ⅒
8531 ⅓
8532 ⅔
8533 ⅕
8534 ⅖
8535 ⅗
8536 ⅘
8537 ⅙
8538 ⅚
8539 ⅛
8540 ⅜
8541 ⅝
8542 ⅞

테스트 사례

1/2 -> ½
1/3 -> ⅓
2/3 -> ⅔
1/4 -> ¼
3/4 -> ¾
3/8 -> ⅜
1/10 -> ⅒

코드를 가능한 짧게 만드십시오. 이것은 코드 골프입니다.

자바 스크립트 (Node.js) , 78 77 바이트

@HermanLauenstein 덕분에 1 바이트 절약

카레 구문으로 입력을 (m)(n)받습니다.

m=>n=>'¾⅗  ⅜    ⅞⅘½⅓¼⅕⅙⅐⅛⅑⅒⅚⅔⅝⅖'[(m*9+n)%31]

온라인으로 사용해보십시오!

펄 6 ,  48  43 바이트

{chr first *.unival==$^m/$^n,(|^191,|(8528..*))}

시도 해봐

{chr first *.unival==$_,(|^191,|(8528..*))}

시도 해봐

넓히는:

{  # 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
      )
}

동일한 유니버설을 가진 다른 유니 코드 문자를 반환하지 않도록 검색을 분할해야합니다. (그렇지 않으면 (1..*))

자바 스크립트 (ES6), 88 86 84 81 79 바이트

@Arnauld 덕분에 2 바이트 절약

m=>n=>String.fromCharCode((4%n?8528:188)|"  130470912"[n]*1.3+~-m/-~"3 1"[n-6])

다른 JS 답변만큼 짧지는 않지만 수학적으로 각 분수의 코드 포인트를 계산하는 것은 재미있었습니다.

테스트 스 니펫

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')

이전 방법 (82 바이트) :

m=>n=>String.fromCharCode((4%n?8539:189)-("0x"+"  08162b0a9"[n])+~-m/-~"3 1"[n-6])

@Arnauld 덕분에 이것에 4 바이트를 절약했습니다.

APL (Dyalog) , 88 64 바이트

{⎕UCS(⌊(⍺-1)÷(1+⍵≡8)⌈4×⍵≡6)-(291194049⊤⍨10⌿12)[⍵]-189⌈8539××⍵|4}

온라인으로 사용해보십시오!

dzaima 덕분에 -3 .

ETHproductions의 84 바이트 접근법 사용.

f←그냥 기능을 테스트 할 수있을 넣어 이후 TIO에 포함이 계산되지 않습니다.

SOGL V0.12 , 51 바이트

5*+'æ%'⁵%"∫}ΣS“LI─{"#!“+ζ}¹"¾ŗŗŗŗŗŗ⅛ŗ⅜½⅝ŗ⅞ ⅓⅔ŗ  ¼”W

여기 사용해보십시오!

매핑을 사용합니다 (m + n*5)%33%22

설명:

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

클로저, 127 바이트

(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)

다음과 같이 입력을받는 익명 함수 "1/2" 받아 해당 문자를 반환 .

Clojure Ratio에서 분수 문자로 의 직접적인 매핑 . compClojure 맵이 함수라는 사실이 여기에 실제로 도움이되었습니다. 문자열 입력을 전달하여 read-string비율 유형으로 평가해야했습니다. 맵에서 모든 부풀어 오른 따옴표를 버릴 수 있기 때문입니다. comp그 포인트 프리를하겠습니다. 좋았습니다. "전체"코드는 다음과 같습니다.

(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)))

다른 답변을 살펴본 후이 접근법이 매우 순진하다는 것을 깨달았습니다. 개선 방법을 찾고 있습니다.

스위프트 , 106 82 바이트

@Arnaulds 포트 JavaScript 답변

@ Mr.Xcoder 덕분에 24 바이트 절약

{Array("¾⅗  ⅜    ⅞⅘½⅓¼⅕⅙⅐⅛⅑⅒⅚⅔⅝⅖")[($0*9+$1)%31]}

온라인으로 사용해보십시오!

숯 , 77 48 46 바이트

Ｆ§§⪪“YW³⦄Ｅν~vγ@⊖Ｘμ～?Iw⸿Ｍ➙b℅¦⦃”,ＮＮ℅⁺℅ι×⁹⁰∨№βι⁹⁴

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 편집 : ASCII 문자에서 멀티 바이트 문자로 매핑하여 29 31 바이트를 저장했습니다 . 설명:

    “....”                  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

파이썬 3 , 87 바이트

lambda n:'⅛⅑⅜¾⅗⅔⅚⅖⅝⅘⅞⅒½⅓¼⅕⅙⅐'[int(n[::2])%50%36%31%18]

온라인으로 사용해보십시오!

또는

lambda n:'⅝⅔⅜⅖__⅞¾⅗⅘_⅒½⅓¼⅕⅙⅐⅛⅑⅚'[int(n[::2])%36%27%22]

온라인으로 사용해보십시오!

파이썬 3, 97 바이트

lambda m,n:'½ ⅓⅔ ¼_¾ ⅕⅖⅗⅘ ⅙___⅚ ⅐ ⅛_⅜_⅝_⅞ ⅑ ⅒'.split()[n-2][m-1]

Vim 스크립트, 67 바이트

fu!F(m,n)
if a:n==10|norm a⅒ 
else|exe'norm a'.a:m.a:n
endif
endfu

빔의와 함수 작품 이중 음자 를 시작한 후 입력 iwth ctrl-k.관련, 분명히 ctrl-k애프터 문자는 exe'norm위의 코드 블록에서 렌더링되지 않습니다.