Giới thiệu

Bạn phải tạo một hàm để chuyển đổi các chữ số Ả Rập thành các chữ số Hy Lạp. Đầu vào sẽ là một số nguyên nhỏ hơn 1000và nhiều hơn 0.

Thuật toán

1. Số chia thành chữ số (ví dụ 123-> 1, 2, 3)
2. Hãy mỗi chữ số, và thay đổi nhân vật được tìm thấy trong bảng dưới đây, để biểu tượng chữ cái hoặc tên thư, (ví dụ 123-> 1, 2, 3-> ΡΚΓhoặc RhoKappaGamma).

Thông số kỹ thuật

• Không có chuyển đổi hệ thống số tích hợp
• Kết quả phải được viết hoa như trong ví dụ.
• Đầu vào sẽ ở cơ sở 10.

Các trường hợp thử nghiệm

123 -> RhoKappaGamma or ΡΚΓ
8 -> Eta or Η
777 -> PsiOmicronZeta or ΨΟΖ
100 -> Rho or Ρ
606 -> ChiDiGamma or ΧϜ

Bàn

Α = 1 = Alpha = 913 UTF-8
Β = 2 = Beta = 914 UTF-8
Γ = 3 = Gamma = 915 UTF-8
Δ = 4 = Delta = 916 UTF-8
Ε = 5 = Epsilon = 917 UTF-8
Ϝ = 6 = DiGamma = 988 UTF-8
Ζ = 7 = Zeta = 918 UTF-8
Η = 8 = Eta = 919 UTF-8
Θ = 9 = Theta = 920 UTF-8

Ι = 10 = Iota = 921 UTF-8
Κ = 20 = Kappa = 922 UTF-8
Λ = 30 = Lambda = 923 UTF-8
Μ = 40 = Mu = 924 UTF-8
Ν = 50 = Nu = 925 UTF-8
Ξ = 60 = Xi = 926 UTF-8
Ο = 70 = Omicron = 927 UTF-8
Π = 80 = Pi = 928 UTF-8
Ϙ = 90 = Koppa = 984 UTF-8

Ρ = 100 = Rho = 929 UTF-8   
Σ = 200 = Sigma = 931 UTF-8
Τ = 300 = Tau = 932 UTF-8
Υ = 400 = Upsilon = 933 UTF-8
Φ = 500 = Phi = 934 UTF-8
Χ = 600 = Chi = 935 UTF-8
Ψ = 700 = Psi = 936 UTF-8
Ω = 800 = Omega = 937 UTF-8
Ϡ = 900 = SamPi = 992 UTF-8

Thạch , 42 40 byte

“#'nn(2jj33556;r”Or2/F+878Ọ
ṚĖ’ḅ9‘xṚQṚị¢

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Pyth, 49 48 46 44 byte

_s.b@+kNsYc3mC+913d-.iU25smXm17hT4Cd"KGO"17_

Hãy thử nó ở đây.

Vẫn đang làm việc để rút ngắn chức năng tạo bảng chữ cái ... và vâng, trình tạo dài hơn mã hóa bảng chữ cái bằng 4 ký tự, nhưng không tính bằng byte.

_s.b@+kNsYc3[...]_
                 _  get input (implicit) and reverse
            [...]   generate "ΑΒΓΔΕϜΖΗΘΙΚΛΜΝΞΟΠϘΡΣΤΥΦΧΨΩϠ" (see below)
          c3        split into 3 equal chunks
  .b                map over each input digit (as Y) and chunk (as N)...
     +kN            prepend empty string to N (to support digits of 0)
    @   sY          get the Yth element of the empty-string-plus-digits array
 s                  concatenate all the digits
_                   reverse again to put digits back in the right order

Đây là cách chức năng tạo bảng chữ cái hoạt động. Hãy lấy tất cả các điểm mã và trừ 913 (giá trị nhỏ nhất):

0 1 2 3 4 75 5 6 7 8 9 10 11 12 13 14 15 71 16 18 19 20 21 22 23 24 79

