Remove vowels from a string: Difference between revisions

{{trans|Python}}

R s.filter(c -> c !C @exclusions).join(‘’)

in one approach to a problem in learning another.’

{{out}}

=={{header|8080 Assembly}}==

jmp demo

;;; Remove the vowels from the $-terminated string at [DE]

mvi c,9 ; Print using CP/M

jmp 5

{{out}}

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

CHAR ARRAY vovels="AEIOUaeiou"

BYTE i

Test("The Quick Brown Fox Jumped Over the Lazy Dog's Back")

Test("Action! is a programming language for Atari 8-bit computer.")

{{out}}

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

=={{header|Ada}}==

with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;

Put_Line (NV2);

end Main;

{{output}}

<pre>

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

# returns s with the vowels removed #

OP DEVOWEL = ( STRING s )STRING:

test devowel( "abcdefghijklmnoprstuvwxyz" );

test devowel( "Algol 68 Programming Language" )

{{out}}

<pre>

=={{header|APL}}==

{{out}}

<pre> devowel 'THE QUICK BROWN FOX jumps over the lazy dog'

We can also improve productivity by using library functions whenever feasible.

-- exceptGlyphs :: String -> String -> Bool

set my text item delimiters to dlm

s

{{Out}}

<pre>Rostt Cod is progrmming chrstomthy sit.

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.

-- searchText can be either a single string or a list of strings to be replaced with replacementText.

on replace(mainText, searchText, replacementText)

set devowelledText to replace(txt, {"a", "e", "i", "o", "u"}, "")

end ignoring

{{output}}

L'œvr d'n lv

vn Dijk

Jř Blhlvk cndcts Mrtn

P c pn tk brzczy w gszcz?

=={{header|Arturo}}==

{{out}}

=={{header|AutoHotkey}}==

for i, v in StrSplit("aeiou")

str := StrReplace(str, v)

{{out}}

<pre>Th qck brwn fx jmps vr th lzy dg</pre>

===RegEx Version===

{{out}}

<pre>Th qck brwn fx jmps vr th lzy dg</pre>

=={{header|AWK}}==

# syntax: GAWK -f REMOVE_VOWELS_FROM_A_STRING.AWK

BEGIN {

exit(0)

}

{{out}}

<pre>

=={{header|BASIC}}==

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

{{out}}

<pre>

</pre>

==={{header|BASIC256}}===

textofinal$ = ""

print textofinal$

==={{header|PureBasic}}===

mensaje.s = "If Peter Piper picked a pack of pickled peppers" + " or how many pickled peppers did Peter Piper pick?"

textofinal.s = ""

PrintN(textofinal)

Input()

==={{header|QBasic}}===

{{works with|QBasic|1.1}}

{{works with|QuickBasic|4.5}}

textofinal$ = ""

print textofinal$

==={{header|Yabasic}}===

textofinal$ = ""

print textofinal$

=={{header|BCPL}}==

let vowel(c) = valof

let start() be

{{out}}

<pre>TH QCK BRWN FX jmps vr th lzy dg.</pre>

=={{header|C}}==

{{trans|Go}}

