Mi perro se llama Rex. Cada vez que lo regaño, no parece muy impresionado y las únicas veces que lo veo reaccionar es cuando pronuncio su nombre. Si yo digo

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

todo lo que oye es

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

El desafío : dada una cadena de entrada, su programa debe generar la misma cadena donde todos los caracteres alfabéticos se han convertido en estrellas, excepto los caracteres en las apariencias de la palabra Rex, que deben dejarse intactos. Los caracteres no alfabéticos también se dejan intactos.

Detalles : el desafío no distingue entre mayúsculas y minúsculas, por lo que también rexdebe dejarse intacto. La palabra Rexpuede ser parte de otra palabra, por lo que, por ejemplo, anorexicdebe representarse como ***rex**.

Actualización : como el texto inicial de este desafío no aclaraba cómo debían tratarse los guiones bajos o los números o los caracteres acentuados, no hago ningún requisito especial sobre esos caracteres. Por lo tanto, una solución es válida siempre que los caracteres en a-zA-Z(y también el mencionado en los ejemplos ,!".) se manejen correctamente.

Casos de prueba :

Entrada: Rex lives in Rexland.

Salida: Rex ***** ** Rex****.

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

Salida: ** **** Rex, **** *** "Rex".

Entrada: My cat is getting anorexic.

Salida: ** *** ** ******* ***rex**.

Retina , 24 21 bytes

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

Pruébalo en línea!

Explicación

Omitir rexs es más fácil al combinarlos también, porque las coincidencias no pueden solaparse. Entonces, si le damos prioridad a rexotras letras, éstas se cubrirán en una sola coincidencia y no se tocarán en las coincidencias de letras individuales.

Pero, ¿cómo hacemos diferentes cosas dependiendo de la alternativa que se utilizó para el partido? Desafortunadamente, Retina (todavía) no tiene ninguna sintaxis de sustitución condicional como el sabor Boge regex. Pero podemos fingirlo al incluir ambas sustituciones en un solo reemplazo y asegurarnos de que solo una de ellas no esté vacía:

• $1es el primer grupo de captura, es decir, el (rex). Si coincidimos con rexesto, simplemente lo vuelve a escribir (por lo que no hace nada), pero si no coincidimos, rexentonces $1hay una cadena vacía y desaparece.
• $#2$**debe leerse como ($#2)$*(*). $#2es el número de veces que 2se usó el grupo , es decir, el (\w). Si coincidimos con rexesto es 0, pero si coincidimos con cualquier otra letra individual, esto es 1. $*repite el siguiente personaje tantas veces como su operando de la izquierda. Entonces, esta parte inserta un solo *para coincidencias de letras individuales y nada en absoluto rex.

** REXX 151 148 141 bytes **

(Parecía apropiado)

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

Pruébalo aquí

Notas para no REXXers:

1. traducir es una función de reemplazo de caracteres (el nombre proviene de una instrucción de ensamblador en IBM MF). Busca en string1 los caracteres en string3. Cada vez que encuentra uno, lo reemplaza con el mismo colocado en la cadena2. Si string2 es demasiado corto, se rellena con el carácter de pad.

Ver aquí para la función de traducción

2. superposición simplemente superpone la cadena1 encima de la cadena2 en la posición especificada.

Ver aquí para la función de superposición

JavaScript (ES6), 42 41 38 bytes

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

Intentalo

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>

Explicación

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

Pruébalo en línea!

PCRE sencilla R eplace.

⍠1establece insensibilidad a mayúsculas y minúsculas. Simplemente reemplaza rexconsigo mismo y todos los demás caracteres de palabras con asteriscos.

Perl 5 , 24 bytes

23 bytes de código + -pbandera.

Utilicé la expresión regular de Martin Ender de su respuesta de Retina (que es más corta en Perl, gracias a \pl), y solo tuve que adaptar el lado derecho de s ///.

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

Pruébalo en línea!

Retina , 32 31 bytes

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

Pruébalo en línea! Explicación: Divide la cadena en ocurrencias de la palabra rexy todo lo demás, pero mantiene las coincidencias. Luego, en líneas que no comienzan rex(es decir, "todo lo demás"), cambie las letras a *s. Finalmente, une todo de nuevo.

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

El entorno IDE de Pelles proporciona (compila con / Go) la función strnicmp. Esta función es idéntica a strncasecmp. Vea cómo funciona aquí (con la función de reemplazo).

La salida se almacena en el primer parámetro, que es un parámetro de entrada / salida.

Gracias a Johan du Toit por hacerme saber que la recursividad es un poco más corta.

Ruby, 36 35 32 bytes

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

Como prueba:

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

Produce:

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

Pruébalo en línea!

PHP, 84 bytes

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

-1 Byte en su \wlugar \plen este caso subrayado y los números también se reemplazan

\pLes más corto como [a-z]o[[:alpha:]]

Pruébalo en línea!

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

Pruébalo en línea!

Python 2 o 3, 75 73 70 bytes

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

Básicamente lo mismo que la respuesta de mi Ruby .

-2 bytes gracias a @Wondercricket.

Como prueba:

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 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 gracias a @ OlivierGrégoire.

Explicación:

Pruébalo en línea.

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

¿Supongo que eso se puede acortar? :)

sed , 37 33 bytes

Código fuente de 36 bytes + 1 byte para el indicador -r.

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

Pruébalo en línea!

Gema, 25 personajes

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

Ejecución de muestra:

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

