我的狗叫雷克斯。每当我责骂他时，他似乎都不会留下深刻的印象，而我唯一看到他的反应就是我念出他的名字时。如果我说

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

他所听到的是

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

挑战：给定一个输入字符串，您的程序必须输出相同的字符串，该字符串中所有字母字符都变为星号，但单词外观上的字符Rex（必须保持原状）除外。非字母字符也保持不变。

详细信息：挑战不区分大小写，因此也rex必须保持不变。该单词Rex可以是另一个单词的一部分，因此例如anorexic必须呈现为***rex**。

更新：由于此挑战的初始文本并未阐明应如何处理下划线或数字或重音符号，因此我对这些字符没有特殊要求。因此，只要正确处理a-zA-Z中的字符（以及示例中提到的字符），解决方案就有效,!".。

测试用例 ：

输入： Rex lives in Rexland.

输出： Rex ***** ** Rex****.

输入： To call Rex, just say "Rex".

输出： ** **** Rex, **** *** "Rex".

输入： My cat is getting anorexic.

输出： ** *** ** ******* ***rex**.

视网膜，24 21字节

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

在线尝试！

说明

rex也可以通过匹配来跳过，因为匹配不能重叠。因此，如果我们优先于rex其他字母，则这些字母将被覆盖在单个匹配项中，而不会受到单个字母匹配项的影响。

但是，根据比赛使用的替代方案，我们如何做不同的事情？不幸的是，Retina还没有像Boost regex之类的任何条件替换语法。但是我们可以通过将两个替换都包含在单个替换中并确保其中只有一个为非空来伪造它：

• $1是第一个捕获组，即(rex)。如果我们这样做符合rex这只是写回（所以它什么都不做），但如果我们不匹配rex则$1是一个空字符串和消失。
• $#2$**应该读为($#2)$*(*)。$#2是2使用组的次数，即(\w)。如果我们匹配，rex则为0，但如果我们匹配其他任何字母，则为1。$*将下一个字符重复其左操作数的次数。因此，此部分*为单个字母匹配项插入单个，而对于则完全不插入任何内容rex。

** REXX 151 148 141字节**

（金田似乎很合适）

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

在这里尝试

非REXXer的注意事项：

1. 翻译是字符替换功能（名称来自IBM MF上的汇编程序指令）。它在string1中搜索string3中的字符。每次找到一个时，它将替换为string2中相同位置的一个。如果string2太短，则用填充字符填充。

看到这里翻译功能

2. overlay只是将string1在指定位置的string2顶部覆盖。

参见此处的叠加功能

JavaScript（ES6），42 41 38字节

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

试试吧

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>

说明

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 字节^SBCS

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

在线尝试！

简单PCRE [R E放置。

⍠1设置不区分大小写。只需将rex其自身以及所有其他单词字符替换为星号即可。

Perl 5，24个字节

23个字节的代码+ -p标志。

我从Martin Ender的Retina答案中使用了regex （由于在Perl中它变短了，这要归功于\pl），并且只需要修改s ///的右侧即可。

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

在线尝试！

视网膜，32 31字节

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

在线尝试！说明：将字符串分成单词rex和其他所有单词的出现，但保留匹配项。然后，在没有开始的行rex（即“其他所有内容”）上，将字母更改为*s。最后，将所有内容重新组合在一起。

C，99 97 92 86 74 73 72 65字节

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

Pelles IDE环境提供了（使用/ Go编译）功能strnicmp。此功能与strncasecmp相同。看到它在这里工作（具有替换功能）。

输出存储在第一个参数中，第一个参数是输入/输出参数。

感谢Johan du Toit让我知道递归稍微短一些。

Ruby，36 35 32字节

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

作为测试：

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

它输出：

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字节

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

在线尝试！

PHP，84字节

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

在这种情况下，请\w改为-1字节\pl下划线和数字

\pL短于[a-z]或[[:alpha:]]

在线尝试！

C（POSIX上的GCC），167 118 93 87字节

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

在线尝试！

Python 2或3，75 73 70字节

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

基本上与我的Ruby的答案相同。

-2个字节，感谢@Wondercricket。

作为测试：

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)

爪哇8，187个 192 168 164 159 138字节

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个字节，感谢@OlivierGrégoire。

说明：

在线尝试。

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字节

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

我想可以缩短吗？:)

sed，37 33字节

36个字节的源代码+ -r标志的1个字节。

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

在线尝试！

Gema，25个字符

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

