pengantar

Anda harus membuat fungsi untuk mengubah angka Arab menjadi angka Yunani. Input akan berupa bilangan bulat kurang dari 1000dan lebih dari 0.

Algoritma

1. Jumlah dibagi menjadi digit (misalnya 123-> 1, 2, 3)
2. Mengambil setiap digit, dan perubahan karakter yang ditemukan di tabel di bawah ini, untuk surat simbol atau nama surat, (misalnya 123-> 1, 2, 3-> ΡΚΓatau RhoKappaGamma).

Spesifikasi

• Tidak ada konversi sistem angka bawaan
• Hasil harus dikapitalisasi sebagai contoh.
• Input akan berada di basis 10.

Uji Kasus

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

Meja

Α = 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

Jelly , 42 40 byte

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

Cobalah online! atau verifikasi semua kasus uji .

Pyth, 49 48 46 44 byte

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

Coba di sini.

Masih bekerja untuk memperpendek fungsi untuk menghasilkan alfabet ... dan ya, generator lebih panjang dari pengodean alfabet sebanyak 4 karakter, tetapi tidak dalam 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

Begini cara fungsi penghasil alfabet bekerja. Mari kita ambil semua codepoint dan kurangi 913 (nilai terkecil):

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

Sekarang mari kita tarik yang tidak sesuai dengan pola:

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

Oke, jadi strateginya terbentuk: hasilkan rentang 0 hingga 24 (kita akan berurusan dengan 17 yang hilang nanti), lalu masukkan 75, 71, dan 79 di lokasi yang benar.

Bagaimana kita bisa memasukkan outlier? Pyth memiliki .ifungsi nterleave yang mengambil ex. [1,2,3]dan [4,5,6]dan menghasilkan [1,4,2,5,3,6]. Kami harus menambahkan beberapa placeholder, karena jelas outliernya berjauhan. Mari kita mewakili pengganti dengan 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

Benar, jadi array outlier bawah dimulai dengan empat Xs. Bisakah kita mengelompokkan outlier ke masing-masing didahului oleh empat Xdan melihat apa yang tersisa?

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

Sekarang kita membuat pengamatan kunci lain: sejak 79 datang pada akhir , bisa ada setiap jumlah Xs mendahuluinya, dan setiap jumlah Xs berikut juga! Ini karena interleaving [1,2,3]dan [4,5,6,7,8,9]menghasilkan [1,4,2,5,3,6,7,8,9]—catat bahwa elemen tambahan dalam array kedua berakhir di akhir, dan karena mereka akan dihapus, kita dapat mengizinkannya dengan aman.

Itu berarti kita dapat menormalkan ini sehingga setiap outlier didahului oleh empat Xdan digantikan oleh 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]

Bagus! Sekarang kita bisa mengambil array [75, 71, 79], menyisipkan empat nilai placeholder sebelum setiap elemen dan enam setelahnya, dan kemudian interleave dengan rentang 0..24.

Tapi tunggu, apa yang terjadi 17? Ingat, baris teratas dalam semua contoh ini telah hilang 17. Kita cukup menghapus 17 setelah interleaving; tetapi ini membiarkan kemungkinan jahat lainnya terbuka. Anda dapat menebaknya — nilai placeholder yang telah kami rujuk Xakan menjadi 17. Ini memungkinkan kami untuk menghapus kedua nilai 17 yang asing dan semua nilai placeholder dalam sekali gerakan.

Akhirnya! Berikut kode yang digunakan untuk mengimplementasikan ini:

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)]:"")

Hitungan byte menggunakan UTF-8. Panjangnya 88 karakter. Input adalah angka.

Uji

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

Retina , 57 byte

• 11 byte disimpan berkat @Martin Büttner.

Transliterasi sederhana dengan rentang karakter yang sesuai dan 0penghapusan pada setiap digit.

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

Cobalah online. (Baris pertama ditambahkan untuk memungkinkan semua testcase berjalan bersama.)

Martin juga menyarankan yang ini untuk skor yang sama:

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

Ini adalah fungsi yang menerima integer dan mengembalikan string.

Untuk setiap digit dalam input dalam urutan terbalik, kita mendapatkan karakter yang sesuai dengan digit itu dari string yang sesuai kemudian menggabungkan karakter dan membalikkan hasilnya. Untuk setiap angka 0, kita cukup menggunakan string kosong.

Julia, 84 byte

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

Cobalah online!

JavaScript (ES6), 83 karakter, 110 byte

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

Perl 6 , 102 byte

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

Cobalah online!

Ruby, 134 byte

Basic lookup dealie menggunakan modulus. Ini mungkin dapat dioptimalkan di suatu tempat, tetapi Ruby tidak akan memaksa string menjadi bilangan bulat seperti Javascript, haha

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