Hecho doloroso que podría ser \CRex=$0;<L1>=\*, pero desafortunadamente $0contiene la plantilla, no la coincidencia. ☹

Retina , 54 50 49 bytes

Golfed 5 bytes gracias a @MartinEnder

Retina , 49 bytes

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

Pruébalo en línea!

PowerShell, 60 bytes

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

Pruébalo en línea

QuadR , 11 10 + 1 = 11 bytes

+1 byte para la ibandera.

rex
\w
&
*

Pruébalo en línea!

Explicación: Reemplazar entre mayúsculas rexy minúsculas y caracteres de palabras consigo mismo y con asteriscos, respectivamente.

MATL , 24 bytes

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

La entrada es una cadena entre comillas simples.

Pruébalo en línea!

Explicación

Considerar 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:]))

Pruébalo en línea!

Perl, 31 bytes

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

Invocar perl con -nopción. Por ejemplo:

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*

Pruébalo en línea!

Me apego a tr en mi respuesta anterior, reemplazo de cadena de matriz bash no funcional y sin reemplazo de preg.

Menos golfizado:

    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 *

Tuve que usar z en lugar de * debido a la expansión

Java 7, 96 98 97 96 bytes

+2 bytes para los e faltantes precedidos por r o seguidos por x pero no ambos

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

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

Pruébalo en línea!

Una versión regex para reemplazar usando Java

Reemplaza todo en esta expresión regular con un * (la nota en Java \ w debe escaparse 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:"*");

Cree que esta es la primera vez que he usado una expresión regular en una respuesta de C # aquí debido al largo espacio de nombres System.Text.RegularExpressions.

No me di cuenta cuando escribí mi respuesta, pero esta parece ser la versión C # de la respuesta JavaScript de @ Shaggy .

CJam , 39 bytes

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

Pruébalo en línea!

Cómo 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

Y aquí hay una sustitución interesante que casi funciona:

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

Imagine ejecutar esto repetidamente en la cadena Rex, dex, I told you not to do this! You're making me angry Rex!Después de la primera línea, la cadena es Rex, *ex, * **** *** *** ** ** ****! ***'*e ****** *e ***** Rex!La segunda pasada dará como resultado Rex, **x, * **** *** *** ** ** ****! ***'** ****** ** ***** Rex!, y la tercera pasada la terminará. Cualquier pase posterior no cambiará la cadena. Sin embargo, podría tomar más de 3 sustituciones para llegar allí, por ejemplo, en cadena xxxxxxxx. Entonces, si hubiera una manera fácil de ejecutar la sustitución anterior hasta que dejara de cambiar las cosas, o tantas veces como la longitud de la entrada, esa sería otra solución. Apuesto a que podría hacerse en V, pero aún así probablemente sería más largo que 34 bytes.

Jalea , 23 bytes

No hubo respuesta en más de 24 horas a mi pregunta sobre el caso , así que publicaré este tentativo 23 byter.

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

Vea los casos de prueba en ¡ Pruébelo en línea!

¿Cómo?

“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 (salida en mayúscula) / 36 bytes (conservación de mayúsculas y minúsculas)

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

Pruébalo en línea!

Si se necesita preservar la letra mayúscula (ya que aún no está claro ), eso se puede lograr con 10 bytes adicionales:

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

Pruébalo en línea!

Por cierto, mientras escribía esta respuesta, encontré lo que consideraría un error de diseño en CJam: los operadores bit a bit &y |no están definidos entre dos valores de caracteres, por lo que no puedo usar .|para tomar el OR bit a bit de dos cadenas. La solución, que terminó costándome dos bytes adicionales, es convertir primero una de las cadenas :ien una matriz de enteros, que luego se pueden OR con la otra cadena. (En realidad, me costó tres bytes, porque si hubiera &funcionado entre dos caracteres, también podría haberlo usado en Sf&lugar de 32f&guardar la información de mayúsculas y minúsculas).

En el lado positivo, descubrí que de {...}f%hecho funciona como se esperaba para iterar sobre los caracteres en una serie de cadenas. Agradable.

De todos modos, aquí hay una versión (ligeramente) comentada del 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";

El truco para guardar mayúsculas y minúsculas funciona porque el caso de las letras ASCII está determinado únicamente por el quinto bit del código ASCII: este bit es 0 para mayúsculas y 1 para letras minúsculas. Por lo tanto, tomar el AND a nivel de bits del código de caracteres con 32 = 2 ⁵ extrae el bit de mayúsculas y ORing a bit este bit con las letras mayúsculas restaura su caso original.

Por supuesto, los caracteres no alfabéticos pueden tener valores arbitrarios para el quinto bit (aunque, debido a la forma en que se organizan los caracteres ASCII, la mayoría de los caracteres de puntuación tienen el quinto bit establecido en 1), pero esto no importa, ya que esos caracteres se dejan intacto por mayúsculas y el bucle de censura de letras de todos modos, y ORing un carácter con su propio quinto bit no lo cambia. Además, convenientemente, el *personaje ya tiene el quinto bit establecido, por lo que también queda sin cambios en la final .|.

Pip , 21 19 bytes

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

Toma entrada de stdin, salidas a stdout. Pruébalo en línea!

Explicación

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

Dejo ambas respuestas, porque creo que son igualmente interesantes.

27 bytes

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

Pruébalo en línea!

Gracias a Brian McCutchon por su idea de hacer esto en V

Hexdump:

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

Explicación:

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

Pruébalo en línea!

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