# Selectively replace multiple instances of a character within a string

You are encouraged to solve this task according to the task description, using any language you may know.

This is admittedly a trivial task but I thought it would be interesting to see how succinctly (or otherwise) different languages can handle it.

Given the string: "abracadabra", replace programatically:

• the first 'a' with 'A'
• the second 'a' with 'B'
• the fourth 'a' with 'C'
• the fifth 'a' with 'D'
• the first 'b' with 'E'
• the second 'r' with 'F'

Note that there is no replacement for the third 'a', second 'b' or first 'r'.

## 11l

Translation of: Python
```V rep = [‘a’ = [1 = ‘A’, 2 = ‘B’, 4 = ‘C’, 5 = ‘D’], ‘b’ = [1 = ‘E’], ‘r’ = [2 = ‘F’]]

F trstring(oldstring, repdict)
DefaultDict[Char, Int] seen
V newchars = ‘’
L(c) oldstring
V i = ++seen[c]
newchars ‘’= I c C repdict & i C repdict[c] {repdict[c][i]} E c
R newchars

Output:
```abracadabra -> AErBcadCbFD
```

## ALGOL 68

```CO in the string "abracadabra", replace the first  'a' with 'A', the second 'a' with 'B'
, the fourth 'a' with 'C', the fifth  'a' with 'D'
the first  'b' with 'E', the second 'r' with 'F'
CO
BEGIN
[,]STRING replacements = ( ( "a", "ABaCD" ), ( "b", "E" ), ( "r", "rF" ) );
[ 1 LWB replacements : 1 UPB replacements ]INT position;
[ LWB input : UPB input ]CHAR output;
FOR i FROM LWB position TO UPB position DO position[ i ] := LWB replacements[ i, 2 ] OD;
FOR c pos FROM LWB input TO UPB input DO
CHAR c           = input[ c pos ];
output[ c pos ] := c;
BOOL found      := FALSE;
FOR r pos FROM 1 LWB replacements TO 1 UPB replacements WHILE NOT found DO
STRING r = replacements[ r pos, 1 ];
IF c = r[ LWB r ] THEN
found := TRUE;
IF position[ r pos ] <= UPB replacements[ r pos, 2 ] THEN
output[   c pos ]  := replacements[ r pos, 2 ][ position[ r pos ] ];
position[ r pos ] +:= 1;
found              := TRUE
FI
FI
OD
OD;
print( ( """", input, """ -> """, output, """" ) );
IF output /= "AErBcadCbFD" THEN print( ( " ** UNEXPECTED RESULT" ) ) FI;
print( ( newline ) )
END```
Output:
```"abracadabra" -> "AErBcadCbFD"
```

## Arturo

```replacement: function [rule,ch,order][
loop rule 'r ->
if r\ = order -> return r\
return ch
]
multiReplace: function [str, rules][
cntr: #.raw flatten couple keys rules repeat 0 size rules

join map str 'ch [
(key? cntr ch)? [
cntr\[ch]: cntr\[ch] + 1
replacement rules\[ch] ch dec cntr\[ch]
] -> ch
]
]

a: [[0 `A`][1 `B`][3 `C`][4 `D`]]
b: [[0 `E`]]
r: [[1 `F`]]
]
```
Output:
`AErBcadCbFD`

## AutoHotkey

```str := "abracadabra"
steps := [[1, "a", "A"]
, [2, "a", "B"]
, [4, "a", "C"]
, [5, "a", "D"]
, [1, "b", "E"]
, [2, "r", "F"]]

MsgBox % result := Selectively_replace(str, steps)
return

Selectively_replace(str, steps){
Res := [], x := StrSplit(str)
for i, step in steps {
n := step.1, L := step.2, R := step.3, k := 0
for j, v in x
if (v=L) && (++k = n) {
Res[j] := R
break
}
}
for j, v in x
result .= Res[j] = "" ? x[j] : Res[j]
return result
}
```
Output:
`AErBcadCbFD`

## C

```#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void) {

char *replaced = malloc(sizeof(string));
strcpy(replaced, string);

