Mój pies nazywa się Rex. Za każdym razem, gdy go besztam, wydaje się, że nie jest pod wielkim wrażeniem, a kiedy widzę, że reaguje, to kiedy wymawiam jego imię. Jeśli powiem

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

wszystko co słyszy to

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

Wyzwanie : biorąc pod uwagę ciąg wejściowy, twój program musi wypisać ten sam ciąg, w którym wszystkie znaki alfabetu zostały zamienione na gwiazdki, z wyjątkiem znaków w wyglądzie słowa Rex, które muszą pozostać nietknięte. Znaki niealfabetyczne również pozostają nietknięte.

Szczegóły : w wyzwaniu nie jest rozróżniana wielkość liter, dlatego rexteż nie można go zmieniać. Słowo Rexmoże być częścią innego słowa, więc na przykład anorexicmusi być renderowane jako ***rex**.

Aktualizacja : ponieważ początkowy tekst tego wyzwania nie wyjaśniał, w jaki sposób należy traktować podkreślenia, liczby lub znaki akcentowane, nie wymagam od tych znaków żadnych specjalnych wymagań. Dlatego rozwiązanie jest ważne, o ile znaki w a-zA-Z(a także te wymienione w przykładach ,!".) są obsługiwane poprawnie.

Przypadki testowe :

Wejście : Rex lives in Rexland.

Wynik : Rex ***** ** Rex****.

Wejście : To call Rex, just say "Rex".

Wynik : ** **** Rex, **** *** "Rex".

Wejście : My cat is getting anorexic.

Wynik : ** *** ** ******* ***rex**.

Siatkówka , 24 21 bajtów

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

Wypróbuj online!

Wyjaśnienie

Pomijanie rexs jest najłatwiejsze, dopasowując je również, ponieważ dopasowania nie mogą się nakładać. Więc jeśli damy pierwszeństwo rexinnym literom, zostaną one pokryte jednym dopasowaniem i nie będą dotknięte dopasowaniami pojedynczych liter.

Ale jak robimy różne rzeczy w zależności od alternatywy użytej do meczu? Niestety, Retina (jeszcze) nie ma żadnej składni warunkowej substytucji, takiej jak smak regexu Boost. Ale możemy to sfałszować, włączając obie substytucje do jednego zamiennika i upewniając się, że tylko jedna z nich nie jest pusta:

• $1jest pierwszą grupą przechwytującą, tj (rex). Jeśli to zrobiliśmy, rexpo prostu zapisuje to z powrotem (więc nic nie robi), ale jeśli nie pasujemy, rexto $1jest pusty ciąg i znika.
• $#2$**należy czytać jako ($#2)$*(*). $#2oznacza liczbę przypadków 2użycia grupy , tj (\w). Jeśli tak, rexto 0jeśli tak, ale jeśli dopasowaliśmy inną indywidualną literę, to jest 1. $*powtarza następną postać tyle razy, ile operand po lewej stronie. Ta część wstawia singiel *dla pojedynczych liter i nic rex.

** REXX 151 148 141 bajtów **

(Trochę mi się to wydawało właściwe)

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

Wypróbuj tutaj

Uwagi dla nie-REXXerów:

1. translate to funkcja zastępująca znaki (nazwa pochodzi od instrukcji asemblera na IBM MF). Przeszukuje string1 pod kątem znaków w string3. Za każdym razem, gdy ją znajdzie, zastępuje ją tą samą pozycją w string2. Jeśli string2 jest zbyt krótki, jest uzupełniany znakiem padu.

Zobacz tutaj funkcję tłumaczenia

2. nakładka po prostu nakłada string1 na string2 w określonej pozycji.

Zobacz tutaj funkcję nakładki

JavaScript (ES6), 42 41 38 bajtów

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

Spróbuj

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>

Wyjaśnienie

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 bajty ^SBCS

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

Wypróbuj online!

Proste PCRE R EUmieãæ.

⍠1ustawia niewrażliwość na wielkość liter. Po prostu zastępuje rexsiebie i wszystkie inne znaki słowne gwiazdkami.

Perl 5 , 24 bajtów

23 bajty kodu + -pflaga.

Użyłem wyrażenia regularnego Martina Endera z jego odpowiedzi Retina (która dzięki Perlowi jest krótsza, dzięki \pl) i musiałem tylko dostosować prawą stronę s ///.

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

Wypróbuj online!

Retina , 32 31 bajtów

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

Wypróbuj online! Objaśnienie: Dzieli ciąg na wystąpienia słowa rexi wszystkiego innego, ale zachowuje dopasowania. Następnie w wierszach, które się nie rozpoczynają rex(tj. „Wszystko inne”), zmień litery na *s. Na koniec połącz wszystko z powrotem razem.

C, 99 97 92 86 74 73 72 65 bajtów

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

Środowisko Pelles IDE udostępnia (kompiluje z / Go) funkcję strnicmp. Ta funkcja jest identyczna jak strncasecmp. Zobacz, jak to działa tutaj (z funkcją zastępowania).

Dane wyjściowe są przechowywane w pierwszym parametrze, który jest parametrem wejścia / wyjścia.

Dzięki Johan du Toit za poinformowanie mnie, że rekursja jest nieco krótsza.

Rubinowy, 36 35 32 bajtów

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

Jako test:

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

Wytwarza:

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 bajtów

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

Wypróbuj online!

PHP, 84 bajtów

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

-1 bajt \wzamiast \pltego w tym przypadku podkreślenie i liczby również są zastępowane

\pLjest krótszy jako [a-z]lub[[:alpha:]]

Wypróbuj online!

C (GCC na POSIX), 167 118 93 87 bajtów

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

Wypróbuj online!

Python 2 lub 3, 75 73 70 bajtów

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

W zasadzie taki sam jak mój Ruby odpowiedź .

-2 bajty dzięki @Wondercricket.

Jako test:

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 159 138 bajtów

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 bajtów dzięki @ OlivierGrégoire.

Wyjaśnienie:

Wypróbuj 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 bajtów

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

Myślę, że można to skrócić? :)

