Meu cachorro se chama Rex. Toda vez que o repreendo, ele não parece muito impressionado e as únicas vezes em que o vejo reagir é quando pronuncio seu nome. Se eu disser

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

tudo o que ele ouve é

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

O desafio : dada uma sequência de entrada, seu programa deve produzir a mesma sequência em que todos os caracteres alfabéticos foram transformados em estrelas, exceto os caracteres nas aparências da palavra Rex, que devem ser deixados intocados. Os caracteres não alfabéticos também são deixados intocados.

Detalhes : o desafio não diferencia maiúsculas de minúsculas, portanto, também rexdeve ser deixado intocado. A palavra Rexpode fazer parte de outra palavra, portanto, por exemplo, anorexicdeve ser renderizada como ***rex**.

Atualização : como o texto inicial desse desafio não esclareceu como os caracteres sublinhados, os números ou os caracteres acentuados devem ser tratados, não faço nenhum requisito especial para esses caracteres. Portanto, uma solução é válida desde que os caracteres a-zA-Z(e também os mencionados nos exemplos ,!".) sejam manipulados corretamente.

Casos de teste :

Entrada : Rex lives in Rexland.

Resultado : Rex ***** ** Rex****.

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

Resultado : ** **** Rex, **** *** "Rex".

Entrada : My cat is getting anorexic.

Resultado : ** *** ** ******* ***rex**.

Retina , 24 21 bytes

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

Experimente online!

Explicação

Ignorar rexs é mais fácil combinando-os também, porque as correspondências não podem se sobrepor. Portanto, se priorizarmos rexoutras letras, elas serão cobertas em uma única correspondência e não serão tocadas pelas correspondências de letras individuais.

Mas como fazemos coisas diferentes, dependendo da alternativa usada na partida? Infelizmente, a Retina ainda não possui nenhuma sintaxe de substituição condicional, como o sabor da expressão regular Boost. Mas podemos falsificá-lo incluindo ambas as substituições em uma única substituição e certificando-se de que apenas uma delas esteja vazia:

• $1é o primeiro grupo de captura, ou seja, o (rex). Se correspondermos a rexisso, basta gravá-lo de volta (para que não faça nada), mas se não correspondermos rex, $1será uma string vazia e desaparecerá.
• $#2$**deve ser lido como ($#2)$*(*). $#2é o número de vezes que o grupo 2foi usado, ou seja, o (\w). Se correspondermos a rexisso 0, mas se correspondermos a qualquer outra letra individual, será 1. $*repete o próximo caractere tantas vezes quanto o operando esquerdo. Portanto, esta parte insere um único *para correspondências de letras individuais e nada para rex.

** REXX 151 148 141 bytes **

(Parecia meio apropriado)

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

Experimente aqui

Notas para não-REXXers:

1. translate é uma função de substituição de caractere (o nome vem de uma instrução assembler no IBM MF). Ele procura string1 pelos caracteres da string3. Toda vez que encontra um, o substitui pelo mesmo posicionado na string2. Se a string2 for muito curta, ela será preenchida com o caractere de preenchimento.

Veja aqui a função de tradução

2. a sobreposição simplesmente sobrepõe a string1 na parte superior da string2 na posição especificada.

Veja aqui a função de sobreposição

JavaScript (ES6), 42 41 38 bytes

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

Tente

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>

Explicaçã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) , ^{SBCS de} 22 bytes

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

Experimente online!

Simples PCRE R moran Jr..

⍠1define insensibilidade ao caso. Simplesmente substitui rexpor ele mesmo e todos os outros caracteres de palavra por asteriscos.

Perl 5 , 24 bytes

23 bytes de código + -psinalizador.

Eu usei o regex de Martin Ender a partir de sua resposta Retina (que por acaso é mais curta em Perl, graças a \pl), e só precisei adaptar o lado direito do s ///.

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

Experimente online!

Retina , 32 31 bytes

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

Experimente online! Explicação: Divide a sequência em ocorrências da palavra rexe tudo mais, mas mantém as correspondências. Então, nas linhas que não começam rex(ou seja, "tudo o resto"), mude as letras para *s. Finalmente, junte tudo novamente.

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

O ambiente IDE Pelles fornece (compila com / Go) a função strnicmp. Esta função é idêntica ao strncasecmp. Veja como funciona aqui (com a função de substituição).

A saída é armazenada no primeiro parâmetro, que é um parâmetro de entrada / saída.

Agradeço a Johan du Toit por me informar que a recursão é um pouco menor.

Ruby, 36 35 32 bytes

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

Como teste:

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

Emite:

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

Experimente online!

PHP, 84 bytes

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

-1 Byte \wvez \plneste caso sublinhado e os números são substituídos demasiado

\pLé mais curto como [a-z]ou[[:alpha:]]

Experimente online!

C (GCC no 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);}

Experimente online!

Python 2 ou 3, 75 73 70 bytes

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

Basicamente, o mesmo que a resposta do meu Ruby .

-2 bytes graças a @Wondercricket.

Como teste:

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 graças a @ OlivierGrégoire.

Explicação:

Experimente online.

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

Eu acho que isso pode ser reduzido? :)

sed , 37 33 bytes

Código de origem de 36 bytes + 1 byte para o sinalizador -r.

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

Experimente online!

Gema, 25 caracteres

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

