Con chó của tôi được gọi là Rex. Mỗi lần tôi mắng anh ta, anh ta có vẻ không ấn tượng lắm và lần duy nhất tôi thấy anh ta phản ứng là khi tôi phát âm tên anh ta. Nếu tôi nói

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

tất cả những gì anh nghe được là

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

Thách thức : đưa ra một chuỗi đầu vào, chương trình của bạn phải xuất ra cùng một chuỗi trong đó tất cả các ký tự chữ cái đã được chuyển thành các ngôi sao, ngoại trừ các ký tự trong lần xuất hiện của từ Rex, người không được chạm tới. Các ký tự không phải là chữ cái cũng không bị ảnh hưởng.

Chi tiết : Thách thức không phân biệt chữ hoa chữ thường, do đó rexcũng phải được xử lý. Từ này Rexcó thể là một phần của một từ khác, vì vậy, ví dụ anorexicphải được hiển thị là ***rex**.

Cập nhật : vì văn bản ban đầu của thử thách này không làm rõ cách xử lý dấu gạch dưới hoặc số hoặc ký tự có dấu, nên tôi không đưa ra bất kỳ yêu cầu đặc biệt nào đối với các ký tự đó. Do đó, một giải pháp có giá trị miễn là các ký tự trong a-zA-Z(và cả các ký tự được đề cập trong các ví dụ ,!".) được xử lý chính xác.

Các trường hợp thử nghiệm:

Đầu vào : Rex lives in Rexland.

Đầu ra: Rex ***** ** Rex****.

Đầu vào : To call Rex, just say "Rex".

Đầu ra: ** **** Rex, **** *** "Rex".

Đầu vào : My cat is getting anorexic.

Đầu ra: ** *** ** ******* ***rex**.

Võng mạc , 24 21 byte

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

Hãy thử trực tuyến!

Giải trình

Bỏ qua rexlà dễ nhất bằng cách kết hợp chúng, bởi vì các kết quả khớp không thể trùng nhau. Vì vậy, nếu chúng tôi ưu tiên rexhơn các chữ cái khác, chúng sẽ được bao phủ trong một trận đấu duy nhất và không bị chạm bởi các trận đấu chữ cái riêng lẻ.

Nhưng làm thế nào để chúng ta làm những điều khác nhau tùy thuộc vào sự thay thế đã được sử dụng cho trận đấu? Thật không may, Retina không (chưa) có bất kỳ cú pháp thay thế có điều kiện nào như hương vị regex Boost. Nhưng chúng ta có thể giả mạo nó bằng cách bao gồm cả hai sự thay thế trong một lần thay thế duy nhất và đảm bảo rằng chỉ một trong số chúng là không trống:

• $1là nhóm bắt đầu tiên, tức là (rex). Nếu chúng ta khớp với rexđiều này chỉ đơn giản là viết lại (vì vậy nó không làm gì cả), nhưng nếu chúng ta không khớp rexthì đó $1là một chuỗi trống và biến mất.
• $#2$**nên được đọc như ($#2)$*(*). $#2là số lần nhóm 2được sử dụng, tức là (\w). Nếu chúng ta khớp với rexcái này 0, nhưng nếu chúng ta khớp với bất kỳ chữ cái riêng lẻ nào khác thì đây là 1. $*lặp lại ký tự tiếp theo nhiều lần như toán hạng bên trái của nó. Vì vậy, phần này chèn một lần duy nhất *cho các kết hợp chữ cái riêng lẻ và không có gì cả rex.

** REXX 151 148 141 byte **

(Kinda có vẻ phù hợp)

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

Hãy thử nó ở đây

Lưu ý cho những người không phải REXXers:

1. dịch là một hàm thay thế ký tự (tên xuất phát từ một lệnh biên dịch chương trình trên IBM MF). Nó tìm kiếm chuỗi1 cho các ký tự trong chuỗi3. Mỗi lần nó tìm thấy nó sẽ thay thế nó bằng cùng một vị trí trong chuỗi2. Nếu chuỗi2 quá ngắn, nó được đệm với ký tự pad.

Xem ở đây để biết chức năng dịch

2. lớp phủ chỉ đơn giản là lớp phủ chuỗi1 trên đầu chuỗi2 tại vị trí đã chỉ định.

Xem ở đây để biết chức năng lớp phủ

JavaScript (ES6), 42 41 38 byte

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

Thử nó

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>

Giải trình

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

Hãy thử trực tuyến!

PCRE R đơn giản .

⍠1đặt trường hợp không nhạy cảm. Đơn giản chỉ cần thay thế rexbằng chính nó và tất cả các ký tự từ khác bằng dấu hoa thị.

Perl 5 , 24 byte

23 byte mã + -pcờ.

Tôi đã sử dụng regex của Martin Ender từ câu trả lời Retina của anh ấy (điều này xảy ra ngắn hơn ở Perl, nhờ \pl) và chỉ phải điều chỉnh phía bên phải của s ///.

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

Hãy thử trực tuyến!

Võng mạc , 32 31 byte

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

Hãy thử trực tuyến! Giải thích: Chia chuỗi thành các lần xuất hiện của từ rexvà mọi thứ khác, nhưng vẫn giữ các kết quả khớp. Sau đó, trên các dòng không bắt đầu rex(nghĩa là "mọi thứ khác"), thay đổi chữ cái thành *s. Cuối cùng, tham gia mọi thứ lại với nhau.

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

Môi trường IDE Pelles cung cấp (biên dịch với / Go) hàm strnicmp. Hàm này giống hệt với strncasecmp. Xem nó hoạt động ở đây (với chức năng thay thế).

Đầu ra được lưu trong tham số đầu tiên là tham số vào / ra.

Cảm ơn Johan du Toit đã cho tôi biết rằng đệ quy ngắn hơn một chút.

Ruby, 36 35 32 byte

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

Như một bài kiểm tra:

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

Nó xuất ra:

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 byte

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

Hãy thử trực tuyến!

PHP, 84 byte

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

-1 Byte \wthay vào đó \pltrong trường hợp này gạch dưới và số cũng được thay thế

\pLngắn hơn là [a-z]hoặc[[:alpha:]]

Hãy thử trực tuyến!

C (GCC trên 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);}

