User talk:CalmoSoft/Find words which contains all the vowels: Difference between revisions

From Rosetta Code
Content added Content deleted
m (→‎{{header|Phix}}: removed unhelpful comment)
(Blanked this page as its contents have now been copied back to whence they came.)
 
Line 1: Line 1:


;Task:
Use the dictionary  [https://web.archive.org/web/20180611003215/http://www.puzzlers.org/pub/wordlists/unixdict.txt 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 &nbsp; <big>'''>&nbsp; 10</big>.


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

=={{header|ALGOL 68}}==
<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</lang>
{{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|C++}}==
<lang cpp>#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <iostream>

bool contains_all_vowels_once(const std::string& word) {
unsigned int vowels = 0;
for (char ch : word) {
unsigned int bit = 0;
switch (ch) {
case 'a':
bit = 1;
break;
case 'e':
bit = 2;
break;
case 'i':
bit = 4;
break;
case 'o':
bit = 8;
break;
case 'u':
bit = 16;
break;
}
if (bit == 0)
continue;
if (vowels & bit)
return false;
vowels |= bit;
}
return vowels == 31;
}

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

{{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|Delphi}}==
{{libheader| System.SysUtils}}
{{libheader| System.IoUtils}}
<lang Delphi>
program Find_words_which_contains_all_the_vowels;

{$APPTYPE CONSOLE}

uses
System.SysUtils,
System.IoUtils;

function IsVowelsOnce(w: string): Boolean;
const
chars: array[0..4] of char = ('a', 'e', 'i', 'o', 'u');
var
cs: array[0..4] of Boolean;
i: Integer;
c: char;
begin
if w.IsEmpty then
exit(false);

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

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

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

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

readln;
end.</lang>
{{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|Factor}}==
<lang factor>USING: grouping io.encodings.ascii io.files math prettyprint
sequences sets.extras ;

"unixdict.txt" ascii file-lines
[ length 10 > ] filter
[ non-repeating "aeiou" superset? ] filter
5 group simple-table.</lang>
{{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}}==
<lang go>package main

import (
"bytes"
"fmt"
"io/ioutil"
"log"
"unicode/utf8"
)

func main() {
wordList := "unixdict.txt"
b, err := ioutil.ReadFile(wordList)
if err != nil {
log.Fatal("Error reading file")
}
bwords := bytes.Fields(b)
var words []string
for _, bword := range bwords {
s := string(bword)
if utf8.RuneCountInString(s) > 10 {
words = append(words, s)
}
}
count := 0
fmt.Println("Words which contain all 5 vowels once in", wordList, "\b:\n")
for _, word := range words {
ca, ce, ci, co, cu := 0, 0, 0, 0, 0
for _, r := range word {
switch r {
case 'a':
ca++
case 'e':
ce++
case 'i':
ci++
case 'o':
co++
case 'u':
cu++
}
}
if ca == 1 && ce == 1 && ci == 1 && co == 1 && cu == 1 {
count++
fmt.Printf("%2d: %s\n", count, word)
}
}
}</lang>

{{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|Julia}}==
See [[Alternade_words]] for the foreachword function.
<lang julia>hassallthevowels(w, d) = all(c -> count(x -> x == c, w) == 1, collect("aeiou")) ? w : ""
foreachword("unixdict.txt", hassallthevowels, colwidth=18, minlen=11, numcols=5)
</lang>{{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|Phix}}==
<lang Phix>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(get_text("demo/unixdict.txt",GT_LF_STRIPPED),allv)
printf(1,"%d words: %s\n",{length(fivev),join(shorten(fivev,"",3))})</lang>
{{out}}
<pre>
25 words: ambidextrous bimolecular cauliflower ... praseodymium stupefaction sulfonamide
</pre>

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

<lang perl6>put +.words, " words found:\n", $_ with 'unixdict.txt'.IO.words\
.grep({ .chars > 10 and all(.comb.Bag<a e i o u>) == 1 })\
.batch(5)».fmt('%-13s').join: "\n";</lang>

{{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|REXX}}==
This REXX version doesn'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''.

It also allows the minimum length to be specified on the command line (CL) as well as the dictionary file identifier.
<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
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 length(vowels) /*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 vowel. */
if pos(v, y, _+1)\==0 then iterate j /*Is there another (of the same) ··· */
end /*k*/ /* ··· vowel? Yes, then skip it. */
finds= finds + 1 /*bump the count of alternades found.*/
say right( left($.j, 25), 40) /*indent the word for a better display.*/
end /*j*/
/*stick a fork in it, we're all done. */
say copies('─',30) finds ' words found with only one each of every vowel,' ,
" and with a minimum length of " minL</lang>
{{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>

=={{header|Ring}}==
<lang ring>
load "stdlib.ring"

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

see "working..." + nl

ln = len(wordList)
for n = ln to 1 step -1
if len(wordList[n]) < 11
del(wordList,n)
ok
next

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

see "done..." + nl

func count(cString,dString)
sum = 0
while substr(cString,dString) > 0
sum = sum + 1
cString = substr(cString,substr(cString,dString)+len(string(sum)))
end
return sum
</lang>
{{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|Swift}}==
<lang swift>import Foundation

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

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

{{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}}
<lang ecmascript>import "io" for File
import "/fmt" for Fmt

var wordList = "unixdict.txt" // local copy
var count = 0
File.read(wordList).trimEnd().split("\n").
where { |w|
return w.count > 10 && "aeiou".all { |v|
return w.count { |c| c == v } == 1
}
}.
each { |w|
count = count + 1
Fmt.print("$2d: $s", count, w)
}</lang>

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

Latest revision as of 09:35, 16 February 2021

Retrieved from "https://rosettacode.org/wiki/User_talk:CalmoSoft/Find_words_which_contains_all_the_vowels?oldid=308086"