Introdução

Você deve criar uma função para converter números arábicos em números gregos. A entrada será um número inteiro menor que 1000e maior que0 .

Algoritmo

1. Número dividida em dígitos (por exemplo, 123-> 1, 2,3 )
2. Tome cada dígito, e mudança de caráter encontrados na tabela abaixo, para o símbolo letra ou nome da letra, (por exemplo, 123-> 1, 2, 3-> ΡΚΓou RhoKappaGamma).

Especificações

• Nenhuma conversão interna do sistema numérico
• O resultado deve ser capitalizado como no exemplo.
• A entrada estará na base 10.

Casos de teste

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

Geléia , 42 40 bytes

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

Experimente online! ou verifique todos os casos de teste .

Pitão, 49 48 46 44 bytes

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

Experimente aqui.

Ainda trabalhando para reduzir a função para gerar o alfabeto ... e sim, o gerador é mais do que codificado em 4 caracteres, mas não em 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

Veja como a função de geração de alfabeto funciona. Vamos pegar todos os pontos de código e subtrair 913 (o menor valor):

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

Agora vamos escolher os que não se encaixam no padrão:

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

Ok, então a estratégia está se formando: gere o intervalo de 0 a 24 (trataremos dos 17 que faltam mais tarde) e insira 75, 71 e 79 nos locais corretos.

Como podemos inserir os valores discrepantes? Pyth tem uma .ifunção nterleave que leva ex. [1,2,3]ee [4,5,6]resulta em [1,4,2,5,3,6]. No entanto, teremos que adicionar alguns espaços reservados, já que obviamente os discrepantes estão distantes. Vamos representar o espaço reservado com 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

Certo, então a matriz inferior discrepante começa com quatro Xs. Podemos agrupar os outliers para cada um deles sendo precedido por quatro se Xver o que resta?

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

Agora, fazemos outra observação importante: desde que o 79 chega ao fim , pode haver qualquer número de Xs precedendo-o e qualquer número de Xs seguindo-o também! Isso ocorre porque a intercalação [1,2,3]e [4,5,6,7,8,9]resulta em[1,4,2,5,3,6,7,8,9] note que os elementos extras na segunda matriz terminam no final e, como serão removidos de qualquer maneira, podemos permitir isso com segurança.

Isso significa que podemos normalizar isso de modo que todos os valores extremos sejam precedidos por quatro se Xsucedidos 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]

Ótimo! Agora podemos simplesmente pegar a matriz [75, 71, 79], inserir quatro valores de espaço reservado antes de cada elemento e seis depois e, em seguida, intercalá-la com o intervalo 0..24.

Mas espere, o que aconteceu 17? Lembre-se de que a linha principal de todos esses exemplos está faltando 17. Podemos simplesmente remover os 17 após a intercalação; mas isso deixa em aberto outra possibilidade deliciosamente maligna. Você adivinhou: o valor do espaço reservado ao qual nos referimos Xserá 17. Isso nos permite remover os 17 valores externos e todos os valores do espaço reservado de uma só vez.

Finalmente! Aqui está o código usado para implementar isso:

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

A contagem de bytes está usando UTF-8. Tem 88 caracteres. Entrada é um número.

Teste

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 salvos graças a @Martin Büttner.

Transliterar simples com intervalos de caracteres apropriados e 0exclusão em cada dígito.

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

Experimente online. (Primeira linha adicionada para permitir que todos os casos de teste funcionem juntos.)

Martin também sugeriu este para a mesma pontuação:

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 é uma função que aceita um número inteiro e retorna uma string.

Para cada dígito na entrada na ordem inversa, obtemos o caractere correspondente a esse dígito a partir da sequência apropriada, depois combinamos os caracteres e invertemos o resultado. Para qualquer dígito que seja 0, simplesmente usamos a string vazia.

Julia, 84 bytes

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

Experimente online!

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**$++%*]}}

Experimente online!

Ruby, 134 bytes

Negócio básico de pesquisa usando módulo. Provavelmente pode ser otimizado em algum lugar, mas Ruby não forçará seqüências de caracteres em números inteiros da maneira que o Javascript pode, haha

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