// Null terminated replacement character arrays
const char *aRep = "ABaCD";
const char *bRep = "E";
const char *rRep = "rF";

for (char *c = replaced; *c; ++c) {
switch (*c) {
case 'a':
if (*aRep)
*c = *aRep++;
break;
case 'b':
if (*bRep)
*c = *bRep++;
break;
case 'r':
if (*rRep)
*c = *rRep++;
break;
}
}

printf("%s\n", replaced);

free(replaced);
return 0;
}
```
Output:
```AErBcadCbFD
```

## C++

```#include <map>
#include <iostream>
#include <string>

int main()
{
std::map<char, std::string> rep =
{{'a', "DCaBA"}, // replacement string is reversed
{'b', "E"},
{'r', "Fr"}};

for(auto it = magic.begin(); it != magic.end(); ++it)
{
if(auto f = rep.find(*it); f != rep.end() && !f->second.empty())
{
*it = f->second.back();
f->second.pop_back();
}
}

std::cout << magic << "\n";
}
```
Output:
```AErBcadCbFD
```

## Delphi

Works with: Delphi version 6.0

```var TestStr: string = 'abracadabra';

function FindNthChar(C: char; S: string; N: integer): integer;
{Routine to find the Nth version of C, string S}
begin
for Result:=1 to Length(S) do
if S[Result]=C then
begin
Dec(N);
if N<=0 then exit;
end;
Result:=-1;
end;

procedure ReplaceNthChar(COld,CNew: char; var S: string; N: integer);
{Find and replace the Nth version COld with CNew}
var Inx: integer;
begin
Inx:=FindNthChar(COld,S,N);
if Inx<1 then exit;
S[Inx]:=CNew;
end;

procedure SelectivelyReplaceChars(Memo: TMemo);
var I: integer;
begin
{Do the replacement toward the end of string first}
ReplaceNthChar('a','D',TestStr,5);
ReplaceNthChar('a','C',TestStr,4);
ReplaceNthChar('a','B',TestStr,2);
ReplaceNthChar('r','F',TestStr,2);
ReplaceNthChar('a','A',TestStr,1);
ReplaceNthChar('b','E',TestStr,1);
end;
```
Output:
```Before: AErBcadCbFD
Elapsed Time: 1.749 ms.

```

## EMal

```fun transmogrify  = text by text input, Map replacements
Map indexes = text%int[]
text result = ""
for each text ch in input
result.append(when(replacements.has(++indexes[ch] + ch), replacements[indexes[ch] + ch], ch))
end
return result
end
text%text["1a" => "A", "2a" => "B", "4a" => "C", "5a" => "D", "1b" => "E", "2r" => "F"]))```
Output:
```AErBcadCbFD
```

## Factor

Works with: Factor version 0.99 2022-04-03
```USING: assocs formatting grouping kernel random sequences ;

CONSTANT: instrs {
CHAR: a 1 CHAR: A
CHAR: a 2 CHAR: B
CHAR: a 4 CHAR: C
CHAR: a 5 CHAR: D
CHAR: b 1 CHAR: E
CHAR: r 2 CHAR: F
}

: counts ( seq -- assoc )
H{ } clone swap [ 2dup swap inc-at dupd of ] zip-with nip ;

