Mein Hund heißt Rex. Jedes Mal, wenn ich ihn schimpfe, scheint er nicht sehr beeindruckt zu sein, und ich sehe ihn nur dann reagieren, wenn ich seinen Namen ausspreche. Wenn ich sage

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

alles was er hört ist

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

Die Herausforderung : Wenn Sie eine Eingabezeichenfolge angeben, muss Ihr Programm dieselbe Zeichenfolge ausgeben, in der alle alphabetischen Zeichen in Sterne umgewandelt wurden, mit Ausnahme der Zeichen im Wort Rex, die unangetastet bleiben müssen. Die nicht alphabetischen Zeichen bleiben ebenfalls unberührt.

Details : Die Herausforderung ist unabhängig von Groß- und Kleinschreibung und rexmuss daher auch unangetastet bleiben. Das Wort Rexkann Teil eines anderen Wortes sein, muss also beispielsweise anorexicals gerendert werden ***rex**.

Update : Da der ursprüngliche Text dieser Herausforderung nicht klarstellte, wie Unterstriche oder Zahlen oder akzentuierte Zeichen zu behandeln sind, habe ich keine besonderen Anforderungen an diese Zeichen. Daher ist eine Lösung gültig, solange die Zeichen in a-zA-Z(und auch die in den Beispielen genannten ,!".) korrekt behandelt werden.

Testfälle:

Eingabe: Rex lives in Rexland.

Ausgabe : Rex ***** ** Rex****.

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

Ausgabe : ** **** Rex, **** *** "Rex".

Eingabe: My cat is getting anorexic.

Ausgabe : ** *** ** ******* ***rex**.

Netzhaut , 24 21 Bytes

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

Probieren Sie es online!

Erläuterung

Das Überspringen von rexs ist am einfachsten, wenn Sie diese ebenfalls zuordnen, da Übereinstimmungen nicht überlappen können. Wenn wir also rexanderen Buchstaben Vorrang einräumen, werden diese in einer einzelnen Übereinstimmung behandelt und von den Übereinstimmungen mit einzelnen Buchstaben nicht berührt.

Aber wie machen wir verschiedene Dinge, je nachdem, welche Alternative für das Match verwendet wurde? Leider hat Retina (noch) keine bedingte Substitutionssyntax wie die Boost-Regex-Variante. Aber wir können es vortäuschen, indem wir beide Ersetzungen in eine einzige Ersetzung aufnehmen und sicherstellen, dass nur eine von ihnen nicht leer ist:

• $1ist die erste Erfassungsgruppe, dh die (rex). Wenn wir das täten passen rexdiese einfach schreibt sie zurück (so es tut nichts), aber wenn wir nicht übereinstimmen , rexdann $1ist eine leere Zeichenfolge und verschwindet.
• $#2$**sollte als gelesen werden ($#2)$*(*). $#2ist die Häufigkeit, mit der die Gruppe 2verwendet wurde, dh (\w). Wenn wir das gefunden rexhaben 0, aber wenn wir einen anderen Buchstaben gefunden haben, dann ist das der Fall 1. $*wiederholt das nächste Zeichen so oft wie sein linker Operand. Dieser Teil fügt also eine Single *für Einzelbuchstaben -Übereinstimmungen ein und überhaupt nichts für rex.

** REXX 151 148 141 Bytes **

(Ein bisschen schien angemessen)

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

Probieren Sie es hier aus

Hinweise für Nicht-REXXer:

1. translate ist eine Zeichenersetzungsfunktion (Name stammt aus einer Assembler-Anweisung in IBM MF). Es durchsucht string1 nach den Zeichen in string3. Jedes Mal, wenn es eines findet, wird es durch das gleiche in string2 ersetzt. Wenn string2 zu kurz ist, wird es mit dem Pad-Zeichen aufgefüllt.

Siehe hier für die Übersetzungsfunktion

2. Die Überlagerung überlagert einfach die Zeichenfolge1 an der angegebenen Position mit der Zeichenfolge2.

Siehe hier für die Überlagerungsfunktion

JavaScript (ES6), 42 41 38 Byte

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

Versuch es

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>

Erläuterung

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

Probieren Sie es online!

Einfacher PCRE R ersatz.

⍠1Legt die Groß- / Kleinschreibung fest. Ersetzt einfach rexmit sich selbst und alle anderen Wortzeichen mit Sternchen.

Perl 5 , 24 Bytes

23 Byte Code + -pFlag.

Ich habe Martin Enders Regex aus seiner Retina-Antwort (die in Perl dank kürzer ist \pl) verwendet und musste nur die rechte Seite des s /// anpassen.

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

Probieren Sie es online!

Retina , 32-31 Bytes

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

Probieren Sie es online! Erläuterung: Teilt die Zeichenfolge in Vorkommen des Wortes rexund alles andere auf, behält jedoch die Übereinstimmungen bei. rexÄndern Sie dann in Zeilen, die nicht beginnen (dh "alles andere"), die Buchstaben in *s. Zum Schluss alles wieder zusammenfügen.

C 99 97 92 86 74 73 72 65 Bytes

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

Die Pelles IDE-Umgebung bietet (Kompilieren mit / Go) die Funktion strnicmp. Diese Funktion ist identisch mit strncasecmp. Sehen Sie , wie es hier funktioniert (mit der Ersatzfunktion).

Die Ausgabe wird im ersten Parameter gespeichert, der ein In / Out-Parameter ist.

Vielen Dank an Johan du Toit, der mir mitteilte, dass die Rekursion etwas kürzer ist.

Ruby, 36 35 32 Bytes

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

Als 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

Es gibt aus:

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

Probieren Sie es online!

PHP, 84 Bytes

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

-1 Byte \wstattdessen, \plin diesem Fall werden Unterstrich und Zahlen ebenfalls ersetzt

\pList kürzer als [a-z]oder[[:alpha:]]

Probieren Sie es online!

C (GCC auf POSIX), 167 118 93 87 Bytes

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

Probieren Sie es online!

Python 2 oder 3, 75 73 70 Bytes

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

Grundsätzlich das gleiche wie meine Ruby- Antwort .

-2 Bytes dank @Wondercricket.

Als 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 138 Bytes

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 Bytes dank @ OlivierGrégoire.

Erläuterung:

Probieren Sie es online aus.

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

Ich denke, das kann gekürzt werden? :)

