text:
EvenSt-ring C ode - g ol!f
An 'Even string' is any string where the parity of the ASCII values of the characters is always alternating. For example, the string EvenSt-ring$! is an even-string because the ASCII values of the characters are:
69 118 101 110 83 116 45 114 105 110 103 36 33

And the parities of these numbers are:
Odd Even Odd Even Odd Even Odd Even Odd Even Odd Even Odd

Which is alternating the whole way. However, a string like Hello world! is not an even string because the ASCII values are:
72 101 108 108 111 32 87 111 114 108 100 33

And the parities are:
Even Odd Even Even Odd Even Odd Odd Even Even Even Odd

Which is clearly not always alternating.
The challenge
You must write either a full program or a function that accepts a string for input and outputs a truthy value if the string is even, and a falsy value otherwise. You can take your input and output in any reasonable format, and you can assume that the input will only have printable ASCII (the 32-127 range). You do not have to handle empty input.
Examples
Here are some examples of even strings:
#define
EvenSt-ring$!
long
abcdABCD
3.141
~
0123456789
C ode - g ol!f
HatchingLobstersVexinglyPopulateJuvenileFoxglove

And all of these examples are not even strings:
Hello World
PPCG
3.1415
babbage
Code-golf
Standard loopholes apply
Shortest answer in bytes wins
Happy golfing!

You may also use this ungolfed solution to test any strings if you're curious about a certain test-case.

this may be slightly more readable

Can the input be length 1? Empty?

@xnor There's a length-1 example in the test cases, but empty input is a good question.

Add another uneven string as a test case: lno.

@xnor The input may be length 1 (which is always even), but empty inputs may result in undefined behavior. I have added that clarification.

Any bonus points for program itself being an even string?

@Daerdemandt I thought that's what this challenge was going to be when I first read it

MATL, 4 3 bytes
Thanks to Emigna for saving a byte and thanks to Luis Mendo for fixing some bugs. Code:
doA

Explanation:
d     # Difference between the characters
 o    # Mod 2
  A   # Matlab style all

Try it online!

I think a list of 1's is true in MATL, so you should be able to remove the A.

See for example this post, stating so :)

@Emigna Thanks :). There has been some discussion about this, so I'm not sure if it is entirely valid.

See this Meta question. The highest voted answer would allow for leaving the A out thanks to the way MATL's if works.

...and we have a WINNER!!!

You can also replace 2\  by o. And the  code will look very... imperative:-)

Crossed out 4 is still regular 4...

@Adnan However, you do need a final A to cover the one-char input (now that gives empty output, which is falsy). So again 3 bytes :-)

@LuisMendo Thanks! It's really nice to have character arithmetic, I should probably implement that in osabie sometime :p.

05AB1E, 5 4 bytes
Saved 1 byte thanks to Adnan.
Ç¥ÉP

Try it online!
Explanation
Ç       # convert to ascii values
 ¥      # compute delta's
  É     # mod by 2
   P    # product

I believe this also works: Ç¥ÉP :)

@Adnan: Lol, of course! Thanks! :)

Jelly, 7 5 4 bytes
OIḂẠ

Saved 2 bytes using the deltas idea from @Steven H.
Saved 1 byte thanks to @Lynn.
Try it online! or Verify all test cases.
Explanation
OIḂẠ  Input: string S
O     Ordinal
 I    Increments
  Ḃ   Mod 2
   Ạ  All, 0 if it contains a falsey value, else 1

I had come up with the same Jelly answer independently, kudos

You can save one byte: %2 → Ḃ

@Lynn Thanks, I felt like there was a builtin for mod 2, but I couldn't find it, was searching using mod.

Python 2, 54 Bytes
lambda s:all((ord(x)-ord(y))%2for x,y in zip(s,s[1:]))

Mathematica, 50 44 bytes
The current version is basically all Martin Ender's virtuosity.
Differences@ToCharacterCode@#~Mod~2~FreeQ~0&