void print_no_vowels(const char *s) {

test("C Programming Language");

return 0;

{{out}}

<pre>Input : C Programming Language

=={{header|C#}}==

{

var stripped = from c in value.ToCharArray()

test("CSharp Programming Language");

}

{{out}}

<pre>Input: CSharp Programming Language

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

#include <iostream>

test("C++ Programming Language");

return 0;

{{out}}

<pre>Input : C++ Programming Language

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

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

(defun remove-vowels (s)

=={{header|Cowgol}}==

include "strings.coh";

CopyString(str, &buf[0]); # make a copy of the string into writeable memory

Devowel(&buf[0]); # remove the vowels

{{out}}

=={{header|D}}==

void print_no_vowels(string s) {

void main() {

print_no_vowels("D Programming Language");

{{out}}

<pre>D Prgrmmng Lngg</pre>

=={{header|Delphi}}==

{{libheader| System.SysUtils}}

program Remove_vowels_from_a_string;

end.

{{out}}

=={{header|F_Sharp|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")

{{out}}

<pre>

=={{header|Factor}}==

: without-vowels ( str -- new-str ) "aeiouAEIOU" without ;

"Factor Programming Language" dup without-vowels

{{out}}

<pre>

=={{header|Forth}}==

: VALIDATE ( char addr len -- 0|n) ROT SCAN NIP ; \ find char in string

THEN

LOOP

{{out}}

<pre>

=={{header|Fortran}}==

program remove_vowels

implicit none

end subroutine print_no_vowels

end program remove_vowels

{{out}}

<pre>

=={{header|FreeBASIC}}==

", how many pickled peppers did Peter Piper pick?"

dim as string outstr = "", c

next i

=={{header|Free Pascal}}==

''See also [[#Pascal|Pascal]]''

{{libheader|strUtils}}

uses

strUtils;

end;

writeLn(line)

=={{header|Fōrmulæ}}==

=={{header|Go}}==

import (

fmt.Println("Input :", s)

fmt.Println("Output :", removeVowels(s))

{{out}}

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

exceptGlyphs :: String -> String -> String

main :: IO ()

or, in terms of filter:

{{Out}}

=={{header|Java}}==

String re = "";

char c;

}

return re;

=={{header|JavaScript}}==

( ''Pace'' Jamie Zawinski, some people, when confronted with a problem, think "I know, I'll use '''parser combinators'''." )

'use strict'

// main ---

return main();

{{Out}}

<pre> Rostt Cod is progrmming chrstomthy sit.

but a filter is all we need here:

'use strict';

// main ---

return main();

{{Out}}

<pre> Rostt Cod is progrmming chrstomthy sit.

{{works with|jq}}

'''Works with gojq, the Go implementation of jq'''

#!/bin/bash

input | jq -Rr --arg v "$vowels" 'gsub("[\($v)]+"; ""; "i")'

{{out}}

<pre>

=={{header|Julia}}==

Unicode sensitive, using the Raku version example text.

const ALLVOWELSY = Dict(ch => 1 for ch in Vector{Char}("AÀÁÂÃÄÅĀĂĄǺȀȂẠẢẤẦẨẪẬẮẰẲẴẶḀÆǼEȄȆḔḖḘḚḜẸẺẼẾỀỂỄỆĒĔĖĘĚÈÉÊËIȈȊḬḮỈỊĨĪĬĮİÌÍÎÏIJOŒØǾȌȎṌṎṐṒỌỎỐỒỔỖỘỚỜỞỠỢŌÒÓŎŐÔÕÖUŨŪŬŮŰŲÙÚÛÜȔȖṲṴṶṸṺỤỦỨỪỬỮỰYẙỲỴỶỸŶŸÝ"))

println("Removing vowels from:\n$testtext\n becomes:\n",

String(filter(!isvowel, Vector{Char}(testtext))))

<pre>

Removing vowels from:

=={{header|Kotlin}}==

val re = StringBuilder()

for (c in s) {

fun main() {

println(removeVowels("Kotlin Programming Language"))

{{out}}

<pre>Ktln Prgrmmng Lngg</pre>

=={{header|Lambdatalk}}==

'{S.replace [aeiouy]* by in

Rosetta Code is a programming chrestomathy site.

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

=={{header|Lua}}==

local outStr, letter = ""

local vowels = "AEIUOaeiou"

local testStr = "The quick brown fox jumps over the lazy dog"

{{out}}

<pre>Th qck brwn fx jmps vr th lzy dg</pre>

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

{{out}}

<pre>Th Qck Brwn Fx Jmpd Ovr th Lzy Dg's Bck</pre>

=={{header|MATLAB}} / {{header|Octave}}==

function [result] = remove_vowels(text)

% http://rosettacode.org/wiki/Remove_vowels_from_a_string

%!test

%! assert(remove_vowels('The quick brown fox jumps over the lazy dog'),'Th qck brwn fx jmps vr th lzy dg')

{{out}}

=={{header|Nim}}==

const Vowels = {'a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'}

const TestString = "The quick brown fox jumps over the lazy dog"

echo TestString

{{out}}

''See also [[#Delphi|Delphi]] or [[#Free Pascal|Free Pascal]]''<br/>

This program works with any ISO 7185 compliant compiler.

const

end;

writeLn

{{in}}

The quick brown fox jumps over the lazy dog.

{{works with|Extended Pascal}}

More convenient though is to use some Extended Pascal (ISO 10206) features:

const

vowels = ['A', 'E', 'I', 'O', 'U', 'a', 'e', 'i', 'o', 'u'];

writeLn(disemvoweledLine)

{{in}}

The quick brown fox jumps over the lazy dog.

=={{header|Perl}}==

Inspired by the Raku entry.

use warnings;

use utf8;

my @vowels;

chr($_) =~ /[aæeiıoœu]/i and push @vowels, chr($_) for 0x20 .. 0x1ff;

{{out}}

<pre>N rw g n, c l nd c, G rm n, T rk sh, Fr nch, Sp n sh, ngl sh:

=={{header|Phix}}==

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

{{out}}

<pre>

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

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</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>

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

println("The Quick Brown Fox Jumped Over the Lazy Dog's Back".remove_vowels),

println("Picat programming language".remove_vowels).

{{out}}

:- system:set_prolog_flag(double_quotes,chars) .

lists:member(CHAR,"AEIOUaeiouüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜáíóúªºαΩ")

.

{{out}}

{{works with|Python|3.7|}}

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre> Rostt Cod is progrmming chrstomthy sit.

===One liner===

Well, almost........

txt = '''

Rosetta Code is a programming chrestomathy site.

print(''.join(list(filter(lambda a: a not in "aeiou",txt))))

{{out}}

<pre>

=={{header|Quackery}}==

witheach

[ bit | ] ] constant is vowels ( --> f )

$ '"Beautiful coquettes are quacks of love."'

$ ' -- Francois De La Rochefoucauld' join

'''Output:'''

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 $text = q:to/END/;

END

{{out}}

<pre>N rw g n, c l nd c, G rm n, T rk sh, Fr nch, Sp n sh, ngl sh:

=== using the TRANSLATE BIF ===

This REXX version uses the &nbsp; '''translate''' &nbsp; BIF which works faster for longer strings as there is no character-by-character manipulation.

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

if x='' | x="," then x= 'REXX Programming Language' /*Not specified? Then use default*/

y= space(translate(y, , vowels), 0) /*trans. vowels──►blanks, elide blanks.*/

y= translate(y, , q) /*trans the Q characters back to blanks*/

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

<pre>

=== using character eliding ===

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

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

if x='' | x="," then x= 'REXX Programming Language' /*Not specified? Then use default*/

x= substr(x, 2) /*elide the prefixed dummy character. */

{{out|output|text=&nbsp; is identical to the 1^st REXX version.}} <br><br>

=={{header|Ring}}==

load "stdlib.ring"

str = "Ring Programming Language"

next

see "String without vowels: " + str + nl

{{out}}

<pre>

</pre>

=={{header|Ruby}}==

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

=={{header|Rust}}==

fn remove_vowels(str: String) -> String {

let vowels = "aeiouAEIOU";

println!("{}", remove_vowels(intro));

}

Output :

<pre>

=={{header|Smalltalk}}==

out := in reject:[:ch | ch isVowel].

in printCR.

{{out}}

<pre>The balloon above harsh harsh waters of programming languages, is the mascot of Smalltalk

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

out := in select:[:ch | ch isVowel not].

ch isVowel ifFalse:[ s nextPut:ch ]

]]

=={{header|Standard ML}}==

CharVector.exists (fn v => c = v) "AaEeIiOoUu"

val str = "LOREM IPSUM dolor sit amet\n"

val () = print str

{{out}}

<pre>LOREM IPSUM dolor sit amet

=={{header|Swift}}==

switch (char) {

case "a", "A", "e", "E", "i", "I", "o", "O", "u", "U":

let str = "The Swift Programming Language"

print(str)

{{out}}

=={{header|Visual Basic .NET}}==

Module Module1

End Sub

{{out}}

<pre>Input : Visual Basic .NET

{{trans|AutoHotkey}}

mut str := 'The quick brown fox jumps over the lazy dog'

for val in 'aeiou'.split('') {str = str.replace(val,'')}

println(str)

{{out}}

=={{header|Wren}}==

var s = "Wren Programming Language"

System.print("Input : %(s)")

{{out}}

=={{header|XBS}}==

set Vowels:array="aeiou"::split();

set nx:string="";

}

{{out}}

<pre>

=={{header|XPL0}}==

func Disemvowel(S); \remove vowels from string

];

Output:

=={{header|XProfan}}==

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)

{{out}}

<pre>