Find words which contain the most consonants: Difference between revisions

{{Template:Strings}}

<br><br>

 

=={{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 FUNC ConsonantsCount(CHAR ARRAY word)

i==-1

OD

{{out}}

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

 

=={{header|Ada}}==

with Ada.Strings.Fixed;

with Ada.Containers.Indefinite_Vectors;

end loop;

 

{{out}}

<pre> 4 consonants: 3 words

9 consonants: 1 words

comprehensible</pre>

 

=={{header|ALGOL W}}==

% an element of a WordList %

record WordListElement ( string(32) w; reference(WordListElement) next );

end if_words_wPos_ne_null

end for_wPos

{{out}}

<pre>

audiovisual bourgeoisie onomatopoeia

</pre>

=={{header|Arturo}}==

 

vowels: ["a" "e" "i" "o" "u"]

 

print ""

]

 

{{out}}

 

=={{header|AutoHotkey}}==

vowels := ["a", "e", "i", "o", "u"]

oRes := []

result .= "`n`n"

}

{{out}}

<pre>9 Unique consonants, word count: 1

 

=={{header|AWK}}==

# syntax: GAWK -f FIND_WORDS_WHICH_CONTAINS_MOST_CONSONANTS.AWK unixdict.txt

#

exit(0)

}

{{out}}

<pre>

 

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

#include <cctype>

#include <cstdlib>

}

return EXIT_SUCCESS;

 

{{out}}

 

=={{header|CLU}}==

% of consonants. If it does have repeated consonants, return

% -1.

stream$putl(po, "")

end

{{out}}

<pre style='height:100ex;'>4 consonants - 3 words:

9 consonants - 1 words:

comprehensible</pre>

 

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

// Word(s) containing most consonants. Nigel Galloway: February 18th., 2021

let vowels=set['a';'e';'i';'o';'u']

let fN g=let g=g|>Seq.filter(vowels.Contains>>not)|>Array.ofSeq in if g=(g|>Array.distinct) then g.Length else 0

printfn "%A" (seq{use n=System.IO.File.OpenText("unixdict.txt") in while not n.EndOfStream do yield n.ReadLine()}|>Seq.filter(fun n->n.Length>10)|>Seq.groupBy fN|>Seq.sortBy fst|>Seq.last)

{{out}}

<pre>

 

=={{header|Factor}}==

prettyprint prettyprint.config sequences sets sets.extras ;

FROM: namespaces => set ;

[ [ "aeiou" member? not ] count ] collect-by >alist reverse

 

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

function uniq_cons( s as string ) as integer

dim letter( 1 to 26 ) as boolean

wend

 

 

=={{header|Go}}==

{{trans|Wren}}

 

import (

}

}

 

{{out}}

 

=={{header|Haskell}}==

 

-- Given a list of words on stdin, write to stdout the set of words having the

main :: IO ()

main = interact (unlines . mostDistinctConsonants . filter longEnough . words)

 

{{out}}

Or, in terms of Data.Set, choosing just one of various possible interpretations of an ambiguous task description.

 

import Data.Function (on)

import Data.List (groupBy, sortOn, (\\))

. take 1

. uniqueGlyphCounts consonants

{{Out}}

<pre>("bremsstrahlung",9)

or adjusting the test above to return only words which use no consonant twice:

 

main =

readFile "unixdict.txt"

. length

. filter (`S.member` consonants)

{{Out}}

<pre>("comprehensible",9)</pre>

 

=={{header|J}}==

 

=={{header|jq}}==

 

'''Preliminaries'''

def bow(stream):

reduce stream as $word ({}; .[($word|tostring)] += 1);

bow(explode[])

| all(.[]; . == 1);

'''The Tasks'''

 

def taskA:

taskB) ;

 

{{out}}

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

=={{header|Julia}}==

{{trans|Phix}}

singlec(consonants) = length(unique(consonants)) == length(consonants)

over10sc(word) = length(word) > 10 && singlec(filter(consonant, word))

println(length(res), " words found.\n\nWord Consonants\n----------------------")

foreach(a -> println(rpad(a[2], 16), -a[1]), res)

