Find words with alternating vowels and consonants: Difference between revisions
m (→{{header|AppleScript}}: Idiomatic: Relabelled. Added preamble.) |
m (→{{header|AppleScript}}: Minor edit to preamble.) |
||
Line 88:
=={{header|AppleScript}}==
===Idiomatic===
The handler here is case- and diacritical-insensitive and has an option to treat "y" as a vowel. With the text file located on the computer's startup disk, it performs the set task in just under a third of a second on my machine, which is probably good enough for such a silly task. However, the "Functional" script beneath it
<lang applescript>(*
|
Revision as of 12:09, 23 January 2021
- Task
Using the dictionary unixdict.txt, find words which odd letters are consonants and even letters are vowels or vice versa.
Display the words here (on this page).
The length of any word shown should have a length > 9.
- 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 contains most consonants
- Find words which contains more than 3 vowels
- Find words which first and last three letters are equals
- Find words which odd letters are consonants and even letters are vowels or vice_versa
- 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
ALGOL 68
<lang algol68># read the list of words and show words with alternating vowels and #
- consonants #
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 ); # returns the length of the string w # OP LENGTH = ( STRING w )INT: ( UPB w - LWB w ) + 1; # returns TRUE if c is a vowel, FALSE otherwise # OP ISVOWEL = ( CHAR c )BOOL: ( c = "a" OR c = "e" OR c = "i" OR c = "o" OR c = "u" ); # blank pads s on the left to width characters # PRIO PAD = 1; OP PAD = ( INT width, STRING s )STRING: IF LENGTH s >= width THEN s ELSE ( " " * ( width - LENGTH s ) ) + s FI; INT alternating count := 0; WHILE STRING word; get( input file, ( word, newline ) ); NOT at eof DO IF LENGTH word >= 10 THEN # the word is at least 10 characters # BOOL is alternating := TRUE; BOOL have vowel := ISVOWEL word[ LWB word ]; FOR w pos FROM LWB word + 1 TO UPB word WHILE BOOL had vowel = have vowel; have vowel := ISVOWEL word[ w pos ]; is alternating := have vowel = NOT had vowel DO SKIP OD; IF is alternating THEN # the characters of word alternate between vowels and # # non-vowels # alternating count +:= 1; print( ( " ", 15 PAD word ) ); IF LENGTH word > 15 OR alternating count MOD 6 = 0 THEN print( ( newline ) ) FI FI FI OD; close( input file ); print( ( newline, whole( alternating count, 0 ), " words of alternating vowels and consonants found", newline ) )
FI</lang>
- Output:
aboriginal apologetic bimolecular borosilicate calorimeter capacitate capacitive capitoline capitulate caricature colatitude coloratura colorimeter debilitate decelerate decolonize definitive degenerate deliberate demodulate denominate denotative deregulate desiderata desideratum dilapidate diminutive epigenetic facilitate hemosiderin heretofore hexadecimal homogenate inoperative judicature latitudinal legitimate lepidolite literature locomotive manipulate metabolite nicotinamide oratorical paragonite pejorative peridotite peripatetic polarimeter recitative recuperate rehabilitate rejuvenate remunerate repetitive reticulate savonarola similitude solicitude tananarive telekinesis teratogenic topologize unilateral unimodular uninominal verisimilitude 67 words of alternating vowels and consonants found
AppleScript
Idiomatic
The handler here is case- and diacritical-insensitive and has an option to treat "y" as a vowel. With the text file located on the computer's startup disk, it performs the set task in just under a third of a second on my machine, which is probably good enough for such a silly task. However, the "Functional" script beneath it — although going to great lengths (!) to disguise how it works and how to use it (the text file has to be in the same folder as the compiled script file), performing a strictly lower-case search (easily fixed by starting the regex with "(?i)"), and assuming the text file has just one word per linefeed-delimited line — is just over ten times as fast, including additional time spent formatting the output for display!
<lang applescript>(*
With AppleScript's text item delimiters set to all the vowels, the 'text items' of a word with alternating vowels and consonants are single-character strings (the consonants), with the possibility of an empty string at the beginning and/or end representing a leading and/or trailing vowel.
- )
on findWordsWithAlternatingVowelsAndConsonants from theText given minLength:minLength, yAsVowel:yAsVowel
script o property wordList : theText's words property output : {} end script set astid to AppleScript's text item delimiters if (yAsVowel) then set AppleScript's text item delimiters to {"a", "e", "i", "o", "u", "y"} else set AppleScript's text item delimiters to {"a", "e", "i", "o", "u"} end if ignoring case and diacriticals repeat with thisWord in o's wordList set thisWord to thisWord's contents if ((count thisWord) ≥ minLength) then set textItems to thisWord's text items set a to 1 if ((count beginning of textItems) is 0) then set a to 2 set b to (count textItems) if ((count end of textItems) is 0) then set b to b - 1 repeat with i from a to b set alternating to ((count item i of textItems) is 1) if (not alternating) then exit repeat end repeat if (alternating) then set end of o's output to thisWord end if end repeat end ignoring set AppleScript's text item delimiters to astid return o's output
end findWordsWithAlternatingVowelsAndConsonants
-- Task code: local theText set theText to (read file ((path to desktop as text) & "unixdict.txt") as «class utf8») findWordsWithAlternatingVowelsAndConsonants from theText without yAsVowel given minLength:10</lang>
- Output:
<lang applescript>{"aboriginal", "apologetic", "bimolecular", "borosilicate", "calorimeter", "capacitate", "capacitive", "capitoline", "capitulate", "caricature", "colatitude", "coloratura", "colorimeter", "debilitate", "decelerate", "decolonize", "definitive", "degenerate", "deliberate", "demodulate", "denominate", "denotative", "deregulate", "desiderata", "desideratum", "dilapidate", "diminutive", "epigenetic", "facilitate", "hemosiderin", "heretofore", "hexadecimal", "homogenate", "inoperative", "judicature", "latitudinal", "legitimate", "lepidolite", "literature", "locomotive", "manipulate", "metabolite", "nicotinamide", "oratorical", "paragonite", "pejorative", "peridotite", "peripatetic", "polarimeter", "recitative", "recuperate", "rehabilitate", "rejuvenate", "remunerate", "repetitive", "reticulate", "savonarola", "similitude", "solicitude", "tananarive", "telekinesis", "teratogenic", "topologize", "unilateral", "unimodular", "uninominal", "verisimilitude"}</lang>
Or if you want to treat "y" as a vowel:
<lang applescript>-- Task code: local theText set theText to (read file ((path to desktop as text) & "unixdict.txt") as «class utf8») findWordsWithAlternatingVowelsAndConsonants from theText with yAsVowel given minLength:10</lang>
- Output:
<lang applescript>{"aboriginal", "apologetic", "bimolecular", "borosilicate", "calorimeter", "capacitate", "capacitive", "capitoline", "capitulate", "caricature", "cohomology", "colatitude", "coloratura", "colorimeter", "debilitate", "decelerate", "decolonize", "definitive", "degeneracy", "degenerate", "dehumidify", "deliberate", "demodulate", "denominate", "denotative", "depositary", "depository", "deregulate", "deregulatory", "derogatory", "desiderata", "desideratum", "dicotyledon", "dilapidate", "diminutive", "epigenetic", "facilitate", "generosity", "hemosiderin", "hereditary", "heretofore", "heterodyne", "hexadecimal", "homogenate", "hypotenuse", "inoperative", "judicatory", "judicature", "laboratory", "latitudinal", "latitudinary", "legitimacy", "legitimate", "lepidolite", "literature", "locomotive", "locomotory", "luminosity", "manipulate", "metabolite", "mineralogy", "monocotyledon", "musicology", "nicotinamide", "numerology", "oratorical", "paragonite", "paramilitary", "pejorative", "peridotite", "peripatetic", "polarimeter", "polymerase", "pyrimidine", "pyroxenite", "recitative", "recuperate", "regulatory", "rehabilitate", "rejuvenate", "remunerate", "repetitive", "repository", "reticulate", "revelatory", "savonarola", "similitude", "solicitude", "solidarity", "tananarive", "telekinesis", "teratogenic", "teratology", "topologize", "toxicology", "unilateral", "unimodular", "uninominal", "verisimilitude", "veterinary", "vocabulary"}</lang>
Functional
<lang applescript>use AppleScript version "2.4" use framework "Foundation" use scripting additions
ALTERNATING VOWELS AND CONSONANTS -----------
on run
set regex to "^.*([aeiou]{2}|[^aeiou]{2}).*$" set query to "(9 < self.length) and not (self matches '" & regex & "')" set fpWordList to scriptFolder() & "unixdict.txt" if doesFileExist(fpWordList) then inColumns(4, ¬ filteredLines(query, readFile(fpWordList))) else display dialog "Word list not found at:" & ¬ linefeed & tab & fpWordList end if
end run
GENERIC :: FILTERED LINES FROM FILE ----------
-- doesFileExist :: FilePath -> IO Bool on doesFileExist(strPath)
set ca to current application set oPath to (ca's NSString's stringWithString:strPath)'s ¬ stringByStandardizingPath set {bln, int} to (ca's NSFileManager's defaultManager's ¬ fileExistsAtPath:oPath isDirectory:(reference)) bln and (int ≠ 1)
end doesFileExist
-- filteredLines :: String -> NString -> [a]
on filteredLines(predicateString, s)
-- A list of lines filtered by an NSPredicate string set ca to current application set predicate to ca's NSPredicate's predicateWithFormat:predicateString set array to ca's NSArray's ¬ arrayWithArray:(s's componentsSeparatedByString:(linefeed)) (array's filteredArrayUsingPredicate:(predicate)) as list
end filteredLines
-- readFile :: FilePath -> IO NSString
on readFile(strPath)
set ca to current application set e to reference set {s, e} to (ca's NSString's ¬ stringWithContentsOfFile:((ca's NSString's ¬ stringWithString:strPath)'s ¬ stringByStandardizingPath) ¬ encoding:(ca's NSUTF8StringEncoding) |error|:(e)) if missing value is e then s else (localizedDescription of e) as string end if
end readFile
-- scriptFolder :: () -> IO FilePath
on scriptFolder()
-- The path of the folder containing this script try tell application "Finder" to ¬ POSIX path of ((container of (path to me)) as alias) on error display dialog "Script file must be saved" end try
end scriptFolder
GENERIC :: COLUMNAR FORMATTING ------------
-- Tuple (,) :: a -> b -> (a, b) on Tuple(a, b)
-- Constructor for a pair of values, -- possibly of two different types. {type:"Tuple", |1|:a, |2|:b, length:2}
end Tuple
-- chunksOf :: Int -> [a] -> a
on chunksOf(k, xs)
script on go(ys) set ab to splitAt(k, ys) set a to |1| of ab if {} ≠ a then {a} & go(|2| of ab) else a end if end go end script result's go(xs)
end chunksOf
-- foldl :: (a -> b -> a) -> a -> [b] -> a
on foldl(f, startValue, xs)
tell mReturn(f) set v to startValue set lng to length of xs repeat with i from 1 to lng set v to |λ|(v, item i of xs, i, xs) end repeat return v end tell
end foldl
-- inColumns :: Int -> [String] -> String
on inColumns(n, xs)
-- The strings in xs displayed in n columns -- of equal width. set widest to maximum(map(my |length|, xs)) unlines({(length of xs as text) & " matches:" & linefeed} & ¬ map(my unwords, chunksOf(n, ¬ map(justifyLeft(widest, space), xs))))
end inColumns
-- justifyLeft :: Int -> Char -> String -> String
on justifyLeft(n, cFiller)
script on |λ|(s) if n > length of s then text 1 thru n of (s & replicate(n, cFiller)) else s end if end |λ| end script
end justifyLeft
-- length :: [a] -> Int
on |length|(xs)
set c to class of xs if list is c or string is c then length of xs else (2 ^ 29 - 1) -- (maxInt - simple proxy for non-finite) end if
end |length|
-- maximum :: Ord a => [a] -> a
on maximum(xs)
script on |λ|(a, b) if a is missing value or b > a then b else a end if end |λ| end script foldl(result, missing value, xs)
end maximum
-- mReturn :: First-class m => (a -> b) -> m (a -> b)
on mReturn(f)
-- 2nd class handler function -- lifted into 1st class script wrapper. if script is class of f then f else script property |λ| : f end script end if
end mReturn
-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
-- The list obtained by applying f -- to each element of xs. tell mReturn(f) set lng to length of xs set lst to {} repeat with i from 1 to lng set end of lst to |λ|(item i of xs, i, xs) end repeat return lst end tell
end map
-- replicate :: Int -> String -> String
on replicate(n, s)
-- Egyptian multiplication - progressively doubling a list, -- appending stages of doubling to an accumulator where needed -- for binary assembly of a target length script p on |λ|({n}) n ≤ 1 end |λ| end script script f on |λ|({n, dbl, out}) if (n mod 2) > 0 then set d to out & dbl else set d to out end if {n div 2, dbl & dbl, d} end |λ| end script set xs to |until|(p, f, {n, s, ""}) item 2 of xs & item 3 of xs
end replicate
-- splitAt :: Int -> [a] -> ([a], [a])
on splitAt(n, xs)
if n > 0 and n < length of xs then if class of xs is text then Tuple(items 1 thru n of xs as text, ¬ items (n + 1) thru -1 of xs as text) else Tuple(items 1 thru n of xs, items (n + 1) thru -1 of xs) end if else if n < 1 then Tuple({}, xs) else Tuple(xs, {}) end if end if
end splitAt
-- unlines :: [String] -> String
on unlines(xs)
-- A single string formed by the intercalation -- of a list of strings with the newline character. set {dlm, my text item delimiters} to ¬ {my text item delimiters, linefeed} set s to xs as text set my text item delimiters to dlm s
end unlines
-- until :: (a -> Bool) -> (a -> a) -> a -> a
on |until|(p, f, x)
set v to x set mp to mReturn(p) set mf to mReturn(f) repeat until mp's |λ|(v) set v to mf's |λ|(v) end repeat v
end |until|
-- unwords :: [String] -> String
on unwords(xs)
set {dlm, my text item delimiters} to ¬ {my text item delimiters, space} set s to xs as text set my text item delimiters to dlm return s
end unwords</lang>
- Output:
67 matches: aboriginal apologetic bimolecular borosilicate calorimeter capacitate capacitive capitoline capitulate caricature colatitude coloratura colorimeter debilitate decelerate decolonize definitive degenerate deliberate demodulate denominate denotative deregulate desiderata desideratum dilapidate diminutive epigenetic facilitate hemosiderin heretofore hexadecimal homogenate inoperative judicature latitudinal legitimate lepidolite literature locomotive manipulate metabolite nicotinamide oratorical paragonite pejorative peridotite peripatetic polarimeter recitative recuperate rehabilitate rejuvenate remunerate repetitive reticulate savonarola similitude solicitude tananarive telekinesis teratogenic topologize unilateral unimodular uninominal verisimilitude
AWK
<lang awk>( length( $1 ) >= 10 ) \ {
# have an appropriate length word word = $1; haveVowel = word ~ /^[aeiou]/; isAlternating = 1; for( wPos = 2; isAlternating && wPos <= length( word ); wPos ++ ) { hadVowel = haveVowel; haveVowel = substr( word, wPos, 1 ) ~ /^[aeiou]/; isAlternating = ( hadVowel && ! haveVowel ) || ( ! hadVowel && haveVowel ); } # for wPos if( isAlternating ) { printf( " %16s%s", word, ( alternatingCount % 6 == 5 ) ? "\n" : "" ); alternatingCount += 1; } # if isAlternating
}
END \ {
printf( "\n%d words with alternating vowels and consonants found\n", alternatingCount );
} # END</lang>
- Output:
aboriginal apologetic bimolecular borosilicate calorimeter capacitate capacitive capitoline capitulate caricature colatitude coloratura colorimeter debilitate decelerate decolonize definitive degenerate deliberate demodulate denominate denotative deregulate desiderata desideratum dilapidate diminutive epigenetic facilitate hemosiderin heretofore hexadecimal homogenate inoperative judicature latitudinal legitimate lepidolite literature locomotive manipulate metabolite nicotinamide oratorical paragonite pejorative peridotite peripatetic polarimeter recitative recuperate rehabilitate rejuvenate remunerate repetitive reticulate savonarola similitude solicitude tananarive telekinesis teratogenic topologize unilateral unimodular uninominal verisimilitude 67 words with alternating vowels and consonants found
C
<lang c>#include <stdbool.h>
- include <stdio.h>
- include <stdlib.h>
- include <string.h>
- define MAX_WORD_SIZE 80
bool is_vowel(char ch) {
switch (ch) { case 'a': case 'A': case 'e': case 'E': case 'i': case 'I': case 'o': case 'O': case 'u': case 'U': return true; } return false;
}
int main(int argc, char** argv) {
const char* filename = argc < 2 ? "unixdict.txt" : argv[1]; FILE* fp = fopen(filename, "r"); if (!fp) { perror(filename); return EXIT_FAILURE; } char line[MAX_WORD_SIZE]; int n = 1; while (fgets(line, sizeof(line), fp)) { size_t len = strlen(line) - 1; // last character is \n if (len <= 9) continue; bool is_odd_even_word = true; for (size_t i = 1; i < len; ++i) { if (is_vowel(line[i]) == is_vowel(line[i - 1])) { is_odd_even_word = false; break; } } if (is_odd_even_word) printf("%2d: %s", n++, line); } fclose(fp); return EXIT_SUCCESS;
}</lang>
- Output:
1: aboriginal 2: apologetic 3: bimolecular 4: borosilicate 5: calorimeter 6: capacitate 7: capacitive 8: capitoline 9: capitulate 10: caricature 11: colatitude 12: coloratura 13: colorimeter 14: debilitate 15: decelerate 16: decolonize 17: definitive 18: degenerate 19: deliberate 20: demodulate 21: denominate 22: denotative 23: deregulate 24: desiderata 25: desideratum 26: dilapidate 27: diminutive 28: epigenetic 29: facilitate 30: hemosiderin 31: heretofore 32: hexadecimal 33: homogenate 34: inoperative 35: judicature 36: latitudinal 37: legitimate 38: lepidolite 39: literature 40: locomotive 41: manipulate 42: metabolite 43: nicotinamide 44: oratorical 45: paragonite 46: pejorative 47: peridotite 48: peripatetic 49: polarimeter 50: recitative 51: recuperate 52: rehabilitate 53: rejuvenate 54: remunerate 55: repetitive 56: reticulate 57: savonarola 58: similitude 59: solicitude 60: tananarive 61: telekinesis 62: teratogenic 63: topologize 64: unilateral 65: unimodular 66: uninominal 67: verisimilitude
C++
<lang cpp>#include <cstdlib>
- include <fstream>
- include <iomanip>
- include <iostream>
- include <string>
bool is_vowel(char ch) {
switch (ch) { case 'a': case 'A': case 'e': case 'E': case 'i': case 'I': case 'o': case 'O': case 'u': case 'U': return true; } return false;
}
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 line; for (int n = 1; getline(in, line); ) { size_t len = line.size(); if (len <= 9) continue; bool is_odd_even_word = true; for (size_t i = 1; i < len; ++i) { if (is_vowel(line[i]) == is_vowel(line[i - 1])) { is_odd_even_word = false; break; } } if (is_odd_even_word) std::cout << std::setw(2) << n++ << ": " << line << '\n'; } return EXIT_SUCCESS;
}</lang>
- Output:
1: aboriginal 2: apologetic 3: bimolecular 4: borosilicate 5: calorimeter 6: capacitate 7: capacitive 8: capitoline 9: capitulate 10: caricature 11: colatitude 12: coloratura 13: colorimeter 14: debilitate 15: decelerate 16: decolonize 17: definitive 18: degenerate 19: deliberate 20: demodulate 21: denominate 22: denotative 23: deregulate 24: desiderata 25: desideratum 26: dilapidate 27: diminutive 28: epigenetic 29: facilitate 30: hemosiderin 31: heretofore 32: hexadecimal 33: homogenate 34: inoperative 35: judicature 36: latitudinal 37: legitimate 38: lepidolite 39: literature 40: locomotive 41: manipulate 42: metabolite 43: nicotinamide 44: oratorical 45: paragonite 46: pejorative 47: peridotite 48: peripatetic 49: polarimeter 50: recitative 51: recuperate 52: rehabilitate 53: rejuvenate 54: remunerate 55: repetitive 56: reticulate 57: savonarola 58: similitude 59: solicitude 60: tananarive 61: telekinesis 62: teratogenic 63: topologize 64: unilateral 65: unimodular 66: uninominal 67: verisimilitude
Factor
<lang factor>USING: grouping.extras io.encodings.ascii io.files kernel math prettyprint sequences ;
"unixdict.txt" ascii file-lines [ length 9 > ] filter [ dup [ "aeiou" member? ] group-by [ length ] bi@ = ] filter .</lang>
- Output:
{ "aboriginal" "apologetic" "bimolecular" "borosilicate" "calorimeter" "capacitate" "capacitive" "capitoline" "capitulate" "caricature" "colatitude" "coloratura" "colorimeter" "debilitate" "decelerate" "decolonize" "definitive" "degenerate" "deliberate" "demodulate" "denominate" "denotative" "deregulate" "desiderata" "desideratum" "dilapidate" "diminutive" "epigenetic" "facilitate" "hemosiderin" "heretofore" "hexadecimal" "homogenate" "inoperative" "judicature" "latitudinal" "legitimate" "lepidolite" "literature" "locomotive" "manipulate" "metabolite" "nicotinamide" "oratorical" "paragonite" "pejorative" "peridotite" "peripatetic" "polarimeter" "recitative" "recuperate" "rehabilitate" "rejuvenate" "remunerate" "repetitive" "reticulate" "savonarola" "similitude" "solicitude" "tananarive" "telekinesis" "teratogenic" "topologize" "unilateral" "unimodular" "uninominal" "verisimilitude" }
Go
<lang go>package main
import (
"bytes" "fmt" "io/ioutil" "log" "strings" "unicode/utf8"
)
func isVowel(c rune) bool { return strings.ContainsRune("aeiou", c) }
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) > 9 { words = append(words, s) } } count := 0 fmt.Println("Words with alternate consonants and vowels in", wordList, "\b:\n") for _, word := range words { found := true for i, c := range word { if (i%2 == 0 && isVowel(c)) || (i%2 == 1 && !isVowel(c)) { found = false break } } if !found { found = true for i, c := range word { if (i%2 == 0 && !isVowel(c)) || (i%2 == 1 && isVowel(c)) { found = false break } } } if found { count++ fmt.Printf("%2d: %s\n", count, word) } }
}</lang>
- Output:
Words with alternate consonants and vowels in unixdict.txt: 1: aboriginal 2: apologetic 3: bimolecular 4: borosilicate 5: calorimeter 6: capacitate 7: capacitive 8: capitoline 9: capitulate 10: caricature 11: colatitude 12: coloratura 13: colorimeter 14: debilitate 15: decelerate 16: decolonize 17: definitive 18: degenerate 19: deliberate 20: demodulate 21: denominate 22: denotative 23: deregulate 24: desiderata 25: desideratum 26: dilapidate 27: diminutive 28: epigenetic 29: facilitate 30: hemosiderin 31: heretofore 32: hexadecimal 33: homogenate 34: inoperative 35: judicature 36: latitudinal 37: legitimate 38: lepidolite 39: literature 40: locomotive 41: manipulate 42: metabolite 43: nicotinamide 44: oratorical 45: paragonite 46: pejorative 47: peridotite 48: peripatetic 49: polarimeter 50: recitative 51: recuperate 52: rehabilitate 53: rejuvenate 54: remunerate 55: repetitive 56: reticulate 57: savonarola 58: similitude 59: solicitude 60: tananarive 61: telekinesis 62: teratogenic 63: topologize 64: unilateral 65: unimodular 66: uninominal 67: verisimilitude
Haskell
<lang haskell>import Control.Monad (join) import Data.Bifunctor (bimap) import Data.List.Split (chunksOf)
WORDS WITH ALTERNATING VOWELS AND CONSONANTS -----
isLongAlternator :: String -> Bool isLongAlternator s =
9 < length s && all alternating (zip s $ tail s)
alternating :: (Char, Char) -> Bool alternating = uncurry (/=) . join bimap isVowel
isVowel :: Char -> Bool isVowel = flip elem "aeiou"
TEST -------------------------
main :: IO () main =
readFile "unixdict.txt" >>= mapM_ putStrLn . ( ((:) . (<> " matching words:\n") . show . length) <*> inColumns 4 ) . filter isLongAlternator . lines
FORMATTING ----------------------
inColumns :: Int -> [String] -> [String] inColumns n xs = unwords <$> chunksOf n (justifyLeft w ' ' <$> xs)
where w = maximum (length <$> xs)
justifyLeft :: Int -> Char -> String -> String justifyLeft n c s = take n (s <> replicate n c)</lang>
- Output:
67 matching words: aboriginal apologetic bimolecular borosilicate calorimeter capacitate capacitive capitoline capitulate caricature colatitude coloratura colorimeter debilitate decelerate decolonize definitive degenerate deliberate demodulate denominate denotative deregulate desiderata desideratum dilapidate diminutive epigenetic facilitate hemosiderin heretofore hexadecimal homogenate inoperative judicature latitudinal legitimate lepidolite literature locomotive manipulate metabolite nicotinamide oratorical paragonite pejorative peridotite peripatetic polarimeter recitative recuperate rehabilitate rejuvenate remunerate repetitive reticulate savonarola similitude solicitude tananarive telekinesis teratogenic topologize unilateral unimodular uninominal verisimilitude
JavaScript
As a standard for an embedded language which may have no access to a file-system, ECMAScript doesn't define any syntax or types for file operations.
This draft defines a readFile function for the Automation library of a macOS osascript instance of a JSContext.
<lang javascript>(() => {
'use strict';
// -- WORDS WITH ALTERNATING VOWELS AND CONSONANTS ---
// isLongAlternator :: String -> Bool const isLongAlternator = s => 9 < s.length && all( ab => isVowel(ab[0]) !== isVowel(ab[1]) )( zip(s)(s.slice(1)) );
// isVowel :: Char -> Bool const isVowel = c => 'aeiou'.includes(c);
// ---------------------- TEST ----------------------- // main :: IO () const main = () => { const matches = lines( readFile('unixdict.txt') ).filter(isLongAlternator);
return `${matches.length} matches:\n\n` + ( inColumns(4)(matches) ); };
// ------------------- FORMATTING --------------------
// inColumns :: Int -> [String] -> String const inColumns = n => xs => ( w => unlines( chunksOf(n)( xs.map(justifyLeft(w)(' ')) ) .map(unwords) ) )( maximum(xs.map(length)) );
// --------------------- GENERIC ---------------------
// Tuple (,) :: a -> b -> (a, b) const Tuple = a => b => ({ type: 'Tuple', '0': a, '1': b, length: 2 });
// all :: (a -> Bool) -> [a] -> Bool const all = p => // True if p(x) holds for every x in xs. xs => [...xs].every(p);
// chunksOf :: Int -> [a] -> a const chunksOf = n => { // xs split into sublists of length n. // The last sublist will be short if n // does not evenly divide the length of xs . const go = xs => { const chunk = xs.slice(0, n), rest = xs.slice(n); return 0 < chunk.length ? ( [chunk].concat(go(rest)) ) : []; }; return go; };
// justifyLeft :: Int -> Char -> String -> String const justifyLeft = n => // The string s, followed by enough padding (with // the character c) to reach the string length n. c => s => n > s.length ? ( s.padEnd(n, c) ) : s;
// length :: [a] -> Int const length = xs => // Returns Infinity over objects without finite // length. This enables zip and zipWith to choose // the shorter argument when one is non-finite, // like cycle, repeat etc 'GeneratorFunction' !== xs.constructor .constructor.name ? ( xs.length ) : Infinity;
// lines :: String -> [String] const lines = s => // A list of strings derived from a single // string delimited by newline and or CR. 0 < s.length ? ( s.split(/[\r\n]+/) ) : [];
// list :: StringOrArrayLike b => b -> [a] const list = xs => // xs itself, if it is an Array, // or an Array derived from xs. Array.isArray(xs) ? ( xs ) : Array.from(xs || []);
// maximum :: Ord a => [a] -> a const maximum = xs => ( // The largest value in a non-empty list. ys => 0 < ys.length ? ( ys.slice(1).reduce( (a, y) => y > a ? ( y ) : a, ys[0] ) ) : undefined )(list(xs));
// readFile :: FilePath -> IO String const readFile = fp => { // The contents of a text file at the // filepath fp. const e = $(), ns = $.NSString .stringWithContentsOfFileEncodingError( $(fp).stringByStandardizingPath, $.NSUTF8StringEncoding, e ); return ObjC.unwrap( ns.isNil() ? ( e.localizedDescription ) : ns ); };
// unlines :: [String] -> String const unlines = xs => // A single string formed by the intercalation // of a list of strings with the newline character. xs.join('\n');
// unwords :: [String] -> String const unwords = xs => // A space-separated string derived // from a list of words. xs.join(' ');
// zip :: [a] -> [b] -> [(a, b)] const zip = xs => // The paired members of xs and ys, up to // the length of the shorter of the two lists. ys => Array.from({ length: Math.min(xs.length, ys.length) }, (_, i) => Tuple(xs[i])(ys[i]));
// MAIN --- return main();
})();</lang>
- Output:
67 matches: aboriginal apologetic bimolecular borosilicate calorimeter capacitate capacitive capitoline capitulate caricature colatitude coloratura colorimeter debilitate decelerate decolonize definitive degenerate deliberate demodulate denominate denotative deregulate desiderata desideratum dilapidate diminutive epigenetic facilitate hemosiderin heretofore hexadecimal homogenate inoperative judicature latitudinal legitimate lepidolite literature locomotive manipulate metabolite nicotinamide oratorical paragonite pejorative peridotite peripatetic polarimeter recitative recuperate rehabilitate rejuvenate remunerate repetitive reticulate savonarola similitude solicitude tananarive telekinesis teratogenic topologize unilateral unimodular uninominal verisimilitude
Julia
See Alternade_words#Julia for the foreachword function. <lang julia>isvowel(c) = c in ['a', 'e', 'i', 'o', 'u'] # NB. leaves out 'α' and similar unicode vowels, and what about y? onlyodds(f, s) = all(c -> f(c), s[1:2:length(s)]) && !any(c -> f(c), s[2:2:length(s)]) onlyevens(f, s) = !any(c -> f(c), s[1:2:length(s)]) && all(c -> f(c), s[2:2:length(s)]) eitheronlyvowels(w, _) = onlyodds(isvowel, w) || onlyevens(isvowel, w) ? w : ""
foreachword("unixdict.txt", eitheronlyvowels, minlen = 10)
</lang>
- Output:
Word source: unixdict.txt aboriginal apologetic bimolecular borosilicate calorimeter capacitate capacitive capitoline capitulate caricature colatitude coloratura colorimeter debilitate decelerate decolonize definitive degenerate deliberate demodulate denominate denotative deregulate desiderata desideratum dilapidate diminutive epigenetic facilitate hemosiderin heretofore hexadecimal homogenate inoperative judicature latitudinal legitimate lepidolite literature locomotive manipulate metabolite nicotinamide oratorical paragonite pejorative peridotite peripatetic polarimeter recitative recuperate rehabilitate rejuvenate remunerate repetitive reticulate savonarola similitude solicitude tananarive telekinesis teratogenic topologize unilateral unimodular uninominal verisimilitude
Perl
Translated from AWK
Used a2p.
<lang Perl># 20210104 added Perl programming solution
use strict; use warnings;
my $alternatingCount = 0;
while (<>) {
(my $Fld1) = split(' ', $_, -1); if ((length($Fld1) >= 10)) { # have an arpropriate length word my $word = $Fld1; my $haveVowel = $word =~ /^[aeiou]/; my $isAlternating = 1; for (my $wPos = 2; $isAlternating && $wPos <= length($word); $wPos++) { my $hadVowel = $haveVowel; $haveVowel = substr($word, ($wPos)-1, 1) =~ /^[aeiou]/; $isAlternating = ($hadVowel && !$haveVowel) || (!$hadVowel && $haveVowel); } # for wPos if ($isAlternating) { printf ' %16s%s', $word, ($alternatingCount % 6 == 5) ? "\n" : ; $alternatingCount += 1; } # if isAlternating }
}
printf "\n%d words with alternating vowels and consonants found\n", $alternatingCount;</lang>
- Output:
aboriginal apologetic bimolecular borosilicate calorimeter capacitate capacitive capitoline capitulate caricature colatitude coloratura colorimeter debilitate decelerate decolonize definitive degenerate deliberate demodulate denominate denotative deregulate desiderata desideratum dilapidate diminutive epigenetic facilitate hemosiderin heretofore hexadecimal homogenate inoperative judicature latitudinal legitimate lepidolite literature locomotive manipulate metabolite nicotinamide oratorical paragonite pejorative peridotite peripatetic polarimeter recitative recuperate rehabilitate rejuvenate remunerate repetitive reticulate savonarola similitude solicitude tananarive telekinesis teratogenic topologize unilateral unimodular uninominal verisimilitude 67 words with alternating vowels and consonants found
Regex solution
I've heard rumors that there are more than 5 vowels... <lang perl>$vowels = 'aeiou'; $v = qr/[$vowels]/; $c = qr/[^$vowels]/;
/^ ( ($c$v)+ $c? | ($v$c)+ $v? ) $/ix and say for grep { /.{10}/ } split "\n", do { (@ARGV, $/) = 'unixdict.txt'; <> };</lang>
- Output:
aboriginal apologetic bimolecular ... verisimilitude
Phix
Not even slightly challenging, or in any way possibly ever useful, or the slightest bit interesting.... Yawneroo. <lang Phix>function odd(integer idx) return remainder(idx,2)=1 end function function vowel(integer ch) return find(ch,"aeiou")!=0 end function function oddeven(string word)
if length(word)<=9 then return false end if sequence consonants = apply(word,vowel), ohoneohone = apply(tagset(length(word)),odd) return find(consonants,{ohoneohone,sq_not(ohoneohone)})
end function sequence words = filter(get_text("demo/unixdict.txt",GT_LF_STRIPPED),oddeven) printf(1,"%d avac words found: %s\n",{length(words),join(shorten(words,"",3),", ")})</lang>
- Output:
67 avac words found: aboriginal, apologetic, bimolecular, ..., unimodular, uninominal, verisimilitude
Plain English
<lang plainenglish>To run: Start up. Put "c:\unixdict.txt" into a path. Read the path into a buffer. Slap a rider on the buffer. Loop. Move the rider (text file rules). Subtract 1 from the rider's token's last. \remove the newline Put the rider's token into a word string. If the word is blank, break. If the word's length is less than 10, repeat. If the word is alternating between vowels and consonants, write the word on the console. Repeat. Wait for the escape key. Shut down.
To decide if a string is alternating between vowels and consonants: Slap a substring on the string. Put the substring's first plus 1 into the substring's last. Loop. If the substring's last's target is noise, say yes. If the substring is double, say no. Add 1 to the substring's first. Add 1 to the substring's last. Repeat.
To decide if a string is double: If the string's first's target is any consonant, set a flag. If the string's last's target is any consonant, set another flag. If the flag is the other flag, say yes. Say no.</lang>
- Output:
aboriginal apologetic bimolecular borosilicate calorimeter capacitate capacitive capitoline capitulate caricature colatitude coloratura colorimeter debilitate decelerate decolonize definitive degenerate deliberate demodulate denominate denotative deregulate desiderata desideratum dilapidate diminutive epigenetic facilitate hemosiderin heretofore hexadecimal homogenate inoperative judicature latitudinal legitimate lepidolite literature locomotive manipulate metabolite nicotinamide oratorical paragonite pejorative peridotite peripatetic polarimeter recitative recuperate rehabilitate rejuvenate remunerate repetitive reticulate savonarola similitude solicitude tananarive telekinesis teratogenic topologize unilateral unimodular uninominal verisimilitude
Python
<lang python>Words with alternating vowels and consonants
- isLongAlternator :: String -> Bool
def isLongAlternator(s):
True if s has 10 or more characters, and no two successive characters that are both vowels, or both consonants. def p(a, b): return isVowel(a) != isVowel(b) return 9 < len(s) and all(map(p, s, s[1:]))
def isVowel(c):
True if c is in the set {a, e, i, o, u} return c in 'aeiou'
- ------------------------- TEST -------------------------
- main :: IO ()
def main():
Words without successive vowels or consonants found in the file 'unixdict.txt' matches = [ x for x in readFile('unixdict.txt').splitlines() if isLongAlternator(x) ] w = max(len(x) for x in matches) print(str(len(matches)) + ' matching words:\n') print( '\n'.join( ' '.join(s) for s in chunksOf(4)([ x.ljust(w, ' ') for x in matches ]) ) )
- ----------------------- GENERIC ------------------------
- chunksOf :: Int -> [a] -> a
def chunksOf(n):
A series of lists of length n, subdividing the contents of xs. Where the length of xs is not evenly divible, the final list will be shorter than n. def go(xs): return ( xs[i:n + i] for i in range(0, len(xs), n) ) if 0 < n else None return go
- readFile :: FilePath -> IO String
def readFile(fp):
The contents of any file at the path. with open(fp, 'r', encoding='utf-8') as f: return f.read()
- MAIN ---
if __name__ == '__main__':
main()</lang>
- Output:
67 matching words: aboriginal apologetic bimolecular borosilicate calorimeter capacitate capacitive capitoline capitulate caricature colatitude coloratura colorimeter debilitate decelerate decolonize definitive degenerate deliberate demodulate denominate denotative deregulate desiderata desideratum dilapidate diminutive epigenetic facilitate hemosiderin heretofore hexadecimal homogenate inoperative judicature latitudinal legitimate lepidolite literature locomotive manipulate metabolite nicotinamide oratorical paragonite pejorative peridotite peripatetic polarimeter recitative recuperate rehabilitate rejuvenate remunerate repetitive reticulate savonarola similitude solicitude tananarive telekinesis teratogenic topologize unilateral unimodular uninominal verisimilitude
Raku
Sigh. Yet another "Filter a word list" task. In a effort to make it a little more interesting, rather than just doing a one-liner, build a grammar and use that to filter.
<lang perl6>grammar VOWCON {
token TOP { <|w> <vowel>? ( <consonant> <vowel> )* <consonant>? <|w> } token vowel { <[aeiou]> } token consonant { <[a..z] - [aeiou]> }
}
say ( grep { VOWCON.parse: .lc }, grep { .chars > 9 }, 'unixdict.txt'.IO.words ).batch(6)».fmt('%-15s').join: "\n";</lang>
- Output:
aboriginal apologetic bimolecular borosilicate calorimeter capacitate capacitive capitoline capitulate caricature colatitude coloratura colorimeter debilitate decelerate decolonize definitive degenerate deliberate demodulate denominate denotative deregulate desiderata desideratum dilapidate diminutive epigenetic facilitate hemosiderin heretofore hexadecimal homogenate inoperative judicature latitudinal legitimate lepidolite literature locomotive manipulate metabolite nicotinamide oratorical paragonite pejorative peridotite peripatetic polarimeter recitative recuperate rehabilitate rejuvenate remunerate repetitive reticulate savonarola similitude solicitude tananarive telekinesis teratogenic topologize unilateral unimodular uninominal verisimilitude
REXX
<lang rexx>/*REXX program finds all the caseless words (within an identified dictionary) that */ /*───────── either have odd letters that are vowels, and even letters that consonants, */ /*───────── or vice versa. */ parse arg minL iFID . /*obtain optional arguments from the CL*/ if minL== | minL=="," then minL= 10 /*Not specified? Then use the default.*/ if iFID== | iFID=="," then iFID='unixdict.txt' /* " " " " " " */
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; upper x /*save: original case and the semaphore*/ end /*#*/ /* [↑] semaphore name is uppercased. */
- = # - 1 /*adjust the record count (DO loop). */
say copies('─', 30) # "words in the dictionary file: " iFID say finds= 0 /*count of the words found (so far). */ vow= 'AEIOU' /*the list of vowels. */ con= 'BCDFGHJKLMNPQRSTVWXYZ' /* " " " consonants. */ @@@= /* " " " words found (so far). */ w= 0 /*the maximum length of any word found.*/
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 /*obtain a word; uppercase it. */ ovec= 1; ocev= 1 /*initialize both test cases as passed.*/
do ov=1 by 2 to L /*only scan odd indexed letters in word*/ z= substr(y, ov, 1) /*examine the odd letters in the word. */ if verify(z, vow)>0 then ovec= 0 /*Odd letter not a vowel? Then flunk. */ end /*k*/
do ev=2 by 2 to L /*only scan eve indexed letters in word*/ z= substr(y, ev, 1) /*examine the odd letters in the word. */ if verify(z, con)>0 then ovec= 0 /*Even letter not a consonant? Flunk. */ end /*k*/
do oc=1 by 2 to L /*only scan odd indexed letters in word*/ z= substr(y, oc, 1) /*examine the odd letters in the word. */ if verify(z, con)>0 then ocev= 0 /*Odd letter not a consonant? Flunk. */ end /*k*/
do ec=2 by 2 to L /*only scan eve indexed letters in word*/ z= substr(y, ec, 1) /*examine the odd letters in the word. */ if verify(z, vow)>0 then ocev= 0 /*Even letter not a vowel? Then flunk.*/ end /*k*/
if ovec==0 & ocev==0 then iterate /*Did the word pass any test? No, skip*/ finds= finds + 1 /*bump the count of "odd words" found. */ w= max(w, L) /*obtain the maximum length word found.*/ @@@= @@@ $.j /*add a word to the list of words found*/ end /*j*/ /*stick a fork in it, we're all done. */
say copies('─', 30) finds ' words found with a minimum length of ' minL _=
do out=1 for finds; z= word(@@@, out) /*build a list that will be displayed. */ if length(_ right(z, w))>130 then do; say substr(_, 2); _=; end /*show a line.*/ _= _ right(z, w) /*append (aligned word) to output line.*/ end /*out*/
if _\== then say substr(_, 2) /*Any residual words? Then show a line*/</lang>
- output when using the default inputs:
────────────────────────────── 25104 words in the dictionary file: unixdict.txt ────────────────────────────── 67 words found with a minimum length of 10 aboriginal apologetic bimolecular borosilicate calorimeter capacitate capacitive capitoline capitulate caricature colatitude coloratura colorimeter debilitate decelerate decolonize definitive degenerate deliberate demodulate denominate denotative deregulate desiderata desideratum dilapidate diminutive epigenetic facilitate hemosiderin heretofore hexadecimal homogenate inoperative judicature latitudinal legitimate lepidolite literature locomotive manipulate metabolite nicotinamide oratorical paragonite pejorative peridotite peripatetic polarimeter recitative recuperate rehabilitate rejuvenate remunerate repetitive reticulate savonarola similitude solicitude tananarive telekinesis teratogenic topologize unilateral unimodular uninominal verisimilitude
Ring
<lang ring> cStr = read("unixdict.txt") wordList = str2list(cStr) words = [] num = 0 vowels = "aeiou" consonants = "bcdfghjklmnpqrstvwxyz"
see "working..." + nl
ln = len(wordList) for n = ln to 1 step -1
if len(wordList[n]) < 10 del(wordList,n) ok
next
see "Words are:" + nl + nl
for n = 1 to len(wordList)
cflag = 0 vflag = 0 len = len(wordList[n]) for m = 1 to len if m % 2 = 1 cons = substr(consonants,wordList[n][m]) if cons > 0 cflag = 1 else cflag = 0 exit ok ok if m % 2 = 0 cons = substr(vowels,wordList[n][m]) if cons > 0 vflag = 1 else vflag = 0 exit ok ok next if cflag = 1 and vflag = 1 add(words,wordList[n]) ok
next
for n = 1 to len(wordList)
cflag = 0 vflag = 0 len = len(wordList[n]) for m = 1 to len if m % 2 = 1 cons = substr(vowels,wordList[n][m]) if cons > 0 cflag = 1 else cflag = 0 exit ok ok if m % 2 = 0 cons = substr(consonants,wordList[n][m]) if cons > 0 vflag = 1 else vflag = 0 exit ok ok next if cflag = 1 and vflag = 1 add(words,wordList[n]) ok
next
words = sort(words)
for n = 1 to len(words)
see "" + n + ". " + words[n] + nl
next
see "done..." + nl </lang> Output:
working... Words are: 1. aboriginal 2. apologetic 3. bimolecular 4. borosilicate 5. calorimeter 6. capacitate 7. capacitive 8. capitoline 9. capitulate 10. caricature 11. colatitude 12. coloratura 13. colorimeter 14. debilitate 15. decelerate 16. decolonize 17. definitive 18. degenerate 19. deliberate 20. demodulate 21. denominate 22. denotative 23. deregulate 24. desiderata 25. desideratum 26. dilapidate 27. diminutive 28. epigenetic 29. facilitate 30. hemosiderin 31. heretofore 32. hexadecimal 33. homogenate 34. inoperative 35. judicature 36. latitudinal 37. legitimate 38. lepidolite 39. literature 40. locomotive 41. manipulate 42. metabolite 43. nicotinamide 44. oratorical 45. paragonite 46. pejorative 47. peridotite 48. peripatetic 49. polarimeter 50. recitative 51. recuperate 52. rehabilitate 53. rejuvenate 54. remunerate 55. repetitive 56. reticulate 57. savonarola 58. similitude 59. solicitude 60. tananarive 61. telekinesis 62. teratogenic 63. topologize 64. unilateral 65. unimodular 66. uninominal 67. verisimilitude done...
Ruby
<lang ruby>VOWELS =%w(a e i o u).map(&:freeze)
res = File.open("unixdict.txt").each_line.select do |line|
word = line.chomp word.size > 9 && word.chars.each_cons(2).all?{|c1, c2| VOWELS.include?(c1) != VOWELS.include?(c2) }
end puts res</lang>
- Output:
aboriginal apologetic bimolecular borosilicate calorimeter capacitate capacitive capitoline capitulate caricature colatitude coloratura colorimeter debilitate decelerate decolonize definitive degenerate deliberate demodulate denominate denotative deregulate desiderata desideratum dilapidate diminutive epigenetic facilitate hemosiderin heretofore hexadecimal homogenate inoperative judicature latitudinal legitimate lepidolite literature locomotive manipulate metabolite nicotinamide oratorical paragonite pejorative peridotite peripatetic polarimeter recitative recuperate rehabilitate rejuvenate remunerate repetitive reticulate savonarola similitude solicitude tananarive telekinesis teratogenic topologize unilateral unimodular uninominal verisimilitude
Swift
<lang swift>import Foundation
func isVowel(_ char: Character) -> Bool {
switch (char) { case "a", "A", "e", "E", "i", "I", "o", "O", "u", "U": return true default: return false }
}
do {
let words = try String(contentsOfFile: "unixdict.txt", encoding: String.Encoding.ascii) var n = 1 for word in words.components(separatedBy: "\n") { if word.count <= 9 { continue } var isOddEvenWord = true var prev: Character = "\n" for ch in word { if prev != "\n" && isVowel(ch) == isVowel(prev) { isOddEvenWord = false break } prev = ch } if isOddEvenWord { print("\(String(format: "%2d", n)): \(word)") n += 1 } }
} catch {
print(error.localizedDescription)
}</lang>
- Output:
1: aboriginal 2: apologetic 3: bimolecular 4: borosilicate 5: calorimeter 6: capacitate 7: capacitive 8: capitoline 9: capitulate 10: caricature 11: colatitude 12: coloratura 13: colorimeter 14: debilitate 15: decelerate 16: decolonize 17: definitive 18: degenerate 19: deliberate 20: demodulate 21: denominate 22: denotative 23: deregulate 24: desiderata 25: desideratum 26: dilapidate 27: diminutive 28: epigenetic 29: facilitate 30: hemosiderin 31: heretofore 32: hexadecimal 33: homogenate 34: inoperative 35: judicature 36: latitudinal 37: legitimate 38: lepidolite 39: literature 40: locomotive 41: manipulate 42: metabolite 43: nicotinamide 44: oratorical 45: paragonite 46: pejorative 47: peridotite 48: peripatetic 49: polarimeter 50: recitative 51: recuperate 52: rehabilitate 53: rejuvenate 54: remunerate 55: repetitive 56: reticulate 57: savonarola 58: similitude 59: solicitude 60: tananarive 61: telekinesis 62: teratogenic 63: topologize 64: unilateral 65: unimodular 66: uninominal 67: verisimilitude
Wren
<lang ecmascript>import "io" for File import "/fmt" for Fmt
var isVowel = Fn.new { |c| "aeiou".contains(c) }
var wordList = "unixdict.txt" // local copy var words = File.read(wordList).trimEnd().split("\n").where { |w| w.count > 9 } var count = 0 System.print("Words with alternate consonants and vowels in %(wordList):\n") for (word in words) {
var found = true for (i in 0...word.count) { var c = word[i] if ((i%2 == 0 && isVowel.call(c)) || (i%2 == 1 && !isVowel.call(c))) { found = false break } } if (!found) { found = true for (i in 0...word.count) { var c = word[i] if ((i%2 == 0 && !isVowel.call(c)) || (i%2 == 1 && isVowel.call(c))) { found = false break } } } if (found) { count = count + 1 Fmt.print("$2d: $s", count, word) }
}</lang>
- Output:
Words with alternate consonants and vowels in unixdict.txt: 1: aboriginal 2: apologetic 3: bimolecular 4: borosilicate 5: calorimeter 6: capacitate 7: capacitive 8: capitoline 9: capitulate 10: caricature 11: colatitude 12: coloratura 13: colorimeter 14: debilitate 15: decelerate 16: decolonize 17: definitive 18: degenerate 19: deliberate 20: demodulate 21: denominate 22: denotative 23: deregulate 24: desiderata 25: desideratum 26: dilapidate 27: diminutive 28: epigenetic 29: facilitate 30: hemosiderin 31: heretofore 32: hexadecimal 33: homogenate 34: inoperative 35: judicature 36: latitudinal 37: legitimate 38: lepidolite 39: literature 40: locomotive 41: manipulate 42: metabolite 43: nicotinamide 44: oratorical 45: paragonite 46: pejorative 47: peridotite 48: peripatetic 49: polarimeter 50: recitative 51: recuperate 52: rehabilitate 53: rejuvenate 54: remunerate 55: repetitive 56: reticulate 57: savonarola 58: similitude 59: solicitude 60: tananarive 61: telekinesis 62: teratogenic 63: topologize 64: unilateral 65: unimodular 66: uninominal 67: verisimilitude