Remove vowels from a string

From Rosetta Code
Remove vowels from a string is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

Remove vowels from a string

Other tasks related to string operations:
Metrics
Counting
Remove/replace
Anagrams/Derangements/shuffling
Find/Search/Determine
Formatting
Song lyrics/poems/Mad Libs/phrases
Tokenize
Sequences



11l

Translation of: Python
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))
Output:

    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.

8080 Assembly 

	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$'
Output:
TH QCK BRWN FX jmps vr th lzy dg

AArch64 Assembly

Works with: as version Raspberry Pi 3B version Buster 64 bits
or android 64 bits with application Termux
/* ARM assembly AARCH64 Raspberry PI 3B */
/*  program supvoyelles64.s   */
   

/*******************************************/
/* Constantes                              */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc" 

.equ BUFFERSIZE,    480
.equ SENTENCESTART,  0
/*******************************************/
/*   Macros                              */
/*******************************************/
//.include "../../ficmacros64.inc"            // for developer debugging

/*********************************/
/* Initialized data              */
/*********************************/
.data
szMessDebutPgm:   .asciz "Program 64 bits start. \n"
szCarriageReturn: .asciz "\n"
szMessFinOK:      .asciz "Program normal end. \n"
szMessErreur:     .asciz "Error  Buffer too small!!!\n"
szSpace1:         .asciz " "

szPhrase1:          .asciz "THE QUICK BROWN FOX jumps over the lazy dog$"
                   
.equ LGPHRASE1,  . -  szPhrase1 - 1

         
/*********************************/
/* UnInitialized data            */
/*********************************/
.bss
.align 4

/*********************************/
/*  code section                 */
/*********************************/
.text
.global main 
main:
    ldr x0,qAdrszMessDebutPgm
    bl affichageMess               // start message 
    sub sp,sp,#BUFFERSIZE
    mov x7,sp
    ldr x4,qAdrszPhrase1            // load phrase adress 
    mov x5,#0
    mov x6,#SENTENCESTART
1:
    ldrb w1,[x4,x5]
    cmp x1,#0
    beq 10f
    cmp x1,#'a'
    beq 2f
    cmp x1,#'A'
    beq 2f
    cmp x1,#'e'
    beq 2f
    cmp x1,#'E'
    beq 2f
    cmp x1,#'i'
    beq 2f
    cmp x1,#'I'
    beq 2f
    cmp x1,#'o'
    beq 2f
    cmp x1,#'O'
    beq 2f
    cmp x1,#'u'
    beq 2f
    cmp x1,#'U'
    beq 2f
    cmp x1,#'y'
    beq 2f
    cmp x1,#'Y'
    beq 2f
    strb w1,[x7,x6]
    add x6,x6,#1
    cmp x6,#BUFFERSIZE
    bge 99f
  
2:
    add x5,x5,#1
    b 1b

 
10:
    mov x1,#0x0A                   // return line
    strb w1,[x7,x6]  
    add x6,x6,#1    
    mov x1,#0
    strb w1,[x7,x6]                // final zero
    mov x0,x7
    bl affichageMess
    
    ldr x0,qAdrszMessFinOK
    bl affichageMess       
    b 100f
99:
    ldr x0,qAdrszMessErreur        // error
    bl affichageMess
    mov x0, #1                     // return code error
    b 100f
100: 
    mov x8,EXIT 
    svc #0                         // system call
qAdrszMessDebutPgm:          .quad szMessDebutPgm
qAdrszMessFinOK:             .quad szMessFinOK
qAdrszMessErreur:            .quad szMessErreur 
qAdrszPhrase1:               .quad szPhrase1

