[Question]
  [
The code has a lot of names, but is very simple:
```
  1 2 3 4 5
1 A B C D E
2 F G H I J 
3 L M N O P
4 Q R S T U
5 V W X Y Z
```
A letter is coded by its coordinates, with the row first, then the column. Ex:
```
M = 3, 2
     V
   1 2 3 4 5
 1 A B C D E
 2 F G H I J 
>3 L M N O P
 4 Q R S T U
 5 V W X Y Z
```
Note the letter 'K' is missing, as a letter needs to be removed to make the alphabet fit in the grid. In some versions, the letter 'J' is removed but K is easier to remove because every line stays in order.
More info [here](https://en.wikipedia.org/wiki/Tap_code) on Wikipedia.
Challenge: Make a program that takes in a message encoded in this way, that outputs the decoded message. Input can be in any reasonable format.
```
23 15 31 31 34 52 34 42 31 14
23153131345234423114
etc
```
Are all reasonable input formats.
Standard loopholes apply.
## Test Cases
```
23 15 31 31 34 52 34 42 31 14 => HELLOWORLD
24 25 31 32 => IJLM
11 22 33 44 55 => AGNTZ
```
  
[Answer]
# [Python 2](https://docs.python.org/2/), ~~40~~ 39 bytes
-1 thanks to kops! (Multiply before integer division)
```
lambda a:[chr(r*16/3+c+59)for r,c in a]
```
An unnamed function accepting an iterable of pairs which returns a list of characters.
**[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUSHRKjo5o0ijSMvQTN9YO1nb1FIzLb9IoUgnWSEzTyEx9n9BUWZeiYa6ul5WfmaeRppGdLSRjnGsjkK0oY4piDLWMUShTECUqY4REs8ExjOE6DOJjdXU1PwPAA "Python 2 – Try It Online")**
[Answer]
# [J](http://jsoftware.com/), 22 bytes
```
65(u:@+>&74)@+[:5&#.<:
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/zUw1Sq0ctO3UzE00HbSjrUzVlPVsrP5rcpWkFpfY6imkJmfkO@haRVulKcQbxcbEcnGpe7j6@PiH@wf5uKgrgFQpGCkYKygYKpgqAGlDOGGiABQxgrJMICxDkDoTLnVHd7@QKKhuQ5CoEUTeGKQSrNH0PwA "J – Try It Online")
* `[:5&#.<:` Decrement each input value `<:` and interpret every resulting 2-element pair as a base 5 number `5&#.`.
* `65...@+` Add 65 to each (to make it an ascii value), and...
* `u:@+>&74` Add 1 more to each number greater than 74 `+>&74` to adjust for the missing K. Finally, convert the result to a character `u:@`.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 10 bytes
```
ḅ5<⁴ạƊ+60Ọ
```
[Try it online!](https://tio.run/##y0rNyan8///hjlZTm0eNWx7uWnisS9vM4OHunv///0dHG@kYx@ooRBvqmIIoYx1DFMoERJnqGCHxTGA8Q4g@k9hYAA "Jelly – Try It Online")
A completely different approach.
## Explanation
```
ḅ5<⁴ạƊ+60Ọ   Main monadic link
             All following operations are automatically vectorized.
ḅ5           Convert from base 5
    ạƊ       Absolute difference with
  <⁴           1 if it's less than 16, else 0
      +60    Add 60
         Ọ   Convert to character
```
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 85 bytes
```
,[>++++++++[<------>-],<[>+++++>>[>]+[<]<<-]>+++++++++++>>>>[<<<<+>>>>-]<<<<.>>>>>>,]
```
[Try it online!](https://tio.run/##PYpBCoBACEUPlAbOODvxIoOLCoIIWgSd30yG3t98fX@9l@Pan@10h67ToAsmigYy3qpdLYyJoP3LFKEkyIb21VkTMPdSqVWKcCuVOU7iFw "brainfuck – Try It Online")
## Explanation
```
,  Read a character
[  While not at the end of input
  >++++++++[<------>-]  Subtract 48 to get the actual number
  ,  Read another character
  <[>+++++>>[>]+[<]<<-]  Add 5 times the number to the character and also expand the number into a group of 1s
  >+++++++++++  Add 11 to the character to turn it into a letter
  >>>>  Go to the third item in the group of 1s
  [<<<<+>>>>-]  If it's a 1 then add 1 to the character
  <<<<.  Print the character
  >>>>>>  Skip past the dirty memory cells
  ,  Read a new character
]
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 10 bytes
```
ØAḟ”Ks5⁸œị
```
[Try it online!](https://tio.run/##y0rNyan8///wDMeHO@Y/apjrXWz6qHHH0ckPd3f/f7h7y8Mdmx41rQkDYpfD7UAy8v9/I2MFQ1MFY0MwMlEwNQKRJkYgrqEJl5GJghFE1ojL0FDBCChurGACVGYKAA "Jelly – Try It Online")
-1 byte thanks to Jonathan Allan!
## How it works
```
ØAḟ”Ks5⁸œị - Main link. Takes a list of pairs P on the left
ØA         - Yield the uppercase alphabet
  ḟ”K      - Filter out "K"
     s5    - Split into a 5x5 matrix, S
       ⁸   - Yield P
        œị - For each pair [A, B] in P,
              get the B'th element of the A'th row of S
```
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 78 bytes
```
,[<<-[----->+>-<<]>>+>,<[>+>]<<[<]>>+[>+>]<<[<]>[--->>+<<]>[->+++++<]>--.>>>,]
```
[Try it online!](https://tio.run/##TYpLCoAwDEQP1EbIp7uQi4QuVBBEcCF4/ph25Sxm3gvZnvW8j3e/IqqrgsOIFQPVbrlVPbur@vSfjNe86EQrI4kAi5nVHiFCjE1QGgkyUmoiM2Eufw "brainfuck – Try It Online")
Takes input for each letter as 2 ascii encoded digits.
**Explanation**
Essentially the formula is
`65+[Row ASCII - 49]*5+[Column ASCII -49]+[1 if row >2]` .
The row ASCII value is reduced by 49, but the column ASCII offset is calculated as
```
 65-49 = 16 = 17-2+1 plus an additional 1 if in row 3 onwards.
```
The approach is quite different to the existing brainfuck answer.
```
,[<<             Take an input for row value into cell 0 to get started then move to cell minus 2
-[----->+>-<<]   make cell minus 1 equal 255/5=51 and also subtract this number from input
>>+>,<           add 1 to row value in cell 0 and input column value into cell 1
[>+>]<<[<]       if cell 0 not 0  row input was not 2 so add 1 to column value
>>+              add 1 to row value in cell 0 so now it is 49 minus the input / note ASCII 49 is 1 
[>+>]<<[<]       if cell 0 not 0 row input was not 1 so add 1 to column value
>[--->>+<<]      add 51/3=17 to column value
>[->+++++<]      add 5 times row value to column value
>--.             subtract 2 from column value and output letter
>>>,]            skip 3 dirty cells and take next row input 
```
[Answer]
# [Haskell](https://www.haskell.org/), ~~39~~ 37 bytes
```
map(\(r,c)->[';'..]!!(r*5+c+r`div`3))
```
[Try it online!](https://tio.run/##y0gszk7NyfmfbhvzPzexQCNGo0gnWVPXLlrdWl1PL1ZRUaNIy1Q7WbsoISWzLMFYUxOoKjNPwVahoCgzr0RBRSE9WsNIx1hTR0HDUMcURBnrGKJQJiDKVMcIiWcC4xlC9Jloxv7/l5yWk5he/F83uaAAAA "Haskell – Try It Online")
* saved 2 thanks to @cole
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 42 bytes
```
a=>Buffer(a.map(([y,x])=>+x+y*16/3+59))+''
```
[Try it online!](https://tio.run/##dZBtS8MwEMff91PcCyGJndU@CTpSUXymOlBBcA5WunREuqSmqW6MfvaZrJvzjRBC7u73/9/lPrKvrM4Vr/SBkBO2yqWoNdSybDSXAugqo8lFUxRM4cybZRXGw0VvPiI0cefuYt8/Pgzd@IQQF6GNNs9qVgMFxT4brhhGRY2Ip1g2ueYle16IHB8RT8tnrbiYYuLVVck1Ru/CYLZDyQUDmsDSAegsh1xUje4Bm1cs12wyMvaW2kppgkjf0IrpRokN7hn/2c4eENkZbGqjvtMaYSEV4P86yaL7Efkzj2J1U2ozxHZPeC1bz2AJWTKvlFM83lt2aAt4@wRK6a89nAHKpVImQHAK6FtJMUUtGRurdhWE4McQ@usTQRzYOwps6Ed2Q7dXaTp4HTyll04QQdCxga3c3acPju9DYOgQIiOObfr85vHl7Qc "JavaScript (Node.js) – Try It Online")
Takes an array of strings.
[Answer]
# [convey](http://xn--wxa.land/convey/), 568 bytes
```
{:v
 1v
v#<   0
v^<<<<(<
v9     ^9
v+2v'A'^+2
"=>!}  ^*5v'Z'
v9     "=>!}
v+3v'B'^9
"=>!}  ^*6v'Y'
v9     "=>!}
v+4v'C'^9
"=>!}  ^*6
v9     ^-1v'X'
v+5v'D'"=>!}
"=>!}  ^9
v9     ^+4
v+6v'E'^*4v'W'
"=>!}  "=>!}
v7     ^9
v*3v'F'^+8
"=>!}  ^*3v'V'
v9     "=>!}
v+2    ^9
v*2v'G'^*5v'U'
"=>!}  "=>!}
v9     ^9
v+9    ^+2
v+5v'H'^*4v'T'
"=>!}  "=>!}
v6     ^9
v*4v'I'^*4
"=>!}  ^+7v'S'
v5     "=>!}
v*5v'J'^7
"=>!}  ^*6v'R'
v9     "=>!}
v*3    ^9
v+4v'L'^*4
"=>!}  ^+5v'Q'
v8     "=>!}
v*4v'M'^5
"=>!}  ^*7v'P'
v9     "=>!}
v+2    ^9
v*3v'N'^+8
"=>!}  ^*2v'O'
>>>>>>>"=>!}
```
And here's a picture of the factory (the gif thing kept crashing):
[![Factory](https://i.stack.imgur.com/HfwNk.png)](https://i.stack.imgur.com/HfwNk.png)
The basic idea is that there is a massive loop which lets one value through at a time. It goes through every letter. Note: Some things which appear to be golfable aren't due to interpreter glitches.
[Try it online!](https://xn--wxa.land/convey/run.html#eyJjIjoiezp2XG4gMXZcbnYjPCAgIDBcbnZePDw8PCg8XG52OSAgICAgXjlcbnYrMnYnQSdeKzJcblwiPT4hfSAgXio1didaJ1xudjkgICAgIFwiPT4hfVxudiszdidCJ145XG5cIj0+IX0gIF4qNnYnWSdcbnY5ICAgICBcIj0+IX1cbnYrNHYnQydeOVxuXCI9PiF9ICBeKjZcbnY5ICAgICBeLTF2J1gnXG52KzV2J0QnXCI9PiF9XG5cIj0+IX0gIF45XG52OSAgICAgXis0XG52KzZ2J0UnXio0didXJ1xuXCI9PiF9ICBcIj0+IX1cbnY3ICAgICBeOVxudiozdidGJ14rOFxuXCI9PiF9ICBeKjN2J1YnXG52OSAgICAgXCI9PiF9XG52KzIgICAgXjlcbnYqMnYnRydeKjV2J1UnXG5cIj0+IX0gIFwiPT4hfVxudjkgICAgIF45XG52KzkgICAgXisyXG52KzV2J0gnXio0didUJ1xuXCI9PiF9ICBcIj0+IX1cbnY2ICAgICBeOVxudio0didJJ14qNFxuXCI9PiF9ICBeKzd2J1MnXG52NSAgICAgXCI9PiF9XG52KjV2J0onXjdcblwiPT4hfSAgXio2didSJ1xudjkgICAgIFwiPT4hfVxudiozICAgIF45XG52KzR2J0wnXio0XG5cIj0+IX0gIF4rNXYnUSdcbnY4ICAgICBcIj0+IX1cbnYqNHYnTSdeNVxuXCI9PiF9ICBeKjd2J1AnXG52OSAgICAgXCI9PiF9XG52KzIgICAgXjlcbnYqM3YnTideKzhcblwiPT4hfSAgXioydidPJ1xuPj4+Pj4+PlwiPT4hfSIsInYiOjEsImkiOiIyMyAxNSAzMSAzMSAzNCA1MiAzNCA0MiAzMSAxNCJ9)
I can't believe Brainfuck is beating this :( - Convey has terrible string handling, so this is the only answer where it implicitly checks every single letter...
[Answer]
# [Scala](http://www.scala-lang.org/), ~~37~~ 36 bytes
Saved 1 byte thanks to @xigoi, who suggested applying @kops's suggestion to Jonathan Allan's answer.
```
_.map{case(r,c)=>r*16/3+c+59 toChar}
```
[Try it online!](https://tio.run/##NU3BSsQwFLz3K4aeErdbTZrKutAF8SToyaPIErNpjXbT0AQRSr@9JnaFxzAzzJvxSvZyGd4/tQp4lsZC/wRtTx73zmHKgG/Zo93jyfjwSh5tKBCBvqE5rN7DhxyjWo7lWbpJSa/JWCjaHMYrdntdbdSmvkMYUmxegNh40i064vd4CaOxHUUDF0noLWmJL73rTSA5clqGIU2kYkwwaZIYckOxhdgVMIStlGKm5fnrUpfFiY7kvAKrUbG/E6h5QsGTZCKnl5AAX0P832IMPKYqiPhURzebl18 "Scala – Try It Online")
Now simply a port of [Jonathan Allan's Python answer](https://codegolf.stackexchange.com/a/222464/95792), which you should upvote!
Outputs a list of characters.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~13~~ 12 bytes
```
<ε5β}Au'Kмsè
```
[Try it online!](https://tio.run/##yy9OTMpM/f/f5txW03Obah1L1b0v7Ck@vOL//@hoIx0F41gdhWhDHQVTEG2so2CIRpuAaFMdBSNkvgmCbwjVbxIbCwA "05AB1E – Try It Online")
-1 byte thanks to [Makonede](https://codegolf.stackexchange.com/users/94066/makonede). Outputs as a list of characters
## How it works
```
<ε5β}Au'Kмsè - Program. Takes an input of a list of pairs P
<            - Decrement to use 0-indexing
 ε  }        - Over each pair [A, B]:
  5β         -   Convert from base 5, yielding 5A+B
     Au      - Push the uppercase alphabet
       'K    - Push "K"
         м   - Remove "K" from the alphabet
          sè - Index into this modified alphabet
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 14 bytes
```
⭆⪪⭆Ｓ⊖ι²§⁻αK⍘ι⁵
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRCO4BEil@yYWaAQX5GQi8z3zCkpLIFwNTR0Fl9TkotTc1LyS1BSNTE2ggBEQO5Z45qWkVmj4ZuaVFmsk6igoeSsBhZ0Si1OhOjN1FEw1gcD6/38jY0NTY0MgNDE1MjYxAXINTf7rluUAAA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
   Ｓ            Input string
  ⭆             Map over characters and join
     ι          Current character
    ⊖           Decremented
 ⪪    ²         Split into pairs of digits
⭆               Map over pairs and join
            ι   Current pair
           ⍘ ⁵  Convert from base 5
       §        Index into
         α      Predefined variable uppercase alphabet
        ⁻       Minus
          K     Literal string `K`
                Implicitly print
```
[Answer]
# [K (ngn/k)](https://bitbucket.org/ngn/k), 20 bytes
```
`c${x+74<x}65+5/'-1+
```
[Try it online!](https://tio.run/##y9bNS8/7/z/NKiFZpbpC29zEpqLWzFTbVF9d11D7f4mVhpGCsYKhgimYhGATIM8ITJsoQGQNFUysgUwQF6bQyBosbgRWAVFrqmCqyZVuZeCnYKTMVZ2mkK5QUate8h8A "K (ngn/k) – Try It Online")
Uses [@Jonah](https://codegolf.stackexchange.com/a/222469/75681)'s method - don't forget to upvote him!
[Answer]
# [Jelly (fork)](https://github.com/cairdcoinheringaahing/jellylanguage), 10 bytes
```
’ḅ5ịØȦḟ”K¤
```
[Try it online!](https://tio.run/##y0rNyan8//9Rw8yHO1pNH@7uPjzjxLKHO@Y/apjrfWjJ////o6ONdBSMY3UUog11FExBtLGOgiEabQKiTXUUjJD5Jgi@IVS/SWwsAA "Jelly – Try It Online") (or rather, don't)
## How it works
```
’ḅ5ịØȦḟ”K¤ - Main link. Takes a list of pairs P on the left
’          - Decrement each integer to use 0-indexing
 ḅ5        - For each pair [A, B], yield 5A+B (convert from base 5)
         ¤ - Group the previous links into a nilad:
    ØȦ     -   Shifted alphabet; Yield "BCDE...XYZA"
      ḟ”K  -   Filter out "K"
   ị       - Index into this modified alphabet
```
[Answer]
# Excel, 42 bytes
```
=CONCAT(REPT(CHAR(A:A*16/3+B:B+59),A:A>0))
```
Another port of [Johnathan Allan's Python Answer](https://codegolf.stackexchange.com/a/222464)
Input is 2 columns of cells.
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 10 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
▄πKñ╜╓♥F⌂F
```
[Run and debug it](https://staxlang.xyz/#p=dce34ba4bdd603467f46&i=%5B%5B3,+2%5D,+%5B5,+1%5D,+%5B1,+3%5D,+%5B1,+3%5D,+%5B4,+3%5D,+%5B2,+5%5D,+%5B4,+3%5D,+%5B2,+4%5D,+%5B1,+3%5D,+%5B4,+1%5D%5D%0A%0A%5B%5B4,+2%5D,+%5B5,+2%5D,+%5B1,+3%5D,+%5B2,+3%5D%5D%0A%0A%5B%5B1,+1%5D,+%5B2,+2%5D,+%5B3,+3%5D,+%5B4,+4%5D,+%5B5,+5%5D%5D&m=1)
takes inputs as `[column, row]`. Based on Jonathan Allan's answer.
[Answer]
# [Befunge-93](https://github.com/catseye/Befunge-93), 31 bytes
```
~:1+!#@_"0"-:2`\5*+~"0"-+";"+,~
```
[Try it online!](https://tio.run/##S0pNK81LT/3/v87KUFtR2SFeyUBJ18ooIcZUS7sOxNZWslbS1qn7/9/QSMHYCAA "Befunge-93 – Try It Online")
### Explanation
```
~             Get a char
:1+!#@_       If at the end of the string, stop the execution (see if the char is -1)
"0"-          Get the row number
:2`\          If greater than 2, push a 1, otherwise a zero, swap the top two in the stack
5*+           Multiply by 5 and sum the 0/1
~"0"-+        Get the col number and sum everything
";"+,         Sum 59 to get the ASCII value of the char
~             Remove the space
```
[Answer]
# [R](https://www.r-project.org/), 37 bytes
```
function(a)intToUtf8(a$x*16/3+a$y+59)
```
[Try it online!](https://tio.run/##K/qfZvs/rTQvuSQzP08jUTMzryQkP7QkzUIjUaVCy9BM31g7UaVS29RS83@aRkpiSaJeWlFibqpGhW2yhpGOkY6xjrGmjkIlkGeiY6pjqGOkqanJhUWlIUglEJoCsQkQG0J1GYN1GQLFjMAYyAKa8B8A "R – Try It Online")
Port of [Jonathan Allan's Python answer](https://codegolf.stackexchange.com/a/222464/95792).
Takes input as a data frame with first digit in first column and second digit in second column.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 34 bytes (31 bytes with Ruby 2.7)
```
->x{x.map{|i,j|(i*16/3+j+59).chr}}
```
A direct port of Johnathan Allan's Python answer.
This lambda accepts an array of pairs and returns an array of characters.
[Try it online!](https://tio.run/##XY5LCsIwAET3OcUsWxsjaRLBhV4kZlH7oSmooVqoND17bERQuhge82Bg@uHyCs3xHLancRrZtXCTt7Tzid3w/U5kXaYOKSvbfp6DQ6O1zimEodCcQkUKCr6ijFQU@X@Xv86/e2mMIQlnTKWsLsoW1R3eegKsZRcl4Ibn43NiuRi3QH2ryJLwBg "Ruby – Try It Online")
`->x{x.map{(_1*16/3+_2+59).chr}}` is written in 31 bytes and also works fine, but it requires Ruby 2.7 (not yet supported by TIO).
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell) 5+, 47 bytes
Tribute to [Metal gear 2: Solid Snake](https://metalgear.fandom.com/wiki/Tap_code#)
```
-join($args|%{(';'..'_'-ne'K')[5*$_[0]+$_[1]]})
```
[Try it online!](https://tio.run/##bY9dT4MwFIbv@yt60VmqZZGvK7MEo8YvJmYzMRkhhEE3tyBMGJmR8duxQHFM7QWH9jzvc9pNsmNp9saiqEKLUVHJ62QVS8hPl9l@UEj4Ag@H2MNyzPAjJo5xijzn3D3jX8V1S1KVAJgSAFTCdzeWZb/aE@saUyipFGqEV4VCo64ahcqvqtfVoFDt7/XDXhF5nZDaf/9gjYW5IdW/ZrUlL2@fXma4DSsC7aSaGNINN9rIzI@/VnM/tfw4xE3HID1BFxTHKtXbrtqH/rn6UVg8BRC4hwNYAMgXYp8bFmxZSPlvHCQhC8csy/wlgyOIvJZJWZZHW35wghbQPMYawnmeXuXZNnm352tuc81WXq9pHgScrG1CI7OPw9gfbtLNEFjTKEFZVd8 "PowerShell – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, 34 bytes
```
s/(.)(.)/(A..J,L..Z)[5*$1-6+$2]/ge
```
[Try it online!](https://tio.run/##K0gtyjH9/79YX0NPE4j0NRz19Lx0fPT0ojSjTbVUDHXNtFWMYvXTU///NzI2NDU2BEITUyNjExMg19DkX35BSWZ@XvF/XV9TPQNDg/@6BQA "Perl 5 – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 75 bytes
```
main(int a,char**b){for(b++;**b;++*b)putchar(16+(a=**b-49)*5+(a>1)+*++*b);}
```
[Try it online!](https://tio.run/##HYpBDkAwEEWvYtl2WEw7lUjDXaoJulAirMTZx5C/eu/91MwpMa8xF5XLWcU6LfEwZtT3tB1qBAgCAUDMfp1fVNiCir3ohjptvMCAGsz/CQ8zW4feoYy8dUSCSC8 "C (gcc) – Try It Online")
In the end, this is pretty straightforward and just uses C's willingness to be fluid about treating characters as integers. It runs through the characters in the first commandline argument, then uses a golfed version of this logic to map each one to the desired character.
```
'A' + (char1-'1')*5 + (char1-'1'>1) + (char2-'1')
```
The only trickery here is using the using the storage provided by the arguments to the `main()` call to avoid having to declare local variables. And the operator precedence in C means this jumble of punctuation,
```
+*++*b
```
does a number of things with just a few characters. That fragment, increments the pointer to the "current character" `*b`, then dereferences that location as a single character, implicitly converts it to an integer and adds it to the rest of the expression. The fact that `+*++*`, which looks more like Morse Code than C code, does something useful is pretty much why I decided to post this entry. :)
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), ~~33~~ 15 bytes
Saved 18 bytes thanks to Razetime! (they also pointed out the answer was invalid)
```
⌷∘(5 5⍴⎕A~'K')¨
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P@1R24RHPdsfdczQMFUwfdS75VHfVMc6dW91zUMr/qcDJdM0NB71dB0GqTA00NQxNKh51LUILKlgZKxgaKpgbAhGJgqmRiDSxAjENTThAsqbKBhB5I2APENDBSOgnLGCCVCpKQA "APL (Dyalog Unicode) – Try It Online")
Takes a vector of pairs of numbers.
```
⌷∘(5 5⍴⎕A~'K')¨
               ¨ ⍝ For each pair in the input
⌷                ⍝ Index into:
       ⎕A        ⍝ Capital letters
          ~'K'   ⍝ Without 'K'
   5 5⍴          ⍝ Reshaped into a 5x5 matrix
```
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 37 bytes
```
T` d`__9\EKPU` |\b\d
+T`dL`__1-7L`.\d
```
[Try it online!](https://tio.run/##K0otycxL/P8/JEEhJSE@3jLG1TsgNEGhJiYpJoVLOyQhxQcoaqhr7pOgF5Py/7@RsYKhqYKxIRiZKJgagUgTIxDX0ITLyETBCCJrxGVoqGAEFDdWMAEqMwUA "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation:
```
T` d`__9\EKPU` |\b\d
```
This does two things; it deletes all the spaces, and it replaces the first of each pair of digits with the characters `9EKPU` respectively, these being the characters in the translation string below that precede the letters from the first column of the code.
```
+T`dL`__1-7L`.\d
```
Repeatedly decrement the remaining digits and increment the preceding letter until the digits become zero, at which point they are deleted. Note that on the first pass the "letter" might actually be a `9`, but this works because on the first pass of this loop all the "letters" will be paired with a digit.
[Answer]
# [R](https://www.r-project.org/), 62 bytes
```
function(x)for(i in x)cat(letters[(y=(i-1)%*%c(5,1)+1)+(y>9)])
```
[Try it online!](https://tio.run/##TY5BCoMwEEX3PYUb4U@bLqLJogt7EemijBECkkAcQU@fGqUgDPN48Gf4KQ@O4@C6PC6BxceAlcaY4CsfqpX4K5iciEtzj62Df2qq7zXDKk2PfbC9X/ShfDyZ/CxgNKolxdDKFrR78gpTYFVzMfM3fd4ZotvZC2VR/gE "R – Try It Online")
Aaargh! I clicked submit and then saw [pajonk's much shorter answer](https://codegolf.stackexchange.com/a/222505/95126) waiting for me! Upvote that one (and [Jonathan Allan's one](https://codegolf.stackexchange.com/a/222464/95126) that it's based-on)!
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 22 bytes
```
~]2/{~\16*3/+59+}/]''+
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPn/vy7WSL@6LsbQTMtYX9vUUrtWP1ZdXfv/fyMFYwUFQwVTBSBtCCdMFIAiRlCWCYRlCFJnAgA "GolfScript – Try It Online")
Another port of @Jonathan Allen’s answer, and my first time trying out GolfScript. Input is just a series of numbers, separated by spaces, but you can separate number pairs with extra spaces for readability.
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 60 bytes
```
($a|%{[char][int][math]::floor($_[0]*16/3+$_[1]+59)})-join''
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfmvkmjroKFhpGOsqaOgYahjCqKMdQxRKBMQZapjhMQzgfEMIfpMNDX/a6gk1qhWRydnJBbFRmfmlcRG5yaWZMRaWaXl5OcXaajERxvEahma6RtrA5mGsdqmlpq1mrpZ@Zl56ur//wMA "PowerShell – Try It Online")
Thanks to @JonathanAllan
]