: replace-nths ( seq instrs -- seq' )
[ counts ] dip 3 group [ f suffix 2 group ] map substitute keys ;

: test ( str -- )
dup instrs replace-nths "" like "%s -> %s\n" printf ;

```
Output:
```abracadabra -> AErBcadCbFD
```

## FreeBASIC

```Function replaceChar(Byref S As String) As String
Dim As String A = "ABaCD", B = "Eb", R = "rF"
Dim As Byte pA = 1, pB = 1, pR = 1
For i As Byte = 0 To Len(S)
Select Case Mid(S,i,1)
Case "a"
Mid(S,i,1) = Mid(A,pA,1)
pA += 1
Case "b"
Mid(S,i,1) = Mid(B,pB,1)
pB += 1
Case "r"
Mid(S,i,1) = Mid(R,pR,1)
pR += 1
End Select
Next i
Return S
End Function

Dim As String S
Print S; " -> "; replaceChar(S)
Print S; " -> "; replaceChar(S)
Sleep```
Output:
```abracadabra -> AErBcadCbFD

## FutureBasic

```include "NSLog.incl"

void local fn DoIt
long               a = 0, b = 0, r = 0, length, i
CFMutableStringRef string = fn MutableStringWithString( @"abracadabra" )
CFStringRef        s

length = len(string)
for i = 0 to length - 1
s = NULL
select ( mid(string,i,1) )
case @"a"
a++
select ( a )
case 1 : s = @"A"
case 2 : s = @"B"
case 4 : s = @"C"
case 5 : s = @"D"
end select
case @"b"
b++
if ( b == 1 ) then s = @"E"
case @"r"
r++
if ( r == 2 ) then s = @"F"
end select
if ( s ) then mid(string,i,1) = s
next

NSLog(@"%@",string)
end fn

fn DoIt

HandleEvents```
Output:
```AErBcadCbFD
```

## Go

Translation of: Wren
```package main

import (
"fmt"
"strings"
)

func main() {
ss := []byte(s)
var ixs []int
for ix, c := range s {
if c == 'a' {
ixs = append(ixs, ix)
}
}
repl := "ABaCD"
for i := 0; i < 5; i++ {
ss[ixs[i]] = repl[i]
}
s = string(ss)
s = strings.Replace(s, "b", "E", 1)
s = strings.Replace(s, "r", "F", 2)
s = strings.Replace(s, "F", "r", 1)
fmt.Println(s)
}
```
Output:
```AErBcadCbFD
```

As a map-accumulation:

```import Data.List (mapAccumL)
import qualified Data.Map.Strict as M
import Data.Maybe (fromMaybe)

---------- POSITIONAL CHARACTER-REPLACEMENT RULES --------

nthCharsReplaced :: M.Map Char [Maybe Char] -> String -> String
nthCharsReplaced ruleMap = snd . mapAccumL go ruleMap
where
go a c =
case M.lookup c a of
Nothing -> (a, c)
Just [] -> (a, c)
Just (d : ds) ->
( M.insert c ds a,
fromMaybe c d
)

--------------------------- TEST -------------------------
main :: IO ()
main = putStrLn \$ nthCharsReplaced rules "abracadabra"

rules :: M.Map Char [Maybe Char]
rules =
M.fromList
[ ('a', (Just <\$> "AB") <> [Nothing] <> (Just <\$> "CD")),
('b', [Just 'E']),
('r', [Nothing, Just 'F'])
]
```
Output:
`AErBcadCbFD`

## J

```   upd=: {{ x (n{I.y=m)} y }}
'ABCD' 'a' upd 0 1 3 4 'E' 'b' upd 0 'F' 'r' upd 1 'abracadabra'
```

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

```   chg=: {{ (}.x) (I.y={.x)} y}}
'aABaCD' chg 'bEb' chg 'rrF' chg 'abracadabra'
```

## Java

Translation of: JavaScript

Here's an example translated from JavaScript.

```int findNth(String s, char c, int n) {
if (n == 1) return s.indexOf(c);
return s.indexOf(c, findNth(s, c, n - 1) + 1);
}

String selectiveReplace(String s, Set... ops) {
char[] chars = s.toCharArray();
for (Set set : ops)
chars[findNth(s, set.old, set.n)] = set.rep;
return new String(chars);
}

record Set(int n, char old, char rep) { }
```
```selectiveReplace("abracadabra",
new Set(1, 'a', 'A'),
new Set(2, 'a', 'B'),
new Set(4, 'a', 'C'),
new Set(5, 'a', 'D'),
new Set(1, 'b', 'E'),
new Set(2, 'r', 'F'));
```
Output:
`AErBcadCbFD`

## JavaScript

```function findNth(s, c, n) {
if (n === 1) return s.indexOf(c);
return s.indexOf(c, findNth(s, c, n - 1) + 1);
}

function selectiveReplace(s, ops) {
const chars = Array.from(s);
for ([n, old, rep] of ops) {
chars[findNth(s, old, n)] = rep;
}
return chars.join("");
}

console.log(
[1, "a", "A"], // the first 'a' with 'A'
[2, "a", "B"], // the second 'a' with 'B'
[4, "a", "C"], // the fourth 'a' with 'C'
[5, "a", "D"], // the fifth 'a' with 'D'
[1, "b", "E"], // the first 'b' with 'E'
[2, "r", "F"], // the second 'r' with 'F'
])
);
```
Output:
`AErBcadCbFD`

Or, expressed as a map-accumulation:

```(() => {
"use strict";

// -- INSTANCE-SPECIFIC CHARACTER REPLACEMENT RULES --

// # nthInstanceReplaced :: Dict Char [(Null | Char)] ->
const nthInstanceReplaced = ruleMap =>
// A string defined by replacements specified for
// the nth instances of various characters.
s => mapAccumL(
(a, c) => c in a ? (() => {
const ds = a[c];

return Boolean(ds.length) ? [
Object.assign(a, {[c]: ds.slice(1)}),
ds || c
] : [a, c];
})() : [a, c]
)(Object.assign({}, ruleMap))(
[...s]
).join("");

// ---------------------- TEST -----------------------
const main = () =>
// Instance-specific character replacement rules.
nthInstanceReplaced({
a: ["A", "B", null, "C", "D"],
b: ["E"],
r: [null, "F"]
})(
);

// --------------------- GENERIC ---------------------

// mapAccumL :: (acc -> x -> (acc, y)) -> acc ->
// [x] -> (acc, [y])
const mapAccumL = f =>
// A tuple of an accumulation and a list
// obtained by a combined map and fold,
// with accumulation from left to right.
acc => xs => [...xs].reduce(
([a, bs], x) => second(
v => [...bs, v]
)(
f(a, x)
),
[acc, []]
);

// second :: (a -> b) -> ((c, a) -> (c, b))
const second = f =>
// A function over a simple value lifted
// to a function over a tuple.
// f (a, b) -> (a, f(b))
([x, y]) => [x, f(y)];

// MAIN --
return main();
})();
```
Output:
`AErBcadCbFD`

## jq

In this section, array-indexing and occurrence-counting are both 0-based except for the transcription of the task in `steps`.

Generic functions

```# Emit empty if the stream does not have an \$n-th item
# Note: jq's nth/2 does not serve our purposes.
def n_th(\$n; stream):
if \$n < 0 then empty
else foreach stream as \$x (-1; .+1; if . == \$n then \$x else empty end)
end;

def positions(stream; \$v):
foreach stream as \$x (-1; .+1; if \$v == \$x then . else empty end);

# Input: an array or string.
# Output: the input with an occurrence of \$old replaced by \$new.
# . and \$reference are assumed to be of the same type and length.
# The search occurs in \$reference and the corresponding spot in . is modified.
def replace_nth(\$occurrence; \$old; \$new; \$reference):
if type == "array"
then (\$reference | n_th(\$occurrence; positions(.[]; \$old)) // null) as \$ix
| if \$ix then .[:\$ix] + [\$new] + .[\$ix + 1:] else . end
else explode
| replace_nth(\$occurrence; \$old|explode|first; \$new|explode|first; \$reference|explode)
| implode
end;```

```def steps:
[1, "a", "A"],
[2, "a", "B"],
[4, "a", "C"],
[5, "a", "D"],
[1, "b", "E"],
[2, "r", "F"];

. as \$reference
| reduce steps as [\$occurrence, \$old, \$new] (.;
replace_nth(\$occurrence - 1; \$old; \$new; \$reference ));

Output:
```AErBcadCbFD
```

## Julia

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

function trstring(oldstring, repdict)
seen, newchars = Dict{Char, Int}(), Char[]
for c in oldstring
i = get!(seen, c, 1)
seen[c] += 1
end
return String(newchars)
end

```
Output:
Same as Perl.

## Lambdatalk

We first translate the replacements program into a sequence of rules

```the first  'a' with 'A'   -> aA1
...and so on
```

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

{def A.findindexes.rec
{lambda {:v :a :b :i}
{if {A.empty? :a}
then :b
else {A.findindexes.rec :v {A.rest :a}
{if {W.equal? {A.first :a} :v}
else :b}
{+ :i 1}} }}}

{lambda {:v :a}
{A.findindexes.rec :v :a {A.new} 0} }}
-> 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}
{A.new
{W.get 0 :r}
{W.get 1 :r}
{A.get {- {W.get 2 :r} 1}  // arrays begin at 0
{A.findindexes {W.get 0 :r} {A.split :w}}}}}}
->  replacements.rules

