Köpeğime Rex denir. Ona her azar azar attığımda, çok etkilenmiyor gibi görünüyor ve tepki verdiğini gördüğüm tek şey ismini telaffuz ettiğim zaman. Söylersem

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

tek duyduğu şey

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

Zorluk : bir giriş dizesi verildiğinde, programınız tüm alfabetik karakterlerin yıldızlara döndürüldüğü aynı dizgeyi Rex, dokunulmadan bırakılması gereken kelimenin görünüşündeki karakterlerin dışında aynı dizgeyi çıkarmalıdır. Alfabetik olmayan karakterlere de dokunulmaz.

Ayrıntılar : Zorluk büyük / küçük harfe duyarsızdır, bu nedenle rexdokunulmadan da bırakılmalıdır. Kelime Rexbaşka bir kelimenin parçası olabilir, bu nedenle örneğin olarak işlenmesi anorexicgerekir ***rex**.

Güncelleme : Bu zorluğun ilk metni, alt çizgi veya sayıların veya vurgulanan karakterlerin nasıl ele alınması gerektiğini netleştiremediğinden, bu karakterler için özel bir gereksinim duymuyorum. Bu nedenle, bir çözüm a-zA-Z(ve ayrıca örneklerde belirtilen ,!".) karakterleri doğru işlendiği sürece geçerlidir .

Test durumları:

Giriş: Rex lives in Rexland.

Çıktı : Rex ***** ** Rex****.

Giriş: To call Rex, just say "Rex".

Çıktı : ** **** Rex, **** *** "Rex".

Giriş: My cat is getting anorexic.

Çıktı : ** *** ** ******* ***rex**.

Retina , 24 21 bayt

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

Çevrimiçi deneyin!

açıklama

rexEşleşmeleri üst üste getiremediklerinden s'yi atlama aynı zamanda bunları eşleştirmekle kolaydır. Yani rex, diğer mektuplara göre öncelik verirsek , bunlar tek bir maçta ele alınacak ve bireysel mektup maçlarına dokunulmayacak.

Fakat maç için kullanılan alternatife bağlı olarak nasıl farklı şeyler yapabiliriz? Ne yazık ki, Retina'da (henüz) Boost regex aroması gibi koşullu bir ikame sözdizimi yoktur. Ancak, her iki değişikliği tek bir oyuncuya dahil ederek ve bunlardan sadece birinin boş olmadığından emin olarak sahte olabiliriz:

• $1ilk yakalama grubu, yani (rex). Biz maç yaptıysak rexbu basitçe (yani hiçbir şey yapmaz) geri yazar, ama biz eşleşmedi eğer rexo zaman $1boş bir dizedir ve ortadan kaybolur.
• $#2$**olarak okunmalı ($#2)$*(*). $#2grubun 2kullanıldığı kaç kez , yani (\w). Biz eşleşti Eğer rexbu 0, ancak herhangi diğer bireysel mektup uyum olursa, bu 1. $*Bir sonraki karakteri sol operandının çoğunu tekrar eder. Bu yüzden bu bölüm *bireysel harfli eşleşmeler için bir tane ve hiçbir şey için bir şey eklemez rex.

** REXX 151 148 141 bayt **

(Biraz uygun görünüyordu)

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

Burada dene

REXXer olmayanlar için notlar:

1. translate bir karakter değiştirme işlevidir (ad, IBM MF'deki bir assembler talimatından gelir). String3 içindeki karakterleri string1 olarak arar. Ne zaman bir tane bulursa onu string2 de aynı pozisyonda değiştirir. String2 çok kısa ise, ped karakteriyle doldurulur.

Tercüme işlevi için buraya bakın

2. bindirme, dizenin2 dizenin2 üstüne belirtilen konumda bindirilmesidir.

Bindirme işlevi için buraya bakınız

JavaScript (ES6), 42 41 38 bayt

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

Dene

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>

açıklama

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

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

Çevrimiçi deneyin!

Basit PCRE R eplace.

⍠1büyük / küçük harf duyarlılığını ayarlar. Basitçe rexkendisi ve diğer tüm kelime karakterleri ile yıldız işaretleriyle yer değiştirir.

Perl 5 , 24 bayt

23 bayt kodu + -pbayrak.

Martin Ender'in regex'ini Retina cevabından kullandım (Perl'de daha kısa olacaktı \pl) ve sadece s /// 'nin sağ tarafını uyarlamak zorunda kaldım.

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

Çevrimiçi deneyin!

Retina , 32 31 bayt

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

Çevrimiçi deneyin! Açıklama: Dizgiyi kelimenin rexve diğer her şeyin oluşumuna böler ancak eşleşmeleri tutar. Sonra, başlamayan satırlarda rex(yani "başka her şey"), harfleri *s olarak değiştirin . Sonunda, her şeyi bir araya getirin.

C, 99 97 92 86 74 73 72 65 bayt

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

Pelles IDE ortamı strnicmp fonksiyonunu (derleme / Go ile derleme) sağlar. Bu işlev strncasecmp ile aynıdır. Burada çalıştığını görün (değiştirme fonksiyonu ile).

Çıkış, bir giriş / çıkış parametresi olan ilk parametrede saklanır.

Özyinelemenin biraz daha kısa olduğunu bana bildirdiği için Johan du Toit'e teşekkür ederim.

Ruby, 36 35 32 bayt

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

Bir test olarak:

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

Çıktıları:

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 Bayt

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

Çevrimiçi deneyin!

PHP, 84 Bayt

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

-1 Bayt \wyerine \plbu durumda alt çizgi ve sayılar da değiştirilir

\pLgibi daha kısa [a-z]ya da[[:alpha:]]

Çevrimiçi deneyin!

C (POSIX’de GCC), 167 118 93 87 bayt

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

Çevrimiçi deneyin!

Python 2 veya 3, 75 73 70 bayt

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

Temelde Ruby'nin cevabı gibi .

@Wondercricket sayesinde -2 bayt.

Bir test olarak:

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 bayt

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 sayesinde -28 bayt.

Açıklama:

Çevrimiçi deneyin.

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 Bayt

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

Sanırım kısaltılabilir mi? :)

sed , 37 33 bayt

-R bayrağı için 36 bayt kaynak kodu + 1 bayt.

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

Çevrimiçi deneyin!

Gema, 25 karakter

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

Örnek çalışma:

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

Olabilir \CRex=$0;<L1>=\*ama maalesef $0eşleşmeyi değil, şablonu içeren acı verici bir gerçek . ☹

Retina , 54 50 49 bayt

@MartinEnder sayesinde 5 bayt golf oynadı

Retina , 49 bayt

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

Çevrimiçi deneyin!

PowerShell, 60 bayt

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

Çevrimiçi deneyin

QuadR , 11 10 + 1 = 11 bayt

iBayrak için +1 bayt .

rex
\w
&
*

Çevrimiçi deneyin!

Açıklama: Harf büyüklüğüne duyarsızca değiştir rexve sözcük karakterlerini sırasıyla kendisiyle ve yıldızlarla değiştir.

MATL , 24 bayt

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

Giriş, tek tırnak içine alınmış bir dizedir.

Çevrimiçi deneyin!

açıklama

Girişi düşünün '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 bayt

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

Çevrimiçi deneyin!

Perl, 31 bayt

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

-nSeçeneği ile perl çağırın . Örneğin:

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

Bash , 128 bayt

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*

Çevrimiçi deneyin!

Önceki cevabımda tr yapıyorum, fonksiyonel olmayan bash dizge stringini değiştirip preg yerine!

Daha az golf oynadı:

    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 *

Genişleme nedeniyle * yerine z kullanmalıydık

Java 7, 96 98 97 96 bayt

Kayıp e'ler için +2 bayt r veya onu izleyen x, her ikisi de değil

Değiştirme -1 bayt [a-z&&[^rex]]için(?![rex])\\w

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

Çevrimiçi deneyin!

Java kullanarak değiştirmek için bir regex sürümü

Bu regex'teki herşeyi bir * ile değiştirir (Java \ w 'da not \ \ w olarak çıkarılmalıdır)

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

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

İnanıyorum ki uzun ad alanı nedeniyle burada ilk defa bir C # cevabında regex kullandım System.Text.RegularExpressions.

Cevabımı yazdığımda fark etmedim ama bu @ Shaggy'nin JavaScript cevabının C # sürümü gibi görünüyor .

CJam , 39 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

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

Ve işte neredeyse işe yarayan ilginç bir ikame:

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

Bunu dizede tekrar tekrar çalıştırdığınızı hayal edin Rex, dex, I told you not to do this! You're making me angry Rex!İlk satırdan sonra, dize Rex, *ex, * **** *** *** ** ** ****! ***'*e ****** *e ***** Rex!“İkinci geçişte sonuçlanacak Rex, **x, * **** *** *** ** ** ****! ***'** ****** ** ***** Rex!ve üçüncü geçişte bitecek. Daha sonraki geçişler dizeyi değiştirmez. Bununla birlikte, örneğin dizgide, oraya 3'den fazla ikame gelmesi gerekebilir xxxxxxxx. Bu nedenle, yukarıdaki değişimleri bir şeyleri değiştirmeyi bırakana kadar ya da girişin uzunluğu kadar defalarca yapmanın kolay bir yolu olsaydı, bu başka bir çözüm olurdu. İddiaya girerim V'de yapılabilir, ancak yine de 34 bayttan daha uzun olurdu.

Jöle , 23 bayt

Davayla ilgili soruma 24 saat içinde cevap yok , bu yüzden bu geçici 23 baytı göndereceğim.

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

Çevrimiçi deneme bölümündeki test senaryolarına bakın !

Nasıl?

“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 bayt (büyük harf çıkışı) / 36 bayt (büyük harf koruyarak)

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

Çevrimiçi deneyin!

Harf durumunun korunması gerekiyorsa (çünkü hala biraz belirsizdir ), bu 10 ekstra bayt ile gerçekleştirilebilir:

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

Çevrimiçi deneyin!

Bu arada, bu cevabı yazarken, CJam'da bir tasarım hatası olarak ne düşüneceğimi öğrendim: bitsel operatörler &ve |iki karakter değeri arasında tanımlanmadı, bu yüzden iki karakterin .|bit yönünde VEYA almak için kullanamıyorum . Bana iki ekstra bayta mal olan çözüm, ilk olarak dizelerden birini :ibir tamsayı dizisine dönüştürmek, sonra da diğer dizge ile ORed olabilir. (Aslında bana üç bayta mal oldu , çünkü &iki karakter arasında çalışmış olsaydım , harf durumu bilgisini kaydetmek Sf&yerine de 32f&kullanabilirdim.)

Olumlu tarafı, {...}f%gerçekten bir dizi dizedeki karakterleri yineleme için beklendiği gibi çalıştığını keşfettim . Güzel.

Her neyse, işte 36 baytlık kodun (hafifçe) yorumlanmış bir sürümü:

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

Vaka tasarrufu hilesi, ASCII harflerinin durumu yalnızca ASCII kodunun beşinci bitiyle belirlendiği için işe yarar: bu bit, büyük harf için 0, küçük harf için 1'dir. Böylece, 32 = 2 ⁵ ile karakter kodunun bit yönünde AND değerini almak büyük / küçük harf biti çıkarır ve büyük harfle bu bitin ORE ile değiştirilmesi orijinal hallerini geri yükler.

Tabii ki, alfabetik olmayan karakterler, beşinci bit için rasgele değerlere sahip olabilir (ASCII karakterlerinin düzenlenme biçimleri nedeniyle, çoğu noktalama karakteri beşinci bit'e 1 olarak ayarlanmış olmasına rağmen), ancak bu önemli değil çünkü Zaten üst kademe ve harf sansürleme döngüsüne dokunulmamışsa da, bir karakterin kendi beşinci bitine sahip olması OR değiştirmez. Ayrıca, elverişli olarak, *karakter zaten beşinci bit setine sahiptir, dolayısıyla final tarafından değiştirilmeden bırakılmıştır .|.

Pip , 21 19 bayt

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

Stdin'den girdi alır, stdout'a çıktı verir. Çevrimiçi deneyin!

açıklama

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 bayt

Her iki cevabı da bırakıyorum çünkü eşit derecede ilginç olduklarını düşünüyorum.

27 bayt

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

Çevrimiçi deneyin!

Brian McCutchon’a bunu V’de yapma fikri için teşekkürler.

HexDump:

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

Açıklama:

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

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

24 bayt

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

Çevrimiçi deneyin!

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