Count how many vowels and consonants occur in a string: Difference between revisions

<br><br>

 

 

=={{header|Ada}}==

This solution uses Ada 2012 aspect clauses to define discontinuous subtypes

-- count vowels and consonants in a string

--

("contains" & vowel_count'Image & " vowels and" & consonant_count'Image &

" consonants.");

{{out}}

<pre>

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

Showing total and distinct vowel/consonant counts, as in the Go, Wren etc. samples.

# returns the 0-based index of the upper case letter c in the alphabet #

# or -1 if c is not a letter #

print vc counts( "Now is the time for all good men to come to the aid of their country" );

print vc counts( "Help avoid turns" )

{{out}}

<pre>

5 vowels and 9 consonants (total)

</pre>

 

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

// Count how many vowels and consonants occur in a string. Nigel Galloway: August 1th., 202

type cType = Vowel |Consonant |Other

let n="Now is the time for all good men to come to the aid of their country."|>Seq.countBy(System.Char.ToLower>>fN)

printfn "%A" n

{{out}}

<pre>

seq [(Consonant, 31); (Vowel, 22); (Other, 16)]

</pre>

=={{header|Factor}}==

{{works with|Factor|0.99 2021-06-02}}

sequences ;

 

"Forever Factor programming language"

"Now is the time for all good men to come to the aid of their country."

{{out}}

<pre>

"Now is the time for all good men to come to the aid of their country."

-> H{ { "other" 16 } { "consonant" 31 } { "vowel" 22 } }

</pre>

 

=={{header|Go}}==

Same approach as the Wren entry.

 

import (

fmt.Printf("contains (distinct %d vowels and %d consonants.\n\n", len(vmap), len(cmap))

}

 

{{out}}

One of (at least) four possible meanings here:

 

import Data.Bifunctor (bimap, first, second)

import Data.Bool (bool)

if p

then t

{{Out}}

<pre>Unique vowels and consonants used, with counts:

Another of (at least) four possible meanings:

 

import Data.Bifunctor (bimap)

import Data.Char (isAlpha)

import qualified Data.Map.Strict as M

 

 

isVowel :: Char -> Bool

 

--------------------------- TEST -------------------------

<> fmap

('\t' :)

)

 

------------------------- GENERIC ------------------------

 

both :: (a -> b) -> (a, a) -> (b, b)

{{Out}}

<pre>33 'vowels and consonants'

('t',1)

('v',1)</pre>

 

=={{header|jq}}==

 

This entry focuses solely on the A-Z alphabet.

def is_lowercase_vowel: IN("a","e","i","o","u");

def is_lowercase_letter: "a" <= . and . <= "z";

| pp, "";

 

{{out}}

<pre>

}

</pre>

 

=={{header|Julia}}==

isletter(c) = 'a' <= c <= 'z' || 'A' <= c <= 'Z'

isconsonant(c) = !isvowel(c) && isletter(c)

 

testvccount()

<pre>

String: Forever Julia programming language

Consonants: 31 (distinct 13)

</pre>

 

=={{header|Nim}}==

 

const

value(consonantCount, "consonant"))

 

 

{{out}}

5 vowels and 13 consonants (distinct)

22 vowels and 31 consonants (total)</pre>

 

=={{header|Perl}}==

 

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

TEST ONE

Now is the time for all good men to come to the aid of their country.

{{out}}

<pre>

 

=={{header|Phix}}==

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

<span style="color: #008080;">procedure</span> <span style="color: #000000;">count_vowels_and_consonants</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>

<span style="color: #000000;">count_vowels_and_consonants</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"Now is the time for all good men to come to the aid of their country."</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

The string "Now is the time for all good men to come to the aid of their country."

contains 22 vowels (5 distinct), 31 consonants (13 distinct), and 16 other (2 distinct).

</pre>

 

=={{header|Python}}==

{{trans|Julia}}

""" true if c is an English vowel (ignore y) """

return c in ['a', 'e', 'i', 'o', 'u', 'A', 'E', "I", 'O', 'U']

 

testvccount()

String: Forever Python programming language

Vowels: 11 (distinct 5)

 

Or, selecting another of the various possible meanings of an ambiguous task description:

 

from functools import reduce

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>33 "vowels and consonants"

('t', 1)

('v', 1)</pre>

 

=={{header|Raku}}==

Note that the task '''does not''' ask for the '''total count''' of vowels and consonants, but for '''how many''' occur.

 

my @consonants = <b c d f g h j k l m n p q r s t v w x y z>;

 

}

 

 

{{out}}

<pre>5 vowels and 8 consonants occur in the string "Forever Ring Programming Language"</pre>

 

=={{header|REXX}}==

=== version 1 ===

Parse Arg s

If s='' Then

sv=translate(s,copies('+',length(vow))copies(' ',256),vow||xrange('00'x,'ff'x))

Say length(space(sc,0)) tag 'consonants,' length(space(sv,0)) tag 'vowels'

{{out}}

<pre>Forever Wren programming language

 

=== version 2 ===

parse arg $ /*obtain optional argument from the CL.*/

if $='' then $= 'Now is the time for all good men to come to the aid of their country.'

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

cnt: arg k; do j=1 to length(@.k); if pos(substr(@.k,j,1),$)>0 then #.k=#.k+1; end; return

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

<pre>

 

=={{header|Ring}}==

str = '"' + "Forever Ring Programming Language" + '"'

 

next

 

{{out}}

Input string = "Forever Ring Programming Language"

In string occur 11 vowels

In string occur 19 consonants

</pre>

 

=={{header|Ruby}}==

RE_C = /[bcdfghjklmnpqrstvwxyz]/

str = "Now is the time for all good men to come to the aid of their country."

 

grouped.each{|k,v| puts "#{k}: #{v.size}, #{v.uniq.size} unique."}

{{out}}

<pre>Consonants: 31, 13 unique.

Other: 16, 2 unique.

</pre>

=={{header|Wren}}==

{{libheader|Wren-str}}

In the absence of any indications to the contrary, we take a simplistic view of only considering English ASCII vowels (not 'y') and consonants.

 

var vowels = "aeiou"

System.print("contains (total) %(vc) vowels and %(cc) consonants.")

System.print("contains (distinct) %(vmap.count) vowels and %(cmap.count) consonants.\n")

 

{{out}}

=={{header|X86 Assembly}}==

Translation of XPL0. Assemble with tasm, tlink /t

.code

.486

msg4 db " consonants."

crlf db 0Dh, 0Ah, 0

 

{{out}}

 

=={{header|XPL0}}==

int VTC, VDC, \vowel total count, vowel distinct count

CTC, CDC, \consonant total count, consonant distinct count

CrLf(0);

];

 

{{out}}