-> aA0
... and so on
```

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

```{def replacements

{def replacements.rec
{lambda {:word :rules}
{if {A.empty? :rules}
then {A.join :word}
else {replacements.rec {A.set! {A.get 2 {A.first :rules}}
{A.get 1 {A.first :rules}}
:word}
{A.rest :rules}} }}}

{lambda {:word :rules}
{replacements.rec
{A.split :word}
{A.map {replacements.rules :word} {A.new :rules}} }}}
-> replacements

-> cABarFECbDd
(cABarFECbDd)
```

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

```{def multrepl_rex
{lambda {:word :rules}
{if {A.empty? :rules}
then :word
else {multrepl_rex
{S.replace_once {W.first {A.first :rules}}
by {W.last {A.first :rules}}
in :word }
{A.rest :rules}} }}}
-> multrepl_rex

{multrepl_rex
{A.new
aA aB a3 aC aD 3a   // save third "a" as "3" and restore it
bE                  // first "b"
r1 rF 1r            // save first "r" as "1" and restore it
}}
```

## Nim

```import std/tables

type
# Table of replacements for a character.
Replacements = Table[int, char]
# Table mapping characters to their replacement table.
ReplacementTable = Table[char, Replacements]

const ReplTable = {'a': {1: 'A', 2: 'B', 4: 'C', 5: 'D'}.toTable,
'b': {1: 'E'}.toTable,
'r': {2: 'F'}.toTable
}.toTable