sed , 37 33 bajtów

36 bajtów kod źródłowy + 1 bajt dla flagi -r.

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

Wypróbuj online!

Gema, 25 znaków

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

Przykładowy przebieg:

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

Bolesny fakt, który może być \CRex=$0;<L1>=\*, ale niestety $0zawiera szablon, a nie dopasowanie. ☹

Siatkówka , 54 50 49 bajtów

Grał w golfa 5 bajtów dzięki @MartinEnder

Siatkówka , 49 bajtów

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

Wypróbuj online!

PowerShell, 60 bajtów

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

Wypróbuj online

QuadR , 11 10 + 1 = 11 bajtów

+1 bajt dla iflagi.

rex
\w
&
*

Wypróbuj online!

Objaśnienie: Zastępuje bez rozróżniania wielkości liter rexi znaków słownych odpowiednio z samym sobą i gwiazdkami.

MATL , 24 bajty

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

Dane wejściowe to ciąg ujęty w pojedyncze cudzysłowy.

Wypróbuj online!

Wyjaśnienie

Rozważ wejście '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 bajty

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

Wypróbuj online!

Perl, 31 bajtów

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

Wywołaj perla z -nopcją. Na przykład:

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

Bash , 128 bajtów

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*

Wypróbuj online!

Trzymam się tr na mojej poprzedniej odpowiedzi, zastępuję niefunkcjonalny ciąg tablicy bash i nie zastępuję preg!

Mniej golfa:

    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 *

Musiałem użyć z zamiast * z powodu rozszerzenia

Java 7, 96 98 97 96 bajtów

+2 bajty za brakujące e poprzedzone r lub po którym następuje x, ale nie oba

-1 bajt do zmiany [a-z&&[^rex]]na(?![rex])\\w

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

Wypróbuj online!

Wersja wyrażenia regularnego do zastępowania za pomocą Java