/***************************************************/
/*      ROUTINES INCLUDE                 */
/***************************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeARM64.inc"
Output:
Program 64 bits start.
TH QCK BRWN FX jmps vr th lz dg$
Program normal end.

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
Output:

Screenshot from Atari 8-bit computer 

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.

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;
Output:
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!!

ALGOL 68 

BEGIN
    # returns s with the vowels removed #
    OP DEVOWEL = ( STRING s )STRING:
       BEGIN
            [ LWB s : UPB s ]CHAR result;
            INT r pos := LWB result - 1;
            FOR s pos FROM LWB s TO UPB s DO
                IF NOT char in string( s[ s pos ], NIL, "aeiouAEIOU" ) THEN
                    # have a non-vowel - add it to the output #
                    r pos +:= 1;
                    result[ r pos ] := s[ s pos ]
                FI
            OD;
            result[ LWB s : r pos ]
       END # DEVOWEL # ;
    # tests the DEVOWEL operator #
    PROC test devowel = ( STRING s )VOID:
         print( ( "<", s, "> -> <", DEVOWEL s, ">", newline ) );
    # some test cases #
    test devowel( ""                              );
    test devowel( "aAeEiIoOuU"                    );
    test devowel( "bcdfghjklmnprstvwxyz"          );
    test devowel( "abcdefghijklmnoprstuvwxyz"     );
    test devowel( "Algol 68 Programming Language" )
END
Output:
<> -> <>
<aAeEiIoOuU> -> <>
<bcdfghjklmnprstvwxyz> -> <bcdfghjklmnprstvwxyz>
<abcdefghijklmnoprstuvwxyz> -> <bcdfghjklmnprstvwxyz>
<Algol 68 Programming Language> -> <lgl 68 Prgrmmng Lngg>

APL 

devowel ← ~∘'AaEeIiOoUu'
Output:
      devowel 'THE QUICK BROWN FOX jumps over the lazy dog'
TH QCK BRWN FX jmps vr th lzy dg

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. 

------- 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
Output:
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.

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. 

-- 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
Output:
"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"

ARM Assembly

Works with: as version Raspberry Pi
or android 32 bits with application Termux
/* ARM assembly Raspberry PI  */
/*  program supvoyelles.s   */
   
/* REMARK 1 : this program use routines in a include file 
   see task Include a file language arm assembly 
   for the routine affichageMess conversion10 
   see at end of this program the instruction include */

/*******************************************/
/* Constantes                              */
/*******************************************/
.include "../constantes.inc"

.equ BUFFERSIZE,    500
.equ SENTENCESTART,  0
/*******************************************/
/*   Macros                              */
/*******************************************/
//.include "../../ficmacros32.inc"            @ for developer debugging

/*********************************/
/* Initialized data              */
/*********************************/
.data
szMessDebutPgm:   .asciz "Program 32 bits start. \n"
szCarriageReturn: .asciz "\n"
szMessFinOK:      .asciz "Program normal end. \n"
szMessErreur:     .asciz "Error  Buffer too small!!!\n"
szSpace1:         .asciz " "

szPhrase1:          .ascii "hi there, how are you today?\n"
                    .ascii "I'd like to present to you the washing machine 9001.\n"
                    .ascii " You have been nominated to win one of these!\n"
                    .asciz " Just make sure you don't break it"
.equ LGPHRASE1,  . -  szPhrase1 - 1

         
/*********************************/
/* UnInitialized data            */
/*********************************/
.bss
.align 4

/*********************************/
/*  code section                 */
/*********************************/
.text
.global main 
main:
    ldr r0,iAdrszMessDebutPgm
    bl affichageMess               @ start message 
    sub sp,sp,#BUFFERSIZE
    mov r7,sp
    ldr r4,iAdrszPhrase1            @ load phrase adress 
    mov r5,#0
    mov r6,#SENTENCESTART
1:
    ldrb r1,[r4,r5]
    cmp r1,#0
    beq 10f
    cmp r1,#'a'
    beq 2f
    cmp r1,#'A'
    beq 2f
    cmp r1,#'e'
    beq 2f
    cmp r1,#'E'
    beq 2f
    cmp r1,#'i'
    beq 2f
    cmp r1,#'I'
    beq 2f
    cmp r1,#'o'
    beq 2f
    cmp r1,#'O'
    beq 2f
    cmp r1,#'u'
    beq 2f
    cmp r1,#'U'
    beq 2f
    cmp r1,#'y'
    beq 2f
    cmp r1,#'Y'
    beq 2f
    strb r1,[r7,r6]
    add r6,r6,#1
    cmp r6,#BUFFERSIZE
    bge 99f
  
2:
    add r5,r5,#1
    b 1b

 
10:
    mov r1,#0x0A        @ return line
    strb r1,[r7,r6]  
    add r6,r6,#1    
    mov r1,#0
    strb r1,[r7,r6]     @ final zero
    mov r0,r7
    bl affichageMess
    
    ldr r0,iAdrszMessFinOK
    bl affichageMess       
    b 100f
