[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](https://0.30000000000000004.com/) 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](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest code in bytes wins!**
  
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 7 bytes
```
eSm.OCM
```
[Test suite](https://pythtemp.herokuapp.com/?code=eSm.OCM&test_suite=1&test_suite_input=%5B%27hello%27%2C+%27world%27%2C+%27bye%27%5D%0A%5B%27code%27%2C+%27golf%27%2C+%27stack%27%2C+%27exchange%27%5D%0A%5B%27%21%40%23%27%2C+%27%24%25%5E%27%2C+%27%26%2a%28%27%5D%0A%5B%27qwertyuiop%5B%27%2C+%27asdfghjkl%3B%27%2C+%27zxcvbnm%2C%27%5D&debug=0)
##### Explanation:
```
eSm.OCM   | Full program
eSm.OCMdQ | with implicit variables
----------+-------------------------------
  m     Q | For each word in the input,
     CMd  |  Get the ord of each character
   .O     |  Get the average
eS        | Get the max
```
[Answer]
# [Python](https://www.python.org), 46 bytes
```
lambda l:max(sum(map(ord,s))/len(s)for s in l)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=XY5bCsIwEEX_XUXERxOp-iuK4D58QNokbXWS1CTV1q34UxB1Te5GBgXBr3OHcy_M9VE2Ibemvanl5l4FNZ69JsB1IjiBueY19ZWmmpfUOhF7xqYgDfVMWUc8KQwB9l09S1eYQBVdR7kEsFFMorN1IDAkjYy2jHV-ndQKiSazoJA-8PSAQdZpzk323--uemj7gx1iOKJ__niWLjRVYcs1FrgXKsv3B1jgdanTU2J0jJvPu2374Rs)
Unfortunately, the only built-in `mean` function Python has is in the `statistics` module, and that's too expensive to import.
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), ~~18~~ 11 bytes
```
|/{+/x%#x}'
```
[Try it online!](https://ngn.codeberg.page/k#eJxLs6rRr9bWr1BVrqhV5+LSV0iLVspIzcnJV4rl4kqL1oByrJXK84tyUoB0UmWqkmYsALq+EBc=)
*Massive -7 bytes golf thanks to Steffan!*
Damn everyone is answering quick. Anyways here's my solution. Takes input as a list of strings.
Explanation:
```
|/{+/x%#x}'  Main function. Takes implicit input
          '  For each string in the input...
  {      }   Execute a function that...
   +/x       Takes sum of every character in the string
      %      And divide it by
       #x    The length of the string
|/           Get the maximum value
```
[Answer]
# [Wren](https://wren.io/), 68 bytes
```
Fn.new{|x|x.reduce(0){|y,z|y.max(z.bytes.reduce{|a,b|a+b}/z.count)}}
```
[Try it](https://wren.io/try/?code=PTAWFMEMBNwJwFADdJwAQDMC8CEgMYD2sCAYgHYB054A7gN4A+AHi5XONAK77gAUABgCUTAJ4AaAF6NRlALaRmfSZQBGogC7gAzu049wTSONWNIAalUBfYCqJdyGoVau4QGQoS2IA2j4BEEAA2QYT+4v60hHBB0OH+6uD+ALriCGgBRLDxAOaEQRjx2hqQ+ADW8eDM+KCQ5DlJqekBAIQAAgDE8QAkADoApAB64Wj+AGQAVHwpaRn+AI608BqiXACWhAAOARGQ2tAYOaAAVmVBANzxktVIquRyKcmUUDVMrADKosXgcpSbcGtHHwMJR8JAQnxmEJnAggA)
[Answer]
# [APL(Dyalog Unicode)](https://dyalog.com), ~~14~~ 13 bytes [SBCS](https://github.com/abrudz/SBCS)
*-1 bytes thanks to [Adám](https://codegolf.stackexchange.com/users/43319/ad%c3%a1m)*
```
⌈/+⌿∘⎕UCS¨÷≢¨
```
[Try it on APLgolf!](https://razetime.github.io/APLgolf/?h=AwA&c=ARoA5f/ijIgvK@KMv@KImOKOlVVDU8Kow7fiiaLCqA&f=S1PPSM3JyVdXUC/PL8pJAdJJlanqXGnqyfkpqUBeen5OGpAqLklMzgbSqRXJGYl56WAVig7KQBGVOFUgqaalARIqLE8tKqkszcwviAYKJhanpKVnZGXnWAM5VRXJZUl5uTrqXAA&i=AwA&r=tryapl&l=apl-dyalog&m=dfn&n=f)
A tacit function which finds the maximum ord. Originally wrote a dfn, but I tried random stuff to convert it to tacit and it somehow worked out.
```
⌈/+⌿∘⎕UCS¨÷≢¨
          ¨              ⍝  for each element in the input...
     ⎕UCS               ⍝  convert the characters to their ascii values...
  +⌿∘                   ⍝  and sum the resulting ascii values...
           ÷             ⍝  divided by...
            ≢¨           ⍝  the length of each element...
⌈/                       ⍝  and take the maximum of that
```
[Answer]
# [><>](https://esolangs.org/wiki/Fish), ~~80~~ ~~51~~ 48 bytes
```
0>0001.
$i:"!"(?v+$1+
(@:{:,$&/
v?(0&~$?/.02
\n;
```
[Animated Version](https://mousetail.github.io/Fish/#eyJ0ZXh0IjoiMDAwMDEuXG4kaTpcIiFcIig/diskMStcbjokQDokLCQmLyhAXG52PygwJn4kPy98LiEwMFxuXFxuOyIsImlucHV0IjoiaGVsbG8gd29ybGQgYnllIiwic3RhY2siOiIiLCJtb2RlIjoibnVtYmVycyJ9)
~~Requires a extra space at the end of the input.~~ Also assumes no 2 spaces in a row. (no 0 length words). Anything with ORD of 32 or lower is considered white-space.
## Explanation
[![enter image description here](https://i.stack.imgur.com/cObTg.png)](https://i.stack.imgur.com/cObTg.png)
Top row: Push 3 0s on to the stack. The first is the current best ORD, the second is the length of the current word, and the last is the sum of the ord values of the current word. `01.` is a jump to the next row.
The second row sums a word. If a character is less than "!" (char value 33) go down. Otherwise sum the word and increment the length. `$1+
In the third row, we fist push the last value to the register `&` . We use this to later check if this was the end of the string. Then we divide by the length to get the new ORD value. Then we use the `:{:@` trick to copy the stack if it has only 2 elements (which is always the case) from the stack and compare them. If the new one is better we swap the stack with `$`. In either case we delete the top item.
Lastly, we take the value of the register and check if it is negative, `&0(?`. If so, we print the maximum ord and exit. If not, we jump back to `00`. To get the correct direction we use the `00!.|` trick.
[Answer]
# [><>](https://esolangs.org/wiki/Fish), ~~65~~ ~~45~~ 44 40 bytes
```
000i:"!"(?v+$1+$20.
$~$0(?n00.>@$,:{:@(?
```
[Try it online!](https://tio.run/##S8sszvj/38DAINNKSVFJw75MW8VQW8XIQI9LpU7FQMM@z8BAz85BRceq2spBw/7//4zUnJx8haTKVIXy/KKcFAA "><> – Try It Online")
Takes input as a space separated string.
[Answer]
# [Factor](https://factorcode.org), 24 bytes
```
[ 0 [ mean max ] foldl ]
```
[Attempt This Online!](https://ato.pxeger.com/run?1=dVA7TsQwEBVtTjEbLQghYRKBQpZt6BANDaKKFuF1nA_rxFnbYRMQJ6GJhKDgBNQcg9MwickWSEwxb8ae997YL-8JZUaq7nvn7ub68uriDESujYaCmoxoQw12OfvtpYq5wgHDFRUaNF_XvGRcQ6W4MW2l8tLA3HGmTw5guBkXQrrgbqQSMeKy5S4c9wbwNybg-x45sTwmYxx0UykSBNyCrRB5wzJaplsJJkvd87yAhJY3Of96xcHp7i3mvYP9_8ysYRiQUzjqIRhxKLhhxOqtN1yZts5lFaEg1XGSZvcrMcfmsWEPy7LYOtj9Z0gf0B8LbzYqPr_VJjkMPyPwIIKC0xI_tYEFJFLEAhb2-qOgFQwvJvag6yz-AA)
Just fold with the max of the mean.
[Answer]
# [R](https://www.r-project.org), 38 bytes
```
\(x)max(sapply(Map(utf8ToInt,x),mean))
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72waMGiNNulpSVpuhY31WI0KjRzEys0ihMLCnIqNXwTCzSAMhYh-Z55JToVmjq5qYl5mpoQ1bcYBdI0kjXUM1JzcvLVdRTUy_OLclJAjKTKVHVNTWUFLMDQ0EDPhAusLzk_JRWkOj0_Jw1EF5ckJmeDGKkVyRmJeekoZhgamOlZQPQpOiiDVKmoxoEoNS0NXHaBgKmpnrmCPogyg9FgRmpJsh7EuMLy1KKSytLM_IJokHmJxSlp6RlZ2TnWIF5VRXJZUl6uDswKkPMtgdrBtCGMYWAJNRESMAsWQGgA)
```
               Map(utf8ToInt,x)        # for every string in the input, store the vector of its codepoints in a list
        sapply(                ,mean)  # apply mean to each of the list elements and return a vector
\(x)max(                             ) # take max
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 4 bytes
```
OÆmṀ
```
[Try it online!](https://tio.run/##y0rNyan8/9//cFvuw50N////j1bPAArlq@soqJfnF@WkgBhJlanqsQA "Jelly – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~10 9~~ 4 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
ÇÅAà
```
-5 thanks to Sʨɠɠan
[Try it online!](https://tio.run/##yy9OTMpM/f//cPvhVsfDC/7/j1bKSM3JyVfSUVAqzy/KSQExkipTlWIB "05AB1E – Try It Online")
**Explained:**
```
ÇÅAà  # Implicit input as a list
      # Implicit map over the input:
Ç     #   Get the ord of each character
 ÅA   #   Get the average of the ords
   à  # Get the maximum value
```
[Answer]
# [Pip](https://github.com/dloscutoff/pip), 12 bytes
```
M:$+A*_/#_Mg
```
[Try It Online!](https://dso.surge.sh/#@WyJwaXAiLCIiLCJNOiQrQSpfLyNfTWciLCIiLCIiLCItcCBxd2VydHl1aW9wWyBhc2RmZ2hqa2w7IHp4Y3Zibm0sIl0=)
[Answer]
# [Knight](https://github.com/knight-lang/knight-lang) (v2), 56 bytes
```
;=mF;W=pP;=s!=i~1;W>Lp=i+1i=s+*10A Gp iTs&<m=t/sLp=m tOm
```
[Try it online!](https://knight-lang.netlify.app/#WyI7PW1GO1c9cFA7PXMhPWl+MTtXPkxwPWkrMWk9cysqMTBBIEdwIGlUcyY8bT10L3NMcD1tIHRPbSIsImNvZGVcbmdvbGZcbnN0YWNrXG5leGNoYW5nZSIsIjIuMCJd)
Because Knight doesn't support floating point values, it outputs the maximum average ord multiplied by \$10\$, as allowed by the rules:
> 
> It may be rounded to any number (\$\ge1\$) of decimal places. If your language does not support floating points, you may output the average multiplied by 10.
> 
> 
> 
[Answer]
# [Julia](https://julialang.org), 34 bytes
```
!a=max(sum.(Int,a)./length.(a)...)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=dZBNbsIwEIXFtqdIHIoclA6JBBRUIXXbMwCVjOP8gGPTxCmhV-mGDYeC05AJRMqinc17I837RjO_520pU3Y6nUsTvcwuxGaLjFW0KDOgH8p4zIWRFCo2CdDaA7j3yWuP7vNUGamovSSJkFITzyIHncsQzeYoyNq1_ignCHwYP3XSXIcCM7GWEWphGN-hERVPmIq7JCfwpzDrpu13B2dX_edP1MGQ_rMY05MJvFojq5Zpq40RhkMX-nUQuTmWqd4vEcqKMIqT7U6-YfdT8e-NyrzHnuageQ1pNGiNP39w7w9rX3wD)
[Answer]
# Excel (ms365), 70 bytes
[![enter image description here](https://i.stack.imgur.com/OYTTN.png)](https://i.stack.imgur.com/OYTTN.png)
Formula in `F1`:
```
=MAX(MAP(A1:C1,LAMBDA(a,SUM(CODE(MID(a,SEQUENCE(LEN(a)),1)))/LEN(a))))
```
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/math_golf.txt), 4 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py)
```
$m▓╙
```
Input as a list of lists of characters.
[Try it online.](https://tio.run/##TY9BDoIwFET33sKI1pjewI33aGoCIqBSUUBRr2E08XpcpE4/s2DxkmGYzwwubou8KjPvI9d/3/3n570xqlBa7UFJKmW1UZ0orWq6qbgJ1FPy1k5wu2MqHTwkcjrhJhOngWpBDEL@JG5ofNAp@PYM8tHXp9AbMJOLCGoOtvK0gFqBJbNX6I5/UrMxLL2BAzddgJHr0NZwd8bWsOIo@4b1a0m@RjvvIOFOBzS6/w)
**Explanation:**
```
$     # Get the codepoint of each inner-most character of the (implicit) input-list
 m    # Map over each list of integers:
  ▓   #  Pop and push the average of the list
   ╙  # After the map: pop and push the maximum
      # (after which the entire stack is output implicitly as result)
```
[Answer]
# [J](https://www.jsoftware.com), 18 bytes
```
[:>./(1#.3&u:%#)&>
```
Accepts list of boxed strings
[Attempt This Online!](https://ato.pxeger.com/run?1=m70wa8FOJT31NAVbKwV1BR0FAwUrINbVU3AO8nFbWlqSpmuxKdrKTk9fw1BZz1it1EpVWVPNDiJxs0eTKzU5I18hTUE9IzUnJ1_dWr08vygnBUgnVaaqwyWT81NSgWLp-TlpQKq4JDE5G0inViRnJOalI6lTdFAGiquoxgFJNS0NhERheWpRSWVpZn5BNFAqsTglLT0jKzvHGsipqkguS8rL1VGHuGnBAggNAA)
```
[:>./(1#.3&u:%#)&>
[:                  NB. cap, [: f g y -> f (g y)
                &>  NB. for each input item, result will be unboxed
     (         )    NB. monadic fork
              #     NB. length
         3&u:       NB. convert input to list of char codes
             %      NB. vectorized division
      1#.           NB. sum the result to compute average
  >./               NB. max item
```
[Answer]
# PHP 8.x, ~~75~~ 73 bytes
Creates an anonymous function that returns the expect values, hopefully.
```
fn($x)=>max(array_map(fn($z)=>array_sum(unpack('C*',$z))/strlen($z),$x));
```
---
-2 bytes thanks to [Sʨɠɠan](https://codegolf.stackexchange.com/users/92689/s%CA%A8%C9%A0%C9%A0an).
## How does it work?
This uses the [`unpack('C*', ...)`](https://www.php.net/manual/en/function.unpack.php) function to convert all characters into an unsigned char (`0`-`255`).  
This assumes all characters are part of the ASCII table.
Then it calculates the average using `array_sum([...])/strlen([...])`.  
The function [`array_sum()`](https://www.php.net/manual/en/function.array-sum.php) takes an array and returns the sum of all elements, and [`strlen()`](https://www.php.net/manual/en/function.strlen.php) returns the length of the string.
The function [`max()`](https://www.php.net/manual/en/function.max.php) takes the array with the averages and returns the highest value from it.
Anonymous functions implicitly return values.
## Example usage
You need to assign this to a variable, or call with [`call_user_func()`](https://www.php.net/manual/en/function.call-user-func) or [`call_user_func_array()`](https://www.php.net/manual/en/function.call-user-func-array.php):
```
<?php
$fn = fn($x)=>max(array_map(fn($z)=>array_sum(unpack('C*',$z))/strlen($z),$x));
// Should output: float(110.4)
var_dump($fn(['hello', 'world', 'bye']));
```
You can try this here (with test examples): <https://onlinephp.io/c/2a424>
[Answer]
# [MATLAB](https://www.gnu.org/software/octave/), 39 31 bytes
```
@(s)max(cellfun(@(x)mean(x),s))
```
Matlab unfortunately doesn't convert strings ("") directly to ASCII values using the double function, and if converted to char type then a string array will be padded with spaces to make a proper matrix. As a result, the input is a cellstr type, which needs to be looped over using the cellfun function with an anonymous function that takes the average of the unicode values of the strings (''). The output is then the maximum of those values.
[Try it online!](https://tio.run/##y08uSSxL/f/fQaNYMzexQiM5NScnrTRPw0GjQjM3NTEPSOkUa2r@/w8A "Octave – Try It Online")
edit: -8 bytes thanks to Guiseppe
[Answer]
# T-SQL, 125 bytes
```
WITH C as(SELECT len(x)m,0b,*FROM @
UNION ALL SELECT m-1,b+ascii(right(x,m)),x
FROM C WHERE
m>0)SELECT max(b*1./len(x))FROM c
```
**[Try it online](https://dbfiddle.uk/mTX9gZl8)**
[Answer]
# [Raku](https://www.raku.org/), 27 bytes
```
*».&{.ords.sum/.chars}.max
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPtf69BuPbVqvfyilGK94tJcfb3kjMSi4lq93MSK/9bFiZUKaRo2Gak5OfkK5flFOSkKSZWpdpr/AQ "Try It Online")
Edit: as per advice from @Steffan
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `G`, 3 bytes
```
Cvṁ
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyLhuItHQSIsIiIsIkN24bmBIiwiIiwiWydoZWxsbycsICd3b3JsZCcsICdieWUnXVxuWydjb2RlJywgJ2dvbGYnLCAnc3RhY2snLCAnZXhjaGFuZ2UnXVxuWychQCMnLCAnJCVeJywgJyYqKCddXG5bJ3F3ZXJ0eXVpb3BbJywgJ2FzZGZnaGprbDsnLCAnenhjdmJubSwnXSJd)
[Answer]
# [Ruby](https://www.ruby-lang.org/), 48 bytes
```
->l{l.map{_1.chars.sum(&:ord)/_1.size.to_f}.max}
```
As the division of two integers in ruby gives an integer, and what was expected was a float, it's long :/  
And `.fdiv` is one byte longer
[Attempt This Online!](https://ato.pxeger.com/run?1=XY5LDoJAEET3nkLjZ8AA6s5oNN4DPwFmBpCBwfkoSDyJGxL1UN5GOhoTXVV1v6p0X-9C-2V9o4v1QytqT59je8kq5qReXu0mThB5QjpSp8ZgxgU2R81OxmfiKL6jlyZVXD69W66VNKjroogwxpHVRicuGAbjlwRtNmbrGwk4JgBCziioVF6QgCFFczEL_-KdVRdgr78FGQyNX3w4EaFKHfPcBe5JTMNon7A5TOciOPpZakHl_Wpdv_UF)
[Answer]
# [Sequences](https://github.com/nayakrujul/sequences/), \$9 \log\_{256}(96) \approx 7.41\$ bytes
```
[$v$aH]gM
```
### Explanation
```
[$v$aH]gM  // Implicit list of string input
[     ]    // Loop through the input list:
 $v$       //   Get a list of ords of each character
    aH     //   Get the average and append to `g`
       g   // Push the list `g`
        M  // Get the maximum value
           // Implicit output
```
[![Screenshot](https://i.stack.imgur.com/OUb2h.png)](https://i.stack.imgur.com/OUb2h.png)
[Answer]
# Mathematica, 29 bytes
```
Max[Mean/@ToCharacterCode@#]&
```
[View it on Wolfram Cloud!](https://www.wolframcloud.com/obj/acdc57e3-3e30-449f-91e1-4fe95d3faafe)
[Answer]
# [Fig](https://github.com/Seggan/Fig), \$6\log\_{256}(96)\approx\$ 4.939 bytes
```
]KemMC
```
[Try it online!](https://fig.fly.dev/#WyJdS2VtTUMiLCJbaGVsbG8sd29ybGQsYnllXSJd)
```
]KemMC
     C - Charcodes
  emM  - Mean of each
 K     - Sort
]      - Last
```
[Answer]
# Java 8, ~~81~~ ~~79~~ 56 bytes
```
a->a.mapToDouble(s->s.chars().average().orElse(0)).max()
```
Input as a `Stream<String>` and output as an `OptionalDouble`.
[Try it online.](https://tio.run/##ZVHLbsIwELzzFa77kF3A6rm0qJXaY@mB3hCVFscEB8dObSeQVnx7uiSgPrh4vJ7Z2dE6gwqGWbJupIEQyAto@9UjRNuo/BKkIpN9SUiGOlFGbcRrEbWzYJ5cuTCKSPZDhegV5GLawh2CtumYAB@hxa6HR4gQtSQTYsl9A8MxiByKN9dZsTAcByFX4APjAirlIVV4c/7ZBMVuOEf1lvFmtLcqsAWtDo6V0wnJMTzrps7mwLvgUYXI6EoZ4@iAbpw3CeKiVrSNdRRIlyh8T51ZIqCrXCOqLcax6T/t2cM5cheX73heXbO/5MdG@ViX2hUzpCEky3SVrc0Ii8@trBY2H9CThbTx2/4uvhDimH9ah6hy4cooCqSisb8W/ug91EFE17Ux4H16S2jfCnmq6n4HNfwwf9d8Aw)
**Explanation:**
```
a->                  // Method with String-Stream parameter & OptionalDouble return-type
   a.map             //  Map over the input-Stream
        ToDouble(s-> //  and convert them to a Stream of Doubles
      s.chars()      //   Convert the String to an IntStream of its codepoint integers
       .average()    //   Then take the average of that IntStream (as OptionalDouble)
       .orElse(0))   //   And convert the OptionalDouble to double
                     //   (`.orElse(0)` is shorter than `.getAsDouble()`)
    .max()           //  After the map: leave the maximum (again as OptionalDouble)
```
[Answer]
# [BQN](https://mlochbaum.github.io/BQN/), ~~13~~ 12 bytes
*-1 byte inspired by [Aiden Chow's APL answer](https://codegolf.stackexchange.com/a/254368/16766)*
```
⌈´+´∘-⟜@¨÷≠¨
```
Anonymous tacit function; takes a list of strings and returns a float. [Try it at BQN online!](https://mlochbaum.github.io/BQN/try.html#code=RiDihpAg4oyIwrTCtygrwrTDt+KJoCnCqC3in5xACgpGICJxd2VydHl1aW9wWyLigL8iYXNkZmdoamtsOyLigL8ienhjdmJubSwiCg==)
### Explanation
```
⌈´+´∘-⟜@¨÷≠¨
          ≠¨  Length of each string
         ÷    Divide the following by the above:
  +´∘           Sum of
     -⟜@       Subtract null character from (each character in)
        ¨       Each string
⌈             Get the maximum of the resulting list of averages
```
[Answer]
# [Go](https://go.dev), ~~132~~ 108 bytes
```
func f(S[]string)(m int){for a,s:=range S{a=0
for _,r:=range s{a+=int(r)}
if a=a*10/len(s);a>m{m=a}}
return}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=NZBNTsMwEIXX-BTG_MXFQNmhVkEcAanLqFRuYieh_gm2Q1usnIRNhMQhuAR7boPdpKs38zya-Z4_v0rd_zQ039CSQUlrBWrZaONuEZcOfbeO3zz8Cd6qHPJkkS2tM7UqcSJhrRz2XBtIiZ2lhqqwYOFpOgXRXBFzNK2n12mYTgzuQM0hTenkfnonmEosntNH6WVKuw4Y5lqjuvHm7-FmJEqwB9bCWQqz5RHAe1QxITQiEG21EUUs1nuGOgI9ynXBolFqwaNaFwLGgu3yKjINY6dPZ9E8v3iJcjlJrgb_bcuM27e1brL4QG3By-p1I-ax-9jl72slCQrEQ9AD2hjVQg9OngOhEyEdCX9mMQYdGFP1_aD_)
* -24 bytes by @Sʨɠɠan: return as an int, multiplied by 10
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-h`](https://codegolf.meta.stackexchange.com/a/14339/), 9 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
Takes input as an array of character arrays.
```
®xc /ZlÃñ
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LWg&header=bXE&code=rnhjIC9abMPx&input=WyJoZWxsbyIsIndvcmxkIiwiYnllIl0)
```
®xc /ZlÃñ     :Implicit input of 2D array of characters
®             :Map each sub-array Z
 x            :  Reduce by addition of
  c           :    Codepoints
    /         :  Divide by
     Zl       :    Length of Z
       Ã      :End map
        ñ     :Sort
              :Implicit output of last element
```
]