Remove vowels from a string: Difference between revisions
m
→{{header|EasyLang}}
Thundergnat (talk | contribs) m (→{{header|Raku}}: Remove redundant topicalizer) |
|||
| (143 intermediate revisions by 54 users not shown) | |||
Line 2:
Remove vowels from a string
{{Template:Strings}}
<br><br>
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">F exceptGlyphs(exclusions, s)
R s.filter(c -> c !C @exclusions).join(‘’)
V txt = ‘
Rosetta Code is a programming chrestomathy site.
The idea is to present solutions to the same
task in as many different languages as possible,
to demonstrate how languages are similar and
different, and to aid a person with a grounding
in one approach to a problem in learning another.’
print(exceptGlyphs(‘eau’, txt))</syntaxhighlight>
{{out}}
<pre>
Rostt Cod is progrmming chrstomthy sit.
Th id is to prsnt soltions to th sm
tsk in s mny diffrnt lnggs s possibl,
to dmonstrt how lnggs r similr nd
diffrnt, nd to id prson with gronding
in on pproch to problm in lrning nothr.
</pre>
=={{header|8080 Assembly}}==
<syntaxhighlight lang="8080asm"> org 100h
jmp demo
;;; Remove the vowels from the $-terminated string at [DE]
dvwl: push d ; Keep output pointer on stack
vwllp: ldax d ; Get current byte
inx d ; Advance input pointer
pop b ; Store at output pointer
stax b
cpi '$' ; Reached the end?
rz ; If so, stop
push b ; Put output pointer back on stack
lxi h,vwls ; Check against each vowel
ori 32 ; Make lowercase
mvi b,5 ; 5 vowels
vchk: cmp m ; Equal to current vowel?
jz vwllp ; Then overwrite with next character
inx h ; Check next vowel
dcr b ; Any vowels left?
jnz vchk
pop b ; Not a vowel, advance output pointer
inx b
push b
jmp vwllp
vwls: db 'aeiou' ; Vowels
;;; Use the routine to remove vowels from a string
demo: lxi d,string
call dvwl ; Remove vowels
lxi d,string
mvi c,9 ; Print using CP/M
jmp 5
string: db 'THE QUICK BROWN FOX jumps over the lazy dog$'</syntaxhighlight>
{{out}}
<pre>TH QCK BRWN FX jmps vr th lzy dg</pre>
=={{header|Action!}}==
<syntaxhighlight lang="action!">BYTE FUNC IsVovel(CHAR c)
CHAR ARRAY vovels="AEIOUaeiou"
BYTE i
FOR i=1 TO vovels(0)
DO
IF vovels(i)=c THEN
RETURN (1)
FI
OD
RETURN (0)
PROC RemoveVovels(CHAR ARRAY s,res)
BYTE i
CHAR c
res(0)=0
FOR i=1 TO s(0)
DO
c=s(i)
IF IsVovel(c)=0 THEN
res(0)==+1
res(res(0))=c
FI
OD
RETURN
PROC Test(CHAR ARRAY s)
CHAR ARRAY res(256)
RemoveVovels(s,res)
PrintE("Input:") PrintE(s)
PrintE("Output:") PrintE(res)
RETURN
PROC Main()
Test("The Quick Brown Fox Jumped Over the Lazy Dog's Back")
Test("Action! is a programming language for Atari 8-bit computer.")
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Remove_vowels_from_a_string.png Screenshot from Atari 8-bit computer]
<pre>
Input:
The Quick Brown Fox Jumped Over the Lazy Dog's Back
Output:
Th Qck Brwn Fx Jmpd vr th Lzy Dg's Bck
Input:
Action! is a programming language for Atari 8-bit computer.
Output:
ctn! s prgrmmng lngg fr tr 8-bt cmptr.
</pre>
=={{header|Ada}}==
<syntaxhighlight lang="ada">with Ada.Text_IO; use Ada.Text_IO;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
procedure Main is
subtype Vowel is Character with
Static_Predicate => Vowel in 'A' | 'E' | 'I' | 'O' | 'U' | 'a' | 'e' |
'i' | 'o' | 'u';
function Remove_Vowels (S : in String) return String is
Temp : Unbounded_String;
begin
for C of S loop
if C not in Vowel then
Append (Source => Temp, New_Item => C);
end if;
end loop;
return To_String (Temp);
end Remove_Vowels;
S1 : String := "The Quick Brown Fox Jumped Over the Lazy Dog's Back";
S2 : String := "DON'T SCREAM AT ME!!";
NV1 : String := Remove_Vowels (S1);
NV2 : String := Remove_Vowels (S2);
begin
Put_Line (S1);
Put_Line (NV1);
New_Line;
Put_Line (S2);
Put_Line (NV2);
end Main;
</syntaxhighlight>
{{output}}
<pre>
The Quick Brown Fox Jumped Over the Lazy Dog's Back
Th Qck Brwn Fx Jmpd vr th Lzy Dg's Bck
DON'T SCREAM AT ME!!
DN'T SCRM T M!!
</pre>
=={{header|ALGOL 68}}==
<
# returns s with the vowels removed #
OP DEVOWEL = ( STRING s )STRING:
Line 28 ⟶ 191:
test devowel( "abcdefghijklmnoprstuvwxyz" );
test devowel( "Algol 68 Programming Language" )
END</
{{out}}
<pre>
Line 36 ⟶ 199:
<abcdefghijklmnoprstuvwxyz> -> <bcdfghjklmnprstvwxyz>
<Algol 68 Programming Language> -> <lgl 68 Prgrmmng Lngg>
</pre>
=={{header|APL}}==
<syntaxhighlight lang="apl">devowel ← ~∘'AaEeIiOoUu'</syntaxhighlight>
{{out}}
<pre> devowel 'THE QUICK BROWN FOX jumps over the lazy dog'
TH QCK BRWN FX jmps vr th lzy dg</pre>
=={{header|AppleScript}}==
===Functional===
Removing three particular Anglo-Saxon vowels from a text.
AppleScript doesn't provide list comprehensions, and even use of regular expressions requires the study of a Foreign Function Interface to ObjC, which might be thought to defeat the goals of an entry-level scripting language.
We can at least use the universally available list monad (using a general '''concatMap''' as the bind operator here, and returning an empty list in place of any excluded glyph).
We can also improve productivity by using library functions whenever feasible.
<syntaxhighlight lang="applescript">------- REMOVE A DEFINED SUBSET OF GLYPHS FROM A TEXT ------
-- exceptGlyphs :: String -> String -> Bool
on exceptGlyphs(exclusions, s)
script go
on |λ|(c)
if exclusions contains c then
{}
else
{c}
end if
end |λ|
end script
concatMap(go, s)
end exceptGlyphs
-- Or, in terms of a general filter function:
-- exceptGlyphs2 :: String -> String -> Bool
on exceptGlyphs2(exclusions, s)
script p
on |λ|(c)
exclusions does not contain c
end |λ|
end script
filter(p, s)
end exceptGlyphs2
---------------------------- TEST --------------------------
on run
set txt to unlines({¬
"Rosetta Code is a programming chrestomathy site. ", ¬
"The idea is to present solutions to the same ", ¬
"task in as many different languages as possible, ", ¬
"to demonstrate how languages are similar and ", ¬
"different, and to aid a person with a grounding ", ¬
"in one approach to a problem in learning another."})
exceptGlyphs("eau", txt)
end run
--------------------- LIBRARY FUNCTIONS --------------------
-- concatMap :: (a -> [b]) -> [a] -> [b]
on concatMap(f, xs)
set lng to length of xs
set acc to {}
tell mReturn(f)
repeat with i from 1 to lng
set acc to acc & (|λ|(item i of xs, i, xs))
end repeat
end tell
if {text, string} contains class of xs then
acc as text
else
acc
end if
end concatMap
-- filter :: (a -> Bool) -> [a] -> [a]
on filter(p, xs)
tell mReturn(p)
set lst to {}
set lng to length of xs
repeat with i from 1 to lng
set v to item i of xs
if |λ|(v, i, xs) then set end of lst to v
end repeat
if {text, string} contains class of xs then
lst as text
else
lst
end if
end tell
end filter
-- 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
-- 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</syntaxhighlight>
{{Out}}
<pre>Rostt Cod is progrmming chrstomthy sit.
Th id is to prsnt soltions to th sm
tsk in s mny diffrnt lnggs s possibl,
to dmonstrt how lnggs r similr nd
diffrnt, nd to id prson with gronding
in on pproch to problm in lrning nothr.</pre>
----
===Idiomatic===
As has been noted on the Discussion page, this is necessarily a parochial task which depends on the natural language involved being written with vowels and consonants and on what constitutes a vowel in its orthography. w and y are vowels in Welsh, but consonants in English, although y is often used as a vowel in English too, as it is in other languages. The code below demonstrates how AppleScript might remove the five English vowels and their diacritical forms from a Latinate text. AppleScript can be made to "ignore" diacriticals and case in string comparisons, but not to ignore ligatures or other variations which aren't strictly speaking diacriticals, such as ø. These would need to be included in the vowel list explicitly.
<syntaxhighlight lang="applescript">-- Bog-standard AppleScript global-search-and-replace handler.
-- searchText can be either a single string or a list of strings to be replaced with replacementText.
on replace(mainText, searchText, replacementText)
set astid to AppleScript's text item delimiters
set AppleScript's text item delimiters to searchText
set textItems to mainText's text items
set AppleScript's text item delimiters to replacementText
set editedText to textItems as text
set AppleScript's text item delimiters to astid
return editedText
end replace
-- Demo:
set txt to "The quick brown fox jumps over the lazy dog
L'œuvre d'un élève
van Dijk
\"The Death of Åse\"
São Paulo Győr Malmö Mjøsa
Jiří Bělohlávek conducts Martinů
Po co pan tak brzęczy w gąszczu?
Mahādeva"
ignoring diacriticals and case
set devowelledText to replace(txt, {"a", "e", "i", "o", "u"}, "")
end ignoring
return devowelledText</syntaxhighlight>
{{output}}
<syntaxhighlight lang="applescript">"Th qck brwn fx jmps vr th lzy dg
L'œvr d'n lv
vn Dijk
\"Th Dth f s\"
S Pl Gyr Mlm Mjøs
Jř Blhlvk cndcts Mrtn
P c pn tk brzczy w gszcz?
Mhdv"</syntaxhighlight>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">str: "Remove vowels from a string"
print str -- split "aeiouAEIOU"</syntaxhighlight>
{{out}}
<pre>Rmv vwls frm strng</pre>
=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">str := "The quick brown fox jumps over the lazy dog"
for i, v in StrSplit("aeiou")
str := StrReplace(str, v)
MsgBox % str</syntaxhighlight>
{{out}}
<pre>Th qck brwn fx jmps vr th lzy dg</pre>
===RegEx Version===
<syntaxhighlight lang="autohotkey">str := "The quick brown fox jumps over the lazy dog"
MsgBox % str := RegExReplace(str, "i)[aeiou]")</syntaxhighlight>
{{out}}
<pre>Th qck brwn fx jmps vr th lzy dg</pre>
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f REMOVE_VOWELS_FROM_A_STRING.AWK
BEGIN {
IGNORECASE = 1
arr[++n] = "The AWK Programming Language"
arr[++n] = "The quick brown fox jumps over the lazy dog"
for (i=1; i<=n; i++) {
str = arr[i]
printf("old: %s\n",str)
gsub(/[aeiou]/,"",str)
printf("new: %s\n\n",str)
}
exit(0)
}
</syntaxhighlight>
{{out}}
<pre>
old: The AWK Programming Language
new: Th WK Prgrmmng Lngg
old: The quick brown fox jumps over the lazy dog
new: Th qck brwn fx jmps vr th lzy dg
</pre>
=={{header|BASIC}}==
==={{header|Applesoft BASIC}}===
<syntaxhighlight lang="gwbasic">S$ = "Remove a defined subset of glyphs from a string."</syntaxhighlight>
<syntaxhighlight lang="gwbasic">N$ = "": IF LEN (S$) THEN FOR I = 1 TO LEN (S$):C$ = MID$ (S$,I,1):K = ASC (C$):K$ = CHR$ (K - 32 * (K > 95)):V = 0: FOR C = 1 TO 5:V = V + ( MID$ ("AEIOU",C,1) = K$): NEXT C:N$ = N$ + MID$ (C$,V + 1): NEXT I: PRINT N$;</syntaxhighlight>
{{out}}
<pre>
Rmv dfnd sbst f glyphs frm strng.
</pre>
==={{header|BASIC256}}===
<syntaxhighlight lang="basic256">mensaje$ = "If Peter Piper picked a pack of pickled peppers" + " or how many pickled peppers did Peter Piper pick?"
textofinal$ = ""
for i = 1 to length(mensaje$)
c$ = mid(mensaje$,i,1)
begin case
case lower(c$) = "a" or lower(c$) = "e" or lower(c$) = "i" or lower(c$) = "o" or lower(c$) = "u"
continue for
else
textofinal$ += c$
end case
next i
print textofinal$
end</syntaxhighlight>
==={{header|PureBasic}}===
<syntaxhighlight lang="purebasic">OpenConsole()
mensaje.s = "If Peter Piper picked a pack of pickled peppers" + " or how many pickled peppers did Peter Piper pick?"
textofinal.s = ""
For i.i = 1 To Len(mensaje)
c.s = Mid(mensaje,i,1)
Select c
Case "a", "e", "i", "o", "u", "A", "E", "I", "O", "U"
Continue
Default
textofinal + c
EndSelect
Next i
PrintN(textofinal)
Input()
CloseConsole()</syntaxhighlight>
==={{header|QBasic}}===
{{works with|QBasic|1.1}}
{{works with|QuickBasic|4.5}}
<syntaxhighlight lang="qbasic">mensaje$ = "If Peter Piper picked a pack of pickled peppers" + ", how many pickled peppers did Peter Piper pick?"
textofinal$ = ""
for i = 1 to len(mensaje$)
c$ = mid$(mensaje$, i, 1)
select case c$
case "a", "e", "i", "o", "u", "A", "E", "I", "O", "U"
REM continue for
case else
textofinal$ = textofinal$ + c$
end select
next i
print textofinal$
end</syntaxhighlight>
==={{header|Yabasic}}===
<syntaxhighlight lang="yabasic">mensaje$ = "If Peter Piper picked a pack of pickled peppers" + " : case how many pickled peppers did Peter Piper pick?"
textofinal$ = ""
for i = 1 to len(mensaje$)
c$ = mid$(mensaje$,i,1)
switch c$
case "a" : case "e" : case "i" : case "o" : case "u" : case "A" : case "E" : case "I" : case "O" : case "U"
continue
default
textofinal$ = textofinal$ + c$
end switch
next i
print textofinal$
end</syntaxhighlight>
=={{header|BCPL}}==
<syntaxhighlight lang="bcpl">get "libhdr"
let vowel(c) = valof
$( c := c | 32
resultis c='a' | c='e' | c='i' | c='o' | c='u'
$)
let devowel(s) = valof
$( let i = 1
while i <= s%0
$( test vowel(s%i)
$( for j=i+1 to s%0 do s%(j-1) := s%j
s%0 := s%0 - 1
$)
or i := i + 1
$)
resultis s
$)
let start() be
writes(devowel("THE QUICK BROWN FOX jumps over the lazy dog.*N"))</syntaxhighlight>
{{out}}
<pre>TH QCK BRWN FX jmps vr th lzy dg.</pre>
=={{header|BQN}}==
<syntaxhighlight lang="bqn">Devowel ← ¬∘∊⟜"AaEeIiOoUu"⊸/</syntaxhighlight>
=={{header|C}}==
{{trans|Go}}
<syntaxhighlight lang="c">#include <stdio.h>
void print_no_vowels(const char *s) {
for (; *s != 0; s++) {
switch (*s) {
case 'A':
case 'E':
case 'I':
case 'O':
case 'U':
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
break;
default:
putchar(*s);
break;
}
}
}
void test(const char *const s) {
printf("Input : %s\n", s);
printf("Output : ");
print_no_vowels(s);
printf("\n");
}
int main() {
test("C Programming Language");
return 0;
}</syntaxhighlight>
{{out}}
<pre>Input : C Programming Language
Output : C Prgrmmng Lngg</pre>
=={{header|C#}}==
<syntaxhighlight lang="csharp">static string remove_vowels(string value)
{
var stripped = from c in value.ToCharArray()
where !"aeiouAEIOU".Contains(c)
select c;
return new string(stripped.ToArray());
}
static void test(string value)
{
Console.WriteLine("Input: " + value);
Console.WriteLine("Output: " + remove_vowels(value));
}
static void Main(string[] args)
{
test("CSharp Programming Language");
}
</syntaxhighlight>
{{out}}
<pre>Input: CSharp Programming Language
Output: CShrp Prgrmmng Lngg</pre>
=={{header|C++}}==
<syntaxhighlight lang="cpp">#include <algorithm>
#include <iostream>
class print_no_vowels {
private:
const std::string &str;
public:
print_no_vowels(const std::string &s) : str(s) {}
friend std::ostream &operator<<(std::ostream &, print_no_vowels);
};
std::ostream &operator<<(std::ostream &os, print_no_vowels pnv) {
auto it = pnv.str.cbegin();
auto end = pnv.str.cend();
std::for_each(
it, end,
[&os](char c) {
switch (c) {
case 'A':
case 'E':
case 'I':
case 'O':
case 'U':
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
break;
default:
os << c;
break;
}
}
);
return os;
}
void test(const std::string &s) {
std::cout << "Input : " << s << '\n';
std::cout << "Output : " << print_no_vowels(s) << '\n';
}
int main() {
test("C++ Programming Language");
return 0;
}</syntaxhighlight>
{{out}}
<pre>Input : C++ Programming Language
Output : C++ Prgrmmng Lngg</pre>
=={{header|Common Lisp}}==
<syntaxhighlight lang="lisp">(defun vowel-p (c &optional (vowels "aeiou"))
(and (characterp c) (characterp (find c vowels :test #'char-equal))))
(defun remove-vowels (s)
(and (stringp s) (remove-if #'vowel-p s)))</syntaxhighlight>
=={{header|Cowgol}}==
<syntaxhighlight lang="cowgol">include "cowgol.coh";
include "strings.coh";
# Remove the vowels from a string in place
sub Devowel(str: [uint8]) is
var out := str;
loop
var ch := [str];
str := @next str;
[out] := ch;
if ch == 0 then
break;
end if;
ch := ch | 32;
if (ch != 'a') and
(ch != 'e') and
(ch != 'i') and
(ch != 'o') and
(ch != 'u') then
out := @next out;
end if;
end loop;
end sub;
var str := "THE QUICK BROWN FOX jumps over the lazy dog.\n";
var buf: uint8[256];
CopyString(str, &buf[0]); # make a copy of the string into writeable memory
Devowel(&buf[0]); # remove the vowels
print(&buf[0]); # print the result </syntaxhighlight>
{{out}}
<pre>TH QCK BRWN FX jmps vr th lzy dg.</pre>
=={{header|D}}==
<syntaxhighlight lang="d">import std.stdio;
void print_no_vowels(string s) {
foreach (c; s) {
switch (c) {
case 'A', 'E', 'I', 'O', 'U':
case 'a', 'e', 'i', 'o', 'u':
break;
default:
write(c);
}
}
writeln;
}
void main() {
print_no_vowels("D Programming Language");
}</syntaxhighlight>
{{out}}
<pre>D Prgrmmng Lngg</pre>
=={{header|Delphi}}==
{{libheader| System.SysUtils}}
<syntaxhighlight lang="delphi">
program Remove_vowels_from_a_string;
{$APPTYPE CONSOLE}
{$R *.res}
uses
System.SysUtils;
function RemoveVowels(const s: string): string;
const
VOWELS =['a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'];
var
c: char;
begin
Result := '';
for c in s do
begin
if not (c in VOWELS) then
Result := Result + c;
end;
end;
const
TEST = 'The quick brown fox jumps over the lazy dog';
begin
Writeln('Before: ', TEST);
Writeln('After: ', RemoveVowels(TEST));
Readln;
end.
</syntaxhighlight>
{{out}}
<pre>
Before: The quick brown fox jumps over the lazy dog
After: Th qck brwn fx jmps vr th lzy dg
</pre>
=={{header|EasyLang}}==
<syntaxhighlight>
func$ rmv s$ .
for c$ in strchars s$
if strpos "AEIOUaeiou" c$ <> 0
c$ = ""
.
r$ &= c$
.
return r$
.
print rmv "The Quick Brown Fox Jumped Over the Lazy Dog's Back"
</syntaxhighlight>
=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">
let stripVowels n=let g=set['a';'e';'i';'o';'u';'A';'E';'I';'O';'U'] in n|>Seq.filter(fun n->not(g.Contains n))|>Array.ofSeq|>System.String
printfn "%s" (stripVowels "Nigel Galloway")
</syntaxhighlight>
{{out}}
<pre>
"Ngl Gllwy"
</pre>
=={{header|Factor}}==
<syntaxhighlight lang="factor">USING: formatting kernel sets ;
: without-vowels ( str -- new-str ) "aeiouAEIOU" without ;
"Factor Programming Language" dup without-vowels
" Input string: %s\nWithout vowels: %s\n" printf</syntaxhighlight>
{{out}}
<pre>
Input string: Factor Programming Language
Without vowels: Fctr Prgrmmng Lngg
</pre>
=={{header|Forth}}==
<syntaxhighlight lang="forth">: VOWELS ( -- add len ) S" aeiouAEIOU" ;
: VALIDATE ( char addr len -- 0|n) ROT SCAN NIP ; \ find char in string
: C+! ( n addr ) TUCK C@ + SWAP C! ; \ add n to byte address
: ]PAD ( ndx -- addr ) PAD 1+ + ; \ index into text section
: PAD, ( char -- ) PAD C@ ]PAD C! 1 PAD C+! ; \ compile char into PAD, inc. count
: NOVOWELS ( addr len -- addr' len')
0 PAD C! \ reset byte count
BOUNDS ( -- end start)
?DO
I C@ DUP VOWELS VALIDATE
IF DROP \ don't need vowels
ELSE PAD, \ compile char & incr. byte count
THEN
LOOP
PAD COUNT ;</syntaxhighlight>
{{out}}
<pre>
CREATE TEST$ S" Now is the time for all good men..." S, ok
TEST$ COUNT NOVOWELS CR TYPE
Nw s th tm fr ll gd mn... ok
</pre>
=={{header|Fortran}}==
<syntaxhighlight lang="fortran">
program remove_vowels
implicit none
character(len=*), parameter :: string1="The quick brown fox jumps over the lazy dog."
character(len=*), parameter :: string2="Fortran programming language"
call print_no_vowels(string1)
call print_no_vowels(string2)
contains
subroutine print_no_vowels(string)
character(len=*), intent(in) :: string
integer :: i
do i = 1, len(string)
select case (string(i:i))
case('A','E','I','O','U','a','e','i','o','u')
cycle
case default
write(*,'(A1)',advance="no") string(i:i)
end select
end do
write(*,*) new_line('A')
end subroutine print_no_vowels
end program remove_vowels
</syntaxhighlight>
{{out}}
<pre>
Th qck brwn fx jmps vr th lzy dg.
Frtrn prgrmmng lngg
</pre>
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">dim as string message = "If Peter Piper picked a pack of pickled peppers"+_
", how many pickled peppers did Peter Piper pick?"
dim as string outstr = "", c
for i as uinteger = 1 to len(message)
c=mid(message,i,1)
select case c
case "a", "e", "i", "o", "u", "A", "E", "I", "O", "U":
continue for
case else:
outstr += c
end select
next i
print outstr</syntaxhighlight>
=={{header|Free Pascal}}==
''See also [[#Pascal|Pascal]]''
{{libheader|strUtils}}
<syntaxhighlight lang="pascal">{$longStrings on}
uses
strUtils;
var
line: string;
c: char;
begin
readLn(line);
for c in ['A', 'E', 'I', 'O', 'U', 'a', 'e', 'i', 'o', 'u'] do
begin
line := delChars(line, c)
end;
writeLn(line)
end.</syntaxhighlight>
=={{header|Frink}}==
<syntaxhighlight lang="frink">s = """Rosetta Code is a programming chrestomathy site.
The idea is to present solutions to the same
task in as many different languages as possible,
to demonstrate how languages are similar and
different, and to aid a person with a grounding
in one approach to a problem in learning another."""
println[s =~ %s/[aeiou]//gi ]</syntaxhighlight>
{{out}}
<pre>
Rstt Cd s prgrmmng chrstmthy st.
Th d s t prsnt sltns t th sm
tsk n s mny dffrnt lnggs s pssbl,
t dmnstrt hw lnggs r smlr nd
dffrnt, nd t d prsn wth grndng
n n pprch t prblm n lrnng nthr.
</pre>
=={{header|Fōrmulæ}}==
{{FormulaeEntry|page=https://formulae.org/?script=examples/Remove_vowels_from_a_string}}
'''Solution'''
[[File:Fōrmulæ - Remove vowels from a string 01.png]]
[[File:Fōrmulæ - Remove vowels from a string 02.png]]
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">window 1, @"Remove vowels from a string"
local fn StringByRemovingVowels( string as CFStringRef ) as CFStringRef
end fn = fn ArrayComponentsJoinedByString( fn StringComponentsSeparatedByCharactersInSet( string, fn CharacterSetWithCharactersInString( @"aeiou" ) ), @"" )
print fn StringByRemovingVowels( @"The quick brown fox jumps over the lazy dog." )
print fn StringByRemovingVowels( @"FutureBasic is a great programming language!" )
HandleEvents</syntaxhighlight>
{{out}}
<pre>
Th qck brwn fx jmps vr th lzy dg.
FtrBsc s grt prgrmmng lngg!
</pre>
=={{header|Go}}==
<
import (
Line 61 ⟶ 961:
fmt.Println("Input :", s)
fmt.Println("Output :", removeVowels(s))
}</
{{out}}
Line 68 ⟶ 968:
Output : G Prgrmmng Lngg
</pre>
=={{header|Haskell}}==
Removing three specific Anglo-Saxon vowels from a text, using a general method which can apply to any specific subset of glyphs.
<syntaxhighlight lang="haskell">------ REMOVE A SPECIFIC SUBSET OF GLYPHS FROM A STRING ----
exceptGlyphs :: String -> String -> String
exceptGlyphs = filter . flip notElem
---------------------------- TEST --------------------------
txt :: String
txt =
"Rosetta Code is a programming chrestomathy site.\n\
\The idea is to present solutions to the same\n\
\task in as many different languages as possible,\n\
\to demonstrate how languages are similar and\n\
\different, and to aid a person with a grounding\n\
\in one approach to a problem in learning another."
main :: IO ()
main = putStrLn $ exceptGlyphs "eau" txt</syntaxhighlight>
{{Out}}
<pre>Rostt Cod is progrmming chrstomthy sit.
Th id is to prsnt soltions to th sm
tsk in s mny diffrnt lnggs s possibl,
to dmonstrt how lnggs r similr nd
diffrnt, nd to id prson with gronding
in on pproch to problm in lrning nothr.</pre>
=={{header|J}}==
<syntaxhighlight lang="j">devowel =: -. & 'aeiouAEIOU'</syntaxhighlight>
=={{header|Java}}==
You can use the ''String.replaceAll'' method, which takes a regular expression as it's first argument.
<syntaxhighlight lang="java">
"rosettacode.org".replaceAll("(?i)[aeiou]", "");
</syntaxhighlight>
<br />
Or
<syntaxhighlight lang="java">public static String removeVowelse(String str){
String re = "";
char c;
for(int x = 0; x<str.length(); x++){
c = str.charAt(x);
if(!(c=='a'||c=='e'||c=='i'||c=='o'||c=='u'))
re+=c;
}
return re;
}</syntaxhighlight>
=={{header|JavaScript}}==
Removing all instances of three particular vowels from a text, using approaches that are generalisable to the removal of any specified subset of glyphs.
( ''Pace'' Jamie Zawinski, some people, when confronted with a problem, think "I know, I'll use '''parser combinators'''." )
<syntaxhighlight lang="javascript">(() => {
'use strict'
// Parser :: String -> Parser String
const purgedText = exclusions =>
fmapP(concatMap(concat))(
sepBy(
some(noneOf(exclusions))
)(
some(oneOf(exclusions))
)
);
// ----------------------- TEST ------------------------
const main = () => {
const txt = `
Rosetta Code is a programming chrestomathy site.
The idea is to present solutions to the same
task in as many different languages as possible,
to demonstrate how languages are similar and
different, and to aid a person with a grounding
in one approach to a problem in learning another.`
return fst(parse(
purgedText('eau')
)(txt)[0]);
};
// ---------------- PARSER COMBINATORS -----------------
// Parser :: String -> [(a, String)] -> Parser a
const Parser = f =>
// A function lifted into a Parser object.
({
type: 'Parser',
parser: f
});
// altP (<|>) :: Parser a -> Parser a -> Parser a
const altP = p =>
// p, or q if p doesn't match.
q => Parser(s => {
const xs = p.parser(s);
return 0 < xs.length ? (
xs
) : q.parser(s);
});
// apP <*> :: Parser (a -> b) -> Parser a -> Parser b
const apP = pf =>
// A new parser obtained by the application
// of a Parser-wrapped function,
// to a Parser-wrapped value.
p => Parser(
s => pf.parser(s).flatMap(
vr => fmapP(vr[0])(
p
).parser(vr[1])
)
);
// bindP (>>=) :: Parser a ->
// (a -> Parser b) -> Parser b
const bindP = p =>
// A new parser obtained by the application of
// a function to a Parser-wrapped value.
// The function must enrich its output, lifting it
// into a new Parser.
// Allows for the nesting of parsers.
f => Parser(
s => p.parser(s).flatMap(
tpl => f(tpl[0]).parser(tpl[1])
)
);
// fmapP :: (a -> b) -> Parser a -> Parser b
const fmapP = f =>
// A new parser derived by the structure-preserving
// application of f to the value in p.
p => Parser(
s => p.parser(s).flatMap(
vr => Tuple(f(vr[0]))(vr[1])
)
);
// liftA2P :: (a -> b -> c) ->
// Parser a -> Parser b -> Parser c
const liftA2P = op =>
// The binary function op, lifted
// to a function over two parsers.
p => apP(fmapP(op)(p));
// many :: Parser a -> Parser [a]
const many = p => {
// Zero or more instances of p.
// Lifts a parser for a simple type of value
// to a parser for a list of such values.
const some_p = p =>
liftA2P(
x => xs => [x].concat(xs)
)(p)(many(p));
return Parser(
s => (
0 < s.length ? (
altP(some_p(p))(pureP([]))
) : pureP([])
).parser(s)
);
};
// noneOf :: String -> Parser Char
const noneOf = s =>
// Any character not found in the
// exclusion string.
satisfy(c => !s.includes(c));
// oneOf :: [Char] -> Parser Char
const oneOf = s =>
// One instance of any character found
// the given string.
satisfy(c => s.includes(c));
// parse :: Parser a -> String -> [(a, String)]
const parse = p =>
// The result of parsing s with p.
s => p.parser(s);
// pureP :: a -> Parser a
const pureP = x =>
// The value x lifted, unchanged,
// into the Parser monad.
Parser(s => [Tuple(x)(s)]);
// satisfy :: (Char -> Bool) -> Parser Char
const satisfy = test =>
// Any character for which the
// given predicate returns true.
Parser(
s => 0 < s.length ? (
test(s[0]) ? [
Tuple(s[0])(s.slice(1))
] : []
) : []
);
// sepBy :: Parser a -> Parser b -> Parser [a]
const sepBy = p =>
// Zero or more occurrences of p, as
// separated by (discarded) instances of sep.
sep => altP(
sepBy1(p)(sep)
)(
pureP([])
);
// sepBy1 :: Parser a -> Parser b -> Parser [a]
const sepBy1 = p =>
// One or more occurrences of p, as
// separated by (discarded) instances of sep.
sep => bindP(
p
)(x => bindP(
many(bindP(
sep
)(_ => bindP(
p
)(pureP))))(
xs => pureP([x].concat(xs))));
// some :: Parser a -> Parser [a]
const some = p => {
// One or more instances of p.
// Lifts a parser for a simple type of value
// to a parser for a list of such values.
const many_p = p =>
altP(some(p))(pureP([]));
return Parser(
s => liftA2P(
x => xs => [x].concat(xs)
)(p)(many_p(p)).parser(s)
);
};
// ----------------- GENERIC FUNCIONS ------------------
// Tuple (,) :: a -> b -> (a, b)
const Tuple = a =>
b => ({
type: 'Tuple',
'0': a,
'1': b,
length: 2
});
// concat :: [[a]] -> [a]
// concat :: [String] -> String
const concat = xs => (
ys => 0 < ys.length ? (
ys.every(Array.isArray) ? (
[]
) : ''
).concat(...ys) : ys
)(xs);
// concatMap :: (a -> [b]) -> [a] -> [b]
const concatMap = f =>
// Where (a -> [b]) returns an Array, this
// is equivalent to .flatMap, which should be
// used by default.
// but if (a -> [b]) returns String rather than [Char],
// the monoid unit is '' in place of [], and a
// concatenated string is returned.
xs => {
const ys = list(xs).map(f);
return 0 < ys.length ? (
ys.some(y => 'string' !== typeof y) ? (
[]
) : ''
).concat(...ys) : ys;
};
// 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 || []);
// map :: (a -> b) -> [a] -> [b]
const map = f =>
// The list obtained by applying f
// to each element of xs.
// (The image of xs under f).
xs => [...xs].map(f);
// fst :: (a, b) -> a
const fst = tpl =>
// First member of a pair.
tpl[0];
// main ---
return main();
})();</syntaxhighlight>
{{Out}}
<pre> Rostt Cod is progrmming chrstomthy sit.
Th id is to prsnt soltions to th sm
tsk in s mny diffrnt lnggs s possibl,
to dmonstrt how lnggs r similr nd
diffrnt, nd to id prson with gronding
in on pproch to problm in lrning nothr.</pre>
but a filter is all we need here:
<syntaxhighlight lang="javascript">(() => {
'use strict';
// Parser :: String -> Parser String
const purgedText = exclusions =>
s => [...s]
.filter(c => !exclusions.includes(c))
.join('');
// ---------------------- TEST -----------------------
const main = () => {
const txt = `
Rosetta Code is a programming chrestomathy site.
The idea is to present solutions to the same
task in as many different languages as possible,
to demonstrate how languages are similar and
different, and to aid a person with a grounding
in one approach to a problem in learning another.`;
return purgedText('eau')(txt);
};
// main ---
return main();
})();</syntaxhighlight>
{{Out}}
<pre> Rostt Cod is progrmming chrstomthy sit.
Th id is to prsnt soltions to th sm
tsk in s mny diffrnt lnggs s possibl,
to dmonstrt how lnggs r similr nd
diffrnt, nd to id prson with gronding
in on pproch to problm in lrning nothr.</pre>
=={{header|Joy}}==
<syntaxhighlight lang="joy">DEFINE unvowel == ["AaEeIiOoUu" in not] filter.
"Remove ALL vowels from this input!" unvowel putchars.</syntaxhighlight>
{{out}}
<pre>Rmv LL vwls frm ths npt!</pre>
=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
<syntaxhighlight lang="sh">
#!/bin/bash
vowels='AÀÁÂÃÄÅĀĂĄǺȀȂẠẢẤẦẨẪẬẮẰẲẴẶḀÆǼEȄȆḔḖḘḚḜẸẺẼẾỀỂỄỆĒĔĖĘĚÈÉÊËIȈȊḬḮỈỊĨĪĬĮİÌÍÎÏIJOŒØǾȌȎṌṎṐṒỌỎỐỒỔỖỘỚỜỞỠỢŌÒÓŎŐÔÕÖUŨŪŬŮŰŲÙÚÛÜȔȖṲṴṶṸṺỤỦỨỪỬỮỰ'
function input {
cat<<'EOF'
In this entry, we assume that the "vowels" of the particular texts of
interest can be specified as a JSON string of letters. Furthermore,
we take advantage of gsub's support for the "ignore case" option, "i",
so that for vowels which have both upper and lower case forms, only
one form need be included in the string. So for example, for
unaccented English text we could use the invocation:
jq -Rr 'gsub("[aeiou]+"; ""; "i")' input.txt
The string of vowels can also be specified as an argument to jq, e.g. assuming
a bash or bash-like scripting environment:
vowels='AÀÁÂÃÄÅĀĂĄǺȀȂẠẢẤẦẨẪẬẮẰẲẴẶḀÆǼEȄȆḔḖḘḚḜẸẺẼẾỀỂỄỆĒĔĖĘĚÈÉÊËIȈȊḬḮỈỊĨĪĬĮİÌÍÎÏIJOŒØǾȌȎṌṎṐṒỌỎỐỒỔỖỘỚỜỞỠỢŌÒÓŎŐÔÕÖUŨŪŬŮŰŲÙÚÛÜȔȖṲṴṶṸṺỤỦỨỪỬỮỰ'
jq -Rr --arg v "$vowels" 'gsub("[\($v)]+"; ""; "i")' input.txt
Norwegian, Icelandic, German, Turkish, French, Spanish, English:
Undervisningen skal være gratis, i det minste på de elementære og grunnleggende trinn.
Skal hún veitt ókeypis, að minnsta kosti barnafræðsla og undirstöðummentu.
Hochschulunterricht muß allen gleichermaßen entsprechend ihren Fähigkeiten offenstehen.
Öğrenim hiç olmazsa ilk ve temel safhalarında parasızdır. İlk öğretim mecburidir.
L'éducation doit être gratuite, au moins en ce qui concerne l'enseignement élémentaire et fondamental.
La instrucción elemental será obligatoria. La instrucción técnica y profesional habrá de ser generalizada.
Education shall be free, at least in the elementary and fundamental stages.
EOF
}
input | jq -Rr --arg v "$vowels" 'gsub("[\($v)]+"; ""; "i")'
</syntaxhighlight>
{{out}}
<pre>
n ths ntry, w ssm tht th "vwls" f th prtclr txts f
ntrst cn b spcfd s JSN strng f lttrs. Frthrmr,
w tk dvntg f gsb's spprt fr th "gnr cs" ptn, "",
s tht fr vwls whch hv bth ppr nd lwr cs frms, nly
n frm nd b ncldd n th strng. S fr xmpl, fr
nccntd nglsh txt w cld s th nvctn:
jq -Rr 'gsb("[]+"; ""; "")' npt.txt
Th strng f vwls cn ls b spcfd s n rgmnt t jq, .g. ssmng
bsh r bsh-lk scrptng nvrnmnt:
vwls=''
jq -Rr --rg v "$vwls" 'gsb("[\($v)]+"; ""; "")' npt.txt
Nrwgn, clndc, Grmn, Trksh, Frnch, Spnsh, nglsh:
ndrvsnngn skl vr grts, dt mnst p d lmntr g grnnlggnd trnn.
Skl hn vtt kyps, ð mnnst kst brnfrðsl g ndrstðmmnt.
Hchschlntrrcht mß lln glchrmßn ntsprchnd hrn Fhgktn ffnsthn.
ğrnm hç lmzs lk v tml sfhlrınd prsızdır. lk ğrtm mcbrdr.
L'dctn dt tr grtt, mns n c q cncrn l'nsgnmnt lmntr t fndmntl.
L nstrccn lmntl sr blgtr. L nstrccn tcnc y prfsnl hbr d sr gnrlzd.
dctn shll b fr, t lst n th lmntry nd fndmntl stgs.
</pre>
=={{header|Julia}}==
Unicode sensitive, using the Raku version example text.
<syntaxhighlight lang="julia">const ALLVOWELS = Dict(ch => 1 for ch in Vector{Char}("AÀÁÂÃÄÅĀĂĄǺȀȂẠẢẤẦẨẪẬẮẰẲẴẶḀÆǼEȄȆḔḖḘḚḜẸẺẼẾỀỂỄỆĒĔĖĘĚÈÉÊËIȈȊḬḮỈỊĨĪĬĮİÌÍÎÏIJOŒØǾȌȎṌṎṐṒỌỎỐỒỔỖỘỚỜỞỠỢŌÒÓŎŐÔÕÖUŨŪŬŮŰŲÙÚÛÜȔȖṲṴṶṸṺỤỦỨỪỬỮỰ"))
const ALLVOWELSY = Dict(ch => 1 for ch in Vector{Char}("AÀÁÂÃÄÅĀĂĄǺȀȂẠẢẤẦẨẪẬẮẰẲẴẶḀÆǼEȄȆḔḖḘḚḜẸẺẼẾỀỂỄỆĒĔĖĘĚÈÉÊËIȈȊḬḮỈỊĨĪĬĮİÌÍÎÏIJOŒØǾȌȎṌṎṐṒỌỎỐỒỔỖỘỚỜỞỠỢŌÒÓŎŐÔÕÖUŨŪŬŮŰŲÙÚÛÜȔȖṲṴṶṸṺỤỦỨỪỬỮỰYẙỲỴỶỸŶŸÝ"))
isvowel(ch, yisavowel=false) = haskey(yisavowel ? ALLVOWELSY : ALLVOWELS, uppercase(ch))
const testtext = """
Norwegian, Icelandic, German, Turkish, French, Spanish, English:
Undervisningen skal være gratis, i det minste på de elementære og grunnleggende trinn.
Skal hún veitt ókeypis, að minnsta kosti barnafræðsla og undirstöðummentu.
Hochschulunterricht muß allen gleichermaßen entsprechend ihren Fähigkeiten offenstehen.
Öğrenim hiç olmazsa ilk ve temel safhalarında parasızdır. İlk öğretim mecburidir.
L'éducation doit être gratuite, au moins en ce qui concerne l'enseignement élémentaire et fondamental.
La instrucción elemental será obligatoria. La instrucción técnica y profesional habrá de ser generalizada.
Education shall be free, at least in the elementary and fundamental stages."""
println("Removing vowels from:\n$testtext\n becomes:\n",
String(filter(!isvowel, Vector{Char}(testtext))))
</syntaxhighlight>{{out}}
<pre>
Removing vowels from:
Norwegian, Icelandic, German, Turkish, French, Spanish, English:
Undervisningen skal være gratis, i det minste på de elementære og grunnleggende trinn.
Skal hún veitt ókeypis, að minnsta kosti barnafræðsla og undirstöðummentu.
Hochschulunterricht muß allen gleichermaßen entsprechend ihren Fähigkeiten offenstehen.
Öğrenim hiç olmazsa ilk ve temel safhalarında parasızdır. İlk öğretim mecburidir.
L'éducation doit être gratuite, au moins en ce qui concerne l'enseignement élémentaire et fondamental.
La instrucción elemental será obligatoria. La instrucción técnica y profesional habrá de ser generalizada.
Education shall be free, at least in the elementary and fundamental stages.
becomes:
Nrwgn, clndc, Grmn, Trksh, Frnch, Spnsh, nglsh:
ndrvsnngn skl vr grts, dt mnst p d lmntr g grnnlggnd trnn.
Skl hn vtt kyps, ð mnnst kst brnfrðsl g ndrstðmmnt.
Hchschlntrrcht mß lln glchrmßn ntsprchnd hrn Fhgktn ffnsthn.
ğrnm hç lmzs lk v tml sfhlrnd prszdr. lk ğrtm mcbrdr.
L'dctn dt tr grtt, mns n c q cncrn l'nsgnmnt lmntr t fndmntl.
L nstrccn lmntl sr blgtr. L nstrccn tcnc y prfsnl hbr d sr gnrlzd.
dctn shll b fr, t lst n th lmntry nd fndmntl stgs.
</pre>
=={{header|K}}==
{{works with|ngn/k}}
<syntaxhighlight lang=K>novowel: {x^"aeiouAEIOU"}
novowel"The Quick Brown Fox Jumped Over the Lazy Dog's Back"
"Th Qck Brwn Fx Jmpd vr th Lzy Dg's Bck"
</syntaxhighlight>
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">fun removeVowels(s: String): String {
val re = StringBuilder()
for (c in s) {
if (c != 'A' && c != 'a'
&& c != 'E' && c != 'e'
&& c != 'I' && c != 'i'
&& c != 'O' && c != 'o'
&& c != 'U' && c != 'u') {
re.append(c)
}
}
return re.toString()
}
fun main() {
println(removeVowels("Kotlin Programming Language"))
}</syntaxhighlight>
{{out}}
<pre>Ktln Prgrmmng Lngg</pre>
=={{header|Lambdatalk}}==
<syntaxhighlight lang="scheme">
'{S.replace [aeiouy]* by in
Rosetta Code is a programming chrestomathy site.
The idea is to present solutions to the same
task in as many different languages as possible,
to demonstrate how languages are similar and
different, and to aid a person with a grounding
in one approach to a problem in learning another.}
-> Rstt Cd s prgrmmng chrstmth st. Th d s t prsnt sltns t th sm tsk n s mn dffrnt lnggs s pssbl, t dmnstrt hw lnggs r smlr nd dffrnt, nd t d prsn wth grndng n n pprch t prblm n lrnng nthr.
</syntaxhighlight>
=={{header|Lua}}==
<syntaxhighlight lang="lua">function removeVowels (inStr)
local outStr, letter = ""
local vowels = "AEIUOaeiou"
for pos = 1, #inStr do
letter = inStr:sub(pos, pos)
if vowels:find(letter) then
-- This letter is a vowel
else
outStr = outStr .. letter
end
end
return outStr
end
local testStr = "The quick brown fox jumps over the lazy dog"
print(removeVowels(testStr))</syntaxhighlight>
{{out}}
<pre>Th qck brwn fx jmps vr th lzy dg</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">StringReplace["The Quick Brown Fox Jumped Over the Lazy Dog's Back", (Alternatives @@ Characters["aeiou"]) -> ""]</syntaxhighlight>
{{out}}
<pre>Th Qck Brwn Fx Jmpd Ovr th Lzy Dg's Bck</pre>
=={{header|MATLAB}} / {{header|Octave}}==
<syntaxhighlight lang="matlab">
function [result] = remove_vowels(text)
% http://rosettacode.org/wiki/Remove_vowels_from_a_string
flag=zeros(size(text));
for c='AEIOUaeiou'
flag=flag|(text==c);
end
result=text(~flag);
end
remove_vowels('The AWK Programming Language')
remove_vowels('The quick brown fox jumps over the lazy dog')
%!test
%! assert(remove_vowels('The AWK Programming Language'),'Th WK Prgrmmng Lngg')
%!test
%! assert(remove_vowels('The quick brown fox jumps over the lazy dog'),'Th qck brwn fx jmps vr th lzy dg')
</syntaxhighlight>
{{out}}
<pre>
ans = Th WK Prgrmmng Lngg
ans = Th qck brwn fx jmps vr th lzy dg
</pre>
=={{header|Nim}}==
<syntaxhighlight lang="nim">import strutils, sugar
const Vowels = {'a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'}
proc removeVowels(str: var string; vowels: set[char]) =
## Remove vowels from string "str".
var start = 0
while true:
let pos = str.find(vowels, start)
if pos < 0: break
str.delete(pos, pos)
start = pos
const TestString = "The quick brown fox jumps over the lazy dog"
echo TestString
echo TestString.dup(removeVowels(Vowels))</syntaxhighlight>
{{out}}
<pre>The quick brown fox jumps over the lazy dog
Th qck brwn fx jmps vr th lzy dg</pre>
=={{header|OCaml}}==
<syntaxhighlight lang="ocaml">let remove_vowels s : string =
let not_vowel = Fun.negate (String.contains "AaEeIiOoUu") in
String.to_seq s |> Seq.filter not_vowel |> String.of_seq</syntaxhighlight>
=={{header|Pascal}}==
''See also [[#Delphi|Delphi]] or [[#Free Pascal|Free Pascal]]''<br/>
This program works with any ISO 7185 compliant compiler.
<syntaxhighlight lang="pascal">program removeVowelsFromString(input, output);
const
stringLength = 80;
type
stringIndex = 1..stringLength;
string = array[stringIndex] of char;
var
sourceIndex, destinationIndex: stringIndex;
line, disemvoweledLine: string;
vowels: set of char;
function lineHasVowels: Boolean;
var
sourceIndex: stringIndex;
vowelIndices: set of stringIndex;
begin
vowelIndices := [];
for sourceIndex := 1 to stringLength do
begin
if line[sourceIndex] in vowels then
begin
vowelIndices := vowelIndices + [sourceIndex]
end
end;
lineHasVowels := vowelIndices <> []
end;
begin
vowels := ['A', 'E', 'I', 'O', 'U', 'a', 'e', 'i', 'o', 'u'];
{ - - input - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - }
for destinationIndex := 1 to stringLength do
begin
line[destinationIndex] := ' ';
if not EOLn(input) then
begin
read(line[destinationIndex])
end
end;
{ - - processing - - - - - - - - - - - - - - - - - - - - - - - - - - - }
if lineHasVowels then
begin
destinationIndex := 1;
for sourceIndex := 1 to stringLength do
begin
if not (line[sourceIndex] in vowels) then
begin
disemvoweledLine[destinationIndex] := line[sourceIndex];
destinationIndex := destinationIndex + 1
end
end;
{ pad remaining characters in `disemvoweledLine` with spaces }
for destinationIndex := destinationIndex to stringLength do
begin
disemvoweledLine[destinationIndex] := ' '
end;
end
else
begin
disemvoweledLine := line
end;
{ - - output - - - - - - - - - - - - - - - - - - - - - - - - - - - - - }
for destinationIndex := 1 to stringLength do
begin
write(disemvoweledLine[destinationIndex])
end;
writeLn
end.</syntaxhighlight>
{{in}}
The quick brown fox jumps over the lazy dog.
{{out}}
Th qck brwn fx jmps vr th lzy dg.
----
{{works with|Extended Pascal}}
More convenient though is to use some Extended Pascal (ISO 10206) features:
<syntaxhighlight lang="pascal">program removeVowelsFromString(input, output);
const
vowels = ['A', 'E', 'I', 'O', 'U', 'a', 'e', 'i', 'o', 'u'];
var
i: integer;
{ Extended Pascal: `… value ''` initializes both variables with `''`. }
line, disemvoweledLine: string(80) value '';
begin
readLn(line);
for i := 1 to length(line) do
begin
if not (line[i] in vowels) then
begin
disemvoweledLine := disemvoweledLine + line[i]
end
end;
writeLn(disemvoweledLine)
end.</syntaxhighlight>
{{in}}
The quick brown fox jumps over the lazy dog.
{{out}}
Th qck brwn fx jmps vr th lzy dg.
=={{header|Perl}}==
Inspired by the Raku entry.
<syntaxhighlight lang="perl">use strict;
use warnings;
use utf8;
binmode STDOUT, ":utf8";
use Unicode::Normalize;
my $text = <<~'END';
Norwegian, Icelandic, German, Turkish, French, Spanish, English:
Undervisningen skal være gratis, i det minste på de elementære og grunnleggende trinn.
Skal hún veitt ókeypis, að minnsta kosti barnafræðsla og undirstöðummentu.
Hochschulunterricht muß allen gleichermaßen entsprechend ihren Fähigkeiten offenstehen.
Öğrenim hiç olmazsa ilk ve temel safhalarında parasızdır. İlk öğretim mecburidir.
L'éducation doit être gratuite, au moins en ce qui concerne l'enseignement élémentaire et fondamental.
La instrucción elemental será obligatoria. La instrucción técnica y profesional habrá de ser generalizada.
Education shall be free, at least in the elementary and fundamental stages.
END
my @vowels;
chr($_) =~ /[aæeiıoœu]/i and push @vowels, chr($_) for 0x20 .. 0x1ff;
print NFD($_) =~ /@{[join '|', @vowels]}/ ? ' ' : $_ for split /(\X)/, $text;</syntaxhighlight>
{{out}}
<pre>N rw g n, c l nd c, G rm n, T rk sh, Fr nch, Sp n sh, ngl sh:
nd rv sn ng n sk l v r gr t s, d t m nst p d l m nt r g gr nnl gg nd tr nn.
Sk l h n v tt k yp s, ð m nnst k st b rn fr ðsl g nd rst ð mm nt .
H chsch l nt rr cht m ß ll n gl ch rm ß n ntspr ch nd hr n F h gk t n ff nst h n.
ğr n m h ç lm zs lk v t m l s fh l r nd p r s zd r. lk ğr t m m cb r d r.
L' d c t n d t tr gr t t , m ns n c q c nc rn l' ns gn m nt l m nt r t f nd m nt l.
L nstr cc n l m nt l s r bl g t r . L nstr cc n t cn c y pr f s n l h br d s r g n r l z d .
d c t n sh ll b fr , t l st n th l m nt ry nd f nd m nt l st g s.</pre>
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">constant</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"Phix Programming Language"</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;">"Input : %s\nOutput : %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">filter</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"out"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"aeiouAEIUO"</span><span style="color: #0000FF;">)})</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Input : Phix Programming Language
Output : Phx Prgrmmng Lngg
</pre>
If you want something a bit more like Julia/Raku, the following should work, but you have to provide your own vowel-set, or nick/merge from Julia/REXX
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">vowels</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">utf8_to_utf32</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"AEIOUIÖaeiouæáåäéêióöú"</span><span style="color: #0000FF;">),</span>
<span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"""
Norwegian, Icelandic, German, Turkish, French, Spanish, English:
Undervisningen skal være gratis, i det minste på de elementære og grunnleggende trinn.
Skal hún veitt ókeypis, að minnsta kosti barnafræðsla og undirstöðummentu.
Hochschulunterricht muß allen gleichermaßen entsprechend ihren Fähigkeiten offenstehen.
Ögrenim hiç olmazsa ilk ve temel safhalarinda parasizdir. Ilk ögretim mecburidir.
L'éducation doit être gratuite, au moins en ce qui concerne l'enseignement élémentaire et fondamental.
La instrucción elemental será obligatoria. La instrucción técnica y profesional habrá de ser generalizada.
Education shall be free, at least in the elementary and fundamental stages.
"""</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">remove_vowels</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">utf8_to_utf32</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">to</span> <span style="color: #000000;">1</span> <span style="color: #008080;">by</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">1</span> <span style="color: #008080;">do</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">find</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">],</span><span style="color: #000000;">vowels</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">' '</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #000080;font-style:italic;">-- if find(s[i],vowels) then s[i..i] = "" end if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">utf32_to_utf8</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">s</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</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;">"%s\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">remove_vowels</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">))</span>
<!--</syntaxhighlight>-->
(output deliberately not shown due to windows console effects, but it is the same as Raku, or Julia with the alternate find/replace line.)
=={{header|Picat}}==
<syntaxhighlight lang="picat">main =>
println("The Quick Brown Fox Jumped Over the Lazy Dog's Back".remove_vowels),
println("Picat programming language".remove_vowels).
remove_vowels(S) = [C : C in S, not membchk(C,"AEIOUaeiou")].</syntaxhighlight>
{{out}}
<pre>Th Qck Brwn Fx Jmpd vr th Lzy Dg's Bck
Pct prgrmmng lngg</pre>
=={{header|Prolog}}==
{{works with|SWI-Prolog|7}}
<syntaxhighlight lang="prolog">
:- system:set_prolog_flag(double_quotes,chars) .
:- [library(lists)] .
%! remove_vowels(INPUTz0,OUTPUTz0)
%
% `OUTPUTz0` is `INPUTz0` but without any vowels .
remove_vowels(INPUTz0,OUTPUTz0)
:-
prolog:phrase(remove_vowels(INPUTz0),OUTPUTz0)
.
remove_vowels([])
-->
[]
.
remove_vowels([INPUT0|INPUTz0])
-->
{ vowel(INPUT0) } ,
! ,
remove_vowels(INPUTz0)
.
remove_vowels([INPUT0|INPUTz0])
-->
! ,
[INPUT0] ,
remove_vowels(INPUTz0)
.
vowel(CHAR)
:-
lists:member(CHAR,"AEIOUaeiouüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜáíóúªºαΩ")
.
</syntaxhighlight>
{{out}}
<pre>
/*
?- remove_vowels("abcdef",Ys).
Ys = [b, c, d, f].
?- remove_vowels("",Ys).
Ys = [].
?- remove_vowels("aeiou",Ys).
Ys = [].
?- remove_vowels("bcdfg",Ys).
Ys = [b, c, d, f, g].
?-
*/
</pre>
=={{header|Python}}==
===Functional===
Removing 3 particular Anglo-Saxon vowels from a string:
{{works with|Python|3.7|}}
<syntaxhighlight lang="python">'''Remove a defined subset of glyphs from a string'''
# exceptGlyphs :: String -> String -> String
def exceptGlyphs(exclusions):
'''A string from which all instances of a
given set of glyphs have been removed.
'''
def go(s):
return ''.join(
c for c in s if c not in exclusions
)
return go
# -------------------------- TEST --------------------------
# main :: IO ()
def main():
'''Test'''
txt = '''
Rosetta Code is a programming chrestomathy site.
The idea is to present solutions to the same
task in as many different languages as possible,
to demonstrate how languages are similar and
different, and to aid a person with a grounding
in one approach to a problem in learning another.'''
print(
exceptGlyphs('eau')(txt)
)
# MAIN ---
if __name__ == '__main__':
main()</syntaxhighlight>
{{Out}}
<pre> Rostt Cod is progrmming chrstomthy sit.
Th id is to prsnt soltions to th sm
tsk in s mny diffrnt lnggs s possibl,
to dmonstrt how lnggs r similr nd
diffrnt, nd to id prson with gronding
in on pproch to problm in lrning nothr.</pre>
===One liner===
Well, almost........
<syntaxhighlight lang="python">
txt = '''
Rosetta Code is a programming chrestomathy site.
The idea is to present solutions to the same
task in as many different languages as possible,
to demonstrate how languages are similar and
different, and to aid a person with a grounding
in one approach to a problem in learning another.'''
print(''.join(list(filter(lambda a: a not in "aeiou",txt))))
</syntaxhighlight>
{{out}}
<pre>
Rstt Cd s prgrmmng chrstmthy st.
Th d s t prsnt sltns t th sm
tsk n s mny dffrnt lnggs s pssbl,
t dmnstrt hw lnggs r smlr nd
dffrnt, nd t d prsn wth grndng
n n pprch t prblm n lrnng nthr.
</pre>
=={{header|Quackery}}==
<syntaxhighlight lang="quackery">[ 0 $ "AEIOUaeiou"
witheach
[ bit | ] ] constant is vowels ( --> f )
[ $ "" swap
witheach
[ dup bit vowels & 0 =
iff join else drop ] ] is disemvowel ( $ --> $ )
$ '"Beautiful coquettes are quacks of love."'
$ ' -- Francois De La Rochefoucauld' join
disemvowel echo$</syntaxhighlight>
'''Output:'''
<pre>"Btfl cqtts r qcks f lv." -- Frncs D L Rchfcld</pre>
=={{header|Raku}}==
Line 74 ⟶ 1,923:
Otherwise, this should work for ''most'' Latinate languages.
Apropos of nothing; reminds me of one of my favorite Between the Lions performances: [https://www.youtube.com/watch?v=EkKKb6C8NKs Sloppy Pop - Sometimes Y]
Spec is 'Remove vowels from a string'; nothing about what they should be replaced with. I chose to replace them with spaces.
Line 79 ⟶ 1,930:
Strings from http://mylanguages.org/. No affiliation, but it's a nice resource. (note: these are not all the same sentence but are all from the same paragraph. They frankly were picked based on their vowel load.)
<syntaxhighlight lang="raku"
my $text = q:to/END/;
Norwegian, Icelandic, German, Turkish, French, Spanish, English:
Undervisningen skal være gratis, i det minste på de elementære og grunnleggende trinn.
Skal hún veitt ókeypis, að minnsta kosti barnafræðsla og undirstöðummentu.
Line 91 ⟶ 1,943:
END
put $text.subst(/@vowels/, ' ', :g);</syntaxhighlight>
{{out}}
<pre>
nd rv sn ng n sk l v r gr t s, d t m nst p d l m nt r g gr nnl gg nd tr nn.
Sk l h n v tt k yp s, ð m nnst k st b rn fr ðsl g nd rst ð mm nt .
H chsch l nt rr cht m ß ll n gl ch rm ß n ntspr ch nd hr n F h gk t n ff nst h n.
ğr n m h ç lm zs lk v t m l s fh l
L' d c t n d t tr gr t t , m ns n c q c nc rn l' ns gn m nt l m nt r t f nd m nt l.
L nstr cc n l m nt l s r bl g t r . L nstr cc n t cn c y pr f s n l h br d s r g n r l z d .
Line 115 ⟶ 1,955:
=={{header|REXX}}==
These two REXX versions remove the Latin (Roman) vowels and all those accented and Greek vowels that are supported in the '''437''' code page.
=== using the TRANSLATE BIF ===
This REXX version uses the '''translate''' BIF which works faster for longer strings as there is no character-by-character manipulation.
<syntaxhighlight lang="rexx">/*REXX program removes vowels (both lowercase and uppercase and accented) from a string.*/
parse arg x /*obtain optional argument from the CL.*/
if x='' | x="," then x= 'REXX Programming Language' /*Not specified? Then use default*/
say ' input string: ' x
vowels= 'AEIOUaeiou' || "üéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜáíóúªºαΩ" /*Latin + accented + Greek*/
$= translate( xrange(), ., ' ') /*define a string of almost all chars. */
q= substr($, verify($, x), 1) /*find a character NOT in the X string.*/
y= translate(x, q, " ") /*trans. blanks in the string (for now)*/
y= space(translate(y, ,
y= translate(y, , q) /*trans the Q characters back to blanks*/
say 'output string: ' y /*stick a fork in it, we're all done. */</
{{out|output|text= when using the default input:}}
<pre>
Line 132 ⟶ 1,976:
</pre>
=== using character eliding
This REXX version uses a character-by-character manipulation and should be easier to understand.
<syntaxhighlight lang="rexx">/*REXX program removes vowels (both lowercase and uppercase and accented) from a string.*/
parse arg x /*obtain optional argument from the CL.*/
if x='' | x="," then x= 'REXX Programming Language' /*Not specified? Then use default*/
say ' input string: ' x
vowels= 'AEIOUaeiou' || "üéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜáíóúªºαΩ" /*Latin + accented + Greek*/
x= . || x /*prefix string with a dummy character.*/
do j=length(x)-1 by -1 for length(x)-1 /*process the string from the back─end.*/
_= pos( substr(x, j, 1),
if _==0 then iterate /*if zero (not a vowel), then skip it.*/
x= left(x, j - 1) || substr(x, j + 1) /*elide the vowel just detected from X.*/
Line 146 ⟶ 1,992:
x= substr(x, 2) /*elide the prefixed dummy character. */
say 'output string: ' x /*stick a fork in it, we're all done. */</
{{out|output|text= is identical to the 1<sup>st</sup> REXX version.}} <br><br>
=={{header|Ring}}==
<
load "stdlib.ring"
str = "Ring Programming Language"
Line 160 ⟶ 2,006:
next
see "String without vowels: " + str + nl
</syntaxhighlight>
{{out}}
<pre>
Input : Ring Programming Language
String without vowels: Rng Prgrmmng Lngg
</pre>
=={{header|RPL}}==
≪ "AEIOUaeiou" → string vowels
≪ "" 1 string SIZE '''FOR''' j
string j DUP SUB
'''IF''' vowels OVER POS '''THEN''' DROP '''ELSE''' + '''END'''
'''NEXT'''
≫ ≫ ''''NOVWL'''' STO
{{in}}
<pre>
"This is a difficult sentence to pronounce" NOVWL
</pre>
{{out}}
<pre>
1: "Ths s dffclt sntnc t prnnc"
</pre>
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">
p "Remove vowels from a string".delete("aeiouAEIOU") # => "Rmv vwls frm strng"
</syntaxhighlight>
=={{header|Rust}}==
<syntaxhighlight lang="rust">
fn remove_vowels(str: String) -> String {
let vowels = "aeiouAEIOU";
let mut devowelled_string = String::from("");
for i in str.chars() {
if vowels.contains(i) {
continue;
} else {
devowelled_string.push(i);
}
}
return devowelled_string;
}
fn main() {
let intro =
String::from("Ferris, the crab, is the unofficial mascot of the Rust Programming Language");
println!("{}", intro);
println!("{}", remove_vowels(intro));
}
</syntaxhighlight>
Output :
<pre>
Ferris, the crab, is the unofficial mascot of the Rust Programming Language
Frrs, th crb, s th nffcl msct f th Rst Prgrmmng Lngg
</pre>
=={{header|sed}}==
<syntaxhighlight lang="sed">s/[AaEeIiOoUu]//g</syntaxhighlight>
=={{header|Smalltalk}}==
<syntaxhighlight lang="smalltalk">in := 'The balloon above harsh waters of programming languages, is the mascot of Smalltalk'.
out := in reject:[:ch | ch isVowel].
in printCR.
out printCR.</syntaxhighlight>
{{out}}
<pre>The balloon above harsh harsh waters of programming languages, is the mascot of Smalltalk
Th blln bv hrsh wtrs f prgrmmng lnggs, s th msct f Smlltlk</pre>
As usual, there are many alternative ways to do this:
<syntaxhighlight lang="smalltalk">out := in reject:#isVowel. " cool: symbols understand value: "
out := in select:[:ch | ch isVowel not].
out := in reject:[:ch | 'aeiou' includes:ch asLowercase ].
out := in reject:[:ch | #( $a $e $i $o $u ) includes:ch asLowercase ].
out := in reject:[:ch | 'AaEeIiOoUu' includes:ch ].
out := String streamContents:[:s |
in do:[:ch |
ch isVowel ifFalse:[ s nextPut:ch ]
]]
</syntaxhighlight>
=={{header|Standard ML}}==
<syntaxhighlight lang="sml">fun isVowel c =
CharVector.exists (fn v => c = v) "AaEeIiOoUu"
val removeVowels =
String.translate (fn c => if isVowel c then "" else str c)
val str = "LOREM IPSUM dolor sit amet\n"
val () = print str
val () = print (removeVowels str)</syntaxhighlight>
{{out}}
<pre>LOREM IPSUM dolor sit amet
LRM PSM dlr st mt</pre>
=={{header|Swift}}==
<syntaxhighlight lang="swift">func isVowel(_ char: Character) -> Bool {
switch (char) {
case "a", "A", "e", "E", "i", "I", "o", "O", "u", "U":
return true
default:
return false
}
}
func removeVowels(string: String) -> String {
return string.filter{!isVowel($0)}
}
let str = "The Swift Programming Language"
print(str)
print(removeVowels(string: str))</syntaxhighlight>
{{out}}
<pre>
The Swift Programming Language
Th Swft Prgrmmng Lngg
</pre>
=={{header|Visual Basic .NET}}==
<syntaxhighlight lang="vbnet">Imports System.Text
Module Module1
Function RemoveVowels(s As String) As String
Dim sb As New StringBuilder
For Each c In s
Select Case c
Case "A", "a"
Case "E", "e"
Case "I", "i"
Case "O", "o"
Case "U", "u"
Exit Select
Case Else
sb.Append(c)
End Select
Next
Return sb.ToString
End Function
Sub Test(s As String)
Console.WriteLine("Input : {0}", s)
Console.WriteLine("Output : {0}", RemoveVowels(s))
End Sub
Sub Main()
Test("Visual Basic .NET")
End Sub
End Module</syntaxhighlight>
{{out}}
<pre>Input : Visual Basic .NET
Output : Vsl Bsc .NT</pre>
=={{header|V (Vlang)}}==
{{trans|AutoHotkey}}
<syntaxhighlight lang="v (vlang)">fn main() {
mut str := 'The quick brown fox jumps over the lazy dog'
for val in 'aeiou'.split('') {str = str.replace(val,'')}
println(str)
}</syntaxhighlight>
{{out}}
<pre>
Th qck brwn fx jmps vr th lzy dg
</pre>
=={{header|Wren}}==
<
var s = "Wren Programming Language"
System.print("Input : %(s)")
System.print("Output : %(removeVowels.call(s))")</
{{out}}
Line 178 ⟶ 2,190:
Input : Wren Programming Language
Output : Wrn Prgrmmng Lngg
</pre>
=={{header|XBS}}==
<syntaxhighlight lang="xbs">func RemoveVowels(x:string):string{
set Vowels:array="aeiou"::split();
set nx:string="";
for(i=0;?x-1;1){
set c = x::at(i);
if (!Vowels::has(c::lower())){
nx+=x::at(i);
}
del c;
}
del Vowels;
send nx;
}
log(RemoveVowels("Hello, world!"));</syntaxhighlight>
{{out}}
<pre>
Hll, wrld!
</pre>
=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">string 0; \make strings zero-terminated
func Disemvowel(S); \remove vowels from string
char S;
int I, O;
[O:= 0;
for I:= 0 to -1>>1 do \for many times...
[case S(I) ! $20 of \shift to lowercase
^a,^e,^i,^o,^u: [] \do nothing
other [S(O):= S(I); O:= O+1]; \otherwise copy char
if S(I)=0 then return S;
];
];
Text(0, Disemvowel("pack my box with FIVE DOZEN LIQUOR JUGS!"))</syntaxhighlight>
Output:
<pre>
pck my bx wth FV DZN LQR JGS!
</pre>
=={{header|XProfan}}==
<syntaxhighlight lang="xprofan">cls
Set("RegEx",1)
Var string e = "The quick brown fox jumps over the lazy dog"
Var string a = Translate$(e,"(?i)[aeiou]","")
MessageBox("Input : "+e+"\nOutput: "+a,"Remove vowels",1)
End</syntaxhighlight>
{{out}}
<pre>
Input : The quick brown fox jumps over the lazy dog
Output: Th qck brwn fx jmps vr th lzy dg
</pre>
| |||