[Question]
  [
# Challenge
Given an input of an all-lowercase string `[a-z]`, output the total distance between the letters.
## Example
```
Input: golf
Distance from g to o : 8
Distance from o to l : 3
Distance from l to f : 6
Output: 17
```
## Rules
* Standard loopholes forbidden
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") - shortest answer in bytes wins.
* The alphabet can be traversed from either direction. **You must always use the shortest path.** (i.e the distance between `x` and `c` is 5).
![1](https://i.stack.imgur.com/RyIZy.jpg)
# Test cases
```
Input: aa
Output: 0
Input: stack
Output: 18
Input: zaza
Output: 3
Input: valleys
Output: 35
```
  
[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly), ~~11~~ 8 bytes
```
OIæ%13AS
```
Saved 3 bytes thanks to @[Martin Ender](https://codegolf.stackexchange.com/users/8478/martin-ender).
[Try it online!](http://jelly.tryitonline.net/#code=T0nDpiUxM0FT&input=&args=J2dvbGYn) or [Verify all test cases.](http://jelly.tryitonline.net/#code=T0nDpiUxM0FTCsOH4oKs&input=&args=Wydnb2xmJywgJ2FhJywgJ3N0YWNrJywgJ3phemEnLCAndmFsbGV5cydd)
## Explanation
```
OIæ%13AS  Input: string Z
O         Ordinal. Convert each char in Z to its ASCII value
 I        Increments. Find the difference between each pair of values
  æ%13    Symmetric mod. Maps each to the interval (-13, 13]
      A   Absolute value of each
       S  Sum
          Return implicitly
```
[Answer]
## Haskell, ~~57~~ 56 bytes
```
q=map$(-)13.abs
sum.q.q.(zipWith(-)=<<tail).map fromEnum
```
Usage example: `sum.q.q.(zipWith(-)=<<tail).map fromEnum $ "valleys"` -> `35`.
How it works:
```
q=map$(-)13.abs                -- helper function.
                               -- Non-pointfree: q l = map (\e -> 13 - abs e) l
                               -- foreach element e in list l: subtract the
                               -- absolute value of e from 13
               map fromEnum    -- convert to ascii values
      zipWith(-)=<<tail        -- build differences of neighbor elements
  q.q                          -- apply q twice on every element
sum                            -- sum it up
```
Edit: @Damien saved one byte. Thanks!
[Answer]
# [MATL](http://github.com/lmendo/MATL), ~~14~~, 10 bytes
```
dt_v26\X<s
```
[Try it online!](http://matl.tryitonline.net/#code=ZHRfdjI2XFg8cw&input=J3ZhbGxleXMn)
*Thanks [@Suever](https://codegolf.stackexchange.com/users/51939/suever) for saving 4 bytes!*
Explanation:
```
d           % Take the difference between consecutive characters
 t_         % Make a copy of this array, and take the negative of each element
   v        % Join these two arrays together into a matrix with height 2
    26\     % Mod 26 of each element
       X<   % Grab the minimum of each column
         s  % Sum these. Implicitly print
```
Previous version:
```
d26\t13>26*-|s
```
[Answer]
## Python 3, ~~69~~ 68 bytes
```
lambda s:sum([13-abs(13-abs(ord(a)-ord(b)))for a,b in zip(s,s[1:])])
```
Breakdown:
```
lambda s:
         sum(                                                      )
             [                             for a,b in zip(s,s[1:])]
              13-abs(13-abs(ord(a)-ord(b)))
```
[Answer]
# Java, ~~126~~ ~~120~~ 117 bytes
```
int f(String s){byte[]z=s.getBytes();int r=0,i=0,e;for(;++i<z.length;r+=(e=(26+z[i]-z[i-1])%26)<14?e:26-e);return r;}
```
Thanks to @KevinCruijssen for pointing out a bug in the original version and suggesting to make the for-loop empty.
The use of `(26 + z[i] - z[i - 1]) % 26)` is inspired from a comment by @Neil on another answer. `(26 + ...)%26` serves the same purpose as `Math.abs(...)` because of `...? e : 26 - e`.
**Ungolfed**:
```
int f(String s) {
    byte[]z = s.getBytes();
    int r = 0, i = 0, e;
    for (; ++i < z.length; r += (e = (26 + z[i] - z[i - 1]) % 26) < 14 ? e : 26 - e);
    return r;
}
```
[Answer]
## JavaScript (ES6), ~~84~~ ~~82~~ 79 bytes
Saved 3 bytes thanks to Cyoce:
```
f=([d,...s],p=parseInt,v=(26+p(s[0],36)-p(d,36))%26)=>s[0]?f(s)+(v>13?26-v:v):0
```
**Explanation:**
```
f=(
  [d,...s],                    //Destructured input, separates first char from the rest
  p=parseInt,                  //p used as parseInt
  v=(26+p(s[0],36)-p(d,36))%26 //v is the absolute value of the difference using base 36 to get number from char
  )
)=>
  s[0]?                        //If there is at least two char in the input
    f(s)                       //sum recursive call
    +                          //added to
    (v>13?26-v:v)              //the current shortest path
  :                            //else
    0                          //ends the recursion, returns 0
```
**Example:**  
Call: `f('golf')`  
Output: `17`
---
Previous solutions :
82 bytes thanks to Neil:
```
f=([d,...s],v=(26+parseInt(s[0],36)-parseInt(d,36))%26)=>s[0]?f(s)+(v>13?26-v:v):0
```
84 bytes:
```
f=([d,...s],v=Math.abs(parseInt(s[0],36)-parseInt(d,36)))=>s[0]?f(s)+(v>13?26-v:v):0
```
[Answer]
## Ruby, 73 bytes
```
->x{eval x.chars.each_cons(2).map{|a,b|13-(13-(a.ord-b.ord).abs).abs}*?+}
```
[Answer]
# PHP, 93 Bytes
```
for(;++$i<strlen($s=$argv[1]);)$r+=13<($a=abs(ord($s[$i-1])-ord($s[$i])))?$a=26-$a:$a;echo$r;
```
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 12 bytes
```
SÇ¥YFÄ5Ø-}(O
```
**Explanation**
```
SÇ                   # convert to list of ascii values
  ¥                  # take delta's
   YF    }           # 2 times do
     Ä5Ø-            # for x in list: abs(x) - 13
          (O         # negate and sum
```
[Try it online!](http://05ab1e.tryitonline.net/#code=U8OHwqVZRsOENcOYLX0oTw&input=dmFsbGV5cw)
[Answer]
# Perl, 46 bytes
Includes +3 for `-p` (code contains `'`)
Give input on STDIN without final newline:
```
echo -n zaza | stringd.pl
```
`stringd.pl`:
```
#!/usr/bin/perl -p
s%.%$\+=13-abs 13-abs ord($&)-ord$'.$&%eg}{
```
[Answer]
## Racket 119 bytes
```
(λ(s)(for/sum((i(sub1(string-length s))))(abs(-(char->integer
(string-ref s i))(char->integer(string-ref s(+ 1 i)))))))
```
Testing: 
```
(f "golf")
```
Output: 
```
17
```
Detailed version: 
```
(define(f s)
  (for/sum((i(sub1(string-length s))))
    (abs(-(char->integer(string-ref s i))
          (char->integer(string-ref s(+ 1 i)))))))
```
[Answer]
# C#, 87 85 bytes
**Improved** solution - *replaced Math.Abs() with the add & modulo trick to save 2 bytes:*
```
s=>{int l=0,d,i=0;for(;i<s.Length-1;)l+=(d=(s[i]-s[++i]+26)%26)>13?26-d:d;return l;};
```
**Initial** solution:
```
s=>{int l=0,d,i=0;for(;i<s.Length-1;)l+=(d=Math.Abs(s[i]-s[++i]))>13?26-d:d;return l;};
```
**[Try it online!](https://ideone.com/4KtV7g)**
Full source, including test cases:
```
using System;
namespace StringDistance
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<string,int>f= s=>{int l=0,d,i=0;for(;i<s.Length-1;)l+=(d=Math.Abs(s[i]-s[++i]))>13?26-d:d;return l;};
            Console.WriteLine(f("golf"));   //17
            Console.WriteLine(f("aa"));     //0
            Console.WriteLine(f("stack"));  //18
            Console.WriteLine(f("zaza"));   //3
            Console.WriteLine(f("valleys"));//35
        }
    }
}
```
[Answer]
# Actually, 21 bytes
Based partially on [cia\_rana's Ruby answer](https://codegolf.stackexchange.com/a/93654/47581).
There was a bug with `O` (in this case, map ord() over a string) where it would not work with `d` (dequeue bottom element) and `p` (pop first element) without first converting the map to a list with `#`. This bug has been fixed, but as that fix is newer than this challenge, so I've kept `#` in.
**Edit:** And the byte count has been wrong since September. Whoops.
Golfing suggestions welcome. [Try it online!](http://actually.tryitonline.net/#code=TyM7ZFhAcFjimYAtYEE7w7psLWttYE3Oow&input=InZhbGxleXMi)
```
O#;dX@pX♀-`A;úl-km`MΣ
```
**Ungolfing**
```
         Implicit input string.
          The string should already be enclosed in quotation marks.
O#       Map ord() over the string and convert the map to a list. Call it ords.
;        Duplicate ords.
dX       Dequeue the last element and discard it.
@        Swap the with the duplicate ords.
pX       Pop the last element and discard it. Stack: ords[:-1], ords[1:]
♀-       Subtract each element of the second list from each element of the first list.
          This subtraction is equivalent to getting the first differences of ords.
`...`M   Map the following function over the first differences. Variable i.
  A;       abs(i) and duplicate.
  úl       Push the lowercase alphabet and get its length. A golfy way to push 26.
  -        26-i
  k        Pop all elements from stack and convert to list. Stack: [i, 26-i]
  m        min([i, 26-i])
Σ        Sum the result of the map.
         Implicit return.
```
[Answer]
# Java 7,128 bytes
```
 int f(String s){char[]c=s.toCharArray();int t=0;for(int i=1,a;i<c.length;a=Math.abs(c[i]-c[i++-1]),t+=26-a<a?26-a:a);return t;}
```
# Ungolfed
```
 int f(String s){
 char[]c=s.toCharArray();
 int t=0;
 for(int i=1,a;
     i<c.length;
   a=Math.abs(c[i]-c[i++-1]),t+=26-a<a?26-a:a);
return t;
 }
```
[Answer]
# Pyth, 20 bytes
```
Lm-13.adbsyy-M.:CMQ2
```
A program that takes input of a quoted string on STDIN and prints the result.
[Try it online](https://pyth.herokuapp.com/?code=Lm-13.adbsyy-M.%3ACMQ2&test_suite=1&test_suite_input=%22aa%22%0A%22stack%22%0A%22zaza%22%0A%22valleys%22&debug=0)
**How it works**
```
Lm-13.adbsyy-M.:CMQ2  Program. Input: Q
L                     def y(b) ->
 m      b              Map over b with variable d:
  -13                   13-
     .ad                abs(d)
                CMQ   Map code-point over Q
              .:   2  All length 2 sublists of that
            -M        Map subtraction over that
          yy          y(y(that))
         s            Sum of that
                      Implicitly print
```
[Answer]
## dc + od, 65 bytes
```
od -tuC|dc -e'?dsN0sT[lNrdsNr-d*vdD[26-]sS<Sd*vlT+sTd0<R]dsRxlTp'
```
**Explanation:**
Because in *dc* you can't access a string's characters, I used *od* to get the ASCII values. These will be processed in reverse order from the stack (LIFO container) like so:
```
dsN0sT             # initialize N (neighbor) = top ASCII value, and T (total) = 0
[lNrdsNr-          # loop 'R': calculate difference between current value and N,
                   #updating N (on the first iteration the difference is 0)
   d*vdD[26-]sS<S  # get absolute value (d*v), push 13 (D) and call 'S' to subtract
                   #26 if the difference is greater than 13
   d*vlT+sT        # get absolute value again and add it to T
d0<R]dsR           # repeat loop for the rest of the ASCII values
xlTp               # the main: call 'R' and print T at the end
```
**Run:**
```
echo -n "golf" | ./string_distance.sh
```
**Output:**
```
17
```
[Answer]
# C, ~~82 86 83~~ 76 bytes
```
t,u;f(char*s){for(t=0;*++s;u=*s-s[-1],t+=(u=u<0?-u:u)>13?26-u:u);return t;}
```
Assumes input string is at least one character long. This doesn't require `#include<stdlib.h>`
Edit: Argh, sequence points!
[Try it on Ideone](https://ideone.com/mLjkOm)
[Answer]
# C, 70 bytes ~~76 bytes~~
```
k,i;f(char *s){for(i=0;*++s;i+=(k=abs(*s-s[-1]))>13?26-k:k);return i;}
```
[Answer]
# Scala, 68 bytes
```
def f(s:String)=(for(i<-0 to s.length-2)yield (s(i)-s(i+1)).abs).sum
```
Criticism is welcome.
[Answer]
# C#, 217 bytes
Golfed:
```
IEnumerable<int>g(string k){Func<Char,int>x=(c)=>int.Parse(""+Convert.ToByte(c))-97;for(int i=0;i<k.Length-1;i++){var f=x(k[i]);var s=x(k[i+1]);var d=Math.Abs(f-s);yield return d>13?26-Math.Max(f,s)+Math.Min(f,s):d;}}
```
Ungolfed:
```
IEnumerable<int> g(string k)
{
  Func<Char, int> x = (c) => int.Parse("" + Convert.ToByte(c)) - 97;
  for (int i = 0; i < k.Length - 1; i++)
  {
    var f = x(k[i]);
    var s = x(k[i + 1]);
    var d = Math.Abs(f - s);
    yield return d > 13 ? 26 - Math.Max(f, s) + Math.Min(f, s) : d;
  }
}
```
Output:
```
aa: 0
stack: 18
zaza: 3
valleys: 35
```
'a' is 97 when converted to bytes, so 97 is subtracted from each one. If the difference is greater than 13 (ie, half of the alphabet), then subtract the differences between each character (byte value) from 26. A last minute addition of "yield return" saved me a few bytes!
[Answer]
# Python 3, 126 bytes
With list *in*comprehension.
```
d=input()
print(sum([min(abs(x-y),x+26-y)for x,y in[map(lambda x:(ord(x)-97),sorted(d[i:i+2]))for i in range(len(d))][:-1]]))
```
[Answer]
# PHP, 79 bytes
```
for($w=$argv[1];$w[++$i];)$s+=13-abs(13-abs(ord($w[$i-1])-ord($w[$i])));echo$s;
```
[Answer]
# Java, 109 bytes
```
int f(String s){int x=0,t,a=0;for(byte b:s.getBytes()){t=a>0?(a-b+26)%26:0;t=t>13?26-t:t;x+=t;a=b;}return x;
```
]