proc replace(text: string; replTable: ReplacementTable): string =
var counts: Table[char, int]  # Follow count of characters.
for c in text:
if c in replTable:
counts.mgetOrPut(c, 0).inc  # Update count for this char.
let pos = counts[c]
else:

```
Output:
```AErBcadCbFD
```

## Perl

```use strict;
use warnings;
use feature 'say';

sub transmogrify {
my(\$str, %sub) = @_;
for my \$l (keys %sub) {
\$str =~ s/\$l/\$_/ for split '', \$sub{\$l};
\$str =~ s/_/\$l/g;
}
\$str
}

say "\$word -> " . transmogrify \$word, 'a' => 'AB_CD', 'r' => '_F', 'b' => 'E';
```
Output:
`abracadabra -> AErBcadCbFD`

## Phix

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

```with javascript_semantics
function replace_nth(string s, r)
string res = s
for i=1 to length(r) by 3 do
res[find_all(r[i],s)[r[i+1]-'0']] = r[i+2]
end for
return res
end function

-- Alternative version
function replace_nths(string s, sequence r)
for icr in r do
{sequence idx, integer ch, string reps} = icr
s = reinstate(s,extract(find_all(ch,s),idx),reps)
end for
return s
end function

constant r = {{{1,2,4,5},'a',"ABCD"},
{{1},'b',"E"},
{{2},'r',"F"}}
```
Output:
```"AErBcadCbFD"
```

## Phixmonti

```/# Rosetta Code problem: https://rosettacode.org/wiki/Selectively_replace_multiple_instances_of_a_character_within_a_string
by Galileo, 11/2022 #/

include ..\Utilitys.pmt

"ABaCD" var A "Eb" var B "rF" var R

tps get tochar
dup "a" == if drop A pop var A tps set else
dup "b" == if drop B pop var B tps set else
"r" == if R pop var R tps set
endif endif endif
ps> drop
endfor

pstack```
Output:
```["AErBcadCbFD"]

