Introducción

Debe crear una función para convertir números arábigos en números griegos. La entrada será un número entero menor 1000y mayor que 0.

Algoritmo

1. El número de rama en dígitos (por ejemplo, 123-> 1, 2, 3)
2. Tome cada dígito, y el cambio de carácter encontró en la tabla a continuación, para el símbolo de letra o nombre de la letra, (por ejemplo, 123-> 1, 2, 3-> ΡΚΓo RhoKappaGamma).

Especificaciones

• Sin conversión de sistema numérico incorporado
• El resultado debe ser capitalizado como en el ejemplo.
• La entrada estará en la base 10.

Casos de prueba

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

Mesa

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

Gelatina , 42 40 bytes

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

Pruébalo en línea! o verificar todos los casos de prueba .

Pyth, 49 48 46 44 bytes

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

Pruébalo aquí

Todavía estoy trabajando en acortar la función para generar el alfabeto ... y sí, el generador es más largo que codificar el alfabeto en 4 caracteres, pero no en 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

Así es como funciona la función generadora de alfabeto. Tomemos todos los puntos de código y restemos 913 (el valor más pequeño):

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

Ahora saquemos los que no se ajustan al patrón:

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

Bien, entonces la estrategia se está formando: genere el rango de 0 a 24 (trataremos con los 17 que faltan más tarde), y luego inserte 75, 71 y 79 en las ubicaciones correctas.

¿Cómo podemos insertar los valores atípicos? Pyth tiene una .ifunción nterleave que toma ex. [1,2,3]yy [4,5,6]resultados en [1,4,2,5,3,6]. Sin embargo, tendremos que agregar algunos marcadores de posición, ya que obviamente los valores atípicos están muy separados. Representemos el marcador de posición con 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

Correcto, entonces la matriz de valores atípicos inferiores comienza con cuatro Xs. ¿Podemos agrupar los valores atípicos para que cada uno sea precedido por cuatro Xsy ver qué queda?

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

Ahora hacemos otra observación clave: dado que 79 viene al final , puede haber cualquier número de Xs que lo preceden, ¡y cualquier número de Xs que lo sigan también! Esto se debe a que el entrelazado [1,2,3]y[4,5,6,7,8,9] da resultado: [1,4,2,5,3,6,7,8,9]tenga en cuenta que los elementos adicionales en la segunda matriz terminan en el extremo, y dado que se eliminarán de todos modos, podemos permitirlo de manera segura.

Eso significa que podemos normalizar esto de modo que cada valor atípico esté precedido por cuatro Xsy tenga éxito por 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]

¡Excelente! Ahora podemos simplemente tomar la matriz[75, 71, 79] , insertar cuatro valores de marcador de posición antes de cada elemento y seis después, y luego intercalarlo con el rango 0..24.

Pero espera, ¿qué pasó con 17 ? Recuerde, la línea superior en todos estos ejemplos ha faltado 17. Simplemente podemos eliminar el 17 después de intercalar; pero esto deja abierta otra posibilidad deliciosamente malvada. Lo has adivinado: el valor de marcador de posición al que nos hemos referido Xserá 17. Esto nos permite eliminar tanto el 17 extraño como todos los valores de marcador de posición de una sola vez.

¡Finalmente! Aquí está el código utilizado para implementar esto:

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 bytes

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

El recuento de bytes está utilizando UTF-8. Tiene 88 caracteres de largo. La entrada es un número.

Prueba

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

Retina , 57 bytes

• 11 bytes guardados gracias a @Martin Büttner.

Transliteración simple con rangos de caracteres apropiados y 0eliminación en cada dígito.

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

Pruébalo en línea. (Se agregó la primera línea para permitir que todos los casos de prueba se ejecuten juntos).

Martin también sugirió este por el mismo puntaje:

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

Esta es una función que acepta un número entero y devuelve una cadena.

Para cada dígito en la entrada en orden inverso, obtenemos el carácter correspondiente a ese dígito de la cadena apropiada, luego combinamos los caracteres e invertimos el resultado. Para cualquier dígito que sea 0, simplemente usamos la cadena vacía.

Julia, 84 bytes

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

Pruébalo en línea!

JavaScript (ES6), 83 caracteres, 110 bytes

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

Perl 6 , 102 bytes

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

Pruébalo en línea!

Rubí, 134 bytes

Búsqueda básica por módulo. Probablemente se pueda optimizar en alguna parte, pero Ruby no convertirá las cadenas en enteros de la forma en que Javascript puede hacerlo, jaja

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