text:
Find the Translation Table
Given two strings, find the translation table (substitution cipher) between the two, if the translation is not possible, output false. The answer must be minimized and created from left-to-right. The first character to be translated between words must be the first in the translation table. In addition to this, any letter that is not translated (in the same place as it was originally), should NOT be in the translation table.
Probably most easily defined through examples:
Valid Cases
"bat", "sap" => ["bt","sp"]

Notice the ordering, an output of ["tb","ps"] is not valid for this challenge.
"sense", "12n12" => ["se","12"]

Notice how the n isn't translated because it is a 1 to 1 relation.
"rabid", "snail" => ["rabd","snal"]

Notice how the i isn't translated because it is a 1 to 1 relation.
"ass", "all" => ["s","l"]

A is not included, it stays the same, s can map to l due to pattern match.
"3121212", "ABLBLBL" => ["312","ABL"]

Matches pattern perfectly.
Falsy Cases
"banana", "angular" => false

(not the same length, impossible).
"animal", "snails" => false

(each character can only be used ONCE on each side of the translation).
"can","cnn" => false

(n is implicitly used in translation, therefore, defining a translation table with n->a would be invalid)
Thusly, [aimal,sails] is an invalid answer, making this falsy.
"a1", "22" => false

See "caveats", this is listed as falsy. In this case, it's because a and 1 cannot both map to 2. (Each character can only be used ONCE on each side of the translation).

This answer seems to be a good benchmark: https://codegolf.stackexchange.com/a/116807/59376
If you have questions about the functionality of two unlisted word pairs, defer to this implementation.

I/O rules

Input may be as a 2 element array or as 2 separate inputs.
Output can be as an array or newline/space delimited, similar to how I have it shown.
False output may be 0, -1 or false. Erroring/Empty output is also fine.
You are guaranteed that a will not equal b and neither a nor b will be empty.
a and b are printable-ASCII-only sequences of letters.

Caveats

Translations must occur from left to right, see example 1.
You must not output characters that remain the same.
Your program may only take in two strings a and b.
Each character can only be used ONCE on each side of the translation. This is what makes the translation from snails to animals impossible.
Recursive replaces should not occur. Example of recursive replace: "a1","22"->[a1,12] where a is first replaced by a 1, then both resultant 1's are replaced with 2's. This is not correct, assume all translations occur independent of each other, meaning this is falsy. Meaning: "a1" with translation table of [a1,12] evaluates to 12 (not 22)

Labeling this "translation" as a simple substitution cipher might help clarify the intent.

Are associative arrays allowed as output? It could save me some bytes

@JörgHülserman I'm not fully sure of the implications of allowing this, maybe make 2 versions so I can see the difference? I'll edit it if I think it isn't harmful to the challenge.

Look at my post first solution as string and the second has as output an associative array

@JörgHülsermann ahhh... I see how you're using it now, I think I'm going to disallow that, not all languages support hash-like structures.

Is an underscore allowed as separator? It would save me 2 Bytes

not all languages support hash-like structures Not all languages natively support matrices (PHP for example does not, while most Eso-Langs do); but I haven´t seen them disallowed anywhere.

@Titus JavaScript's basic arrays are also technically hash-like structures as well

PHP >=7.1, 130 Bytes
18 Bytes saved by @Titus
for([,$x,$y]=$argv;a&$o=$y[$i];)$o==($p=$x[$i++])?:$k[$c[$p]=$o]=$p;echo$y==strtr($x,$c)&$x==strtr($y,$k)?join($k)." ".join($c):0;

Testcases
Expanded
for([,$x,$y]=$argv;a&$o=$y[$i];)
$o==($p=$x[$i++])?:$k[$c[$p]=$o]=$p; # if char string 1 not equal char string 2 make key=char1 value=char2 and key array
echo$y==strtr($x,$c) # boolean replacement string 1 equal to string 2
    &$x==strtr($y,$k) # boolean replacement string 2 equal to string 1
    ?join($k)." ".join($c) # output for true cases
:0; #Output false cases

PHP >=7.1, 148 Bytes
prints 0 for false Output true as string

for([,$x,$y]=$argv;a&$o=$y[$i];$i++)$x[$i]==$o?:$c[$x[$i]]=$o;echo$y==strtr($x,($f=array_flip)($k=$f($c)))&$x==strtr($y,$k)?join($k)." ".join($c):0;

Testcases
Expanded

for([,$x,$y]=$argv;a&$o=$y[$i];$i++)
$x[$i]==$o?:$c[$x[$i]]=$o; # if char string 1 not equal char string 2 set key=char1 value=char2
echo$y==strtr($x,($f=array_flip)($k=$f($c))) # boolean replacement string 1 equal to string 2
&$x==strtr($y,$k) # boolean replacement string 2 equal to string 1
    ?join($k)." ".join($c) # output for true cases
:0; #Output false cases

PHP >=7.1, 131 Bytes
The second answer can be shorted to this if associative arrays are allowed
prints 0 for false Output true as associative array instead of string

for([,$x,$y]=$argv;a&$o=$y[$i];$i++)$x[$i]==$o?:$c[$x[$i]]=$o;print_r($y==strtr($x,($f=array_flip)($f($c)))&$x==strtr($y,$k)?$c:0);

Testcases
PHP >=7.1, 227 Bytes
prints 0 for false

[,$x,$y]=$argv;echo strlen($x)==strlen($y)?strtr($x,$c=array_filter(($f=array_flip)($z=$f(array_combine(($p=str_split)($x),$p($y)))),function($v,$k){return$k!=$v;},1))==$y&$x==strtr($y,$z)?join(array_keys($c))." ".join($c):0:0;

Testcases
Expanded

[,$x,$y]=$argv; #
echo strlen($x)==strlen($y) #compare string lengths
?strtr($x,  # replace function
$c=array_filter( # filter
($f=array_flip)($z=$f( # # remove doubles like in testcase: a1 => 22
    array_combine(($p=str_split)($x),$p($y))  # replacement array keys string 1 values string 2
))
    ,function($v,$k){return$k!=$v;},1)) # remove all keys that equal to values in array
    ==$y # boolean replacement string 1 equal to string 2
&$x==strtr($y,$z) # boolean replacement string 2 equal to string 1
?join(array_keys($c))." ".join($c) # output for true cases
    :0 # Output if replacement from string 1 is not equal to string 2
:0; #Output for different lengths

You are an extremely experienced PHP developer, I am entirely impressed by that 144-byte one-liner.

@carusocomputing Thank you for the compliment. I have forget a little trick. I Know that here are many people they are better then me

Your definitely good at finding solutions +1 but array_values() inside join() is completly useless and can be dropped.

@Christoph yes I am an idiot. Thank You

This fails the a1 22 => false test case. Also, your first program doesn't seem to work in the online tester.

@mbomb007 Try it now Thank you very much. The Joke with the double array_flip to remove these doubles in the values in my bigger solution is more worth  as the few bytes

WTG I think this is the first time you beat me. And you can save another byte with echo$y==. Care to add  tags?

@Titus done I am not sure that I beat you. It is very complex and the trick with the double array_flip has saved much bytes. and your experience is better as my

Shut up. It´s marvellous.

The flippers can go: Save 18 bytes with ($p=$x[$i])==$o?:$k[$c[$p]=$o]=$p; in the loop and $y==strtr($x,$c) for the first test.

@Titus now you have beat my marvellous Solution . Congratulations. Now I hate really that associative arrays as output are not allowed

Output can be as an array ... I´ll help clearing that subject. And I didn´t beat you; You still have a very nice and short solution with strtr (which I unfortunately completely ignored in my approach).

@Titus your improvement count for me as a beat.

JavaScript (ES6), 128 bytes

f=
(s,t)=>!t[s.length]&&[...s].every((c,i)=>n[d=t[i]]==c||d&&!m[c]&&!n[d]&&(n[m[c]=d]=c,c==d||(a+=c,b+=d)),m={},n={},a=b='')&&[a,b]

<input id=s><input id=t>

Doesn't work for ass and all, should be s,l.

Yeah, that snippet be trippin', also verified, it's fine.

@carusocomputing It was a variable name clash - it's fixed now. Sorry about that.

JavaScript (ES6), 108 107 105 106 bytes
Edit: Fixed to support inputs such as "22" / "a1" that should be falsy.

Returns either 0 or an array of two strings.
f=(a,b,x)=>[...a].some((c,i)=>d[C=b[i]]?d[C]!=c:(d[C]=c)!=C&&(s+=c,t+=C,!C),s=t='',d=[])?0:x||f(b,a,[s,t])

Formatted and commented
f = (                       // given:
  a,                        // - a = first string
  b,                        // - b = second string
  x                         // - x = reference result from previous iteration,
) =>                        //       or undefined
  [...a].some((c, i) =>     // for each character c at position i in a:
    d[                      //   if we already have a translation
      C = b[i]              //   of the character C at the same position in b,
    ] ?                     //   then:
      d[C] != c             //     return true if it doesn't equal c
    :                       //   else:
      (d[C] = c) != C &&    //     store the translation C -> c in the dictionary
      (                     //     if the characters are different:
        s += c, t += C,     //       append them to the translation strings s and t
        !C                  //       return true if C is undefined
      ),                    //
    s = t = '', d = []      //   initialize s, t and d
  ) ?                       // if some() returns true:
    0                       //   there was a translation error: abort
  :                         // else:
    x ||                    //   if this is the 2nd iteration, return x
    f(b, a, [s, t])         //   else do a recursive call with (b, a)

Test cases

f=(a,b,x)=>[...a].some((c,i)=>d[C=b[i]]?d[C]!=c:(d[C]=c)!=C&&(s+=c,t+=C,!C),s=t='',d=[])?0:x||f(b,a,[s,t])

// truthy
console.log(f('bat','sap'))
console.log(f('sense','12n12'))
console.log(f('rabid','snail'))
console.log(f('ass','all'))
console.log(f('3121212','ABLBLBL'))

// falsy
console.log(f('banana','angular'))
console.log(f('animal','snails'))
console.log(f('a1','22'))
console.log(f('22','a1'))
console.log(f('aaa','bab'))
console.log(f('abc','abcd'))
console.log(f('abcd','abc'))

f('22')('a1') should be falsy too.

Hopefully I got it right this time.

It's always handy when your bugfix turns out to simplify to something shorter!

Retina, 194 191 185 229 225 241 bytes
.+
$&;$&
+`^\w(\w*;)\w
$1
^;\w.*|.+;;.*|;;

^((.)*)(.)(.*;(?<-2>.)*(?(2)(?!)))\3
$1$4
+`((.)(.)*)\2((.)*;.*(.)(?<-3>.)*(?(3)(?!)))\6((?<-5>.)*(?(5)(?!)))$
$1$4$7
^(.)*(.)(.)*(\2)?.*;(?<-1>.)*(?(1)(?!))(.)(?<-3>.)*(?(3)(?!))(?(4)(?!\5)|\5).*

Try it online!
Takes input ;-separated. Output is also ; separated. False inputs are signified by empty outputs.
I know this is painfully verbose, I am still trying to cut down bytes. Most of these bytes go into deleting false inputs.
Edits

It turns out that I had a significant flaw with my program. It's fixed now, but at the cost of over 40 bytes.

Another mistake was found where my program did not declare the input a1;22 false, but I was able to keep the program under 250 bytes after fixing it

Explanation
(a more detailed explanation will be coming shortly)
First we have to check if the lengths of strings a and b are the same or not. If they are not, we delete everything.
Duplicates the input to preserve it while we do some length-testing.
.+                      Matches everything
$&;$&                   $& indicates the match, so $&;$& will duplicate the match and separate it with a semi-colon

Now in a loop, we delete the first character of a and the first character of b until one of the strings become empty.
+`                     Repeatedly (until no more substitutions could be made) replace
  ^\w                   A word character (letter or number) at the beginning
     (\w*;)             Capture Group 1: matches any number of word characters and a semicolon
           \w           And a word character after the semi-colon
                       with
$1                      The result of the first capture group

Now there are there possibilities for the "pattern space".

;;abc Both strings are of equal length
def;;abc a is longer than b
;def;abc b is longer than a

Now we have to empty the input if the strings are not of the same length (scenarios 2 and 3). This is what this substitution below does. It removes text that matches scenarios 2 and 3.
^;\w.*|.+;;.*|;;

This removes characters that are not transliterated in strings a and b. abc;1b2 => ac;12
^((.)*)(.)(.*;(?<-2>.)*(?(2)(?!)))\3
$1$4

After that, we have to remove duplicate characters. sese;1212 => se;12, but this preserves inputs like aba;123
+`((.)(.)*)\2((.)*;.*(.)(?<-3>.)*(?(3)(?!)))\6((?<-5>.)*(?(5)(?!)))$
$1$4$7