<pre>

347 words found.

 

=={{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[Characters[#], MemberQ[consonants, #] &]} & /@ dict;

dict //= Select[Last /* DuplicateFreeQ];

{{out}}

<pre>{audiovisual,bourgeoisie,onomatopoeia}

 

=={{header|Nim}}==

 

const Vowels = {'a', 'e', 'i', 'o', 'u'}

for i, word in results[n]:

stdout.write word.align(14), if (i + 1) mod 9 == 0: '\n' else: ' '

 

{{out}}

 

=={{header|Perl}}==

 

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

$most[$_] and printf "%d Unique consonants, word count: %d\n\n%s\n\n",

$_, $most[ $_ ] =~ tr/\n//, $most[ $_ ] =~ tr/\n/ /r =~ s/.{66}\K /\n/gr

{{out}}

<pre>

 

=={{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;">consonant</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">ch</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">return</span> <span style="color: #7060A8;">find</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ch</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"aeiou"</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">0</span> <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sort_columns</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</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;">over10sc</span><span style="color: #0000FF;">),</span><span style="color: #000000;">mostc</span><span style="color: #0000FF;">),{-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</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 most consonant words: %v\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)})</span>

<small>It does ''not'' escape me that the use of lambda expressions would make this ''slightly'' easier to write but ''much'' harder to comprehend...<br>

Admittedly adding a dozen or so line breaks to the above might (actually) improve matters, but I'm sure you'll cope somehow.</small>

=={{header|Python}}==

"Use Python," they say, "it's comprehensible," they say.

(x for x in ((n, [x[1] for x in l if x[0] == n]) for n in range(maxlen, -1, -1)) if x[1]))) if (maxlen := max(l := [(len(c), w)

for w in [l for l in [l.rstrip() for l in open('unixdict.txt')] if len(l) > 10 and all(c >= 'a' and c <= 'z' for c in l)]

{{out}}

<pre>9: comprehensible

 

The above is roughly equivalent to the following:

from collections import defaultdict

 

print(f'{k}: {len(v)} words')

else:

 

 

 

from itertools import groupby

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Words using largest sets of unique consonants:

Excluding words which reuse any consonants:

('comprehensible', 9)</pre>

 

=={{header|R}}==

Far and away the hardest part of this task is filtering down the dict until it only contains words with no repeated consonants. If we only had to find the word with the most consonants, this would be easy.

dictBig <- dict[nchar(dict) > 10]

consonants <- letters[!letters %in% c("a", "e", "i", "o", "u")]

cat("Biggest:", paste(biggestWords(0), collapse = ", "),

"\n \n Second biggest:", paste(biggestWords(1), collapse = ", "),

{{out}}

<pre>Read 25104 items

=={{header|Racket}}==

 

 

(define (consonant-count s)

group-with-max-consonant-count

(printf "with: ~a consonants in each word"

 

{{out}}

Hmm. Depends on how you define "most".

 

my @vowel = <a e i o u>;

my $vowel = rx/ @vowel /;

say "\nNumber found, ratio and list of words with the highest ratio of unique, unrepeated consonants to vowels:";

say +.value, ' @ ', $_ for 'unixdict.txt'.IO.slurp.words.grep( {.chars >= $min and so all(.comb.Bag{@consonant}) <= 1} )

{{out}}

<pre style="max-width:100%;">Minimum characters in a word: 11

 

It also allows the minimum length to be specified on the command line (CL) as well as the dictionary file identifier.

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

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

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

/*──────────────────────────────────────────────────────────────────────────────────────*/

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

 

 

=={{header|Ring}}==

load "stdlib.ring"

 

next

return aList

{{out}}

<pre>

 

done...

</pre>

 

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

var wordList = "unixdict.txt" // local copy

var s = (count == 1) ? "" : "s"

System.print("%(count) word%(s) found with %(i) unique consonants:")

System.print()

}

 

{{out}}

 

=={{header|XPL0}}==

int MaxCon, Con, Set, I, Ch;

char Word(25), MaxWord(25);

until Ch = EOF;

Text(0, MaxWord);

 

{{out}}