sed , 37 33 bytes

36 Byte Quellcode + 1 Byte für -r Flag.

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

Probieren Sie es online!

Gema, 25 Zeichen

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

Probelauf:

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

Schmerzhafte Tatsache, die sein könnte \CRex=$0;<L1>=\*, aber leider $0die Vorlage enthält, nicht die Übereinstimmung. ☹

Retina , 54 50 49 Bytes

Golf 5 Bytes dank @MartinEnder

Netzhaut , 49 Bytes

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

Probieren Sie es online!

PowerShell, 60 Byte

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

Probieren Sie es online aus

QuadR , 11 10 + 1 = 11 Bytes

+1 Byte für das iFlag.

rex
\w
&
*

Probieren Sie es online!

Erklärung: Ersetzen Sie rexund word-chars mit sich selbst bzw. Sternchen case-insensitively .

MATL , 24 Bytes

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

Die Eingabe ist eine Zeichenfolge in einfachen Anführungszeichen.

Probieren Sie es online!

Erläuterung

Betrachten Sie die Eingabe '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 Bytes

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

Probieren Sie es online!

Perl, 31 Bytes

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

Perl mit -nOption aufrufen . Zum Beispiel:

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

Bash , 128 Bytes

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*

Probieren Sie es online!

Ich halte mich an meine vorherige Antwort, nicht funktionierende Bash-Array-Zeichenfolge ersetzen und kein Preg ersetzen!

Weniger golfen:

    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 *

Musste wegen der Erweiterung z anstelle von * verwenden

Java 7, 96 98 97 96 Bytes

+2 Bytes für fehlende e vor r oder gefolgt von x, aber nicht beide

-1 Byte für den Wechsel [a-z&&[^rex]]zu(?![rex])\\w

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

Probieren Sie es online!

Eine Regex-Version zum Ersetzen mit Java

Ersetzt alles in diesem regulären Ausdruck durch ein * (Anmerkung in Java \ w muss als \\ w maskiert werden)