99:
    ldr r0,iAdrszMessErreur        @ error
    bl affichageMess
    mov r0, #1                     @ return code error
    b 100f
100: 
    mov r7,#EXIT                   @ program end
    svc #0                         @ system call
iAdrszMessDebutPgm:          .int szMessDebutPgm
iAdrszMessFinOK:             .int szMessFinOK
iAdrszMessErreur:            .int szMessErreur 
iAdrszPhrase1:               .int szPhrase1

/***************************************************/
/*      ROUTINES INCLUDE                 */
/***************************************************/
.include "../affichage.inc"
Output:
Program 32 bits start.
h thr, hw r  td?
'd lk t prsnt t  th wshng mchn 9001.
  hv bn nmntd t wn n f ths!
 Jst mk sr  dn't brk t
Program normal end.

Arturo 

str: "Remove vowels from a string"

print str -- split "aeiouAEIOU"
Output:
Rmv vwls frm  strng

AutoHotkey 

str := "The quick brown fox jumps over the lazy dog"
for i, v in StrSplit("aeiou")
	str := StrReplace(str, v)
MsgBox % str
Output:
Th qck brwn fx jmps vr th lzy dg

RegEx Version

str := "The quick brown fox jumps over the lazy dog"
MsgBox % str := RegExReplace(str, "i)[aeiou]")
Output:
Th qck brwn fx jmps vr th lzy dg

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)
}
Output:
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


BASIC

Applesoft BASIC 

S$ = "Remove a defined subset of glyphs from a string."

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$;
Output:
Rmv  dfnd sbst f glyphs frm  strng.

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

Chipmunk Basic

Translation of: FreeBASIC
Works with: Chipmunk Basic version 3.6.4
100 mensaje$ = "If Peter Piper picked a pack of pickled peppers"+", how many pickled peppers did Peter Piper pick?"
110 textofinal$ = ""
120 for i = 1 to len(mensaje$)
130   c$ = mid$(mensaje$,i,1)
140   select case c$
150   case "a","e","i","o","u","A","E","I","O","U"
160     rem continue for
170   case else
180     textofinal$ = textofinal$+c$
190   end select
200 next i
210 print textofinal$

Gambas

Translation of: FreeBASIC
Public Sub Main() 
  
  Dim mensaje As String = "If Peter Piper picked a pack of pickled peppers, how many pickled peppers did Peter Piper pick?" 
  Dim textofinal As String = ""
  Dim c As String
  
  For i As Integer = 1 To Len(mensaje) 
    c = Mid(mensaje, i, 1) 
    Select Case c 
      Case "a", "e", "i", "o", "u", "A", "E", "I", "O", "U" 
        Continue 
      Case Else 
        textofinal &= c 
    End Select 
  Next 
  
  Print textofinal
  
End

GW-BASIC

Works with: PC-BASIC version any
Works with: BASICA
Works with: MSX BASIC version any
Works with: QBasic
Works with: Chipmunk Basic
10 MS$ = "If Peter Piper picked a pack of pickled peppers, how many pickled peppers did Peter Piper pick?"
20 TF$ = ""
30 FOR I = 1 TO LEN(MS$)
40   C$ = MID$(MS$,I,1)
50   IF C$ <> "a" AND C$ <> "e" AND C$ <> "i" AND C$ <> "o" AND C$ <> "u" AND C$ <> "A" AND C$ <> "E" AND C$ <> "I" AND C$ <> "O" AND C$ <> "U" THEN TF$ = TF$ + C$
60 NEXT I
70 PRINT TF$

MSX Basic

Works with: MSX BASIC version any

Same code as GW-BASIC

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

QBasic

Works with: QBasic version 1.1
Works with: QuickBasic version 4.5
Works with: QB64
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

Quite BASIC

Translation of: FreeBASIC
10 LET M$ = "If Peter Piper picked a pack of pickled peppers, how many pickled peppers did Peter Piper pick?"
20 LET T$ = ""
30 FOR I = 1 TO LEN(M$)
40   LET C$ = MID$(M$,I,1)
50   IF C$ <> "a" AND C$ <> "e" AND C$ <> "i" AND C$ <> "o" AND C$ <> "u" AND C$ <> "A" AND C$ <> "E" AND C$ <> "I" AND C$ <> "O" AND C$ <> "U" THEN LET T$ = T$ + C$
60 NEXT I
70 PRINT T$

