Find words which contains more than 3 e vowels

Task

Use the dictionary unixdict.txt

Find words which contains more than three e vowels and contains only e vowels.

Show the output here on this page.

Other tasks related to string operations:

Metrics

Counting

Remove/replace

Anagrams/Derangements/shuffling

Find/Search/Determine

Formatting

Song lyrics/poems/Mad Libs/phrases

Tokenize

Sequences

Factor

<lang factor>USING: formatting io io.encodings.ascii io.files kernel math sequences ;

"unixdict.txt" ascii file-lines [ [ "aiou" member? ] any? ] reject [ [ CHAR: e = ] count 3 > ] filter [ 1 + "%2d: " printf print ] each-index</lang>

Output:

 1: belvedere
 2: dereference
 3: elsewhere
 4: erlenmeyer
 5: evergreen
 6: everywhere
 7: exegete
 8: freewheel
 9: nevertheless
10: persevere
11: preference
12: referee
13: seventeen
14: seventeenth
15: telemeter
16: tennessee

Go

<lang go>package main

import (

   "bytes"
   "fmt"
   "io/ioutil"
   "log"
   "strings"
   "unicode/utf8"

)

func main() {

   wordList := "unixdict.txt"
   b, err := ioutil.ReadFile(wordList)
   if err != nil {
       log.Fatal("Error reading file")
   }
   bwords := bytes.Fields(b)
   var words []string

outer:

   for _, bword := range bwords {
       s := string(bword)
       if utf8.RuneCountInString(s) >= 4 {
           for _, c := range s {
               if strings.ContainsRune("aiou", c) {
                   continue outer
               }
           }
           words = append(words, s)
       }
   }
   wcount := 0
   for _, word := range words {
       ecount := 0
       for _, c := range word {
           if c == 'e' {
               ecount++
           }
       }
       if ecount > 3 {
           wcount++
           fmt.Printf("%2d: %s\n", wcount, word)
       }
   }

}</lang>

Output:

 1: belvedere
 2: dereference
 3: elsewhere
 4: erlenmeyer
 5: evergreen
 6: everywhere
 7: exegete
 8: freewheel
 9: nevertheless
10: persevere
11: preference
12: referee
13: seventeen
14: seventeenth
15: telemeter
16: tennessee

See Alternade_words#Julia for the foreachword function. <lang julia>ecount(word) = count(x -> x == 'e', word) vowelcount(word) = count(x -> x in ['a', 'e', 'i', 'o', 'u'], word) onlyevowelsmorethan3(word, _) = begin n, m = vowelcount(word), ecount(word); n == m && m > 3 ? word : "" end

foreachword("unixdict.txt", onlyevowelsmorethan3, colwidth=15, numcols=8)

</lang>

Output:

belvedere      dereference    elsewhere      erlenmeyer     evergreen      everywhere     exegete        freewheel      
nevertheless   persevere      preference     referee        seventeen      seventeenth    telemeter      tennessee

Phix

<lang Phix>function note(string word) return find_any("aiou",word)=0 and length(find_all('e',word))>3 end function sequence notes = filter(get_text("demo/unixdict.txt",GT_LF_STRIPPED),note) printf(1,"%d words: %s\n",{length(notes),join(shorten(notes,"",3))})</lang>

Output:

16 words: belvedere dereference elsewhere ... seventeenth telemeter tennessee

Raku

<lang perl6>.say for "unixdict.txt".IO.lines.grep: { !/<[aiou]>/ and /e.*e.*e.*e/ };</lang>

Output:

belvedere
dereference
elsewhere
erlenmeyer
evergreen
everywhere
exegete
freewheel
nevertheless
persevere
preference
referee
seventeen
seventeenth
telemeter
tennessee

REXX

This REXX version doesn't care what order the words in the dictionary are in, nor does it care what
case (lower/upper/mixed) the words are in, the search for the words and vowels is caseless.

