Selectively replace multiple instances of a character within a string: Difference between revisions

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

, the fourth 'a' with 'C', the fifth 'a' with 'D'

the first 'b' with 'E', the second 'r' with 'F'

IF output /= "AErBcadCbFD" THEN print( ( " ** UNEXPECTED RESULT" ) ) FI;

print( ( newline ) )

{{out}}

<pre>

=={{header|AutoHotkey}}==

steps := [[1, "a", "A"]

, [2, "a", "B"]

result .= Res[j] = "" ? x[j] : Res[j]

return result

{{out}}

<pre>AErBcadCbFD</pre>

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

#include <iostream>

#include <string>

std::cout << magic << "\n";

{{out}}

<pre>

=={{header|Factor}}==

{{works with|Factor|0.99 2022-04-03}}

CONSTANT: instrs {

"abracadabra" test

{{out}}

<pre>

=={{header|FreeBASIC}}==

Dim As String A = "ABaCD", B = "Eb", R = "rF"

Dim As Byte pA = 1, pB = 1, pR = 1

S = "caarabadrab"

Print S; " -> "; replaceChar(S)

{{out}}

<pre>abracadabra -> AErBcadCbFD

=={{header|Go}}==

{{trans|Wren}}

import (

s = strings.Replace(s, "F", "r", 1)

fmt.Println(s)

{{out}}

=={{header|Haskell}}==

As a map-accumulation:

import qualified Data.Map.Strict as M

import Data.Maybe (fromMaybe)

('b', [Just 'E']),

('r', [Nothing, Just 'F'])

{{Out}}

<pre>AErBcadCbFD</pre>

=={{header|J}}==

'ABCD' 'a' upd 0 1 3 4 'E' 'b' upd 0 'F' 'r' upd 1 'abracadabra'

<tt>upd</tt> here takes four arguments -- two on the left (replacement characters, original character) and two on the right(index values for which instances to replace, and the original string).

However, here's a more compact approach (the first item in the left argument is the target, and the rest of the left argument explicitly provides values for every instance of that item in the right argument):

'aABaCD' chg 'bEb' chg 'rrF' chg 'abracadabra'

=={{header|JavaScript}}==

if (n === 1) return s.indexOf(c);

return s.indexOf(c, findNth(s, c, n - 1) + 1);

[2, "r", "F"], // the second 'r' with 'F'

])

{{out}}

<pre>AErBcadCbFD</pre>

Or, expressed as a map-accumulation:

"use strict";

// MAIN --

return main();

{{Out}}

<pre>AErBcadCbFD</pre>

=={{header|Julia}}==

rep = Dict('a' => Dict(1 => 'A', 2 => 'B', 4 => 'C', 5 => 'D'), 'b' => Dict(1 => 'E'), 'r' => Dict(2 => 'F'))

println("abracadabra -> ", trstring("abracadabra", rep))

=={{header|Lambdatalk}}==

Then we add to the existing set of array functions a new one finding the indexes of some value in a given array.

{def A.findindexes

-> [0,3,5,7,10]

... and so on

Using findindexes we can translate the aA1 aB2 aC4 aD5 bE1 rF2 sequence into a new one where numbers are replaced by indexes in the given string, here abracadabra.

{def replacements.rules

{lambda {:w :r}

-> aA0

... and so on

Finally the replacements function will apply this sequence of rules to the word.

{def replacements

-> cABarFECbDd

(cABarFECbDd)

2) second answer using regexps

Here is a quick & dirty answer using the S.replace_once primitive.

{def multrepl_rex

{lambda {:word :rules}

-> AErBcadCbFD

(AErBcadCbFD)

=={{header|Perl}}==

use warnings;

use feature 'say';

my $word = 'abracadabra';

{{out}}

<pre>abracadabra -> AErBcadCbFD</pre>

=={{header|Phix}}==

Couldn't really decide which I prefer so posted both.

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

<span style="color: #008080;">function</span> <span style="color: #000000;">replace_nth</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">r</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">{{</span><span style="color: #000000;">2</span><span style="color: #0000FF;">},</span><span style="color: #008000;">'r'</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"F"</span><span style="color: #0000FF;">}}</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">replace_nths</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"abracadabra"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">r</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

=={{header|Python}}==

{{trans|Julia}}

rep = {'a' : {1 : 'A', 2 : 'B', 4 : 'C', 5 : 'D'}, 'b' : {1 : 'E'}, 'r' : {2 : 'F'}}

print('abracadabra ->', trstring('abracadabra', rep))

===Alternative===

from typing import Iterable

],

)

{{out}}

<pre>AErBcadCbFD</pre>

Or, as a map-accumulation:

from functools import reduce

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>AErBcadCbFD</pre>

Set up to not particularly rely on absolute structure of the word. Demonstrate with both the original 'abracadabra' and with a random shuffled instance.

$str.match(:ex, 'a')».from.map: { $str.substr-rw($_, 1) = 'ABaCD'.comb[$++] };

$str.=subst('b', 'E');

say $_, ' -> ', .&mangle given 'abracadabra';

{{out}}

=={{header|Vlang}}==

A similar approach to the C++ entry.

mut bytes := s.bytes()

mut counts := {

println('$old -> $new')

}

{{out}}

{{libheader|Wren-regex}}

Not particularly succinct but, thanks to a recently added library method, better than it would have been :)

import "./str" for Str

s = Str.replace(s, "b", "E", 1)

s = Str.replace(s, "r", "F", 2, 1)

{{out}}

Alternatively, using regular expressions (embedded script) producing output as before.

var s = "abracadabra"

s = Regex.compile("b").replace(s, "E")

s = Regex.compile("r").replaceAll(s, "F", 2, 1)

=={{header|XPL0}}==

proc Mangle(S);

char S, A, B, R;

S:= "caarabadrab";

Text(0, S); Text(0, " -> "); Mangle(S); Text(0, S); CrLf(0);

{{out}}