Finally, we delete the input if there are duplicate characters that map to different characters like aba;123 or a1;22.
^(.)*(.)(.)*(\2)?.*;(?.)*(?(1)(?!))(.)(?.)*(?(3)(?!))(?(4)(?!\5)|\5).*

And finally, remove duplicate characters.

Using those balancing groups I see!

@Neil Indeed! I also used the (?(1)(?!)) I learnt from your answer :)

I wonder whether it would be shorter to remove duplicates first and then validate the remaining sets - there should only be one of each letter remaining on each side of the ;.

@Neil I found an error with my code experimenting with that. I will look further into it in the morning.

Jelly, 18 bytes
ẠaQ⁼µ€Ạ
z0EÐḟQZẋÇ$

Unnamed monadic link (one-input function) taking a list, which returns:
an empty list in the falsey cases; or
a list containing two lists of characters in the truthy cases.
Try it online! (the footer splits the list with a space to avoid printing a smushed representation)
...or see a test suite.
How?
ẠaQ⁼µ€Ạ - Link 1, valid?: mapping list
    µ€  - perform the code to the left for €ach mapping entry
Ạ       -     none of mapping entry falsey? (this & Main's z0 handle unequal input lengths)
  Q     -     deduplicate mapping entry
   ⁼    -     is equal to mapping list? (non-vectorising)
 a      -     and
      Ạ - none falsey (both mapping lists must pass that test)
        - The whole function returns 1 if the mapping list is acceptable, 0 if not

z0EÐḟQZẋÇ$ - Main link: list of strings
z0         - transpose with filler 0 (unequal lengths make pairs containing zeros)
   Ðḟ      - filter discard:
  E        -     all equal? (removes the untranslated character pairs)
     Q     - deduplicate (removes the repeated translation pairs)
      Z    - transpose (list of pairs to pair of lists)
         $ - last two links as a monad:
       ẋ   -     repeat list this many times:
        Ç  -         call last link (1) as a monad

Jelly, 28 26 bytes
QL$€⁼L€
EÐḟQZK0Ç?
ZÇ0L€E$?

Try it online!
QL$€⁼L€      Checks validity of mapping
QL$€          number of unique characters in mapping
    ⁼         equals
     L€       number of characters in mapping

EÐḟQZK0Ç?  Writes valid mapping or 0
EÐḟ           filter maps where a = b
   Q          filter duplicate maps
    Z         zip by column [["ac"],["bd"]] => ["ab","cd"]
     K0Ç?   print if valid map, else print 0

ZÇ0L€E$?      main link: takes an array of 2 strings
Z              zip by column: ["ab", "cd"] => [["ac"],["bd"]]
 Ç     ?       print mapping if
   L€E$         all pairs are same length (returns 0 if initial strings were
  0             else 0

Welcome to PPCG! How the hell do you already know Jelly with only 21 points? Very impressive!

Thanks.  Looked around the site a bit and it seemed like a neat language to learn.

05AB1E is another easy and fun one to try out.

Ruby, 133 bytes
->a,b{a.size!=b.size||(m=a.chars.zip b.chars).any?{|i,j|m.any?{|k,l|(i==k)^(j==l)}}?0:m.select{|x,y|x!=y}.uniq.transpose.map(&:join)}

Try it online!
More readably:
->a, b{
    # Pair the letters in each string - [AB, AB, AB,...]
    pairs = a.chars.zip(b.chars)

    # If there's any combination of two pairs that share one character but not both,
    # or if the strings have different lengths, then the input's invalid.
    if a.size != b.size || pairs.any?{|i,j| pairs.any? {|k, l| (i==k)!=(j==l) }}
        return 0 # 0 isn't actually falsy in Ruby, but this challenge allows it anyway
    end
    return pairs.select{|x,y| x != y} # Remove unchanged letters
                .uniq                 # Remove duplicates
                .transpose            # Change [AB, AB, AB] form to [AAA, BBB] form.
                .map(&:join)          # Convert the arrays back into strings
}

Just for kicks, here's an 84 byte version in Goruby, which is Ruby, but with a golf flag set when compiling the interpreter. Among other things, it allows you to abbreviate method calls to their shortest unique identifier.
->a,b{a.sz!=b.sz||(m=a.ch.z b).ay?{|i,j|m.y?{|k,l|(i==k)^(j==l)}}?0:m.rj{|x,y|x==y}.u.tr.m(&:j)}

Why not post a second answer with the Goruby implementation? Is it not an accepted golfing language?

@carusocomputing It totally is; it just seemed to me like it didn't merit its own answer - it's exactly the same as my main answer, just with method names abbreviated. Perhaps if I find a way to take advantage of more of Goruby's differences I'll post a separate answer.

Python 3.6, 211 185 181 178 bytes
Exits with an error for falsy results.
def f(x,y,d={}):
    for a,b in zip(x,y):1/(a not in d or b==d[a]or len(x)-len(y));d[a]=b;1/([*d.values()].count(b)<2)
    return map(''.join,zip(*[x for x in d.items()if x[0]!=x[1]]))

This requires Python 3.6, which you can run in a shell here.
You can test it without the correct output ordering on TIO here. (TIO doesn't have 3.6).
Ungolfed:
from collections import*
d=OrderedDict()                     # keep order
x,y=input()
if len(x)!=len(y):1/0               # equal lengths
for a,b in zip(x,y):
    if a in d and d[a]!=b:1/0       # no duplicate keys
    else:d[a]=b
    if d.values().count(b)>1:1/0    # no duplicate values
print map(''.join,zip(*[x for x in d.items()if x[0]!=x[1]])) # format, no no-ops

If only order didn't matter...

Shouldn't a1,12 return a1,12 instead of False? Under the Caveats section it is said that "a1" with translation table of [a1,12] evaluates to 12.

Well, the program in your TIO link returns False. 1a 21 would also be wrong, as the oeder has to be preserved.

@fergusq Fixed. But notice that you have a typo in your comment if that's the test case you're referring to, since you said a1,12 instead of a1,22.

I misunderstood you. You referred to the Caveats section in your question edit, but the Caveats section actually handles a different case – not the bijection rule. That confused me.

It handles a different rule, but it still says that the result of that test case is false, which is what mattered.

In Python 3.6, regular old dicts preserve order. It's an implementation detail, but it'd save you a few bytes to use it vs Python 2 because you wouldn't need to import anything.

Oh, and I think 1/(a not in d or d[a]==b) can be replaced with 1/(not d.get(a)), because dict.get() returns None if the key isn't present. It's totally possible I didn't think the edge cases through on this one, though.

That last change fails the "rabid", "snail" test case.

You can do [*d.values()] instead of list(d.values()), too, to save 3 bytes, I believe.

Python 2, 198,193,189,182,179,175,169,165 bytes
def f(a,b):
 r=([""]*2,0)[len(a)!=len(b)]
 for u,v in zip(a,b):
	if r:
		q,w=r
		f=q.find(u)
		if u!=v:r=(([q+u,w+v],r)[f>-1 and w[f]==v],0)[f<0 and v in w]
 print r

Try it online!

-4 bytes! thanks to  mbomb007 for suggesting the use of tab instead of space.
modified the input format, again thanks to mbomb007.

what do you mean by that? please stop making unwanted edits which doesnt add any value to answer!

tab saved  around 4 bytes! Thank you!

Let us continue this discussion in chat.

And I made your program have each test case on a single line, which is extremely helpful to anyone testing your program.

I'd would have better if you could have mentioned that in your edit comment!

It's bad practice to have a variable f inside a function f. Also, it's probably shorter to use a,b=input() instead of declaring a function, because then you have less indentation.

@mbomb007 Isn't everything we do here bad practice?

@L3viathan Hey, if you can avoid it without costing bytes, then no.

Röda, 108 119 bytes
{c=[{_<>_|[[_,_]]|orderedUniq}()]d=[]e=[]c|_|{{d+=a;e+=b}if[a!=b]}for a,b[d,e]if[0,1]|{|n|c|[_[n]]|sort|count|[_2=1]}_}

Try it online!
This is a function that takes two lists of characters from the stream and pushes two lists to the stream.
This could be sorter if I was allowed to return pairs.
Explanation (out-dated):
{
    c=[{
        _<>_|       /* pull two lists and interleave them */
        [[_,_]]|    /* "unflat", create lists from pairs */
        orderedUniq /* remove duplicates */
    }()]            /* c is a list of the pairs */
    d=[]
    e=[]
    c| /* push the pairs to the stream */
    _| /* flat */
    {  /* for each pair (a, b): */
        { /* if a != b (remove "1-to-1 relations"):  */
            d+=a;
            e+=b
        }if[a!=b]
    }for a,b
    /* return d and e if no character is mapped to more than one character */
    [d,e]if c|[_[0]]|sort|count|[_2=1]
}

Here's an underscore solution that contains no variables (114 bytes):
{[[{_<>_}()|[[_,_]]|unorderedUniq]]|[[_()|_|[_]if[_1!=_2]],[_1()|_|[_2]if[_1!=_2]]]if[[_1()|_][::2],[_1()|_][1::2]]|[sort(_)|count|[_2=1]]}

That's a lot of underscores.

What does the <> do?

@KritixiLithos It's the interleave operator. a() <> b() is same as interleave([a()], [b()]) (or just interleave(a, b), if a and b are arrays).

This fails the a1 22 => false test case. "all translations occur independent of each other, meaning this is falsy."

@mbomb007 I don't quite understand what you say? Do you mean it has to be a bijection, ie. no two characters must be mapped to a same character?

Yes. That's what the question says. (Each character can only be used ONCE on each side of the translation)

@mbomb007 Fixed.

k, 28 bytes
{$[(y?y)~x?x;+?(~=/)#x,'y;]}

Explanation:
{                          } /function that takes in two strings, x and y
 $[         ;            ;]  /if statement (to check if there is a mapping)
         x?x                 /first index of [each letter in x] in x
   (y?y)                     /first index of [each letter in y] in y
        ~                    /make sure they match
                     x,'y    /zip together the two strings
               (~=/)#        /remove equal pairs
              ?              /unique pairs only
             +               /transpose ("unzip", in a way)

AWK, 140 bytes
BEGIN{RS="(.)"}RT~/\W/{S=1}RT~/\w/&&S{if(RT!=x=A[++b]){if(B[z=RT]==""){B[z]=x
c=c x
d=d z}a=B[z]!=x?0:a}}!S{A[++a]=RT}END{if(a==b)print c,d}

Usage:
Place code in FILE then:
awk -f FILE <<< "string1 string2"

The input strings need to be whitespace separated.
The output is empty if they fail, or 2 strings separated by a space.

APL (Dyalog) with AGL, 22 bytes
{≡/⍳⍨¨⍺⍵:↓⍉↑∪⍺(≠é,¨)⍵}

Try it online!
{…} anonymous function:
 If…
  ⍺⍵ the arguments
  ⍳⍨¨ when self-indexed (i.e. the first occurrences of their elements in themselves)
  ≡/ are equivalent
 : then:
  ⍺(…)⍵ apply the following tacit function to the arguments:
   ,¨ concatenate corresponding elements (errors on mismatching lengths)
   é then filter by (é is just the primitive function /)
   ≠ where the strings are different
  ∪ unique (remove duplicates)
  ↓⍉↑ transpose list-of-pairs to pair-of-lists (lit. mix into table, transpose table, split into lists)
 else, do nothing

patiently awaits the explanation of this answer :P

@carusocomputing I'm on it.

@carusocomputing OK?

I missed that reply, sorry! ↓⍉↑ still has me a little confused.

@carusocomputing Maybe this helps? Note that in APL and J, a matrix is not the same as a list of lists.

Oh, wow, yeah that definitely helps; and I know very little about the language, it makes a lot more sense now.

PHP (>=7.1), 165 bytes
for([,$x,$y]=$argv;a&$c=$x[$i];$t[$c]=$d)$z+=($d=$y[$i++])&&$d==($t[$c]??$d);foreach($t as$a=>$b)$a==$b?:$r[$a]=$b;print_r($z<$i|array_unique($r)<$t||a&$y[$i]?0:$t);

prints 0 for falsy, associative array else. Run with -r or test it online.
breakdown
for([,$x,$y]=$argv;         # import arguments to $x and $y
    a&$c=$x[$i];            # loop through $x
    $t[$c]=$d)                  # 2. add pair to translation
$z+=                            # 1. increment $z if
    ($d=$y[$i++])&&             # there is a corresponding character in $y and
    $d==($t[$c]??$d);           # it equals a possible previous replacement
                            # remove identities from translation
foreach($t as$a=>$b)$a==$b?:$r[$a]=$b;
print_r(
    $z<$i                   # if not all tests passed
    |array_unique($t)<$t    # or there are duplicates in the translation
    ||a&$y[$i]              # or $y has more characters
    ?0                      # then print 0
    :$r                     # else print translation
);

Are associative arrays as Output  allowed? Could you please add that it works above version 7.1

@JörgHülsermann Output can be as an array or ..., so I´d say yes. Current PHP version is implicit for all my postings; but if I find something important to edit, I´ll add the version.

The valid cases shows only one meaning of array output. If associative arrays are also allowed I can save a few bytes. If it is allowed and array_unique($r)!=$r is in every case array_unique($r)<$r I will upvote your post alone for this trick. In the moment I am searching for an explanation

@JörgHülsermann array_unique($t)<$t (had to change that because can to cnn is invalid) works, because array comparison (unlike string comparison) compares lengths before anything else.

The test can to cnn cost me 17 Bytes Forget my suggestion

CJam, 38 bytes
{_:,~={1\/;}:K~z{)\c=!},L|z_{_L|=K}%;}

Input and output are arrays on the stack.

Ruby, 96 bytes
Throws an error for a negative result.
->a,b,**h{a.chars.zip(b.chars){(h[_1]&&h[_1]!=_2)?fail: h[_1]=_2}
h.map(&:join).grep_v(/(.)\1/)}

Attempt This Online!


text:
Bernardino identifies unaltered dollar words
Definition
A dollar word is a word where when each of its letters is given a cent value, from a = 1 to z = 26, and the letters are summed, the result is 100. Here is an example on CodeReview, and here is a list of dollar words I found online.
Input
Input will be alphabetical from a-z, in your one language's text datatypes (arrays are allowed). You do not need to account for any other input - there will be no spaces, apostrophes, or hyphens. You can take as lowercase, uppercase, or a combination. Trailing newlines are allowed.
Output
Output a truthy value if the input is a dollar word, and a falsey value if it is not.
Test Cases
Truthy:
buzzy
boycott
identifies
adiabatically
ttttt

Falsey:
zzz
zzzzzzz
abcdefghiljjjzz
tttt
basic

This is code-golf, so the shortest answer in bytes wins! Standard loopholes and rules apply. Tie goes to first poster.

Title has dollar words in it, sorry if it threw you off.

GS2, 6 bytes
▲1Θd←q

Input must be in uppercase.
Try it online!
How it works
  Θ       Combine the previous two tokens into a block and map it over the input.
▲             Push 64.
 1            Subtract 64 from the character on the stack.
   d      Take the sum of the resulting character array.
    ←     Push 100.
     q    Compare the two items on the stack for equality.

05AB1E, 8 bytes
Code:
Ç96-O4bQ

Uses the CP-1252 encoding. Try it online!
Explanation:
Ç          # Convert the string into a list of character codes
 96-       # Subtract 96 of each element
    O      # Take the sum
     4b    # Push 100 (4 in binary)
       Q   # Check if equal

Tn works too :P

Ç4+OTn%0Q was another idea I had, but it's worse.

7 bytes

@lyxal No need for uppercase, the 4b in the current answer can simply be т for 7 bytes.

Python, 39 38 bytes
lambda s:sum(ord(i)-96for i in s)==100

Try it online!

-1 byte thanks to @JonathanAllan

Raku, 21 bytes
{100==[+] .ords X%32}

Try it
Alternate:
{Ⅽ==[+] .ords X%32}

Try it
Note that the Ⅽ is ROMAN NUMERAL ONE HUNDRED U+216D with a unival of … 100
Which takes 3 bytes to encode.
Expanded:
{  # bare block lambda with implicit parameter $_

  100     # is 100
  ==      # equal to
  [+]     # the sum of the following

    .ords # the ordinals of the input (implicit method call on $_)
    X[%]  # crossed using the modulus operator
    32    # with 32 to get 65..90 or 97..122 to become 1..26
}

MATL, 8 bytes
96-s100=

Uses lowercase input.
Try it online!
Explanation
The code is as readable as it gets:
96-   % Implicitly input string. Subtract 96 from each char interpreted as ASCII code
s     % Sum of array
100=  % Does it equal 100? Implicitly display

JavaScript (ES6), 46 bytes
Returns 0 or 1.

let f =

w=>[...w].map(c=>p-=parseInt(c,36)-9,p=100)|!p

console.log(f('buzzy'))
console.log(f('qwerty'))

Interestingly when I tried reduce and recursion they both came out 2 bytes longer.

@Neil Actually, it was using reduce() during the first few minutes of the grace period when I initially posted it.

C, 45 43 bytes
Thanks to @Neil for saving two bytes and making the solution case-insensitive!
n;f(char*s){for(n=100;*s;)n-=*s++&31;n=!n;}

Try it online!

Seems like you can save a byte by setting n=0 globally and then skipping the first clause of the loop spec, no? edit: never mind—I guess that would only work for the very first call.

Could counting down from 100 save bytes? Also, &31 might work to make your code case insensitive.

Out of curiosity, how does n=!n work? I understand it checks if n is zero, because based on some test I see !0 returns 1; !15 returns 0; and !-15 returns 0 as well. But why? Which operand is ! in C when using it as !integer?

@KevinCruijssen ! is just the logical not. In C, 0 means false, and any other integer value means true. So !0 == 1, and !n == 0 for every n != 0.

@Steadybox Ah, I didn't knew this part: "and any other integer value means true", but it indeed makes sense. I always (incorrectly) thought of it as 0=false; 1=true instead, hence my confusion. Thanks for the answer.

Mathematica, 23 bytes
100==Tr@LetterNumber@#&

Pure function taking a string (or an array of letters) as input, case-insensitive, and returning True or False. Here Tr just adds the letter-numbers together; everything else is self-explanatory.

Haskell, 32 bytes
f s=sum[1|c<-s,_<-['a'..c]]==100

Try it online!
The idea is to make a list of characters from a to the given character for each character in the list, and check that the total length is 100.
Other attempts:
f s=sum[1|c<-s,_<-['a'..c]]==100

f s=sum[fromEnum c-96|c<-s]==100
f s=100==length((\c->['a'..c])=<<s)
(==100).length.(>>= \c->['a'..c])
(==100).length.(=<<)(\c->['a'..c])
(==100).length.(enumFromTo 'a'=<<)
f s=100==length(do c<-s;['a'..c])

Too bad enumFromTo is so long.

You're right that the length is a shame—(100==).length.(enumFromTo 'a' =<<) is such a clean use of point-free-ness

Jelly, 9 7?* 8 bytes
ɠO%32S⁼³

Full program, outputting 1 if the input is a dollar word, or 0 if not.
Try it online!
How?
ɠO%32S⁼³ - Main link
ɠ        - read a line of input from STDIN
 O       - cast to ordinals
  %32    - mod 32 (vectorises) (-3*32=96 from lowercase; -2*32=64 from uppercase)
     S   - sum
       ³ - literal: 100
      ⁼  - equal?

* Could it be 7 bytes?
The only reason this took input with ɠ was to keep ³ as the literal 100 rather than the 3rd command line input (1st program input).
A way to avoid that would be, as pointed out by Dennis, to create 100 using the raw literal form ȷ2 which is 102. This leads to another 8 byte O%32S=ȷ2, but this is now an unnamed monadic function (as well as operating as a full program with a 3rd argument).
Since, in golf, one may create variables or helper functions which restrict the program in which they may reside (one cannot reuse the name in-scope without stopping the function from being reusable), maybe restricting the program to only taking input from STDIN may also be acceptable, in which case the 7 byte O%32S=³ would be acceptable here as an unnamed function.

Alternatively, O%32S=ȷ2. Works for uppercase and lowercase input.

@Dennis It may be borderline but wouldn't O%32S⁼³ actually be a valid entry as it does define an unnamed, reusable function, so long as the rest of the program it is in does not use command line arguments for input?

Hm, I guess that could be done. Not that different from using a global variable in C, for example.

Haskell, 32 bytes
f w=sum[fromEnum c-96|c<-w]==100

This works for lowercase input. For uppercase, s/96/64/. Mixed-case support would add a bunch of bytes.

R, 55 54 bytes
function(x)sum(match(el(strsplit(x,"")),letters))==100

-1 byte thanks to BLT

returns a function that does the required computation, which returns TRUE and FALSE as one would expect.

takes input in as lowercase; would only be a switch from letters to LETTERS for all uppercase

function(x)sum(match(el(strsplit(x,"")),letters))==100 saves a byte.

Java 8, 36 bytes
s->s.chars().map(c->c%32).sum()==100

Try it online!
Note: case independent.

Alice, 23 bytes
/o!
\i@/e)q&w[?'`-+k3-n

Try it online!
Input should be lower case. Prints 1 for dollar words and 0 otherwise.
Explanation
Time to show off Alice's tape and some advanced control flow. Despite being fairly good at working with integers and strings individually, Alice has no built-ins to a) determine a string's length, b) convert between characters and their code points. The reason for this is that all of Alice's commands either map integers to integers or strings to strings. But both of those would require mapping strings to integers or vice versa, so they don't fit into either of Alice's modes.
However, in addition to it's stack, Alice also has a tape and Cardinal and Ordinal mode interpret the data on the tape in different ways

In Cardinal mode, it's a regular tape familiar from other languages like Brainfuck. You can store one integer in each cell and you can move a tape head around. The tape is infinitely long and initially holds a -1 in every cell. The cells are also indexed and the tape head starts at index 0.
Ordinal mode has its own tape head (also starting at index 0) and it interprets the tape as a list of strings. Strings are terminated by non-character cells (i.e. any values which are not a valid Unicode code point), in particular -1. So for Ordinal mode, the tape is initially filled with empty strings.

This tape can be used for both of the above operations: to get a string length, we write it to the tape in Ordinal mode, seek the terminating -1 in Cardinal mode and retrieve the position of the tape head. To convert characters to their code points, we simply read them off the tape in Cardinal mode.
The other two important features used in this solution are the return stack and an iterator. Alice has a return stack which is usually filled when using the jump command j, and which you can pop an address from to jump back with k. However, it's also possible to push the current address to the return stack without jumping anywhere with w. If we combine w with the repeat command &, we can push the current address to the return stack n times. Now each time we reach k, one copy is popped off the return stack and we perform another iteration from w (starting at the cell after it, because the IP moves before executing another command). When the return stack becomes empty, k does nothing at all and the IP simply passes through. Hence &w...k pops an integer n and then executes ... n+1 times, which gives us a very concise way to express a simple for loop.
On to the code itself...
/     Reflect to SE. Switch to Ordinal.
i     Read the input word as a string.
      Bounce off bottom boundary, move NE.
!     Store the input word on the tape.
      Bounce off top boundary, move SE.
/     Reflect to E. Switch to Cardinal.
e     Push -1.
)     Seek right on the tape for a -1, which finds the -1 terminating
      the input word.
q     Push the tape head's position, which gives us the string length N.
&w    Repeat this loop n+1 times (see above for an explanation)...
  [     Move the tape head left by one cell.
  ?     Retrieve the code point of the character in that cell.
  '`    Push 96.
  -     Subtract it from the code point to convert the letters to 1...26.
  +     Add the result to a running total. This total is initialised to
        zero, because in Cardinal mode, the stack is implicitly filled with
        an infinite amount of zeros at the bottom.
k    End of loop.
     Note that the above loop ran once more than we have characters in the
     string. This is actually really convenient, because it means that we've
     added a "-1 character" to the running total. After subtracting 96 to
     convert it to its "letter value" this gives 97. So dollar words will
     actually result in 100 - 97 = 3, which we can check against for one
     byte less than for equality with 100.
3-   Subtract 3 to give 0 for dollar words.
n    Logical NOT. Turns 0 (dollar words) into 1 and everything else into 0.
     The IP wraps around to the beginning of the first line.
\    Reflect to NE. Switch to Ordinal.
o    Implicitly convert the result to a string and print it.
     Bounce off top boundary, move SE.
@    Terminate the program.

Nice! I got 41 with my first try

Ruby, 25 bytes
->s{s.sum-s.size*64==100}

Works for uppercase.
I see a couple of more complex Ruby entries, but it really is this simple. s.sum adds the ASCII codes of the input string, and from this we subtract 64 times the length of the string.
Example of use
f=->s{s.sum-s.size*64==100}

puts f["ADIABATICALLY"]
puts f["ZZZ"]

This only works on Ruby 2.4 and currently does not work on TIO

@GB thanks for the comment but I'm running on 2.2.6 and it works fine for me. The feature has been documented since 1.9.3. It works on TIO.run and Ideone.com for me too.

You are right, I thought it was the same as Array#sum, which is new in 2.4

Actually, it's not the sum of ASCII values, the definition is "Returns a basic n-bit checksum of the characters in str". This works in this case, of course.

Perl 5, 30 bytes
-1 byte thanks to @Neil (31& instead of -96+).
29 bytes of code + -p flag.
$@+=31&ord for/./g;$_=$@==100

Try it online!

Can you use 31&ord instead?

@Neil Hum... I've always been using -96+ for such things.. Thanks a lot for that! (but now I feel like I should go back through my old posts and replace every -96+ :x )

The question specifies arrays are allowed as input. This can thus be briefer as a subroutine: {$@+=31&ord for@_;$@==100} (untested)

I guess it depends on context - here you're using it in a +=, but in other cases you might waste the saving on parentheses.

@msh210 The challenge says your one language's text datatypes. Arrays are hardly Perl's text datatype... (Otherwise it would have saved 1 byte indeed)

@Neil yea, & precedence is a bit low, but I'm pretty sure it could have saved me one byte more than once!

05AB1E, 9 bytes
5bIvAyk>-

Try it online!
Explanation
As 1 is the only truthy value in 05AB1E we can save a byte using subtraction over comparing to 100.
5b         # convert 5 to binary (results in 101)
  Iv       # for each letter in input word
    Ayk    # get the index of the letter in the alphabet
       >   # increment
        -  # subtract from total

PowerShell, 36 30 bytes
$args|%{$s+=$_[0]-96};$s-eq100

Try it online!
Inputs as an array, but I'm wondering if there is a better way to handle characters.
EDIT Missed an easy space but @AdmBorkBork kindly let me know :P also, there was in fact a better way to handle the characters!

Hiya - a couple quick golfs. You don't need the parens around [char]$_-96, and you don't need the space between -eq and 100, getting you down to 33. You can also do "$_"[0] instead of [char]$_, getting you down to 32. Try it online!

Are the " around $_ necessary? It appears to work without the cast. Could it be due to the input being a string array already?

Ah, indeed you are correct. The " aren't needed in this particular instance.

Dyalog APL, 17 15 bytes
100=+/17-⍨⎕AV⍳⍞

Uses the Dyalog Classic character set.
              ⍞  ⍝ string input
          ⎕AV⍳   ⍝ index in the character map
      17-⍨       ⍝ subtract 17 from each ('a' = 18)
    +/           ⍝ sum
100=             ⍝ equal to 100?

By default all submission must be full programs or functions. REPL programs are allowed as long as they're identified as such. However, you still have to request user input.

Alice, 28 18 bytes
Thanks to @MartinEnder for golfing 10 bytes
=I.!'`-+?hn
>3-nO@

Try it online!
This submission uses a different method than @MartinEnder's answer.
This submission outputs 0x00 for falsy and 0x01 for truthy.
So here is a version that outputs 0 or 1 instead: Try it!
Explanation
The explanation below is for the "visible" version. Both are very similar, except in the first program, the last o doesn't convert the 0 or 1 into a string (because we are in cardinal mode), but instead takes the number and output the character at that code point.
=                 Does nothing, but will be useful later on
I                 Read a character and push its code point onto the stack
                  If there is no more input, -1 is pushed instead
.                 Duplicate it
!                 Store it on the tape
#                 Skip the next command
o                 Gets skipped
'`                Push 96
-                 Subtract it from the character
+                 And add it to the total
?                 Load the number on the tape
h                 Increment it
n                 And negate it
                  For all characters that are read, ?hn results in 0,
                  but if -1 is pushed, then the result becomes 1

After this the IP wraps around to the left edge at the =. If the top value of the stack is 0, the IP continues on with its path, increasing the total sum of all the characters, once it is done with the input (the top of the stack will be 1), then the IP turns right (90 degrees clockwise).
One thing is important to note, the loop on the first line will iterate once after the input has ended. This will subtract 97 (96 from the '` and -1 from the lack of input) from the total.
>                Set the direction of the IP to East
3-               Subtract 3 from it (yields 0 if sum is 100, something else otherwise)
n                Negate it; Zero becomes 1, non-zero numbers become 0
/                Mirror; the IP gets redirected South-East
                 The IP reflects off the bottom and goes North-East
                 Now the program is in Ordinal mode, where numbers are automatically converted into strings when being used
o                Output the top of the stack as a string
                 IP reflects off the top and heads South-East
@                End the program

Taxi, 1259 bytes
Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to Auctioneer School.Go to Auctioneer School:s 1 r 1 l 1 l.Pickup a passenger going to Chop Suey.0 is waiting at Starchild Numerology.Go to Starchild Numerology:s 1 l.Pickup a passenger going to Addition Alley.Go to Chop Suey:e 1 l 2 r 3 r 3 r.[a]Switch to plan "b" if no one is waiting.Pickup a passenger going to Charboil Grill.Go to Charboil Grill:n 1 l 3 l 3 l.Pickup a passenger going to What's The Difference.Go to Go More:e.64 is waiting at Starchild Numerology.Go to Starchild Numerology:e 2 r.Pickup a passenger going to What's The Difference.Go to What's The Difference:e 1 l 2 r 1 l.Pickup a passenger going to Addition Alley.Go to Addition Alley:e 2 r.Pickup a passenger going to Addition Alley.Go to Chop Suey:n 1 r 2 r.Switch to plan "a".[b]Go to Addition Alley:n 1 l 2 l.Pickup a passenger going to Equal's Corner.100 is waiting at Starchild Numerology.Go to Starchild Numerology:n 1 l 1 l 3 l 2 r.Pickup a passenger going to Equal's Corner.Go to Equal's Corner:w 1 l.Switch to plan "c" if no one is waiting."TRUE" is waiting at Writer's Depot.[c]"FALSE" is waiting at Writer's Depot.Go to Writer's Depot:n 1 l 1 r.Pickup a passenger going to Post Office.Go to Post Office:n 1 r 2 r 1 l.

With line breaks, it looks like this:
Go to Post Office:w 1 l 1 r 1 l.
Pickup a passenger going to Auctioneer School.
Go to Auctioneer School:s 1 r 1 l 1 l.
Pickup a passenger going to Chop Suey.
0 is waiting at Starchild Numerology.
Go to Starchild Numerology:s 1 l.
Pickup a passenger going to Addition Alley.
Go to Chop Suey:e 1 l 2 r 3 r 3 r.
[a]
Switch to plan "b" if no one is waiting.
Pickup a passenger going to Charboil Grill.
Go to Charboil Grill:n 1 l 3 l 3 l.
Pickup a passenger going to What's The Difference.
Go to Go More:e.
64 is waiting at Starchild Numerology.
Go to Starchild Numerology:e 2 r.
Pickup a passenger going to What's The Difference.
Go to What's The Difference:e 1 l 2 r 1 l.
Pickup a passenger going to Addition Alley.
Go to Addition Alley:e 2 r.
Pickup a passenger going to Addition Alley.
Go to Chop Suey:n 1 r 2 r.
Switch to plan "a".
[b]
Go to Addition Alley:n 1 l 2 l.
Pickup a passenger going to Equal's Corner.
100 is waiting at Starchild Numerology.
Go to Starchild Numerology:n 1 l 1 l 3 l 2 r.
Pickup a passenger going to Equal's Corner.
Go to Equal's Corner:w 1 l.
Switch to plan "c" if no one is waiting.
TRUE is waiting at Writer's Depot.
[c]
FALSE is waiting at Writer's Depot.
Go to Writer's Depot:n 1 l 1 r.
Pickup a passenger going to Post Office.
Go to Post Office:n 1 r 2 r 1 l.

It accepts upper or lowercase because the Auctioneer School converts it all to uppercase.
Chop Suey breaks it into individual characters.
Charboil Grill converts characters to their ASCII code.
We pickup one character a time, convert it to ASCII, subtract 65, and add it to the running total.
Once there aren't any more characters, compare the total to 100.
Returns TRUE for dollar words and FALSE for everything else.

In a world of "boring" unreadable code-golf langages <20bytes answers, I welcome thy entry, kind stranger.

IA-32 machine code, 21 bytes
Hexdump:
33 c0 6a 64 5a 8a 01 41 24 1f 75 05 83 ea 01 d6
c3 2b d0 eb f0

Assembly code:
    xor eax, eax;   initialize eax to 0
    push 100;       initialize edx
    pop edx;            to 100
myloop:
    mov al, [ecx];  load a byte
    inc ecx;        go to next byte
    and al, 31;     convert from letter to number
    jnz cont;       not done? continue

    ;               done:
    sub edx, 1;     check whether edx got to 0; result is in CF
    __emit(0xd6);   aka SALC - set al to CF
    ret
cont:
    sub edx, eax
    jmp myloop

Counts from 100 to 0. If arrived to 0, returns true (0xff); otherwise false (0x00).

///, 564 210 189 185 bytes
/~/1\/\///4/11~3/41//6/33//2/66//5/22~a/~b/1~c/4~d/3~e/31~f/34~g/6~h/16~i/46~j/36~k/316~l/346~m/2~n/12~o/42~p/32~q/312~r/342~s/62~t/162~u/462~v/362~w/3162~x/3462~y/22~z/122~5555/0///1/0

Try it online!
Prints a 1 if it is a "dollar word", otherwise prints a "0"
Input is the following: (Scroll all the way to the right)
/~/1\/\///4/11~3/41//6/33//2/66//5/22~a/~b/1~c/4~d/3~e/31~f/34~g/6~h/16~i/46~j/36~k/316~l/346~m/2~n/12~o/42~p/32~q/312~r/342~s/62~t/162~u/462~v/362~w/3162~x/3462~y/22~z/122~5555/0//INPUT WORD HERE/1/0

Works by replacing each letter with its value in unary, then replacing a unary 100 with a 0. It then substitutes whatever the word's value is with a 1. If the word's value is 0, then it will print a 1 because at the end of the code, it is replacing a 0. If the word's value is anything else, it will just print that 0.
The golf works by using common occurrences in the code as replacements.

Python, 38 bytes
lambda s:sum(map(ord,s))==4-96*~len(s)

Try it online!
Same length as ovs's solution. Rather than subtracting 96 from each ord value, this checks if the ord total equals 100+96*len(s). This is expressed one byte shorter as 4-96*~len(s), which equals 4-96*(-len(s)-1).

In Python 3, lambda s:sum(s.encode(),96*~len(s))==4 would also work.

Japt, 13 12 10 bytes
L¥U¬x_c %H

Explanation:
L¥ U¬x _c %H
L¥(U¬x(_c %H))
L¥(          )   // 100==
   U¬            //   Input split into a char array
     x(     )    //   The sum of:
       _         //     At each char:
        c        //       Get the char-code and
          %H     //       Mod 32

Test it online!
12-bytes:
L¥U¬mc m%H x

Try it online!
Another 12-byte solution using a different technique
L¥U¬x@;CaX Ä

Try it online!

Great job! I think you can save a byte on the first one with m%H instead of m-96 (it'll work on both cases now, bonus!), and one on the second with L¥U¬x@;CaX Ä

@ETHproductions Thanks! m%H was a nice find. x@ was a great idea too!

@ETHproductions Got it down to 10 bytes ;)

Ruby, 35 30 bytes
->w{196==eval(w.bytes*'-96+')}

Try it online!

Retina, 47 23 bytes
\w
!$&
}T`l`_l
^!{100}$

Try it online! Note: Header lowercases input and splits it into words; results appear on separate lines. Edit: Saved far too many bytes thanks to @MartinEnder.

It's a lot shorter to compute the letter values by gradually lowering them while inserting characters: https://tio.run/nexus/retina#C0nwScjhCk6IjkvUrYrV5lLV0HBP@B9TzqWoosZVG5KQkxCfwxWnWG1oYFCr8v@/U2pRXmJRSmZevkJmSmpeSWZaZmqxQmleYk5JalFqikJKfk5OYpFCeX5RSjEA

Octave, 18 bytes
@(x)sum(x-96)==100

Subtracts 96 from the input string x (lower case), to get the numeric values of the letters. Takes the sum and compares it to 100. Returns a logical 1 for truthy cases, and a logical 0 for false cases.
I could save one byte if it was OK to give false for "dollar words" and true for "non-dollar words".

Ruby (2.4+), 38 bytes
Takes input in lowercase. Requires Ruby 2.4's Array#sum so it won't run on TIO.
->a{a.chars.map{|c|c.ord-96}.sum==100}

Use String#bytes instead of String#chars so you don't have to call c.ord.

And use sum on the array instead of map

Aceto, 49 bytes
TL;DR: 3rd-order Hilbert curve. Uses character input, looping until a newline is given. Sums up the values (96 (5*3+9*9) minus them), and in the end adds 100 (5*5*4) and checks whether it's zero. Uses the fairly new catch marks.
}){(
(o-+
d{))
|(&
=,d@*45(
{d""*+5(
3*)+=0
599*p

Outputs True if the given word is a dollar word, False otherwise.
Explanation:
We first construct a 96 by calculating 5*3+9*9: 53*99*+. Next, we move a stack to the right and push an empty string: )"". Because we're about to enter a repeating part, we set the catching mark using @. This is where we will return if an error occurs.
We duplicate the empty string, read a single character (,), duplicate that character, and move it to the original stack ({). Still on the right stack, we compare the top two values (the empty string and our character) and use the conditional mirror to jump to the right edge if they are equal: =|.
Assuming they're not, we now move on the left stack, push the character once more one stack to the left, duplicate the 96, go to the left stack, push the character back on the middle stack and go there again: ({d(}).
Now we convert the character to the value of its unicode codepoint and subtract it from 96, resulting in it's negated dollar value: o-. We do it this way, because we'd have to swap the values otherwise. We push the value to the left stack, go there, and add the two values there (initially 0 and our negative character value): {(+. To prepare for reading another character, we go to the middle stack again ), and then raise an error: &.
Once a newline is read and the character is therefore empty and the equality truthful, we got mirrored somewhere on the top-left quadrant; the exact position doesn't matter in our case. The next operation that does something is moving back on the stack of our final value: ((. On it, we should now have the sum of all character values, negative. That means, if it's a dollar word, it should be -100. To test whether it is, we add 100 (554**+), push 0, test for equality and print the result: =p.

Bash + GNU utils, 47
od -An -td1 -vw1|sed 's/^/a+=-96+/;$a!a-100'|bc

Try it online.

R, 36 39 bytes
Using a different method than the other R answer
function(x)sum(utf8ToInt(x)-96)==100

This is an unnamed function for lowercase characters. utf8ToInt(x) converts the string into a vector of ascii values.  96 is taken away from all items and sum checked against 100.
In use
> f=
+ function(x)sum(utf8ToInt(x)-96)==100
> f('buzzy')
[1] TRUE
> f('boycott')
[1] TRUE
> f('identifies')
[1] TRUE
> f('adiabatically')
[1] TRUE
> f('ttttt')
[1] TRUE
> f('zzz')
[1] FALSE
> f('zzzzzzz')
[1] FALSE
> f('abcdefghiljjjzz')
[1] FALSE
> f('tttt')
[1] FALSE
> f('basic')
[1] FALSE

You can save a few bytes by using sum(utf8ToInt(scan(,""))-96)==100 instead of defining a function using function(x).

@JarkoDubbeldam Generally that would be considered a snippet as it requires a REPL to output the result.  I would have to wrap a cat around it to make it a full program

is that new? Generally the implicit print when something is not assigned was considered 'output'.

@JarkoDubbeldam Not that new I think, I've been pinged on it before

Odd, that never was mentioned on any of my submissions :x

CJam, 9 bytes
q'`f-:+E=

Input should be in lowercase with a trailing newline. This is a tad cheaty as there's no reason to append a newline to the input, but it follows the rules as written.
Try it online!
How it works
q         e# Read all input from STDIN and push the resulting string on the stack.
 '`       e# Push the backtick character.
   f-     e# Subtract the backtick character from each input character. The
          e# difference of two characters is the difference of their code points,
          e# so this maps a..z to 1..26 and the newline to -86.
     :+   e# Take the sum.
       E  e# Push 14.
        = e# Test the sum and 14 for equality.

If it makes your program shorter and it doesn't really affect look, that's why it's in the rules :)

C++ (gcc), 45 bytes
Unnamed generic lambda, accepting char[], std::string or any other container of char and returning via reference parameter.

0 means dollar word
everything else is no dollar word

Even works for capital letters ;>
[](auto&s,int&r){r=100;for(auto x:s)r-=x&31;}

Try it online!

tinylisp, 56 bytes
(load library
(q((W)(e 100(s(sum(chars W))(*(strlen W)96

Anonymous function that takes a lowercase word (must be quoted, like (q bernardino)) and returns 1 for dollar words and 0 otherwise. Try it online!
Or, 53 bytes if I can swap truthy and falsey (returns 0 for dollar words and some nonzero integer otherwise):
(load library
(q((W)(-(sum(chars W))100(*(strlen W)96

Try it online!
Ungolfed/explanation
(load library)                 ; Needed for sum, *, strlen, and ungolfed aliases

(lambda (word)                 ; Anonymous function with one argument
  (equal? 100                  ; Is the following equal to 100?
    (sub2                      ; The difference of
      (sum (chars word))       ; the sum of the codepoints of the word
      (* (strlen word) 96))))  ; and 96 times the length of the word

Factor + math.unicode, 19 bytes
[ 96 v-n Σ 100 = ]

Try it online!
Explanation
       ! "boycott"
96     ! "boycott" 96
v-n    ! { 2 15 25 3 15 20 20 }
Σ      ! 100
100    ! 100 100
=      ! t

PHP, 45 Bytes
combination 3 Bytes saved by @user63956
input as argument list
for(;$s+=ord($argv[++$i])%32?:die($s==100););

input as string using the -R option
for(;$s+=ord($argn[$i++])%32?:die($s==100););

PHP, 48 Bytes
combination
for(;$c=$argv[++$i];)$s+=ord($c)%32;echo$s==100;

PHP, 50 Bytes
Running PHP from the commandline without a file $argv[0] is "-"
prints 1 for true and nothing for false
lowercase
echo array_sum(array_map(ord,$argv))-96*$argc==49;

uppercase
echo array_sum(array_map(ord,$argv))-64*$argc==81;

for(;$s+=ord($argv[++$i])%32?:die($s==100);); saves 3 bytes.

@user63956 nice trick thank you

You should either mention that you take the letters as distinct command line arguments or use -R and $argn[$i++].

@Titus Done If you find other improvements you can edit it by yourself

Java 7, 77 74 bytes
boolean c(String s){int r=0;for(int c:s.getBytes())r+=c&31;return r==100;}

Case-insensitive thanks to @Neil by changing c-96 to c&31.
-3 bytes thanks to @SuperChafouin.
Explanation:
Try it here.
boolean c(String s){          // Method with String parameter and boolean return-type
  int r=0;                    //  Resulting sum-integer
  for(int c:s.getBytes())     //  For each character in the String (as integer value)
    r+=c&31;                  //   Sum its alphabetic 1-indexed index (case-insensitive)
                              //  End of loop (implicit / single-line body)
  return r==100;              //  return if the sum equals 100
}                             // End of method

Could counting down from 100 save bytes? Also, &31 might work to make your code case insensitive.

@Neil Thanks for the tip of making it case-insensitive. But counting down from 100 is the same byte-count: boolean c(String s){int r=100;for(int c:s.toCharArray())r-=c-96;return r==0;}

As input is a-z, maybe you can use getBytes ?

Ah, of course, this is Java, it takes 3 bytes to compare to zero...

jq, 28 characters
(25 characters code + 3 characters command line option)
[explode[]|.-96]|add==100

Sample run:
bash-4.3$ jq -R '[explode[]|.-96]|add==100' <<< 'bernardino'
true

On-line test

C#, 72 64 bytes

Golfed
(string w)=>{int s=0;foreach(var c in w)s+=c-96;return s==100;};

Ungolfed
( string w ) => {
   int s = 0;

   foreach( var c in w )
      s += c - 96;

   return s == 100;
};

Ungolfed readable
( string w ) => {
   // Initialize the var to store the sum of the chars
   //    of the given word
   int s = 0;

   // Cycle through each char
   foreach( var c in w )

      // Add it to the sum minus 96
      //    'a' == 97
      s += c - 96;

   // Return if the sum is equal, or not, to 100
   return s == 100;
};

Full code
using System;
using System.Collections.Generic;

namespace Namespace {
   class Program {
      static void Main( String[] args ) {
         Func<String, Boolean> f = ( string w ) => {
            int s = 0;

            foreach( var c in w )
               s += c - 96;

            return s == 100;
         };
         List<String>
            testCases = new List<String>() {
               "buzzy",
               "boycott",
               "identifies",
               "adiabatically",
               "ttttt",
               "zzz",
               "zzzzzzz",
               "abcdefghiljjjzz",
               "tttt",
               "basic",
            };

         foreach( String testCase in testCases ) {
            Console.WriteLine( $" Input: {testCase}\nOutput:{f( testCase )}\n" );
         }

         Console.ReadLine();
      }
   }
}

Releases

v1.1 - -8 bytes - Swapped the for loop with a foreach one
v1.0 - 72 bytes - Initial solution.

Notes

$

braingasm, 20 bytes
Assumes input without trailing newlines, e.g echo -n "unaltered" | braingasm dollarwords.bg
,[96-[->+<],]>100-z:

Could easily been done in plain brainfuck, if I had the patience for it.
,                       Read a byte to the current cell.
 [                      While there's something in the current cell:
  96-                     subtract 96 from it,
     [->+<]               move the remainder to the next cell,
           ,              read another byte.
            ]
             >100-      Move to next cell and subtract 100 from it,
                  z:    print 1 if remainder is zero, 0 if not.

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

Try it online!

Brachylog, 12 9 bytes
-3 bytes thanks to Fatalize
ạ-₉₆ᵐ+100

Takes input as a string of lowercase letters. Try it online!
Explanation
ạ          Convert input string to a list of ASCII codes
    ᵐ      To that list, map this predicate:
 -₉₆        Subtract 96 from each charcode
     +     Sum the resulting list of numbers 1-26
      100  Succeed if the sum is 100, fail otherwise

You can save 3 bytes like this: ạ-₉₆ᵐ+100

R, 45 bytes
sum(as.numeric(charToRaw(scan(,"")))-96)==100

Try it online!
Returns TRUE or FALSE.
As stated in the question, expects user input in a-z, converts the characters to numbers, brings them to the 1–26 range, and checks if the sum is equal to 100.
Even if one converts it to a function, it still beats Giuseppe’s answer in terms of byte count (it would be 48):
function(x)sum(as.numeric(charToRaw(x))-96)==100

Stax, 9 bytes
ü☺ïΦΘ╬╟₧╘

I love the ☺ in the code! Potential Stax/Emojicode polyglot in the future...?
Run and debug it at staxlang.xyz!
Unpacked (10 bytes):
{64-m|+AJ=

Explanation:
{   m         Form a block and map it over input.
 64-            Push 64 and subtract it from the character code.
     |+       Sum the resulting array.
       AJ     Push 10 and square it.
         =    Check for equality!

I'm quite new to Stax (and golfing languages); this can almost certainly be shortened. I think the { can probably be dropped with proper placement of the m...
Another approach (imperative, 10 bytes):
ú☼7Tí:£_▓δ

12 unpacked:
c|+AJ-s%64*=
c               Copy the top item on the stack.
 |+             Sum it. For a string, this sums code points.
   AJ           Push 10 and square, yielding 100.
     -          Subtract this 100 from the earlier sum.
      s         Swap the top two items, putting the input back on top.
       %        Push the input's length.
        64*     Push 64 and multiply.
           =    Check for equality!

Input for both is capital letters. For lowercase, replace 64 with 96.

Rust, 158 bytes
fn main(){let(i,mut c)=(&mut"".into(),0);std::io::stdin().read_line(i);let l:Vec<u8>=i.trim().bytes().collect();for b in&l{c+=*b as u8-96}print!("{}",c==100)}

Ungolfed
fn main() {
    let (input_string, mut count) = (&mut "".into(), 0);
    std::io::stdin().read_line(input_string);
    let bytes: Vec<u8> = input_string.trim().bytes().collect();
    for byte in &bytes {
        count += *byte as u8 - 96;
    }
    print!("{}", count == 100);
}

Prints true if the input is a dollar word, and false if it is not. Only works on lower case letters.

I don't believe that zero is considered a truthy value in rust.  Here is how we generally define truthy.  It is not the clearest, which is why we have been moving away from the terminology lately but I don't think it includes 0.

You can also likely save a byte by using *b as u8 instead of u64.  Unless I am missing something.

Thanks for the clarification. I've edited my answer

BQN, 13 12 bytes
-1 byte thanks to Razetime
100=0+´-⟜'`'

Anonymous tacit function that takes a lowercase string as its argument. Try it!
Explanation
       -⟜'`'  Subtract ` from each character of the argument; gives list of numbers 1-26
    0+´       Fold on addition, starting at 0
100=          1 if the result equals 100, 0 otherwise

with ·(nothing you can make the tacit version 12: 100=·+´-⟜'`'

Useful usescript: https://github.com/razetime/userscripts/blob/main/bqncgcc.user.js

Ah, thanks. I didn't realize fold had a dyadic version. I opted to use an explicit left argument of 0 instead because it was easier to explain.

nothing doesn't exactly count as a special case of fold, but rather a train function separator, so effectively BQN reads it as though it were your original solution: https://mlochbaum.github.io/BQN/try.html#code=MTAwPcK3K8K0LeKfnCdgJw==

TI-Basic, 53 bytes
ᴇ2=sum(seq(inString("ABCDEFGHIJKLMNOPQRSTUVWXYZ",sub(Ans,I,1)),I,1,length(Ans

Takes input in uppercase in Ans. Output is stored in Ans and displayed.

Julia 1.0, 19 bytes
s->sum(s.-'`')==100

Try it online!
Takes input as an array of characters (since the question explicitly allows that).

J 14 bytes or 10 bytes if rules allow!!!
100=+/_96+a.i.

        100=+/_96+a.i. 'identifies'
    1
        100=+/_96+a.i. 'ttttt'
    1
        100=+/_96+a.i. 'wrong'
    0

    Because:
                        a.i. gives position in code table 0-255
                    _96+ subtracts 96 ('a') from each value
                +/   adds them all together
            100= compares with 100

IDEA: Can a "truthy" value be 100, and a "falsey value be <> 100?
If so...
+/_96+a.i.

    +/_96+a.i. 'boycott'
    100
    +/_96+a.i. 'boycot'
    80

:O)

We have a rather specific definition of truthy/falsy, so I'm afraid calling 100 truthy and non-100 falsy is not allowed. 100=+/_96+a.i. is also not valid, albeit just because of a technicality: by default, submissions have to be full programs or functions. Tacit verbs are usually the shortest option.

I don't understand your second point. What is the difference between my attempt and the Dialog APL solution directly above it???

I also don't understand your first point. In the discussion, it was proposed: if (x) {     print "x is truthy"; } else {     print "x is falsy"; }. With my idea, substitute "answer is 100" for x and all is well.

Hadn't seen the APL answer; left a comment there as well.

You don't get to define which check to perform to determine truthiness; your language does. For J, non-zero integers are truthy and zero is falsy. https://tio.run/nexus/j#@59ZXFJUWpJRqWBrpWCsYKVgwKUABJlpekCyUiElX09BHaJAHSyRmlOcCpICAfW0xJximHheih6XJhdXanJGvgLczNTE5AyFeEMFAwVDBUtLBUMDg///AQ

Groovy, 32 characters
{s->s*.value.sum{it[0]-96}==100}

Sample run:
groovy:000> ({s->s*.value.sum{it[0]-96}==100}("bernardino"))
===> true

Ruby 2.4, 30 + 1 = 31 bytes
One extra byte for the n flag: $ ruby -n dollar_words.rb
p chop.bytes.sum{|c|c-96}==100

Prints true or false for each given line of input:
$ ruby -n dollar_words.rb
zzzzz
false
unaltered
true
dollar
false

QBIC, 34 bytes
;[_lA||p=p+asc(_sA,a,1|)%32]?p=100

Explanation:
;               Get A$ from the cmd-line
[_lA||          FOR a = 0; a <= a$.Length(); a++
p=p+asc(        Increment P with the ASCII value of
_sA,a,1|)%32]     A$.Substring(a,1) mod 32 (thank you @JonathanAllan, that's a neat trick!)
?p=100          When done, print -1 if p is 100, 0 otherwise

Pyth, 16
!-100+Fm+1xGdcQ1

Try online.

Röda, 25 bytes
{[ord(_)-96]|sum|[_=100]}

Try it online!

Batch, 189 bytes
@set/p,=
@set z=1
@for %%a in (a b c d e f g h i j k l m n o p q r s t u v w z y)do @set/a%%a=z,z+=1
@set .=100
:l
@set/a.-=%,:~,1%
@set ,=%,:~1%
@if not "%,%"=="" goto l
@exit/b%.%

Takes lowercase input on STDIN and ouputs via ERRORLEVEL (0 is truthy). Batch has no character code operator so I set the variables a-z to their value in a loop, then I individually evaluate all the characters in the input word and subtract them all from 100.
By using non-alphabetic variable names the code is readily extended to handle uppercase input.

Pyth, 9 bytes
q100smhxG

Explanation:
q100smhxGdQ autofill variables
       xGd  [index of d in "abcdefghijklmnopqrstuvwxyz"
      h      + 1
     m    Q  for d in eval(input())]
    s       sum(^)
q100        == 100

Test suite.

Came to the exact same program, but you need to count the d for 10 bytes, no?

Nope! d automatically gets filled in, since it's inside m.  Variables inside lambdas autofill to the lambda's parameter (the first input in the case of two parameters).  Look at what Python code results from this Pyth.

Fixed arity continues to be the greatest gift to the code golf in history, dang!

Excel, 52 + 2 bytes
{=SUM(IFERROR(CODE(MID(A1,ROW(A1:A100),1))-64,0))=100}

Input is in cell A1 in all uppercase.
Must be entered as an array formula with Ctrl+Shift+Enter (Adds the curly brackets { }).
Returns TRUE for dollar words and FALSE for others.

Rip, 27 bytes
10gDiW[8DmsagDi]P9iDmsI[d]O

Works only for uppercase input, which it reads from stdin. Please do not end the input with a newline. :)
Explanation:
1                            0I[Push a 1 for later]
 0                           0I[Sum is 0 now]
  gDiW[                      0I[Getchar, duplicate, increment, while: while not EOF]
       8Dms                  0I[8 8 dup mul subtract: subtract 65]
           a                 0I[Add to the current total]
            gDi]             0I[Getchar, dup, increment, end while: while not EOF]
                P            0I[Pop the last -1 (=EOF) read]
                 9iDms       0I[Subtract 100 (9 incr dup mul subtract)]
                      I[d]   0I[If not zero, decrement the first 1 (see first line) to a 0]
                          O  0I[Output the result (1 if ==100, 0 else) as a number]

C# / Linq, 42 bytes
Is Linq cheating?
(string w)=>{return w.Sum(x=>x-96)==100;};

Given Linq is a default .NET library it might be cheating a little, but you should be fine given you specified it's C# with Linq. Also you don't need string before w, or parentheses around it, you can just do w=>{...};

Based on other Java/C# answers, this format seems OK w=>w.Sum(x=>x-96)==100. I can see how the compiler having to infer the type of w from somewhere being a little odd though.

Braingolf, 13 bytes [non.competing]
{#`-}&+#de1:0

Try it online!
Requires all lowercase input, outputs 1 for dollar word, 0 otherwise
Explanation
{#`-}&+#de1:0  Implicit input of string as char values to stack
{...}          Foreach item on stack..
 #`            ..Push char value of ` (96)
   -           ..Subtract from input char value
     &+        Sum entire stack
       #d      Push char value of d (100)
         e     If last 2 items are equal..
          1    ..Push 1
           :   else
            0  ..Push 0
               Implicit output of last item on stack

Perl 5, 28 + 1 (-p) = 29 bytes
s/./96-ord$&/ge;$_=-100^eval

Try it online!
Returns 0 for truthy, anything else for falsey.  Assumes lowercase input.
How?
Replace each character with the additive inverse of its position in the alphabet.  Then, evaluate that equation and XOR it with -100 to determine if this is a dollar word.

Common Lisp, 56 bytes
(=(loop as x across(read-line)sum(-(char-code x)96))100)

Try it online!

Proton, 32 bytes
map(ord+((-)&96))+sum+((==)&100)

Try it online!
Waiting for pull from TIO.

SmileBASIC, 48 bytes
INPUT W$WHILE""<W$D=D+ASC(POP(W$))-64WEND?D==100

The classic string eating loop.

Pyth, 15 bytes
Vz=+ZhxGN)qZ^T2

Try it online!
The other Pyth answers use Q=eval(input()), which means the input must be in quotes in order to be valid. This program does not have that stipulation.
Pyth (indented) | Python 3 (translation)
             | G="abcdefghijklmnopqrstuvwxyz"
             | T=10
             | Z=0
             | z=input()
Vz           | for N in z:
    =+ZhxGN) |     Z+=G.find(N)+1
qZ^T2        | print(Z==T**2)

Befunge-98, 14 13 bytes
+~'@ #.-"d"$#

Try it online!
Takes input as uppercase letters. Outputs 0 for truthy, any other number for falsey.
How It Works:
 ~          Get input and continue right.
+ '@   -    Subtract 64 from the letter and add it to the total
 ~          On EOF go left instead
       -"d" Subtract 100 from the total
   @  .     Print the value and end the program

Pip, 11 bytes
A_-96MSa==h

Takes a string of lowercase letters as a command-line argument. Try it online!
How it works
             a is 1st command-line arg; h is 100 (implicit)
A_           An anonymous function that takes the ASCII value of its argument
  -96        and subtracts 96
     MSa     Map that to the characters of a and sum the result
        ==h  Test if that's equal to 100
             The result (0 or 1) is autoprinted

We use == (exact equality) instead of the usual = (numeric equality) because it has lower precedence than MS.

Tcl, 70 bytes
puts [expr 100==[join [lmap c [split $argv ""] {scan $c %c}] -96+]-96]

Try it online!

Tcl, 71 bytes
proc D s {expr 100==[join [lmap c [split $s ""] {scan $c %c}] -96+]-96}

Try it online!

Tcl, 74 bytes
puts [expr 100==[join [lmap c [split $argv ""] {expr [scan $c %c]-96}] +]]

Try it online!
Saved a byte using a command line argument instead of a function.

Tcl, 75 bytes
proc D s {expr 100==[join [lmap c [split $s ""] {expr [scan $c %c]-96}] +]}

Try it online!

Add++, 18 bytes
D,f,@~,€O96€_s100=

Try it online!

Julia 0.6, 27 bytes
s->sum(c->Int(c)-96,s)==100

Try it online!

-3 bytes using broadcast subtraction instead of map: Try it online!

Kotlin, 23 bytes
{it.sumBy{it-'`'}==100}

Try it online!

Ahead, 21 bytes
>jvi96-+v
^~>'d=O~<~@

Try it online!

Attache, 20 bytes
{100=Sum[_-96]}@Ords

Try it online!
Explanation
{100=Sum[_-96]}@Ords
               @Ords    convert input to ordinates
{             }         anonymous lambda, input: _
         _-96           subtract 96 from each char
     Sum[    ]          take the sum
 100=                   is it equal to 100?

Alternatives
20 bytes: {100=Sum[Ords@_-96]}
21 bytes: 100&`=@Sum@`-&96@Ords
22 bytes: {100=_}@Sum@`-&96@Ords
22 bytes: {100=Sum@_}@`-&96@Ords
24 bytes: {100=Sum!-~_}##STN=>List
25 bytes: {100-#_=Sum@_}##STN=>List
25 bytes: {100=Sum[_+1]}##STN=>List
26 bytes: {100=Sum[_+1]}##STN=>Chars
26 bytes: 100&`=@Sum##Succ@STN=>List
27 bytes: {100=_}@Sum##Succ@STN=>List

F# (Mono), 38 bytes
fun s->Seq.sumBy(fun c->int c-96)s=100

Try it online!

APOL, 33 bytes
v(0);f(i ∆(0 +(⌕(ⓛ ∋) 1)));=(⁰ ô)

Batch 210 bytes
@Set i=%1&set/A$=}=0&Setlocal Enabledelayedexpansion&@For /l %%i in (97 1 123)Do @Cmd/C Exit %%i&Set/A"!=exitcodeASCII!}=%%i-96"
@For /l %%i in (0 1 99)Do @Set/A$+=!i:~%%i,1!}
@If !$!==100 (Echo(1)Else Echo(0

Defines a group of associated variables for each character containing the appropriate cent value. iterates over the string incrementing by the cent value of the current character. } is used to associate the variables, and also is defined as a variable with zero value to prevent missing operator errors if the current index exceeds the strings length. Iterates to a string length of 100 characters seeing as 100 A's is the longest possible dollar "word"
Edit: input is via command line argument when executing from cmd.exe

Old solution:
Python 3, 38 bytes
lambda s:sum(ord(c)-96for c in s)==100

Try it online!
Realized that was a duplicate so...
Python 3, 42 bytes
lambda s:sum(n-96for n in map(ord,s))==100

Try it online!

Vyxal, 6 bytes
C₆-∑₁=

Try it Online!
A port of the GS2 answer. Requires input to be uppercase (7 bytes for lowercase)
Explained
C₆-∑₁=  # Full program - takes single string S
C       # push [ord(char) for char in S]
 ₆-     # and subtract 64 from each
   ∑    # and get the sum of that.
    ₁=  # does that equal 100?

Oh look, a use case for the K flag

Ly, 12 bytes
iy'`*N&+'d-!

Try it online!
Take input as lowercase characters.
i             - read input to stack as codepoints
 y            - push number of chars on stack
  '`          - push codepoint("a")-1 on stack
    *N        - multiple, flip sign
      &+      - sum the stack
        'd    - push 100 (codepoint for "d") on the stack
          -   - subtract from sum
           !  - "not" to map 0 to 1 and anything else to 0, prints automatically

MathGolf, 6 bytes
$♥%Σ♀=

Input as a list of characters. Input casing is irrelevant; can be lower-, upper-, or even mixed cased.
Try it online.
Explanation:
$      # Convert each character in the (implicit) input-list to a codepoint-integer
 ♥%    # Modulo-32 on each
   Σ   # Sum the list together
    ♀= # And check if it's equal to 100
       # (after which the entire stack is output implicitly as result)

Whitespace, 105 104 bytes
[S S S N
_Push_0][N
S S N
_Create_Label_LOOP][S N
S _Duplicate_sum][S N
S _Duplicate_sum][S N
S _Duplicate_sum][T N
T   S _Read_STDIN_as_Character][T   T   T   _Retrieve_input][S N
S _Duplicate_input][S S S T S T S N
_Push_10][T S S T   _Subtract][N
T   S S N
_If_0_Jump_to_Label_PRINT][S S S T  S S S S S N
_Push_32][T S T T   _Modulo][T  S S S _Add][N
S N
N
_Jump_to_Label_LOOP][N
S S S N
_Create_Label_PRINT][S N
S _Duplicate_10][T  S S N
_Multiply][T    S S T   _Subtract][S N
S _Duplicate][N
T   S T N
_If_0_Jump_to_Label_TRUTHY][S S T   T   N
_Push_-1][N
S S T   N
_Create_Label_TRUTHY][T N
S T _Print_as_integer]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.
Input casing is irrelevant; can be lower-, upper-, or even mixed cased.
Since Whitespace can only read input one character at a time, the input must contain a trailing newline so we'll know when we're done reading characters.
Whitespace also lacks truthy/falsey values, so this program will output 0 for truthy and -1 for falsey (could be 5 bytes less with 0 as truthy and any other integer as falsey).
Try it online (with raw spaces, tabs and new-lines only).
Explanation in pseudo-code:
Integer sum = 0
LOOP:
  Integer c = STDIN as character-codepoint
  If(c == '\n'):
    Jump to PRINT
  c = c modulo-32
  sum = sum + c
  Jump to LOOP

PRINT:
  If(sum == c*c):   // Note: c=10 at this point, which is the codepoint for '\n'
    Integer result = 0
    Jump to TRUTHY
  result = -1
  TRUTHY:
    Print result as integer to STDOUT

Thunno 2, 4 bytes
ÄSɦ=

Attempt This Online!
Explanation
ÄSɦ=  # Implicit input
Ä     # Alphabet to number
 S    # Sum the list
   =  # Equals
  ɦ   # 100?
      # Implicit output

source: Stack Exchange

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

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

sort: votes


text:
Calculate a User's Reputation
Challenge
Given a user's name (not ID, we have that challenge already), output their current reputation and their ID.
Input
Input will be a single string which is the user's username. You may assume that this user exists.
Output
Output will be two integers to either STDOUT or STDERR which will be the user's reputation and the user's ID. They must be in that specific order and can be output in any reasonable format
Specifics

The reputation output must not be more than 10 minutes out of date.
Your program may not throw any errors during normal execution
Standard loopholes apply (including No URL Shorteners)
If there is more than one user with that username, you may output the stats of any user with that username. This is also why you must output the ID.
The reputation to be output is the reputation of the user on PPCG, not the network total score.

The Stack Exchange API site can be found here. You can read the documentation from there.

Link the stack-exchange API.

@carusocomputing Will do, thanks. I also need to fix something because apparently multiple users can have the same name.

I suppose this rule applies? Also, can you confirm that it's the total reputation of the user on PPCG rather than SE?

@Arnauld I will say yes. And I confirm that it's just the PPCG reputation. I will clarify that in the challenge. Thanks.

Well I did this T-SQL entry but it doesn't meet rule 1 as it's not updated enough :(

@ʰᵈˑ Oh :( That's too bad. Yeah I did that to prevent answers using the cache :P

Is an answer valid if they output the results for a user whose name just contains the input string instead of having an exact match?

Would {"items":[{"reputation":2820,"user_id":42295}]} be a reasonable output format?

@Tom Sure. I will say yes. As long as it's obvious where the data is.

@HyperNeutrino Any input on the exact match question I had? So let's say your input was "tom" and your answer output was for "Tom Carpenter" would that be acceptable?

Bash + JQ, 93 bytes
Rolled back the 87 byte version, as it was not handling multi-user responses correctly.
Golfed
curl "api.stackexchange.com/users?site=codegolf&inname=$1"|zcat|jq ..\|numbers|sed -n 4p\;12p

Will output first user id and reputation on the separate lines.
How It Works ?
1)curl + zcat are used to fetch the JSON formatted API reply
2) jq ..|numbers will unfold JSON recursively, and print all the numeric values, one per line
...
1   35
2   8
3   2
4   3315904
5   1487694154
6   1492702469
7   4565
8   82
9   82
10  60
11  20
12  6275
...

(line numbers were added with nl for illustration purposes only)
3) Next we use sed to lookup the first account_id and reputation,
by their absolute row numbers
Test
>./reputation zeppelin
3315904
6275

JavaScript (ES6), 145 139 136 125 123 117 bytes
a=>fetch(`//api.stackexchange.com/users?site=codegolf&filter=!)LgZAmQ6ls0hH&inname=`+a).then(_=>_.text()).then(alert)

Saved 6 bytes thanks to Shaggy and 6 bytes thanks to Cyoce.
I'm not sure if it should output all users with the same name, or just one of them; this code outputs all of them.

f=a=>fetch(`//api.stackexchange.com/users?site=codegolf&filter=!)LgZAmQ6ls0hH&inname=`+a).then(_=>_.text()).then(alert)

f("tom")

Beat me to it. Save 6 bytes with "//api.stackexchange.com/users?site=codegolf&inname="+a.

Note: It seems you return more results than you (possibly) should. I've been trying to get HyperNeutrino's feedback on what is appropriate but your result returns values for users whose name just contains the input - not exactly matches.  So your top result is for "Tom Carpenter" and not "tom".

Would it be possible to replace _=>alert(_) with just alert?

@Dason Yep, that's one point I wasn't sure on; I'll change my answer when it's confirmed.

@Cyoce That worked, thanks!

@Tom I think the answer to that question would impact all the current answers so far since they're all basically using the same method to get the results.

Python 2, 178 169 149 Bytes
I'd use requests for this:
from requests import*
a=get("http://api.stackexchange.com/users?site=codegolf&inname="+input()).json()["items"][0]
print a["reputation"],a["user_id"]

Basically, it uses stack's api to fetch the information as JSON and then gets the item "reputation".  Additionally, the API featured many extra parameters, I shaved those off as well.
Generous contributions from: carusocomputing, ElPedro, Malivil, Keerthana Prabhakaran

["items"][0] this only gets the first result, on the multiple users case it will still ignore the extras if I'm not mistaken.

import requests as r and r.get(... saves 4 bytes.

@ElPedro updated it, thanks for the input.

It actually goes to 157 Try it online!. Note that it doesn't actually work on TryItOnline as it can't find requests but works locally for me. TIO is just somewhere to put the code :)

@ElPedro Nice, I updated it again.

If you rearrange the parameters so that it reads ?site=codegolf&inname=" you can save 3 bytes (+"")

@Malivil Very clever, updated it.

Also it works without the 2.2/ in the url. Not sure what version of the API it is using then but it saves another 4 :)

@ElPedro Updated. Thanks again.

Using from requests import*;a=get() reduces a byte!

@KeerthanaPrabhakaran Thanks for the input, updated it.

Groovy, 144 156 bytes
{new groovy.json.JsonSlurper().parse(new URL("http://api.stackexchange.com/2.2/users/?site=codegolf&inname=$it")).items.collect{[it.user_id,it.reputation]}}

Anonymous closure.
EDIT: forgot to use import of groovy.json. for JSON Slurper + 14 bytes.
Example output [[UserID, Reputation],...]:
[[20260, 60695], [20469, 21465], [3103, 8856], [41805, 7783], [134, 6829], [42643, 5622], [45268, 4389], [10732, 3976], [32, 3635], [53745, 3392], [10801, 3216], [49362, 2418], [2104, 2160], [3563, 1988], [18280, 1491], [742, 1466], [59487, 1362], [19039, 1330], [56642, 1133], [9522, 951], [34438, 886], [1744, 793], [52661, 778], [18187, 768], [11426, 751], [26850, 711], [178, 637], [29451, 631], [19700, 616], [15862, 601]]

JsonSlurper... o_O

slurrrrrrrrrp

@HyperNeutrino if you ever get a chance to look at it, I consider it my favorite JSON parsing library. It's so easy.

Alright, thanks! I'll take a look at it.

Swift, 225 201 bytes
import Foundation;var f:(String)->Any={return try!JSONSerialization.jsonObject(with:Data(contentsOf:URL(string:"http://api.stackexchange.com/users?site=codegolf&filter=!)LgZAmQ6ls0hH&inname=\($0)")!))}

Un-golfed:
import Foundation

var f:(String) -> [String: Any] = {
    return try! JSONSerialization.jsonObject(with:Data(contentsOf:URL(string:"http://api.stackexchange.com/users?site=codegolf&filter=!)LgZAmQ6ls0hH&inname=\($0)")!)) as! [String:Any]
}

Example output:
["items": <__NSArrayI 0x6180001ffc00>(
{
    reputation = 2820;
    "user_id" = 42295;
},
{
    reputation = 2468;
    "user_id" = 31203;
},
{
    reputation = 2106;
    "user_id" = 2800;
},
{
    reputation = 1479;
    "user_id" = 6689;
},
{
    reputation = 1287;
    "user_id" = 64424;
},
{
    reputation = 1037;
    "user_id" = 64070;
},
{
    reputation = 644;
    "user_id" = 25193;
},
{
    reputation = 641;
    "user_id" = 3171;
},
{
    reputation = 639;
    "user_id" = 743;
},
{
    reputation = 590;
    "user_id" = 33233;
},
{
    reputation = 571;
    "user_id" = 26993;
},
{
    reputation = 563;
    "user_id" = 1730;
},
{
    reputation = 321;
    "user_id" = 18570;
},
{
    reputation = 309;
    "user_id" = 39156;
},
{
    reputation = 291;
    "user_id" = 7880;
},
{
    reputation = 281;
    "user_id" = 25190;
},
{
    reputation = 261;
    "user_id" = 40820;
},
{
    reputation = 231;
    "user_id" = 14154;
},
{
    reputation = 206;
    "user_id" = 2774;
},
{
    reputation = 196;
    "user_id" = 48231;
},
{
    reputation = 181;
    "user_id" = 1230;
},
{
    reputation = 176;
    "user_id" = 64077;
},
{
    reputation = 171;
    "user_id" = 31365;
},
{
    reputation = 171;
    "user_id" = 43455;
},
{
    reputation = 163;
    "user_id" = 21469;
},
{
    reputation = 161;
    "user_id" = 11845;
},
{
    reputation = 157;
    "user_id" = 25181;
},
{
    reputation = 131;
    "user_id" = 263;
},
{
    reputation = 131;
    "user_id" = 3922;
},
{
    reputation = 128;
    "user_id" = 67227;
}
)
]

05AB1E, 58 bytes
’¸¸.Â‚‹º.ŒŒ/†š?€¼=ƒËŠˆ&€†‚ˆ=ÿ’.wD„n"¡1è¦',¡н,'‡¾¡2è¦¦',¡н,

Beats all other answers.
’...’.wD„n"¡1è¦',¡н,'‡¾¡2è¦¦',¡н,  # trimmed program
                   ,               # output...
                  н                # first element of...
             è                     # element at 0-based index...
            1                      # literal...
             è                     # in...
     .wD                           # content of response to request to URL...
                                   # (implicit) "http://" concatenated with...
’...’                              # "api.stackexchange.com/users?site=codegolf&inname=ÿ"...
                                   # (implicit) with ÿ replaced by...
                                   # implicit input...
           ¡                       # split by...
        „n"                        # literal
              ¦                    # excluding the first character...
                 ¡                 # split by...
               ',                  # literal
                                ,  # output...
                               н   # first element of...
                         è         # element at 0-based index...
                        2          # literal...
                         è         # in...
     .w                            # content of response to request to URL...
                                   # (implicit) "http://" concatenated with...
’...’                              # "api.stackexchange.com/users?site=codegolf&inname=ÿ"...
                                   # (implicit) with ÿ replaced by...
                                   # implicit input...
                       ¡           # split by...
                    '‡¾            # "id"...
                          ¦        # excluding the first character...
                           ¦       # excluding the first character...
                              ¡    # split by...
                            ',     # literal

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


text:
What characters are more common in my MD2 hash?
The challenge is simple
Write a script that, when given a string input, will hash the string using the MD2 hashing algorithm, and then return either a positive integer or negative integer output based on which character set below is more common in the resulting hash as a hexadecimal string:
01234567 - (positive)
89abcdef - (negative)

The input will always be a string, but may be of any length up to 65535
The entire input, whitespace and all, must be hashed
For the purposes of this challenge, the integer 0 is considered neither positive nor negative (see tie output)
The more common set is the one who's characters are more common within the 32 character hexadecimal hash string
Your output may contain trailing whitespace of any kind, as long as the only non-whitespace characters are a valid truthy or falsey output
In the event of a tie, where the hexadecimal string contains exactly 16 characters from each set, the program should output a 0

I/O Examples
Input: "" (Empty String)
Hash: 8350e5a3e24c153df2275c9f80692773
Output: 1

Input: "The quick brown fox jumps over the lazy cog" (Without quotes)
Hash: 6b890c9292668cdbbfda00a4ebf31f05
Output: -1

Input: "m" (Without quotes)
Hash: f720d455eab8b92f03ddc7868a934417
Output: 0

Winning Criterion
This is code-golf, fewest bytes wins!

It would be good to link to or ideally explain the MD2 hashing algorithm in the challenge specification to make it self contained.

@MartinEnder Will do!

I think it would be fair to simply accept three distinct values for win, lose, and tie

@mathjunkie true, probably shouldn't be changing the spec so much, but I guess just having 1, 0 or -1 is the best way

Hi there! Since others haven't mentioned it yet, I'll toss out a recommendation to use the Sandbox for future challenges, where you can get meaningful feedback and tighten up the challenge before posting on Main.

@AdmBorkBork Ah thanks! Had I know about that I'd've definitely done so before posting it, will keep that in mind for the future, thanks!

"are a valid truthy or falsey output" Shouldn't it be a valid integer...? "Your output may contain trailing whitespace of any kind, as long as the only non-whitespace characters..." The first part says trailing whitespace is allowed, but the second part implies leading and trailing whitespace are allowed. Which is it?

This strikes me as a chameleon challenge. Either your language has a build-in or library to do MD2 and the rest is simple character counting, or it doesn't and you have to implement it yourself.

@xnor A lot of challenges are trivial in some language and difficult in others. Take the reciprocal challenge for instance... Many languages already have a function for this or at least support division. Some answers are in languages that don't and those answers seem to generally get more attention. It all comes down to not upvoting trivial solutions

Octave, 35 bytes
@(s)diff(hist(hash('md2',s),+'78'))

*Requires the latest version of Octave (at least 4.2).
Computes histcounts of the hash string with it's center of bins are 7 and 8 then computes the difference of counts.

Given it's been a few days I'll put yours up as the winning answer, if somebody comes along later with a shorter solution I can always change it. Well done!

Mathematica, 43 bytes
Tr@Sign[15-2#~Hash~"MD2"~IntegerDigits~16]&

Outputs the number of digits in 01234567 minus the number of digits in 89abcdef.

Too bad that 3E is between 8 and 9 and not between 7 and 8. :|

JavaScript (ES6), 731 bytes
This monster is implementing the MD2 algorithm, so it's embarrassingly long. Based on js-md2 by Chen Yi-Cyuan.

let f =

m=>{L=x=s=b=0,n=m.length,M=[],X=[],C=[],S=[...atob`KS5DyaLYfAE9NlSh7PAGE2KnBfPAx3OMmJMr2bxMgsoem1c8/dTgFmdCbxiKF+USvk7E1tqe3kmg+/WOuy/ueqloeZEVsgc/lMIQiQsiXyGAf12aWpAyJzU+zOe/95cD/xkws0iltdHXXpIqrFaqxk+4ONKWpH22dvxr4px0BPFFnXBZZHGHIIZbz2XmLagCG2Alra6wufYcRmFpNEB+D1VHoyPdUa86w1z5zrrF6iYsUw1uhSiECdPfzfRBgU1Satw3yGzBq/ok4XsIDL2xSniIlYvjY+ht6cvV/jsAHTny77cOZljQ5KZ3cvjrdUsKMURQtI/tHxrbmY0znxGDFA`].map(c=>c[O='charCodeAt']());for(l=1;l-2;){for(j=19;j--;)M[j]=M[16+j]||0;for(i=s;i<16;x++)L=(x-n||(b+=i-s,s=i-16,l=2),C[i]^=S[(M[i++]=x<n?m[O](x):16-(b&15))^L]);for(i=0;i<l;i++){for(j=16;j--;)X[32+j]=(X[16+j]=(i?C:M)[j])^X[j];for(t=j=0;j<18;t=t+j++&255)for(k=0;k<48;)t=X[k++]^=S[t]}}for(i=16,n=-i;i--;)n+=!(X[i]&8)+!(X[i]&128);return n}

console.log(f(''))
console.log(f('The quick brown fox jumps over the lazy cog'))
console.log(f('m'))

Beat me to it. Really nice effort.

Props for, thus far, being the only one to actually implement the full MD2 algorithm rather than using built-in functions.

Highest byte answer deserving of more points.

Python 2 + Crypto, 108 99 93 91 87 78 bytes
Python doesn't have a native builtin for MD2.
from Crypto.Hash import*
lambda s:sum(x<'8'for x in MD2.new(s).hexdigest())-16

Saved 12 bytes thanks to @ovs.
Saved 9 bytes thanks to @FelipeNardiBatista.

lambda s:cmp(sum((int(x,16)<8)-.5for x in MD2.new(s).hexdigest()),0) should reduce the byte count to 93

@ovs Very clever!

sum(x<'8'for x ......

lambda s:sum(x<'8'for x in MD2.new(s).hexdigest())-16 for 78. the output can be any number, not just -1,0,1

Java 8, 173 bytes
-4 thanks to dzaima
-128 thanks to Oliver, this is basically his answer now.
a->{String h="";for(byte b:java.security.MessageDigest.getInstance("MD2").digest(a.getBytes()))h+=h.format("%02x",b);return h.codePoints().filter(c->c>47&&c<56).count()-16;}

Positive for truthy. Negative for falsy. 0 for 0.

You can save 4 bytes by removing the enclosing brackets of for and if

bytes to hex can be golfed: String s="";for(byte b:bytes)h+=h.format("%02x",b);. Also, you don't need to write a full program, but a lambda suffice: a->{... return x;}. Finally the for loop can be replaced by int x=s.codePoints().filter(c->c>47&&c<56).count();. All in all, I get 173 for your algorithm, golfed: a->{String h="";for(byte b:java.security.MessageDigest.getInstance("MD2").digest(a.getBytes()))h+=h.format("%02x",b);return h.codePoints().filter(c->c>47&&c<56).count()-16;}. More golfing is possible, but this is a net improvement in byte count, isn't it?

Some things to golf: println -> print and for(char c:s.toCharArray())if("01234567".contains(""+c))x++; -> for(String c:s.split(""))if("01234567".contains(c))x++;

@OlivierGrégoire I don't know much about Java 8, I switched to Groovy/Grails around the same time.

PHP, 50 Bytes
prints 1 for truthy and -1 for false and 0 for a tie
<?=preg_match_all("#[0-7]#",hash(md2,$argn))<=>16;

PHP, 58 Bytes
prints 1 for truthy and -1 for false and 0 for a tie
<?=16<=>strlen(preg_filter("#[0-7]#","",hash(md2,$argn)));

Sorry for all the spec changes, final output requirements are in now.
Basically what you currently have but reversed (1 for truthy, -1 for falsey) which should be fairly easy as iirc in PHP -0 === 0

@Mayube this is too long 1 Byte more is enough. The best way is to specified the output by the possibilities of the language and not general

echo 16<=>strlen(preg_filter("#[0-7]#","",hash(md2,$argn))); should do the trick without additional byte.

Golfed version: <?=preg_match_all("/[0-7]/",hash(md2,$argn))<=>16;

@Christoph I feel like an idiot that I have not think about preg_match_all

Tcl + Trf package, 79
package require Trf
puts [expr [regexp -all \[0-7\] [hex -m e [md2 $argv]]]-16]

Try it online. (Thanks @Dennis for adding Tcl to TIO.)

PHP, 56 bytes
while($i<32)${hash(md2,$argn)[$i++]>'7'}++;echo$$_<=>16;

Java 137 130 124 123 bytes
a->{int c=32;for(int b:java.security.MessageDigest.getInstance("MD2").digest(a.getBytes()))c-=(b>>6&2)+(b>>2&2);return c;}

Test it online!
Basically, for each byte, we're asked to check against its 4th and 8th least significant bits. I don't go through the hex representation at all. So it seemed only natural to start playing with bits.
Values <0 are falsey, values >0 are truthy, value 0 is neither truthy or falsey. The usual truthy and falsey can't be applied to Java this time (because it can't be true or false or 0 with the rule if(<truthy>)), so I took the liberty to declare as such.
Saves

137 -> 130 bytes: golfed by using bit operations, removing 2 everytime I get a "falsy" bit.
130 -> 124 bytes: more bitwise operations
124 -> 123 bytes: replaced byte by int in the for loop declaration.