Mode length of a sentence

Question

The task is simple. You are given a string with alphabetical words (say "Hello world, this are tests"). You have to return the mode of the lengths of words in the string. In this case, output is 5, as it's the most often length of words in the string.

Definition of an alphabetical word (for this challenge): a string that consists of a-zA-Z only.

Sample I/O:

Constraints: Input has atleast one word, and a unique mode. Max. length is provided in last test case. Also, the string would be a single line, no newline chars.

(In = Out format)

"Hello world, this are tests"                     =  5
"Hello    world, this... are tests"               =  5
"I"                                               =  1
"Let's box (ง︡'-'︠)ง"                               =  3
"Writing some ✍(◔◡◔) program"                   =  7
"the-the-the-then"                                =  3
"Gooooooooogle is an app"                         =  2
"()<>a+/sentence$#@(@with::many---_symbols{}|~~"  =  4
"anot_her test actually"                          =  4

_{The unicode tests are optional.}

1000 words string = 5 (Password: PXuCdMj5u65vwst)

This is a code-golf, so fewest bytes will win!

Answer 1

05AB1E, 10 9 7 bytes

-1 byte inspired by Jonathan Allans Jelly answer.
-2 bytes thanks to Kevin Cruijssen!

Input is a list of characters.

aγO0K.M

Try it online!

Commented:

aγO0K.M     implicit input       ["a","b"," ","c","d"," ","e","."]

a           is_alpha (vectorizes)[1, 1, 0, 0, 1, 1, 0, 1, 0]
 γ          split into chunks of equal elements
              [[1, 1], [0, 0], [1, 1], [0], [1], [0]]
  O         sum the lists        [2, 0, 2, 0, 1, 0]
   0K       remove 0's
     .M     mode                 2

            implicit output      2

a is implemented as Regex.match?(~r/^[a-zA-Z]+$/, to_string(x)), which should be equivalent to the challenge specification.

I feel like there has to be a shorter way to remove 0s from a list than ʒĀ}.

Answer 2

APL (Dyalog Unicode), 30 bytes

{⍵[⊃⍒+/∘.=⍨⍵]}≢¨⊆⍨⎕A∊⍨1(819⌶)⎕

Try it online!

{⍵[⊃⍒+/∘.=⍨⍵]}≢¨⊆⍨⎕A∊⍨1(819⌶)⎕ ⍝ Full program
1(819⌶)⎕ ⍝ Uppercase the input
⎕A∊⍨     ⍝ Test if each character is a capital letter
⊆⍨       ⍝ Group the letters together
≢¨       ⍝ Length of each word
{⍵[⊃⍒+/∘.=⍨⍵]} ⍝ Mode

The mode dfn is by ngn. My approach was similar but one byte longer: {⊃⍵[⍒+/¨⍵⍷¨⊂⍵]}.

Answer 3

Ruby, 70 68 58 bytes

->s{(s=s.scan(/[a-z]+/i).map &:size).max_by{|y|s.count y}}

Try it online!

-20 bytes from Dingus.

-2 bytes from Rahul Verma.

-10 bytes from Dingus(again) by removing a variable.

Ruby, 90 bytes

->a{a.split(/\W+/).map(&:size).inject(Hash.new(0)){|h,v|h[v]+=1;h}.sort_by{|k,v|v}[-1][0]}

Try it online!

Answer 4

R, 79 67 bytes

Edit: -9 and then -3 more bytes thanks to Giuseppe

names(sort(-table(nchar(el(strsplit(scan(,''),"[^a-zA-Z]+"))))))[1]

Try it online!

Commented:

names(              # Get the names (=values) of...
  sort(-            # the descending (-) frequencies of...
    table(          # the table of values of...
     (w=nchar(      # the number of characters of...
       strsplit(scan(,''),
                    # the input, grouped by splitting on...
       "[^a-zA-Z0-9]")[[1]]))
                    # non-alphanumeric characters...
     [w>0]          # ignoring zero-length groups.
    )               
  )
)[1]                # Output the first name, which is
                    # the most-frequent number of characters
                    # per group.

Answer 5

JavaScript (ES6), 66 bytes

s=>s.replace(o=/[a-z]+/gi,w=>o[s]>(o[n=w.length]=-~o[n])?0:s=n)&&s