=== Press any key to exit ===```

## Python

Translation of: Julia
```from collections import defaultdict

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

def trstring(oldstring, repdict):
seen, newchars = defaultdict(lambda:1, {}), []
for c in oldstring:
i = seen[c]
newchars.append(repdict[c][i] if c in repdict and i in repdict[c] else c)
seen[c] += 1
return ''.join(newchars)

```

### Alternative

```import functools

from typing import Iterable
from typing import Tuple

@functools.cache
def find_nth(s: str, sub: str, n: int) -> int:
assert n >= 1
if n == 1:
return s.find(sub)
return s.find(sub, find_nth(s, sub, n - 1) + 1)

def selective_replace(s: str, ops: Iterable[Tuple[int, str, str]]) -> str:
chars = list(s)
for n, old, new in ops:
chars[find_nth(s, old, n)] = new
return "".join(chars)

print(
selective_replace(
[
(1, "a", "A"),  # the first 'a' with 'A'
(2, "a", "B"),  # the second 'a' with 'B'
(4, "a", "C"),  # the fourth 'a' with 'C'
(5, "a", "D"),  # the fifth 'a' with 'D'
(1, "b", "E"),  # the first 'b' with 'E'
(2, "r", "F"),  # the second 'r' with 'F'
],
)
)
```
Output:
`AErBcadCbFD`

Or, as a map-accumulation:

```'''Instance-specific character replacement rules'''

from functools import reduce

# nthInstanceReplaced :: Dict Char [(None | Char)] ->
# String -> String
def nthInstanceReplaced(ruleMap):
def go(a, c):
ds = a.get(c, None)
return (
dict(a, **{c: ds[1:]}),
ds or c
) if ds else (a, c)

return lambda s: ''.join(
mapAccumL(go)(ruleMap)(s)
)

# ------------------------- TEST -------------------------
def main():
'''Rule-set applied to a given string.'''

print(
nthInstanceReplaced({
'a': ['A', 'B', None, 'C', 'D'],
'b': ['E'],
'r': [None, 'F']
})(
)
)

# ----------------------- GENERIC ------------------------

# mapAccumL :: (acc -> x -> (acc, y)) ->
# acc -> [x] -> (acc, [y])
def mapAccumL(f):
'''A tuple of an accumulation and a map
with accumulation from left to right.
'''
def go(a, x):
return second(lambda v: a + [v])(
f(a, x)
)
return lambda acc: lambda xs: reduce(
go, xs, (acc, [])
)

# second :: (a -> b) -> ((c, a) -> (c, b))
def second(f):
'''A simple function lifted to a function over a tuple,
with f applied only to the second of two values.
'''
return lambda xy: (xy, f(xy))

# MAIN ---
if __name__ == '__main__':
main()
```
Output:
`AErBcadCbFD`

## Quackery

If there is no nth instance of a particular character in the string, `selectivereplace` will disregard it. For example, if the nest of replacements in the example included `[ 1 char z char ! ]` the output would be the same, as there is no z in "abracadabra".

``` [ dup size temp put
witheach
[ over = if
[ swap 1 -
tuck 0 = if
[ i^ temp replace
conclude ] ] ]
2drop
temp take ]               is nfind            ( n c \$ --> n )

[ temp put
[] [] rot witheach
[ 2 pluck
dip rot join unrot
nested join ]
[] swap witheach
[ do
temp share nfind
join ]
temp take 0 join unrot
witheach
[ dip [ behead rot ]
poke swap ]
drop
-1 split drop ]           is selectivereplace (   [ \$ --> \$ )

' [ [ 1 char a char A ]
[ 2 char a char B ]
[ 4 char a char C ]
[ 5 char a char D ]
[ 1 char b char E ]
[ 2 char r char F ] ]
selectivereplace echo\$```
Output:
`AErBcadCbFD`

## Raku

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

```sub mangle (\$str is copy) {
\$str.match(:ex, 'a')».from.map: { \$str.substr-rw(\$_, 1) = 'ABaCD'.comb[\$++] };
\$str.=subst('b', 'E');
\$str.substr-rw(\$_, 1) = 'F' given \$str.match(:ex, 'r')».from;
\$str
}

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