Hãy thử trực tuyến!

Python 2 hoặc 3, 75 73 70 byte

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

Về cơ bản giống như câu trả lời của Ruby của tôi .

-2 byte nhờ @Wondercricket.

Như một bài kiểm tra:

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 nhờ @ OlivierGrégoire.

Giải trình:

Hãy thử trực tuyến.

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 byte

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

Tôi đoán có thể rút ngắn? :)

sed , 37 33 byte

36 byte sourcecode + 1 byte cho cờ -r.

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

Hãy thử trực tuyến!

Gema, 25 ký tự

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

Chạy mẫu:

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

Thực tế đau đớn có thể \CRex=$0;<L1>=\*, nhưng không may $0chứa mẫu, không phải là trận đấu. ☹

Võng mạc , 54 50 49 byte

Đã chơi 5 byte nhờ @MartinEnder

Võng mạc , 49 byte

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

Hãy thử trực tuyến!

PowerShell, 60 byte

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

Dùng thử trực tuyến

QuadR , 11 10 + 1 = 11 byte

+1 byte cho icờ.

rex
\w
&
*

Hãy thử trực tuyến!

Giải thích: Thay thế không phân biệt chữ hoa chữ thường rexvà chữ tương ứng bằng chính nó và dấu hoa thị.

MATL , 24 byte

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

Đầu vào là một chuỗi được bao trong các dấu ngoặc đơn.

Hãy thử trực tuyến!

Giải trình

Xem xét đầu vào '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:]))

Hãy thử trực tuyến!

Perl, 31 byte

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

Gọi perl với -ntùy chọn. Ví dụ:

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*

Hãy thử trực tuyến!

Tôi đang theo dõi câu trả lời trước của tôi, chuỗi bash không chức năng thay thế và không thay thế preg!

Ít chơi gôn hơn:

    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 *

Phải sử dụng z thay vì * vì mở rộng

Java 7, 96 98 97 96 byte

+2 byte cho thiếu e đứng trước r hoặc theo sau bởi x nhưng không phải cả hai

-1 byte để thay đổi [a-z&&[^rex]]thành(?![rex])\\w

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

Hãy thử trực tuyến!

Phiên bản regex để thay thế bằng Java

Thay thế mọi thứ trong regex này bằng dấu * (lưu ý trong Java \ w phải được thoát là \ 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:"*");

Hãy tin rằng đây là lần đầu tiên tôi sử dụng regex trong câu trả lời C # ở đây vì không gian tên dài System.Text.RegularExpressions.

Tôi đã không nhận ra khi tôi viết câu trả lời của mình nhưng đây dường như là phiên bản C # của câu trả lời JavaScript của @ Shaggy .

CJam , 39 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Và đây là một sự thay thế thú vị gần như hoạt động:

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