Returns True or False. Nothing too clever: takes the mod-2 sum of each pair of consecutive ASCII codes, and checks that 0 is never obtained.
Old version:
Union@Mod[Most[a=ToCharacterCode@#]+Rest@a,2]=={1}&

R, 41 35 bytes
EDIT:
Saved a few bytes thanks to @JDL by using diff instead of rle.
all(diff(utf8ToInt(readline())%%2))

all(rle(utf8ToInt(readline())%%2)[[1]]<2)

Explanation

readline() read input.
utf8ToInt()%%2 convert to ascii values and mod 2 (store as R-vector)
all(rle()==1) run length encoding of to find runs. All runs should be equal to one or smaller than 2 since no runs cant be negative or 0 (saves one byte instead of ==).

I think using prod(...) rather than all(... == 1) saves a few chars.

@JDL Not sure what you mean. Wouldn't this always return something >1?

Sorry, I confused your solution with the method of another one. For some reason I thought the thing inside all was entirely zeroes and ones.

I think we can save more actually by ditching rle and using diff: all(diff(utf8ToInt(readline())%%2)) (we get a warning, but I don't think that's disallowed)

I think it does; with a length one string, it boils down to all(numeric(0)) which is TRUE, the desired answer for a length one string. (I tested, if it matters, against R-3.3.1)

JavaScript (ES6), 60 50 46 bytes
s=>[...s].every(c=>p-(p=c.charCodeAt()%2),p=2)

I tried recursion, but at 51 bytes, it doesn't seem to be quite worth it:
f=([c,...s],p=2)=>c?p-(p=c.charCodeAt()%2)&f(s,p):1

Test snippet

f=s=>[...s].every(c=>p-(p=c.charCodeAt()%2),p=2)
<input id=I value="Evenst-ring"><button onclick="console.log(f(I.value))">Run</button>

41 characters in Node.js: s=>[...Buffer(s)].every(c=>p-(p=c&1),p=2)

Brain-Flak, 138 114 112 84 + 3 = 87 bytes
Thanks to @Riley for help golfing.
This program treats empty input as a noneven string.
{({}(())){({}[()]<(()[{}])>)}{}(({})<>[[]{}]()){{}(<>)}{}({}<>)<>}<>(([])[()]){<>}{}

Try it online!
Explanation (outdated)
Shifts the input from the left stack to the right while modding by 2. Finds the difference between each adjacent character until all have been checked or one of the differences is equal to zero (which would only occur in a noneven string). If the loop terminated due to a noneven string then switch back to the left stack and pop the value remaining on it. Otherwise, stay on the right stack and pop the zero above the 1 remaining on the stack.

Nice! I was going I'd get a bflack answer on this one. Empty input is undefined, so you can go with the shorter one.

You can save 10 bytes by not using the height of the stack when you compute mod 2. Just change the beginning ([]){{} -> { and remove ([]) from just before the close of the first loop.

Thanks @Riley, I have been looking into reducing the size of the mod 2 and I think that the whole thing can be made into {({}(())){({}[()]<(()[{}])>)}{}({}<>)<>}<> (42 bytes). This was derived from your original modulus. To make it work with your program an additional +1 nilad needs to be added: {({}(())){({}[()]<(()[{}])>)}{}({}()<>)<>}<>

95% of my original one was from the wiki. You saved me a ton of bytes with the new mod 2. I knew there had to be a better, I just didn't have time to find it. Thanks!

Pyth (fork), 9 bytes
.A%R2.+CM

No Try It Online link because the fork does not have its own version in the online interpreters.
Explanation:
       CM       Map characters to their ASCII codes.
     .+         Get deltas (differences between consecutive character codes)
  %R2           Take the modulo of each base 2
.A              all are truthy (all deltas are odd)

Brachylog, 17 bytes
@c:{:2%}a@b:{l1}a

Try it online!
Explanation
@c                   Input to a list of char codes
  :{:2%}a            Apply X mod 2 for each X in the list of char codes
         @b          Split the list into a list of lists where each sublist elements are the
                       same, e.g. turn [1,0,1,1,0,0] into [[1],[0],[1,1],[0,0]]
           :{l1}a    The length of each sublist must be 1

Java 8, 77 76 72 57 bytes
a->{int i=2,b=1;for(int c:a)b=i==(i=c%2)?0:b;return b>0;}

-4 bytes thanks to @Geobits.
Explanation:
Try it online.
a->{               // Method with character-array parameter and boolean return-type
  int i=2,         //  Integer `i`, starting at any integer not 0 or 1
      b=1;         //  Flag-integer `b`, starting at 1
  for(int c:a)     //  Loop over the input-array
    b=i==(i=c%2)?  //   If two adjacent characters were both odd or even:
       0           //    Set the flag-integer `b` to 0
      :            //   Else:
       b;          //    The flag-integer `b` remains the same
  return b>0;}     //  Return if the flag-integer `b` is still 1

The meta consensus for truthy values means you should be returning a boolean here (I know, it sucks). The best I could get this that way (72) is by using a flag-int like: boolean c(char[]a){int i=3,b=1;for(int c:a)b=i==(i=c%2)?0:b;return b>0;}

Brain-Flak 155 151 141 121
Includes +3 for -a
Saved 30 bytes thanks to 1000000000
{({}(())){({}[()]<(()[{}])>)}{}({}()<>)<>}<>{({}[({})]<(())>){((<{}{}>))}{}({}[()]<>)<>}<>{{}}([]<(())>){((<{}{}>))}{}

Output:
truthy: 1
falsy:  0 on top of the stack
Try it online! (truthy)
Try it online! (falsy)

Better explanation coming later (if I can remember how it works after a few hours...)
#compute ((mod 2) + 1) and put on other stack
{({}(())){({}[()]<(()[{}])>)}{}({}()<>)<>}<>

#compare top two (remove top 1) push on other stack (-1 for different 0 for same)
{({}[({})]<(())>){((<{}{}>))}{}({}[()]<>)<>}<>

#remove all of the top -1s
{{}}

#take the logical not of the stack height
([]<(())>){((<{}{}>))}{}

Starry, 85 bytes
 ,       +    *   ` , +               + * ' +  ' `       +    * +   + *   '     +  `.

Try it online!
Note that since a Starry program has no way of telling when an input of arbitrary length ends, this program uses a trailing newline in the input to mark the end of the string. If you get a cryptic error message about and undefined method ord for nil:NilClass then the input is missing a trailing newline.
Explanation
The basic strategy that the program employs is it reads the characters one by one from input and if they are not a newline (character 10) it mods they ASCII value of the character by 2 and finds the difference between it and the previously read character. If the difference is zero the program terminates and prints 0 (falsey). Otherwise the program loops back and does the process over again. If the program reads a newline it terminates and prints 10 (truthy).
Annotated Program
 ,               Push the first character
       +         Push 2
    *            Replace the first character and 2 with the first character mod 2
   `             Label 3 <--------------------------------------------------------\
 ,               Push the next the character                                      |
 +               Push a duplicate of it                                           |
               + Push 10                                                          |
 *               Replace the 10 and the duplicate with their difference           |
 '               Pop and if not zero (the read char is not 10) goto label 1 >-\   |
 +               Push a duplicate of the character which must be newline (10) |   |
  '              Pop and goto label 2 >---------------------------------------+-\ |
 `               Label 1 <----------------------------------------------------/ | |
       +         Push 2                                                         | |
    *            Replace the character and 2 with the character mod 2           | |
 +               Duplicate it ^                                                 | |
   +             Roll the top three items on the stack. The top goes to         | |
                   the bottom. The top three items are now                      | |
                   (from top to bottom) the current character, the previous     | |
                   character, the current character (all modded by 2).          | |
 *               Replace the current character and previous character           | |
                   with their difference                                        | |
   '             Pop if nonzero goto label 3 >----------------------------------+-/
     +           Push zero                                                      |
  `              Label 2 <------------------------------------------------------/
.                Print out the number on top of the stack
                    0 if we came by not following the goto label 3
                   10 if we came by going to label 2

Perl, 24 + 1 (-p) = 25 bytes
-4 bytes thanks to @Ton Hospel !
s/./$&&v1/eg;$_=!/(.)\1/

Needs -p flag. Outputs 1 is the string is even, nothing otherwise. For instance :
perl -pe 's/./$&&v1/eg;$_=!/(.)\1/' <<< "#define
Hello World"

Explanations : replaces each character by its value mod 2 (so the string contains only 0s and 1s after that). Then search for two following 1 or 0 : if it finds some, then the string isn't even, otherwise it is.

The right method but not completely golfed out. s/./$&&v1/eg;$_=!/(.)\1/. PS (ord$&)%2 could have been written as 1&ord$&

@TonHospel Damn, I was happy I found that... But I tend to forget about bitwise operations on strings.Thanks a lot ! :)

@TonHospel, I haven't tried it, but can't you save a byte by using v1 itself instead of v1?

@msh210 No, you can only use valid identifiers as bare words, and \x01 isn't

J, 15 bytes
0=1#.2=/\2|3&u:

Usage
   f =: 0=1#.2=/\2|3&u:
   f 'C ode - g ol!f'
1
   f 'Code-golf'
0

Explanation
0=1#.2=/\2|3&u:  Input: string S
           3&u:  Get ordinals of each char
         2|      Take each modulo 2
     2  \        For each pair of values
      =/           Test if they are equal, 1 if true else 0
  1#.            Treat the list of integers as base 1 digits and convert to decimal
                 This is equivalent to taking the sum
0=               Is it equal to 0, 1 if true else 0, and return

Vim, 38 bytes
qqs<C-R>=char2nr(@")%2<CR><Esc>l@qq@q:g/00\|11/d<CR>
Assumes input string in buffer, and empty "q. Outputs binary nonsense if true, nothing if false.

s<C-R>=char2nr(@")%2<CR>: Replaces a character with 1 if odd, 0 if even. The macro this is in just does this to every character in the line (no matter how long it is).
:g/00\|11/d<CR>: Deletes the line if 2 consecutive "bits" have the same value. Faster than a back-reference.

Normally, in vimgolf, when you use an expression function inside a macro, you're supposed to do the macro itself on the expression register and use some trickery to tab-complete. That's more difficult this time. I may find a way to shorten that later.

Retina, 39 bytes
Byte count assumes ISO 8859-1 encoding.
S_`
%{2`
$`
}T01`p`_p
..

Mm`.¶.|^¶$
^0

Outputs 1 for truthy and 0 for falsy.
Try it online! (The first line enables a linefeed-separated test suite.)
Explanation
Inspired by a answer of mbomb007's I recently developed a reasonably short ord() implementation in Retina. This is largely based on that, although I was able to make a few simplifications since I don't need a decimal result in since I only need to support printable ASCII (and I only care about the parity of the result, so ending up with an arbitrary offset is fine, too).
Stage 1: Split
S_`

This simply splits the input into its individual characters by splitting it around the empty match and dropping the empty results at the beginning and end with _.
Stage 2: Replace
%{2`
$`

The %{ tells Retina a) that this stage and the next should be run in a loop until the string stops changing through a full iteration, and that these two stages should be applied to each line (i.e each character) of the input separately.
The stage itself is the standard technique for duplicating the first character of the input. We match the empty string (but only look at the first two matches) and insert the prefix of that match. The prefix of the first match (at the beginning of the string) is empty, so this doesn't do anything, and the prefix of the second match is the first character, which is therefore duplicated.
Stage 3: Transliterate
}T01`p`_o

} indicates the end of the loop. The stage itself is a transliteration. 01 indicates that it should only be applied to the first character of the string. p is shorthand for all printable ASCII characters and _ means "delete". So if we expand this, the transliteration does the following transformation:
from:   !"#$%...
to:    _ !"#$...

So spaces are deleted and all other characters are decremented. That means, these two stages together will create a character range from space to the given character (because they'll repeatedly duplicate and decrement the first character until it becomes a space at which point the duplication and deletion cancel).
The length of this range can be used to determine the parity of the character.
Stage 4: Replace
..

We simply drop all pairs of characters. This clears even-length lines and reduces odd-length lines to a single character (the input character, in fact, but that doesn't really matter).
Stage 5: Match
Mm`.¶.|^¶$

It's easier to find inputs which aren't even, so we count the number of matches of either two successive empty lines or two successive non-empty lines. We should get 0 for even inputs and something non-zero otherwise.
Stage 6: Match
^0

All that's left is to invert the result, which we do by counting the number of matches of this regex, which checks that the input starts with a 0. This is only possible if the result of the first stage was 0.

Clojure, 59 bytes
#(every?(fn[p](odd?(apply + p)))(partition 2 1(map int %)))

Generates all sequential pairs from string n and checks if every pair sum is odd. If a sequence of ints is considered a reasonable format then it's 50 bytes.
#(every?(fn[p](odd?(apply + p)))(partition 2 1 %))

See it online : https://ideone.com/USeSnk

Haskell, 42 40 bytes
all odd.(zipWith(-)=<<tail).map fromEnum

Usage example: all odd.(zipWith(-)=<<tail).map fromEnum $ "long" -> True.
How it works:
               map fromEnum         -- turn into a list of ascii values
    (zipWith(/=)=<<tail)            -- build a list of neighbor differences
all odd                             -- check if all differences are odd

Edit: @xnor saved two bytes. Thanks!

It's a bit shorter to take differences and check if those are odd: all odd.(zipWith(-)=<<tail).map fromEnum.

Julia, 55 53 Bytes
f(s)=!ismatch(r"00|11",join(map(x->Int(x)%2,[s...])))

Explained
Map chars to 0|1 and check if the resulting string contains "00" or "11", which makes the string not alternating.

Python, 52 bytes
f=lambda s:s==s[0]or(ord(s[0])-ord(s[1]))%2*f(s[1:])

A recursive function. Produces 1 (or True) for even strings, 0 for odd ones. Multiplies the parity of the difference of the first two characters by the recursive value on the remainder. A single-character string gives True, as checked by it equaling its first character. This assumes the input is non-empty; else, one more byte is needed for s==s[:1] or len(s)<2.

Python 2, 52 bytes
p=r=2
for c in input():x=ord(c)%2;r*=p-x;p=x
print r

Alternatively, an iterative solution. Iterates over the input characters, storing the current and previous character values mod 2. Multiplies the running product by the difference, which because 0 (Falsey) only when two consecutive parities are equal.
The "previous" value is initialized to 2 (or any value not 0 or 1) so that the first character never matches parity with the fictional previous character.

Python, 42 bytes, outputs via exit code
p=2
for c in input():x=ord(c)%2;p=x/(p!=x)

Outputs via exit code. Terminates with a ZeroDivisionError when two consecutive characters have the same parities, otherwise terminates cleanly.

Ruby, 41 30 (+1) bytes
p gsub(/./){$&.ord%2}!~/(.)\1/

Call this from the command line with the -n flag, like so:
ruby -ne 'p gsub(/./){$&.ord%2}!~/(.)\1/'

Replaces each character with the parity of its ASCII value and then compares to a regex. If even, the =~ comparison will return the index of the first match (i.e. 0), which is a truthy value in Ruby; if not even, the comparison will return nil.
Thanks to Jordan for the improvements!

You can save 6 bytes by replacing =~/^0?(10)*1?$/ with !~/(.)\1/ (or !~/00|11/).

You can get it down to 30 + 1 bytes with the -n flag and input on stdin: ruby -ne 'p gsub(/./){$&.ord%2}!~/(.)\1/'.

Mathematica, 41 40 Bytes
And@@OddQ@Differences@ToCharacterCode@#&

-1 character, thanks to Martin Ender

C, 52 bytes
int f(char*s){return s[1]?(s[0]-s[1])%2?f(s+1):0:1;}

Compares the parity of first 2 characters, recursively moving through the string until it finds 2 characters with the same parity or the string with the length of 1 (s[1] == 0).
Code with some of the test cases

you can shorten this quite a bit by doing f(char*s){s=s[1]?(*s-s[1])%2?f(s+1):0:1;}   you don't need the int, return or [0]

by doing *++s instead of the second s[1] you can change f(s+1) to f(s). that plus my previous comment bring the total down to 39; I should also add that removing return makes it not work on ideone, but it still works with gcc on windows

with one final tweak I brought it down to 38 by removing the inner ternary. f(char*s){s=s[1]?(*s-*++s)%2&&f(s):1;} I'd go on but it's 5 am and I have wake up in 3 hours lmao

C#, 69 bytes
s=>{int i=1,e=0;for(;i<s.Length;)e+=(s[i-1]+s[i++]+1)%2;return e<1;};

Full program with test cases:
using System;

namespace EvenStrings
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<string,bool>f= s=>{int i=1,e=0;for(;i<s.Length;)e+=(s[i-1]+s[i++]+1)%2;return e<1;};

            Console.WriteLine(f("lno")); //false

            //true:
            Console.WriteLine(f("#define"));
            Console.WriteLine(f("EvenSt-ring$!"));
            Console.WriteLine(f("long"));
            Console.WriteLine(f("abcdABCD"));
            Console.WriteLine(f("3.141"));
            Console.WriteLine(f("~"));
            Console.WriteLine(f("0123456789"));
            Console.WriteLine(f("C ode - g ol!f"));
            Console.WriteLine(f("HatchingLobstersVexinglyPopulateJuvenileFoxglove"));

            //false:
            Console.WriteLine(f("Hello World"));
            Console.WriteLine(f("PPCG"));
            Console.WriteLine(f("3.1415"));
            Console.WriteLine(f("babbage"));
            Console.WriteLine(f("Code-golf"));
            Console.WriteLine(f("Standard loopholes apply"));
            Console.WriteLine(f("Shortest answer in bytes wins"));
            Console.WriteLine(f("Happy golfing!"));
        }
    }
}

Nice answer! +1 It's funny that when I try to port your answer to Java 7 it's longer than the one I have. But when I try to port my answer to C# it's longer than what you have. ;)

@KevinCruijssen Thanks, but there was a bug, which was not caught by any test case :(  I'll try to find some other method later.

Pyke, 8 bytes
m.o$2m%B

Try it here!
m.o      -    map(ord, input)
   $     -   delta(^)
    2m%  -  map(> % 2, ^)
       B - product(^)

PHP, 69 Bytes
for(;$i<strlen($s=$argv[1])-1;)$d+=1-ord($s[$i++]^$s[$i])%2;echo$d<1;

solution with Regex 81 Bytes
for(;$i<strlen($s=$argv[1]);)$t.=ord($s[$i++])%2;echo 1-preg_match("#00|11#",$t);

PowerShell v2+, 47 bytes
-join([char[]]$args[0]|%{$_%2})-notmatch'00|11'

(Can't quite catch PowerShell's usual competitors ...)
Takes input $args[0] as a string, casts it as a char-array, loops through it |%{...}, each iteration placing the modulo on the pipeline (with implicit [char] to [int] conversion). Those are encapsulated in parens and -joined into a string, which is fed into the left-hand of the -notmatch operator, checking against 00 or 11 (i.e., returns True iff the 0s and 1s alternate). That Boolean result is left on the pipeline and output is implicit.
Test Cases
PS C:\Tools\Scripts\golfing> '#define','EvenSt-ring$!','long','abcdABCD','3.141','~','0123456789','C ode - g ol!f','HatchingLobstersVexinglyPopulateJuvenileFoxglove'|%{"$_ --> "+(.\evenst-ring-c-ode-g-olf.ps1 $_)}
#define --> True
EvenSt-ring$! --> True
long --> True
abcdABCD --> True
3.141 --> True
~ --> True
0123456789 --> True
C ode - g ol!f --> True
HatchingLobstersVexinglyPopulateJuvenileFoxglove --> True

PS C:\Tools\Scripts\golfing> 'Hello World','PPCG','3.1415','babbage','Code-golf','Standard loopholes apply','Shortest answer in bytes wins','Happy golfing!'|%{"$_ --> "+(.\evenst-ring-c-ode-g-olf.ps1 $_)}
Hello World --> False
PPCG --> False
3.1415 --> False
babbage --> False
Code-golf --> False
Standard loopholes apply --> False
Shortest answer in bytes wins --> False
Happy golfing! --> False

><>, 29 27 bytes
i2%\0 n;n 1<
0:i/!?-}:%2^?(

Outputs 1 if the word is even, 0 if the word is odd.
You can try it online.
Edit : saved two bytes thanks to Martin Ender

Perl 6,  47  26 bytes
{?all .ords.rotor(2=>-1).map({(.[0]+^.[1])%2})}

{[~](.ords X%2)!~~/(.)$0/}

Expanded:
# bare block lambda with implicit parameter $_
{
  [~](             # reduce using concatenation operator ( no space chars )
    .ords X[%] 2   # the ordinals cross modulus with 2 ( 1 or 0 )
  # ^-- implicit method call on $_
  )

  ![~~]            # negating meta operator combined with smartmatch operator

  / ( . ) $0 /     # is there a character followed by itself?
}

Scala, 54 bytes
(_:String)sliding 2 map(t=>t(0)%2!=t(1)%2)reduce(_&&_)

I'm sure this can be improved.

Node.js (ES6), 45 44 bytes
s=>![...Buffer(s)].some((b,c,d)=>b+c-d[0]&1)

The Buffer object saved me alot of trouble over charCodeAt().
Also felt like including my attempts via JavaScript (ES6), though they aren't as short as ETHproduction's:
a=>![...a].some((b,c,d)=>b.charCodeAt()+c-d[0]&1) // 49 bytes

a=>!/(.),\1/.test([...a].map(b=>b.charCodeAt()&1)) // 50 bytes

a=>new Set([...a].map((b,i)=>b.charCodeAt()+i&1)).size<2 // 56 bytes

The first in the JavaScript (ES6) equivalent of what I went with in Node.js. The second was an attempt to use regex to simplify the pattern matching (45 bytes in Node.js). The third was an attempt to use Set's ability to determine unique values, combined with math that made valid arrays be either all 1's or 0's (51 bytes in Node.js).

C, 54 bytes
int c,p=*s^1,r=1;while(c=*s++){r&=p^c;p=c;}return r&1;

An xor of previous and current chars equal to xxxxxxx1 indicates a difference in parity. ANDing the results of every pair of chars in the string computes the string parity. A zero length string returns true.

Welcome to PPCG! All answers need to be full programs or callable functions whereas this appears to be merely a question body. Please include the full function in your answer or turn this into a full program.

Attache, 17 bytes
All@Odd@Delta@Ord

Try it online!
Checks if All of the Deltas are Odd.
Alternatives
19 bytes: All##Odd''Even##Ord
26 bytes: All##Odd@Sum=>Slices&2@Ord

Groovy, 33 30 Bytes
{(int)(it.getChars().sum())%2}

Basically collects the chars in the string into an array as their values modulo 2, sums them, then modulos the answer. In groovy a 0 is false and a 1 is a true. 0 for odd (false), 1 for true (even). This also implicitly handles empty input...
Try it: https://groovyconsole.appspot.com/script/5132426728701952
-2 Bytes if I can output an odd number if odd, even if even.

APL, 26 or 25 bytes
{~1∊↑(2/¨0 1)⍷¨2⍴⊂2|⍵}⎕UCS

One byte can be saved if ⎕IO is 0: {~1∊↑(2/¨⍳2)⍷¨2⍴⊂2|⍵}⎕UCS
The dyadic function returns 1 if the string is even, 0 otherwise.

Python 3, 65 Bytes
l=p=print
for i in input():
    c=ord(i)%2
    if l==c:
        p(1>2)
        break
    l=c
else: p(1<2)

1 and 0 are truthy and falsey (respectively) in Python, so you could print those instead of 1>2 and 1<2. Additionally, I count 92 bytes (interpreting the indents as tabs), and lots of whitespace that could be removed.

C#, 55 bytes
s=>{var f=1;for(;0<*++s;)f&=(*--s+*++s)%2;return 0<f;};

For all the dangerous golfers out there.
/*unsafe delegate bool Function(char* s);*/ // Function signature
/*unsafe Function Lambda = */ s =>
{
    var f = 1;                              // Output var, initialized to true
    for (; 0 < *++s;)                       // Enumerate string, starting from the 2nd char
         f &= (*--s + *++s) % 2;            // Bitwise AND whether previous and current
                                            // chars are alternating because
                                            // even+odd = odd,
                                            // even+even = odd+odd = even.
    return 0 < f;                           // Cast int to bool
};

MATLAB, 18 bytes
@(s)mod(diff(s),2)

This returns
f=@(s)mod(diff(s),2)
f('PPCG')
ans =
     0     1     0
f('#define')
ans =
     1     1     1     1     1     1

In MATLAB, if x is a vector, then if x is equivalent to if all(x). According to this Meta post, it's enough to return x.

Racket 131 bytes
(let p((l (map even?(map char->integer(string->list s)))))(cond[
(= 1(length l))#t][(equal?(car l)(second l))#f][else(p(cdr l))]))

Ungolfed:
(define (f s)
    (let loop ((lst (map even? (map char->integer(string->list s)))))
      (cond
        [(= 1 (length lst)) #t]
        [(equal? (first lst) (second lst)) #f]
        [else (loop (rest lst))]
        )))

Testing:
(f "EvenSt-ring$!")
(f "#define")
(f "abcdABCD")
(f "babbage")
(f "Code-golf")
(f "PPCG")

Output:
#t
#t
#t
#f
#f
#f

Clean, 55 bytes
\x->all(\(a,b)->(toInt a-toInt b)rem 2>0)(zip2 x(tl x))

Brain-Flak, 60 bytes
(()){{}({}({})(())){({}[()]<(()[{}])>)}{}}{}((){[()]<{{}}>})

Try it online!
-a no longer costs 3 bytes, so this is a 24-byte improvement over 0 ''s answer.  Output is 0 for falsy and 1\n0 for truthy.
The general idea is to calculate the parity of sums of adjacent characters until an even sum is reached.  If the string is alternating, the stopping condition will occur after reaching the implicit zeroes below the stack.  It thus suffices to check whether the next character is a null.

Thunno 2, 3 bytes
Ṣɗp

Try it online!
Explanation
Ṣɗp  # Implicit input
Ṣ    # Deltas
 ɗ   # Mod 2
  p  # Product
     # Implicit output

Vyxal, 4 bytes
C¯∷Π

Try it Online!
Explanation
C¯∷Π  # Implicit input
C     # Charcodes
 ¯    # Deltas
  ∷   # Mod 2
   Π  # Product
      # Implicit output


text:
Help me with my Halloween decoration
The Halloween is upon us, and I haven't decorated my house yet, so I gonna need your help to do this task
Input
The input will be a list of 4 digits numbers, where each digit represent a portion of decoration:
EMBU
||||
|||+-upper decoration
||+-bottom decoration
|+-mouth/nose
+-eyes

Eyes:
0 - °
1 - ¯
2 - -
3 - ^
4 - '
Mouth/Nose
0 - v
1 - w
2 - o
3 - _
4 - -
Bottom decoration
0 - nothing
1 - skeleton
2 - pumpkin
Upper decoration
0 - nothing
1 - flying bat
2 - resting bat
3 - spider
Output
Skeleton:
(EME)
 _|_
/[|]\
  |
 / \
Pumpkin
  ,
(EME)
Flying bat

 ^"^
Resting bat
  ()
  ´`
Spider
  |
 .|.
 :":

Each decoration has a 5 character width
Upper decorations start from the top
Lower decorations start from the bottom
If the spider is over the pumpkin or there is no bottom decoration the web length will be 3, if it's over the skeleton, the web length will be 1
When the bottom decoration is 0 the first 2 digits are irrelevant
Between each decoration there will be an empty column

Example
Input
3123 ??02 1021 0310
Output
   |     ()
   |     ´`   ^"^
  .|.              (°_°)
  :":               _|_
                   /[|]\
   ,           ,     |
 (^w^)       (¯v¯)  / \

Trailing spaces at the end of each line are optional
Trailing newline at the end of the entire output is allowed
Winning criteria
This is code-golf so the shortest answer wins

Is input always valid, so no 9999?

@KarlNapf yes, the input will always be valid

JavaScript (ES6), 319 315 bytes

let f =

s=>[0,1].map(i=>s.map(([A,B,C,D],x)=>+(z=i?D:C)&&[...'01/21/5015/41211/91/65'.split`/`[z-(i?C+D-13?1:-2:-2)]].map((n,y)=>a[(i?y:6-y)*4+x]=' '+('      ^"^   ()   ´`  / \\   |   .|. /[|]\\ _|_ ('+(e='°¯-^'[A])+'vwo_-'[B]+e+')  ,   :": ').substr(p+=n*5,5),p=0)),a=Array(28).fill`      `)&&a.join``.match(/.{24}/g).join`
`

console.log(f(["3123","0002","1021","0310"]));

Java, 829, 798
Yeah. Substantially improved thanks to Kevin Cruijssen and corvus_192.
s->{String[]e=s.split(" ");char c[][]=new char[8][e.length*6],t,u,h='|';int y,x=2,i=0,j;for(String l:e){y=0;char[]p=l.toCharArray(),z=c[y];int a=p[0],b=p[1],f=p[2],d=p[3],k=x-1,m=x+1;t=a<49?'°':a<50?'¯':a<51?45:a<52?'^':39;u=(char)(b<50?b+70:b<51?111:b<52?95:39);if(d>50){z[x]=h;if(f!=49){y=2;c[1][x]=h;c[2][x]=h;}z=c[y];z[k]=46;z[m]=46;z=c[++y];z[k]=58;z[m]=58;z[x]=34;}if(d==50){z[x]=40;z[m]=41;c[++y][x]='´';c[y][m]=96;}if(d==49){z=c[++y];z[k]=94;z[x]=34;z[m]=94;}if(f>49){y=6;c[y][x]=44;}if(f>48){y=f>49?7:3;z=c[y++];z[x]=u;z[k]=t;z[m]=t;z[x-2]=40;z[x+2]=41;}if(f==49){z=c[y++];z[x]=h;z[k]=95;z[m]=95;z=c[y];z[x]=h;z[k]=91;z[m]=93;z[x-2]=47;c[y++][x+2]=92;c[y++][x]=h;c[y][k]=47;c[y][m]=92;}x+=6;}for(;i<8;i++){s="";for(j=0;j<c[0].length;){t=c[i][j++];s+=t<1?' ':t;}System.out.println(s);}};

the ungolfed version
static void makeDecorations(String s){
    String[]e=s.split(" ");
    char c[][]=new char[8][e.length*6],t,u,h='|';
    int x=2,i=0,j,y;
    for(String l:e){
        y=0;
        char[]p=l.toCharArray(), z=c[y];
        int a=p[0],b=p[1],f=p[2],d=p[3],k=x-1,m=x+1;
        t=a<49?'°':a<50?'¯':a<51?45:a<52?'^':39;
        u=(char)(b<50?b+70:b<51?111:b<52?95:39);
        if(d>50){z[x]=h;
            if(f!=49){y=2;
                c[1][x]=h;
                c[2][x]=h;
            }
            z=c[y];
            z[k]=46;
            z[m]=46;
            z=c[++y];
            z[k]=58;
            z[m]=58;
            z[x]=34;
        }
        if(d==50){
            z[x]=40;
            z[m]=41;
            c[++y][x]='´';
            c[y][m]=96;
        }

        if(d==49){
            z=c[++y];
            z[k]=94;
            z[x]=34;
            z[m]=94;}
        if(f>49){
            y=6;
            c[y][x]=44;
        }
        if(f>48){
            y=f>49?7:3;
            z=c[y++];
            z[x]=u;
            z[k]=t;
            z[m]=t;
            z[x-2]=40;
            z[x+2]=41;
        }
        if(f==49){
            z=c[y++];
            z[x]=h;
            z[k]=95;
            z[m]=95;
            z=c[y];
            z[x]=h;
            z[k]=91;
            z[m]=93;
            z[x-2]=47;
            c[y++][x+2]=92;
            c[y++][x]=h;
            c[y][k]=47;
            c[y][m]=92;
        }
        x+=6;
    }
    for(;i<8;i++){
        s="";
        for(j=0;j<c[0].length;){
            t=c[i][j++];s+=t<1?32:t;
        }
        System.out.println(s);
    }
}

Favorite decoration (which apparently looks more evil in my console): terminator skeleton
(-w-)
 _|_
/[|]\
  |
 / \

You can save some bytes by defining a lambda instead of a full method

That initial "Yeah" made me laugh hard, I don't know why.

+1! Some things you can golf: char[][]c=new char[8][e.length*6];char t,u,h='|'; -> char c[][]=new char[8][e.length*6],t,u,h='|';; '-' can be 45; '^' can be 94; The space can be removed here: if(f>48) {; And I'm sure a lot more can be golfed, but it's a bit too much to go into more complex golfing. :)

Kevin and corvus: thanks, I'll take another go at it later when I have the time. I'm sure this can be dropped under 800, especially with a lambda.

Ruby 2.3.1, 777 752 bytes
Edit_0: I totally missed out on some golfable variable usage and some other stuff.
@o=Array.new;$*.each_with_index do|j,i|a,e,n,b,u,q,r,z,y=0,j[0].to_i,j[1].to_i,j[2].to_i,j[3].to_i,['°','¯','-','^',"'"],['v','w','o','_',"-"],Array.new(7," "),"     ";g,h=[z,["(#{q[e]}#{r[n]}#{q[e]})"," _|_ ","/[|]\\","  |  "," / \\ "],["     ","  ,  ","(#{q[e]}#{r[n]}#{q[e]})"]],[z,["     "," ^\"^ "],["  () ", "  ´` "],[" .|. "," :\": "]];2.times{h[3].unshift("  |  ")}unless b==1;if b<1 && u<1;@o.push(z);elsif b<1;u<3 ? (a=5):(a=3);a.times{h[u].push(y)};@o.push(h[u]);elsif u<1;b==1 ? (a=2):(a=4);a.times{g[b].unshift(y)};@o.push(g[b]);elsif u>0;2.times{h[u].push(y)}if u<3&&b>1;@o.push(h[u]+g[b]);end;@o.push(z);end;@o.transpose.each do|v|;v.each do |w|;print w;end;print"\n";end

Takes in N number of variables of decorations. There's certainly some more golfing that can be done with this. I'm not that familiar with a lot of Ruby's tricks, but here's a shot at it! I'm also happy at being able to solve it.
Un-golfed
@output = Array.new
$*.each_with_index do |j, i|
  # output decoration combo
  s = 0

  # set up vars for decoration input
  e = j[0].to_i
  n = j[1].to_i
  b = j[2].to_i
  u = j[3].to_i

  # Setup decorations/misc
  eyes = ['°','¯','-','^',"'"]
  nose = ['v','w','o','_',"-"]
  nothing = Array.new(7, " ")
  skeleton = ["(#{eyes[e]}#{nose[n]}#{eyes[e]})", " _|_ ", "/[|]\\", "  |  ", " / \\ "]
  pumpkin = ["     ", "  ,  ", "(#{eyes[e]}#{nose[n]}#{eyes[e]})"]
  fbat = ["     ", " ^\"^ "]
  rbat = ["  () ", "  ´` "]
  spider = ["  |  ", " .|. ", " :\": "]
  spider.unshift("  |  ") unless b == 1
  a = "     "
  bot = [nothing, skeleton, pumpkin]
  top = [nothing, fbat, rbat, spider]

  # if bottom and upper are empty
  if b < 1 && u < 1
    @output.push(nothing)
  # if bottom is empty
  elsif b < 1
    u < 2 ? (s = 3) : (s = 5)
    s.times {top[u].push(a)}
    @output.push(top[u])
  # if upper is empty
  elsif u < 1
    # put in white space before the decorations
    b == 1 ? (s = 2) : (s = 5)
    s.times {bot[b].unshift(a)}
    @output.push(bot[b])
  # if there's an upper decoration
  elsif u > 0
    # put in the top deco
    2.times {top[u].push(a)} if u < 3 && b > 1
    @output.push(top[u] + bot[b])
  end
  # Input the empty column
  @output.push(nothing)
end

# Transpose the array of arrays so that
# instead of outputting each line of a single each decoration
# what's output is each line of each decoration.
# Example:
# [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5]]
# [[1, 1, 1, 1, 1], [2, 2, 2, 2, 2], [3, 3, 3, 3, 3], [4, 4, 4, 4, 4], [5, 5, 5, 5, 5]]
@output.transpose.each do |data|
   data.each do |data1|
     print data1
   end
   print "\n"
end

The following:
ruby deco_g.rb 0000 0001 0002 0003 1110 1111 1112 1113 2220 2221 2222 2223 3310 3312 3321 3323

Outputs this:
          ()    |                 ()   .|.                ()    |           ()          |
   ^"^    ´`    |          ^"^    ´`   :":         ^"^    ´`    |           ´`   ^"^    |
               .|.  (¯w¯) (¯w¯) (¯w¯) (¯w¯)                    .|.  (^_^) (^_^)        .|.
               :":   _|_   _|_   _|_   _|_                     :":   _|_   _|_         :":
                    /[|]\ /[|]\ /[|]\ /[|]\                         /[|]\ /[|]\
                      |     |     |     |     ,     ,     ,     ,     |     |     ,     ,
                     / \   / \   / \   / \  (-o-) (-o-) (-o-) (-o-)  / \   / \  (^_^) (^_^)

Python 2, 331 bytes""
B,I,l,s=' '*5,'  |  ',' .|. ',' :": '
r=[]
for x in inputtt:m,n,b,u=(int(y)for y in x);e="°¯-^'"[m];H='('+e+"vwo_-"[n]+e+')';r+=[[[B,B,'  () ',[I,l,I][b]][u],[B,' ^"^ ','  ´` ',[I,s,I][b]][u],[[B,l][u==3],H][b==1],[[B,s][u==3],' _|_ '][b==1]]+[[B]*3,['/[|]\\',I,' / \ ',],[B,'  ,  ',H]][b]]
print'\n'.join(map(' '.join,zip(*r)))

Takes input as list of strings
-
Example
Input:
["1212","4321","0123","1102","0020","1010","0101","2113"]
Output:
  ()          |     ()                     .|.
  ´`   ^"^    |     ´`               ^"^   :":
(¯o¯)        .|.              (¯v¯)       (-w-)
 _|_         :":               _|_         _|_
/[|]\                         /[|]\       /[|]\
  |     ,     ,           ,     |           |
 / \  ('_') (°w°)       (°v°)  / \         / \

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
A Triangular Slice of Squared Pi
Inspired by Bake a slice of Pi
Challenge
Given input 3 <= n <= 100 and 3 <= y <= n, construct an n x n matrix of the decimal portion of pi (14159...), starting in the top left. Then, take the upper-right triangle of size y x y and concatenate it together. Output the resulting number.
For example, for input n = 5, y = 3, the following matrix is constructed
14159
26535
89793
23846
26433

Then, the upper-right 3 x 3 triangle would be
159
 35
  3

so 159353 is the output.
Input
Two integers -- n representing the size of the square matrix of the digits of pi, and y representing the upper-right triangle -- in any convenient format.
Output

The resulting sliced and concatenated number, either printed/displayed to the screen, returned as a string, etc.
Trailing/leading whitespace is optional, so long as there's no whitespace in the output (i.e., 159 35  3 or the like would be invalid).
Note that since we're explicitly looking for the digits of pi, and not an approximation or mathematical calculation, answers should not round the final digit of the matrix.

Rules

This is code-golf so all the usual rules for golfing apply, and the shortest code (in bytes) wins.
Either a full program or function are acceptable.
Standard loopholes are forbidden.

Examples
 n  y  output
-------------
 3  3  141923
 5  3  159353
 6  4  1592589383
 6  6  141592535893238643794
20 12  358979323846950288419715820974944628620899211706792306647223172745025559196615

Thanks. Also, can the last digit be rounded? Some answers seem to do that, and it could be really difficult to avoid it

@LuisMendo That's a good point. No, there should not be rounding of the last digit, since we're looking for the actual digits of pi, not an approximation or calculation. I'll clarify that and verify with the answerers.

05AB1E, 19 bytes
Uses CP-1252 encoding.
nžs¦¦¹ôI£íRvyN>£J}R

Try it online!
Explanation
n=5, y=3 used for example
nžs                  # push pi to n^2 digits
                     # STACK: 3.1415926535897932384626433
   ¦¦                # remove the first 2 chars
                     # STACK: 1415926535897932384626433
     ¹ô              # split into n*n matrix
                     # STACK: ['14159', '26535', '89793', '23846', '26433']
       I£            # keep the first y rows
                     # STACK: ['14159', '26535', '89793']
         íR          # reverse the list of rows and each individual row
                     # STACK: ['39798', '53562', '95141']
           v     }   # for each y,N (row, index) in the list
            yN>£J    # keep the first index+1 digits of the row and join to string
                     # STACK: 353951
                  R  # reverse the string
                     # STACK: 159353
                     # implicit print

Congrats for 10k!

Python 2 (with sympy), 100 bytes
from sympy import*
lambda n,y:''.join(c for i,c in enumerate(`pi.round(n*n+1)`[2:])if i%n-i/n>n-y-1)

No sympy, 260 246 244 233 231 218 bytes
p=lambda n,y,a=-30,b=10,c=3,d=2,e=0,f=5,s='',i=0:i<n*n and p(n,y,*[((2*b+a)*f,b*d,c*f,d+1,(b*(7*d)+2+(a*f))/(c*f),f+2,s,i),(10*(a-e*c),10*b,c,d,((10*(3*b+a))/c)-10*e,f,s+(str(e)[:i%n-i/n>n-y-1]),i+1)][4*b+a-c<e*c])or s

This employs "The Spigot Algorithm For Pi" of Stanley Rabinowitz and Stan Wagon.
The standard arguments would be a,b,c,d,e,f=0,1,1,1,3,3 to yield the first digit of pi, 3, since that is not required the algorithm is initialised to the point before 1 is yielded, which saves two bytes even though a and b are longer as the result does not require slicing and i can start at 0 rather than -1.
Hits default recursion limit for last test case
Uses // for the first of the divisions so that str(v) may be replaced by `v` (otherwise it would end in L for a long).
repl.it

A non-recursive version for 232 bytes which evaluates the last test case too:
def p(n,y):
 a,b,c,d,e,f,i,s=-30,10,3,2,0,5,0,''
 while i<n*n:
    if 4*b+a-c<e*c:s+=`e`[:i%n-i/n>n-y-1];g=10*(a-e*c);e=((10*(3*b+a))//c)-10*e;b*=10;i+=1
    else:g=(2*b+a)*f;h=(b*(7*d)+2+(a*f))/(c*f);b*=d;c*=f;f+=2;d+=1;e=h
    a=g
 print s

repl.it (first indent is one space, second indent is one tab)

That "no sympy" version is impressive :)

I added a link, it's not my algorithm!

...but if you want to "memorise" Pi to a million digits, this is probably easier

Mathematica, 82 bytes
Print@@Join@@Partition[RealDigits[Pi-3,10,#^2][[1]],#][[i,i-#2-1;;]]~Table~{i,#2}&

You can use #&@@ instead of [[1]].

@TimmyD Nope. It truncates. (n = 10, y = 10 gives 1415926535979323846433832798841971937510749448164899259; the last 9 is the 100th digit of pi, and the 101th digit is 8 -- no rounding)

MATL, 23 22 27 bytes
1 Byte saved thanks to @Luis
UtEYPwY$IbH+&:)GetGi-&R!g)!

Try it Online
Explanation
        % Implicitly grab input (n)
Ut      % Square n and duplicate
E       % Multiply n^2 by 2
YP      % Pi literal
w       % Flip the stack
Y$      % Compute the first 2 * (n^2) digits of pi (accounts for rounding)
IbH+&:) % Grab the first n^2 digits after the decimal
Ge      % Reshape it into an n x n matrix in row-major ordering
t       % Duplicate this matrix
Gi-     % Grab the second input (y) and compute the difference between n and y
&R!     % Get the upper diagonal part and transpose to convert to lower diagonal
g)      % Convert it to a logical array and use it to select the digits of interest
!       % Transpose the result and implicitly display