say \$_, ' -> ', .&mangle given 'abracadabra'.comb.pick(*).join;
```
Output:
```abracadabra -> AErBcadCbFD

## RPL

The character "-" in the rule string means that no replacement should be made for the occurrence concerned. Any other character can be chosen by modifying the code appropriately.

Due to the use of `INCR` and `REPL` instructions, this program will only work directly on HP48 compatible RPL versions. HP28 users must have programmed their own version of these instructions.

RPL code Comment
``` ≪ 0 → car rule occ
≪ 1 OVER SIZE FOR j
IF DUP j DUP SUB car == THEN
rule 'occ' INCR DUP SUB
IF DUP "-" == THEN DROP ELSE j SWAP REPL END
END NEXT
≫ ≫ 'REPLR' STO
```
```REPLR ( "string" "character" "rule" -- "string" )
loop for j = 1 to string length
if string[j] == character
get todo = rule[++occ]
replace if todo is different from "-"
end if end loop
return string
```
Input:
```"abracadabra"
≪ "a" "AB-CD" REPLR "b" "E" REPLR "r" "-F" REPLR ≫ EVAL
```
Output:
```1: "AErBcadCbFD"
```

## Ruby

```str = "abracadabra"
rules = [
["a", 1, "A"],
["a", 2, "B"],
["a", 4, "C"],
["a", 5, "D"],
["b", 1, "E"],
["r", 2, "F"]]

indices = Hash.new{[]}
str.each_char.with_index{|c, i| indices[c] <<= i}

rules.each{|char, i, to| str[indices[char][i-1]] = to}

p str
```
Output:
```"AErBcadCbFD"
```

## sed

```s/a\([^a]*\)a\([^a]*a[^a]*\)a\([^a]*\)a/A\1B\2C\3D/
s/b/E/
s/\(r[^r]*\)r/\1F/
```

## V (Vlang)

A similar approach to the C++ entry.

```fn selectively_replace_chars(s string, char_map map[string]string) string {
mut bytes := s.bytes()
mut counts := {
'a': 0
'b': 0
'r': 0
}
for i := s.len - 1; i >= 0; i-- {
c := s[i].ascii_str()
if c in ['a', 'b', 'r'] {
bytes[i] = char_map[c][counts[c]]
counts[c]++
}
}
return bytes.bytestr()
}

fn main() {
char_map := {
'a': 'DCaBA'
'b': 'bE'
'r': 'Fr'
}
new := selectively_replace_chars(old, char_map)
println('\$old -> \$new')
}
}
```
Output:
```abracadabra -> AErBcadCbFD
```

## Wren

Library: Wren-seq
Library: Wren-str
Library: Wren-regex

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

```import "./seq" for Lst
import "./str" for Str

var sl = s.toList
var ixs = Lst.indicesOf(sl, "a")
var repl = "ABaCD"
for (i in 0..4) sl[ixs[i]] = repl[i]
s = sl.join()
s = Str.replace(s, "b", "E", 1)
s = Str.replace(s, "r", "F", 2, 1)
System.print(s)```
Output:
```AErBcadCbFD
```

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

```import "./regex" for Regex

var split = Regex.compile("a").split(s)
var repl = "ABaCD"
var res = ""
for (i in 0...split.count-1) res = res + split[i] + repl[i]
s = res + split[-1]
s = Regex.compile("b").replace(s, "E")
s = Regex.compile("r").replaceAll(s, "F", 2, 1)
System.print(s)```

## XPL0

```string 0;
proc Mangle(S);
char S, A, B, R;
[A:= "ABaCD";  B:= "Eb";  R:= "rF";
while S(0) do
[case S(0) of
^a: [S(0):= A(0);  A:= A+1];
^b: [S(0):= B(0);  B:= B+1];
^r: [S(0):= R(0);  R:= R+1]
other [];
S:= S+1;
];
];

char S;
```abracadabra -> AErBcadCbFD