Greek Conversion Golf

Pyth, 49 48 46 44 bytes

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

Try it here.

Still working on shortening the function to generate the alphabet... and yes, the generator is longer than hardcoding the alphabet by 4 characters, but not 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

Here's how the alphabet-generating function works. Let's take all the codepoints and subtract 913 (the smallest value):

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

Now let's pull out the ones that don't fit the pattern:

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, so the strategy is forming: generate the range 0 to 24 (we'll deal with the missing 17 later), and then insert 75, 71, and 79 at the correct locations.

How can we insert the outliers? Pyth has an .interleave function that takes ex. [1,2,3] and [4,5,6] and results in [1,4,2,5,3,6]. We're going to have to add some placeholders, though, since obviously the outliers are far apart. Let's represent the placeholder with 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

Right, so the bottom outlier array starts with four Xs. Can we group the outliers to each be preceded by four Xs and see what remains?

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

Now we make another key observation: since 79 comes at the very end, there can be any number of Xs preceding it, and any number of Xs following it as well! This is because interleaving [1,2,3] and [4,5,6,7,8,9] results in [1,4,2,5,3,6,7,8,9]—note that the extra elements in the second array end up at the end, and since they're going to be removed anyway, we can safely allow that.

That means we can normalize this such that every outlier is preceding by four Xs and succeeded by 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]

Great! Now we can simply take the array [75, 71, 79], insert four placeholder values before each element and six after, and then interleave it with the range 0..24.

But wait, what happened to 17? Remember, the top line in all of these examples has been missing 17. We can simply remove the 17 after interleaving; but this leaves another delightfully evil possibility open. You guessed it—the placeholder value we've been referring to as X will be 17. This allows us to remove both the extraneous 17 and all the placeholder values in one fell swoop.

Finally! Here's the code used to implement this:

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

Julia, 138 bytes

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

This is a function that accepts an integer and returns a string.

For each digit in the input in reversed order, we get the character corresponding to that digit from the appropriate string then combine the characters and reverse the result. For any digits that are 0, we simply use the empty string.

JavaScript (ES6), 120 115 bytes

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

Byte count is using UTF-8. It's 88 characters long. Input is a number.

Test

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"));