@LuisMendo Ah! I knew we had a function for that but couldn't find it. Thanks!

@TimmyD  Thanks for noticing. Updated.

Perl, 67 bytes
s/ /bpi++$_**2/e;$%=$';$%-=print/(.{$%})$/ for/\d{$`}/g

Requires the command line option -nMbignum=bpi, counted as 12. Input is taken from stdin.
Sample Usage
$ echo 3 3 | perl -nMbignum=bpi primo-square-pi.pl
141923

$ echo 5 3 | perl -nMbignum=bpi primo-square-pi.pl
159353

$ echo 6 4 | perl -nMbignum=bpi primo-square-pi.pl
1592589383

$ echo 6 6 | perl -nMbignum=bpi primo-square-pi.pl
141592535893238643794

$ echo 20 12 | perl -nMbignum=bpi primo-square-pi.pl
358979323846950288419715820974944628620899211706792306647223172745025559196615

C#, 232 bytes 268 bytes
Edit:
I originally used a constant string for Pi outside of the method, but it seems this was cheating. I've had to use the C# Math.PI value, which only has 14 decimal places, so the highest m value I can use is 3. Back to the drawing board...
Golfed:
IEnumerable<string>f(int m,int t){var a=new string[m, m];var b=Math.PI.ToString().Replace("3.","").Substring(0,m*m).ToArray();var c=0;for(int i=0;i<m;i++){for(int j=0;j<m;j++){a[i, j]=b[c]+"";c++;}}c=0;while(t>0){for(int i=t;i>0;i--){yield return a[c,m-i];}t--;c++;}}}

