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

{{trans|Python}}

‘ true if c is an English vowel (ignore y) ’

R c C (‘a’, ‘e’, ‘i’, ‘o’, ‘u’, ‘A’, ‘E’, ‘I’, ‘O’, ‘U’)

V s = ‘Now is the time for all good men to come to the aid of their country.’

V (vcnt, ccnt, vu, cu) = vccounts(s)

{{out}}

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

BYTE i

CHAR c

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

Test("Forever Action! programming language")

{{out}}

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

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

</pre>

=={{header|Applesoft BASIC}}==

110 FOR I = 0 TO 3

120 FOR V = 1 TO 5

450 N = N + C( ASC ( MID$ (S$,I,1)))

460 NEXT I

=={{header|Arturo}}==

cRe: {/[bcdfghjklmnpqrstvwxyz]/}

print ["Found" size vowels "vowels -" size unique vowels "unique"]

{{out}}

=={{header|AutoHotkey}}==

oV:= [], oC := [], v := c := o := 0

for i, ch in StrSplit(str)

MsgBox % result := str "`n`n" v+c+o " characters, " v " vowels, " c " consonants and " o " other"

{{out}}

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

=={{header|AWK}}==

# syntax: GAWK -f COUNT_HOW_MANY_VOWELS_AND_CONSONANTS_OCCUR_IN_A_STRING.AWK

BEGIN {

exit(0)

}

{{out}}

<pre>

=={{header|BCPL}}==

let ucase(c) =

let start() be

{{out}}

<pre>'If not now, then when? If not us, then who?': 10 vowels, 20 consonants.</pre>

=={{header|C}}==

https://rosettacode.org/wiki/Count_how_many_vowels_and_consonants_occur_in_a_string

{{out}}

<pre>

=={{header|CLU}}==

if c>='a' & c<='z' then return(char$i2c(char$c2i(c)-32))

else return(c)

start_up = proc ()

example("If not now, then when? If not us, then who?")

{{out}}

<pre>"If not now, then when? If not us, then who?": 10 vowels, 20 consonants.</pre>

=={{header|COBOL}}==

PROGRAM-ID. VOWELS-AND-CONSONANTS.

COUNT-CONSONANT.

INSPECT IN-STR TALLYING N-CONSONANTS FOR ALL CONSONANTS(C).

{{out}}

<pre>If not now, then when? If not us, then who?

=={{header|Common Lisp}}==

(and (characterp c) (characterp (find c vowels :test #'char-equal))))

(defun count-consonants (s)

=={{header|Cowgol}}==

sub vowels_consonants(s: [uint8]): (vowels: intptr, consonants: intptr) is

end sub;

{{out}}

<pre>'If not now, then when? If not us, then who?': 10 vowels, 20 consonants.</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>

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

=={{header|FreeBASIC}}==

Dim As String cadena = """Forever the FreeBASIC programming language"""

Dim As Integer vocal = 0, consonante = 0

Print "In string occur"; vocal; " vowels"

Print "In string occur"; consonante; " consonants"

{{out}}

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

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

{{Out}}

<pre>33 'vowels and consonants'

Implementation (two tallies: vowels first, consonants second):

consonant=: (,toupper) (a.{~97+i.16) -. vowel

Examples:

22 18

vctally 'Forever Action! programming language'

=={{header|JavaScript}}==

===Count of "Vowels and Consonants" ?===

"use strict";

// MAIN ---

return main();

{{Out}}

<pre>33 "vowels and consonants"</pre>

===Counts of distinct vowels and distinct consonants seen ?===

"use strict";

// MAIN ---

return main();

{{Out}}

<pre>Distinct vowels: (aeiou, 5)

===Counts of vowel and consonant occurrences ?===

"use strict";

return main();

{{Out}}

<pre>Vowel occurrences: 12

===Counts of occurrence for each vowel and consonant ?===

"use strict";

// MAIN ---

return main();

{{Out}}

<pre>Vowel counts:

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>

=={{header|Julia}}==

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

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

testvccount()

<pre>

String: Forever Julia programming language

=={{header|Ksh}}==

#!/bin/ksh

printf "Consonants: %3d (Unique: %2d)\n" "${lettercnt[0]}" "${uniquecnt[0]}"

printf " Vowlels: %3d (Unique: %2d)\n" "${lettercnt[1]}" "${uniquecnt[1]}"

<pre>

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

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

conso = {"b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"};

vowels = Join[vowels, ToUpperCase@vowels];

<|"vowels" -> StringCount[str, Alternatives @@ vowels],

"consonants" -> StringCount[str, Alternatives @@ conso],

{{out}}

<pre><|"vowels" -> 22, "consonants" -> 24, "other" -> 11|></pre>

=={{header|Modula-2}}==

FROM InOut IMPORT WriteString, WriteCard, WriteLn;

FROM Strings IMPORT Length;

BEGIN

Display("If not now, then when? If not us, then who?");

{{out}}

<pre>"If not now, then when? If not us, then who?": 10 vowels, 20 consonants.</pre>

=={{header|Nim}}==

const

value(consonantCount, "consonant"))

{{out}}

=={{header|Pascal}}==

Standard “Unextended” Pascal (ISO standard 7185) does not really know the notion of strings:

var

writeLn(vowelCount, ' vowels');

writeLn(consonantCount, ' consonants')

{{in}}

The quick brown fox jumps over the lazy dog.

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

===List comprehension===

Also using maps for counting individual characters.

S = "Count how many vowels and consonants occur in a string",

vowels(Vowels),

foreach(C in S, (Cs != "" -> membchk(C,Cs) ; true))

Map.put(C,Map.get(C,0)+1)

{{out}}

===Recursion===

S = "Count how many vowels and consonants occur in a string",

vowels(Vowels),

Vs1 = Vs0

),

{{out}}

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

=={{header|Quackery}}==

[ 0 $ "AEIOUaeiuo"

witheach [ bit | ] ] constant

echo say " vowels" cr

{{out}}

'''OR''', depending on how you interpret the task…

witheach [ bit | ] ] constant is vowels ( --> n )

echo say " distinct vowels" cr

{{out}}

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

=={{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" + '"'

vowel = 0 vowels = [] for x in "AEIOUaeiou" add(vowels, x) next

? "In string occur " + vowel + " vowels"

? "In string occur " + (ltrc - vowel) + " consonants"

{{out}}

<pre>working...

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

=={{header|SNOBOL4}}==

{{works with|SNOBOL4, SPITBOL for Linux}}

* Program: countvc.sbl,

* To run: sbl countvc.sbl

END

{{out}}

<pre>

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