It also allows the vowel to be specified, and also the minimum number of the specific vowels to be specified on the command line (CL) as well as the dictionary file identifier. <lang rexx>/*REXX pgm finds words (within an identified dict.) which contain more than three "e"s.*/ parse arg char many iFID . /*obtain optional arguments from the CL*/ if char== | char=="," then char= 'e' /*Not specified? Then use the default.*/ if many== | many=="," then many= 4 /* " " " " " " */ if iFID== | iFID=="," then iFID='unixdict.txt' /* " " " " " " */ chrU= char; upper chrU /*obtain an uppercase version of char.*/

          do #=1  while lines(iFID)\==0         /*read each word in the file  (word=X).*/
          x= strip( linein( iFID) )             /*pick off a word from the input line. */
          @.#= x                                /*save:  the original case of the word.*/
          end   /*#*/                           /* [↑]   semaphore name is uppercased. */

= # - 1 /*adjust word count because of DO loop.*/

say copies('─', 30) # "words in the dictionary file: " iFID finds= 0 /*count of the "eeee" words found. */ vowels= 'aeiou' /*obtain the list of all the vowels. */ upper vowels /*uppercase all the other vowels. */ vowels= space( translate(vowels, , chrU), 0) /*elide the one vowel we're looking for*/

    do j=1  for #;      $= @.j                  /*process all the words that were found*/
    upper $                                     /*uppercase it for caseless finds.     */
    if verify(vowels, $, 'M')>0  then iterate   /*Does it contain other vowels? Skip it*/
    if countstr(chrU, $) < many  then iterate   /*Does it have enough of  'e's?   "   "*/
    finds= finds + 1                            /*bump count of only "e" vowels found. */
    say right(left(@.j, 30), 40)                /*indent original word for readability.*/
    end        /*j*/
                                                /*stick a fork in it,  we're all done. */

say copies('─', 30) finds ' "e" words found using the characters: ' many "'e'"</lang>

output when using the default inputs:

────────────────────────────── 25104 words in the dictionary file:  unixdict.txt
          belvedere
          dereference
          elsewhere
          erlenmeyer
          evergreen
          everywhere
          exegete
          freewheel
          nevertheless
          persevere
          preference
          referee
          seventeen
          seventeenth
          telemeter
          tennessee
────────────────────────────── 16  "e" words found using the characters:  4 'e'

Ring

<lang ring> load "stdlib.ring"

cStr = read("unixdict.txt") wordList = str2list(cStr) char = list(9) nextwords = [] nr = 0 num = 0

see "working..." + nl

ln = len(wordList) for n = ln to 1 step -1

   if len(wordList[n]) < 6
      del(wordList,n)
   ok

for n = 1 to len(wordList)

   num = 0
   flag = 1
   for m = 1 to len(wordList[n])
       if isvowel(wordList[n][m])
          if wordList[n][m] != "e"
             flag = 0
             exit
          else
             num = num + 1
          ok
       ok
   next
   if flag = 1 and num > 3
      nr = nr + 1
      see "" + nr + ". " + wordList[n] + nl
   ok

working...
Words are:
1. belvedere
2. dereference
3. elsewhere
4. erlenmeyer
5. evergreen
6. everywhere
7. exegete
8. freewheel
9. nevertheless
10. persevere
11. preference
12. referee
13. seventeen
14. seventeenth
15. telemeter
16. tennessee
done...

Wren

Library: Wren-fmt

<lang ecmascript>import "io" for File import "/fmt" for Fmt

var hasAIOU = Fn.new { |word| word.any { |c| "aiou".contains(c) } } var wordList = "unixdict.txt" // local copy var words = File.read(wordList).trimEnd().split("\n").where { |w| w.count >= 4 && !hasAIOU.call(w) }.toList var count = 0 for (word in words) {

   if (word.count { |c| c == "e" } > 3) {
       count = count + 1
       Fmt.print("$2d: $s", count, word)
   }

}</lang>

Output:

 1: belvedere
 2: dereference
 3: elsewhere
 4: erlenmeyer
 5: evergreen
 6: everywhere
 7: exegete
 8: freewheel
 9: nevertheless
10: persevere
11: preference
12: referee
13: seventeen
14: seventeenth
15: telemeter
16: tennessee