Ungolfed:
  class ATriangularSliceOfSquaredPi
  {
    //http://www.piday.org/million/
    //const string p = "1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831";

    public IEnumerable<string> f(int m, int t)
        {
          var a = new string[m, m];

          //var b = p.Substring(0, m * m).ToArray();
          var b = Math.PI.ToString().Replace("3.", "").Substring(0, m * m).ToArray();

          var c = 0;

          for (int i = 0; i < m; i++)
          {
            for (int j = 0; j < m; j++)
            {
              a[i, j] = b[c] + "";
              c++;
            }
          }

          c = 0;

          while (t > 0)
          {
            for (int i = t; i > 0; i--)
            {
              yield return a[c, m - i];
            }
            t--;
            c++;
          }
        }
      }

Not the shortest answer, but I was just happy I solved this one...
Test Output:
m   t   output
3   3   141923

5  3   159353
6   4   1592589383
6   6   141592535893238643794
20  12 358979323846950288419715820974944628620899211706792306647223172745025559196615

Nice answer! Sadly, if you're using p and it's not a built-in in the language (which I'm pretty sure it isn't), you'll need to include that in your byte score.

@TimmyD Oh no! Ok, leave it with me!! If I simply paste my pi numbers in that will require 400+ more bytes, so I think a different approach is required... :)

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
World Time Conversion
World Time Conversion
Challenge:
Given an initial clock time in UTC and a list of countries: for each country in the list, output the local time it is in that country based on the initial time.  In cases where a country is big enough to have multiple local time zones (like the United States), you may output any valid local time for that country, provided you state which time zone you are using (i.e. for United States, EST for Eastern Standard Time).  You do not have to worry about daylight savings time.
Input:
The current time, in UTC, followed by a list of countries.  The format of the input time can be given in any way (12 or 24 hour, with or without seconds, etc), and the countries can all be on the same line or on new lines after the time, your choice.  You may also use any characters to delimit the countries (space, comma, etc.).  You may choose to take a list of country -> timezone in as input, in which case I would prefer a common list be used across all answers, found here.  This part can be excluded from your byte count.
Output:
The local time in each country from the input list.  Once again, you may use any characters or newline to delimit the times for each country so long as it is easy to tell one time from another.  However, unlike the input, the times must be output in a 12 hour format (so there must be an AM/PM indication).  Other than that, you may express the digits in the time in any format (i.e. leading 0's for hours that are single digits, with or without seconds/milliseconds) as long as the character that is used to separate hours and minutes is different than the character that is used to separate the different times.  I would prefer if a date was not included in the answer since this is a challenge dealing specifically with different times.
Examples:
Input 1:
12:00 AM [United States]

Output 1:
7:00 PM EST (or any other time zone with the appropriate time)

Input 2:
12:00 PM [United States, Italy, Russia]

Output 2:
4:00 AM PST, 2:00 PM, 3:00 PM MSK

Rules:
This is code-golf, so shortest code in bytes wins.  Standard loopholes are forbidden.
Common list of country -> timezone:
// Format:  <country>,<UTC offset>,<time-zone abbreviation>
// You may use any alternate format or any other UTC/abbreviation for a country for those that have more than one zone
France,1,CET
United States,-5,EST
Russia,3,MSK
United Kingdom,0,UTC
Australia,10,AEST
Canada,-5,EST
Kingdom of Denmark,1,CET
New Zealand,12,NZST
Brazil,-3,BRT
Mexico,-6,MDT
Indonesia,7,WIST
Kiribati,12,LINT
Chile,-3,CLT
Democratic Republic of the Congo,1,WAT
Ecuador,-5,ECT
Federated States of Micronesia,11,KOST
Kazakhstan,6,ALMT
Kingdom of the Netherlands,1,CET
Mongolia,8,ULAT
Papua New Guinea,10,AEST
Portugal,0,WET
South Africa,2,SAST
Spain,1,CET
Afghanistan,4.5,AFT
Albania,1,CET
Algeria,1,CET
Andorra,1,CET
Angola,1,WAT
Antigua and Barbuda,-4,AST
Argentina,-3,ART
Armenia,4
Austria,1,CET
Azerbaijan,4
Bahamas,-5,EST
Bahrain,3
Bangladesh,6,BDT
Barbados,-4
Belarus,3,FET
Belgium,1,CET
Belize,-6
Benin,1,WAT
Bhutan,6,BTT
Bolivia,-4
Bosnia and Herzegovina,1,CET
Botswana,2,CAT
Brunei,8
Bulgaria,2,EET
Burkina Faso,0,UTC
Burundi,2,CAT
Cambodia,7
Cameroon,1,WAT
Cape Verde,-1,CVT
Central African Republic,1,WAT
Chad,1,WAT
China,8,CST
Colombia,-5
Comoros,3,EAT
Republic of the Congo,1,WAT
Costa Rica,-6
Croatia,1,CET
Cuba,-5
Cyprus,2,EET
Czech Republic,1,CRT
Djibouti,3,EAT
Dominica,-4
Dominican Republic,-4
East Timor,9
Egypt,2,EET
El Salvador,-6
Equatorial Guinea,1,WAT
Eritrea,3,EAT
Estonia,2,EET
Ethiopia,3,EAT
Fiji,12
Finland,2,EET
Gabon,1,WAT
Gambia,0,GMT
Georgia,4
Germany,1,CET
Ghana,0,GMT
Greece,2,EET
Grenada,-4
Guatemala,-6
Guinea,0,GMT
Guinea-Bissau,0,GMT
Guyana,-4
Haiti,-5
Honduras,-6
Hong Kong,8,HKT
Hungary,1,CET
Iceland,0,GMT
India,5.5,IST
Iran,3.5,IRST
Iraq,3
Ireland,0,WET
Israel,2,IST
Italy,1,CET
Ivory Coast,0,GMT
Jamaica,-5
Japan,9,JST
Jordan,2
Kenya,3,EAT
North Korea,8.5,PYT
South Korea,9,KST
Kuwait,3,AST
Kosovo,1
Kyrgyzstan,6
Laos,7
Latvia,2,EET
Lebanon,2,EET
Lesotho,2
Liberia,0,GMT
Libya,2,EET
Liechtenstein,1,CET
Lithuania,2,EET
Luxembourg,1,CET
Macau China,8,CST
Macedonia,1,CET
Madagascar,3,EAT
Malawi,2,CAT
Malaysia,8,MYT
Maldives,5
Mali,0,GMT
Malta,1,CET
Marshall Islands,12
Mauritania,0,GMT
Mauritius,4,MUT
Moldova,2,EET
Monaco,1,CET
Montenegro,1,CET
Morocco,0,WET
Mozambique,2,CAT
Myanmar,6.5,MST
Namibia,1,WAT
Nauru,12
Nepal,5.75,NPT
Nicaragua,-6
Niger,1,WAT
Nigeria,1,WAT
Norway,1,CET
Oman,4
Pakistan,5,PKT
Palau,9
Panama,-5
Paraguay,-4
Peru,-5,PET
Philippines,8,PHT
Poland,1,CET
Qatar,3,AST
Romania,2,EET
Rwanda,2,CAT
Saint Kitts and Nevis,-4
Saint Lucia,-4
Saint Vincent and the Grenadines,-4
Samoa,13
San Marino,1,CET
São Tomé and Príncipe,0,GMT
Saudi Arabia,3,AST
Senegal,0,GMT
Serbia,1,CET
Seychelles,4,SCT
Sierra Leone,0,GMT
Singapore,8,SST
Slovakia,1,CET
Slovenia,1,CET
Solomon Islands,11
Somalia,3,EAT
South Sudan,3,EAT
Sri Lanka,5.5,SLST
Sudan,3,EAT
Suriname,-3
Swaziland,2
Sweden,1,CET
Switzerland,1,CET
Syria,2,EET
Taiwan,8
Tajikistan,5,
Tanzania,3,EAT
Thailand,7,THA
Togo,0,GMT
Tonga,13
Trinidad and Tobago,-4
Tunisia,1,CET
Turkey,2,EET
Turkmenistan,5
Tuvalu,12
Uganda,3,EAT
Ukraine,2,EET
United Arab Emirates,4
Uruguay,-3
Uzbekistan,5,UZT
Vanuatu,11,
Vatican City,1,CET
Venezuela,-4
Vietnam,7,ICT
Yemen,3
Zambia,2,CAT
Zimbabwe,2,CAT

very close to this question, the difference is the "convert country name to timezone" part

@Rod Yeah, I mentioned I found that in my sandbox post, but people didn't comment on it.

This "list of country -> timezone" - do you have a compiled version? The Wikipedia article has entries like "French Polynesia" in the section for France.

@JonathanAllan I don't, I was going to leave it up to people as to how they wanted to set it up/format it.

So can "AM" just be "A" and "PM" just be "P"?

@JonathanAllan I suppose that is fine, still gets the message across.

@Yodle What if a country spans multiple time zones is there a preference to which?

@carusocomputing It specifies that in the question

@Yodle Ah, missed that. Can you use the Wikipedia API to load the inputs? Do you have to handle all countries?

@carusocomputing You can get the list anyway you want, and I would prefer being able to handle every country in case I want to travel somewhere new!

@Yodle Ah, so just to clarify, the instantiation of the dictionary of countries is not included in byte count? May want to put that in the brief, other than that this is a cool challenge.

@carusocomputing See the edit, and thanks :)