(?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 Bytes

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

Ich glaube, dies ist das erste Mal, dass ich in einer C # -Antwort aufgrund des langen Namespaces einen regulären Ausdruck verwende System.Text.RegularExpressions.

Ich wusste es nicht, als ich meine Antwort schrieb, aber dies scheint die C # -Version von @ Shaggys JavaScript-Antwort zu sein .

CJam , 39 Bytes

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

Probieren Sie es online!

Wie es funktioniert

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 Bytes

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

Und hier ist eine interessante Ersetzung, die fast funktioniert:

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

Stellen Sie sich vor, Sie führen dies wiederholt für die Zeichenfolge aus. Rex, dex, I told you not to do this! You're making me angry Rex!Nach der ersten Zeile lautet die Zeichenfolge. Rex, *ex, * **** *** *** ** ** ****! ***'*e ****** *e ***** Rex!Der zweite Durchgang führt zu Rex, **x, * **** *** *** ** ** ****! ***'** ****** ** ***** Rex!und der dritte Durchgang beendet die Zeichenfolge . Alle nachfolgenden Durchläufe ändern die Zeichenfolge nicht. Es können jedoch mehr als 3 Substitutionen erforderlich sein, beispielsweise auf einer Zeichenfolge xxxxxxxx. Wenn es also eine einfache Möglichkeit gäbe, die obige Substitution auszuführen, bis sich die Dinge nicht mehr ändern oder so oft wie die Länge der Eingabe, wäre dies eine andere Lösung. Ich wette, es könnte in V gemacht werden, aber es wäre wahrscheinlich immer noch länger als 34 Bytes.

Jelly , 23 Bytes

Keine Antwort in mehr als 24 Stunden auf meine Frage bezüglich des Falls , also werde ich dieses vorläufige 23 Byte posten.

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

Sehen Sie sich die Testfälle unter Online testen an !

Wie?

“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 Bytes (Ausgabe in Großbuchstaben) / 36 Bytes (Groß- / Kleinschreibung beachten )

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

Probieren Sie es online!

Wenn die Groß- und Kleinschreibung beibehalten werden muss (da dies noch etwas unklar ist ), kann dies mit 10 zusätzlichen Bytes erreicht werden:

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

Probieren Sie es online!

By the way, während diese Antwort zu schreiben, fand ich , was würde ich für ein Design - Fehler in CJam sein: die Bit - Operatoren &und |nicht zwischen zwei char Werten definiert, so kann ich nicht verwenden , .|das bitweise zu nehmen oder von zwei Strings. Die Lösung, die mich zwei zusätzliche Bytes :igekostet hat , besteht darin, zuerst eine der Zeichenfolgen mit in ein Array von Ganzzahlen zu konvertieren, die dann mit der anderen Zeichenfolge ODER-verknüpft werden können. (Eigentlich hat es mich drei Bytes gekostet , denn wenn& zwischen zwei Zeichen gearbeitet, konnte ich auch verwendet habe , Sf&statt 32f&die Groß- und Kleinschreibung Informationen zu speichern.)

Positiv ist, dass ich das entdeckt habe {...}f% Durchlaufen der Zeichen in einer Reihe von Zeichenfolgen tatsächlich wie erwartet funktioniert. Nett.

Wie auch immer, hier ist eine (leicht) kommentierte Version des 36-Byte-Codes:

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

Der Trick zum Speichern der Groß- und Kleinschreibung funktioniert, da die Groß- und Kleinschreibung von ASCII-Buchstaben ausschließlich durch das fünfte Bit des ASCII-Codes bestimmt wird: Dieses Bit ist 0 für Großbuchstaben und 1 für Kleinbuchstaben. Wenn Sie also das bitweise UND des Zeichencodes mit 32 = 2 ^{5 nehmen, wird} das Groß- / Kleinschreibung-Bit extrahiert, und wenn Sie dieses Bit mit den Großbuchstaben bitweise ODER-verknüpfen, wird die ursprüngliche Groß- / Kleinschreibung wiederhergestellt.

Natürlich können nicht-alphabetische Zeichen beliebige Werte für das fünfte Bit haben (obwohl aufgrund der Art und Weise, wie ASCII-Zeichen organisiert sind, das fünfte Bit bei den meisten Interpunktionszeichen auf 1 gesetzt ist), aber dies spielt keine Rolle, da diese Zeichen übrig bleiben Unberührt von Großbuchstaben und der Buchstaben-Zensur-Schleife ändert sich dies nicht, wenn Sie ein Zeichen mit einem eigenen fünften Bit ODER-verknüpfen. Praktischerweise ist für das *Zeichen bereits das fünfte Bit gesetzt, so dass es auch für das Finale unverändert bleibt .|.

Pip , 21 bis 19 Bytes

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

Übernimmt die Eingabe von stdin und gibt sie an stdout aus. Probieren Sie es online!

Erläuterung

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 Bytes

Ich lasse beide Antworten offen, weil ich denke, dass sie gleichermaßen interessant sind.

27 Bytes

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

Probieren Sie es online!

Vielen Dank an Brian McCutchon für seine Idee, dies in V zu tun

Hexdump:

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

Erläuterung:

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

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

24 Bytes

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

Probieren Sie es 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