XBasic

Works with: Windows XBasic
Translation of: FreeBASIC
PROGRAM	"Remove vowels from a string"
VERSION	"0.0000"

DECLARE FUNCTION  Entry ()

FUNCTION  Entry ()
    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"
            ' Skip the vowel
        CASE ELSE
            textofinal$ = textofinal$ + c$
        END SELECT
    NEXT i

    PRINT textofinal$
END FUNCTION
END PROGRAM

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


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"))
Output:
TH QCK BRWN FX jmps vr th lzy dg.

BQN 

Devowel ← ¬∘∊⟜"AaEeIiOoUu"⊸/

C

Translation of: Go
#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;
}
Output:
Input  : C Programming Language
Output : C Prgrmmng Lngg

C# 

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");
}
Output:
Input:  CSharp Programming Language
Output: CShrp Prgrmmng Lngg

C++ 

#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;
}
Output:
Input  : C++ Programming Language
Output : C++ Prgrmmng Lngg

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

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
Output:
TH QCK BRWN FX jmps vr th lzy dg.

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");
}
Output:
D Prgrmmng Lngg

Dart

Translation of: C++
void main() {
  test("Dart Programming Language");
}

class PrintNoVowels {
  final String str;

  PrintNoVowels(this.str);

  @override
  String toString() {
    StringBuffer buffer = StringBuffer();
    for (int i = 0; i < str.length; i++) {
      String c = str[i];
      switch (c) {
        case 'A':
        case 'E':
        case 'I':
        case 'O':
        case 'U':
        case 'a':
        case 'e':
        case 'i':
        case 'o':
        case 'u':
          break;
        default:
          buffer.write(c);
          break;
      }
    }
    return buffer.toString();
  }
}

void test(String s) {
  print("Input  : $s");
  print("Output : ${PrintNoVowels(s)}");
}
Output:
Input  : Dart Programming Language
Output : Drt Prgrmmng Lngg

Delphi

Library: System.SysUtils
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.
Output:
Before: The quick brown fox jumps over the lazy dog
After:  Th qck brwn fx jmps vr th lzy dg

EasyLang 

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"

ed

Solution adapted from Strip a set of characters from a string 

H
# can also do g/.*/s/[aeiou]//gi on GNU ed
g/.*/s/[aeiouAEIOU]//g
,p
Q
Output:
$ cat strip-vowels.ed | ed -lEGs strip-vowels.input 
Newline appended
TH QCK BRWN FX jmps vr th lzy dg

F# 

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")
Output:
"Ngl Gllwy"

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
Output:
  Input string: Factor Programming Language
Without vowels: Fctr Prgrmmng Lngg

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 ;
Output:
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

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
Output:
Th qck brwn fx jmps vr th lzy dg. 

Frtrn prgrmmng lngg

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

Free Pascal

See also Pascal

Library: strUtils
{$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.

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 ]
Output:
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.

Fōrmulæ

Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.

Programs in Fōrmulæ are created/edited online in its website.

In this page you can see and run the program(s) related to this task and their results. You can also change either the programs or the parameters they are called with, for experimentation, but remember that these programs were created with the main purpose of showing a clear solution of the task, and they generally lack any kind of validation.

Solution

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
Output:
Th qck brwn fx jmps vr th lzy dg.
FtrBsc s  grt prgrmmng lngg!

Go 

package main

import (
    "fmt"
    "strings"
)

func removeVowels(s string) string {
    var sb strings.Builder
    vowels := "aeiouAEIOU"
    for _, c := range s {
        if !strings.ContainsAny(string(c), vowels) {
            sb.WriteRune(c)
        }
    }
    return sb.String()
}

func main() {
    s := "Go Programming Language"
    fmt.Println("Input  :", s)
    fmt.Println("Output :", removeVowels(s))
}
Output:
Input  : Go Programming Language
Output : G Prgrmmng Lngg

Haskell

Removing three specific Anglo-Saxon vowels from a text, using a general method which can apply to any specific subset of glyphs. 

------ 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
Output:
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.

J 

devowel =: -. & 'aeiouAEIOU'

Java

You can use the String.replaceAll method, which takes a regular expression as it's first argument. 

"rosettacode.org".replaceAll("(?i)[aeiou]", "");


Or 

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

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

