Anjing saya bernama Rex. Setiap kali saya memarahinya, dia tampak tidak terlalu terkesan dan satu-satunya saat saya melihatnya bereaksi adalah ketika saya mengucapkan namanya. Jika saya katakan

Rex, I told you not to do this! You're making me angry Rex!

yang dia dengar hanyalah

Rex, * **** *** *** ** ** ****! ***'** ****** ** ***** Rex!

Tantangannya : diberi string input, program Anda harus menampilkan string yang sama di mana semua karakter alfabet telah berubah menjadi bintang, kecuali karakter dalam tampilan kata Rex, yang harus dibiarkan tidak tersentuh. Karakter non-alfabet juga tidak tersentuh.

Detail : Tantangannya adalah case-insensitive, oleh karena itu rexharus dibiarkan tidak tersentuh juga. Kata tersebut Rexdapat menjadi bagian dari kata lain, jadi misalnya anorexicharus diterjemahkan sebagai ***rex**.

Pembaruan : karena teks awal dari tantangan ini tidak menjelaskan bagaimana garis bawah atau angka atau karakter yang ditekankan harus diperlakukan, saya tidak membuat persyaratan khusus pada karakter tersebut. Dengan demikian, solusi valid selama karakter dalam a-zA-Z(dan juga yang disebutkan dalam contoh ,!".) ditangani dengan benar.

Kasus uji:

Memasukkan : Rex lives in Rexland.

Keluaran: Rex ***** ** Rex****.

Memasukkan : To call Rex, just say "Rex".

Keluaran: ** **** Rex, **** *** "Rex".

Memasukkan : My cat is getting anorexic.

Keluaran: ** *** ** ******* ***rex**.

Retina , 24 21 byte

i`(rex)|(\w)
$1$#2$**

Cobalah online!

Penjelasan

Melewati rexs paling mudah dengan mencocokkannya juga, karena pertandingan tidak bisa tumpang tindih. Jadi jika kita mengutamakan rexlebih dari surat-surat lain, itu akan dibahas dalam satu pertandingan dan tidak tersentuh oleh pertandingan individu-huruf.

Tetapi bagaimana kita melakukan hal-hal yang berbeda tergantung pada alternatif yang digunakan untuk pertandingan? Sayangnya, Retina belum (belum) memiliki sintaksis substitusi bersyarat seperti Boost regex flavor. Tetapi kita dapat memalsukannya dengan memasukkan kedua pergantian tersebut dalam satu penggantian dan memastikan bahwa hanya satu yang tidak kosong:

• $1adalah grup penangkap pertama, yaitu (rex). Jika kami benar-benar mencocokkan rexini, cukup tulis kembali (jadi tidak ada hasilnya), tetapi jika kami tidak cocok rexmaka $1adalah string kosong dan menghilang.
• $#2$**harus dibaca sebagai ($#2)$*(*). $#2adalah berapa kali grup 2digunakan, yaitu (\w). Jika kami cocok dengan rexini 0, tetapi jika kami cocok dengan huruf individual lainnya, ini 1. $*mengulangi karakter berikutnya sebanyak operan tangan kirinya. Jadi bagian ini memasukkan satu *untuk setiap pertandingan huruf dan tidak ada sama sekali untuk rex.

** REXX 151 148 141 byte **

(Agak tampak tepat)

i=arg(1)
m=i
o=translate(m,'',xrange('A','z'),'*')
p=0
do forever
   p=pos('REX',m,p+1)
   if p=0 then leave
   o=overlay(substr(i,p,3),o,p)
end
say o

Coba di sini

Catatan untuk non-REXXers:

1. terjemahkan adalah fungsi penggantian karakter (nama berasal dari instruksi assembler pada IBM MF). Itu mencari string1 untuk karakter di string3. Setiap kali ia menemukan satu itu menggantikannya dengan yang diposisikan sama di string2. Jika string2 terlalu pendek itu diisi dengan karakter pad.

Lihat di sini untuk fungsi terjemahan

2. overlay cukup dengan meletakkan string1 di atas string2 pada posisi yang ditentukan.

Lihat di sini untuk fungsi overlay

JavaScript (ES6), 42 41 38 byte

s=>s.replace(/rex|\w/gi,m=>m[1]?m:"*")

Cobalah

o.innerText=(f=

s=>s.replace(/rex|\w/gi,m=>m[1]?m:"*")

)(i.value="Rex, I told you not to do this! You're making me angry Rex!")
oninput=_=>o.innerText=f(i.value)

<input id=i><pre id=o>

Penjelasan

s=>            :Anonymous function that takes the string as an argument via parameter s.
s.replace(x,y) :Replace x in s with y.
/rex|\w/gi     :Case-insenstive regular expression that globally matches all occurrences
                of "rex" or any single letter, number or underscore.
                (numbers & underscores will never be included in the input.)
m=>            :Anonymous function that takes each match as an argument via parameter m.
m[1]?          :If string m has a second character, ...
                (Equivalent to m.charAt(1))
m              :Return m, ...
:"*"           :Otherwise return "*".

APL (Dyalog Unicode) , 22 byte ^SBCS

'rex' '\w'⎕R'\0' '*'⍠1

Cobalah online!

Sederhana PCRE R eplace.

⍠1Menetapkan ketidakpekaan case. Cukup ganti rexdengan dirinya sendiri dan semua karakter kata lainnya dengan tanda bintang.

Perl 5 , 24 byte

23 byte kode + -pbendera.

Saya menggunakan regex Martin Ender dari jawaban Retina- nya (yang kebetulan lebih pendek di Perl, terima kasih \pl), dan hanya perlu menyesuaikan sisi kanan s ///.

s%(rex)|\pl%$1//"*"%gie

Cobalah online!

Retina , 32 31 byte

iS`(rex)
%iT`Ll`*`^(?!rex).*
¶

Cobalah online! Penjelasan: Pisahkan string menjadi kemunculan kata rexdan yang lainnya, tetapi tetap cocok. Kemudian, pada baris yang tidak dimulai rex(yaitu "segalanya"), ubah huruf menjadi *s. Akhirnya, gabungkan semuanya kembali bersama.

C, 99 97 92 86 74 73 72 65 byte

f(char*s){*s&&f(s+=strnicmp("Rex",s,3)?!isalpha(*s)||(*s=42):3);}

Lingkungan Pelles IDE menyediakan (kompilasi dengan / Go) strnicmp fungsi. Fungsi ini identik dengan strncasecmp. Lihat berfungsi di sini (dengan fungsi penggantian).

Output disimpan dalam parameter pertama yang merupakan parameter masuk / keluar.

Terima kasih kepada Johan du Toit karena memberi tahu saya bahwa rekursi sedikit lebih pendek.

Ruby, 36 35 32 byte

->s{s.gsub(/(rex)|\w/i){$1||?*}}

Sebagai ujian:

f=->s{s.gsub(/(rex)|\w/i){$1||?*}}

tests = [
  ["Rex, I told you not to do this! You're making me angry Rex!", "Rex, * **** *** *** ** ** ****! ***'** ****** ** ***** Rex!"],
  ["Rex lives in Rexland.", "Rex ***** ** Rex****."],
  ["To call Rex, just say \"Rex\".", %q(** **** Rex, **** *** "Rex".)],
  ["My cat is getting anorexic.", "** *** ** ******* ***rex**."]
] 

tests.each do |input, output|
  if f.call(input) == output
    puts "Fine for #{input.inspect}"
  else
    puts "Problem with :\n#{input.inspect}"
    puts f.call(input)
    puts output
  end
  puts
end

Ini menghasilkan:

Fine for "Rex, I told you not to do this! You're making me angry Rex!"

Fine for "Rex lives in Rexland."

Fine for "To call Rex, just say \"Rex\"."

Fine for "My cat is getting anorexic."

PHP, 78 Bytes

<?=preg_replace("#[a-df-qs-wyz]|r(?!ex)|(?<!r)e|e(?!x)|(?<!re)x#i","*",$argn);

Cobalah online!

PHP, 84 Bytes

<?=preg_replace_callback("#(rex)|\pL#i",function($t){return$t[1]?$t[1]:"*";},$argn);

-1 Byte \wsebagai gantinya \pldalam hal ini garis bawah dan angka diganti juga

\pLlebih pendek sebagai [a-z]atau[[:alpha:]]

Cobalah online!

C (GCC pada POSIX), 167 118 93 87 byte

i,j;f(char*s){for(i=0;j=s[i];i++)strncasecmp("Rex",s+i,3)?s[i]=isalpha(j)?42:j:(i+=2);}

Cobalah online!

Python 2 atau 3, 75 73 70 byte

import re;f=lambda s:re.sub('(?i)(rex)|\w',lambda x:x.group(1)or'*',s)

Pada dasarnya sama dengan jawaban Ruby saya .

-2 byte berkat @Wondercricket.

Sebagai ujian:

tests = [
  ["Rex, I told you not to do this! You're making me angry Rex!", "Rex, * **** *** *** ** ** ****! ***'** ****** ** ***** Rex!"],
  ["Rex lives in Rexland.", "Rex ***** ** Rex****."],
  ["To call Rex, just say \"Rex\".", "** **** Rex, **** *** \"Rex\"."],
  ["My cat is getting anorexic.", "** *** ** ******* ***rex**."]
]


for test_in, test_out in tests:
    print(test_in)
    print(f(test_in))
    print(f(test_in) == test_out)

Java 8, 187 192 168 164 159 138 byte

s->{for(int i=0;i<s.length();System.out.print(s.regionMatches(0<1,i,"rex",0,3)?s.substring(i,i+=3):s.replaceAll("\\w","*").charAt(i++)));}

-28 byte terima kasih kepada @ OlivierGrégoire.

Penjelasan:

Cobalah online.

s->{                         // Method with String parameter and no return-type
  for(int i=0;i<s.length();  //  Loop over the characters of the input-String
    System.out.print         //   Print:
     s.regionMatches(1>0,i,"rex",0,3)? 
                             //    If we've found "rex" (case-insensitive):
      s.substring(i,i+=3)    //     Print this REX-word (case-sensitive)
     :                       //    Else:
      s.replaceAll("\\w","*").charAt(i++));
                             //     Print the current character,
                             //     or '*' if it's an alpha-numeric character

Python 2, 87 Bytes

import re
print re.sub(r'(?i)[a-df-qs-wyz]|r(?!ex)|(?<!r)e|e(?!x)|(?<!re)x','*',input())

Saya kira itu bisa dipersingkat? :)

sed , 37 33 byte

Kode sumber 36 byte + 1 byte untuk flag -r.

s:(rex)|\w:\1*:Ig
s:(rex)\*:\1:Ig

Cobalah online!

Gema, 25 karakter

/[rR][eE][xX]/=$0
<L1>=\*

Contoh dijalankan:

bash-4.3$ gema '/[rR][eE][xX]/=$0;<L1>=\*' <<< "Rex, I told you not to do this! You're making me angry Rex!
Rex lives in Rexland.
To call Rex, just say \"Rex\".
My cat is getting anorexic."
Rex, * **** *** *** ** ** ****! ***'** ****** ** ***** Rex!
Rex ***** ** Rex****.
** **** Rex, **** *** "Rex".
** *** ** ******* ***rex**.

Fakta menyakitkan itu bisa saja \CRex=$0;<L1>=\*, tetapi sayangnya $0mengandung templat, bukan kecocokan. ☹

Retina , 54 50 49 byte

Golf 5 byte berkat @MartinEnder

Retina , 49 byte

i(`[\w-[rex]]
*
(?<!r)e|e(?!x)|r(?!ex)|(?<!re)x
*

Cobalah online!

PowerShell, 60 byte

{$args|%{$_-replace'(rex)|\p{L}','$1*'-replace'(x)\*','$1'}}

Cobalah online

QuadR , 11 10 + 1 = 11 byte

+1 byte untuk ibendera.

rex
\w
&
*

Cobalah online!

Penjelasan: Ganti huruf-huruf rexdan karakter kata-kata dengan dirinya sendiri dan tanda bintang, masing-masing.

MATL , 24 byte

42y3Y2mFGk'rex'Xf!3:q+((

Inputnya adalah string yang dilampirkan dalam tanda kutip tunggal.

Cobalah online!

Penjelasan

Pertimbangkan input 'Rex lives in Rexland.'

42    % Push 42 (ASCII for '*')
      % STACK: 42
y     % Implicit input. Duplicate from below
      % STACK: 'Rex lives in Rexland.', 42, 'Rex lives in Rexland.'
3Y2   % Push string 'ABC...YZabc...yz'
      % STACK: 'Rex lives in Rexland.', 42, 'Rex lives in Rexland.', 'ABC...YZabc...yz'
m     % Ismember
      % STACK: 'Rex lives in Rexland.', 42, [1 1 1 0 1 1 1 1 1 0 1 1 0 1 1 1 1 1 1 1 0]
F     % Push false
      % STACK: 'Rex lives in Rexland.', 42, [1 1 1 0 1 1 1 1 1 0 1 1 0 1 1 1 1 1 1 1 0], 0
Gk    % Push input lower-cased
      % STACK: 'Rex lives in Rexland.', 42, [1 1 1 0 1 1 1 1 1 0 1 1 0 1 1 1 1 1 1 1 0], 0, 'rex lives in rexland'
'rex' % Push this string
      % STACK: 'Rex lives in Rexland.', 42, [1 1 1 0 1 1 1 1 1 0 1 1 0 1 1 1 1 1 1 1 0], 0, 'rex lives in rexland', 'rex'
Xf!   % Strfind and transpose: gives indices of matchings as a column vector
      % STACK: 'Rex lives in Rexland.', 42, [1 1 1 0 1 1 1 1 1 0 1 1 0 1 1 1 1 1 1 1 0], 0, [1; 14]
3:q   % Push [0 1 2]
      % STACK: 'Rex lives in Rexland.', 42, [1 1 1 0 1 1 1 1 1 0 1 1 0 1 1 1 1 1 1 1 0], 0, [1; 14], [0 1 2]
+     % Addition, element-wise with broadcast
      % STACK: 'Rex lives in Rexland.', 42, [1 1 1 0 1 1 1 1 1 0 1 1 0 1 1 1 1 1 1 1 0], 0, [1 2 3; 14 15 16]
(     % Assignment indexing: sets indicated entries to 0
      % STACK: 'Rex lives in Rexland.', 42, [0 0 0 0 1 1 1 1 1 0 1 1 0 0 0 0 1 1 1 1 0]
(     % Assignment indexing: sets indicated entries to 42 (that is, '*'). Implicit display
      % 'Rex ***** ** Rex****.'

Python 2 , 93 92 byte

f=lambda s:s and("rex"==s[:3].lower()and s[:3]+f(s[3:])or("*"+s)[s[0].isalpha()<1]+f(s[1:]))

Cobalah online!

Perl, 31 byte

s/(rex)|[a-z]/$1||"*"/ieg;print

Aktifkan perl dengan -nopsi. Sebagai contoh:

echo 'To call rex, just say "Rex".'| perl -ne 's/(rex)|[a-z]/$1||"*"/ieg;print'
** **** rex, **** *** "Rex".

Bash , 128 byte

r=REXrex;a=`tr -c $r'",. !
' l<<<$1`;for i in {r,R}{e,E}{x,X};{
a=`echo ${a[@]//$i/$(tr $r f-k<<<$i)}`;}
tr $r l<<<$a|tr f-l $r*

Cobalah online!

Saya berpegang teguh pada tr pada jawaban saya sebelumnya, string array bash non-fungsional diganti dan tidak ada penggantian awal!

Kurang bermain golf:

    a=`echo $1 |tr -c 'REXrex.,\"! ' 'z'`;        -> a replaces with z chars in input not matching REXrex or punctuation
    for i in {r,R}{e,E}{x,X}; {                   -> iterates over rex .. rEx .. REX
      j=$(tr 'REXrex' 'ABCabc' <<<$i)}            -> holds a for r, A for R, ando so on
      a=`echo ${a[@]//$i/$j`;                     -> replace each combination of rex .. rEx .. REX with abc ... aBc.. ABC
    }
    tr 'REXrex' 'z' <<<$a |tr 'ABCabcz' 'REXrex*' -> replaces each remainig r,e,x,R,E,X with z and finally each ABC with REX and z with *

Harus menggunakan z bukannya * karena ekspansi

Java 7, 96 98 97 96 byte

+2 byte untuk e yang hilang diawali dengan r atau diikuti oleh x tetapi tidak keduanya

-1 byte untuk diubah [a-z&&[^rex]]menjadi(?![rex])\\w

String a(String s){return s.replaceAll("(?i)r(?!ex)|(?<!r)e|e(?!x)|(?<!re)x|(?![rex])\\w","*");}

Cobalah online!

Versi regex untuk penggantian menggunakan Java

Mengganti semua yang ada di regex ini dengan * (catatan di Java \ w harus diloloskan sebagai \\ w)

(?i)r(?!ex)|(?<!r)e|e(?!x)|(?<!re)x|(?![rex])\w

(?i)                                                   // Case Insensitive
    r(?!ex)                                            // Any r not followed by ex
           |(?<!r)e                                    // Or any e not preceded by r
                   |e(?!x)                             // Or any e not followed by x
                          |(?<!re)x                    // Or any x not preceded by re
                                   |(?![rex])\w        // Or any other word character

C #, 93 90 byte

s=>System.Text.RegularExpressions.Regex.Replace(s,"(?i)rex|\w",m=>m.Length>1?m.Value:"*");

Percayalah ini adalah pertama kalinya saya menggunakan regex dalam jawaban C # di sini karena namespace yang panjang System.Text.RegularExpressions.

Tidak menyadarinya ketika saya menulis jawaban saya tetapi ini tampaknya merupakan versi C # dari jawaban JavaScript @ Shaggy .

CJam , 39 byte

q{_3<_el"rex"=3{elc_'{,97>&'*@?1}?\o>}h

Cobalah online!

Bagaimana itu bekerja

q           e# Read the input.
{           e# Do:
 _3<        e#  Copy the string and get its first three characters.
 _el"rex"=  e#  Check case-insensitively if they equal "rex".
  3         e#   If they do, push 3.
  {         e#   If they don't:
   elc_     e#    Take the first character of the three, and make it lowercase.
   '{,97>&  e#    Take its set intersection with the lowercase alphabet. Returns a non-empty
            e#      string (truthy) if it's a letter or an empty string (falsy) if not.
   '*@?     e#    Push a * if the char is a letter, or itself if it's not.
   1        e#    Push 1.
  }?        e#  (end if)
 \o         e#  Print the second-from-the-top stack item.
 >          e#  Slice the string after the first 3 or 1 characters, depending on previous outcome.
}h          e# Repeat the above until the string is empty.

VimScript, 34 byte

s/\v(rex|r@<=ex|(re)@<=x)@!\w/*/gi

Dan inilah substitusi menarik yang hampir berfungsi:

s/\vr(ex)@!|<e|<x|[rex]@!\w/*/gi

Bayangkan menjalankan ini berulang kali pada string. Rex, dex, I told you not to do this! You're making me angry Rex!Setelah baris pertama, stringnya adalah Rex, *ex, * **** *** *** ** ** ****! ***'*e ****** *e ***** Rex!Pass kedua akan menghasilkan Rex, **x, * **** *** *** ** ** ****! ***'** ****** ** ***** Rex!, dan pass ketiga akan menyelesaikannya. Setiap lintasan selanjutnya tidak akan mengubah string. Namun, dibutuhkan lebih dari 3 pergantian untuk sampai ke sana, misalnya pada string xxxxxxxx. Jadi, jika ada cara mudah untuk menjalankan substitusi di atas sampai berhenti mengubah hal-hal, atau berapa kali panjang input, itu akan menjadi solusi lain. Saya yakin itu bisa dilakukan dalam V, tetapi mungkin masih akan lebih lama dari 34 byte.

Jelly , 23 byte

Tidak ada jawaban dalam lebih dari 24 jam untuk pertanyaan saya tentang kasus , jadi saya akan posting byter tentatif 23 ini.

“rex”
Œlœṣ¢µØaW;”*yµ€j¢

Lihat test case di Coba online!

Bagaimana?

“rex” - Link 1, get "rex": no arguments
“rex” - literal "rex"

Œlœṣ¢µØaW;”*yµ€j¢ - Main link: string s (or list of characters)
Œl                - convert s to lowercase
    ¢             - call the last link (1) as a nilad (get "rex")
  œṣ              - split left (s) at sublists equal to right ("rex")
     µ            - call the result t
             µ€   - for each word, w, in t:
      Øa          -   literal: lowercase alphabet
        W         -   wrap it in a list
          ”*      -   literal: '*'
         ;        -   concatenate the wrapped alphabet with the asterisk
            y     -   translate: replace all lowercase letters with asterisks.
                ¢ - call the last link (1) as a nilad (get "rex")
               j  - join left (translated, split text) with copies of right ("rex")

CJam , 26 byte (output huruf besar) / 36 byte (case-preserving)

qeu"REX":R/{__el-'*@?}f%R*

Cobalah online!

Jika huruf besar perlu dilestarikan (karena itu masih sedikit tidak jelas ), itu dapat diselesaikan dengan 10 byte tambahan:

q_32f&:i\eu"REX":R/{__el-'*@?}f%R*.|

Cobalah online!

Ngomong-ngomong, ketika menulis jawaban ini, saya menemukan apa yang saya anggap sebagai bug desain di CJam: operator bitwise &dan |tidak didefinisikan antara dua nilai char, jadi saya tidak bisa menggunakan .|bitwise ATAU dua string. Solusinya, yang pada akhirnya menghabiskan dua byte tambahan, adalah pertama-tama mengubah salah satu string :imenjadi array bilangan bulat, yang kemudian dapat ORed dengan string lainnya. (Sebenarnya harganya tiga byte, karena jika &bekerja di antara dua karakter, saya bisa juga menggunakan Sf&alih-alih 32f&menyimpan informasi huruf.)

Di sisi positif, saya menemukan bahwa {...}f%memang berfungsi seperti yang diharapkan untuk mengulangi karakter dalam serangkaian string. Bagus.

Bagaimanapun, inilah versi kode 36-byte (ringan) yang dikomentari:

q                                       "read input";
 _32f&:i\                               "save the case bit of each input char";
         eu"REX":R/                     "uppercase input and split it on 'REX'";
                   {                    "start code block:"
                    __el-'*@?           "c = (c != lowercase(c) ? '*' : c)";
                             }f%        "apply block to chars in each substring";
                                R*      "join the substrings with 'REX' again";
                                  .|    "bitwise OR the case bits back in";

Trik hemat huruf berfungsi karena huruf ASCII ditentukan oleh bit kelima kode ASCII: bit ini adalah 0 untuk huruf besar dan 1 untuk huruf kecil. Dengan demikian, mengambil bitwise AND dari kode karakter dengan 32 = 2 ⁵ mengekstrak bit case, dan bitwise ORing bit ini dengan huruf besar mengembalikan case asli mereka.

Tentu saja, karakter non-alfabet dapat memiliki nilai arbitrer untuk bit kelima (walaupun, karena cara karakter ASCII diatur, sebagian besar karakter tanda baca memiliki bit kelima diatur ke 1) tetapi ini tidak masalah, karena karakter tersebut dibiarkan tidak tersentuh oleh huruf besar dan loop sensor huruf tetap, dan ORing karakter dengan bit kelima sendiri tidak mengubahnya. Selain itu, mudahnya, *karakter sudah memiliki set bit kelima, sehingga tidak berubah oleh final .|.

Pip , 21 19 byte

qR-`(rex)|\w`{b|'*}

Mengambil input dari stdin, output ke stdout. Cobalah online!

Penjelasan

q                    Read a line of stdin
 R                   and replace
   `(rex)|\w`          a regex matching `rex` or any single alphanumeric character,
  -                    case-insensitive
             {    }  with this callback function:
              b|'*     If the 1st capture group (rex) matched, return it, else asterisk
                       The result of the replacement is auto-printed

V , 27 , 24 byte

Saya meninggalkan kedua jawaban itu, karena saya pikir keduanya sama-sama menarik.

27 byte

òÓãr¨ex©À!ü¼eü¼xü[rex]À!÷/*

Cobalah online!

Terima kasih kepada Brian McCutchon untuk idenya untuk melakukan ini dalam V

Hexdump:

00000000: f2d3 e372 a865 78a9 c021 fcbc 65fc bc78  ...r.ex..!..e..x
00000010: fc5b 7265 785d c021 f72f 2a              .[rex].!./*

Penjelasan:

ò                           " Until the output stops changing...
 Óãr¨ex©À!ü¼eü¼xü[rex]À!÷/* " Run the compressed vim regex:

:s/\vr(ex)@!|<e|<x|[rex]@!\w/*/gi

24 byte

Óãrex/ò&ò
HòÓ÷/*/e
jjòÍî

Cobalah online!

Ó           " Substitute
 ã          "   (case-insensitive)
  rex       "   'rex'
     /      " with
       &    "   'rex'
      ò ò   "   Surrounded in new lines
ò           " Recursively...
 Ó          "   Substitute...
  ÷         "     A word character
   /        "   with
    *       "     An asterisk
     /e     "     (don't break if there are 0 matches)
jj          "   Move down 2 lines
  ò         " end the recursive loop
   Íî       " Remove all newlines