Mon chien s'appelle Rex. À chaque fois que je le gronde, il ne semble pas très impressionné et la seule fois où je le vois réagir, c'est quand je prononce son nom. Si je dis

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

tout ce qu'il entend c'est

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

Le défi : étant donné une chaîne de saisie, votre programme doit générer la même chaîne où tous les caractères alphabétiques ont été convertis en étoiles, à l'exception des caractères apparaissant dans le mot Rex, qui ne doivent pas être modifiés. Les caractères non alphabétiques sont également laissés inchangés.

Détails : Le défi est insensible à la casse et rexdoit donc être laissé inchangé. Le mot Rexpeut faire partie d'un autre mot. Par exemple, il anorexicdoit être rendu sous la forme ***rex**.

Mise à jour : comme le texte initial de ce défi ne précisait pas comment les traits de soulignement, les chiffres ou les caractères accentués devaient être traités, je ne pose aucune exigence particulière à ces caractères. Ainsi, une solution est valable tant que les caractères a-zA-Z(ainsi que celui mentionné dans les exemples ,!".) sont gérés correctement.

Cas de test:

Contribution : Rex lives in Rexland.

Sortie: Rex ***** ** Rex****.

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

Sortie: ** **** Rex, **** *** "Rex".

Contribution : My cat is getting anorexic.

Sortie: ** *** ** ******* ***rex**.

Retina , 24 21 octets

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

Essayez-le en ligne!

Explication

Sauter rexs est plus facile en les associant également, car les correspondances ne peuvent pas se chevaucher. Donc, si nous accordons la priorité aux rexautres lettres, celles-ci seront couvertes en une seule correspondance et ne seront pas touchées par les correspondances individuelles.

Mais comment pouvons-nous faire différentes choses en fonction de l'alternative utilisée pour le match? Malheureusement, Retina n’a pas (encore) de syntaxe de substitution conditionnelle comme la saveur Boost regex. Mais nous pouvons le simuler en incluant les deux substitutions dans un seul remplaçant et en veillant à ce qu'un seul d'entre eux soit non vide:

• $1est le premier groupe de capture, c’est-à-dire le (rex). Si nous avons fait correspondre rexceci, nous le réécrirons simplement (de sorte que cela ne fera rien), mais si nous ne faisons pas correspondre, rexalors $1une chaîne vide et disparaîtra.
• $#2$**devrait être lu comme ($#2)$*(*). $#2est le nombre de fois où le groupe a 2été utilisé, c’est-à-dire le (\w). Si nous avons apparié rexceci est 0, mais si nous avons apparié toute autre lettre individuelle, ceci est 1. $*répète le caractère suivant autant de fois que son opérande de gauche. Donc, cette partie insère un simple *pour les correspondances de lettre individuelle et rien du tout pour rex.

** REXX 151 148 141 octets **

(Kinda semblait approprié)

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

Essayez ici

Remarques pour les non-REXXers:

1. translate est une fonction de remplacement de caractère (le nom provient d'une instruction d'assembleur sur IBM MF). Il recherche dans chaîne1 les caractères de chaîne3. Chaque fois qu'il en trouve un, il le remplace par le même emplacement dans string2. Si la chaîne 2 est trop courte, elle est complétée par le caractère pad.

Voir ici pour la fonction de traduction

2. superposer recouvre simplement la chaîne 1 au-dessus de la chaîne 2 à la position spécifiée.

Voir ici pour la fonction de superposition

JavaScript (ES6), 42 41 38 octets

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

L'essayer

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>

Explication

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 22 octets

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

Essayez-le en ligne!

Simple PCRE R eplace.

⍠1définit l'insensibilité à la casse. Remplace simplement rexpar lui-même et tous les autres caractères du mot avec des astérisques.

Perl 5 , 24 octets

23 octets de code + -pdrapeau.

J'ai utilisé l'expression régulière de Martin Ender de sa réponse Retina (qui est plus courte en Perl, grâce à \pl), et je n'ai eu qu'à adapter le côté droit du s ///.

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

Essayez-le en ligne!

Retina , 32 à 31 octets

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

Essayez-le en ligne! Explanation: Divise la chaîne en occurrences du mot rexet de tout le reste, mais conserve les correspondances. Ensuite, sur les lignes qui ne commencent pas rex(c'est-à-dire "tout le reste"), remplacez les lettres par *s. Enfin, réunissez tout.

C, 99 97 92 86 74 73 72 65 octets

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

L'environnement IDE de Pelles fournit (compile avec / Go) la fonction strnicmp. Cette fonction est identique à strncasecmp. Voir cela fonctionne ici (avec la fonction de remplacement).

La sortie est stockée dans le premier paramètre qui est un paramètre in / out.

Merci à Johan du Toit de me faire savoir que la récursion est légèrement plus courte.

Ruby, 36 35 32 octets

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

À titre de test:

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

Il produit:

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 octets

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

Essayez-le en ligne!

PHP, 84 octets

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

-1 octet à la \wplace, \pldans ce cas, le trait de soulignement et les nombres sont également remplacés

\pLest plus courte que [a-z]ou[[:alpha:]]

Essayez-le en ligne!

C (GCC sur POSIX), 167 118 93 87 octets

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

Essayez-le en ligne!

Python 2 ou 3, 75 73 70 octets

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

Fondamentalement, la même chose que la réponse de mon Ruby .

-2 octets grâce à @Wondercricket.

À titre de test:

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 octets

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 octets grâce à @ OlivierGrégoire.

Explication:

Essayez-le en ligne.

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 octets

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

Je suppose que cela peut être raccourci? :)

sed , 37 33 octets

36 octets code source + 1 octet pour l'indicateur -r.

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

Essayez-le en ligne!

Gema, 25 caractères

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

Échantillon échantillon:

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

Fait douloureux qui pourrait être \CRex=$0;<L1>=\*, mais $0contient malheureusement le modèle, pas la correspondance. ☹

Retina , 54 50 49 bytes

Golfé 5 octets grâce à @MartinEnder

Retina , 49 octets

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

Essayez-le en ligne!

PowerShell, 60 octets

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

Essayez-le en ligne

QuadR , 11 10 + 1 = 11 octets

+1 octet pour le idrapeau.

rex
\w
&
*

Essayez-le en ligne!

Explanation: Remplacer les caractères rexet les caractères sans tenir compte de la casse par eux-mêmes et par des astérisques, respectivement.

MATL , 24 octets

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

L'entrée est une chaîne entre guillemets simples.

Essayez-le en ligne!

Explication

Considérer l'entrée '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 octets

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

Essayez-le en ligne!

Perl, 31 octets

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

Invoquer perl avec -noption. Par exemple:

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

Bash , 128 octets

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*

Essayez-le en ligne!

Je m'en tiens à ma réponse précédente, chaîne de tableau de bash non fonctionnelle remplacer et pas de remplacement de preg!

Moins joué au golf:

    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 *

Doit utiliser z au lieu de * à cause de l'expansion

Java 7, 96 98 97 96 octets

+2 octets pour les e manquants précédés de r ou suivis de x mais pas les deux

-1 octet pour passer [a-z&&[^rex]]à(?![rex])\\w

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

Essayez-le en ligne!

Une version regex pour remplacer en utilisant Java

Remplace tout ce qui est dans cette regex par un * (note en Java \ w doit être échappé sous la forme \\ 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 octets

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

Croyez que c’est la première fois que j’utilise une expression rationnelle dans une réponse C # ici à cause du long espace de noms System.Text.RegularExpressions.

Je ne m'en étais pas rendu compte quand j'ai écrit ma réponse, mais cela semble être la version C # de la réponse JavaScript de @ Shaggy .

CJam , 39 octets

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

Essayez-le en ligne!

Comment ça fonctionne

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 octets

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

Et voici une substitution intéressante qui fonctionne presque:

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

Imaginez que vous exécutiez ceci de manière répétée sur la chaîne. Rex, dex, I told you not to do this! You're making me angry Rex!Après la première ligne, la chaîne est la suivante Rex, *ex, * **** *** *** ** ** ****! ***'*e ****** *e ***** Rex!: la deuxième passe aboutit Rex, **x, * **** *** *** ** ** ****! ***'** ****** ** ***** Rex!et la troisième passe la termine. Les passes suivantes ne changeront pas la chaîne. Cependant, il faut parfois plus de 3 substitutions pour y arriver, par exemple en chaîne xxxxxxxx. Ainsi, s’il existait un moyen simple d’exécuter la substitution ci-dessus jusqu’à ce qu’elle cesse de changer, ou autant de fois que la longueur de l’entrée, ce serait une autre solution. Je parie que cela pourrait être fait en V, mais ce serait toujours plus long que 34 octets.

Gelée , 23 octets

En 24 heures , je n'ai reçu aucune réponse à ma question sur l'affaire . Je vais donc poster ce 23 byter provisoire.

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

Voir les cas de test sur Essayez-le en ligne!

Comment?

“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 octets (sortie en majuscule) / 36 octets (préservant la casse)

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

Essayez-le en ligne!

Si la casse des lettres doit être préservée (étant donné que cela reste un peu flou ), vous pouvez le faire avec 10 octets supplémentaires:

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

Essayez-le en ligne!

En passant, en écrivant cette réponse, j'ai trouvé ce que je considérerais comme un bug de conception dans CJam: les opérateurs au niveau du bit &et |ne sont pas définis entre deux valeurs de caractère. Je ne peux donc pas utiliser .|le OU au niveau du bit de deux chaînes. La solution, qui a fini par me coûter deux octets supplémentaires, est d’abord de convertir l’une des chaînes avec :iun tableau d’entiers, qui peuvent ensuite être convertis en OR avec l’autre chaîne. (En fait, cela m'a coûté trois octets, car si &je travaillais entre deux caractères, j'aurais aussi pu utiliser Sf&au lieu de 32f&sauvegarder les informations de casse des lettres.)

Sur le plan positif, j’ai découvert qu’en {...}f%fait, il fonctionnait comme prévu pour effectuer une itération sur les caractères d’un tableau de chaînes. Agréable.

Quoi qu'il en soit, voici une version (légèrement) commentée du code à 36 octets:

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

L'astuce de sauvegarde de la casse fonctionne car la casse des lettres ASCII est uniquement déterminée par le cinquième bit du code ASCII: ce bit est 0 pour les lettres majuscules et 1 pour les lettres minuscules. Ainsi, prendre le bit ET du code de caractère avec 32 = 2 ⁵ extrait le bit de casse, et ORer ce bit avec les lettres en majuscule rétablit leur casse initiale.

Bien sûr, les caractères non alphabétiques peuvent avoir des valeurs arbitraires pour le cinquième bit (bien que, en raison de la manière dont les caractères ASCII sont organisés, le cinquième bit de la plupart des caractères de ponctuation soit défini sur 1), mais cela n'a pas d'importance, car ces caractères sont laissés. de toute façon insensible à la casse et à la boucle de censure des lettres, et ORer un caractère avec son cinquième bit ne le change pas. En outre, *le cinquième bit est déjà défini sur le caractère et reste donc inchangé pour le final .|.

Pip , 21 19 octets

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

Prend les entrées de stdin, les sorties sur stdout. Essayez-le en ligne!

Explication

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 octets

Je laisse les deux réponses, parce que je pense qu'elles sont tout aussi intéressantes.

27 octets

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

Essayez-le en ligne!

Merci à Brian McCutchon pour son idée de faire cela en V

Hexdump:

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

Explication:

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

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

24 octets

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

Essayez-le en ligne!

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