Which word uses all the vowels

Study guides

Still have questions?

People also asked

Other tasks related to string operations:

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)

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

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;

# 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

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

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

# 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("%sn",$0)
    }
}
END {
    exit(0)
}

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

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()
$)

#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;
}

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

       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.

(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)

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.

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

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

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.

: 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

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

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]
}

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

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: %sn", count, word)
        }
    }
}

   >(#~ ((]-:&(/:~)([-.-.))&'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

select(length > 10)
| . as $w
| select( all("a","e","i","o","u";
               . as $v | ($w | test($v) and (test( "($v).*($v)")|not))))

hassallthevowels(w, d) = all(c -> count(x -> x == c, w) == 1, collect("aeiou")) ? w : ""
foreachword("unixdict.txt", hassallthevowels, colwidth=18, minlen=11, numcols=5)

#!/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}

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

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.

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: ' '

#!/usr/bin/perl

use strict;
use warnings;

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

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;

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)

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))]

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";

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

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

output   when using the internal default input:

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

output   is identical to the 1^st REXX version.

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

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

#!/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

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)
}

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)
    }

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;
]