Il mio cane si chiama Rex. Ogni volta che lo rimprovero, non sembra molto colpito e le uniche volte in cui lo vedo reagire è quando pronuncio il suo nome. Se dico

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

tutto ciò che sente è

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

La sfida : data una stringa di input, il tuo programma deve generare la stessa stringa in cui tutti i caratteri alfabetici sono stati trasformati in stelle, tranne i caratteri nelle apparenze della parola Rex, che devono essere lasciati intatti. Anche i caratteri non alfabetici non vengono toccati.

Dettagli : la sfida non fa distinzione tra maiuscole e minuscole, quindi non rexdeve essere toccata. La parola Rexpuò far parte di un'altra parola, quindi ad esempio anorexicdeve essere resa come ***rex**.

Aggiornamento : poiché il testo iniziale di questa sfida non ha chiarito in che modo trattare i caratteri di sottolineatura o i numeri o i caratteri accentati, non ho alcun requisito speciale su questi caratteri. Pertanto, una soluzione è valida fintanto che i caratteri in a-zA-Z(e anche quello menzionato negli esempi ,!".) vengono gestiti correttamente.

Casi test :

Input: Rex lives in Rexland.

Produzione : Rex ***** ** Rex****.

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

Produzione : ** **** Rex, **** *** "Rex".

Input: My cat is getting anorexic.

Produzione : ** *** ** ******* ***rex**.

Retina , 24 21 byte

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

Provalo online!

Spiegazione

Saltare rexs è più facile abbinando anche loro, perché le partite non possono sovrapporsi. Quindi, se diamo priorità alle rexaltre lettere, queste verranno coperte in una singola corrispondenza e non toccate dalle corrispondenze delle singole lettere.

Ma come possiamo fare cose diverse a seconda dell'alternativa utilizzata per la partita? Sfortunatamente, Retina non ha (ancora) alcuna sintassi di sostituzione condizionale come il sapore regex Boost. Ma possiamo fingere includendo entrambe le sostituzioni in una singola sostituzione e assicurandoci che solo una di esse sia non vuota:

• $1è il primo gruppo di acquisizione, ovvero il (rex). Se l'abbiamo fatto corrispondere rexsemplicemente lo riscrive (quindi non fa nulla), ma se non l'abbiamo fatto, rexallora $1è una stringa vuota e svanisce.
• $#2$**dovrebbe essere letto come ($#2)$*(*). $#2è il numero di volte in cui è 2stato utilizzato il gruppo , ovvero il (\w). Se abbiamo abbinato rexquesto è 0, ma se abbiamo abbinato qualsiasi altra singola lettera, questo è 1. $*ripete il personaggio successivo tante volte quanto l'operando di sinistra. Quindi questa parte inserisce un singolo *per le corrispondenze di singole lettere e nulla per niente rex.

** REXX 151 148 141 byte **

(Kinda sembrava appropriato)

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

Provalo qui

Note per i non-REXXer:

1. translate è una funzione di sostituzione dei caratteri (il nome deriva da un'istruzione assembler su IBM MF). Cerca string1 per i caratteri in string3. Ogni volta che ne trova uno, lo sostituisce con lo stesso posizionato in string2. Se string2 è troppo corto, viene riempito con il carattere pad.

Vedi qui per la funzione di traduzione

2. overlay sovrappone semplicemente stringa1 sopra stringa2 nella posizione specificata.

Vedi qui per la funzione di sovrapposizione

JavaScript (ES6), 42 41 38 byte

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

Provalo

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>

Spiegazione

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

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

Provalo online!

Semplice PCRE R eplace.

⍠1imposta l'insensibilità al maiuscolo / minuscolo. Sostituisce semplicemente rexcon se stesso e tutti gli altri caratteri di parole con asterischi.

Perl 5 , 24 byte

23 byte di codice + -pflag.

Ho usato la regex di Martin Ender dalla sua risposta Retina (che sembra essere più breve in Perl, grazie a \pl), e ho dovuto solo adattare il lato destro della s ///.

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

Provalo online!

Retina , 32 31 byte

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

Provalo online! Spiegazione: divide la stringa in occorrenze della parola rexe di tutto il resto, ma mantiene le corrispondenze. Quindi, sulle righe che non iniziano rex(ovvero "tutto il resto"), cambia le lettere in *s. Infine, unisciti a tutto di nuovo insieme.

C, 99 97 92 86 74 73 72 65 byte

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

L'ambiente IDE di Pelles fornisce (compilare con / Go) la funzione strnicmp. Questa funzione è identica a strncasecmp. Guardalo funzionare qui (con la funzione di sostituzione).

L'output è memorizzato nel primo parametro che è un parametro in / out.

Grazie a Johan du Toit per avermi fatto sapere che la ricorsione è leggermente più breve.

Rubino, 36 35 32 byte

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

Come 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

Emette:

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 byte

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

Provalo online!

PHP, 84 byte

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

-1 In questo caso, \winvece, il byte viene \plsottolineato e anche i numeri vengono sostituiti

\pLè più breve di [a-z]o[[:alpha:]]

Provalo online!

C (GCC su POSIX), 167 118 93 87 byte

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

Provalo online!

Python 2 o 3, 75 73 70 byte

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

Praticamente uguale alla risposta di mio Ruby .

-2 byte grazie a @Wondercricket.

Come 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 byte

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

Spiegazione:

Provalo 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 byte

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

Immagino che possa essere abbreviato? :)

sed , 37 33 byte

36 byte codice sorgente + 1 byte per -r flag.

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

Provalo online!

Gema, 25 personaggi

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

Esecuzione di esempio:

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

Fatto doloroso che potrebbe essere \CRex=$0;<L1>=\*, ma purtroppo $0contiene il modello, non la corrispondenza. ☹

Retina , 54 50 49 byte

Golfato 5 byte grazie a @MartinEnder

Retina , 49 byte

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

Provalo online!

PowerShell, 60 byte

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

Provalo online

QuadR , 11 10 + 1 = 11 byte

+1 byte per la ibandiera.

rex
\w
&
*

Provalo online!

Spiegazione: Sostituire senza maiuscole rexe minuscole con se stesso e asterischi, rispettivamente.

MATL , 24 byte

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

L'input è una stringa racchiusa tra virgolette singole.

Provalo online!

Spiegazione

Considera l'input '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 byte

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

Provalo online!

Perl, 31 byte

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

Richiama perl con -nopzione. Per esempio:

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

Bash , 128 byte

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*

Provalo online!

Mi attengo a tr sulla mia risposta precedente, sostituzione della stringa di array bash non funzionale e nessuna sostituzione sost

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

Ho dovuto usare z invece di * a causa dell'espansione

Java 7, 96 98 97 96 byte

+2 byte per le e mancanti mancanti precedute da r o seguite da x ma non da entrambe

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

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

Provalo online!

Una versione regex per la sostituzione tramite Java

Sostituisce tutto in questa regex con un * (la nota in Java \ w deve essere salvata come \\ 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 byte

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

Credo che questa sia la prima volta che ho usato un regex in una risposta C # qui a causa del lungo spazio dei nomi System.Text.RegularExpressions.

Non me ne sono reso conto quando ho scritto la mia risposta, ma questa sembra essere la versione C # della risposta JavaScript di @ Shaggy .

CJam , 39 byte

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

Provalo online!

Come funziona

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 byte

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

Ed ecco una sostituzione interessante che quasi funziona:

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

Immagina di eseguirlo ripetutamente sulla stringa Rex, dex, I told you not to do this! You're making me angry Rex!Dopo la prima riga, la stringa è Rex, *ex, * **** *** *** ** ** ****! ***'*e ****** *e ***** Rex!Il secondo passaggio si tradurrà in Rex, **x, * **** *** *** ** ** ****! ***'** ****** ** ***** Rex!, e il terzo passaggio lo finirà. Eventuali passaggi successivi non modificheranno la stringa. Tuttavia, potrebbero essere necessarie più di 3 sostituzioni per arrivarci, ad esempio sulla stringa xxxxxxxx. Quindi, se ci fosse un modo semplice per eseguire la sostituzione di cui sopra fino a quando non ha smesso di cambiare le cose, o tante volte quanto la lunghezza dell'input, quella sarebbe un'altra soluzione. Scommetto che potrebbe essere fatto in V, ma probabilmente sarebbe comunque più lungo di 34 byte.

Gelatina , 23 byte

Nessuna risposta in oltre 24 ore alla mia domanda sul caso , quindi posterò questo provvisorio 23 byte.

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

Guarda i casi di test su Provalo online!

Come?

“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 byte (maiuscole) / 36 byte (maiuscole / minuscole)

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

Provalo online!

Se è necessario conservare il maiuscolo (poiché è ancora un po 'poco chiaro ), ciò può essere ottenuto con 10 byte extra:

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

Provalo online!

A proposito, mentre scrivevo questa risposta, ho trovato quello che considererei un bug di progettazione in CJam: gli operatori bit a bit &e |non sono definiti tra due valori char, quindi non posso usare .|per prendere l'OR bit a bit di due stringhe. La soluzione, che mi è costata due byte extra, è di convertire prima una delle stringhe :iin una matrice di numeri interi, che può quindi essere ORed con l'altra stringa. (In realtà mi è costato tre byte, perché se &avessi lavorato tra due caratteri, avrei potuto usare anche Sf&invece di 32f&salvare le informazioni sul caso di lettera.)

Sul lato positivo, ho scoperto che {...}f%effettivamente funziona come previsto per iterare i personaggi in una serie di stringhe. Bello.

Ad ogni modo, ecco una versione (leggermente) commentata del codice a 36 byte:

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

Il trucco per salvare le maiuscole funziona perché il caso delle lettere ASCII è determinato esclusivamente dal quinto bit del codice ASCII: questo bit è 0 per le lettere maiuscole e 1 per le lettere minuscole. Pertanto, prendendo AND bit a bit del codice carattere con 32 = 2 ⁵ estrae il bit del case e OR bit a bit questo bit con le lettere maiuscole ripristina il caso originale.

Naturalmente, i caratteri non alfabetici possono avere valori arbitrari per il quinto bit (anche se, a causa del modo in cui sono organizzati i caratteri ASCII, la maggior parte dei caratteri di punteggiatura hanno il quinto bit impostato su 1), ma questo non ha importanza, poiché quei caratteri sono lasciati non toccato dal maiuscolo e dal ciclo di censura delle lettere, e ORing un personaggio con il suo quinto bit non lo cambia. Inoltre, convenientemente, il *personaggio ha già il quinto bit impostato, quindi rimane invariato dal finale .|.

Pip , 21 19 byte

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

Prende input da stdin, output in stdout. Provalo online!

Spiegazione

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 byte

Lascio entrambe le risposte, perché penso che siano ugualmente interessanti.

27 byte

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

Provalo online!

Grazie a Brian McCutchon per la sua idea di farlo in V

hexdump:

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

Spiegazione:

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

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

24 byte

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

Provalo 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