View source for Find words which contains all the vowels

{{Draft task}}

;Task:
Use the dictionary &nbsp;[https://web.archive.org/web/20180611003215/http://www.puzzlers.org/pub/wordlists/unixdict.txt unixdict.txt]

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

The length of any word shown should have a length &nbsp; <big>'''>&nbsp; 10</big>.


{{Template:Strings}}
<br><br>

=={{header|11l}}==
<syntaxhighlight 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)</syntaxhighlight>

{{out}}
<pre>
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
</pre>

=={{header|Action!}}==
In the following solution the input file [https://gitlab.com/amarok8bit/action-rosetta-code/-/blob/master/source/unixdict.txt 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.
<syntaxhighlight 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</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Find_words_which_contains_all_the_vowels.png Screenshot from Atari 8-bit computer]
<pre>
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
</pre>

=={{header|Ada}}==
<syntaxhighlight 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;</syntaxhighlight>

=={{header|ALGOL 68}}==
<syntaxhighlight lang="algol68"># find 11 or more character words that contain all the vowels once   #

# 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</syntaxhighlight>
{{out}}
<pre>
    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
</pre>
=={{header|Arturo}}==

<syntaxhighlight 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
    ]
]</syntaxhighlight>

{{out}}

<pre>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</pre>

=={{header|AutoHotkey}}==
<syntaxhighlight 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</syntaxhighlight>
{{out}}
<pre>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</pre>

=={{header|AWK}}==
<syntaxhighlight lang="awk">
# 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)
}
</syntaxhighlight>
{{out}}
<pre>
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
</pre>

=={{header|BASIC}}==
<syntaxhighlight 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</syntaxhighlight>
{{out}}
<pre>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</pre>

=={{header|BCPL}}==
<syntaxhighlight 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()
$)</syntaxhighlight>
{{out}}
<pre>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</pre>

=={{header|C}}==
<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <string.h>


/* "Use the dictionary unixdict.txt" */
#define DICTIONARY_FILE_NAME "unixdict.txt"

/* "The length of any word shown should be >10" */
#define MIN_WORD_LENGTH 11


char *create_word_buffer( const char *file_name, size_t *buffer_size );
int verify_vowels( const char *word, size_t word_length );
int wait_for_return( void );


int main() {
    size_t buffer_size = 0;
    char *buffer = create_word_buffer( DICTIONARY_FILE_NAME, &buffer_size );

    if( buffer ) {
        FILE *f = fopen( DICTIONARY_FILE_NAME, "r" );

        if( f ) {
            while( fgets(buffer,buffer_size,f) ) {
                size_t l = strlen( buffer );
                if( '\n'==buffer[l-1] ) buffer[--l] = '\0';

                if( l>=MIN_WORD_LENGTH && verify_vowels(buffer,l) ) {
                    printf( "%s\n", buffer );
                }
            }

            fclose( f ); f = NULL; /* cleanup */
        } else puts( "Couldn't open dictionary file." );

        free( buffer ); buffer = NULL; /* cleanup */
    } else puts( "Couldn't create word buffer." );

    return wait_for_return();
}


/*==============================================================================
No need to verify any parameters in any of the following function - the caller
did his homeworks.
==============================================================================*/


size_t get_line_length( FILE *f ) {
    size_t line_length = 0;
    int c, ok;

    do {
        c = fgetc(f);
        ok = '\n'!=c&&EOF!=c;
        line_length += ok;
    } while( ok );

    return line_length;
}


size_t find_longest_line_in_file( const char *file_name ) {
    size_t max_line_length = ((size_t)-1);

    FILE *f = fopen( file_name, "r" );

    if( f ) {
        max_line_length = 0;

        while( !feof(f) ) {
            size_t line_length = get_line_length( f );

            if( line_length>max_line_length )
                max_line_length = line_length;
        }

        fclose( f ); f = NULL;
    }

    return max_line_length;
}


char *create_word_buffer( const char *file_name, size_t *buffer_size ) {
    char *buffer = NULL;

    size_t max_line_length = find_longest_line_in_file( file_name );

    if( ((size_t)-1)!=max_line_length ) {
        buffer = calloc( max_line_length+2, sizeof(*buffer) );
        if( buffer ) *buffer_size = max_line_length+2;
    }

    return buffer;
}


int verify_vowels( const char *word, size_t word_length ) {
    int vowel_instances[5] = {0};
    size_t i;

    for( i=0; i<word_length; ++i ) {
        switch( word[i] ) {
            case 'A': case 'a': vowel_instances[0]++; break;
            case 'E': case 'e': vowel_instances[1]++; break;
            case 'I': case 'i': vowel_instances[2]++; break;
            case 'O': case 'o': vowel_instances[3]++; break;
            case 'U': case 'u': vowel_instances[4]++; break;
            default: ;
        }
    }

    return 1==vowel_instances[0] &&
           1==vowel_instances[1] &&
           1==vowel_instances[2] &&
           1==vowel_instances[3] &&
           1==vowel_instances[4];
}


int wait_for_return( void ) {
    puts( "\nPress Return to exit...    " );
    while( '\n'!=getchar() );
    return 0;
}
</syntaxhighlight>

{{out}}
<pre>
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

Press Return to exit...
</pre>

=={{header|C++}}==
<syntaxhighlight lang="cpp">#include <bitset>
#include <cctype>
#include <cstdlib>
#include <fstream>
#include <iomanip>
#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;
}</syntaxhighlight>

{{out}}
<pre>
 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
</pre>

=={{header|CLU}}==
<syntaxhighlight lang="clu">has_all_vowels_once = proc (s: string) returns (bool)
    vowels: string := "aeiou"
    vowel_counts: array[int] := array[int]$fill(1,string$size(vowels),0)
    for c: char in string$chars(s) do
        v: int := string$indexc(c, vowels)
        if v>0 then
            vowel_counts[v] := vowel_counts[v] + 1
            if vowel_counts[v] > 1 then return(false) end
        end
    end
    for i: int in array[int]$elements(vowel_counts) do
        if i ~= 1 then return(false) end
    end
    return(true)
end has_all_vowels_once

start_up = proc ()
    po: stream := stream$primary_output()
    fname: file_name := file_name$parse("unixdict.txt")
    fstream: stream := stream$open(fname, "read")
    
    while true do
        word: string := stream$getl(fstream)
        if string$size(word) > 10 cand has_all_vowels_once(word) then
            stream$putl(po, word)
        end
    end except when end_of_file:
        stream$close(fstream)
    end
end start_up</syntaxhighlight>
{{out}}
<pre>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</pre>

=={{header|COBOL}}==
<syntaxhighlight 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.</syntaxhighlight>
{{out}}
<pre>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</pre>

=={{header|Common Lisp}}==

<syntaxhighlight 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)</syntaxhighlight>

=={{header|Delphi}}==
{{libheader| System.SysUtils}}
{{libheader| System.IoUtils}}
<syntaxhighlight 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.</syntaxhighlight>
{{out}}
<pre> 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</pre>

=={{header|Draco}}==
<syntaxhighlight lang="draco">\util.g

proc all_vowels(*char line) bool:
    word a, e, i, o, u;
    char ch;
    a := 0;
    e := 0;
    i := 0;
    o := 0;
    u := 0;
    
    while 
        ch := line*; 
        line := line + 1; 
        ch ~= '\e' and a<=1 and e<=1 and i<=1 and o<=1 and u<=1
    do
        if   ch='a' then a := a + 1
        elif ch='e' then e := e + 1
        elif ch='i' then i := i + 1
        elif ch='o' then o := o + 1
        elif ch='u' then u := u + 1
        fi
    od;
    
    a=1 and e=1 and i=1 and o=1 and u=1
corp

proc nonrec main() void:
    file(1024) dictfile;
    [32] char buf;
    *char line;
    channel input text dict;
    
    open(dict, dictfile, "unixdict.txt");
    line := &buf[0];
    
    while readln(dict; line) do
        if CharsLen(line) > 10 and all_vowels(line) then 
            writeln(line) 
        fi
    od;
    
    close(dict)
corp</syntaxhighlight>
{{out}}
<pre>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</pre>

=={{header|F_Sharp|F#}}==
<syntaxhighlight 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")
</syntaxhighlight>
{{out}}
<pre>
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
</pre>

=={{header|Factor}}==
<syntaxhighlight 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.</syntaxhighlight>
{{out}}
<pre>
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
</pre>

=={{header|Forth}}==
{{works with|Gforth}}
<syntaxhighlight 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</syntaxhighlight>

{{out}}
<pre>
 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
</pre>

=={{header|FreeBASIC}}==
<syntaxhighlight 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
</syntaxhighlight>
{{out}}<pre>
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
</pre>

=={{header|Frink}}==
<syntaxhighlight lang="frink">for word = select[lines["https://web.archive.org/web/20180611003215if_/http://www.puzzlers.org:80/pub/wordlists/unixdict.txt"], {|x| length[x] > 10}]
{
   d = countToDict[charList[word]]
   if d@"a" == 1 and d@"e" == 1 and d@"i" == 1 and d@"o" == 1 and d@"u" == 1
      println[word]
}</syntaxhighlight>
{{out}}
<pre>
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
</pre>

=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">

#plist NSAppTransportSecurity @{NSAllowsArbitraryLoads:YES}

local fn Words as CFArrayRef
  CFURLRef     url       = fn URLWithString( @"http://wiki.puzzlers.org/pub/wordlists/unixdict.txt" )
  CFStringRef  string    = fn StringWithContentsOfURL( url, NSUTF8StringEncoding, NULL )
  CFArrayRef   array     = fn StringComponentsSeparatedByCharactersInSet( string, fn CharacterSetNewlineSet )
  PredicateRef predicate = fn PredicateWithFormat( @"self.length > %d", 10 )
end fn = fn ArrayFilteredArrayUsingPredicate( array, predicate )

void local fn DoIt
  CFArrayRef  words = fn Words
  CFStringRef wd
  
  for wd in words
    long index, a = 0, e = 0, i = 0, o = 0, u = 0
    for index = 0 to len(wd) - 1
      select ( fn StringCharacterAtIndex( wd, index ) )
        case _"a" : a++
        case _"e" : e++
        case _"i" : i++
        case _"o" : o++
        case _"u" : u++
      end select
    next
    if ( a == 1 and e == 1 and i == 1 and o == 1 and u == 1 )
      print wd
    end if
  next  
end fn

fn DoIt

HandleEvents
</syntaxhighlight>

{{out}}
<pre>
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
</pre>

=={{header|Go}}==
<syntaxhighlight 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)
        }
    }
}</syntaxhighlight>

{{out}}
<pre>
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
</pre>

=={{header|Haskell}}==
<syntaxhighlight lang="haskell">
condition :: String -> Bool
condition s = all (\vow -> count vow s == 1 ) "aeiou" 
 where
  count :: Char -> String -> Int
  count letter word = length $ filter ( == letter ) word

main :: IO ( )
main = do
   theLines <- readFile "unixdict.txt"
   let selected = filter condition $ words theLines
   mapM_ putStrLn selected</syntaxhighlight>

{{out}}
(with my version of unixdict.txt)
<pre>
ambidextrous
aureomycin
bimolecular
cauliflower
colatitude
communicable
communicate
consanguine
consultative
countervail
dalhousie
denudation
deputation
dialogue
equivocal
euphorbia
euphoria
exclusionary
exhaustion
exhumation
exudation
exultation
facetious
fluoridate
gelatinous
grandiloquent
gregarious
houdaille
importunate
incommutable
incomputable
inoculate
insupportable
loudspeaking
malnourished
mendacious
mensuration
oneupmanship
pandemonium
permutation
persuasion
perturbation
pneumonia
portraiture
praseodymium
precarious
precaution
quasiorder
refutation
reputation
sequoia
stupefaction
sulfonamide
tambourine
tenacious
veracious
vexatious
</pre>

or, adding the restriction to words of more than 10 characters, and using Data.Set to identify words with a set of 5 unique vowel characters, which have no more than 5 vowel characters in total:

<syntaxhighlight lang="haskell">import Data.Set (Set, fromList, member, size)

---- WORDS OVER 10 CHARS WHICH CONTAIN EACH VOWEL ONCE ---

p :: String -> Bool
p = ((&&) . (10 <) . length) <*> eachVowelOnce

eachVowelOnce :: String -> Bool
eachVowelOnce w =
  all (5 ==) $
    [length, size . fromList] <*> [filter (`member` vowels) w]

vowels :: Set Char
vowels = fromList "aeiou"

--------------------------- TEST -------------------------
main :: IO ()
main =
  readFile "unixdict.txt"
    >>= (mapM_ putStrLn . filter p . lines)</syntaxhighlight>
{{Out}}
<pre>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</pre>

=={{header|J}}==
<syntaxhighlight lang="j">   >(#~ ((]-:&(/:~)([-.-.))&'aeiou' * 10 <#)@>) cutLF fread '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</syntaxhighlight>

=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
<syntaxhighlight lang="jq">
select(length > 10)
| . as $w
| select( all("a","e","i","o","u";
               . as $v | ($w | test($v) and (test( "\($v).*\($v)")|not))))
</syntaxhighlight>
{{out}}
Invocation example: jq -Rr -f program.jq unixdict.txt
<pre>
ambidextrous
bimolecular
cauliflower
...
praseodymium
stupefaction
sulfonamide
</pre>

=={{header|Julia}}==
See [[Alternade_words]] for the foreachword function.
<syntaxhighlight 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)
</syntaxhighlight>{{out}}<pre>
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
</pre>

=={{header|Ksh}}==
<syntaxhighlight lang="ksh">
#!/bin/ksh

# Find words which contains all the vowels

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

#	# Functions:
#
#	# 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
}
 ######
# main #
 ######
integer i=0
while read; do
        (( ${#REPLY} <= MINLENGTH )) && continue
        _allvowels "$REPLY"
        (( $? )) && print "$((++i)). $REPLY"
done < ${dict}</syntaxhighlight>
{{out}}<pre>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</pre>

=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight 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]]];
dict[[All,1]]</syntaxhighlight>
{{out}}
<pre>{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}</pre>

=={{header|Modula-2}}==
<syntaxhighlight 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.</syntaxhighlight>
{{out}}
<pre>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</pre>

=={{header|Nim}}==
<syntaxhighlight 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: ' '</syntaxhighlight>

{{out}}
<pre>   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</pre>

=={{header|Perl}}==
<syntaxhighlight lang="perl">#!/usr/bin/perl

use strict;
use warnings;

@ARGV = 'unixdict.txt';
length > 11 and !/([aeiou]).*\1/ and tr/aeiou// == 5 and print while <>;</syntaxhighlight>
{{out}}
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

=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
 <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
 <span style="color: #008080;">function</span> <span style="color: #000000;">onev</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">word</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">vowel</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">return</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">find_all</span><span style="color: #0000FF;">(</span><span style="color: #000000;">vowel</span><span style="color: #0000FF;">,</span><span style="color: #000000;">word</span><span style="color: #0000FF;">))=</span><span style="color: #000000;">1</span> <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
 <span style="color: #008080;">function</span> <span style="color: #000000;">allv</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">word</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">return</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">word</span><span style="color: #0000FF;">)></span><span style="color: #000000;">10</span> <span style="color: #008080;">and</span> <span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #000000;">onev</span><span style="color: #0000FF;">,{{</span><span style="color: #000000;">word</span><span style="color: #0000FF;">},</span><span style="color: #008000;">"aeiou"</span><span style="color: #0000FF;">}))=</span><span style="color: #000000;">5</span> <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
 <span style="color: #004080;">sequence</span> <span style="color: #000000;">fivev</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">filter</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">unix_dict</span><span style="color: #0000FF;">(),</span><span style="color: #000000;">allv</span><span style="color: #0000FF;">)</span>
 <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d words: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fivev</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fivev</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">))})</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
25 words: ambidextrous bimolecular cauliflower ... praseodymium stupefaction sulfonamide
</pre>

=={{header|PL/I}}==
<syntaxhighlight 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;</syntaxhighlight>
{{out}}
<pre>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</pre>

=={{header|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.
<syntaxhighlight 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)
</syntaxhighlight>
{{out}}
<pre>
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
</pre>

=={{header|Quackery}}==

<syntaxhighlight lang="Quackery">  [ [] swap ]'[ swap
    witheach
      [ dup nested
        unrot over do
        iff [ dip join ]
        else nip ]
    drop ]               is filter (   [ --> [ )

  [ 2dup peek
    1+ unrot poke ]      is pink   ( [ n --> [ )

  [ ' [ 0 0 0 0 0 0 ]
    swap witheach
      [ lower
        $ "aeiou" find
        pink ]
    -1 split drop
    ' [ 1 1 1 1 1 ] = ]  is valid  (   [ --> b )

  $ "rosetta/unixdict.txt" sharefile drop nest$
  filter [ size 10 > ]
  filter valid
  70 wrap$</syntaxhighlight>

{{out}}

<pre>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</pre>

=={{header|R}}==
Adapting this from https://rosettacode.org/wiki/Find_words_which_contain_the_most_consonants#R is trivial.
<syntaxhighlight 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]
#The following line is equivalent to sapply(c("a", "e", "i", "o", "u"), function(x) stringr::str_count(dictBig, x))
#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))]</syntaxhighlight>

=={{header|Raku}}==
Yet another "Filter a word list" task. 

<syntaxhighlight lang="raku" line>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";</syntaxhighlight>

{{out}}
<pre>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 </pre>

=={{header|Red}}==
<syntaxhighlight lang="rebol">Red[]

vowels: charset "aeiou"

count-vowels: function [
    "Returns the number of vowels in a string"
    word [string!]
][
    result: 0
    foreach letter word [
        if find vowels letter [result: result + 1]
    ]
    result
]

foreach word read/lines %unixdict.txt [
    if all [
        10 < length? word
        5 = length? intersect word "aeiou"
        5 = count-vowels word
    ][
        print word
    ]
]</syntaxhighlight>
{{out}}
<pre>
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
</pre>

=={{header|REXX}}==
These REXX versions don't care what order the words in the dictionary are in, &nbsp; nor does it care what
<br>case &nbsp;(lower/upper/mixed)&nbsp; the words are in, &nbsp; the search for the words is &nbsp; ''caseless''.

They also allows the minimum length to be specified on the command line (CL) as well as the dictionary file identifier.
=== version 1 ===
<syntaxhighlight 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                                         /*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</syntaxhighlight>
{{out|output|text=&nbsp; when using the internal default input:}}
<pre>
────────────────────────────── 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
</pre>

=== version 2 ===
This REXX version uses the &nbsp; '''countstr''' &nbsp; BIF which returns the count of (a particular) character in a string. 
<syntaxhighlight 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                                         /*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</syntaxhighlight>
{{out|output|text=&nbsp; is identical to the 1<sup>st</sup> REXX version.}} <br><br>

=={{header|Ring}}==
<syntaxhighlight 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
</syntaxhighlight>
{{out}}
<pre>
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...

</pre>

=={{header|RPL}}==
The only way to use <code>unixdict.txt</code> as input is to convert it into a list of 25104 strings. Fortunately, emulators can handle such a big data structure in RAM.
{{works with|Halcyon Calc|4.2.7}}
 ≪ { } 
    1 UnixDict SIZE '''FOR''' j 
      'UnixDict' j GET 
      '''IF''' DUP SIZE 10 < '''THEN''' DROP '''ELSE'''
        { 5 } 0 CON 
        1 3 PICK SIZE '''FOR''' j 
           OVER j DUP SUB 
           '''IF''' "AEIOUaeiou" SWAP POS '''THEN''' 
              LAST 1 - 5 MOD 1 + 
              DUP2 GET 1 + PUT   
           '''END''' 
        '''NEXT''' 
        '''IF''' [ 1 1 1 1 1 ] == '''THEN''' + '''ELSE''' DROP '''END'''
      '''END NEXT'''
 » '<span style="color:blue">AEIOU</span>' STO

{{out}}
<pre>
1: { "ambidextrous" "aureomycin" "bimolecular" "cauliflower" "colatitude" "communicable" "communicate" "consanguine" "consultative" "countervail" "denudation" "deputation" "exclusionary" "exhaustion" "exhumation" "exultation" "fluoridate" "gelatinous" "grandiloquent" "gregarious" "importunate" "incommutable" "incomputable" "insupportable" "loudspeaking" "malnourished" "mendacious" "mensuration" "oneupmanship" "pandemonium" "permutation" "persuasion" "perturbation" "portraiture" "praseodymium" "precarious" "precaution" "quasiorder" "refutation" "reputation" "stupefaction" "sulfonamide" "tambourine" }
</pre>

=={{header|Ruby}}==
<syntaxhighlight lang="ruby">File.open("unixdict.txt").each(chomp: true) do |word|
  puts word if word.size > 10 && word.chars.tally.values_at('a','e','i','o','u').all?(1)
end
</syntaxhighlight>
{{out}}
<pre>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
</pre>

=={{header|sed}}==
<syntaxhighlight lang="sed">#!/bin/sed -f

/^.\{11\}/!d
/^[^a]*a[^a]*$/!d
/^[^e]*e[^e]*$/!d
/^[^i]*i[^i]*$/!d
/^[^o]*o[^o]*$/!d
/^[^u]*u[^u]*$/!d</syntaxhighlight>

=={{header|Swift}}==
<syntaxhighlight 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)
}</syntaxhighlight>

{{out}}
<pre>
 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
</pre>

=={{header|Wren}}==
{{libheader|Wren-fmt}}
<syntaxhighlight lang="wren">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)
    }</syntaxhighlight>

{{out}}
<pre>
 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
</pre>

=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">string 0;               \Use zero-terminated strings
int  I, Ch, Len;
char Word(100); \(longest word in unixdict.txt is 22 chars)
def  LF=$0A, CR=$0D, EOF=$1A;

        func AllVowels; \Return 'true' if Word contains all vowels once
        int  Cnt, I;
        [Cnt:= 0;
        for I:= 0 to Len-1 do
            case Word(I) of
              ^a: Cnt:= Cnt + $00001;
              ^e: Cnt:= Cnt + $00010;
              ^i: Cnt:= Cnt + $00100;
              ^o: Cnt:= Cnt + $01000;
              ^u: Cnt:= Cnt + $10000
            other [];
        return Cnt = $11111;
        ];

[FSet(FOpen("unixdict.txt", 0), ^I);    \open dictionary and set it to device 3
OpenI(3);
repeat  I:= 0;
        loop    [repeat Ch:= ChIn(3) until Ch # CR;     \remove possible CR
                if Ch=LF or Ch=EOF then quit;
                Word(I):= Ch;
                I:= I+1;
                ];
        Word(I):= 0;                    \terminate string
        Len:= I;
        if Len > 10 then
            if AllVowels then [Text(0, Word);  CrLf(0)];
until   Ch = EOF;
]</syntaxhighlight>

{{out}}
<pre>
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
</pre>