Bây giờ, hãy rút ra những cái không phù hợp với mẫu:

0 1 2 3 4    5 6 7 8 9 10 11 12 13 14 15    16 18 19 20 21 22 23 24
          75                             71                         79

Được rồi, vì vậy chiến lược đang hình thành: tạo phạm vi từ 0 đến 24 (chúng ta sẽ xử lý 17 thiếu sau), sau đó chèn 75, 71 và 79 vào đúng vị trí.

Làm thế nào chúng ta có thể chèn các ngoại lệ? Pyth có .ichức năng nterleave mất ex. [1,2,3]và [4,5,6]kết quả trong [1,4,2,5,3,6]. Tuy nhiên, chúng ta sẽ phải thêm một số trình giữ chỗ, vì rõ ràng các ngoại lệ cách xa nhau. Hãy đại diện cho trình giữ chỗ với X:

0 1 2 3  4 5 6 7 8 9 10 11 12 13 14 15 16 18 19 20 21 22 23 24
X X X X 75 X X X X X  X  X  X  X  X 71  X  X  X  X  X  X  X 79

Phải, vì vậy mảng ngoại lệ phía dưới bắt đầu bằng bốn Xs. Chúng ta có thể nhóm các ngoại lệ cho mỗi trước bốn Xgiây và xem những gì còn lại không?

0 1 2 3  4 5 6 7 8 9 10 11 12 13 14 15 16 18 19 20 21 22 23 24
[four X]75 X X X X X  X [  four X  ]71  X  X  X [  four X  ]79

Bây giờ chúng tôi thực hiện một quan sát quan trọng khác: vì 79 đến cuối cùng , có thể có bất kỳ số Xs nào đứng trước nó và bất kỳ số lượng nàoX theo sau nó! Điều này là do xen kẽ [1,2,3]và [4,5,6,7,8,9]kết quả là trong chú thích [1,4,2,5,3,6,7,8,9]rằng các phần tử bổ sung trong mảng thứ hai kết thúc ở cuối và vì dù sao chúng sẽ bị xóa, chúng ta có thể cho phép điều đó một cách an toàn.

Điều đó có nghĩa là chúng ta có thể bình thường hóa điều này sao cho mọi ngoại lệ đều đi trước bốn Xgiây và thành công sau 6:

0 1 2 3  4 5 6 7 8 9 10 11 12 13 14 15 16 18 19 20 21 22 23 24
[four X]75[   six X   ] [  four X  ]71[     six X      ] [four X]79[six X]

Tuyệt quá! Bây giờ chúng ta chỉ cần lấy mảng [75, 71, 79], chèn bốn giá trị giữ chỗ trước mỗi phần tử và sáu sau, sau đó xen kẽ nó với phạm vi 0..24.

Nhưng chờ đã, chuyện gì đã xảy ra 17? Hãy nhớ rằng, dòng trên cùng trong tất cả các ví dụ này đã bị thiếu 17. Chúng ta chỉ cần xóa 17 sau khi xen kẽ; nhưng điều này để lại một khả năng ác thú vị khác mở ra. Bạn đoán nó là giá trị giữ chỗ mà chúng tôi đã đề cập đến là X17. Điều này cho phép chúng tôi loại bỏ cả 17 giá trị ngoại lai và tất cả các giá trị giữ chỗ trong một cú trượt.

Cuối cùng! Đây là mã được sử dụng để thực hiện điều này:

mC+913d-.iU25smXm17hT4Cd"KGO"17
              m         "KGO"    for each char in the string "KGO"...
                      Cd         take its ASCII value ("KGO" -> 75,71,79)
                m17hT            generate an 11-element array filled with 17
               X     4           replace the 5th element with the ASCII value ^^
             s                   concatenate all of these together
        .iU25                    interleave with range(25)
       -                     17  remove all the 17s
m     d                          for each value in the resulting array...
  +913                           add 913 (to get the real character value)
 C                               convert to character

JavaScript (ES6), 120 115 byte