I think we need an authoritative list of countries/time zones to be able to make any objective comparisons between answers.

@RobertFraser Okay, I will work on compiling one when I am home.

@Yodle You can slice and dice the one in my answer, if you want.

Do we need to explicitly output the time zone information as well? (EST, etc.) Or is just the time output OK?

@TimmyD I would like the timezone information included if the country has more than one timezone.  And thanks, I'll probably use your list and make more general.  Pastebin links are allowed in posts right?

@Yodle Fixed. As far as I'm aware, Pastebin is OK if it doesn't fit in the challenge. Ideally, challenges should be self-contained.

I've updated the post with a list of country -> timezone.

PowerShell v3+, 71 bytes
param($a,$b,$x)$b|%{$y=$x[$_];"{0:t} $($y[1])"-f(date $a).AddHours($y[0])}

(74 bytes, -3 bytes for input ,$x, the dictionary of country->timezone conversions, equals 71 bytes)
Uses the below dictionary/hashtable for the timezone conversion, which I manually created (with some creative Excel, PowerShell, and Ctrl-H help) based on the Wikipedia link.
$x=@{'France'=(1,'CET');'United States'=(-5,'EST');'Russia'=(3,'Moscow');'United Kingdom'=(0,'UTC');'Australia'=(10,'AEST');'Canada'=(-5,'EST');'Kingdom of Denmark'=(1,'CET');'New Zealand'=(12,'NZST');'Brazil'=(-3,'BRT');'Mexico'=(-6,'Zona Centro');'Indonesia'=(7,'WIST');'Kiribati'=(12,'Gilbert');'Chile'=(-3,'CLT');'Democratic Republic of the Congo'=(1,'WAT');'Ecuador'=(-5,'Ecuador Time');'Federated States of Micronesia'=(11,'Kosrae');'Kazakhstan'=(6,'Almaty');'Kingdom of the Netherlands'=(1,'CET');'Mongolia'=(8,'Ulaanbaatar');'Papua New Guinea'=(10,'AEST');'Portugal'=(0,'WET');'South Africa'=(2,'SAST');'Spain'=(1,'CET');'Afghanistan'=(4.5,'Afghanistan');'Albania'=(1,'CET');'Algeria'=(1,'CET');'Andorra'=(1,'CET');'Angola'=(1,'WAT');'Antigua and Barbuda'=(-4,'AST');'Argentina'=(-3,'ART');'Armenia'=(4,'');'Austria'=(1,'CET');'Azerbaijan'=(4,'');'Bahamas'=(-5,'EST');'Bahrain'=(3,'');'Bangladesh'=(6,'BDT');'Barbados'=(-4,'');'Belarus'=(3,'FET');'Belgium'=(1,'CET');'Belize'=(-6,'');'Benin'=(1,'WAT');'Bhutan'=(6,'BTT');'Bolivia'=(-4,'');'Bosnia and Herzegovina'=(1,'CET');'Botswana'=(2,'CAT');'Brunei'=(8,'');'Bulgaria'=(2,'EET');'Burkina Faso'=(0,'UTC');'Burundi'=(2,'CAT');'Cambodia'=(7,'');'Cameroon'=(1,'WAT');'Cape Verde'=(-1,'CVT');'Central African Republic'=(1,'WAT');'Chad'=(1,'WAT');'China'=(8,'Chinese Standard Time');'Colombia'=(-5,'');'Comoros'=(3,'EAT');'Republic of the Congo'=(1,'WAT');'Costa Rica'=(-6,'');'Croatia'=(1,'CET');'Cuba'=(-5,'');'Cyprus'=(2,'EET');'Czech Republic'=(1,'CRT');'Djibouti'=(3,'EAT');'Dominica'=(-4,'');'Dominican Republic'=(-4,'');'East Timor'=(9,'');'Egypt'=(2,'EET');'El Salvador'=(-6,'');'Equatorial Guinea'=(1,'WAT');'Eritrea'=(3,'EAT');'Estonia'=(2,'EET');'Ethiopia'=(3,'EAT');'Fiji'=(12,'');'Finland'=(2,'EET');'Gabon'=(1,'WAT');'Gambia'=(0,'GMT');'Georgia'=(4,'');'Germany'=(1,'CET');'Ghana'=(0,'GMT');'Greece'=(2,'EET');'Grenada'=(-4,'');'Guatemala'=(-6,'');'Guinea'=(0,'GMT');'Guinea-Bissau'=(0,'GMT');'Guyana'=(-4,'');'Haiti'=(-5,'');'Honduras'=(-6,'');'Hong Kong'=(8,'HKT');'Hungary'=(1,'CET');'Iceland'=(0,'GMT');'India'=(5.5,'IST');'Iran'=(3.5,'IRST');'Iraq'=(3,'');'Ireland'=(0,'WET');'Israel'=(2,'IST');'Italy'=(1,'CET');'Ivory Coast'=(0,'GMT');'Jamaica'=(-5,'');'Japan'=(9,'JST');'Jordan'=(2,'');'Kenya'=(3,'EAT');'North Korea'=(8.5,'Pyongyang');'South Korea'=(9,'KST');'Kuwait'=(3,'AST');'Kosovo'=(1,'');'Kyrgyzstan'=(6,'');'Laos'=(7,'');'Latvia'=(2,'EET');'Lebanon'=(2,'EET');'Lesotho'=(2,'');'Liberia'=(0,'GMT');'Libya'=(2,'EET');'Liechtenstein'=(1,'CET');'Lithuania'=(2,'EET');'Luxembourg'=(1,'CET');'Macau (China)'=(8,'Macau');'Macedonia'=(1,'CET');'Madagascar'=(3,'EAT');'Malawi'=(2,'CAT');'Malaysia'=(8,'Malaysia');'Maldives'=(5,'');'Mali'=(0,'GMT');'Malta'=(1,'CET');'Marshall Islands'=(12,'');'Mauritania'=(0,'GMT');'Mauritius'=(4,'Mauritius');'Moldova'=(2,'EET');'Monaco'=(1,'CET');'Montenegro'=(1,'CET');'Morocco'=(0,'WET');'Mozambique'=(2,'CAT');'Myanmar'=(6.5,'MST');'Namibia'=(1,'WAT');'Nauru'=(12,'');'Nepal'=(5.75,'Nepal');'Nicaragua'=(-6,'');'Niger'=(1,'WAT');'Nigeria'=(1,'WAT');'Norway'=(1,'CET');'Oman'=(4,'');'Pakistan'=(5,'PKT');'Palau'=(9,'');'Panama'=(-5,'');'Paraguay'=(-4,'');'Peru'=(-5,'PET');'Philippines'=(8,'PHT');'Poland'=(1,'CET');'Qatar'=(3,'AST');'Romania'=(2,'EET');'Rwanda'=(2,'CAT');'Saint Kitts and Nevis'=(-4,'');'Saint Lucia'=(-4,'');'Saint Vincent and the Grenadines'=(-4,'');'Samoa'=(13,'');'San Marino'=(1,'CET');'São Tomé and Príncipe'=(0,'GMT');'Saudi Arabia'=(3,'AST');'Senegal'=(0,'GMT');'Serbia'=(1,'CET');'Seychelles'=(4,'Seychelles');'Sierra Leone'=(0,'GMT');'Singapore'=(8,'SST');'Slovakia'=(1,'CET');'Slovenia'=(1,'CET');'Solomon Islands'=(11,'');'Somalia'=(3,'EAT');'South Sudan'=(3,'EAT');'Sri Lanka'=(5.5,'SLST');'Sudan'=(3,'EAT');'Suriname'=(-3,'');'Swaziland'=(2,'');'Sweden'=(1,'CET');'Switzerland'=(1,'CET');'Syria'=(2,'EET');'Taiwan'=(8,'');'Tajikistan'=(5,'');'Tanzania'=(3,'EAT');'Thailand'=(7,'THA');'Togo'=(0,'GMT');'Tonga'=(13,'');'Trinidad and Tobago'=(-4,'');'Tunisia'=(1,'CET');'Turkey'=(2,'EET');'Turkmenistan'=(5,'');'Tuvalu'=(12,'');'Uganda'=(3,'EAT');'Ukraine'=(2,'EET');'United Arab Emirates'=(4,'');'Uruguay'=(-3,'');'Uzbekistan'=(5,'Uzbekistan');'Vanuatu'=(11,'');'Vatican City'=(1,'CET');'Venezuela'=(-4,'');'Vietnam'=(7,'Indochina');'Yemen'=(3,'');'Zambia'=(2,'CAT');'Zimbabwe'=(2,'CAT')}

