[Question]
  [
### Your task
Given a string, output the range of ASCII values.
### Example
Let's say we have the string `Hello`.
We get the ASCII values:
* `H` = 72
* `e` = 101
* `l` = 108
* `l` = 108
* `o` = 111
Now, we get the range (`max - min`):
* 111 - 72 = 39
Our answer is 39.
### Test cases
```
Input           Output
Hello, World!   82
aaaaa           0
Code Golf       79
Stack Exchange  88
ASCII           18
```
### Scoring
For scoring, we will get the range of ASCII/Unicode values of your program source code, and add that to the length of your code in bytes.
For example, with the program `abc`, the score would be:
* 3 (the length of the program) + 2 (the ASCII range of the program) = 5
You can use [this TIO link](https://tio.run/##RYyxCoMwFEX3fMXbTKh16SZ0KJ2Ebu3S8dVEDSR54SUF/XobKeh2OefeG5c8Ubisq/WROENakmC4gkP/0QiuBY@zdArO4G0oQdBhUwvOpiw9Rkmsa0hKieHwcwssSc6F2kLLd5OytqFhg1oqgQUO0irhto0JW4xsQ5bV7XnvOmAMo2mrGnAXDxPGPG3M7exFGR2knvhfPjm1rm/6MvSkDYxkEkyGzQ8) to get your score.
### Clarifications
* There will be no non-ASCII characters in the input (but your program source code may contain non-ASCII characters)
* There will be no newline characters in the input (but your program source code may include newlines)
* **Lowest score wins**
  
[Answer]
# [MATL](https://github.com/lmendo/MATL), score 37 (length 7, range 30)
```
X>GX<ZP
```
[Try it online!](https://tio.run/##y00syfn/P8LOPcImKuD/f3WP1JycfHUA "MATL – Try It Online") Or [verify](https://tio.run/##y00syfmf8D/Czj3CJirgv0tURch/dY/UnJx8HYXw/KKcFEV1LvVEEADSzvkpqQru@TlpQHZwSWJytoJrRXJGYl56KlDAMdjZ0xNIQ41SBwA) all test cases and source code.
```
X>    % Implicit input. Maximum
G     % Push input again
X<    % Minimum
ZP    % Distance (of code points). Implicit display
```
[Answer]
# [C (clang)](http://clang.llvm.org/), 79 bytes + 28 = ~~145 138 129 112 111~~ 107
*-7 score thanks to [@Digital Trauma](https://codegolf.stackexchange.com/users/11259/digital-trauma)  
~~-9~~ -10 score thanks to [@jdt](https://codegolf.stackexchange.com/users/41374/jdt)*
```
A,B;D(*C)??<*C<A?A=*C:*C>B?B=*C:0;*++C?D(C):0;??>C(*C)??<A=B=*C;D(C);*C=B-A;??>
```
[Try it online!](https://tio.run/##jVBNT4QwED3TXzGSbAIFshyNXWiga3STve1hDysHLB9LrNAAuhrDXxdbRA/Egz29eTNvOu9xj4u0LscxcmOytTCzKd1gtoloFGB2g1kY01gjn2DHYXRrMVthSkM2D0eB7hPdIJgFsRfp7ljVPXpOq9p6barMRh/IUAzgPu/6UwIBKMLYm/e5EI0Lx6YV2ZXpTlyq34xZk@Vw14hirg99yp/g9o2f1dH5TEYHttv94F8bpqrXGBzAa9ib/zK1kMwWl4v@MrxUTtf4yBhcwFi68PhSnK79xIU27wlCRtG0YEkVg86DAJYEHEfaUyoX3nH5bimJEkubKIrpakKyVTEWlrkSHXghrLKH2tRj31/4iR4a0DB@8kKkZTd6fVuVbSrPCl6@AA "C (clang) – Try It Online")
## Explanation
`??<` and `??>` are trigraphs for `{` and `}` respectively
```
A,B;      // A will track the minimum, B will track the maximum
D(*C){    // D() will traverse C updating the values of A and B
  *C<A?   // if current character < A
    A=*C  //   update A with it's value
  :*C>B?  // else if current character > B
    B=*C  //   update B with it's value
  :0;     // else, do nothing
  *++C?   // if we're not at the end of the string
    D(C)  //   call D recursively with the next character
  :0;     // else, do nothing
}         // end D()
C(*C){    // C() takes the string, which is also where we'll store the output
  A=B=*C; // initialize A and B with the first character in C
  D(C);   // call D
  *C=B-A; // store the range (max - min) in the out argument
}         // end C()
```
[Answer]
# [Bash](https://www.gnu.org/software/bash/) + GNU utilities, 52 bytes + 92 range = 144
```
od -An -w1 -td1 -v|sort -n|sed -n '1p;$p'|dc -e??r-p
```
[Try it online!](https://tio.run/##nY2xDoIwFAD3fsWTYLrYgZmBEEKUxMHIYBwr7yHEpq9piTj03yv@gjfccsM9dJjSOs2GwJPGEpCF87NdRpD7ICHLr@3lfM8gJkZQtQW1FqAW3PSOgf0CysZAW7MgC1fmTkYcQFFVeeUSsqV0ImP4ADf2BndC/xANI8GRzSj6RQ8vaD/DpO2TRN03XSf@mYkv "Bash – Try It Online")
[Answer]
# [Pip](https://github.com/dloscutoff/pip), 13 bytes + 39 = 52
```
a:A^aMXaADMNa
```
[Try It Online!](https://dso.surge.sh/#@WyJwaXAiLCIiLCJhOkFeYU1YYUFETU5hIiwiIiwiIiwiXCJIZWxsbywgV29ybGQhXCIiXQ==)
### Explanation
A straight code-golf solution to the challenge might look like this:
```
A*:a;Ma-Na
   a        First command-line argument
A*          Get ASCII value of each character
  :         and assign that list of integers back to a
    ;       Statement separator
        Na  Minimum of a
      a-    Subtract that from each element in a
     M      and take the maximum of the resulting list
```
This gets a score of 65. The `a` for getting the command-line argument and `A` for taking ASCII values are both necessary, so to improve the score we'll need to look at the characters with ASCII values less than `A`.
The smallest character is `*`, which we can get rid of by splitting the string into a list of characters with `^` and passing that list to `A` directly:
```
A*:a
 ->
a:A^a
```
The next-smallest character is `-`, which we can get rid of by using the absolute difference operator `AD` instead. Then we have to rearrange a bit more to avoid needing a space; we'll use the old `MX` and `MN` operators for max and min instead of the newer `M` and `N`.
```
Ma-Na
 ->
MXaADMNa
```
(We could also keep using `M`, but since it also requires a semicolon to parse correctly, the score is the same if we replace it with `MX` which doesn't need the semicolon.)
[Answer]
# [Alumin](https://github.com/ConorOBrien-Foxx/Alumin), ~~36~~ 19 bytes + ~~22~~ 20 = ~~58~~ 39
```
idiqdhhhwrvsruripkc
```
[Try it online!](https://tio.run/##S8wpzc3M@/8/MyWzMCUjI6O8qKy4qLQosyA7GasgAA "Alumin – Try It Online")
Both the right language for the job~~, and horribly inefficient at it!~~ Turns out, I'm just an inefficient thinker!
## Explanation
```
idiqdhhhwrvsruripkc
                       explanation           | stack
id                     take input, duplicate | MAX MIN
  iq           ip      while input > 0       | MAX MIN in
    d                    duplicate           | MAX MIN in in
     hhhw                grab top 3          | MAX [ MIN in in ]
         r               reverse stack       | MAX [ in in MIN ]
          v              get lesser of two   | MAX [ in MIN' ]
           s             ungrab              | MAX in MIN'
            r            reverse stack       | MIN' in MAX
             u           get greater of two  | MIN' MAX'
              r          reverse stack       | MAX' MIN'
                         (this gives us a better score than using `y` to swap 2)
                      loop finishes          | MAX MIN -1
                 k    discard eof            | MAX MIN
                  c   subtract               | MAX-MIN
```
## Explanation (Old)
```
hqidrlhcwrspkrklhhgwfufsykrlhcwfvfsc
h                                     push 1 (to start loop)
 q         p                          input loop
  id                                  take input, duplicate
    r                                 reverse stack
     lhc                              stack length - 1
        wrs                           reverse that many elements off the stack
                                      this has the effect of pushing two copies of the input
            krk                       pop trailing EOF twice
               lhhg                   stack length / 2
                   w                  grab that many elements into a new stack
                    fuf               fold over maximum
                       sykr           place on bottom stack, remove initial 1
                           lhc        stack length - 1
                              w       grab that many elements as before
                               fvf    fold over minimum
                                  sc  push and subtract
```
[Answer]
# [Octave](https://www.gnu.org/software/octave/), score 56 (length 6, range 50)
```
@range
```
[Try it online!](https://tio.run/##y08uSSxL/f/foSgxLz31f5qCrUJiXrE1V5qGukdqTk6@jkJ4flFOiqK6JkgoEQQgTOf8lFQF9/ycNAg3uCQxOVvBtSI5A2QORMwx2NnTE8KEGK@u@R8A "Octave – Try It Online")
[Answer]
# [Terse](https://gymhgy.github.io/TerseLang/), 7 bytes + 6769 = 6776
```
找没最手样找到
```
[Try it here](https://gymhgy.github.io/TerseLang/?code=wGm9voTAag&in=IuaJvuayoeacgOaJi-agt-aJvuWIsCI)
Could be worse.
```
找　　　　　　　　Char codes
　没　　　　　　　Maximum, after
　　最手　　　　　　Squaring and then square root (identity)
　　　　样　　　　Subtract
　　　　　找到　　Minimum
```
[Answer]
# [Nibbles](http://golfscript.com/nibbles/index.html), ~~9~~ 12 bytes + ~~56~~ ~~49~~ 38 = 50
```
;*;-;o;/;\;`<@@o;/_$;`$$
```
This corresponds to the [Nibbles](http://golfscript.com/nibbles/index.html) program with nibbles:
```
6 a 6 9 6 e 6 a 6 b 6 e 4 d 4 e 6 a 5 3 6 d 7 3
```
Which, paired-up into bytes, gives
```
6a 69 6e 6a 6b 6e 4d 4e 6a 53 6d 73
```
which can be read-out as a string (with the same ASCII values)
```
jinjknMNjSms
```
with ASCII range 115 (`73`) - 77 (`4d`) = 38.
---
**How?**
We start from a straightforward code-golf solution to the question: `-o/\;`<$$o/` (5.5 bytes, 11 nibbles):
```
-o/\;`<$@o/
-                   # subtract
 o                  #   character value of
  /                 #   fold over
   \                #     reverse of
    ;               #     (save)
     `<             #     sorted
       @            #     input
        $           #   returning left element each time
                    #   (so the fold returns the first element)
                    # from
         o          #   character value of
          /         #   fold over
                    #   (implicit) saved sorted input
                    #   (implicit) returning left element each time
```
The nibbles are slightly re-arranged in the final program, since the 2-nibble 'sort' function ( ``<`) wraps around its argument (here `$`). Thus, the paired-up nibbles from this are:
```
-o /\ ;` @< $o /    # program code (in final order)
9e ab 6e 4d 3e a    # nibbles
```
We can reduce the range of bytes by inserting 'save' operators (`;`, nibble `6`) to shift high-valued nibbles into the least-significant-nibble position of each byte.  
This doesn't affect the output, but we need to override the final implicit variable to account for the saved (but ignored) values. Hence:
```
;- ;o ;/ ;\ ;` @< $o ;/ ;$   # program code (in final order), with final variable changed to ;$
69 6e 6a 6b 6e 4d 3e 6a 63   # nibbles
```
Modifying both folds (so returning right element `@` instead of left element `$`) avoids the lowest byte `3e`, but unfortunately outputs a negated value.  
So we multiply (and save: `;*`) the negated value by its own sign (also saved: `;`$`): this corrects the output, introducing a new highest byte of `73`, but the overall score is still reduced.
[![enter image description here](https://i.stack.imgur.com/KOztR.png)](https://i.stack.imgur.com/KOztR.png)
[Answer]
# [Julia](https://julialang.org), 22 bytes + 80 = 102
```
+s=-(-(extrema(s)...))
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m700qzQnM3HBgqWlJWm6Ftu0i211NXQ1UitKilJzEzWKNfX09DQ1IZI3G6OVPFJzcvJ1FMLzi3JSFJV0lBUULIy4lBJBAMyDAwMuJef8lFQF9_ycNISMuSWXUnBJYnK2gmtFckZiXnoqxAwLLiXHYGdPTyVkIxQMLbhi9WrsCooy80py8h51zNCGOATmWgA)
[Answer]
# Java 8, score: 134 (54 bytes)
```
s->s.chars().max().orElse(0)-s.chars().min().orElse(0)
```
[**Try it online**](https://tio.run/##dVLBTuMwEL33KwafbKU1e0IrKlaCqLAcFlYExIFFq8FxGhfXruxpAaF@e7GT0q1WIpEmmTfjN@@NPMMVjmb180ZZjBF@oXHvAwDjSIcGlYarnHYAKF5RMG4KUYwTuB6kEAnJKLgCByebOPoRpWoxRC7kHF9T9GFio@bfxGivYtx@ZTPORIvlk01EW76VNzXMk5jtyIdHFNQG/xJh8qr0gox3vbDGB77CAKQjlRj1sdMv8Hnonf3U1voh3Ptg6wM2ZJif9C19reHC2yb9V4TqOfO26KY6AadVeXnJ1qIbAFC9RdJz6ZckF4mXrOOf0wp2DKxwUu0QITo7AFmUylNO4J8kPkv7ls542Rir5XkKUQaN9am1Z2@J47@G30it9A1n8lBmMpmMMyGGsGvrlqpJJhOuxlCXfR7l3e353@9CxoU1xNkfx8TD0eN48IWh3FDkCWK8Ux90XFrK@pO/vVq@C1a7KbWp1qnqMy6@pq/K65tJ3hXvWYv@iCgYcFZsMZbeHi@YYNtLtt58AA) (also contains code to extract the lambda function from the code-block and calculate its score: `(max_codepoint - min_codepoint) + length`).
Not too much too improve unfortunately.
* We could change the `x` to `\u0078`, but unfortunately the next highest codepoint then becomes `u` which isn't too much lower than `x`, so the +5 in byte-count is higher than the -3 in codepoint, giving a +2 in score instead of decrease: [Try it online](https://tio.run/##dVLBThsxEL3nK6Y@2drE5NQiIirRVaAcSiu2iAOgyvV6sw6OHdmTUITy7el4N4QIiV3J9rwZv/dm5Llaq9G8ftxqp1KCH8r6lwGA9Whio7SBqxx2AGheYbR@BklMCNwMaEmo0Gq4Ag@n2zT6mqRuVUxcyIW6X43HX47pGOLUJcPHYnSQtv4ws51ktuXqryO2Hek62BoW5Gine/egBLYxPCWY/tNmiTb43l0TIl@rCGgSliqZE2@e4PXSC/tunAtDuA3R1Z/YkKn80V6G2sBFcA2dK1T6MfO2ys8MAWdVeXnJNqITAKieE5qFDCuUS@JF5/mrWsFOgBVe6j0iRNcOQDals8opvFnicxq69DbIxjojz2lJMhpVnzn37Zk43hX8UtjK0HAmj2Qmk9Q4E2II@7JuqAYlNeFrFeuyj5O8@X3@51jItHQWObv3TNx9fpgMPmgoFxRZQUz27qNJK4fZP/V3kMsPwhk/w5Zynas@4uJj@qr8eT3Ns@I9a9FfEQUDzoodxujv8YIJtntpm@1/).
* Using a regular for-loop requires both `{}` and a space, so the difference of the max-min codepoints would widen on both ends. And in addition it's longer anyway: [Try it online](https://tio.run/##dVLBjtMwEL33KwafbKU1nBBtNotKtAt7yIIIKw6lQsZxmnQdu7KnXaqq317spFsE0iaS7Xl6897M2GuxE5N19XiSWngPhWjNYQTQGlSuFlLBfQx7ACSVjXCLpWdpwI6jsHgU2Eq4BwPZyU@uD5HXZdPpdFxkb9LaOtpnzjw7dJm86t7LWZcWmbwuwqlIj07h1hkoJl16PKVRcrP9pYPkWXln2wq6UBUt0bVmtVgKho2zTx5ufku1wdaaocLotRMOUHnMhVczo57gOelAPimt7Ri@W6erV2RMRPzCnttKwUer63AuUcjHqNsIs1IBmJf53R05st4AoNx7VB23W@SboIva0Ge3hMyAJIbLC8LR5mFcc@fEnjLG@uYAYokyembwt0C6DtfATWt53WrFb8PiuVOimmv9YR8U/yN8EdhwW1PCX/MoxsMYCGNjuNDiTXmFPLRkKuGqfIg9f/h2@/Md436jW6TkhyFs8XaZjl5oLxKS6MDSS/VO@a3GWH/odnD/p9P08mC0MitsArNnDRFlL5uV@eevN3GOdPBIhhSWEKAkOWMk/AOeEEbOT/F4@gM).
**Explanation:**
```
s->            // Method with String parameter and integer return-type
  s.chars()    //  Convert the String to an IntStream of codepoint integers
   .max()      //  Get the maximum of these codepoints
   .orElse(0)  //  Convert the OptionalInt to an int
               //  (`.orElse(0)` is 1 byte shorter than `.getAsInt()`)
  -            //  And subtract
   s.chars().min().orElse(0)
               //  The same to get the minimum codepoint
```
[Answer]
# [Excel](https://www.microsoft.com/en-us/microsoft-365/excel), score = ~~103~~ 94 (length 46, range 48)
-9 score thanks to [Engineer Toast](https://codegolf.stackexchange.com/users/38183/engineer-toast)
```
=LET(A,CODE(RIGHT(A1,ROW(A:A))),MAX(A)-MIN(A))
```
[![enter image description here](https://i.stack.imgur.com/SzCp3.png)](https://i.stack.imgur.com/SzCp3.png)
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), ~~12 bytes + 86 = 98~~ 13 bytes + 56 = 69
h/t @isaacg
```
+/1_-':@/1<:\
```
[Try it online!](https://ngn.codeberg.page/k#eJxLs9LWN4zXVbdy0De0sYrh4srPSbHS1deo0bdW09d0iLHi4gqx0lDySM3JyVcIzy/KSVFU4lJQUFBKBAIIyzk/JVXBPT8nDcINLklMzlZwrUjOSMxLT4WIOQY7e3pCmEhmx1hBhFBcEKOkycWVph7CBQBShCQG)
[Answer]
# [MATL](https://github.com/lmendo/MATL), 3 bytes + 32 = 35
```
Sds
```
### Explanation
```
Sds
S     % Sort implicit input
 d    % Difference between adjacent elements
  s   % Sum the values
```
[Try it online!](https://tio.run/##y00syfn/Pzil@P9/dY/UnJx8HYXw/KKcFEV1AA "MATL – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page) + 149 = 154
I think this is about as good as it's going to get in Jelly due to the distance between `O` (unavoidable as it's the only way to get the ordinals of the input string) and the large ordinals of Unicode characters representing the bytes for mapping and getting maximums and minimums, index into a list etc.
```
OÞOIS
```
A monadic Link that accepts a list of characters and yields the range size as an integer.
**[Try it online!](https://tio.run/##y0rNyan8/9//8Dx/z@D///@rewAF8nUUwvOLclIU1QE "Jelly – Try It Online")**
### How?
```
OÞOIS - Link: list of characters        (ordinal)
 Þ    - sort by:                        (222)
O     -   ordinal value                 (79)
  O   - ordinal values                  (79)
   I  - forward differences             (73)
    S - sum                             (83)
                                        ----
                                         222
                                       -  73
                                        ====
                                         149
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), 11 bytes + [63](https://tio.run/##RYy9CsIwGEX3PMW3NcHaxS2iUAShIDjUxfGz6U8gfyQZWl8@pgjtdjnn3uuWOFlzSklqZ32EsATi4QIK9UcgKA4aZ6oYHEFLkwOxuw0clAyRanTUelFCYIwMu585eGrpnKnMNH9XIQppKt@joIxghgOVjKh105s1Oi9NpEXd3poGPJqx50UJuIlHb8Y4rUxt7GUjKgid9f/yQbGU6vZ7tef7@6m7Hw) = 74
```
ASz>o;FYOmc
```
[Try it online!](https://tio.run/##yygtzv7/3zG4yi7f2i3SPzf5////Hqk5Ofk6CuH5RTkpigA "Husk – Try It Online")
```
ASz>o;FYOmc
         m   # map over input
          c  #   getting character values
        O    # and sort into ascending order;
  z          # now, zip together
   >         # getting differences
 S           #   the sorted list itself
             # and
    o;       #   the single-element list of
      F      #   fold over the sorted list
       Y     #   getting pairwise maxima
A            # finally, get the average
             # of the resulting single-element list.
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 42 bytes + 80 = 122
```
s=>Math.max(...b=Buffer(s))-Math.min(...b)
```
[Try it online!](https://tio.run/##Xc/BbsIwDAbgO0/hRRwSAWHbhW5SkQChwWGnHnYlhKQthBiSDDFNffauHSBV8dH@7F/ei4vw0pWnMLK4U7VOa59OP0Uo@FFcKed8m86/tVaOesZGt0Fp/weslmg9GsUN5nSTSXTqHfq/FlLQPGAWXGlzyrhRNg9FBdufoDwMGnJuCe0iVjWtdncA52rDer3ubU3JShmDQ/hCZ3ZPBBiD8RiS15iJtgg86saeY7VoXoUPNJp01OQtZlkQ8gDLqyyEzRW5ZyYxm2WL9TrOfEnqPw "JavaScript (Node.js) – Try It Online")
[Answer]
# [Ly](https://github.com/LyricLy/Ly), 8 bytes + 70 = 78
```
ia0I-s>l
```
[Try it online!](https://tio.run/##y6n8/z8z0cBTt9gu5///4JLE5GwF14rkjMS89FQA "Ly – Try It Online")
I found a shorter program, but the character range of the code was big enough that it had a higher total score.
```
ia        - read STDIN onto stack as codepoints, sort the stack
  0I      - copy the bottom of the stack to the top
    -     - subtract to get the range
     s>l  - save result, switch to clean stack, load result
```
[Answer]
# [Raku](https://www.raku.org/), 25 bytes
ASCII range: 88
Length: 25
Total score: 113
```
[-] @_.ords.minmax[*-1,0]
```
[Try it online!](https://tio.run/##K0gtyjH7X1yapJCmUP0/WjdWwSFeL78opVgvNzMvN7EiWkvXUMcg9n@ttUJBUWZeCVCZukdqTk6@jkJ4flFOiqL6fwA "Perl 6 – Try It Online")
[Answer]
# [J](http://jsoftware.com/), score 70 (16 bytes, range 54)
```
[:+/2-/\a.I.]\:]
```
[Try it online!](https://tio.run/##y/r/P03B1koh2kpb30hXPyZRz1MvNsYq9n9qcka@QpqCukdqTk6@jkJ4flFOiqL6fwA "J – Try It Online")
* `]` `\:` `]`: Pass the input (using the identity function [`]`](https://www.jsoftware.com/help/dictionary/d500.htm)) on both sides of [`\:`](https://www.jsoftware.com/help/dictionary/d431.htm) to sort it in descending order.
* `a.` `I.`: For each character of the sorted input, find its index in the ["alphabet"](https://www.jsoftware.com/help/dictionary/dadot.htm); at least on TIO's setup, this contains all of [ISO-8859-1](https://en.wikipedia.org/wiki/ISO-8859-1) in order, which includes ASCII. Thus, this produces the ASCII values of the characters, while keeping the highest used character lower than the straightforward method of `3` [`u:`](https://www.jsoftware.com/help/dictionary/duco.htm) would.  
([`I.`](https://www.jsoftware.com/help/dictionary/dicapdot.htm) would also take the following index if a character is not found, but that never happens; it was chosen over [`i.`](https://www.jsoftware.com/help/dictionary/didot.htm) to reduce the highest used character.)
* `2-/\`: For each length-2 subarray (from the `2` and [`\`](https://www.jsoftware.com/help/dictionary/d430.htm)), subtract the second value from the first ([`-`](https://www.jsoftware.com/help/dictionary/d120.htm) [`/`](https://www.jsoftware.com/help/dictionary/d420.htm)).
* `[:` `+/`: Take the sum ([`+`](https://www.jsoftware.com/help/dictionary/d100.htm) [`/`](https://www.jsoftware.com/help/dictionary/d420.htm)) of the values, using [`[:`](https://www.jsoftware.com/help/dictionary/d502.htm) to do so monadically.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal) -v, 35 bytes, score 61
```
castminusordceilceil[q]ordminmin[q]
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z85sbgkNzOvtDi/KCU5NTMHhKMLY4E8oCgQAdnEKdItywEA "Charcoal – Try It Online") Abusing Charcoal's verbose parser again. In order for it to recognise `q` as a variable name I can't follow it with a letter, so the next nearest suitable characters are the list delimiters. I've also used `ceil` instead of `max` to avoid using an `x`; this costs 2 bytes but overall saves 1 from my score. Normally the program would be written like this:
```
Print(Cast(Minus(Ordinal(Maximum(q)), Ordinal(Minimum(q)))));
```
The best I could do in succinct Charcoal was a score of 10135:
```
⭆ψ⁻℅⌈θ℅⌊θ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRCO4BEil@yYWaFTqKPhm5pUWa/gXpWTmJeZo@CZWZOaW5moUamrqKMAFM/NggkBg/f//o7Vt5zseNe5@1NL6qKfj3A4w3XVux3/dshwA "Charcoal – Try It Online") Link is to verbose version of code. Explanation: The limiting factors here are the Greek letter `θ` needed for the two occurrences of the input variable (the only other input method uses `Ｓ` which has a ridiculously high Unicode code point of 65531) and the `⭆` used to stringify the result (again, `Ｉ` would have had far too high a code point).
```
 ψ          Predefined string null character
⭆           Map over characters and join
     θ      Input string
    ⌈       Maximium
   ℅        Ordinal
  ⁻         Minus
        θ   Input string
       ⌊    Minimum
      ℅     Ordinal
            Implicitly print
```
If using bytes from Charcoal's code page was allowed, its score would "only" be 210:
```
ＳαＩ⁻℅⌈α℅⌊α
```
[Try it online!](https://tio.run/##S85ILErOT8z5/98zr6C0JLikKDMvXSNR05orAMgq0XBOLC7R8M3MKy3W8C9KycxLzNHwTazIzC3NBSrS1FGAC2bmwQSBwPr//8NTDy883Hlo7aFmqcMLDzVLHl74X7csBwA "Charcoal – Try It Online") Link is to verbose version of code. Explanation: The limiting factors here are that `⌊` (`Minimum`) is byte index 25 while `α` (variable `a`) is byte index 225, although I did reduce my score by 14 by taking the input into `α` rather than the default input of `θ` (variable `q`, byte index 241).
```
Ｓ           Input as a string
 α          Store in variable `a`
      α     Input string
     ⌈      Maximum
    ℅       Ordinal
   ⁻        Subtract
         α  Input string
        ⌊   Minimum
       ℅    Ordinal
  Ｉ         Cast to string
            Implicitly print
```
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 8 bytes + 34 = 42
```
+F.+CDCM
```
[Try it online!](https://tio.run/##K6gsyfj/X9tNT9vZxdn3/38lGFMJAA "Pyth – Try It Online")
* `CM`: Map to ASCII value
* `CD`: Sort (equivalent to `S`)
* `.+`: Deltas (Differences between consecutive elements, all nonegative because of sort)
* `+F`: Sum (equivalent to `s`)
Using `.+` is golfier than `h` and `e`, and also stays within the established ASCII value range.
[Answer]
# [Burlesque](https://github.com/FMNSSun/Burlesque), 12 bytes + 52 = 64
```
)**J>]\/<].-
```
[Try it online!](https://tio.run/##SyotykktLixN/V/9X1NLy8suNkbfJlZP939teM5/j9ScnHwuZGEA "Burlesque – Try It Online")
```
)**  # Map to char code
J    # Duplicate
>]   # Maximum
\/   # Swap
<]   # Minimum
.-   # Difference
```
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 98 score (18 bytes)
ASCII range: 80  
Length: 18  
```
s=>s.Max()-s.Min()
```
[Try it online!](https://tio.run/##ZY7LCsIwEEX3/Yoxq4Q@EJdqC1J8FCoIFVyHJG2DJZEmlYL47bUPoYizGc6Zy3CZ8ZmR3aFRbGtsLVXhgVQ2ghzCzoSRCc60xcTvt1SYdBvnKozF6CSqSiPygx7cdF3xxazpMDPGmgs46iqfVWYpu8O@ZSVVhZj9LouTZMAv/1cZj08tOYyJqXzf/dFY8nIAbrW0IpVK4NG5aI1chIIL5anILV4t/dEHqVCFLYmbTznSv313Hw "C# (Visual C# Interactive Compiler) – Try It Online")
* -27 score thanks to Kevin Cruijssen for the tip to use C# Interactive
---
# [C# (Visual C# Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 125 score (36 bytes)
ASCII range: 89  
Length: 36  
Total score: 125
```
s=>s.Max()-s.Min()
```
If we're going traditional through the compiler then we have to include an extra 18 bytes for `using System.Linq;`
[Try it online!](https://tio.run/##jc1LCoMwEIDhfU8xdZWAegGrUKQPoULBhesQow1NE@rEYimePY3FvZ3NwPD9DMeII3cDSt1B9UYrHvFF6mcCXDFEuMIH0DIrObyMbKBkUhPqj4s9Dprv0PY@D0Fqm0ELKThMM4xLNhIa@T0nLtksSW40GiXiupdW@F@CtCQ4C6VMQOkfKoTa9KrZrmo2z6rKTSPgZFS7KivL@B0OI78x3YlVvq/yovipCSb3BQ "C# (Visual C# Compiler) – Try It Online")
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 6 bytes + 67 = score 73
```
C:G$g-
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyJBIiwiIiwiQzpHJGctIiwiIiwiXCJIZWxsbywgV29ybGQhXCJcblwiQzpHJGctXCJcblwiYVwiIl0=)
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 31 bytes + 85 = 116
```
ToCharacterCode@s//Max@#-Min@#&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n1icnJkZlJiXnhpdHB9cUpSZlx6rYGX7PyTfOSOxKDG5JLXIOT8l1aFYX983scJBWdc3M89BWQ1Zn5JHak5Ovo5CeH5RToqiUqy@fgDQmBIuZCWJIIBdCmS8gnt@Thp26eCSxORsBdeK5AwQH7sax2BnT0@41H8A)
[Answer]
# [Thunno 2](https://github.com/Thunno/Thunno2) `GB`, 2 + 24 = 26
```
G_
```
[Try it online!](https://Not-Thonnu.github.io/run#aGVhZGVyPSZjb2RlPUdfJmZvb3Rlcj0maW5wdXQ9SGVsbG8mZmxhZ3M9R0I=)
Port of lyxal's Vyxal answer.
#### Explanation
```
G_  # Implicit input
    # Convert to codepoints
G   # Maximum codepoint
 _  # Subtract each input codepoint
    # Find the maximum
    # Implicit output
```
[Answer]
# [Sequences](https://github.com/nayakrujul/sequences), score = 73 + 4.12 = 77.12
(Sequences uses the 96 printable ASCII characters as its codepage, so the byte count of this program is \$5\log\_{256}(96) \approx 4.12\$)
```
`vMm-
```
### Explanation
```
`vMm-  # Implicit input as a string
`v     # Get the ASCII values of the input string in a list
  M    # Get the maximum value of that list
   m   # Get the minimum value of that list
    -  # And subtract to find the range
       # (implicit output)
```
[Answer]
# [Python](https://www.python.org), 39 + 80 = 119
```
print(ord(max(s:=input()))-ord(min(s)))
```
[Attempt This Online!](https://ato.pxeger.com/run?1=dY8xTgMxEEV7n2JwE1vZTUGFVtoCRQhSb5HarG1i4R1btoOSs6RJA1yDa-Q2zO6SdEz3x-9__zl9xWPZBTx_W2iBc_65L7Z-uCxiclhESFoM6iBy0zqM-yKklPW0dCgyiT_8h5yrXJKLQjI2e3nXh2QaXoE3KKysgC9JXCOtlFDDNYsUvbc3GJYg_iUl_eGGGFKBfMyM2ZDAOzTgcFxQEe2wYUAztabLvBpetWom7FZ0BMyH8pQ533G-3L8Y70MF25C8vmNqHLYO2sBz8JZ1RfXv8HTodwrfDHvs1pvNbP0F)
[Answer]
# [Ruby](https://www.ruby-lang.org/), 26 bytes + 80 = 106
-2 bytes thanks to [Steffan](https://codegolf.stackexchange.com/users/92689/steffan)
```
->s{y=s.bytes;y.max-y.min}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72kqDSpcsEiN9ulpSVpuha7dO2Kqytti_WSKktSi60r9XITK3SBZGZeLUTBlgIFt2glj9ScnHwdhfD8opwURaVYiNSCBRAaAA)
[Answer]
# [Haskell](https://www.haskell.org), 27 bytes + 84 = score 111
```
_?s=(maximum$s)-(minimum$s)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m708I7E4OzUnZ8FN7dzEzDzbgqLMvBIFFQUNe00FA4VoQwNDHQUoYaGjYG4EZBgaxi4tLUnTtdgdb19sq5GbWJGZW5qrUqypq5GbmQdlQ1QsgFJQGgA)
]