[Question]
  [
# 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](https://codereview.stackexchange.com/questions/58446/program-to-find-dollar-words) is an example on CodeReview, and [here](http://mathlair.allfunandgames.ca/onedollarwords.php) 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.
  
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 8 bytes
Code:
```
Ç96-O4bQ
```
Uses the **CP-1252** encoding. [Try it online!](https://tio.run/nexus/05ab1e#@3@43dJM198kKfD//6TSqqpKAA "05AB1E – TIO Nexus")
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
```
[Answer]
# Python, ~~39~~ 38 bytes
```
lambda s:sum(ord(i)-96for i in s)==100
```
[Try it online!](https://tio.run/nexus/python2#JYxBCoMwEEX3nmKYVUK12E2hQnqRtouJMTQQtSSThYpnt5H81YP/eFa9D0@jNgSxi2kUczDCyeZxt3MAB26CKJW6te3BIfF3AQUv1GldF6yxT55TGDKRcaSJXU/eL/ipLPk4FJl0jzXgmnceOctntuQuRewq@AU3MeC2Q/OEbcdrNkdiwTVYwVIefw "Python 2 – TIO Nexus")
---
-1 byte thanks to @JonathanAllan
[Answer]
# [MATL](https://github.com/lmendo/MATL), 8 bytes
```
96-s100=
```
Uses lowercase input.
[Try it online!](https://tio.run/nexus/matl#@29ppltsaGBg@/@/elJpVVWlOgA "MATL – TIO Nexus")
### 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
```
[Answer]
# [Raku](https://perl6.org), 21 bytes
```
{100==[+] .ords X%32}
```
[Try it](https://tio.run/nexus/perl6#VVDBTsMwDL3nK3wYaNXaaQOJS1W0E1/QQyXEwU1SSBWaqknYmmlfxCfsth8rSVMh8MHPdp6f7VjN4etpS3PyOcK90BlTUuKQHdXAoJjO@92uKF43b7D1BQ3V3ePDZfLUQzlYDgXcvglAbZ0bA6qRKmN8JBjvjGgE1z5BJrBGIyhKGWgmmMcyGLld59mHF5T6V9E5F72LEdaU8eb9Q8i2befKolGjFnTWsL675NrkpJfYLQtuFt2cNGqARqKBdXypIECS@jxOrmDGBLJnWImutyaFFT/1nBrO4ByO0vD/g9aRl/whpktvTi7TDw "Perl 6 – TIO Nexus")
Alternate:
```
{Ⅽ==[+] .ords X%32}
```
[Try it](https://tio.run/nexus/perl6#VVDBTsMwDL3nK3wY06q1O4DEpSraiS/oodK0g5ukkCo0VZPAmmlHvgbxBdz2KfxISZoKgQ9@tvP8bMdqDq/3O5qTlxHWQmdMSYlD9qYGBsV0/n7/LIrD9gg7X9BQ3dzdXiZP3ZeD5VDA9YMA1Na5MaAaqTLGR4LxzohGcO0TZAJrNIKilIFmgnksg5Hr1zx7/4hS/yo656J3McKaMt48PQvZtu1cWTRq1ILOGtZ3l1ybnPQSu2XB7aKbk0YN0Eg0sIkvFQRIUp/HyRXMmED2ACvR9daksOKnnlPDGZzDURr@f9Am8pI/xHTpzcll@gE "Perl 6 – TIO Nexus")
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
}
```
[Answer]
# [GS2](https://github.com/nooodl/gs2), 6 bytes
```
▲1Θd←q
```
Input must be in uppercase.
[Try it online!](https://tio.run/nexus/gs2#@/9o2ibDczNSHrVNKPz/38k1yM8xyMXTzx8A "GS2 – TIO Nexus")
### 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.
```
[Answer]
## 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'))
```
[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.
[Answer]
# [Haskell](https://www.haskell.org/), 32 bytes
```
f s=sum[1|c<-s,_<-['a'..c]]==100
```
[Try it online!](https://tio.run/nexus/haskell#HYpbCoMwFAW3cpCCP1X036xEpNy82hsSFRMRQ/duTQcOw4G5LKKIexj7rxqa@HwNzVhT3bZqmoTou@4KxDME1o3nhAcCrbC3j2XTEZXccz4hl1MtKYG1mRNbNhGkmSQlVuT9iVRAzrmsAJJKG/v@sHfO3f8fSIqsqusH "Haskell – TIO Nexus")
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.
[Answer]
# 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!](https://tio.run/nexus/c-gcc#HcjRCkAwFIDh@z3FrGhnKHJ52o08hptFi@LQxgXy7LP8V19/ILRymIxTHh67OUm6ripUHoFKrXyeZ02NpBPCN8x08NXMJIE9jMd2F5eVIh17SkdR8Oj2vO9LwO9uWxbjBACyN3w)
[Answer]
# [Haskell](https://www.haskell.org/), 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.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~9~~ 7?\* 8 [bytes](https://github.com/DennisMitchell/jelly)
```
ɠO%32S⁼³
```
Full program, outputting 1 if the input is a dollar word, or 0 if not.
**[Try it online!](https://tio.run/nexus/jelly#@39ygb@qsVHwo8Y9hzb//5@ZkppXkpmWmVrMBQA)**
### 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.
[Answer]
## [Alice](https://github.com/m-ender/alice), 23 bytes
```
/o!
\i@/e)q&w[?'`-+k3-n
```
[Try it online!](https://tio.run/nexus/alice#@6@fr8gVk@mgn6pZqFYeba@eoKudbayb9/9/YkpmYlJiSWZyYk5OJQA "Alice – TIO Nexus")
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.
```
[Answer]
# 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
[Answer]
# 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"]
```
[Answer]
# Java 8, 36 bytes
```
s->s.chars().map(c->c%32).sum()==100
```
[Try it online!](https://tio.run/nexus/java-openjdk#ZY6xTgMxDIb3ewovSIlErQLjcTcwMMF0I2Iwaa6kSpwocQoV6rMfhxpY@Bdb9qfPXlxIMQsc6EhYxXmcKxtxkfGxNX33j5kMMdvcd12qb94ZMJ5KgWdyDF8drGnzIiRrOUa3g7Bu1STZ8f7lFSjvi27wT36v3V@Ia3iI0VviEWYYoGzGguadclEaAyVlNqO5urvVWGpQehhuttv@zzWditiAsQqmVSae1YyUkj8pth/QvlcNc6yR7ac8ObZKa33xnLvzslQmLzbb3Tc "Java (OpenJDK 8) – TIO Nexus")
Note: case independent.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 9 bytes
```
5bIvAyk>-
```
[Try it online!](https://tio.run/nexus/05ab1e#@2@a5FnmWJltp/v/f1JpVVUlAA "05AB1E – TIO Nexus")
**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
```
[Answer]
# [Perl 5](https://www.perl.org/), 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!](https://tio.run/nexus/perl5#U1YsSC3KUdAt@K/ioG1rbKiWX5SikJZfpK@nn26tEm@r4mBra2hg8P9/elF@aUkxAA "Perl 5 – TIO Nexus")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 36 30 bytes
```
$args|%{$s+=$_[0]-96};$s-eq100
```
[Try it online!](https://tio.run/nexus/powershell#@6@SWJReXKNarVKsbasSH20Qq2tpVmutUqybWmhoYPD//3/1JPX/6qVAXAXFlepf8/J1kxOTM1IB "PowerShell – TIO Nexus")
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!
[Answer]
# [Alice](https://github.com/m-ender/alice), ~~28~~ 18 bytes
*Thanks to @MartinEnder for golfing 10 bytes*
```
=I.!'`-+?hn
>3-nO@
```
[Try it online!](https://tio.run/nexus/alice#@2/rqaeonqCrbZ@Rx2VnrJvn7/D/f2JKZmJSYklmcmJOTiUA "Alice – TIO Nexus")
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!](https://tio.run/nexus/alice#@2/rqaeonK@eoKttn5HHZWesm6ev4PD/f2JKZmJSYklmcmJOTiUA)
### 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
```
[Answer]
# [Taxi](https://bigzaphod.github.io/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.
[Answer]
# 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).
[Answer]
# 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?
```
[Answer]
# [Python](https://docs.python.org/2/), 38 bytes
```
lambda s:sum(map(ord,s))==4-96*~len(s)
```
[Try it online!](https://tio.run/nexus/python2#JczBCoMwEATQu1@x7ClpY0@lUCH9kbaHTVQaSFSSzUHF/rpNcU4D85hev3ZPwbQEqUk5iECTGGOrkpRaX@v77fT13SCS3Dlm/syg4YkmL8uMCm32nGNXGrWODLGz5P2M76onn7oDk7GoAJeS/zBGYHADHHfnAzYVTNENDLhuUD9g3fBSZCAWrKAXLOX@Aw "Python 2 – TIO Nexus") 
Same length as [ovs's solution](https://codegolf.stackexchange.com/a/116937/20260). 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)`.
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~35~~ 30 bytes
```
->w{196==eval(w.bytes*'-96+')}
```
[Try it online!](https://tio.run/nexus/ruby#S7P9r2tXXm1oaWZrm1qWmKNRrpdUWZJarKWua2mmra5Z@7@gtKRYIS1aKS0ns6CgUimWCyaQVFpVBeT/BwA "Ruby – TIO Nexus")
[Answer]
# [Retina](https://github.com/m-ender/retina), ~~47~~ 23 bytes
```
\w
!$&
}T`l`_l
^!{100}$
```
[Try it online!](https://tio.run/nexus/retina#C0nwScjhCk6IjkvUrYrV5lLV0HBP@B9TzqWoosZVG5KQkxCfwxWnWG1oYFCr8v@/U2pRXmJRSmZevkJmSmpeSWZaZmqxQmleYk5JalFqikJKfk5OYpFCeX5RSjEA "Retina – TIO Nexus") Note: Header lowercases input and splits it into words; results appear on separate lines. Edit: Saved far too many bytes thanks to @MartinEnder.
[Answer]
# 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".
[Answer]
# [///](https://esolangs.org/wiki////), ~~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!](https://tio.run/nexus/slashes#FY43EsNADMSeBJE88zVqnHPOLvbrMrUtZjEYENbTAw0zBc0giQAnEya4a4pmmOY0LQgtCdOKaFqT2mCpLS21I1L7gqlD0dQR1wlznWmuC@G6FnbdCrvupOtRd9ez/q5XCVzv0eD6jArXdwz4lcQ1qdFVq9ENwx8 "/// – TIO Nexus")
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.
[Answer]
# [Japt](https://github.com/ETHproductions/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!](https://tio.run/nexus/japt#@@9zaGnooTUV8ckKqh7//yslpmQmJiWWZCYn5uRUKgEA)
12-bytes:
```
L¥U¬mc m%H x
```
[Try it online!](https://tio.run/nexus/japt#@@9zaGnooTW5yQq5qh4KFf//K2WmpOaVZKZlphYrAQA)
Another 12-byte solution using a different technique
```
L¥U¬x@;CaX Ä
```
[Try it online!](https://tio.run/nexus/japt#@@9zaGnooTUVDtbOiREKh1v@/1fKTEnNK8lMy0wtVgIA)
[Answer]
# 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}
```
[Answer]
# Bash + GNU utils, 47
```
od -An -td1 -vw1|sed 's/^/a+=-96+/;$a!a-100'|bc
```
[Try it online](https://tio.run/nexus/bash#Pc3NCsIwEATgu08xQiWHEtpeBCkefBFh86dbSiLNqjT03av14AdzGBiYkCaIz2Ipe3CEeZYyw6TZJhGw81E4sM8gx2RI2NI4zpANSilbNiBjnQ@3O4/DMHz7b2Aos@3h0g5fj4mjBKhDVqj@p8uaHPQlQovroF/vbsneQeXm2lB91qdj3fQV7Ul3basWY1eXol8/).
]