Takes input $a as a string in 24hr format, $b as an explicit array of strings, and the dictionary $x. Loops through $b, and for each creates a new Date based on $a, then calls .AddHours, indexing into the dictionary to determine how many, and uses the -format operator to pull out the correct information.
Example
PS C:\Tools\Scripts\golfing> .\world-time-conversion.ps1 '12:00' @('United States','Italy','Russia','Nepal') $x
7:00 AM EST
1:00 PM CET
3:00 PM Moscow
5:45 PM Nepal

Python 2, 154 153 151 148 147 138 134 131 123 121 116 bytes
-4 bytes thanks to @Shebang (missed a div // to / Py3 -> Py2 conversion; print time zone using unpacking; use map to replace two int casts)
def f(t,c,d):
 for x in c:a,b=map(int,t.split(':'));e,z=d[x];v=60*a+b+e;print`v/60%12`+':'+`v%60`,'pa'[v%1440<720],z

repl.it (I only bothered with a tiny subset of countries, as that's a chore and I'm lazy - but I included Nepal to have a non-standard offset in there & Tuvalu with it's +12:00 one).
Input is t the time string in 24 hr format; c the list of countries; and d a dictionary of country string to tuple of minutes offset and time zone name.
Prints a 12hr format plus time zone for each country split by new lines. Leading zeros are not printed AM/PM indicator is just a/p (e.g. 08:06 in Nepal prints as 8:6 a Nepal Time)

Hehe, repl.it/Dvck... Quack xD

So cloooooose :)

@Shebang Oops - yeah - I always write in Python 3 and then move over! Thanks

Also, you can save another three bytes here: %s'%(v/60%12,v%60,'PA'[v<720],z) to '%(v/60%12,v%60,'PA'[v<720]),z (remove the space in front of the last %s as well)

And another byte by doing t=map(int,t.split(':')) and removing the int casts in the next section.

I'd counted map as equal in length to int and disregarded doing that heh.

Nepal is like that kid in middle school who needs special attention for everything. Flag isn't rectangular, time zone offset is all wrong...

@BetaDecay Duck points to an C++ hello world example instead... what a waste :(

@RobertFraser Highest mountain in the world etc.

bash (126 bytes)
w(){ cd /u*/sh*/z*
join -o2.2 <(egrep "$2" i*) <(cut -sf1,3 zone.*)|while read z
do TZ=$z date -d"UTC$1" +"%z %r";done|uniq;}
w 12:00PM "United States|Italy|Russia"

uses GNU date and file:/usr/share/zoneinfo/{iso3166,zone}.tab


text:
Determine if a coin system is Canonical
The Cashier's Algorithm is an algorithm for making change in the minimal number of coins that works quite well for most currency systems.  However like most greedy algorithms it is not without its flaws.  If a currency system is set up just right (or just wrong) there are certain values in which the Cashier's Algorithm will fail to find the optimal change.
Take the following example:
We have 4¢, 3¢, and 1¢ coins.  We want to make 6¢.
The Cashier's Algorithm will first select as many of the largest coin (one 4¢ to start) and subtract and repeat.  This will result in one 4¢ coin and two 1¢ coins, for a total of 3 coins.
Unfortunately for the Algorithm there is a way to make 6¢ with only two coins (two 3¢ coins).
A system of change will be considered canonical iff for all integer values the Cashier's Algorithm will find the optimal number of coins.
Task
You task will be to take a system as a either an unordered container or sorted ordered container of integers representing coin values and output a truthy value if the system input is canonical and falsy otherwise.
Your program should work for all systems that can create any value.  (i.e. all systems will have a 1¢ coin)
This is code golf least bytes wins.
Test cases
This list is by no means exhaustive, your program should work for all valid input
1, 3, 4       -> 0
1, 5, 10, 25  -> 1
1, 6, 10, 25  -> 0
1, 2, 3       -> 1
1, 8, 17, 30  -> 0
1, 3, 8, 12   -> 0
1, 2, 8, 13   -> 0
1, 2, 4, 6, 8 -> 1

@Geobits not in every case it means more that the difference growing or equal from the smallest coin to the largest

@JörgHülsermann That's not really good enough either. [1, 6, 13] has a growing difference, but it still fails on something like 18 (13+15 instead of 63).

These are called Canonical Coin Systems. This short paper gives a polynomial-time algorithm for checking whether a coin system is canonical (though a less efficient method might be golfier). An interesting test case is making 37 cents from 25, 9, 4, 1 (from this math.SE post) -- even though each coin is bigger than the sum of the smaller ones, the non-greedy 25, 4, 4, 4 beats the greedy 25, 9, 1, 1, 1.

@xnor Note that 9, 4, 1 -> 4, 4, 4 being better than 9, 1, 1, 1 is a tighter example.

Haskell, 94 87 82 bytes
f s=and[j i-2<j(i-x)|let j i=last$0:[1+j(i-x)|x<-s,x<i],i<-[1..2*last s],x<-s,x<i]

this solution works by defining a function j which perform's the cashier's algorithm and tells us how many coins the cashier used. we then check up to twice the biggest number in the list, assuming that the system has been canonical for all previous numbers, that taking the biggest possible coin is the right choice.
this solution assumes the input is sorted.
proof checking up to twice the biggest number is enough:
assume that the system is not canonical for some number i, and let k be the biggest number in the list not bigger than i. assume that i >= 2k and the system is canonical for all numbers less than i.
take some optimal way to make i out of coins, and assume it doesn't contain the coin k. if we throw away one of the coins, the new sum of coins must be bigger than k and smaller than i - but the cashier's algorithm on this number would use the k coin - and therefore, this set of coins can be replaced with an equal set of coins containing the coin k, and therefore there is a set of coins containing the coin k for the number i, and by induction the cashier's algorithm returns the optimal choice.
this argument really shows that we only need to check until the sum of the two biggest elements - but it is lengthier to do so.
Edit: five bytes off thanks to Ørjan Johansen!

You can save a byte by using let instead of where. You can either put it as a |let ... pattern guard after f s, or inside the list comprehension.

Another four bytes with j i=last$0:[1+j(i-k)|k<-s,k<i].

PHP, 323 Bytes
Same way as other count the coins until the sum of the two last elements in the array
<?function t($g){rsort($g);$m=array_slice($g,1);for($y=1,$i=$g[0];$i<$g[0]+$m[0];$i++){$a=$b=$i;$p=0;$r=$s=[];while($a||$b){$o=$n=0;$g[$p]<=$a?$a-=$r[]=$g[$p]:$o=1;($m[$p]??1)<=$b?$b-=$s[]=$m[$p]:$n=1;$p+=$o*$n;}$y*=count($r)<=count($s);}return$y;}for($i=0,$t=1;++$i<count($a=$_GET[a]);)$t*=t(array_slice($a,0,$i+1));echo$t;

My best and longest answer I believe >370 Bytes
I give only an expanded version cause it is longer then my answer before
for($x=1,$n=0,$f=[];++$n<count($a)-1;){
$z=array_slice($a,0,$n+1);
$q=$a[$n]-$a[$n-1];
$i=array_fill(1,$c=max($a[$n+1]??1,11),"X");#$q*$a[$n]
$f=range($a[$n],$c,$q);

$f[]=2*$a[$n];
for($d=[$z[$n]],$j=0;$j<$n;){
   $f[]=$a[$n]+$d[]=$z[$n]-$z[$j++];
}

while($f){
    $i[$t=array_pop($f)]="T";
    foreach($d as $g)
    if(($l=$t+$g)<=$c)$f[]=$l;
}

foreach($i as$k=>$v){
    if(in_array($k,$z))$i[$k]="S";
}
#var_dump($i);
if($i[$a[$n+1]]=="X")$x*=0;
}
echo$x;

Explanation for this answer
Online Version

Set all in the array to false == X
Set all numbers in the array you control to S
Found differences between the last S and the other S or 0
Start at last S in the array
Set all number to D Where Last S+ one of all differences
Begin at all D
SET "T" to D values in the array
GOTO 5 Repeat it with all found D I did it not really in the code
If next item in the Array has X it is a false case else True

Additional Steps
Difference is in the case in the snippet 3
Between 1 and 4 are 2 X
This means you need the second D by Step 5. After this value in this case 10 are all cases true
I could see so far that there is a relationship between difference and the count in the array you control to calculate how much D (Step 5) you need to get the point before you find the last false case.
You set multiple values from the last item directly to true.
These Points can make a difference to decide if it could been that the greedy count of coins with the next value is same then the multiple of the last in the array.
On the other way you can set enemy

Set first enemy at 1+Last S
From this Point add each value in the array to set the next enemies
Start with last enemy Goto 2

If you now have enemies and true cases in it the
probability grows that the counts can be the same
With more D the probability sinks.

table{width:80%}
td,th{width:45%;border:1px solid blue;}

Working [1,4]

Number	Status

1	S

2	X

3	X

4	S

5	X

6	X

7	D3

8	D4

9	X

10	D3D3

11	D4D3

12	D4D4

13	D3D3D3

14	D4D3D3

15	D4D4D4

16	D4D4D3

S Number in Array

D Start|End point TRUE sum Differences from last S

X False

plus ? Bytes Thank You @JonathanAllan to give me wrong test cases
262 Bytes
Nearly but not good enough 4 wrong testcase in the moment
test cases [1,16,256] before should true after false
<?for($q=[1],$i=0,$t=1,$w=[0,1];++$i<count($a=$_GET[v]);$w[]=$a[$i],$q[]=$m)($x=$a[$i]-$a[$i-1])>=($y=$a[$i-1]-$a[$i-2])&&((($x)%2)==(($m=(($a[$i]+$x)*$a[$i-1])%$a[$i])%2)&&$m>array_sum($q)||(($x)%2)==0&&(($a[$i]-$a[$i-2])*2%$y)==0||in_array($m,$w))?:$t=0;echo$t;

Ascending Order of the Array
Explanation
for($q=[1],$i=0,$t=1,$w=[0,1] # $t true case $q array for modulos $w checke values in the array
;++$i<count($a=$_GET[v])   #before loop
;$w[]=$a[$i],$q[]=$m) # after loop $q get the modulo from the result and fill $w with the checked value

($x=$a[$i]-$a[$i-1])>=($y=$a[$i-1]-$a[$i-2])
# First condition difference between $a[i] and $a[$i-1] is greater or equal $a[$i-1] and $a[$i-2]
# if $a[$-1] == 1 $a[$i-2] will be interpreted as 0
&&  ## AND Operator with the second condition
(
(($x)%2)==   # See if the difference is even or odd
(($m=(($a[$i]+$x)*$a[$i-1])%$a[$i])%2)&&$m>array_sum($q)
# After that we multiply the result with the lower value *$a[$i-1]
    # for this result we calculate the modulo of the result with the greater value %$a[$i]
    # if the difference and the modulo are both even or odd this belongs to true
# and the modulo of the result must be greater as the sum of these before
    # Ask me not why I have make try and error in an excel sheet till I see this relation
||
(($x)%2)==0&&(($a[$i]-$a[$i-2])*2%$y)==0 # or differce modulator is even and difference $a[$i],$a[$i-1] is a multiple of half difference $a[$i-1],$a[$i-2]
||
in_array($m,$w) # if the modulo result is equal to the values that we have check till this moment in the array we can also neglect the comparison
)
?:$t=0; # other cases belongs to false
echo$t; #Output

It looks like that what I have seen
the table contains values from [1,2,3,4,5,6] and I change only the last item until 9. for 2to3 and 4to5 we create the value of the lower value in the modulo calculation

table{width:95%;}th,td{border:1px solid}

difference		1	1	1	1	1

difference modulo 2		1	1	1	1	1

value	1	2	3	4	5	6

result		3	8	15	24	35

modulo value great		1	2	3	4	5

modulo 2		1	0	1	0	1

difference		1	1	1	1	2

difference modulo 2		1	1	1	1	0

value	1	2	3	4	5	7

result		3	8	15	24	45

modulo value great		1	2	3	4	3

modulo 2		1	0	1	0	1

difference		1	1	1	1	3

difference modulo 2		1	1	1	1	1

value	1	2	3	4	5	8

result		3	8	15	24	55

modulo value great		1	2	3	4	7

modulo 2		1	0	1	0	1

difference		1	1	1	1	4

difference modulo 2		1	1	1	1	0

value	1	2	3	4	5	9

result		3	8	15	24	65

modulo value great		1	2	3	4	2

modulo 2		1	0	1	0	0

Why do you split on ", " when you could split on ","; why do you split when you could take a list; why do you sort when you could take a sorted list? (I am also still unsure if the method you are using is infallible, have you a proof, because the literature I have skimmed through seems to suggest it is harder than what I think your code is doing.)

@JörgHülsermann Sorry if I have caused any confusion, although it was different before you can now take a sorted list if you so choose.

I'm afraid I think you'd have to test more than just mod 2 on the differences, as an example [1,2,5,11,17] is canonical. Maybe have a look at the paper linked in my answer.

...and just to confirm it with proud haskeller's code rather than mine: http://ideone.com/C022x0

@WheatWizard is [1,2,5,11,17] true or false?

@JörgHülsermann I believe that it is True.

@JörgHülsermann Yes that is correct. It is not canonical iff there is a smaller non-greedy solution.

@JonathanAllan The next wrong test case please. I have remember me it the differences are equal I must not consider the other condition

How about  [1,2,5,13,21]?

@JonathanAllan I found something more relationship but could not manage all test cases

The underlying problem is a variation of the knapsack problem which  is NP-complete (and optimisation NP-hard) - I think search and check is going to be the only way that works. Would have been cool if you had found a way!

@JonathanAllan I have make an other approach. I believe really that it will be you surprise much. And its working great.

i searched the difference between my results and your result some time ago, the only difference are [Can=Min mean canonical r=1] r=1 BUG# Can=Min [1 5 10 33]£ r=1 BUG# Can=Min [1 5 10 34]£ r=1 BUG# Can=Min [1 2 5 11 21 47]£ r=1 BUG# Can=Min [1 2 5 11 21 47 99]£ r=0 BUG# Can=5 Min=4 01+05+410+032=40=40 [1 5 10 32]$ r=0 BUG# Can=3 Min=2 01+03+011+219+0*32=38=38 [1 3 11 19 32]£ it is a little difficult find the routine that find min from no code and without use nested loop and possible that function is bugged and not find the right min...

@RosLuP 1 [1,5,10,33]
1 [1,5,10,34]
1 [1,2,5,11,21,47]
1 [1,2,5,11,21,47,99]
0 [1,5,10,32]
0 [1,3,11,19,32] should been the right results. Without loops. I have now found how you must use the differences right. Now I can make another approach to subtract from the value I will control

@JonathanAllan Now I believe really that you can't find false cases with the build of differences from the last value until the value that you will control. It was many search and try and error. 2 nearly ways which I have try before give only some false answers because it was not from the beginning to see that we must use all differences. sometimes the use of a few differences lead to a right result.

In my home made 'solution' below: if exist s=ka[j] for some j or s=a[j]+a[j+1]...+a[j+k] for some k and j with that s has canonical sum with more element than k => a[0..n] is not canonical. Else I consider it canonical (even if I can not dimostrate this last else proposition I have done some random test and not find contro example: one not canonical a[0..n] that not has any s with s=ka[j]or s=a[j]+a[j+1]...+a[j+k] where s is build with canonical algo with a sum of number elements > k

@RosLuP If understand you right you could not believe that the way with differences work? Maybe for understand better that it works this link help. http://sandbox.onlinephpfunctions.com/code/7785d671817ff1d5e8f56cfc31fbf03326a14aa1 Short explain get differences down from the number you control to the last number before. search for differences in this form use the largest difference if you has use it you can also use the next largest difference and so on. If you found differences you are canonical

I say just it seems I find property characterize a[0..n] canonical doing some operation only on a[i] (something not exponential perhaps O(n^2)) Possibly with your differences property is ok and my property are not ok... In general I'm not too smart, some time I see something with intuition. In your situation i  wrote one function for find the min number element if one has a[0..n] and a sum s and a test with that function against the other function; this for you can be easy it would enough test your function again (or with)  some other solution in this page with 1000 random array random Len...

@RosLuP It is hard to find right ways cause it depends not only of one vaue in the array. I have think before that only a few differences have a role not all. Now I am sure that all differences have a role in the calculating. And for thinking may assume there is always a zero in the array

For me we need an extensive search with random array for find contro example and think how adjust them: If we adjust all them end ok, there is a chance it return always the right number (the final prove would be the mathematical demonstration of that, but I would not know how)

@RosLuP I think why should I do the work of mathematicians. I can't find a wrong case with my way with the differences and can it do in two ways.

Pyth, 18 15 bytes
!x#eST.gsky_S*e

Test suite
A different sort of brute force. This starts by forming all collections of coins with up to k of each, where k is the largest coin, which is assumed to be the last coin. I believe this always sufficient to form two sets of coins with the same sum, one greedy and one shorter, whenever such a pair exists.
I then locate such a pair as follows:
The subsets are generated in order of increasing size, and lexicographically by position in the input secondarily. Group the coin collections by their sums, stably. Each coin collection is generated in descending order, so the greedy solution will be the first element of the group if and only if the greedy solution is optimal, and it will be the last element of the group lexicographically. Thus, we find the greedy solution, and filter on a nonzero index in the group. If the coin set is cannonical, this will filter out everything, so we simply logically negate the result and output.
Explanation:
!x#eST.gsky_S*e
!x#eST.gsky_S*eQQ   Variable introduction.
                    Q = eval(input()) - sorted list of coins.
              eQ    Greatest coin in the list
             *  Q   Repeat that many times.
            S       Sort the coins
           _        Reverse, so we have the coins in descending order.
          y         Form all subsets, in increasing size then
                    decreasing lexicographic order.
      .gsk          Group by sum
 x#                 Filter by the index in the group of
   eST              The last element lexicographically (greedy solution).
!                   Logically negate.

Very nice - any idea why it hangs on herokuapp for [1, 2, 4, 6, 8] and gets killed with /opt/tryitonline/bin/pyth: line 5: 28070 Killed ... Exit code: 137 at TIO? Just out of memory?

This uses 2^(num coins * last coin) bytes of memory. So for your example, 2^40. There aren't many machines with a terabyte of RAM

I thought that may be the case, the description of the algorithm makes sense, but I hadn't calculated the numbers - so vast so quickly!

Python, 218 211 205 bytes
-1 byte thanks to @TuukkaX (a space could be deleted between <3 and or)
from itertools import*
g=lambda x,c,n=0:x and g(x-[v for v in c if v<=x][0],c,n+1)or n
lambda c:len(c)<3or 1-any(any(any(x==sum(p)for p in combinations(c*i,i))for i in range(g(x,c)))for x in range(c[0]*2))

repl.it
Input in descending order.
Horribly brute force. Any set of a single unit coin and some other coin is canonical. For larger sets the smallest fail case, if one exists will be greater than or equal to the 3rd smallest coin (not sure myself how it could be equal!) and less than the sum of the two largest coins - see this paper (which actually references another but also gives an O(n^3) method).
g counts the coins used by the greedy method, and the unnamed function traverses the possible candidates (actually from 0 to one less than twice the largest coin to save bytes) and looks for any collection of less coins that also sum to that amount.
g works by performing what a cashier would, it recursively takes the largest coin less than or equal to the amount still to make up, [v for v in c if v<=x][0] away, and counts up the number of coins used, n.
The unnamed function returns 1 if len(c) is less than 3, and otherwise tests that it is not the case, 1-..., that any values in the range of possibilities, range(c[0]*2))), are possible with less coins, i in range(g(x,c)), by making a collection of that many of every coin, c*i, and examining all combinations of i coins, combinations(c*i,i), to see if any sum to the same value.

@WheatWizard it returns False for [13,8,2,1] - I added it to the test cases. Added clarification that input is in descending order.

3or should work.

Thanks @TuukkaX, also I could replace not(...) with 1-...

JavaScript (ES6), 116 125 130
l=>eval("r=(d,k)=>d?--k&&l.map(v=>v>d||r(d-v,k)):x=1;for(x=l[0]*2;--x>1;r(x,g))g=0,h=x,l.map(v=>(g+=h/v|0,h%=v));x")

This needs the input array sorted in descending order. For each value from 2N downto 2 (N being the max coin value), it find the number of coins from the greedy algorithm and try to find a smaller set of coins.
Less golfed
l=>{
  // recursive function to to find a smaller set of coins
  // parameter k is the max coin limit
  r = (d,k) => d // check if difference is not 0
     ? --k // if not, and if the number of coins used will be less than limit
      && l.map(v => v>d || r(d-v, k))  // proceed with the recursive search
     : x=1 // if diff is 0, value found, set x to 1 to stop the loop
  for( x=l[0]*2; --x > 1; )
    g=0, h=x, l.map(v=>(g += h/v|0, h %= v)), // find g with the greedy algorithm
    r(x,g) // call with initial difference equal to target value
  return x
}

Test

f=
l=>eval("r=(d,k)=>d?--k&&l.map(v=>v>d||r(d-v,k)):x=1;for(x=l[0]*2;--x>1;r(x,g))g=0,h=x,l.map(v=>(g+=h/v|0,h%=v));x")

/* No eval
f=l=>{
  r=(d,k)=>d?--k&&l.map(v=>v>d||r(d-v,k)):x=1;
  for(x=l[0]*2;--x>1;r(x,g))
    g=0,h=x,l.map(v=>(g+=h/v|0,h%=v));
  return x;
}*/

;[
 [[100,50,20,10,5,2,1],1], [[4,3,1],0],
 [[25,10,5,1],1], [[25,10,6,1],0],
 [[3,2,1],1], [[30,17,8,1], 0],
 [[12,8,3,1],0], [[13,8,2,1], 0]
].forEach(t=>{
  var i=t[0],k=t[1],r=f(i),
      msg=((r==k)?'OK ':'KO ')+i+' -> '+r
      + (r==k?'':' (should be '+k+')')
  O.textContent += msg+'\n'
})

function test()
{
  var i=I.value.match(/\d+/g).map(x=>+x).sort((a,b)=>b-a)
  O.textContent = i+' -> '+f(i)+'\n'+O.textContent
 }
#I { width:50% }
<input id=I value='1 4 9'><button onclick='test()'>test</button>

JavaScript (ES6), 144 132 124 122 110 bytes
a=>![...Array(a[0]*2)].some((_,i)=>(g=(a,l=0,n=i)=>[a.filter(c=>c>n||(l+=n/c|0,n%=c,0)),-l*!n])(...g(a))[1]>0)

Requires the array to be sorted in descending order. Uses the observation in the linked paper that if the system is not canonical then there is at least one value less than 2a[0] which takes fewer coins when decomposed using the unused coins from the initial greedy algorithm.
Edit: Saved 12 bytes by realising that I could check all the coins even though I had already reached the target value. Saved 8 bytes by switching my intermediate output from [l,b] to [b,-l]; this allowed me to pass the first result directly as the parameter of the second call, plus also a small saving detecting whether the second call was successful. Saved 2 bytes by moving the definition of g into the some callback, allowing me to avoid unnecessarily passing in the loop variable twice. Saved 12 bytes by switching from my recursive helper function to a call to filter (made possible by my intermediate output switch).

Jelly (fork), 15 14 bytes
SRæFµS€Ṃ=$Ṫµ€Ȧ

This solution uses the bounds for counter-examples from this paper. There, the author uses a tight bound for the counter-example, but in the interests of golfing, the range of the sum of coin denominations is used which is larger and contains that bound.
This program computes all test cases in less than a second on my machine.
Unfortunately, this relies on a branch of Jelly where I was working on implementing a Frobenius solve atom so you cannot try it online.
Usage
$ ./jelly eun 'SRæFµS€Ṃ=$Ṫµ€Ȧ' '1,2,4,6,8'
1

The performance is good and can solve all test cases at once in less than a second.
$ time ./jelly eun 'SRæFµS€Ṃ=$Ṫµ€Ȧ¶Ç€' '[[1,3,4],[1,5,10,25],[1,6,10,25],[1,2,3],[1,8,17,30],[1,3,8,12],[1,2,8,13],[1,2,4,6,8]]'
[0, 1, 0, 1, 0, 0, 0, 1]

real    0m0.793s
user    0m0.748s
sys     0m0.045s

Explanation
SRæFµS€Ṃ=$Ṫµ€Ȧ  Input: list of integers C
    µ           Start a new monadic chain
S                 Sum
 R                Range, [1, 2, ..., sum(C)]
  æF              Frobenius solve for each X in the range using coefficients from C
                  This generates all vectors where the dot product of a
                  vector with C equals X, ordered by using values from the
                  start to end of C
           µ€   Start a new monadic chain that operates on each list of vectors
     S€           Sum each vector
         $        Monadic hook on the sums
       Ṃ            Minimum (This is the optimal solution)
        =           Vectorized equals, 1 if true else 0
          Ṫ       Tail (This is at the index of the greedy solution)
             Ȧ  All, returns 0 if it contains a falsey value, else 1

Perl, 69 bytes
Includes +2 for -pa
Give coins in descending order on STDIN. You can optionally leave out the 1 coin.
coins.pl <<< "4 3 1"

coins.pl:
#!/usr/bin/perl -pa
$_=!map{grep$`>=$_&&($n=$G[$`-$_]+1)<($G[$`]||=$n),@F,/$/}1..2*"@F"

Builds up the number of coins used by the cashiers algorithm in @G for amounts 1 to twice the largest coin. For each amount checks that if that amount is reduced by 1 coin value the cashiers algorithm needs at most 1 less coin. If not this is a counterexample (or there was an earlier counterexample). I could stop at the first counterexample but that takes more bytes. So the time complexity is O(max_coin * coins) and space complexity is O(max_coin)


text:
Given a string, Return its Cumulative Delta
Related
Explanation
Given a string such as DCBA, convert it to ASCII ordinals, such as 68 67 66 65. Then, take the differences between each value, eg 67 - 68 = -1, 66 - 67 = -1... giving -1 -1 -1 Now as long as there is more than 1 left over value, repeat getting the differences.
For a 3 letter string, your pathway should be similar to
A   F   G
65  70  71
-5  -1
-4

And for a 5 letter string...
B   A   C   E   D   F
66  65  67  69  68  70
1   -2  -2  1   -2
3   0   -3  3
3   3   -6
0   9
-9

The Challenge
Take a string input through any Standard IO Method, and output the value of the cumulative delta as described above.
Test Cases
input: cows
output: 8

input: helloworld
output: 905

input: aaaaaa
output: 0

input: abcdef
output: 0

input: ghfie
output: 20

input: CODEGOLF
output: 185

Rules

Standard Loopholes Apply
The input will only consist of ASCII letters that are either all uppercase or all lowercase
Your code MUST work for both lower and upper case.
The input will contain at least 2 characters.
The output may be positive or negative, as long as its absolute value matches the absolute value of the cumulative delta.
This is marked as code-golf, as such, shortest answer in bytes wins!

What is the expected output for a single character input? Or is a single-character input even valid?

@Suever Presumably just the character's ordinal.

@Suever Behaviour undefined. I'll add a note under rules that a single character input will not be supplied. (Although the character's ordinal is what was outputted by my test code)

Negatives would matter in all the intermediate steps, so I'm not sure why you'd want to ignore them in the final output.

@Geobits If the string was taken in reverse, "FA" or "AF", the difference in the end cumulative delta is simply signage, "5" or "-5" respectively. The same applies for strings of any length. I've shown no biased for signage purely due to the fact that some languages consider deltas in different orders to others, to make the challenge slightly easier.

@nimi fixed, was the result of bad planning on my behalf

Once again, Signage of the output does not matter. -185 = 185 for the sake of this question.

how do i post my solution...i come with an equation to solve this question.(using pascal triangle)

Jelly, 6 4 bytes
-2 bytes thanks to @Dennis (implement a while loop)
OIṖ¿

TryItOnline
RunAllTestCases
How?
OIṖ¿ - Main link: s
O     - cast to ordinals
  Ṗ¿  - while, ¿, pop last value, Ṗ, evaluates to True:
 I    -     find increments between consecutive values

You can save two bytes with ¿ (while loop).

@Dennis - I can never make while loops...

OIṖ¿ does the job here.

Huh the condition is pop?

Yes. Once there's a single digit left, Ṗ will return an empty array, breaking out of the loop. The condition doesn't affect the return value.

Python 3, 71 bytes
s=input();k=r=0
for c in s:r=ord(c)-r*k/(len(s)-k);k+=1
print(round(r))

Test it on Ideone.
Alternate version, 58 bytes (inexact)
If an approximate result is enough – e.g., -904.9999999999993 ≈ -905 for input helloworld – then the following solution works as well.
f=lambda s,k=1:len(s)and-~-len(s)*f(s[1:],k+1)/k+ord(s[0])

Test it on Ideone.
Background
Proposition Let f be a variadic function that maps the code points s0, ⋯, sn to their cumulative delta with sign (-1)n, i.e.,

Then

Proof The statement is clearly true when n = 0. Suppose that it holds for n - 1, where n > 0.
By the recursive definition of f and the hypothesis,

By induction, the statement holds for all non-negative values of n.
How it works
Since

we can rewrite the proposition as follows.

The iterative implementation does precisely this. Numerators are computed by incrementing k, denominators by subtracting k from the length of the input string s, i.e., n+1.
Unfortunately, not all fractions will evaluate to integers, so the result is computed using floating point arithmetic and finally rounded to the nearest integer.
The recursive implementation does roughly the same, but it keeps track of the denominator via the auxiliary variable k and computes the numerator by subtracting 1 from the length of the remaining string (~-len(s)).

The explanation currently has some bugs (mostly related to signs). I'll fix that asap.

MATL, 5 bytes
`dtnq

Try it Online! or here is a slightly modified version for all test cases.
Explanation
        % Implicitly grab the input as a string
`       % Do....while loop
    d   % Compute the difference between all consecutive ASCII codes
    tnq % Determine the current length and subtract 1
        % Implicit end of do...while. Evaluate (and consume) stack element and break out
        % of loop if it's 0.
        % Implicit end of loop and display

Gosh Darn MATL.
...Have an explanation?

@JonathanAllan As stated in the challenge, sign doesn't matter.

J, 15 bytes
<:@#2&(-/\)3&u:

Usage
   f =: <:@#2&(-/\)3&u:
   f 'cows'
8
   f 'helloworld'
_905
   f 'aaaaaa'
0
   f 'abcdef'
0
   f 'ghfie'
_20
   f 'CODEGOLF'
_185

Explanation
<:@#2&(-/\)3&u:  Input: string S
           3&u:  Ordinal of each char
   #             Get the length of S
<:@                Decrement it
    2&(   )      Repeat len(s)-1 times on x = ordinal(S)
    2    \         For each pair of values
       -/            Reduce using subtraction
                   Return that as the next value of x
                 Return the final x as the result

Python 2, 80 73 bytes
Saving 7 bytes thanks to Dennis.
L=map(ord,input())
while L[1:]:L=[x-y for x,y in zip(L,L[1:])]
print L[0]

Requires input to be given in quotes, e.g. "helloworld"

You can replace raw_input with input if you surround the string with quotes (allowed by default). Also, len(L)>1 can become L[1:].

05AB1E, 7 bytes
ÇDgG¥}`

Try it online!
Explanation
Ç        # convert to list of ascii codes
 DgG }   # length-1 times do:
    ¥    # take deltas
      `  # pop the single value left in the list and output

Racket 147 bytes
(let p((l(map char->integer(string->list s))))(if(= 1(length l))(car l)(p
(for/list((i(range 1(length l))))(-(list-ref l(- i 1))(list-ref l i))))))

Ungolfed:
(define (f s)
  (let loop ((lst (map char->integer (string->list s))))
    (if (= 1 (length lst))
        (first lst)
        (loop (for/list ((i (range 1 (length lst))))
                (- (list-ref lst (sub1 i))
                   (list-ref lst i))
                )))))

Testing:
(f "AFG")
(f "BACEDF")
(f "cows")
(f "helloworld")
(f "abcdef")
(f "aaaaaa")
(f "ghfie")
(f "CODEGOLF")

Output:
-4
-9
8
-905
0
0
-20
-185

Signage doesn't matter for the answer. You can save those characters.

Ok. Thanks. I will remove absolute function.

RProgN, 17 Bytes
►Sb]L1-1\1:[d}P

Explination
►                   # Spaceless segment
 Sb                 # Convert the input to a stack, convert the stack of strings to a stack of ordinals.
   ]L               # Push a duplicate of that stack, pop it and push the length in its place
     1-             # Subtract 1 from the length.
       1\1          # Push a one, slide it under the top value, push another one, such that 1 LENGTH 1
          :  }      # For (i=1; i<=LENGTH; i+=1)
           [d       # Pop the iterator, pop the current stack, push the delta stack representing it.
              P     # Pop the top value of the stack, push it to the reg stack, and implicitly print.

I used (A version of) this script to test the question itself. I thought I might as well share it.
Try It Online!

Haskell, 51 47 bytes
g[x]=x
g x=g$zipWith(-)=<<tail$x
g.map fromEnum

Usage example: g.map fromEnum $ "CODEGOLF"-> 185.
map fromEnum turns the string into a list of ascii values. If it has only a single element, return it, else build neighbor differences and check again.

JavaScript (ES6), 116 bytes
Good that the input is more than 1 char so I can use s.length for both Arrays and Strings!
Snippet referenced from Neil's answer on another question :P

d=k=>/\d/.test(k)?k:k.charCodeAt(0);r=x=>(a=[...x],a.pop(),a.map((c,i)=>d(c)-d(x[i+1])));f=s=>s.length-1?f(r(s)):s[0]
<input oninput=o.textContent=this.value&&f(this.value)><pre id=o>

Brain-Flak, 97 bytes
([][()]<>){<>([][()]){({}[()]<({}[({})]<>)><>)}{}{}<>([]){({}[()]<({}<>)<>>)}{}<>({}<>[()])}<>

Try it online!
This is 97 bytes of code, plus 3 bytes for the -a flag, which enables ASCII input.
This would be a lot simpler if we didn't have to worry about the difference between characters sometimes being zero. Instead, we have to muck around with reversing the stack and pushing stack height several times.
Explanation:
Push the stack height onto the alternate stack
([][()]<>)

While this stack is non-empty:
{

    Move back
    <>

    Push the height of the stack minus one
    ([][()])

    While true
    {

        Decrement the stack height counter
        ({}[()]

        Move the difference over to the other stack
        <({}[({})]<>)><>)

    }

    Pop the last value and the left-over counter
    {}{}

    Move on to the other stack
    <>

    Move everything back
    ([]){({}[()]<({}<>)<>>)}

    Pop the counter
    {}<>

    Move the step number minus one back
    ({}<>[()])

End
}

Move back one last time
<>

R, 58 bytes
x=rev(utf8ToInt(readline()));while(length(x)>1)x=diff(x);x

diff() in R works differently than the difference defined in this challenge. Therfore we have reverse the vector (using rev) prior to taking the difference the first time.