Maximum average ord

Question

Your task

Take a list of strings as the input, and output the maximum average ord.

Example

Given the list ['hello', 'world', 'bye']:

• The average ord of 'hello' is:
  • (ord(h) + ord(e) + ord(l) + ord(l) + ord(o)) / len('hello')
  • = 106.4
• The average ord of 'world' = 110.4
• The average ord of 'bye' = 106.7

The maximum average ord is 110.4. This is your output.

Test cases

Note: For the last two test cases, I have given the roundings for 1, 2, and 3 decimal places. As mentioned in the rules below, you can round to any number of decimal places.

Input                                        Output
['hello', 'world', 'bye']                    110.4
['code', 'golf', 'stack', 'exchange']        106.8
['!@#', '$%^', '&*(']                        55.7 / 55.67 / 55.667 / etc.
['qwertyuiop[', 'asdfghjkl;', 'zxcvbnm,']    110.9 / 110.91 / 110.909 / etc.

Rules/clarifications

• The output must be only the average ord. You may not output anything else.
• It may be rounded (up or down) to any number (\$\ge\$ 1) of decimal places. If your language does not support floating points, you may output the average multiplied by 10.
• Floating point innacuracies are ok.
• You may assume that the input list will always have a length of 2 or more
• You may assume that the strings will never be empty
• You may assume that the strings will not contain whitespace or non-ASCII characters
• This is code-golf, so shortest code in bytes wins!

Answer 1

C (clang), ^{87 86 84} 81 bytes.

v;*p;f(**t,float*r){for(*r=0;p=*t;*r=fmax(*r,v*1./(p-*t++)))for(v=0;*p;)v+=*p++;}

Try it online!

Answer 2

C++ (gcc), 166 120 bytes

-46 thanks to the combined efforts of @ceilingcat and @jdt.

#import<bits/stdc++.h>
auto f(auto a,float*r){*r=0;for(char*t:a){int u=0,s=0;for(;*t;u+=*t++)s++;*r=fmax(*r,(0.+u)/s);}}

Try it online!

Original Answer:

Attempting to apply general-purpose programming to code golf doesn't seem to work out well.

#import<bits/stdc++.h>
auto g(char*a){int t=0,s=0;for(a--;*++a;s++,t+=*a);return(0.0+t)/s;}auto f(std::list<char*>a){float m=0;for(char*t:a)m=m>g(t)?m:g(t);return m;}

Try it online!

Ungolfed:

// Gets the average ord value of a string
auto g(char* a) {
    int t=0, s=0;             // Running total and size 

    for (a--;*++a;s++,t+=*a); // Loop until a equals 0 and add a onto the running total
    
    return (0.0+t) / s;       // Cast to float by adding 0.0 and divide the total by the size.
}

// "Main" function
auto f(std::list<char*> a) {
    float m = 0;           // Maximum value
    
    for (char* t : a) {    // Loop through all the strings in the list
        m = m>g(t)?m:g(t); // If m is greater than the output from the function, return m. Otherwise, return the output of the function
    }
    
    return m;              // m is the final result that we want
}

Answer 3

><>, 36 35 bytes

