Einführung

Sie müssen eine Funktion erstellen, um arabische Ziffern in griechische Ziffern umzuwandeln. Die Eingabe ist eine Ganzzahl kleiner 1000und größer als 0.

Algorithmus

1. Split - Nummer in Ziffern (zB 123-> 1, 2, 3)
2. Nehmen Sie jede Ziffer und Änderung Charakter gefunden unten in der Tabelle, für den Buchstaben Symbol oder Buchstaben Namen, (zB 123-> 1, 2, 3-> ΡΚΓoder RhoKappaGamma).

Spezifikationen

• Keine eingebaute Konvertierung des Zahlensystems
• Das Ergebnis muss wie im Beispiel großgeschrieben werden.
• Die Eingabe erfolgt in Basis 10.

Testfälle

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

Tabelle

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

Gelee , 42 40 Bytes

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

Probieren Sie es online aus! oder überprüfen Sie alle Testfälle .

Pyth, 49 48 46 44 Bytes

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

Probieren Sie es hier aus.

Wir arbeiten immer noch daran, die Funktion zum Generieren des Alphabets zu verkürzen ... und ja, der Generator ist länger als das Hardcodieren des Alphabets um 4 Zeichen, jedoch nicht in Bytes.

_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

So funktioniert die Funktion zum Generieren von Alphabeten. Nehmen wir alle Codepunkte und subtrahieren 913 (der kleinste Wert):

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

Ziehen wir nun diejenigen heraus, die nicht zum Muster passen:

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

Okay, die Strategie formt sich also: Generieren Sie den Bereich 0 bis 24 (wir werden uns später mit den fehlenden 17 befassen) und fügen Sie dann 75, 71 und 79 an den richtigen Stellen ein.

Wie können wir die Ausreißer einfügen? Pyth hat eine .iNterleave-Funktion, die ex nimmt. [1,2,3]und [4,5,6]und führt zu [1,4,2,5,3,6]. Wir müssen jedoch einige Platzhalter hinzufügen, da die Ausreißer offensichtlich weit voneinander entfernt sind. Stellen wir den Platzhalter mit X dar:

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

Richtig, das untere Ausreißer-Array beginnt also mit vier Xs. Können wir die Ausreißer so gruppieren, dass jeweils vier XSekunden vorangestellt sind, und sehen, was noch übrig ist?

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

Jetzt machen wir noch eine wichtige Bemerkung: Da 79 ganz am Ende steht , kann eine beliebige Anzahl von Xs davor stehen und eine beliebige Anzahl von Xs, die ihm folgen! Dies liegt daran, dass Interleaving [1,2,3]und [4,5,6,7,8,9]Ergebnisse dazu [1,4,2,5,3,6,7,8,9]führen, dass die zusätzlichen Elemente im zweiten Array am Ende enden. Da sie ohnehin entfernt werden, können wir dies sicher zulassen.

Das heißt, wir können dies so normalisieren, dass jedem Ausreißer vier Sekunden vorausgehen Xund 6 folgen:

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]

Großartig! Jetzt können wir einfach das Array nehmen [75, 71, 79], vier Platzhalterwerte vor jedem Element und sechs nach jedem Element einfügen und es dann mit dem Bereich verschachteln 0..24.

Aber warte, was ist passiert 17? Denken Sie daran, dass in all diesen Beispielen die oberste Zeile 17 fehlt. Wir können die 17 nach dem Verschachteln einfach entfernen. aber dies lässt eine andere herrlich böse Möglichkeit offen. Sie haben es erraten - der Platzhalterwert, auf den wir uns bezogen haben, Xwird 17. Dies ermöglicht es uns, sowohl die fremden 17 als auch alle Platzhalterwerte auf einen Schlag zu entfernen.

Schließlich! Hier ist der Code, mit dem dies implementiert wird:

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 bis 115 Byte

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

Die Byteanzahl verwendet UTF-8. Es ist 88 Zeichen lang. Eingabe ist eine Zahl.

Prüfung

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 Bytes

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

Netzhaut , 57 Bytes

• 11 Bytes dank @Martin Büttner gespeichert.

Einfaches Transliterieren mit entsprechenden Zeichenbereichen und 0Löschen auf jeder Ziffer.

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

Probieren Sie es online aus. (Erste Zeile hinzugefügt, damit alle Testfälle zusammen ausgeführt werden können.)

Martin schlug auch dieses für die gleiche Punktzahl vor:

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

Julia, 138 Bytes

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

Dies ist eine Funktion, die eine Ganzzahl akzeptiert und eine Zeichenfolge zurückgibt.

Für jede Ziffer in der Eingabe in umgekehrter Reihenfolge erhalten wir das dieser Ziffer entsprechende Zeichen aus der entsprechenden Zeichenfolge. Kombinieren Sie dann die Zeichen und kehren Sie das Ergebnis um. Für alle Ziffern, die 0 sind, verwenden wir einfach die leere Zeichenfolge.

Julia, 84 Bytes

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

Probieren Sie es online aus!

JavaScript (ES6), 83 Zeichen, 110 Byte

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

Perl 6 , 102 Bytes

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

Probieren Sie es online aus!

Ruby, 134 Bytes

Grundlegende Suche Dealie mit Modul. Es kann wahrscheinlich irgendwo optimiert werden, aber Ruby wird Strings nicht wie Javascript in ganze Zahlen zwingen, haha

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