Find words which contains all the vowels: Difference between revisions

From Rosetta Code
Content added Content deleted
(Add COBOL)
m (→‎{{header|R}}: Syntax highlighting.)
Line 1,324: Line 1,324:
=={{header|R}}==
=={{header|R}}==
Adapting this from https://rosettacode.org/wiki/Find_words_which_contain_the_most_consonants#R is trivial.
Adapting this from https://rosettacode.org/wiki/Find_words_which_contain_the_most_consonants#R is trivial.
<lang R>dict <- scan("https://web.archive.org/web/20180611003215/http://www.puzzlers.org/pub/wordlists/unixdict.txt", what = character())
<lang rsplus>dict <- scan("https://web.archive.org/web/20180611003215/http://www.puzzlers.org/pub/wordlists/unixdict.txt", what = character())
dictBig <- dict[nchar(dict) > 10]
dictBig <- dict[nchar(dict) > 10]
#The following line is equivalent to sapply(c("a", "e", "i", "o", "u"), function(x) stringr::str_count(dictBig, x))
#The following line is equivalent to sapply(c("a", "e", "i", "o", "u"), function(x) stringr::str_count(dictBig, x))

Revision as of 23:15, 8 January 2022

Find words which contains all the vowels is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.
Task

Use the dictionary  unixdict.txt

Find the words which contains all the vowels,   but each vowel should appear only once in a word.

The length of any word shown should have a length   >  10.


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



11l

<lang 11l>L(word) File(‘unixdict.txt’).read().split("\n") 

  I word.len > 10
     L(vowel) (‘a’, ‘e’, ‘i’, ‘o’, ‘u’)
        I word.count(vowel) != 1
           L.break
     L.was_no_break
        print(word)</lang>
Output:
ambidextrous
bimolecular
cauliflower
communicable
communicate
consanguine
consultative
countervail
exclusionary
grandiloquent
importunate
incommutable
incomputable
insupportable
loudspeaking
malnourished
mensuration
oneupmanship
pandemonium
permutation
perturbation
portraiture
praseodymium
stupefaction
sulfonamide

Action!

In the following solution the input file unixdict.txt is loaded from H6 drive. Altirra emulator automatically converts CR/LF character from ASCII into 155 character in ATASCII charset used by Atari 8-bit computer when one from H6-H10 hard drive under DOS 2.5 is used. <lang Action!>BYTE FUNC Once(CHAR ARRAY text CHAR c) 

 BYTE i,n

 i=1 n=0
 FOR i=1 TO text(0)
 DO
   IF text(i)=c THEN
     n==+1
     IF n>1 THEN
       RETURN (0)
     FI
   FI
 OD
 IF n=1 THEN
   RETURN (1)
 FI

RETURN (0)

