[Question]
  [
Given a string that contains only lowercase letters, encode that string with the alphabet cipher.
To encode with the alphabet cipher (I will be using the example `hello`):
1. First, convert each letter in the string to a number depending on its position in the alphabet (`a` = `1`, `b` = `2`, etc.) Example: `8` `5` `12` `12` `15`
2. Pad each number to two characters with `0`s. Example: `08` `05` `12` `12` `15`
3. Join. Example: `0805121215`
## Test cases
```
helloworld -> 08051212152315181204
codegolf -> 0315040507151206
alphabetcipher -> 0112160801020520030916080518
johncena -> 1015081403051401
```
Remember, this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the code with the fewest number of bytes wins.
  
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), ~~11~~ 6 bytes
**Code:**
```
Ç4+€¦J
```
**Explanation:**
First, we convert the string to their ASCII values. `codegolf` would become:
```
[99, 111, 100, 101, 103, 111, 108, 102]
```
To get to the indices of the alphabet, you subtract `96`:
```
[3, 15, 4, 5, 7, 15, 12, 6]
```
To pad with zeros, add `100` to each element and remove the first character of each int. For the above example, `+100` would be:
```
[103, 115, 104, 105, 107, 115, 112, 106]
```
And removing the first character of each would lead to:
```
[03, 15, 04, 05, 07, 15, 12, 06] 
```
We can merge both steps above (the `-96` and the `+100`) part to just `+4`. For the code:
```
Ç       # Convert to an array of ASCII code points
 4+     # Add four to each element in the array
   €¦   # Remove the first character of each element
     J  # Join to a single string
```
[Try it online!](http://05ab1e.tryitonline.net/#code=w4c0K-KCrMKmSg&input=Y29kZWdvbGY)
[Answer]
# Python 2, 42 bytes
```
f=lambda s:s and`ord(s[0])+4`[1:]+f(s[1:])
```
Test it on [Ideone](http://ideone.com/p7RFlo).
[Answer]
# C, ~~55~~ 43 bytes
```
f(char*c){for(;*c;)printf("%02d",*c++-96);}
```
[ideone](http://ideone.com/SZPzoT)
[Answer]
# Pyth, ~~11~~ 10 bytes
```
FNwpt`+4CN
```
[Try it!](https://pyth.herokuapp.com/?code=%23FNwpt%60%2B4CN%29%22&input=helloworld%0Acodegolf%0Aalphabetcipher%0Ajohncena&debug=0) My first go at Pyth.
```
FNwpt`+4CN
FNw         # For N in w (w is input, N will be single char)
   p        # Print without newline
        CN  # Int with code point `N`
      +4CN  # Add 4 to int with code point N
     `+4CN  # representation of above (basically to string)
    t`+4CN  # Tail (All but first character)
```
Python equivalent:
```
for N in input():
    print(repr(ord(N) + 4)[1:], end='')
```
[Answer]
# Python, 46 bytes
```
lambda x:"".join("%02i"%(ord(j)-96)for j in x)
```
Pretty straightforward. [**Try it on repl.it!**](https://repl.it/EIwU/0)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~9~~ 7 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
O+4ṾḊ$€
```
**[TryItOnline](http://jelly.tryitonline.net/#code=Tys04bm-4biKJOKCrA&input=&args=aGVsbG8)**
### How?
```
O+4ṾḊ$€ - Main link: s                                e.g. hello
O       - cast to ordinals                            e.g. [ 104,  101,  108,  108,  111]
 +4     - add 4                                       e.g. [  108,  109,  112,  112,  115]
     $€ - last two links as a monad for €ach
   Ṿ    -    uneval, effectively converts to strings  e.g. ["108","109","112","112","115"]
    Ḋ   -    dequeue, remove the leading '1'          e.g. [ "08", "09", "12", "12", "15"]
        - implicit print                              e.g. "0809121215"
```
[Answer]
# Haskell, ~~fortyfour 30~~ 28 bytes
```
(>>=tail.show.(+4).fromEnum)
```
Using the `+4` approach from [Adnan's answer](https://codegolf.stackexchange.com/a/97864/56433) saves 14 bytes.
[Try it on Ideone.](http://ideone.com/RzY4ET) Usage:
```
> (>>=tail.show.(+4).fromEnum)"codegolf"
"0315040507151206"
```
Two bytes off thanks to [xnor](https://codegolf.stackexchange.com/users/20260/xnor). Old version:
```
f a=['0'|a<'k']++(show$fromEnum a-96)
(f=<<)
```
[Answer]
## Perl, 29 bytes
28 bytes of code + `-n` flag.
```
printf"%02s",-96+ord for/./g
```
Run with :
```
perl -ne 'printf"%02s",-96+ord for/./g' <<< "helloworld"
```
[Answer]
# JavaScript (ES6), ~~52~~ 49 bytes
```
f=s=>s&&(s.charCodeAt()+4+f(s.slice(1))).slice(1)
```
Recursion turned out to be 3 bytes shorter than `.replace`:
```
s=>s.replace(/./g,s=>(s.charCodeAt()+4+"").slice(1))
```
`parseInt(s,36)` is slightly longer for each approach, because you have to change `4` to `91`:
```
s=>s.replace(/./g,s=>(parseInt(s,36)+91+"").slice(1))
f=s=>s&&(parseInt(s[0],36)+91+f(s.slice(1))).slice(1)
```
[Answer]
# Japt, 10 bytes
```
¡4+Xc)s s1
```
Probably doesn't get shorter than this...
[**Test it online!**](http://ethproductions.github.io/japt/?v=master&code=oTQrWGMpcyBzMQ==&input=ImhlbGxvd29ybGQi)
## Explanation
```
¡           // Map each char X in the input by this function:
 4+Xc)      //   Take 4 + the char code of X.
      s s1  //   Convert to a string, then remove the first char.
            // Implicit: output last expression
```
[Answer]
# Java 7,60 bytes
```
void f(char[]s){for(int i:s)System.out.printf("%02d",i-96);} 
```
[Answer]
# MATL, ~~12~~ 11 bytes
*1 byte saved thanks to @Luis*
```
4+!V4LZ)!le
```
[**Try it Online**](http://matl.tryitonline.net/#code=NCshVjRMWikhbGU&input=J2hlbGxvd29ybGQn)
[Answer]
# [Hexagony](https://github.com/m-ender/hexagony), 33 bytes
```
10}{'a({=!{{\.@29$\,<.-":!\>Oct\%
```
[Try it Online!](http://hexagony.tryitonline.net/#code=MTB9eydhKHs9IXt7XC5AMjkkXCw8Li0iOiFcPk9jdFwl&input=aGVsbG93b3JsZA)
Mm.. got a few no-ops in the Hexagon so I put today's date in.
## Expanded Form with date replaced by no-ops
```
   1 0 } {
  ' a ( { =
 ! { { \ . @
. . $ \ , < .
 - " : ! \ >
  . . . \ %
   . . . .
```
1. Initialise a `10` and move Memory Pointer to somewhere...
2. `$` skips the mirror and `,` reads a byte. `<` branches:
3. If end of string (`-1` which is non-positive) it goes to `@` and terminates the program.
4. Otherwise it subtracts `95` (decremented `a`), and then we print `result / 10` (integer division) and `result % 10` and loop again.
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 5 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
öÇIªÆ
```
[Run and debug it](https://staxlang.xyz/#p=948049a692&i=%22helloworld%22%0A%22codegolf%22%0A%22alphabetcipher%22%0A%22johncena%22&a=1&m=2)
For each character
* add 4 to the codepoint e.g. `108`
* convert to string e.g. `"108"`
* drop the first character e.g. `"08"`
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), ~~19~~ 12 bytes [SBCS](https://en.wikipedia.org/wiki/SBCS)
```
        ⎕UCS  ⍝ Convert the argument (string) into an array of codepoints.
      4+      ⍝ and add 4 to each of those codepoints.
     ¨        ⍝ Now, for each of those numbers
    ⍕         ⍝ turn it into a string
   ∘          ⍝ and
 1↓           ⍝ drop its first character.
∊             ⍝ Finally enlist the strings into a single string (as in, join them together)
```
Thanks @Bubbler for saving 7 bytes
## my original 19 bytes
```
{,/{1↓⍕⍵}¨4+⎕UCS ⍵}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///v1pHv9rwUdvkR71TH/VurT20wkT7Ud/UUOdgBRD3f2pecn5K6qO2CY96@x51NT/qXfOod8uh9caP2iYClQUHOQPJEA/PYKhCBfXEpOSU1LT0jMys7JzcvPyCwqLiktKy8orKKnUA "APL (Dyalog Unicode) – Try It Online")
```
{                   } ⍝ Define a function taking a string as argument.
             ⎕UCS ⍵  ⍝ Convert the argument (string) into an array of codepoints.
           4+         ⍝ and add 4 to each of those codepoints.
   {     }¨           ⍝ For each number in the array,
      ⍕⍵             ⍝ convert it to a string
    1↓                ⍝ and drop the first character (the 1).
 ,/                   ⍝ Finally join everything and return.
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `s`, 6 bytes
```
C4+ƛSḢ
```
*-1 byte thanks to [@Steffan](https://codegolf.stackexchange.com/users/92689/steffan)*
[Try it Online!](https://vyxal.pythonanywhere.com/#WyJzIiwiIiwiQzQrxptT4biiIiwiIiwiaGVsbG93b3JsZCJd)
Explanation:
```
C       # Convert to ASCII codes
 4+     # Add 4
   ƛ    # On each number:
    S   #   Stringify
     Ḣ  #   Remove first char
```
[Answer]
# Vim, 60 keystrokes
```
:s/./\=char2nr(submatch(0))-96."\r"/g
:%s/\<\d\n/0&
V{gJ
```
An *almost* entirely regex based solution. As usual, using the eval register makes it obscenely long.
[Answer]
# PHP, 58 Bytes
```
foreach(str_split($argv[1])as$c)printf("%02d",ord($c)%32);
```
[Answer]
## PowerShell v2+, 44 bytes
```
-join([char[]]$args[0]|%{"{0:D2}"-f($_%32)})
```
Takes input `$args[0]`, casts it as a `char`-array, feeds into a loop. Each iteration, we take the current character `$_` modulo `32`, which implicitly casts as the ASCII value. Conveniently ;-), this lines up so `a = 1, b = 2`, etc. That fed into the `-f`ormat operator, operating on string `"{0:D2}"`, which specifies a two digit minimum (i.e., it prepends a leading zero if required). Those strings of digits are encapsulated in parens, `-join`ed together into one string, and left on the pipeline. Output via implicit `Write-Output` happens at program conclusion.
```
PS C:\Tools\Scripts\golfing> .\encode-alphabet-cipher.ps1 'hello'
0805121215
PS C:\Tools\Scripts\golfing> .\encode-alphabet-cipher.ps1 'helloworld'
08051212152315181204
PS C:\Tools\Scripts\golfing> .\encode-alphabet-cipher.ps1 'codegolf'
0315040507151206
PS C:\Tools\Scripts\golfing> .\encode-alphabet-cipher.ps1 'johncena'
1015081403051401
```
[Answer]
# Perl, 24 bytes
Includes +1 for `-p`
Give input on STDIN:
```
encode.pl <<< hello
```
`encode.pl`
```
#!/usr/bin/perl -p
s/./substr 4+ord$&,1/eg
```
[Answer]
# [DASH](https://github.com/molarmanful/DASH), 27 bytes
```
@><""(->@rstr["."""]+4#0)#0
```
Example usage:
```
(@><""(->@rstr["."""]+4#0)#0)"helloworld"
```
# Explanation
```
@ (                         #. take input through a lambda
  join "" (                 #. join with newlines the following:
    (map                    #. result of mapping
      @ (                   #. this lambda
        rstr ["." ; ""] (     #. replace first char w/ empty string:
          + 4 #0               #. mapped item's codepoint + 4
        )
      )
    ) #0                    #. over the argument
  )
)
```
[Answer]
## Batch, ~~256~~ ~~239~~ 237 bytes
```
@echo off
set/ps=
set r=
set a=abcdefghijklmnopqrstuvwxyz
:g
set c=%a%
for /l %%i in (101,1,126)do call:l %%i
set s=%s:~1%
if not "%s%"=="" goto g
echo %r%
exit/b
:l
set i=%1
if %c:~,1%==%s:~,1% set r=%r%%i:~1%
set c=%c:~1%
```
Takes input on STDIN.
[Answer]
# IBM PC DOS 8088 Assembly, ~~33~~ ~~28~~ 27 bytes
Assembled binary:
```
00000000: be82 00ac 2c60 7812 d40a 0530 3092 86f2  ....,`x....00...
00000010: b402 cd21 86f2 cd21 ebe9 c3              ...!...!...
```
Unassembled:
```
BE 0082     MOV  SI, 82H        ; point SI to command line string 
        CH_LOOP: 
AC          LODSB               ; load next char into AL
2C 60       SUB  AL, 'a'-1      ; convert ASCII to a=1,b=2...z=26 
78 12       JS   DONE           ; if char is terminator or not valid, exit
D4 0A       AAM                 ; convert binary to BCD 
05 3030     ADD  AX, '00'       ; convert BCD to ASCII 
92          XCHG DX, AX         ; save AX to DX for display 
86 F2       XCHG DH, DL         ; reverse bytes 
B4 02       MOV  AH, 2          ; DOS display char function 
CD 21       INT  21H            ; write first digit 
86 F2       XCHG DH, DL         ; reverse bytes back 
CD 21       INT  21H            ; write second digit 
EB E9       JMP  CH_LOOP        ; restart loop 
        DONE: 
C3          RET                 ; return to DOS
```
Standalone PC DOS executable. Input string from command line, output to console.
I/O:
[![enter image description here](https://i.stack.imgur.com/wi57R.png)](https://i.stack.imgur.com/wi57R.png)
[Answer]
# [BQN](https://mlochbaum.github.io/BQN/), 16 bytes
```
∾·(1↓•Fmt)¨4+-⟜@
```
[Try it at BQN online!](https://mlochbaum.github.io/BQN/try.html#code=RiDihpAg4oi+wrcoMeKGk+KAokZtdCnCqDQrLeKfnEAKCkYgImFoZWxsbyI=)
### Explanation
Same approach, independently derived, as [RGS's APL answer](https://codegolf.stackexchange.com/a/201756/16766) and [tybocopperkettle's Vyxal `s` answer](https://codegolf.stackexchange.com/a/250415/16766).
```
∾·(1↓•Fmt)¨4+-⟜@
             -⟜@  Subtract null byte from each character, giving its ASCII value
           4+      Add 4 (a = 101, z = 126)
  (      )¨        Map this function to each number:
     •Fmt            Format as string
   1↓                Drop first character
∾·                Join together into a single string
```
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), 8 bytes
```
,/1_'$4+
```
[Try it online!](https://ngn.codeberg.page/k#eJwdjMEKAjEMRO/7GUXwoOAk26zVn5Haba0StssiePPbTSUwEObNK9fjiW77nT8Mg0OAENsJjyQUiOHdt7iaVdunbTo7g6yCh+BsCGPqQGpzfjQtvSbbT2YiMISBEZf/b76ORl1rvOd3eq41bzYgmC+QN1AsqUOvVpeUl+h++NUoXQ==)
`4+` add 4 to (the ASCII codes of) the argument - this turns `a` into 101, `b` into 102, etc
`$` format numbers as strings
`1_'` drop one digit from each
`,/` concatenate
[Answer]
# [J](http://jsoftware.com/), 25 22 15 bytes
```
[:,4}.@":@+3&u:
```
[Try it online!](https://tio.run/##dcq9CsIwFAXgvU9xzeC1tA03aVLbC0JRcBIHVxGH/lgkEBDEQXz2GBRHOZzlnO8amhmrUzXjBjEREkdYMSDkQMCxhYTNYbcNR87NS7aC26yc3zmkyX4tIa5nvXhKwanIzOdJhm7yMAJOg3P@4W@ux@@GVJNVOsbqUllVK00GoeA/OhoyZGkZrabqJzvfDxfvRgxv "J – Try It Online")
*-7 bytes thanks to [ngn's K approach](https://codegolf.stackexchange.com/a/250555/15469)*
[Answer]
# [Knight](https://github.com/knight-lang/knight-lang), ~~45~~ 41 bytes
*-4 thanks Aiden*
```
;=xP W<1Lx;O++*'0'-2L=a-Ax 96a'\'=xSxF1""
```
[Try it online!](https://tio.run/##rVltV9vKEf5s/4rFOVhaWU5kQXtubWQOyYUcTgnkQtJ8ADcIWcY6V5ZdSealhP71dGb2RSvbpE17@WBZu8/Mzjw7OzNrou5tFH1/lWRRuhzHe0U5Tuavp8OmOZImN7WhqHxcxCugPMlua0NlMhOYcTxJspilKUvn2S19NPXop9PPH1iver34dM786vVvB@dst3o9On3Hfqlezz@zXgU@OrkwsKefTwzo59MPBxd/tQvObPxos3/1/sT17MEFLCsmo2mYM4dXAiYKbNUqhkO2W82dHn7ByQwmyaNvDL/v7a1gcBnCoJuASVOOwBrm7dnZCYHwY5@c7KNvhiHn7wUA5A1b78J0GXN@mY14s0l@wK5cjoLz1uHZkf19EDx8ZF/2eicPg7NOx7E8q@ufBGH34IH95c@hdWUFDxcPR71W6zsHfGsgVDigIw5nLEBlg2YTVlyEeRHbnD01G0lWsmTQbMAore4yZ7LMIhgh4Qjey9nCLRbZpT8KnjzXewYdjQTUER6eHg68eYPqkwW7nyZlXCzCKG424Hsa2zAO4rYww2Wtq/Iqu5pc5ezp@XJk8/6rFidTGsmE2dragFmvLM6ECjW6BaNXGQx3OmIE7GzEaRGbA8/CnGgaR7@zyTxn2XJ2E@eFtIfZSTFObpNSaYXV0Z2eqz0ST4f1PNZhjrS80@Gsy4B0WAItTTjL43KZZ0zFixCjkBms2nAX5kl4k8bKCjAind/HuR3BesoQ9u0bU8ZF9BYREV8tLulJNrieBD0X9ijQwyvW4QmUkQqQbLxc2LilTHLaZfC2brDIB4XQJsy4sqzKppYlNg2EwQNtFAMlkD/gO1i2CIuSldMYlIV5CWC5AY5iFDc04uiJMtY4Vi8aC589ThvdqMgg8zF0y2SegdkYsd4ITIsUI8VysUDCuYoqNWLSb8Yf0G6QjTpUKC8yiGPIZRi50nLByidLH3gxcIQDmNf6mM/QTBVklAqFqzbajaaGaTqP7F3P7XF0EIe1E@RgtkzTMH80Ha3259zYno@WtowWlPLLbEWalujhEjIpbPL04PDtu@vftk5@PTMcNtXeJBv1@ut6t2qK3x9fvKCxjHNSGWZj9o9lqF5R7Z25xM76EoKA95bm4ngDFyS8WxeuY54pVebLDHdoIPOxU84LW@VKOgAQ2mUSMZq9WU4u/d2RtENsdJvSgzagWMCxKic2QMH/7TQdt1TeoXrkopJVBXAotAJR6cT6Ndwe6@3U/UTnMRb3WavMl3ELYlCPY0jC@CSEDIITLYysVkUC@om@y5JEdHx9O5@nMHNTZ@BFXyu3fuSQ8/MemWberJmZoo3ZH2ojBG05T1PbNNVlngsV4n8wOVszGavwh4OPpy7WYhFo8Hp82fM8D8IJXIFX9VYk/4y/lgwfAyNGDW@RAXhz8cOnz52gp0o6Zjis6vigT188dgBwdHxy6LAJJMdBQ4e2XA/TcBQu3DTOqAMwuFIdk@AMzt1LZKwKYm3C0oYFx06ol4BavEdcDKCoJDip80Y0W6zsAJGUjKoUgjQlI1ymuE/KaGo7wMxagwUcMfkXYZ2yDqw@w1UEIEBCsUWDLMzb5JRUL5vEWsjyAVXhCkGdaJlj6aJm9HLEn6owgwaKcrtY@BwWruvOIePZvO09TPCvQn4EJGgVHN3GZQp9pN2mvWzjDmGJHCcZHyQT26b9xIYgmuZoiwtxyrnY5sAbbLQVHpzaALHeoVhPdI6YDSQhA2UvkiRzZ2Xl28ofgdcz76oZlDQp1phrwGA0QPwFi/kizmxjYbeVt6hVAKuCmaiUEI@B7@3@QuOyubBFRzIB08foFLRwELIu9ncAh96B3nANWFqFlw2DrBNQK4QnFpBc0g16aC2iGjU4AfPNnqWisfLkN/AkfoA2Dk/7mp9btV2n68IWZrI14MlaeMAqaZ0XA/6r1Zd94oZA1plPVqDWKbXFNtYgrorQcLjLq8ZyLR0q0QtqDu3tAgXrh2FdGOiE1sdcFzIpb1VQNYHlJQ4zqfalEiZrlrkDMrdIFs4qFvBgiIsPkib2s0Yda7fpjtXtInQk2twrarcbyqzt104B9tjwxpk6arlh/rIs1O7rmBC9njCoow2iPAn5ElMyhpaxPaKbbtR3W1xYEQ19P1Ox5Is9x/6XDoPYAELhMJ7yQHnp882hGoWlesius9epaOLqO@ri0I269CxljpB@ddei04h2bNXr9gohp9qdDSyslucNPDhrPIh93cTCbINrDmECUwkJQA2yKUMG1hVc8hA06HZJnySKSubqRgtGy9rpf/NDYt5sJmb7h0Lbm4X@TmzWHBJXBxrzTS8HknbBesC6Pc0yYYH6Hpyzbg/OWM8E@z@J3oP0WMMGAUJp3b4a8RTlRLQ/9CTXPqd2xQmI/@bqgaBJcgXuCJRgscTAd7wyTOM8tgqWzaGHTtIyydh9@Ai8sfEc7qRlfBvnILOYZ3FWJiHeIuAkz9l9zKbhXQxAqQjhJZuF2RLC5/E1jqJ3N8g4UEFMFMu0xB8NaHGd8BSka2LUkiuUmXIasqIe9b2M9F42RMP2aiiP7udhirXxEbzOxmk8ZteV2ddayxN@E42ZsUjlzBCVdbvqnRO8IaGOYfqzzoN7FKwrhQ@TXi0vBvWsuM/Mw79nHgMU7cuf4tpMAPZZrVGkQZcZ2RB1eEJSlVxf1AHEbgVQbYwuaAiHEkNrPp732SyeRQsMs4wNr/f/X1eGf4ArQ@XK1gZfAumLdGX/ZfbFqhtMxul9VgP4GuGrArq1yc7qRbunMo@pQJvXrtIf@rKpNuybkjKVaPlv/428zEGGGi0/sPomutbmrmKDKuvWp3/6IqN62@omg7hG7TajUyFhUOMoqEkbaRIlENHpaDFh8hdwT/zqZTaaNe@Y2btIseN6145QQ37f7@8YtLwXV4bA6LA6ZgFavyNl8uLh6rOwU2toLwTRK0oHqyXP31TydrjuA3wtvUuD/6EhQsPwiVsR6eZft0Nmb@SDh7hqp4dNEjUIIv7FJD0I0ZEnAVYfx5MQkiR4pjrMJIPJZEw/IoVRCWXK2o4s7DlxhLMXbrGoTNdA6AblDwmzMMmwWWVhfhu5pNRx4Psdx5@r6H6J/9mxPbKmfo17/j6NweH7eZ6O/w0 "C (gcc) – Try It Online")
[Answer]
# [Piet](https://www.dangermouse.net/esoteric/piet.html) + [ascii-piet](https://github.com/dloscutoff/ascii-piet), 44 bytes (2×22=44 codels)
```
tuuuumknnfbkqmkcalrmu_sajs?daltdddbfckkkkk ?
```
[Try Piet online!](https://piet.bubbler.one/#eJw1TtsKgzAM_Zc8RzBOnforKtLVuDq6tqhjD2P_vlRnTiDnwin9gPYjQ9O2KRZ_EGGNVwFdkHLh-WGRRCWWmEUpvOqxvUSrQjkVUnbk6c6OzfdHCmmfoDo2e4SVAzSQJAkg2PkpnNI4InnV0EzKrowwu_DaJDRsrX_7xY5D56TVufjzu7fTqZUNRt1403MwvJzuwxun2akBvj97yj8B)
Input the string with the [sentinel value](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods/24639#24639) `_`.
### Pseudocode
```
while true:
  S = character input
  n = (codepoint of S) - 96
  if n+1 == 0:
    exit
  else:
    print(floor(n/10))
    print(n modulo 10)
```
[Answer]
# [MATL](http://github.com/lmendo/MATL), 11 bytes
```
96-OH&YA!1e
```
[Try it online!](http://matl.tryitonline.net/#code=OTYtT0gmWUEhMWU&input=J2hlbGxvd29ybGQn)
```
         % Implicit input
96-      % Subtract 96. So 'a' becomes 1, 'b' becomes 2 etc
OH&YA    % Convert each number to 2 decimal digits. Gives a 2-column matrix
!1e      % Transpose and linearize into a row
         % Implicit display
```
[Answer]
## Ruby, ~~53~~ 46 bytes
~~`->s{s.chars.map{|c|(c.ord-96).to_s.rjust(2,?0)}.join}`~~
`->s{s.chars.map{|c|(c.ord+4).to_s[1..2]}.join}`
]