Range of ASCII values

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 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 1

MATL, score 37 (length 7, range 30)

X>GX<ZP

Try it online! Or verify all test cases and source code.

X>    % Implicit input. Maximum
G     % Push input again
X<    % Minimum
ZP    % Distance (of code points). Implicit display

Answer 2

C (clang), 79 bytes + 28 = ^{145 138 129 112 111} 107

-7 score thanks to @Digital Trauma
-9 -10 score thanks to @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!

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 3

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!

Answer 4

Pip, 13 bytes + 39 = 52

a:A^aMXaADMNa

Try It Online!

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 5

Alumin, 36 19 bytes + 22 20 = 58 39

idiqdhhhwrvsruripkc

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 6

Octave, score 56 (length 6, range 50)

@range

Try it online!

Answer 7

Terse, 7 bytes + 6769 = 6776

找没最手样找到

Try it here

Could be worse.

找　　　　　　　　Char codes
　没　　　　　　　Maximum, after
　　最手　　　　　　Squaring and then square root (identity)
　　　　样　　　　Subtract
　　　　　找到　　Minimum

Answer 8

Nibbles, 9 12 bytes + 56 49 38 = 50

;*;-;o;/;\;`<@@o;/_$;`$$

This corresponds to the Nibbles 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.

Answer 9

Julia, 22 bytes + 80 = 102

+s=-(-(extrema(s)...))

Attempt This Online!

Answer 10

Java 8, score: 134 (54 bytes)

s->s.chars().max().orElse(0)-s.chars().min().orElse(0)

Try it online (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.
• 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.

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 11

Excel, score = ¹⁰³ 94 (length 46, range 48)

-9 score thanks to Engineer Toast

=LET(A,CODE(RIGHT(A1,ROW(A:A))),MAX(A)-MIN(A))

Answer 12

K (ngn/k), 12 bytes + 86 = 98 13 bytes + 56 = 69

h/t @isaacg

+/1_-':@/1<:\

Try it online!

Answer 13

MATL, 3 bytes + 32 = 35

Sds

Explanation

Sds
S     % Sort implicit input
 d    % Difference between adjacent elements
  s   % Sum the values

Try it online!

Answer 14

Jelly, 5 bytes + 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!

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 15

Husk, 11 bytes + 63 = 74

ASz>o;FYOmc

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 16

JavaScript (Node.js), 42 bytes + 80 = 122

s=>Math.max(...b=Buffer(s))-Math.min(...b)

Try it online!

Answer 17

Ly, 8 bytes + 70 = 78

ia0I-s>l

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 18

Raku, 25 bytes

ASCII range: 88 Length: 25 Total score: 113

[-] @_.ords.minmax[*-1,0]

Try it online!

Answer 19

J, score 70 (16 bytes, range 54)

[:+/2-/\a.I.]\:]

Try it online!

• ] \: ]: Pass the input (using the identity function ]) on both sides of \: to sort it in descending order.
• a. I.: For each character of the sorted input, find its index in the "alphabet"; at least on TIO's setup, this contains all of 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: would.
  (I. would also take the following index if a character is not found, but that never happens; it was chosen over i. to reduce the highest used character.)
• 2-/\: For each length-2 subarray (from the 2 and \), subtract the second value from the first (- /).
• [: +/: Take the sum (+ /) of the values, using [: to do so monadically.

Answer 20

Charcoal -v, 35 bytes, score 61

castminusordceilceil[q]ordminmin[q]

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! 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! 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 21

Pyth, 8 bytes + 34 = 42

+F.+CDCM

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 22

Burlesque, 12 bytes + 52 = 64

)**J>]\/<].-

Try it online!

)**  # Map to char code
J    # Duplicate
>]   # Maximum
\/   # Swap
<]   # Minimum
.-   # Difference

Answer 23

C# (Visual C# Interactive Compiler), 98 score (18 bytes)

ASCII range: 80
Length: 18
Total score: 98

s=>s.Max()-s.Min()

Try it online!

• -27 score thanks to Kevin Cruijssen for the tip to use C# Interactive

---

C# (Visual C# Compiler), 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!

Answer 24

Vyxal, 6 bytes + 67 = score 73

C:G$g-

Try it Online!

Answer 25

Wolfram Language (Mathematica), 31 bytes + 85 = 116

ToCharacterCode@s//Max@#-Min@#&

Try it online!

Answer 26

Thunno 2 GB, 2 + 24 = 26

G_

Try it online!

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 27

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 28

Python, 39 + 80 = 119

print(ord(max(s:=input()))-ord(min(s)))

Attempt This Online!

Answer 29

Ruby, 26 bytes + 80 = 106

-2 bytes thanks to Steffan

->s{y=s.bytes;y.max-y.min}

Attempt This Online!

Answer 30

Haskell, 27 bytes + 84 = score 111

_?s=(maximum$s)-(minimum$s)

Attempt This Online!