Find words which contain all the vowels
(Redirected from Find words which contains all the vowels)
Find words which contain all the vowels is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.
- Task
Use the dictionary unixdict.txt
Find the words which contains all the vowels, but each vowel should appear only once in a word.
The length of any word shown should have a length > 10.
Other tasks related to string operations:
- Metrics
- Counting
- Word frequency
- Letter frequency
- Jewels and stones
- I before E except after C
- Bioinformatics/base count
- Count occurrences of a substring
- Count how many vowels and consonants occur in a string
- Remove/replace
- XXXX redacted
- Conjugate a Latin verb
- Remove vowels from a string
- String interpolation (included)
- Strip block comments
- Strip comments from a string
- Strip a set of characters from a string
- Strip whitespace from a string -- top and tail
- Strip control codes and extended characters from a string
- Anagrams/Derangements/shuffling
- Word wheel
- ABC problem
- Sattolo cycle
- Knuth shuffle
- Ordered words
- Superpermutation minimisation
- Textonyms (using a phone text pad)
- Anagrams
- Anagrams/Deranged anagrams
- Permutations/Derangements
- Find/Search/Determine
- ABC words
- Odd words
- Word ladder
- Semordnilap
- Word search
- Wordiff (game)
- String matching
- Tea cup rim text
- Alternade words
- Changeable words
- State name puzzle
- String comparison
- Unique characters
- Unique characters in each string
- Extract file extension
- Levenshtein distance
- Palindrome detection
- Common list elements
- Longest common suffix
- Longest common prefix
- Compare a list of strings
- Longest common substring
- Find common directory path
- Words from neighbour ones
- Change e letters to i in words
- Non-continuous subsequences
- Longest common subsequence
- Longest palindromic substrings
- Longest increasing subsequence
- Words containing "the" substring
- Sum of the digits of n is substring of n
- Determine if a string is numeric
- Determine if a string is collapsible
- Determine if a string is squeezable
- Determine if a string has all unique characters
- Determine if a string has all the same characters
- Longest substrings without repeating characters
- Find words which contains all the vowels
- Find words which contain the most consonants
- Find words which contains more than 3 vowels
- Find words whose first and last three letters are equal
- Find words with alternating vowels and consonants
- Formatting
- Substring
- Rep-string
- Word wrap
- String case
- Align columns
- Literals/String
- Repeat a string
- Brace expansion
- Brace expansion using ranges
- Reverse a string
- Phrase reversals
- Comma quibbling
- Special characters
- String concatenation
- Substring/Top and tail
- Commatizing numbers
- Reverse words in a string
- Suffixation of decimal numbers
- Long literals, with continuations
- Numerical and alphabetical suffixes
- Abbreviations, easy
- Abbreviations, simple
- Abbreviations, automatic
- Song lyrics/poems/Mad Libs/phrases
- Mad Libs
- Magic 8-ball
- 99 bottles of beer
- The Name Game (a song)
- The Old lady swallowed a fly
- The Twelve Days of Christmas
- Tokenize
- Text between
- Tokenize a string
- Word break problem
- Tokenize a string with escaping
- Split a character string based on change of character
- Sequences
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)- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
Action!
In the following solution the input file unixdict.txt is loaded from H6 drive. Altirra emulator automatically converts CR/LF character from ASCII into 155 character in ATASCII charset used by Atari 8-bit computer when one from H6-H10 hard drive under DOS 2.5 is used.
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- Output:
Screenshot from Atari 8-bit computer
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
Ada
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;
ALGOL 68
The source of files.incl.a68 is on a separate page on Rosetta Code - see the above link.
BEGIN # find 11 or more character words that contain all the vowels once #
PR read "files.incl.a68" PR # include file utilities #
# prints word if it contains all the vowels once; #
# returns TRUE if it does, FALSE otherwise #
# count so far will contain the number of such words preceding this one #
PROC show vowel word = ( STRING word, INT count so far )BOOL:
IF ( UPB word - LWB word ) + 1 <= 10
THEN FALSE
ELSE # 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 OR e count /= 1 OR i count /= 1 OR o count /= 1 OR u count /= 1
THEN FALSE
ELSE INT vowel words = count so far + 1;
print( ( whole( vowel words, -5 ), ": ", word, newline ) );
TRUE
FI
FI # show vowel words # ;
IF "unixdict.txt" EACHLINE show vowel word < 0 THEN
print( ( "Unable to open unixdict.txt", newline ) )
FI
END- Output:
1: ambidextrous
2: bimolecular
3: cauliflower
4: communicable
5: communicate
6: consanguine
7: consultative
8: countervail
9: exclusionary
10: grandiloquent
11: importunate
12: incommutable
13: incomputable
14: insupportable
15: loudspeaking
16: malnourished
17: mensuration
18: oneupmanship
19: pandemonium
20: permutation
21: perturbation
22: portraiture
23: praseodymium
24: stupefaction
25: sulfonamide
Arturo
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
]
]
- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
AutoHotkey
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
- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
AWK
# 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)
}
- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
BASIC
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
- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
BCPL
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()
$)- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
BQN
Match ← ∧´1=·+˝=⌜˜
•Show "aeiou"⊸Match¨⊸/ (10<≠¨)⊸/ •Flines "unixdict.txt"
- Output:
⟨ "ambidextrous" "bimolecular" "cauliflower" "communicable" "communicate" "consanguine" "consultative" "countervail" "exclusionary" "grandiloquent" "importunate" "incommutable" "incomputable" "insupportable" "loudspeaking" "malnourished" "mensuration" "oneupmanship" "pandemonium" "permutation" "perturbation" "portraiture" "praseodymium" "stupefaction" "sulfonamide" ⟩
C
#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;
}
- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide Press Return to exit...
C++
#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;
}
- Output:
1: ambidextrous 2: bimolecular 3: cauliflower 4: communicable 5: communicate 6: consanguine 7: consultative 8: countervail 9: exclusionary 10: grandiloquent 11: importunate 12: incommutable 13: incomputable 14: insupportable 15: loudspeaking 16: malnourished 17: mensuration 18: oneupmanship 19: pandemonium 20: permutation 21: perturbation 22: portraiture 23: praseodymium 24: stupefaction 25: sulfonamide
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- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
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.
- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
Common Lisp
(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)
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.
- Output:
1: ambidextrous 2: bimolecular 3: cauliflower 4: communicable 5: communicate 6: consanguine 7: consultative 8: countervail 9: exclusionary 10: grandiloquent 11: importunate 12: incommutable 13: incomputable 14: insupportable 15: loudspeaking 16: malnourished 17: mensuration 18: oneupmanship 19: pandemonium 20: permutation 21: perturbation 22: portraiture 23: praseodymium 24: stupefaction 25: sulfonamide
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- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
DuckDB
In this entry, the fact that an on-the-fly table can be referenced within a function is used to avoid having to create a named table while still allowing a certain measure of functional abstraction. The alternative would involve using query_table(), which was only introduced in DuckDB 1.1.
# Use an in-scope dictionary, dictionary(word), as the dictionary
create or replace function all_vowel_words() as table (
FROM dictionary
WHERE contains(word, 'a') and contains(word, 'e') and contains(word, 'i')
and contains(word, 'o') and contains(word, 'u')
and length(word) = length(regexp_replace(word, '[aeiou]', '', 'g')) + 5
ORDER BY word
);
with dictionary as (
SELECT lower(word) as word
FROM read_csv('unixdict.txt', header=false, sep='',
columns={'word': VARCHAR}, auto_detect=false)
WHERE length(word)>10
)
FROM all_vowel_words();
- Output:
┌───────────────┐ │ word │ │ varchar │ ├───────────────┤ │ 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 rows │ └───────────────┘
EasyLang
repeat
s$ = input
until s$ = ""
if len s$ > 10
c[] = [ 0 0 0 0 0 0 ]
for c$ in strchars s$
h = strpos "aeiou" c$
c[h + 1] += 1
.
if c[2] * c[3] * c[4] * c[5] * c[6] = 1
print s$
.
.
.
# the content of unixdict.txt
input_data
10th
1st
.
.
communicate
.
.
Ed
Independently evolved to the same implementation as #sed
H
v/.{10,}/d
v/^[^a]*a[^a]*$/d
v/^[^e]*e[^e]*$/d
v/^[^i]*i[^i]*$/d
v/^[^o]*o[^o]*$/d
v/^[^u]*u[^u]*$/d
,p
Q- Output:
$ cat all-vowels.ed | ed -E unixdict.txt 206403 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
F#
// 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")
- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
Factor
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.
- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
Forth
: 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
- Output:
1. ambidextrous 2. bimolecular 3. cauliflower 4. communicable 5. communicate 6. consanguine 7. consultative 8. countervail 9. exclusionary 10. grandiloquent 11. importunate 12. incommutable 13. incomputable 14. insupportable 15. loudspeaking 16. malnourished 17. mensuration 18. oneupmanship 19. pandemonium 20. permutation 21. perturbation 22. portraiture 23. praseodymium 24. stupefaction 25. sulfonamide
FreeBASIC
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
- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
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]
}- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
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- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
Go
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)
}
}
}
- Output:
Words which contain all 5 vowels once in unixdict.txt: 1: ambidextrous 2: bimolecular 3: cauliflower 4: communicable 5: communicate 6: consanguine 7: consultative 8: countervail 9: exclusionary 10: grandiloquent 11: importunate 12: incommutable 13: incomputable 14: insupportable 15: loudspeaking 16: malnourished 17: mensuration 18: oneupmanship 19: pandemonium 20: permutation 21: perturbation 22: portraiture 23: praseodymium 24: stupefaction 25: sulfonamide
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
- Output:
(with my version of unixdict.txt)
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
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:
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)
- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
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
jq
Works with gojq, the Go implementation of jq
select(length > 10)
| . as $w
| select( all("a","e","i","o","u";
. as $v | ($w | test($v) and (test( "\($v).*\($v)")|not))))- Output:
Invocation example: jq -Rr -f program.jq unixdict.txt
ambidextrous bimolecular cauliflower ... praseodymium stupefaction sulfonamide
Julia
See Alternade_words for the foreachword function.
hassallthevowels(w, d) = all(c -> count(x -> x == c, w) == 1, collect("aeiou")) ? w : ""
foreachword("unixdict.txt", hassallthevowels, colwidth=18, minlen=11, numcols=5)
- Output:
Word source: unixdict.txt
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
Ksh
#!/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}
- Output:
1. ambidextrous2. bimolecular 3. cauliflower 4. communicable 5. communicate 6. consanguine 7. consultative 8. countervail 9. exclusionary 10. grandiloquent 11. importunate 12. incommutable 13. incomputable 14. insupportable 15. loudspeaking 16. malnourished 17. mensuration 18. oneupmanship 19. pandemonium 20. permutation 21. perturbation 22. portraiture 23. praseodymium 24. stupefaction
25. sulfonamide
Mathematica /Wolfram Language
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]]
- Output:
{ambidextrous, bimolecular, cauliflower, communicable, communicate, consanguine, consultative, countervail, exclusionary, grandiloquent, importunate, incommutable, incomputable, insupportable, loudspeaking, malnourished, mensuration, oneupmanship, pandemonium, permutation, perturbation, portraiture, praseodymium, stupefaction, sulfonamide}
Modula-2
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.
- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
Nim
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: ' '
- Output:
ambidextrous bimolecular cauliflower communicable communicate
consanguine consultative countervail exclusionary grandiloquent
importunate incommutable incomputable insupportable loudspeaking
malnourished mensuration oneupmanship pandemonium permutation
perturbation portraiture praseodymium stupefaction sulfonamide
Nu
let pat = [a e i o u] | each {|v| $"\(?i)^[^($v)]*($v)[^($v)]*$" }
open 'unixdict.txt' | split words -l 11 | where ($pat | all { $it =~ $in })- Output:
╭────┬───────────────╮ │ 0 │ ambidextrous │ │ 1 │ bimolecular │ │ 2 │ cauliflower │ │ 3 │ communicable │ │ 4 │ communicate │ │ 5 │ consanguine │ │ 6 │ consultative │ │ 7 │ countervail │ │ 8 │ exclusionary │ │ 9 │ grandiloquent │ │ 10 │ importunate │ │ 11 │ incommutable │ │ 12 │ incomputable │ │ 13 │ insupportable │ │ 14 │ loudspeaking │ │ 15 │ malnourished │ │ 16 │ mensuration │ │ 17 │ oneupmanship │ │ 18 │ pandemonium │ │ 19 │ permutation │ │ 20 │ perturbation │ │ 21 │ portraiture │ │ 22 │ praseodymium │ │ 23 │ stupefaction │ │ 24 │ sulfonamide │ ╰────┴───────────────╯
OmniMark
process
submit file 'unixdict.txt'
find line-start (any-text{10} any-text+) => word line-end
local stream aeiou initial {''}
repeat scan word
match ["aeiou"] => vowel
do when aeiou matches unanchored vowel
set aeiou to 'too many vowels'
exit
else
set aeiou to aeiou || vowel
done
match any ; ignore
again
output '%x(word)%t' when length of aeiou = 5
find any ; strip anything else- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
PascalABC.NET
This task uses countChars from Words with more than 3 ez
// Find words which contains all the vowels. Nigel Galloway: September 3rd., 2024
var predicate:Dictionary<char,integer>->boolean:=n->(n['a']=1) and (n['e']=1) and (n['i']=1) and (n['o']=1) and (n['u']=1);
begin
foreach s:string in System.IO.File.ReadLines('unixdict.txt') do if (s.Length>10) and (predicate(countChars('aeiou',s))) then println(s);
end.
- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
Perl
#!/usr/bin/perl
use strict;
use warnings;
@ARGV = 'unixdict.txt';
length > 11 and !/([aeiou]).*\1/ and tr/aeiou// == 5 and print while <>;
- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
Phix
with javascript_semantics function onev(string word, integer vowel) return length(find_all(vowel,word))=1 end function function allv(string word) return length(word)>10 and sum(apply(true,onev,{{word},"aeiou"}))=5 end function sequence fivev = filter(unix_dict(),allv) printf(1,"%d words: %s\n",{length(fivev),join(shorten(fivev,"",3))})
- Output:
25 words: ambidextrous bimolecular cauliflower ... praseodymium stupefaction sulfonamide
PL/I
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;- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
Python
Tested on Python 3+, the file download will work only if the link is still active. It is possible that you may be able to fetch the file in your browser but download via code may still fail. Check whether you are connected to a VPN, it works on open networks.
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)
- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
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$- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
R
Adapting this from https://rosettacode.org/wiki/Find_words_which_contain_the_most_consonants#R is trivial.
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))]
Raku
Yet another "Filter a word list" task.
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";
- Output:
25 words found: ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
Red
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
]
]
- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
REXX
These REXX versions don't care what order the words in the dictionary are in, nor does it care what
case (lower/upper/mixed) the words are in, the search for the words is caseless.
They also allows the minimum length to be specified on the command line (CL) as well as the dictionary file identifier.
version 1
/*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:
────────────────────────────── 25104 words in the dictionary file: unixdict.txt
ambidextrous
bimolecular
cauliflower
communicable
communicate
consanguine
consultative
countervail
exclusionary
grandiloquent
importunate
incommutable
incomputable
insupportable
loudspeaking
malnourished
mensuration
oneupmanship
pandemonium
permutation
perturbation
portraiture
praseodymium
stupefaction
sulfonamide
────────────────────────────── 25 words found with only one each of every vowel, and with a minimum length of 11
version 2
This REXX version uses the countstr BIF which returns the count of (a particular) character in a string.
/*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 1st REXX version.
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- Output:
working... 1. ambidextrous 2. bimolecular 3. cauliflower 4. communicable 5. communicate 6. consanguine 7. consultative 8. countervail 9. exclusionary 10. grandiloquent 11. importunate 12. incommutable 13. incomputable 14. insupportable 15. loudspeaking 16. malnourished 17. mensuration 18. oneupmanship 19. pandemonium 20. permutation 21. perturbation 22. portraiture 23. praseodymium 24. stupefaction 25. sulfonamide done...
RPL
The only way to use unixdict.txt as input is to convert it into a list of 25104 strings. Fortunately, emulators can handle such a big data structure in RAM.
≪ { }
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
» 'AEIOU' STO
- Output:
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" }
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
- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
Rust
use std::fs;
fn hasoneofeachvowel(word: &&str, minsize: usize) -> bool {
if word.len() < minsize {
return false;
}
let letters = word.chars();
let vowels = "aeiou".chars();
return vowels
.filter(|v| letters.clone().filter(|c| c == v).count() == 1)
.count()
== 5;
}
fn main() {
let wordsfile = fs::read_to_string("unixdict.txt").unwrap().to_lowercase();
let words = wordsfile
.split_whitespace()
.filter(|w| hasoneofeachvowel(w, 11));
for (i, w) in words.enumerate() {
print!("{:<15}{}", w, if (i + 1) % 5 == 0 { "\n" } else { "" });
}
return ();
}
- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
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
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)
}
- Output:
1. ambidextrous 2. bimolecular 3. cauliflower 4. communicable 5. communicate 6. consanguine 7. consultative 8. countervail 9. exclusionary 10. grandiloquent 11. importunate 12. incommutable 13. incomputable 14. insupportable 15. loudspeaking 16. malnourished 17. mensuration 18. oneupmanship 19. pandemonium 20. permutation 21. perturbation 22. portraiture 23. praseodymium 24. stupefaction 25. sulfonamide
UNIX Shell
#!/bin/bash
dictionary_file="$1" # $1 is the first argument when invoked on CLI
[[ -e "$dictionary_file" ]] || echo "invalid dictionary file"
while IFS= read -r line; do
[[ ${#line} -le 10 ]] && continue # skip to the next word
a=0; e=0; i=0; o=0; u=0;
for (( i=0; i<${#line}; i++ )); do
char="${line:$i:1}"
case "$char" in
a|A) ((a++));;
e|E) ((e++));;
i|I) ((i++));;
o|O) ((o++));;
u|U) ((u++));;
esac
done
[[ a -eq 1 && e -eq 1 && i -eq 1 && o -eq 1 && u -eq 1 ]] && echo "$line"
done < "${dictionary_file}"
- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
V (Vlang)
import os
const vowels := ["a", "e", "i", "o", "u"]
fn main() {
mut result := ""
mut count := 0
unixdict := os.read_file("./unixdict.txt") or {panic("file not found")}
for word in unixdict.split_into_lines() {
if vowels.all(word.count(it) == 1) && word.len >= 11 {
count++
result += "${count:2}: " + "${word}" + "\n"
}
}
println(result)
}
- Output:
1: ambidextrous 2: bimolecular 3: cauliflower 4: communicable 5: communicate 6: consanguine 7: consultative 8: countervail 9: exclusionary 10: grandiloquent 11: importunate 12: incommutable 13: incomputable 14: insupportable 15: loudspeaking 16: malnourished 17: mensuration 18: oneupmanship 19: pandemonium 20: permutation 21: perturbation 22: portraiture 23: praseodymium 24: stupefaction 25: sulfonamide
Wren
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)
}
- Output:
1: ambidextrous 2: bimolecular 3: cauliflower 4: communicable 5: communicate 6: consanguine 7: consultative 8: countervail 9: exclusionary 10: grandiloquent 11: importunate 12: incommutable 13: incomputable 14: insupportable 15: loudspeaking 16: malnourished 17: mensuration 18: oneupmanship 19: pandemonium 20: permutation 21: perturbation 22: portraiture 23: praseodymium 24: stupefaction 25: sulfonamide
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;
]- Output:
ambidextrous bimolecular cauliflower communicable communicate consanguine consultative countervail exclusionary grandiloquent importunate incommutable incomputable insupportable loudspeaking malnourished mensuration oneupmanship pandemonium permutation perturbation portraiture praseodymium stupefaction sulfonamide
Categories:
- Draft Programming Tasks
- 11l
- Action!
- Ada
- ALGOL 68
- ALGOL 68-files
- Arturo
- AutoHotkey
- AWK
- BASIC
- BCPL
- BQN
- C
- C++
- CLU
- COBOL
- Common Lisp
- Delphi
- System.SysUtils
- System.IoUtils
- Draco
- DuckDB
- EasyLang
- Ed
- F Sharp
- Factor
- Forth
- FreeBASIC
- Frink
- FutureBasic
- Go
- Haskell
- J
- Jq
- Julia
- Ksh
- Mathematica
- Wolfram Language
- Modula-2
- Nim
- Nu
- OmniMark
- PascalABC.NET
- Perl
- Phix
- PL/I
- Python
- Quackery
- R
- Raku
- Red
- REXX
- Ring
- RPL
- Ruby
- Rust
- Sed
- Swift
- UNIX Shell
- V (Vlang)
- Wren
- Wren-fmt
- XPL0