내 개는 렉스라고합니다. 내가 그를 꾸짖을 때마다, 그는 그다지 큰 인상을받지 않은 것 같으며 내가 그를 보는 유일한 순간은 내가 그의 이름을 발음 할 때입니다. 내가 말하면

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

온라인으로 사용해보십시오!

설명

rexs를 건너 뛰는 것은 일치하는 항목과 겹칠 수 없기 때문에 가장 쉬운 방법입니다. 따라서 rex다른 문자보다 우선 순위가 높은 경우 단일 문자로 표시되며 개별 문자 일치는 다루지 않습니다.

그러나 경기에 사용 된 대안에 따라 어떻게 다른 일을합니까? 불행히도 Retina는 Boost 정규식 풍미와 같은 조건부 대체 구문을 가지고 있지 않습니다. 그러나 두 개의 대체를 단일 대체에 포함시키고 그 중 하나만 비어 있지 않은지 확인하여 위조 할 수 있습니다.

• $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

여기 사용해보십시오

비 REXXers를위한 참고 사항 :

1. translate는 문자 교체 기능입니다 (이름은 IBM MF의 어셈블러 명령어에서 제공됨). string3에서 string3의 문자를 검색합니다. 하나를 찾을 때마다 string2에서 동일한 위치로 바꿉니다. string2가 너무 짧으면 패드 문자로 채워집니다.

번역 기능은 여기를 참조하십시오

2. 오버레이는 단순히 지정된 위치에서 string2 위에 string1을 오버레이합니다.

오버레이 기능은 여기를 참조하십시오

자바 스크립트 (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의 eplace.

⍠1대소 문자를 구분하지 않습니다. rex그 자체와 다른 모든 단어 문자를 별표로 간단히 대체합니다 .

펄 5 , 24 바이트

23 바이트의 코드 + -p플래그.

나는 그의 Retina 답변 에서 Martin Ender의 정규 표현식을 사용했으며 (이 덕분에 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 환경은 strnicmp 함수를 제공합니다 (/ Go로 컴파일). 이 기능은 strncasecmp와 동일합니다. 여기에서 작동 하는지 확인 하십시오 (교체 기능 사용).

출력은 입력 / 출력 매개 변수 인 첫 번째 매개 변수에 저장됩니다.

재귀가 약간 짧다는 것을 알려 주신 Johan du Toit 에게 감사드립니다 .

루비, 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의 답변 과 동일 합니다.

@Wondercricket 덕분에 -2 바이트.

테스트로 :

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

@ OlivierGrégoire 덕분에 -28 바이트.

설명:

온라인으로 사용해보십시오.

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

파이썬 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 바이트

-r 플래그의 경우 36 바이트 소스 코드 + 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 바이트

i플래그의 경우 +1 바이트

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

파이썬 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:]))

온라인으로 사용해보십시오!

펄, 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 바꾸기가 tr에 붙어 있습니다!

덜 골프 :

    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를 사용해야했습니다.

자바 7, 96 98 97 96 바이트

누락 된 e 앞에 r이 앞에 오거나 x가 오는 경우 +2 바이트

로 변경 [a-z&&[^rex]]하기 위한 -1 바이트(?![rex])\\w

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

온라인으로 사용해보십시오!

Java를 사용하여 교체하기위한 정규식 버전

이 정규식의 모든 것을 *로 바꿉니다 (Java의 참고는 \\ 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!이고 세 번째 패스가 완료됩니다. 후속 패스는 문자열을 변경하지 않습니다. 그러나 예를 들어 string과 같이 3 회 이상 대체해야 할 수 있습니다 xxxxxxxx. 따라서 변경 사항을 멈추거나 입력 길이만큼 여러 번 위의 대체를 실행하는 쉬운 방법이 있다면 또 다른 해결책이 될 것입니다. V로 할 수는 있지만 여전히 34 바이트보다 길 것입니다.

젤리 , 23 바이트

case 에 관한 질문에 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을 사용 하는 데 사용할 수 없습니다 . 2 바이트의 비용이 들었던 해결책은 먼저 문자열 중 하나 :i를 정수 배열로 변환 한 다음 다른 문자열과 OR 될 수 있습니다. (실제로 두 문자 사이에서 작업 하면 대소 문자 정보를 저장하는 대신 사용할 수 있기 때문에 3 바이트가 필요 &했습니다 .)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 ^{5 인} 문자 코드의 비트 AND를 취하면 대소 문자를 추출하고이 비트를 대문자로 비트 OR하면 원래 대소 문자를 복원합니다.

물론, 알파벳이 아닌 문자는 다섯 번째 비트에 대해 임의의 값을 가질 수 있습니다 (ASCII 문자가 구성되는 방식으로 인해 대부분의 문장 부호 문자는 다섯 번째 비트가 1로 설정 됨). 어쨌든 대문자와 문자 검열 루프에 의해 건드리지 않고 자신의 다섯 번째 비트로 문자를 OR 링해도 변경되지 않습니다. 또한 편리하게도 *문자에는 이미 다섯 번째 비트 세트가 있으므로 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]À!÷/*

온라인으로 사용해보십시오!

V에서이 작업 을 수행 하려는 그의 아이디어에 대해 Brian McCutchon에게 감사합니다.

16 진 덤프 :

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