Zamienia wszystko w tym wyrażeniu regularnym na * (uwaga w Javie \ w musi być zmieniona jako \\ 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 bajtów

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

Uwierz, że po raz pierwszy użyłem wyrażenia regularnego w odpowiedzi w języku C # ze względu na długą przestrzeń nazw System.Text.RegularExpressions.

Nie zdawałem sobie z tego sprawy, kiedy napisałem swoją odpowiedź, ale wygląda na to, że jest to wersja C # odpowiedzi JavaScript @ Shaggy'ego .

CJam , 39 bajtów

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

Wypróbuj online!

Jak to działa

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 bajty

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

A oto ciekawa substytucja, która prawie działa:

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

Wyobraź sobie, że powtarzasz to wielokrotnie w ciągu. Rex, dex, I told you not to do this! You're making me angry Rex!Po pierwszym wierszu napis: Rex, *ex, * **** *** *** ** ** ****! ***'*e ****** *e ***** Rex!Drugie przejście spowoduje Rex, **x, * **** *** *** ** ** ****! ***'** ****** ** ***** Rex!, a trzecie przejście go zakończy. Wszelkie kolejne przejścia nie zmienią ciągu. Jednak może to zająć więcej niż 3 podstawienia, na przykład w łańcuchu xxxxxxxx. Tak więc, jeśli istniałby łatwy sposób uruchomienia powyższej substytucji, dopóki nie przestanie ona zmieniać rzeczy lub tyle razy, ile wynosi długość danych wejściowych, byłoby to inne rozwiązanie. Założę się, że można to zrobić w V, ale prawdopodobnie będzie to dłużej niż 34 bajty.

Galaretka , 23 bajty

Brak odpowiedzi w ciągu ponad 24 godzin na moje pytanie dotyczące sprawy , więc opublikuję ten niepewny 23 bajt.

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

Zobacz przypadki testowe na stronie Wypróbuj online!

W jaki sposób?

“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 bajtów (wyjście wielkich liter) / 36 bajtów (zachowanie wielkości liter)

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

Wypróbuj online!

Jeśli trzeba zachować wielkość liter (ponieważ nadal jest to trochę niejasne ), można to osiągnąć za pomocą 10 dodatkowych bajtów:

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

Wypróbuj online!

Nawiasem mówiąc, pisząc tę ​​odpowiedź, znalazłem coś, co uważam za błąd projektowy w CJam: operatory bitowe &i |nie są zdefiniowane między dwiema wartościami char, więc nie mogę użyć .|bitowej LUB dwóch ciągów. Rozwiązaniem, które w końcu kosztowało mnie dwa dodatkowe bajty, jest najpierw konwersja jednego z łańcuchów za pomocą :ina tablicę liczb całkowitych, które następnie można ORedować z drugim łańcuchem. (W rzeczywistości kosztowało mnie to trzy bajty, ponieważ jeśli &działałem między dwoma znakami, mógłbym również użyć Sf&zamiast 32f&zapisywania informacji o wielkości liter).

Z drugiej strony odkryłem, że {...}f%rzeczywiście działa zgodnie z oczekiwaniami w przypadku iteracji znaków w szeregu ciągów. Miły.

W każdym razie oto (lekko) skomentowana wersja 36-bajtowego kodu:

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

Sztuczka polegająca na zapisywaniu wielkości liter działa, ponieważ wielkość liter ASCII jest określana wyłącznie przez piąty bit kodu ASCII: ten bit to 0 dla wielkich liter i 1 dla małych liter. Zatem pobranie bitowego AND kodu znakowego o wartości 32 = ²⁵ wyodrębnia bit wielkości liter, a bitowe ORowanie tego bitu wielkimi literami przywraca ich pierwotną wielkość.

Oczywiście znaki niealfabetyczne mogą mieć dowolne wartości dla piątego bitu (chociaż ze względu na sposób organizacji znaków ASCII większość znaków interpunkcyjnych ma ustawiony piąty bit na 1), ale to nie ma znaczenia, ponieważ znaki te pozostały i tak nietknięte przez górną część obudowy i pętlę cenzurowania liter, a ORing znaku z jego piątym bitem go nie zmienia. Ponadto, dogodnie, *postać ma już ustawiony piąty bit, więc pozostaje również niezmieniony przez finał .|.

Pip , 21 19 bajtów

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

Pobiera dane wejściowe ze standardowego wejścia, a wyjściowe na standardowe wyjście. Wypróbuj online!

Wyjaśnienie

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 bajtów

Obie odpowiedzi pozostawiam, bo myślę, że są równie interesujące.

27 bajtów

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

Wypróbuj online!

Dzięki Brianowi McCutchonowi za pomysł zrobienia tego w V

Hexdump:

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

Wyjaśnienie:

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

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

24 bajty

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

Wypróbuj 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