Hãy tưởng tượng việc chạy này liên tục trên chuỗi Rex, dex, I told you not to do this! You're making me angry Rex!Sau dòng đầu tiên, chuỗi là Rex, *ex, * **** *** *** ** ** ****! ***'*e ****** *e ***** Rex!Đường chuyền thứ hai sẽ dẫn đến Rex, **x, * **** *** *** ** ** ****! ***'** ****** ** ***** Rex!và đường chuyền thứ ba sẽ kết thúc chuỗi đó. Bất kỳ lần tiếp theo nào sẽ không thay đổi chuỗi. Tuy nhiên, có thể mất hơn 3 lần thay thế để đến đó, ví dụ như trên chuỗi xxxxxxxx. Vì vậy, nếu có một cách dễ dàng để chạy thay thế ở trên cho đến khi nó ngừng thay đổi mọi thứ, hoặc nhiều lần như độ dài của đầu vào, đó sẽ là một giải pháp khác. Tôi cá là nó có thể được thực hiện bằng V, nhưng nó vẫn có thể dài hơn 34 byte.

Thạch , 23 byte

Không có câu trả lời nào trong hơn 24 giờ cho câu hỏi của tôi về trường hợp này , vì vậy tôi sẽ đăng bài dự kiến ​​23 byter này.

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

Xem các trường hợp thử nghiệm tại Dùng thử trực tuyến!

Làm sao?

“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 (đầu ra chữ hoa) / 36 byte (bảo quản trường hợp)

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

Hãy thử trực tuyến!

Nếu trường hợp chữ cái cần được bảo tồn (vì vẫn chưa rõ ràng một chút ), điều đó có thể được thực hiện với 10 byte bổ sung:

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

Hãy thử trực tuyến!

Nhân tiện, trong khi viết câu trả lời này, tôi đã tìm thấy cái mà tôi sẽ coi là lỗi thiết kế trong CJam: các toán tử bitwise &và |không được xác định giữa hai giá trị char, vì vậy tôi không thể sử dụng .|để lấy bit HOẶC của hai chuỗi. Giải pháp, cuối cùng khiến tôi phải trả thêm hai byte, trước tiên là chuyển đổi một trong các chuỗi :ithành một mảng các số nguyên, sau đó có thể được OR với chuỗi khác. (Trên thực tế, tôi phải trả ba byte, vì nếu &làm việc giữa hai ký tự, tôi cũng có thể sử dụng Sf&thay vì 32f&lưu thông tin trường hợp chữ cái.)

Về mặt tích cực, tôi đã khám phá ra rằng {...}f%thực sự hoạt động như mong đợi để lặp lại các ký tự trong một chuỗi các chuỗi. Đẹp.

Dù sao, đây là phiên bản được nhận xét (nhẹ) của mã 36 byte:

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

Thủ thuật lưu trường hợp hoạt động vì trường hợp các chữ cái ASCII chỉ được xác định bởi bit thứ năm của mã ASCII: bit này là 0 cho chữ hoa và 1 cho chữ cái viết thường. Do đó, lấy bit bit AND của mã ký tự với 32 = 2 ⁵ trích xuất bit trường hợp và bit bit ORing bit này với các chữ cái viết hoa khôi phục lại trường hợp ban đầu của chúng.

Tất nhiên, các ký tự không phải là chữ cái có thể có các giá trị tùy ý cho bit thứ năm (mặc dù, do cách tổ chức các ký tự ASCII, hầu hết các ký tự dấu chấm câu có bit thứ năm được đặt thành 1) nhưng điều này không thành vấn đề, vì các ký tự đó bị bỏ lại không bị ảnh hưởng bởi cách viết hoa và vòng lặp kiểm duyệt chữ cái, và ORing một ký tự với bit thứ năm của chính nó không thay đổi nó. Ngoài ra, thuận tiện, *nhân vật đã có bộ bit thứ năm, do đó, nó cũng không bị thay đổi bởi trận chung kết .|.

Pip , 21 19 byte

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

Đưa đầu vào từ stdin, đầu ra đến thiết bị xuất chuẩn. Hãy thử trực tuyến!

Giải trình

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

Tôi đang để lại cả hai câu trả lời, vì tôi nghĩ chúng thú vị như nhau.

27 byte

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

Hãy thử trực tuyến!

Cảm ơn Brian McCutchon vì ý tưởng của anh ấy để làm điều này trong V

Hexdump:

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

Giải trình:

ò                           " 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òÍî

Hãy thử trực tuyến!

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