样品运行：

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

可能是的痛苦事实\CRex=$0;<L1>=\*，但不幸的是$0包含模板，而不是匹配。☹

视网膜，54 50 49字节

感谢@MartinEnder，打了5个字节

视网膜，49字节

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

在线尝试！

PowerShell，60字节

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

在线尝试

QuadR，11 10 +1 = 11字节

+1字节的i标志。

rex
\w
&
*

在线尝试！

说明：不区分大小写rex，分别用自身和星号替换和单词字符。

MATL，24字节

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

输入是用单引号引起来的字符串。

在线尝试！

说明

考虑输入 '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个字节

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

在线尝试！

Perl，31个字节

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

使用-n选项调用perl 。例如：

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

重击，128字节

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*

在线尝试！

我坚持我以前的回答，非功能性bash数组字符串替换并且没有preg替换！

少打高尔夫球：

    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 *

由于扩展，不得不使用z而不是*

Java 7、96 98 97 96字节

+2个字节，用于缺少e的前跟r或后跟x，但不能同时包含两者

-1个字节，用于更改[a-z&&[^rex]]为(?![rex])\\w

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

在线尝试！

使用Java替换的正则表达式版本

用*替换此正则表达式中的所有内容（Java \ w中的注释必须转义为\\ 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字节

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

相信这是我第一次在C＃答案中使用正则表达式，因为名称空间很长System.Text.RegularExpressions。

当我编写答案时并没有意识到这一点，但这似乎是@Shaggy的JavaScript答案的C＃版本。

CJam，39个字节

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

在线尝试！

这个怎么运作

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个字节

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

这是一个几乎可行的有趣替代方法：

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

想象在字符串上重复运行此命令，Rex, dex, I told you not to do this! You're making me angry Rex!在第一行之后，字符串为Rex, *ex, * **** *** *** ** ** ****! ***'*e ****** *e ***** Rex!。第二遍将得到Rex, **x, * **** *** *** ** ** ****! ***'** ****** ** ***** Rex!，第三遍将完成它。随后的任何传递都不会更改字符串。但是，可能需要3个以上的替换才能到达该位置，例如在string上xxxxxxxx。因此，如果有一种简单的方法可以运行上述替换操作，直到它停止更改内容或输入长度不变，那么这将是另一种解决方案。我敢打赌它可以在V中完成，但它可能仍会超过34个字节。

果冻，23 字节

我在24小时内未对案件提出任何问题，因此没有回复，因此，我将发布此暂定的23言。

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

请参阅“ 在线试用”中的测试用例！

怎么样？

“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个字节（大写输出）/ 36个字节（保留大小写）

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

在线尝试！

如果需要保留字母大小写（因为仍然不清楚），那么可以通过增加10个字节来实现：

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

在线尝试！

顺便说一句，在编写此答案时，我发现我会认为是CJam中的一个设计错误：按位运算符&并且|未在两个char值之间定义，因此我无法使用.|两个字符串的按位OR。解决方案最终导致我多花了两个字节，首先将其中一个字符串:i转换为整数数组，然后将其与另一个字符串进行“或”运算。（实际上，这花了我三个字节，因为如果&在两个字符之间工作，我还可以使用它Sf&来代替32f&字母大小写信息。）

从积极的一面来看，我确实发现{...}f%确实可以按预期的那样遍历字符串数组中的字符。真好

无论如何，这是36字节代码的（简短）注释版本：

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

节省大小写的技巧之所以有效，是因为ASCII字母的大小写完全由ASCII码的第五位决定：此位对于大写字母是0，对于小写字母是1。因此，使用32 = 2 ⁵的字符代码按位与将提取大小写位，并将此位与大写字母进行按位或运算将恢复其原始大小写。

当然，非字母字符的第五位可能具有任意值（尽管由于ASCII字符的组织方式，大多数标点符号都将第五位设置为1），但这无关紧要，因为这些字符已保留无论如何都不受大写字母和字母审查循环的影响，并且将字符与自己的第五位进行“或”运算不会改变它。同样，方便地，该*字符已经设置了第五位，因此final也将其保持不变.|。

点，21 19字节

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

从stdin输入，输出到stdout。在线尝试！

说明

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字节

我将两个答案都保留了，因为我认为它们同样有趣。

27个字节

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

在线尝试！

感谢Brian McCutchon 在V中执行此操作的想法

十六进制转储：

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

说明：

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

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

24字节

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

在线尝试！

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