n=>(s=n+"").replace(/./g,(d,i)=>d--?"ΑΒΓΔΕϜΖΗΘΙΚΛΜΝΞΟΠϘΡΣΤΥΦΧΨΩϠ"[d+9*(s.length+~i)]:"")

Số lượng byte đang sử dụng UTF-8. Nó dài 88 ký tự. Đầu vào là một con số.

Kiểm tra

var solution = n=>(s=n+"").replace(/./g,(d,i)=>d--?"ΑΒΓΔΕϜΖΗΘΙΚΛΜΝΞΟΠϘΡΣΤΥΦΧΨΩϠ"[d+9*(s.length+~i)]:"")
var testCases = [ 123, 8, 777, 100, 606, 700, 803 ];
document.write("<pre>"+testCases.map(c=>c+": "+solution(c)).join("\n"));

Python 3, 118 byte

f=lambda n,i=3:i*"_"and f(n//10,i-1)+"   ΡΙΑΣΚΒΤΛΓΥΜΔΦΝΕΧΞϜΨΟΖΩΠΗϠϘΘ"[i-1::3][n%10].strip()

Võng mạc , 57 byte

• 11 byte được lưu nhờ @Martin Büttner.

Chuyển ngữ đơn giản với phạm vi ký tự phù hợp và 0xóa trên mỗi chữ số.

T`d`_ΡΣ-ΩϠ`.(?=..)
T`d`_Ι-ΠϘ`.\B
T`d`_Α-ΕϜΖ-Θ

Hãy thử trực tuyến. (Dòng đầu tiên được thêm vào để cho phép tất cả các testcase chạy cùng nhau.)

Martin cũng đề nghị cái này cho cùng một số điểm:

T`d`_J-R`.(?=..)
T`d`_L`.\B
T`dL`_Α-ΕϜΖ-ΠϘΡΣ-ΩϠ

Julia, 138 byte

f(x,d=digits(x))=reverse(join([d[i]>0?[["ΑΒΓΔΕϜΖΗΘ","ΙΚΛΜΝΞΟΠϘ","ΡΣΤΥΦΧΨΩϠ"][i]...][d[i]]:""for i=1:endof(d)]))

Đây là một hàm chấp nhận một số nguyên và trả về một chuỗi.

Đối với mỗi chữ số trong đầu vào theo thứ tự đảo ngược, chúng ta lấy ký tự tương ứng với chữ số đó từ chuỗi thích hợp sau đó kết hợp các ký tự và đảo ngược kết quả. Đối với bất kỳ chữ số nào là 0, chúng tôi chỉ cần sử dụng chuỗi trống.

Julia, 84 byte

f(x,p=0)=x>0?f(x÷10,p+9)"$(x%10<1?"":"/0123z456789:;<=>v?ABCDEFG~"[p+x%10]+866)":""

Hãy thử trực tuyến!

JavaScript (ES6), 83 ký tự, 110 byte

n=>`${1e3+n}`.replace(/./g,(d,i)=>i--&&d--?"ΡΣΤΥΦΧΨΩϠΙΚΛΜΝΞΟΠϘΑΒΓΔΕϜΖΗΘ"[d+9*i]:"")

Perl 6 , 102 byte

{[~] <ΡΣΤΥΦΧΨΩϠ ΙΚΛΜΝΞΟΠϘ ΑΒΓΔΕϜΖΗΘ>>>.&{('',|$^b.comb)[$_/100*10**$++%*]}}

Hãy thử trực tuyến!

Ruby, 134 byte

Tra cứu cơ bản bằng cách sử dụng mô-đun. Có lẽ nó có thể được tối ưu hóa ở đâu đó, nhưng Ruby sẽ không ép buộc các chuỗi thành số nguyên theo cách Javascript có thể, haha

->n{((0<d=n/100)?"ΡΣΤΥΦΧΨΩϠ"[d-1]:"")+((0<d=n%100/10)?"ΙΚΛΜΝΞΟΠϘ"[d-1]:"")+((0<n%=10)?"ΑΒΓΔΕϜΖΗΘ"[n-1]:"")}