000\&l3-,:{:@)?$&0(?n1[!
"(?\+:i:"!

Try it online!

Words are separated by spaces (or characters less than space like newline). This uses the length of the stack rather than a counter to get the length of the word.

Answer 4

Arturo, 48 22 bytes

$=>[map&=>average|max]

Try it

Answer 5

Husk, 6 bytes

▲moAmc

Try it online!

Outputs the highest average ord value as an exact fraction.

▲moAmc
 mo    # map 2 functions over each element of input
    mc #   get ord values of each character
   A   #   get the average of those
▲      # output the maximum.

Answer 6

JavaScript (Node.js), 58 bytes

a=>Math.max(...a.map(s=>eval(Buffer(s).join`+`)/s.length))

Try it online!

Answer 7

Nibbles, 8 bytes (16 nibbles)

`/.$/*+.$o$10,$]

Nibbles works only in integers, so this returns the maximum average ord multiplied by 10 (and rounded-down to a whole number).

`/.$/*+.$o$10,$]
  .$              # map over each input string
       .$         #   map over each character
         o$       #     getting it's ord 
      +           #   sum them all
     *     10     #   multiply by 10
    /             #   and divide by    
             ,$   #   the length of the string
`/                # finally, fold over the list
               ]  #   getting the max of each pair

Answer 8

sclin, 38 bytes

"dup S>c0\+ fold rev len /"map0\| fold

Try it here! This might be a good case for adding sum/prod/min/max functions to sclin, the fold construct is alright but it could be better.

For testing purposes:

["hello" "world" "bye"] ; 30N>d n>o
"dup S>c0\+ fold rev len /"map0\| fold

Explanation

Prettified code:

( dup S>c 0 \+ fold rev len / ) map 0 \| fold

Assuming input list xs.

• (...) map map over xs...
  • dup S>c get codepoints
  • 0 \+ fold sum
  • rev len / divide by length (i.e. average)
• 0 \| fold maximum

Answer 9

J-uby, 43 38 36 30 bytes

-5 bytes thanks to Steffan

Originally based on TKirishima's Ruby answer.

:*&:/%[:bytes|:sum,:+@|Q]|:max

Attempt This Online!

Explanation

:* & :/ % [ :bytes | :sum, :+@ | Q ] | :max

:* &                                         # Map with...
            :bytes | :sum                    #   Sum of bytes
     :/ % [              ,         ]         #   Divided by
                           :+@ | Q           #   Length converted to float
                                     | :max  # Get max

Answer 10

CJam, 19 14 bytes

{:d_:+\,/}%$W=

Try it online!

A function which takes an input as an array. Link includes test cases.

Explanation

{:d_:+\,/}%$W= # function which takes an array as input
{        }%    # for each value in the input array...
 :d            # short map `:` the operator `d` to convert into an array of `d`oubles
   _:+         # duplicate and sum
      \        # swap
       ,       # get the length of the array
        /      # divide, giving the average
           $   # perform a $ort on the resulting array
            W= # and get index `W` (shorthand for `-1`), which is the last value of the sort, or the max

Answer 11

Stax, ¹⁰ 9 bytes

é)u6║"⌂w╙

Run and debug it

This is a PackedStax program, which unpacks to the following:

{:V}kTlE:_

Run and debug it

Explanation (unpacked)

{  }k      # map the following over all the values in the input
 :V        # get the mean of the array
     T     # Get the maximum of this map
      l    # The output is a fraction, so it must be listified
       E   # Explode this list onto the stack
        :_ # Float division

Answer 12

Lua, 94 bytes

I tried two approaches here, both of which ended up having the same byte count.

List of Arguments

m=0 for i=1,#arg do n=0s=arg[i]s:gsub('.',load'n=s.byte(...)+n')m=math.max(m,n/#s)end print(m)

Try it online!

Space Delimited String

m=0(...):gsub('%S+',load'n=0s=...s:gsub(".",load"n=s.byte(...)+n")m=math.max(m,n/#s)')print(m)

Try it online!

Answer 13

Octave, 18 bytes

@(x)max(mean(+x'))

Try it online!

Answer 14

Zsh, 63 bytes

for w;c=&&for a (${(s::)w})((c+=#a,o=1.*c/$#w,m=o>m?o:m))
<<<$m

Try it online!  _{65b 74b}

for w; implicitly iterates over the arguments ($@).
for a (${(s::)w}) iterates over each letter in word w.
c accumulates the ascii sum
o is the average ord for w
m is the maximum o found

_{Edit: Saved 6 bytes by chaining 3 math expressions in the parentheses((,,))!}

Answer 15

Uiua, 15 bytes

/↥∵(÷⊃⧻/+-@\0⊔)

Try it!

/↥∵(÷⊃⧻/+-@\0⊔)
  ∵(          )  # map over input
             ⊔   # unbox a string
         -@\0    # subtract null character
    ÷⊃⧻/+        # mean
/↥               # max

Answer 16

Charcoal, 15 bytes

ＷＳ⊞υ∕ΣＥι℅κＬιＩ⌈υ

Try it online! Link is to verbose version of code. Takes input as a list of newline-terminated strings. Explanation:

ＷＳ

Repeat until the end of the list is reached...

⊞υ∕ΣＥι℅κＬι

... take the ordinals of the characters in the string, and divide their sum by the string's length.

Ｉ⌈υ

Output the maximum average.

Answer 17

Python 3, 71 70 bytes

lambda l:max(map(lambda s:mean(map(ord,s)),l))
from statistics import*

Try it online!

-1 thanks to The Thonnu

Answer 18

Thunno 2 G, 2 bytes

€m

Try it online!

Take the mean of €ach string in the (implicit) input list (this automatically converts to codepoints). Then, take the Greatest item.

Answer 19

Nekomata, 4 bytes

eᵐµṀ

Attempt This Online!

eᵐµṀ
e       Ord
 ᵐ      Map
  µ     Mean
   Ṁ    Maximum