BYTE FUNC IsValidWord(CHAR ARRAY word) 

 IF word(0)<=10 THEN RETURN (0) FI
 IF Once(word,'a)=0 THEN RETURN(0) FI
 IF Once(word,'e)=0 THEN RETURN(0) FI
 IF Once(word,'i)=0 THEN RETURN(0) FI
 IF Once(word,'o)=0 THEN RETURN(0) FI
 IF Once(word,'u)=0 THEN RETURN(0) FI

RETURN (1)

PROC FindWords(CHAR ARRAY fname) 

 CHAR ARRAY line(256)
 CHAR ARRAY tmp(256)
 BYTE pos,dev=[1]

 pos=2
 Close(dev)
 Open(dev,fname,4)
 WHILE Eof(dev)=0
 DO
   InputSD(dev,line)
   IF IsValidWord(line) THEN
     IF pos+line(0)>=39 THEN
       PutE() pos=2
     FI
     Print(line) Put(32)
     pos==+line(0)+1
   FI
 OD
 Close(dev)

RETURN

PROC Main() 

 CHAR ARRAY fname="H6:UNIXDICT.TXT"

 FindWords(fname)

RETURN</lang>

Output:

Screenshot from Atari 8-bit computer 

ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary
grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration
oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide

Ada

<lang Ada>with Ada.Text_Io; with Ada.Strings.Maps; with Ada.Strings.Fixed;

procedure Find_All_Vowels is 

  use Ada.Text_Io;
  use Ada.Strings;

  type Vowels     is ('a', 'e', 'i', 'o', 'u');
  type Count_Type is array (Vowels) of Natural;

  Filename : constant String := "unixdict.txt";
  Chars    : constant array (Vowels) of Character := "aeiou";
  File     : File_Type;

begin 

  Open (File, In_File, Filename);
  while not End_Of_File (File) loop
     declare
        Word  : constant String  := Get_Line (File);
        Count : Count_Type;
     begin
        for Vowel in Vowels loop
           Count (Vowel) := Fixed.Count (Word, Maps.To_Set (Chars (Vowel)));
        end loop;

        if Count = Count_Type'(others => 1) and Word'Length > 10 then
           Put_Line (Word);
        end if;
     end;
  end loop;
  Close (File);

end Find_All_Vowels;</lang>

ALGOL 68

<lang algol68># find 11 or more character words that contain all the vowels once #

  1. read the list of words and look for suitable words #

IF FILE input file; 

   STRING file name = "unixdict.txt";
   open( input file, file name, stand in channel ) /= 0

THEN 

   # failed to open the file #
   print( ( "Unable to open """ + file name + """", newline ) )

ELSE 

   # file opened OK #
   BOOL at eof := FALSE;
   # set the EOF handler for the file #
   on logical file end( input file, ( REF FILE f )BOOL:
                                    BEGIN
                                        # note that we reached EOF on the #
                                        # latest read #
                                        at eof := TRUE;
                                        # return TRUE so processing can continue #
                                        TRUE
                                    END
                      );
   INT vowel words := 0;
   WHILE STRING word;
         get( input file, ( word, newline ) );
         NOT at eof
   DO
       IF ( UPB word - LWB word ) + 1 > 10 THEN
           # have an eleven or more character word #
           INT a count := 0, e count := 0, i count := 0, o count := 0, u count := 0;
           FOR w pos FROM LWB word TO UPB word DO
               CHAR c = word[ w pos ];
               IF   c = "a" THEN a count +:= 1
               ELIF c = "e" THEN e count +:= 1
               ELIF c = "i" THEN i count +:= 1
               ELIF c = "o" THEN o count +:= 1
               ELIF c = "u" THEN u count +:= 1
               FI
           OD;
           IF a count = 1 AND e count = 1 AND i count = 1 AND o count = 1 AND u count = 1 THEN
              vowel words +:= 1;
              print( ( whole( vowel words, -5 ), ": ", word, newline ) )
           FI
       FI
   OD;
   close( input file )

FI</lang>

Output:
    1: ambidextrous
    2: bimolecular
    3: cauliflower
    4: communicable
    5: communicate
    6: consanguine
    7: consultative
    8: countervail
    9: exclusionary
   10: grandiloquent
   11: importunate
   12: incommutable
   13: incomputable
   14: insupportable
   15: loudspeaking
   16: malnourished
   17: mensuration
   18: oneupmanship
   19: pandemonium
   20: permutation
   21: perturbation
   22: portraiture
   23: praseodymium
   24: stupefaction
   25: sulfonamide

Arturo

<lang rebol>words: read.lines relative "unixdict.txt" vowels: ["a" "e" "i" "o" "u"] containsAllVowels?: function [w][ 

   loop vowels 'v [
       if not? contains? w v -> return false
       if 1 < size match w v -> return false
   ]
   return true

]

loop words 'word [ 

   if 10 < size word [
       if containsAllVowels? word ->
           print word
   ]

]</lang>

Output:
ambidextrous
bimolecular
cauliflower
communicable
communicate
consanguine
consultative
countervail
exclusionary
grandiloquent
importunate
incommutable
incomputable
insupportable
loudspeaking
malnourished
mensuration
oneupmanship
pandemonium
permutation
perturbation
portraiture
praseodymium
stupefaction
sulfonamide

AutoHotkey

<lang AutoHotkey>FileRead, db, % A_Desktop "\unixdict.txt" vowels := ["a", "e", "i", "o", "u"] main: for i, word in StrSplit(db, "`n", "`r") { 

   if StrLen(word) < 11
       continue
   for j, v in vowels
   {
       StrReplace(word, v, v, c)
       if (c<>1)
           continue, main
   }
   result .= word "`n"

} MsgBox, 262144, , % result</lang>

Output:
ambidextrous
bimolecular
cauliflower
communicable
communicate
consanguine
consultative
countervail
exclusionary
grandiloquent
importunate
incommutable
incomputable
insupportable
loudspeaking
malnourished
mensuration
oneupmanship
pandemonium
permutation
perturbation
portraiture
praseodymium
stupefaction
sulfonamide

AWK

<lang AWK>

  1. syntax: GAWK -f FIND_WORDS_WHICH_CONTAINS_ALL_THE_VOWELS.AWK unixdict.txt

{ if (length($0) <= 10) { 

     next
   }
   tmp = gsub(/a/,"&",$0) gsub(/e/,"&",$0) gsub(/i/,"&",$0) gsub(/o/,"&",$0) gsub(/u/,"&",$0)
   if (tmp ~ /^11111$/) {
     printf("%s\n",$0)
   }

} END { 

   exit(0)

} </lang>

Output:
ambidextrous
bimolecular
cauliflower
communicable
communicate
consanguine
consultative
countervail
exclusionary
grandiloquent
importunate
incommutable
incomputable
insupportable
loudspeaking
malnourished
mensuration
oneupmanship
pandemonium
permutation
perturbation
portraiture
praseodymium
stupefaction
sulfonamide

BASIC

<lang basic>10 DEFINT A-Z: DEFSTR C,W 20 OPEN "I",1,"UNIXDICT.TXT" 30 IF EOF(1) THEN CLOSE #1: END 40 LINE INPUT #1,W 50 IF LEN(W)<=10 THEN 30 60 A=0: E=0: I=0: O=0: U=0 70 FOR N=1 TO LEN(W) 80 C=MID$(W,N,1) 90 IF C="a" THEN A=A+1: IF A>1 THEN 30 100 IF C="e" THEN E=E+1: IF E>1 THEN 30 110 IF C="i" THEN I=I+1: IF I>1 THEN 30 120 IF C="o" THEN O=O+1: IF O>1 THEN 30 130 IF C="u" THEN U=U+1: IF U>1 THEN 30 140 NEXT N 150 IF A=1 AND E=1 AND I=1 AND O=1 AND U=1 THEN PRINT W, 160 GOTO 30</lang>

Output:
ambidextrous  bimolecular   cauliflower   communicable  communicate
consanguine   consultative  countervail   exclusionary  grandiloquent
importunate   incommutable  incomputable  insupportable loudspeaking
malnourished  mensuration   oneupmanship  pandemonium   permutation
perturbation  portraiture   praseodymium  stupefaction  sulfonamide

BCPL

<lang bcpl>get "libhdr"

let reads(v) = valof $( v%0 := 0 

   $(  let ch = rdch()
       if ch = endstreamch resultis false
       if ch = '*N' resultis true
       v%0 := v%0 + 1
       v%(v%0) := ch
   $) repeat

$)

let count(ch, str) = valof $( let n = 0 

   for i=1 to str%0
       if str%i = ch then n := n + 1
   resultis n

$)

let testword(str) = 

   str%0 > 10 & 
   count('a',str) = 1 &
   count('e',str) = 1 &
   count('i',str) = 1 &
   count('o',str) = 1 &
   count('u',str) = 1

let start() be $( let word = vec 256/BYTESPERWORD 

   selectinput(findinput("unixdict.txt"))
   while reads(word) if testword(word) do writef("%S*N", word)
   endread()

$)</lang>

Output:
ambidextrous
bimolecular
cauliflower
communicable
communicate
consanguine
consultative
countervail
exclusionary
grandiloquent
importunate
incommutable
incomputable
insupportable
loudspeaking
malnourished
mensuration
oneupmanship
pandemonium
permutation
perturbation
portraiture
praseodymium
stupefaction
sulfonamide

C++

<lang cpp>#include <bitset>

  1. include <cctype>
  2. include <cstdlib>
  3. include <fstream>
  4. include <iomanip>
  5. include <iostream>

bool contains_all_vowels_once(const std::string& word) { 

   std::bitset<5> vowels;
   for (char ch : word) {
       ch = std::tolower(static_cast<unsigned char>(ch));
       size_t bit = 0;
       switch (ch) {
       case 'a': bit = 0; break;
       case 'e': bit = 1; break;
       case 'i': bit = 2; break;
       case 'o': bit = 3; break;
       case 'u': bit = 4; break;
       default: continue;
       }
       if (vowels.test(bit))
           return false;
       vowels.set(bit);
   }
   return vowels.all();

}

int main(int argc, char** argv) { 

   const char* filename(argc < 2 ? "unixdict.txt" : argv[1]);
   std::ifstream in(filename);
   if (!in) {
       std::cerr << "Cannot open file '" << filename << "'.\n";
       return EXIT_FAILURE;
   }
   std::string word;
   int n = 0;
   while (getline(in, word)) {
       if (word.size() > 10 && contains_all_vowels_once(word))
           std::cout << std::setw(2) << ++n << ": " << word << '\n';
   }
   return EXIT_SUCCESS;

}</lang>

Output:
 1: ambidextrous
 2: bimolecular
 3: cauliflower
 4: communicable
 5: communicate
 6: consanguine
 7: consultative
 8: countervail
 9: exclusionary
10: grandiloquent
11: importunate
12: incommutable
13: incomputable
14: insupportable
15: loudspeaking
16: malnourished
17: mensuration
18: oneupmanship
19: pandemonium
20: permutation
21: perturbation
22: portraiture
23: praseodymium
24: stupefaction
25: sulfonamide

COBOL

<lang cobol> IDENTIFICATION DIVISION. 

      PROGRAM-ID. ALL-VOWELS.
      
      ENVIRONMENT DIVISION.
      INPUT-OUTPUT SECTION.
      FILE-CONTROL.
          SELECT DICT ASSIGN TO DISK
          ORGANIZATION LINE SEQUENTIAL.
          
      DATA DIVISION.
      FILE SECTION.
      FD DICT 
          LABEL RECORD STANDARD
          VALUE OF FILE-ID IS "unixdict.txt".
      01 WORD            PIC X(64).
      
      WORKING-STORAGE SECTION.
      01 A               PIC 99.
      01 E               PIC 99.
      01 I               PIC 99.
      01 O               PIC 99.
      01 U               PIC 99.
      01 LEN             PIC 99.
      
      PROCEDURE DIVISION.
      BEGIN.
          OPEN INPUT DICT.
          
      READ-WORD.
          READ DICT, AT END CLOSE DICT, STOP RUN.
          PERFORM CHECK-WORD.
          GO TO READ-WORD.
          
      CHECK-WORD.
          MOVE ZERO TO LEN, A, E, I, O, U.
          INSPECT WORD TALLYING LEN FOR CHARACTERS 
              BEFORE INITIAL SPACE.
          INSPECT WORD TALLYING A FOR ALL 'a'.
          INSPECT WORD TALLYING E FOR ALL 'e'.
          INSPECT WORD TALLYING I FOR ALL 'i'.
          INSPECT WORD TALLYING O FOR ALL 'o'.
          INSPECT WORD TALLYING U FOR ALL 'u'.
          IF LEN IS GREATER THAN 10
             AND 1 IS EQUAL TO A AND E AND I AND O AND U,
              DISPLAY WORD.</lang>
Output:
ambidextrous
bimolecular
cauliflower
communicable
communicate
consanguine
consultative
countervail
exclusionary
grandiloquent
importunate
incommutable
incomputable
insupportable
loudspeaking
malnourished
mensuration
oneupmanship
pandemonium
permutation
perturbation
portraiture
praseodymium
stupefaction
sulfonamide

Common Lisp

<lang lisp>(defun print-words (file-name word-length vowels vowels-number) 

  (with-open-file (dictionary file-name :if-does-not-exist nil)
     (loop for word = (read-line dictionary nil nil)
           while word
              when (and (> (length word) word-length)
                        (every #'(lambda (c)
                                    (= (count c word :test #'char-equal) vowels-number))
                                 vowels)) do
                 (write-line word))))

(print-words "unixdict.txt" 10 "aeiou" 1)</lang>

Delphi

Library: System.SysUtils
Library: System.IoUtils

<lang Delphi> program Find_words_which_contains_all_the_vowels;

{$APPTYPE CONSOLE}

uses 

 System.SysUtils,
 System.IoUtils;

function IsVowelsOnce(w: string): Boolean; const 

 chars: array[0..4] of char = ('a', 'e', 'i', 'o', 'u');

var 

 cs: array[0..4] of Boolean;
 i: Integer;
 c: char;

begin 

 if w.IsEmpty then
   exit(false);

 FillChar(cs, length(cs), 0);

 for c in w do
 begin
   for i := 0 to 4 do
   begin
     if c = chars[i] then
     begin
       if cs[i] then
         exit(false);
       cs[i] := True;
     end;
   end;
 end;

 for i := 0 to 4 do
   if not cs[i] then
     exit(False);
 Result := True;

end;

begin 

 var Lines := TFile.ReadAllLines('unixdict.txt');
 var count := 0;
 for var Line in Lines do
   if IsVowelsOnce(Line) and (Line.length > 10) then
   begin
     inc(count);
     Writeln(count: 2, ': ', Line);
   end;

 readln;

end.</lang>

Output:
 1: ambidextrous
 2: bimolecular
 3: cauliflower
 4: communicable
 5: communicate
 6: consanguine
 7: consultative
 8: countervail
 9: exclusionary
10: grandiloquent
11: importunate
12: incommutable
13: incomputable
14: insupportable
15: loudspeaking
16: malnourished
17: mensuration
18: oneupmanship
19: pandemonium
20: permutation
21: perturbation
22: portraiture
23: praseodymium
24: stupefaction
25: sulfonamide

F#

<lang fsharp> // Words which containing all the vowels once . Nigel Galloway: February 17th., 2021 let fN g=if String.length g < 11 then false else let n=Map.ofSeq (Seq.countBy id g) in let fN g=n.ContainsKey g && n.[g]=1 in fN 'a' && fN 'i' && fN 'o' && fN 'u' && fN 'e' seq{use n=System.IO.File.OpenText("unixdict.txt") in while not n.EndOfStream do yield n.ReadLine()}|>Seq.filter fN|>Seq.iter(printfn "%s") </lang>

Output:
ambidextrous
bimolecular
cauliflower
communicable
communicate
consanguine
consultative
countervail
exclusionary
grandiloquent
importunate
incommutable
incomputable
insupportable
loudspeaking
malnourished
mensuration
oneupmanship
pandemonium
permutation
perturbation
portraiture
praseodymium
stupefaction
sulfonamide


Factor

<lang factor>USING: grouping io.encodings.ascii io.files math prettyprint sequences sets.extras ;

"unixdict.txt" ascii file-lines [ length 10 > ] filter [ non-repeating "aeiou" superset? ] filter 5 group simple-table.</lang>

Output:
ambidextrous bimolecular  cauliflower  communicable  communicate
consanguine  consultative countervail  exclusionary  grandiloquent
importunate  incommutable incomputable insupportable loudspeaking
malnourished mensuration  oneupmanship pandemonium   permutation
perturbation portraiture  praseodymium stupefaction  sulfonamide

Forth

Works with: Gforth

<lang forth>: contains-all-vowels-once ( addr u -- ? ) 

 0 { vowels }
 0 do
   dup c@ case
     'a' of  1 endof
     'e' of  2 endof
     'i' of  4 endof
     'o' of  8 endof
     'u' of 16 endof
     0 swap
   endcase
   dup 0<> if
     vowels or
     dup vowels = if
       unloop 2drop false exit
     then
     to vowels
   else
     drop
   then
   1+
 loop
 drop
 vowels 31 = ;

256 constant max-line create line-buffer max-line 2 + allot

main
 0 0 { count fd-in }
 s" unixdict.txt" r/o open-file throw to fd-in
 begin
   line-buffer max-line fd-in read-line throw
 while
   dup 10 > if
     line-buffer swap 2dup contains-all-vowels-once if
       count 1+ to count
       count 2 .r ." . " type cr
     else
       2drop
     then
   else
     drop
   then
 repeat
 drop
 fd-in close-file throw ;

main bye</lang>

Output:
 1. ambidextrous
 2. bimolecular
 3. cauliflower
 4. communicable
 5. communicate
 6. consanguine
 7. consultative
 8. countervail
 9. exclusionary
10. grandiloquent
11. importunate
12. incommutable
13. incomputable
14. insupportable
15. loudspeaking
16. malnourished
17. mensuration
18. oneupmanship
19. pandemonium
20. permutation
21. perturbation
22. portraiture
23. praseodymium
24. stupefaction
25. sulfonamide

FreeBASIC

<lang freebasic>dim as boolean v(1 to 5) dim as string s, c, q(1 to 5) = {"a","e","i","o","u"} dim as integer i, j, n

open "unixdict.txt" for input as #1

while not eof(1) 

   line input #1, s
   n = len(s)
   if n<11 then continue while
   for i=1 to 5
       v(i) = false
   next i
   for i = 1 to n
       c = mid(s,i,1)
       for j = 1 to 5
           if c=q(j) then
               if v(j) = true then continue while
               v(j)=true
           end if
       next j
   next i
   for i=1 to 5
       if v(i)=false then continue while
   next i
   print s

wend

close #1 </lang>

Output:


ambidextrous
bimolecular
cauliflower
communicable
communicate
consanguine
consultative
countervail
exclusionary
grandiloquent
importunate
incommutable
incomputable
insupportable
loudspeaking
malnourished
mensuration
oneupmanship
pandemonium
permutation
perturbation
portraiture
praseodymium
stupefaction
sulfonamide

Go

<lang go>package main

import ( 

   "bytes"
   "fmt"
   "io/ioutil"
   "log"
   "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
   for _, bword := range bwords {
       s := string(bword)
       if utf8.RuneCountInString(s) > 10 {
           words = append(words, s)
       }
   }
   count := 0
   fmt.Println("Words which contain all 5 vowels once in", wordList, "\b:\n")
   for _, word := range words {
       ca, ce, ci, co, cu := 0, 0, 0, 0, 0
       for _, r := range word {
           switch r {
           case 'a':
               ca++
           case 'e':
               ce++
           case 'i':
               ci++
           case 'o':
               co++
           case 'u':
               cu++
           }
       }
       if ca == 1 && ce == 1 && ci == 1 && co == 1 && cu == 1 {
           count++
           fmt.Printf("%2d: %s\n", count, word)
       }
   }

}</lang>

Output:
Words which contain all 5 vowels once in unixdict.txt:

 1: ambidextrous
 2: bimolecular
 3: cauliflower
 4: communicable
 5: communicate
 6: consanguine
 7: consultative
 8: countervail
 9: exclusionary
10: grandiloquent
11: importunate
12: incommutable
13: incomputable
14: insupportable
15: loudspeaking
16: malnourished
17: mensuration
18: oneupmanship
19: pandemonium
20: permutation
21: perturbation
22: portraiture
23: praseodymium
24: stupefaction
25: sulfonamide


jq

Works with: jq

Works with gojq, the Go implementation of jq <lang jq> select(length > 10) | . as $w | select( all("a","e","i","o","u"; 

              . as $v | ($w | test($v) and (test( "\($v).*\($v)")|not))))

</lang>

Output:

Invocation example: jq -Rr -f program.jq unixdict.txt 

ambidextrous
bimolecular
cauliflower
...
praseodymium
stupefaction
sulfonamide

Julia

See Alternade_words for the foreachword function. <lang julia>hassallthevowels(w, d) = all(c -> count(x -> x == c, w) == 1, collect("aeiou")) ? w : "" foreachword("unixdict.txt", hassallthevowels, colwidth=18, minlen=11, numcols=5)

</lang>

Output:


Word source: unixdict.txt

ambidextrous      bimolecular       cauliflower       communicable      communicate
consanguine       consultative      countervail       exclusionary      grandiloquent
importunate       incommutable      incomputable      insupportable     loudspeaking
malnourished      mensuration       oneupmanship      pandemonium       permutation
perturbation      portraiture       praseodymium      stupefaction      sulfonamide

Ksh

<lang ksh>

  1. !/bin/ksh
  1. Find words which contains all the vowels
  1. # Variables:

dict='../unixdict.txt' integer MINLENGTH=10 typeset -a vowels=( a e i o u )

  1. # Functions:
  3. # Function _allvowels(str) - return 1 if str contains all 5 vowels

function _allvowels { typeset _str ; typeset -l _str="$1" typeset _i ; integer _i

for ((_i=0; _i<${#vowels[*]}; _i++)); do [[ ${_str} != *+(${vowels[_i]})* ]] && return 0 [[ ${_str/${vowels[_i]}/} == *+(${vowels[_i]})* ]] && return 0 done return 1 } 

######
  1. main #
######

integer i=0 while read; do 

       (( ${#REPLY} <= MINLENGTH )) && continue
       _allvowels "$REPLY"
       (( $? )) && print "$((++i)). $REPLY"

done < ${dict}</lang>

Output:
1. ambidextrous

2. bimolecular
3. cauliflower
4. communicable
5. communicate
6. consanguine
7. consultative
8. countervail
9. exclusionary
10. grandiloquent
11. importunate
12. incommutable
13. incomputable
14. insupportable
15. loudspeaking
16. malnourished
17. mensuration
18. oneupmanship
19. pandemonium
20. permutation
21. perturbation
22. portraiture
23. praseodymium
24. stupefaction


25. sulfonamide

Mathematica/Wolfram Language

<lang Mathematica>vowels=Characters["euioa"]; dict=Once[Import["https://web.archive.org/web/20180611003215/http://www.puzzlers.org/pub/wordlists/unixdict.txt"]]; dict//=StringSplit[#,"\n"]&; dict//=Select[StringLength/*GreaterThan[10]]; dict={#,Select[Characters[#],MemberQ[vowels,#]&]}&/@dict; dict//=Select[Last/*DuplicateFreeQ]; dict//=Select[Last/*Length/*EqualTo[Length[vowels]]]; dictAll,1</lang>

Output:
{ambidextrous, bimolecular, cauliflower, communicable, communicate, consanguine, consultative, countervail, exclusionary, grandiloquent, importunate, incommutable, incomputable, insupportable, loudspeaking, malnourished, mensuration, oneupmanship, pandemonium, permutation, perturbation, portraiture, praseodymium, stupefaction, sulfonamide}

Modula-2

<lang modula2>MODULE Vowels; IMPORT SeqIO; IMPORT Texts; FROM InOut IMPORT WriteString, WriteLn; FROM Strings IMPORT Length;

VAR file: SeqIO.FILE; 

   dict: Texts.TEXT;
   word: ARRAY [0..63] OF CHAR;
   fs: SeqIO.FileState;
   ts: Texts.TextState;

PROCEDURE HasAllVowels(word: ARRAY OF CHAR): BOOLEAN; 

   VAR a, e, i, o, u, pos: CARDINAL;
       ch: CHAR;

BEGIN 

   a := 0; e := 0; i := 0; o := 0; u := 0;
   FOR pos := 0 TO Length(word)-1 DO
       ch := word[pos];
       IF    ch = 'a' THEN INC(a);
       ELSIF ch = 'e' THEN INC(e);
       ELSIF ch = 'i' THEN INC(i);
       ELSIF ch = 'o' THEN INC(o);
       ELSIF ch = 'u' THEN INC(u);
       END;
       IF (a>1) OR (e>1) OR (i>1) OR (o>1) OR (u>1) THEN
           RETURN FALSE;
       END;
   END;
   RETURN (a=1) AND (e=1) AND (i=1) AND (o=1) AND (u=1);

END HasAllVowels;

BEGIN 

   fs := SeqIO.Open(file, "unixdict.txt");
   ts := Texts.Connect(dict, file);
   
   WHILE NOT Texts.EOT(dict) DO
       Texts.ReadLn(dict, word);
       IF (Length(word) > 10) AND HasAllVowels(word) THEN
            WriteString(word);
            WriteLn();
       END;
   END;
   
   ts := Texts.Disconnect(dict);
   fs := SeqIO.Close(file);

END Vowels.</lang>

Output:
ambidextrous
bimolecular
cauliflower
communicable
communicate
consanguine
consultative
countervail
exclusionary
grandiloquent
importunate
incommutable
incomputable
insupportable
loudspeaking
malnourished
mensuration
oneupmanship
pandemonium
permutation
perturbation
portraiture
praseodymium
stupefaction
sulfonamide

Nim

<lang Nim>import strutils

const Vowels = ['a', 'e', 'i', 'o', 'u']

var count = 0 for word in "unixdict.txt".lines: 

 if word.len > 10:
   block checkWord:
     for vowel in Vowels:
       if word.count(vowel) != 1:
         break checkWord
     inc count
     stdout.write word.align(15), if count mod 5 == 0: '\n' else: ' '</lang>
Output:
   ambidextrous     bimolecular     cauliflower    communicable     communicate
    consanguine    consultative     countervail    exclusionary   grandiloquent
    importunate    incommutable    incomputable   insupportable    loudspeaking
   malnourished     mensuration    oneupmanship     pandemonium     permutation
   perturbation     portraiture    praseodymium    stupefaction     sulfonamide

Perl

<lang perl>#!/usr/bin/perl

use strict; use warnings;

@ARGV = 'unixdict.txt'; length > 11 and !/([aeiou]).*\1/ and tr/aeiou// == 5 and print while <>;</lang>

Output:

ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide

Phix

with javascript_semantics
function onev(string word, integer vowel) return length(find_all(vowel,word))=1 end function
function allv(string word) return length(word)>10 and sum(apply(true,onev,{{word},"aeiou"}))=5 end function
sequence fivev = filter(unix_dict(),allv)
printf(1,"%d words: %s\n",{length(fivev),join(shorten(fivev,"",3))})
Output:
25 words: ambidextrous bimolecular cauliflower ... praseodymium stupefaction sulfonamide

PL/I

<lang pli>allTheVowels: procedure options(main); 

   countChar: procedure(str, ch) returns(fixed);
       declare str char(32) varying, ch char, (i, n) fixed;
       n = 0;
       do i = 1 to length(str);
           if substr(str, i, 1) = ch then n = n + 1;
       end;
       return(n);
   end countChar;

   declare dict file;
   open file(dict) title('unixdict.txt');
   on endfile(dict) stop;
   
   declare word char(32) varying, (a, e, i, o, u) fixed;
   do while('1'b);
       get file(dict) list(word);
       if length(word) > 10 then do;
           a = countChar(word, 'a');
           e = countChar(word, 'e');
           i = countChar(word, 'i');
           o = countChar(word, 'o');
           u = countChar(word, 'u');
           if a=1 & e=1 & i=1 & o=1 & u=1 then
               put skip list(word);
       end;
   end;

end allTheVowels;</lang>

Output:
ambidextrous
bimolecular
cauliflower
communicable
communicate
consanguine
consultative
countervail
exclusionary
grandiloquent
importunate
incommutable
incomputable
insupportable
loudspeaking
malnourished
mensuration
oneupmanship
pandemonium
permutation
perturbation
portraiture
praseodymium
stupefaction
sulfonamide

Python

Tested on Python 3+, the file download will work only if the link is still active. It is possible that you may be able to fetch the file in your browser but download via code may still fail. Check whether you are connected to a VPN, it works on open networks. <lang Python> import urllib.request from collections import Counter

urllib.request.urlretrieve("http://wiki.puzzlers.org/pub/wordlists/unixdict.txt", "unixdict.txt")

dictionary = open("unixdict.txt","r")

wordList = dictionary.read().split('\n')

dictionary.close()

for word in wordList: 

   if len(word)>10:
       frequency = Counter(word.lower())
       if frequency['a']==frequency['e']==frequency['i']==frequency['o']==frequency['u']==1:
           print(word)

</lang>

Output:
ambidextrous
bimolecular
cauliflower
communicable
communicate
consanguine
consultative
countervail
exclusionary
grandiloquent
importunate
incommutable
incomputable
insupportable
loudspeaking
malnourished
mensuration
oneupmanship
pandemonium
permutation
perturbation
portraiture
praseodymium
stupefaction
sulfonamide

R

Adapting this from https://rosettacode.org/wiki/Find_words_which_contain_the_most_consonants#R is trivial. <lang rsplus>dict <- scan("https://web.archive.org/web/20180611003215/http://www.puzzlers.org/pub/wordlists/unixdict.txt", what = character()) dictBig <- dict[nchar(dict) > 10]

  1. The following line is equivalent to sapply(c("a", "e", "i", "o", "u"), function(x) stringr::str_count(dictBig, x))
  2. As with all things with strings in R, life is easier with stringr or stringi.

vowelCount <- sapply(c("a", "e", "i", "o", "u"), function(x) lengths(regmatches(dictBig, gregexec(x, dictBig)))) dictBig[apply(vowelCount, MARGIN = 1, function(x) all(x == 1))]</lang>

Raku

Yet another "Filter a word list" task.

<lang perl6>put +.words, " words found:\n", $_ with 'unixdict.txt'.IO.words\ 

 .grep({ .chars > 10 and all(.comb.Bag<a e i o u>) == 1 })\
 .batch(5)».fmt('%-13s').join: "\n";</lang>
Output:
25 words found:
ambidextrous  bimolecular   cauliflower   communicable  communicate  
consanguine   consultative  countervail   exclusionary  grandiloquent
importunate   incommutable  incomputable  insupportable loudspeaking 
malnourished  mensuration   oneupmanship  pandemonium   permutation  
perturbation  portraiture   praseodymium  stupefaction  sulfonamide

REXX

These REXX versions don'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 is   caseless.

They also allows the minimum length to be specified on the command line (CL) as well as the dictionary file identifier.

version 1

<lang rexx>/*REXX pgm finds all words that contain only one vowel each (no duplication of vowels). */ parse arg minL iFID . /*obtain optional arguments from the CL*/ if minL== | minL=="," then minL= 11 /*Not specified? Then use the default.*/ if iFID== | iFID=="," then iFID='unixdict.txt' /* " " " " " " */ @.= /*default value of any dictionary word.*/ 

           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: original case and the semaphore*/
           end   /*#*/                          /* [↑]   semaphore name is uppercased. */
  1. = # - 1 /*adjust word count because of DO loop.*/

finds= 0 /*count of the alternade words found. */ say copies('─', 30) # "words in the dictionary file: " iFID vowels= 'aeiou'; upper vowels /*create a list of vowels; uppercase it*/ say; Lv= length(vowels) /*obtain the number of vowels (faster).*/ 

       do j=1  for #;          L= length($.j)   /*process all the words that were found*/
       if L<minL  then iterate                  /*Is word too short?   Then ignore it. */
       y= $.j;                 upper y          /*uppercase the dictionary word.       */
       if verify(vowels, y)>0  then iterate     /*The word have a least each vowel ?   */     /* ◄──── optional test (for speed).*/
          do k=1  for Lv                        /*process each of the vowels specified.*/
          v= substr(vowels, k, 1)               /*extract a vowel from the vowel list. */
          _= pos(v, y)                          /*find the position of the first vowel.*/
          if pos(v, y, _+1)\==0  then iterate j /*Is there another  (of the same)  ··· */
          end   /*k*/                           /*   ··· vowel?     Yes, then skip it. */
       finds= finds + 1                         /*bump the  count  of alternades found.*/
       say right( left($.j, 25),  40)           /*indent the word for a better display.*/
       end        /*j*/
                                                /*stick a fork in it,  we're all done. */

say copies('─',30) finds ' words found with only one each of every vowel,' , 

                             " and with a minimum length of "    minL</lang>
output   when using the internal default input:
────────────────────────────── 25104 words in the dictionary file:  unixdict.txt

               ambidextrous
               bimolecular
               cauliflower
               communicable
               communicate
               consanguine
               consultative
               countervail
               exclusionary
               grandiloquent
               importunate
               incommutable
               incomputable
               insupportable
               loudspeaking
               malnourished
               mensuration
               oneupmanship
               pandemonium
               permutation
               perturbation
               portraiture
               praseodymium
               stupefaction
               sulfonamide
────────────────────────────── 25  words found with only one each of every vowel,  and with a minimum length of  11

version 2

This REXX version uses the   countstr   BIF which returns the count of (a particular) character in a string. <lang rexx>/*REXX pgm finds all words that contain only one vowel each (no duplication of vowels). */ parse arg minL iFID . /*obtain optional arguments from the CL*/ if minL== | minL=="," then minL= 11 /*Not specified? Then use the default.*/ if iFID== | iFID=="," then iFID='unixdict.txt' /* " " " " " " */ @.= /*default value of any dictionary word.*/ 

           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: original case and the semaphore*/
           end   /*#*/                          /* [↑]   semaphore name is uppercased. */
  1. = # - 1 /*adjust word count because of DO loop.*/

finds= 0 /*count of the alternade words found. */ say copies('─', 30) # "words in the dictionary file: " iFID vowels= 'aeiou'; upper vowels /*create a list of vowels; uppercase it*/ say; Lv= length(vowels) 

       do j=1  for #;          L= length($.j)   /*process all the words that were found*/
       if L<minL  then iterate                  /*Is word too short?   Then ignore it. */
       y= $.j;                 upper y          /*uppercase the dictionary word.       */
       if verify(vowels, y)>0  then iterate     /*The word have a least each vowel ?   */     /* ◄──── optional test (for speed).*/
          do k=1  for Lv                        /*process each of the vowels specified.*/
          _= substr(vowels, k, 1)               /*obtain a particular vowel for search.*/
          if countstr(_, y)\==1  then iterate j /*Does this word have only one of  ··· */
          end   /*k*/                           /* ··· this vowel?   No, then skip it. */
       finds= finds + 1                         /*bump the  count  of alternades found.*/
       say right( left($.j, 25),  40)           /*indent the word for a better display.*/
       end        /*j*/
                                                /*stick a fork in it,  we're all done. */

say copies('─',30) finds ' words found with only one each of every vowel,' , 

                             " and with a minimum length of "    minL</lang>
output   is identical to the 1st REXX version.



Ring

<lang ring> load "stdlib.ring"

cStr = read("unixdict.txt") wordList = str2list(cStr) num = 0 same = [] vowels = "aeiou"

see "working..." + nl

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

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

next

for n = 1 to len(wordList) 

   flag = 1
   str = wordList[n]
   stra = count(str,"a")
   stre = count(str,"e")
   stri = count(str,"i")
   stro = count(str,"o")
   stru = count(str,"u")
   strtmp = [stra,stre,stri,stro,stru]
   ln = len(strtmp)
   for m = 1 to ln
       if strtmp[m] != 1
          flag = 0
          exit
       ok
   next
   if flag = 1
      num = num + 1
      see "" + num + ". " + wordList[n] + nl
   ok

next

see "done..." + nl

func count(cString,dString) 

    sum = 0
    while substr(cString,dString) > 0
          sum = sum + 1
          cString = substr(cString,substr(cString,dString)+len(string(sum)))
    end
    return sum

</lang>

Output:
working...
1. ambidextrous
2. bimolecular
3. cauliflower
4. communicable
5. communicate
6. consanguine
7. consultative
8. countervail
9. exclusionary
10. grandiloquent
11. importunate
12. incommutable
13. incomputable
14. insupportable
15. loudspeaking
16. malnourished
17. mensuration
18. oneupmanship
19. pandemonium
20. permutation
21. perturbation
22. portraiture
23. praseodymium
24. stupefaction
25. sulfonamide
done...

Swift

<lang swift>import Foundation

func containsAllVowelsOnce(_ word: String) -> Bool { 

   var vowels = 0
   for ch in word {
       var bit = 0
       switch (ch) {
       case "a", "A":
           bit = 1
       case "e", "E":
           bit = 2
       case "i", "I":
           bit = 4
       case "o", "O":
           bit = 8
       case "u", "U":
           bit = 16
       default:
           break
       }
       if bit == 0 {
           continue
       }
       if ((vowels & bit) != 0) {
           return false
       }
       vowels |= bit
   }
   return vowels == 31

}

do { 

   try String(contentsOfFile: "unixdict.txt", encoding: String.Encoding.ascii)
       .components(separatedBy: "\n")
       .filter{$0.count > 10 && containsAllVowelsOnce($0)}
       .enumerated()
       .forEach{print(String(format: "%2d. %@", $0.0 + 1, $0.1))}

} catch { 

   print(error.localizedDescription)

}</lang>

Output:
 1. ambidextrous
 2. bimolecular
 3. cauliflower
 4. communicable
 5. communicate
 6. consanguine
 7. consultative
 8. countervail
 9. exclusionary
10. grandiloquent
11. importunate
12. incommutable
13. incomputable
14. insupportable
15. loudspeaking
16. malnourished
17. mensuration
18. oneupmanship
19. pandemonium
20. permutation
21. perturbation
22. portraiture
23. praseodymium
24. stupefaction
25. sulfonamide

Wren

Library: Wren-fmt

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

var wordList = "unixdict.txt" // local copy var count = 0 File.read(wordList).trimEnd().split("\n"). 

   where { |w|
       return w.count > 10 && "aeiou".all { |v| 
           return w.count { |c| c == v } == 1
       }
   }.
   each { |w|
       count = count + 1
       Fmt.print("$2d: $s", count, w)
   }</lang>
Output:
 1: ambidextrous
 2: bimolecular
 3: cauliflower
 4: communicable
 5: communicate
 6: consanguine
 7: consultative
 8: countervail
 9: exclusionary
10: grandiloquent
11: importunate
12: incommutable
13: incomputable
14: insupportable
15: loudspeaking
16: malnourished
17: mensuration
18: oneupmanship
19: pandemonium
20: permutation
21: perturbation
22: portraiture
23: praseodymium
24: stupefaction
25: sulfonamide
Retrieved from "https://rosettacode.org/wiki/Find_words_which_contains_all_the_vowels?oldid=308243"