(() => {
    '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();
})();
Output:
            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.


but a filter is all we need here: 

(() => {
    '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();
})();
Output:
            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.

Joy 

DEFINE unvowel == ["AaEeIiOoUu" in not] filter.

"Remove ALL vowels from this input!" unvowel putchars.
Output:
Rmv LL vwls frm ths npt!

jq

Works with: jq

Works with gojq, the Go implementation of jq 

#!/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")'
Output:
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.

Julia

Unicode sensitive, using the Raku version example text. 

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))))
Output:
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.

K

Works with: ngn/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"

Kotlin 

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"))
}
Output:
Ktln Prgrmmng Lngg

Lambdatalk 

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

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))
Output:
Th qck brwn fx jmps vr th lzy dg



Mathematica /Wolfram Language 

StringReplace["The Quick Brown Fox Jumped Over the Lazy Dog's Back", (Alternatives @@ Characters["aeiou"]) -> ""]
Output:
Th Qck Brwn Fx Jmpd Ovr th Lzy Dg's Bck

MATLAB / Octave 

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')
Output:
ans = Th WK Prgrmmng Lngg
ans = Th qck brwn fx jmps vr th lzy dg

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))
Output:
The quick brown fox jumps over the lazy dog
Th qck brwn fx jmps vr th lzy dg

Nu

Works with: Nushell version 0.96.1
$in | str replace -a -r '(?i)[aeiou]' ''

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

OmniMark

What is considered a vowel for this task?

  1. Only English AEIOUaeiou, not Yy?
  2. ISO-8859-1 vowels? (So, adding, "ÀÁÂÃÄÅÆÈÉÊËÌÍÎÏÒÓÔÕÖØÙÚÛÜàáâãäåæèéêëìíîïòóôõöùúûü".)
  3. Any Unicode plausible vowel, which could include: "ꭤ ａ ⱥ ⒜" (U+AB64 U+FF41 U+2C65 U+249C) and all sorts of other characters, perhaps even including combining characters like " ͣ" (U+0363)?

Only 1 and 2 have been considered. The lack of `output` after the `find` rules means that the vowels are suppressed and the rest of the input stream is output as-is.

Solution 1 

process
  submit 'The Quick Brown Fox Jumps Over the Lazy Dog.%n'

find ul ['aeiou']
Output:
Th Qck Brwn Fx Jmps vr th Lzy Dg.

Solution 2 

macro latin1-vowels is
  ['AEIOUaeiouÀÁÂÃÄÅÆÈÉÊËÌÍÎÏÒÓÔÕÖØÙÚÛÜàáâãäåæèéêëìíîïòóôõöùúûü']
macro-end

process
  submit 'AÀÁÂÃÄÅÆThe EÈÉÊËQuick IÌÍÎÏBrown OÒÓÔÕÖØFox UÙÚÛÜJumps ' ||
         'aàáâãäåæOver eèéêëthe iìíîïLazy oòóôõöDog.uùúûü%n'

find latin1-vowels
Output:
Th Qck Brwn Fx Jmps vr th Lzy Dg.

Pascal

See also Delphi or Free Pascal
This program works with any ISO 7185 compliant compiler. 

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.
Input:
The quick brown fox jumps over the lazy dog.
Output:
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: 

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.
Input:
The quick brown fox jumps over the lazy dog.
Output:
Th qck brwn fx jmps vr th lzy dg.

Perl

Inspired by the Raku entry. 

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;
Output:
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.

Phix 

constant s = "Phix Programming Language"
printf(1,"Input  : %s\nOutput : %s\n",{s,filter(s,"out","aeiouAEIUO")})
Output:
Input  : Phix Programming Language
Output : Phx Prgrmmng Lngg

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 

with javascript_semantics

constant vowels = utf8_to_utf32("AEIOUIÖaeiouæáåäéêióöú"),
s = """
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.
"""
 
function remove_vowels(sequence s)
    s = utf8_to_utf32(s)
    for i=length(s) to 1 by -1 do
        if find(s[i],vowels) then s[i] = ' ' end if
--      if find(s[i],vowels) then s[i..i] = "" end if
    end for
    s = utf32_to_utf8(s)
    return s
end function
printf(1,"%s\n",remove_vowels(s))