Try it online!

Answer 6

Retina 0.8.2, 43 bytes

M!i`[a-z]+
%M`.
O#`
O#^$`(.+)(¶\1)*
$#2
1G`

Try it online! Link includes test cases. Explanation:

M!i`[a-z]+

List only the words.

%M`.

Take the length of each word.

O#`

Sort the lengths numerically.

O#^$`(.+)(¶\1)*
$#2

Sort in reverse order of frequency.

1G`

Take the mode.

Answer 7

Jelly, 11 bytes

e€ØẠŒg§ḟ0Æṃ

A monadic Link accepting a list of characters which yields an integer.

Try it online! Or see the test-suite.

How?

e€ØẠŒg§ḟ0Æṃ - Link: S
  ØẠ        - alphabetic characters
 €          - for each (c in S)
e           -   (c) exists in (S)?
    Œg      - group runs of equal elements (1s or 0s)
      §     - sums
        0   - zero
       ḟ    - filter discard
         Æṃ - mode

Answer 8

Perl 5 -pF'[^A-Za-z]+', 51 bytes

map$k{y///c}++,@F;$_=(sort{$k{$b}-$k{$a}}keys%k)[0]

Try it online!

Answer 9

MATL, 8 bytes

3Y4XXzXM

Supports ASCII characters only. Try it online! Or verify all ASCII test cases.

How it works

3Y4   % Push predefined literal '[A-Za-z]+'
XX    % Implicit input. Regexp. Gives cell array of matched substrings
z     % Number of nonzero chars of each substring
XM    % Mode. Implicit display

Answer 10

Pip, 18 bytes

aMR:+XA#_(_NaSKav)

Try it online!

Explanation

aMR:+XA#_(_NaSKav)
                    a is 1st cmdline arg; v is -1 (implicit)
aMR:                Map a function to each regex match in a and assign the result back to a
    +XA              Regex: a letter (XA) repeated one or more times (+)
       #_            The function: length of the match
                    Now we just need to get the mode:
             SKa    Sort a using this key function:
          _Na        Count of each element in the full list a
         (      v)  Since it's now sorted from least common to most, get the last element

If Pip had a two-byte builtin for getting the mode of a list, I could do this in 10 bytes: MO#*Ya@+XA (with MO being the mode builtin). Ah well.

Answer 11

Python 3, 148 143 140 132 100 99 bytes

n,*c=0,
for x in input()+'1':
 if'`'<x.lower()<'{':n+=1
 elif n:c+=n,;n=0
print(max(c,key=c.count))

Try it online!

Uses regex to check if character is a letter of the English alphabet and adds the count of all consecutive alphabets to a list and finds the mode of that list.

-3 bytes thanks to Rahul Verma

-32 bytes thanks to ovs

-1 byte thanks to DLosc

Answer 12

Husk, ¹² 8 bytes

►=mLmf√w

Try it online!

Previous answer was badly optimized.(-4 bytes)

From Zgarb:

► has a second mode. If you give it a binary function f, it returns an element x that maximizes the number of elements y for which fxy holds.

So ►= is a 2-byte max by frequency.

Explanation

►=fImLmf√ġK√
         ġK√ group string on non alphabet-characters.
       f√    filter out non-alphabet characters
      m      map that to each word ↑
    mL       Length of each word
  fI         filter out zeroes (empty string length)
►=           max by frequency

Answer 13

Scala, 66 bytes

"[a-zA-Z]+".r.findAllIn(_).toSeq.groupBy(_.size)maxBy(_._2.size)_1

Try it in Scastie

Unfortunately, finding the mode in Scala is a bit clumsy

Answer 14

Io, 141 bytes

A really awful solution... just 2 bytes shorter than the Python one. 3

method(x,x asUppercase asList map(i,if(if(i at(0),i at(0),0)isLetter,1,0))join split("0")map(size)remove(0)uniqueCount map(reverse)max at(1))

Try it online!

Answer 15

Java (JDK), 129 bytes

Saved 10 bytes thanks to @ceilingcat!

s->{int m=0,z=s.length()+1,a[]=new int[z];for(var x:s.split("[^a-zA-Z]+"))a[x.length()]++;for(;z-->0;m=a[z]>a[m]?z:m);return m;};

Try it online!

---

Explanation:

s -> {
  int m=0,             //m is the index of the max element in a
      z=s.length()+1,  //z is to avoid using a.length twice
      a[]=new int[z];  //Each index corresponds to a length, and the element at that index its frequency
  for(var x : s.split("[^a-zA-Z]+")) //Fill up the pigeonholes
    a[x.length()]++;
  for(;                 //Find the index of the max element/highest frequency/mode
      z-->0;            //For every index from a.length to 0,
      m=a[z]>a[m]?z:m); //If the current element is greater than the current max frequency, change the mode length
  return m;             //Return the length with the highest frequency
};

Answer 16

Java (JDK), 113 bytes

s->{int m=0,l=s.length(),t,L=0;for(;l>0;L=t>m?(m=t)-m+l:L)t=s.split("\\b[a-zA-Z]{"+l--+"}\\b").length;return-~L;}

Try it online!

Explanation

This basically splits the String on ascii words of all possible lengths to count them, and returns the max value of the count.

s->{
 int m=0,                                 // The maximum number of 
     l=s.length(),                        // The length of ASCII letters, going from high to low
     t,                                   // Declare a temp variable.
     L=0;                                 // Initialize the most present length to 0.
 for(                                     // Loop
      ;
      l>0;                                // On each length, going down
      L=t>m?(m=t)-m+l:L                   // If a count is higher than the max count, the new count becomes the max count and the most present length becomes the current length
     )
  t=                                     
      s.split("\\b[a-zA-Z]{"+l--+"}\\b")  // Count the number of parts between or around words of length l
                                          // Also, decrement l
       .length;                           // Store the count into t
 return-~L;                               // Return L + 1
}

Answer 17

C (gcc), 115 113 112 bytes

-1 byte ceilingcat

m;n;w;c;l;i;f(char*s){for(m=n=l=0;s[l++];m=c>n?n=c,l:m)for(i=w=c=0;w=isalpha(s[i])?1+w:w-l?0:!++c,s[i++];);n=m;}

Try it online!

Answer 18

Japt v2.0a0, 13 bytes

q\L f üÊñÊÌÌÊ

Try it

q\L f üÊñÊÌÌÊ     :Implicit input of string U    e.g., "()<>a+/sentence$#@(@with::many---_symbols{}|~~"
q                 :Split on
 \L               :  Regex /[^a-z]/i             ["","","","","a","","sentence","","","","","with","","many","","","","symbols","","","","",""]
    f             :Filter (remove empty strings) ["a","sentence","with","many","symbols"]
      ü           :Group & sort by
       Ê          :  Length                      [["a"],["with","many"],["symbols"],["sentence"]]
        ñ         :Sort by
         Ê        :  Length                      [["a"],["symbols"],["sentence"],["with","many"]]
          Ì       :Last element                  ["with","many"]
           Ì      :Last element                  "many"
            Ê     :Length                        4

Answer 19

Python 3.8, 81 75 bytes

Thanks to Mukundan314 for 5 bytes and ovs for another 1 byte

lambda S:max(L:=[*map(len,re.findall("[a-z]+",S,2))],key=L.count)
import re

Try it online!

Anonymous function: Finds all runs of letters using regex, collects a list of the lengths of those runs, and prints the item with the maximum frequency in the list.

Answer 20

Wolfram Language (Mathematica), 48 bytes

Commonest@*StringLength@*StringCases[__?LetterQ]

Try it online! Function. Takes a string as input and returns a list of most common lengths as output. The list should only have a single number if the mode length is unique. It gives incorrect output on one of the Unicode examples, presumably due to ง counting as a letter.

Answer 21

PHP, 101 bytes

$a=array_count_values(array_map(strlen,preg_split('/[^A-Za-z]/',$argn,0,1)));arsort($a);echo key($a);

Try it online!

Drat PHP and it's super long function names again...

Answer 22

Factor + math.unicode, 57 bytes

[ [ Letter? ¬ ] split-when harvest [ length ] map mode ]

Try it online!

Split on non-letters, harvest (remove) any vestigial empty strings, get the length of each word, and take the mode.