Exemplo de execução:

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

Doloroso fato que poderia ser \CRex=$0;<L1>=\*, mas infelizmente $0contém o modelo, não a correspondência. ☹

Retina , 54 50 49 bytes

Golfed 5 bytes graças a @MartinEnder

Retina , 49 bytes

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

Experimente online!

PowerShell, 60 bytes

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

Experimente online

QuadR , 11 10 + 1 = 11 bytes

+1 byte para o isinalizador.

rex
\w
&
*

Experimente online!

Explicação: Substitua maiúsculas de minúsculas por maiúsculas rexe minúsculas por caracteres próprios e asteriscos, respectivamente.

MATL , 24 bytes

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

A entrada é uma cadeia de caracteres entre aspas simples.

Experimente online!

Explicação

Considere entrada '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:]))

Experimente online!

Perl, 31 bytes

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

Invoque perl com a -nopção Por exemplo:

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*

Experimente online!

Estou aderindo ao tr na minha resposta anterior, substituir a string do array bash não funcional e não substituir o preg!

Menos golfe:

    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 *

Tinha que usar z em vez de * por causa da expansão

Java 7, 96 98 97 96 bytes

+2 bytes para e ausentes, precedidos por r ou seguidos de x, mas não ambos

-1 byte para mudar [a-z&&[^rex]]para(?![rex])\\w

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

Experimente online!

Uma versão regex para substituir usando Java

Substitui tudo neste regex por um * (observe em Java \ w deve ser escapado como \\ 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 bytes

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

Acredite que esta é a primeira vez que usei uma regex em uma resposta C # aqui por causa do longo espaço para nome System.Text.RegularExpressions.

Não percebi quando escrevi minha resposta, mas esta parece ser a versão C # da resposta JavaScript de @ Shaggy .

CJam , 39 bytes

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

Experimente online!

Como funciona

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

E aqui está uma substituição interessante que quase funciona:

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

Imagine executar isso repetidamente na string. Rex, dex, I told you not to do this! You're making me angry Rex!Após a primeira linha, a string é Rex, *ex, * **** *** *** ** ** ****! ***'*e ****** *e ***** Rex!A segunda passagem resultará Rex, **x, * **** *** *** ** ** ****! ***'** ****** ** ***** Rex!e a terceira passagem terminará. Quaisquer passes subsequentes não mudarão a sequência. No entanto, pode levar mais de três substituições para chegar lá, por exemplo, na string xxxxxxxx. Portanto, se houvesse uma maneira fácil de executar a substituição acima até que ela parasse de mudar as coisas, ou quantas vezes o comprimento da entrada, essa seria outra solução. Aposto que isso poderia ser feito em V, mas provavelmente ainda teria mais de 34 bytes.

Gelatina , 23 bytes

Nenhuma resposta em mais de 24 horas à minha pergunta sobre o caso , por isso vou postar este artigo de 23 bytes.

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

Veja os casos de teste em Experimente online!

Quão?

“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 (saída em maiúsculas) / 36 bytes (preservação de maiúsculas e minúsculas)

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

Experimente online!

Se for necessário preservar maiúsculas e minúsculas (já que isso ainda é um pouco incerto ), isso pode ser feito com 10 bytes extras:

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

Experimente online!

A propósito, ao escrever esta resposta, descobri o que consideraria um bug de design no CJam: os operadores bit a bit &e |não são definidos entre dois valores de caracteres, portanto, não posso usar .|o OR bit a bit de duas strings. A solução, que acabou me custando dois bytes extras, é primeiro converter uma das strings :iem uma matriz de números inteiros, que podem ser ORed com a outra string. (Na verdade, isso me custou três bytes, porque, se &funcionasse entre dois caracteres, eu também poderia ter usado em Sf&vez de 32f&salvar as informações da caixa da carta.)

No lado positivo, descobri que {...}f%realmente funciona como esperado para iterar sobre os caracteres em uma série de strings. Agradável.

De qualquer forma, aqui está uma versão (levemente) comentada do código de 36 bytes:

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

O truque para salvar maiúsculas e minúsculas funciona porque o caso das letras ASCII é determinado exclusivamente pelo quinto bit do código ASCII: esse bit é 0 para letras maiúsculas e 1 para letras minúsculas. Assim, pegar o AND bit a bit do código de caractere com 32 = 2 ⁵ extrai o bit case e OR bit a bit esse bit com as letras maiúsculas restaura o caso original.

Obviamente, caracteres não alfabéticos podem ter valores arbitrários para o quinto bit (embora, devido à organização dos caracteres ASCII, a maioria dos caracteres de pontuação tenha o quinto bit definido como 1), mas isso não importa, pois esses caracteres são deixados intocado por letras maiúsculas e loop de censura de letras de qualquer maneira, e ORing um caractere com seu próprio quinto bit não o altera. Além disso, convenientemente, o *personagem já possui o quinto bit definido, por isso também é deixado inalterado pela final .|.

Pip , 21 19 bytes

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

Pega a entrada de stdin, produz para stdout. Experimente online!

Explicação

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

Estou deixando as duas respostas, porque acho que são igualmente interessantes.

27 bytes

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

Experimente online!

Agradecemos a Brian McCutchon por sua idéia de fazer isso em V

Hexdump:

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

Explicação:

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

Experimente 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