(output deliberately not shown due to windows console effects, but it is the same as Raku, or Julia with the alternate find/replace line.)

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")].
Output:
Th Qck Brwn Fx Jmpd vr th Lzy Dg's Bck
Pct prgrmmng lngg

Prolog

Works with: SWI-Prolog version 7


:- 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üéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜáíóúªºαΩ")
.
Output:
/*
?- 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].

?- 
*/

Python

Functional

Removing 3 particular Anglo-Saxon vowels from a string:

Works with: Python version 3.7
'''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()
Output:
        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.

One liner

Well, almost........ 

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))))
Output:
        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.

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$

Output: 

"Btfl cqtts r qcks f lv." -- Frncs D L Rchfcld

Raku

Works with: Rakudo version 2020.07

Not going to bother with 'y', it's too touchy feely (How many vowels are in the word my? why? any?) and subject to interpretation.

Otherwise, this should work for most Latinate languages.

Apropos of nothing; reminds me of one of my favorite Between the Lions performances: 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.

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

my @vowels = (0x20 .. 0x2fff).map: { .chr if .chr.samemark('x') ~~ m:i/<[aæeiıoœu]>/ }

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

put $text.subst(/@vowels/, ' ', :g);
Output:
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.

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. 

/*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, , vowels), 0)              /*trans. vowels──►blanks, elide blanks.*/
y= translate(y, , q)                             /*trans the Q characters back to blanks*/
say 'output string: '    y                       /*stick a fork in it,  we're all done. */
output   when using the default input:
 input string:  REXX Programming Language
output string:  RXX Prgrmmng Lngg

using character eliding

This REXX version uses a character-by-character manipulation and should be easier to understand. 

/*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), vowels)            /*is this particular character a vowel?*/
     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.*/
     end   /*j*/

x= substr(x, 2)                                  /*elide the prefixed dummy character.  */
say 'output string: '    x                       /*stick a fork in it,  we're all done. */
output   is identical to the 1st REXX version.



Ring 

load "stdlib.ring"
str = "Ring Programming Language"
see "Input : " + str + nl
for n = 1 to len(str)
    if isVowel(str[n])
       str = substr(str,str[n],"")
    ok
next
see "String without vowels: " + str + nl
Output:
Input : Ring Programming Language
String without vowels: Rng Prgrmmng Lngg

RPL 

≪ "AEIOUaeiou" → string vowels
  ≪ "" 1 string SIZE FOR j
       string j DUP SUB
       IF vowels OVER POS THEN DROP ELSE + END 
    NEXT
≫ ≫ 'NOVWL' STO
Input:
"This is a difficult sentence to pronounce" NOVWL
Output:
1: "Ths s  dffclt sntnc t prnnc"

Ruby 

p "Remove vowels from a string".delete("aeiouAEIOU") # => "Rmv vwls frm  strng"

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

Output : 

Ferris, the crab, is the unofficial mascot of the Rust Programming Language
Frrs, th crb, s th nffcl msct f th Rst Prgrmmng Lngg

sed 

s/[AaEeIiOoUu]//g

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.
Output:
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

As usual, there are many alternative ways to do this: 

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

Standard ML 

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)
Output:
LOREM IPSUM dolor sit amet
LRM PSM dlr st mt

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))
Output:
The Swift Programming Language
Th Swft Prgrmmng Lngg

Visual Basic .NET 

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
Output:
Input  : Visual Basic .NET
Output : Vsl Bsc .NT

V (Vlang)

Translation of: AutoHotkey
fn main() {
    mut str := 'The quick brown fox jumps over the lazy dog'
    for val in 'aeiou'.split('') {str = str.replace(val,'')}
    println(str)
}
Output:
Th qck brwn fx jmps vr th lzy dg

Wren 

var removeVowels = Fn.new { |s| s.where { |c| !"aeiouAEIOU".contains(c) }.join() }

var s = "Wren Programming Language"
System.print("Input  : %(s)")
System.print("Output : %(removeVowels.call(s))")
Output:
Input  : Wren Programming Language
Output : Wrn Prgrmmng Lngg

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!"));
Output:
Hll, wrld!

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

Output: 

pck my bx wth FV DZN LQR JGS!

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
Output:
Input : The quick brown fox jumps over the lazy dog
Output: Th qck brwn fx jmps vr th lzy dg
Retrieved from "https://rosettacode.org/wiki/Remove_vowels_from_a_string?oldid=369105"