Find words which contains more than 3 e vowels: Difference between revisions

{{trans|Python}}

L(word) File(‘unixdict.txt’).read().split("\n")

I !any(word.map(c -> c C :aiou)) & sum(word.map(c -> Int(c == ‘e’))) > 3

{{out}}

=={{header|8080 Assembly}}==

fopen: equ 15 ; Open file

fread: equ 20 ; Read block

jmp 5

emsg: db 'Error$'

{{out}}

=={{header|Action!}}==

In the following solution the input file [https://gitlab.com/amarok8bit/action-rosetta-code/-/blob/master/source/unixdict.txt unixdict.txt] is loaded from H6 drive. Altirra emulator automatically converts CR/LF character from ASCII into 155 character in ATASCII charset used by Atari 8-bit computer when one from H6-H10 hard drive under DOS 2.5 is used.

BYTE i,n

FindWords(fname)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Find_words_which_contains_more_than_3_e_vowels.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

with Ada.Strings.Maps;

with Ada.Strings.Fixed;

end loop;

Close (File);

=={{header|ALGOL 68}}==

Interesting to note the word with the most es is "dereference" - a term first used (I believe) in Algol 68...

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

OD;

close( input file )

{{out}}

<pre>

=={{header|Arturo}}==

otherVowels: ["a" "i" "o" "u"]

containsMoreThan3Es?: function [w][

if containsMoreThan3Es? word ->

print word

{{out}}

=={{header|AutoHotkey}}==

vowelsLessE := ["a", "i", "o", "u"]

oRes := []

result .= word "`n"

}

{{out}}

<pre>belvedere

=={{header|AWK}}==

{{out}}

=={{header|BCPL}}==

let reads(v) = valof

while reads(word) if testword(word) do writef("%S*N",word)

endread()

{{out}}

<pre>belvedere

=={{header|C}}==

#define SIZE 256

fclose(f);

return 0;

{{out}}

=={{header|C++}}==

#include <fstream>

return 0;

{{out}}

=={{header|CLU}}==

e: int := 0

for c: char in string$chars(s) do

end

stream$close(dict)

{{out}}

<pre>belvedere

=={{header|COBOL}}==

PROGRAM-ID. E-WORDS.

INSPECT WORD TALLYING OTHER FOR ALL 'u'.

IF E IS GREATER THAN 3 AND OTHER IS EQUAL TO ZERO,

{{out}}

<pre>belvedere

=={{header|Cowgol}}==

include "file.coh";

end if;

{{out}}

=={{header|Draco}}==

word e;

char c;

close(dict)

{{out}}

<pre>belvedere

=={{header|F_Sharp|F#}}==

// Words contains more than 3 e vowels. Nigel Galloway: February 11th., 2021.

let fN g=let n=Map.ofSeq (Seq.countBy id g) in let fN g=not(n.ContainsKey g) in fN 'a' && fN 'i' && fN 'o' && fN 'u' && not(fN 'e') && n.['e']>3

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

{{out}}

<pre>

=={{header|Factor}}==

sequences ;

[ [ "aiou" member? ] any? ] reject

[ [ CHAR: e = ] count 3 > ] filter

{{out}}

<pre>

=={{header|Forth}}==

{{works with|Gforth}}

0 { ecount }

0 do

main

{{out}}

=={{header|FreeBASIC}}==

dim as string s, c

next i

if e>3 then print s

{{out}}<pre>

belvedere

=={{header|Frink}}==

{

d = countToDict[charList[word]]

if d.get["a",0] == 0 and d.get["e",0] > 3 and d.get["i",0] == 0 and d.get["o",0] == 0 and d.get["u",0] == 0

println[word]

{{out}}

<pre>

=={{header|Go}}==

import (

}

}

{{out}}

=={{header|Haskell}}==

main = withFile "unixdict.txt" ReadMode $ \h -> do

putStrLn $ unlines $ filter valid words

{{out}}

=={{header|J}}==

belvedere

dereference

seventeenth

telemeter

(Also possible to do this with regular expressions, but this works. Here, we counted how many times each vowel occurred, limited the maximum count to 4, and checked the resulting signature.)

===Using regular expressions===

| select(test("[aiou]")|not)

===Regex-free solution===

("aiou" | explode) as $disallow

count(.[] | select(. == 101)) > 3) # "e" is 101

| $word

{{out}}

Invocation example: jq -nrR program.jq unixdict.txt

=={{header|Julia}}==

See [[Alternade_words#Julia]] for the foreachword function.

vowelcount(word) = count(x -> x in ['a', 'e', 'i', 'o', 'u'], word)

onlyevowelsmorethan3(word, _) = begin n, m = vowelcount(word), ecount(word); n == m && m > 3 ? word : "" end

foreachword("unixdict.txt", onlyevowelsmorethan3, colwidth=15, numcols=8)

<pre>

belvedere dereference elsewhere erlenmeyer evergreen everywhere exegete freewheel

=={{header|Ksh}}==

#!/bin/ksh

(( $(_countch "$REPLY" "e") >= MINE )) && print $REPLY

done < ${dictionary}

{{out}}<pre>

belvedere

=={{header|Mathematica}}/{{header|Wolfram Language}}==

dict = Once[Import["https://web.archive.org/web/20180611003215/http://www.puzzlers.org/pub/wordlists/unixdict.txt"]];

dict //= StringSplit[#, "\n"] &;

dict //= Select[Last /* Count["e"] /* GreaterThan[3]];

dict //= Select[Last /* Apply[SameQ]];

{{out}}

<pre>{belvedere, dereference, elsewhere, erlenmeyer, evergreen, everywhere, exegete, freewheel, nevertheless, persevere, preference, referee, seventeen, seventeenth, telemeter, tennessee}</pre>

=={{header|Nim}}==

const NonEVowels = ['a', 'i', 'o', 'u']

if vowel in word: break checkWord

inc count

{{out}}

=={{header|Pascal}}==

{{works with|Turbo Pascal}}

var

FileVar: Text;

end

end

{{out}}

=={{header|Perl}}==

use strict; # https://rosettacode.org/wiki/Find_words_which_contains_more_than_3_e_vowels

@ARGV = 'unixdict.txt';

{{out}}

belvedere

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">note</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">word</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">return</span> <span style="color: #7060A8;">find_any</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"aiou"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">word</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">0</span> <span style="color: #008080;">and</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">find_all</span><span style="color: #0000FF;">(</span><span style="color: #008000;">'e'</span><span style="color: #0000FF;">,</span><span style="color: #000000;">word</span><span style="color: #0000FF;">))></span><span style="color: #000000;">3</span> <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">notes</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">filter</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">unix_dict</span><span style="color: #0000FF;">(),</span><span style="color: #000000;">note</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d words: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">notes</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">notes</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">))})</span>

{{out}}

<pre>

=={{header|PL/I}}==

declare dict file;

open file(dict) title('unixdict.txt');

close file(dict);

{{out}}

<pre>belvedere

=={{header|Python}}==

for line in f.readlines():

if not any(c in 'aiou' for c in line) and sum(c=='e' for c in line)>3:

{{out}}

=={{header|R}}==

Adapting this from https://rosettacode.org/wiki/Find_words_which_contains_all_the_vowels#R is trivial.

#The following line is equivalent to sapply(c("a", "i", "o", "u"), function(x) stringr::str_count(dict, x))

#As with all things with strings in R, life is easier with stringr or stringi.

notEVowelCount <- sapply(c("a", "i", "o", "u"), function(x) lengths(regmatches(dict, gregexec(x, dict))))

eCount <- lengths(regmatches(dict, gregexec("e", dict)))

=={{header|Racket}}==

;; probably not the best name, but matches the name of the task

(module+ main

{{out}}

Hardly even worth saving as a script file; an easily entered one-liner.

{{out}}

<pre>

In an attempt to be a little less useless, here's an alternate script that allows you to specify a vowel, the minimum count to search for, and the file to search. Counts base vowels case, and combining accent insensitive; works with ''any'' text file, not just word lists. Defaults to finding words with at least 4 'e's in unixdict.txt. Default output is same as above.

.say for squish sort

( $file.IO.slurp.words.grep: { ((my $b = .lc.samemark(' ').comb.Bag){$vowel} >= $min) && $b<a e i o u>.sum == $b{$vowel} } )\

How about: find words with at least 4 'a's in the [https://github.com/thundergnat/rc-run/blob/master/rc/resources/lemiz.txt Les Misérables file] used for the [[Word frequency]] task?

=={{header|Red}}==

words: read/lines %unixdict.txt

]

if all [retain e's > 3] [print word]

{{out}}

<pre>

It also allows the vowel to be specified, &nbsp; and also the minimum number of the specific vowels to be specified on the command line (CL) as well as the dictionary file identifier.

parse arg char many iFID . /*obtain optional arguments from the CL*/

if char=='' | char=="," then char= 'e' /*Not specified? Then use the default.*/

end /*j*/

/*stick a fork in it, we're all done. */

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

=={{header|Ring}}==

load "stdlib.ring"

see "done..." + nl

Output:

<pre>

=={{header|Ruby}}==

puts word if word.count("e") > 3 && word.count("aiou") == 0

end

{{out}}

<pre>belvedere

</pre>

=={{header|Snobol}}==

output = 'Error!' :(end)

line word = words :f(end)

word 'e' arb 'e' arb 'e' arb 'e' :f(line)

output = word :(line)

{{out}}

=={{header|Swift}}==

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

} catch {

print(error.localizedDescription)

{{out}}

=={{header|Wren}}==

{{libheader|Wren-fmt}}

import "/fmt" for Fmt

Fmt.print("$2d: $s", count, word)

}

{{out}}

=={{header|XPL0}}==

int I, Ch, Len;

char Word(100); \(longest word in unixdict.txt is 22 chars)

if Es then [Text(0, Word); CrLf(0)];

until Ch = EOF;

{{out}}