Мою собаку зовут Рекс. Каждый раз, когда я ругаю его, он, кажется, не очень впечатлен, и я вижу, как он реагирует, только когда я произношу его имя. Если я скажу

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

все что он слышит

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

Задача : с учетом входной строки ваша программа должна вывести ту же строку, где все буквенные символы были превращены в звезды, кроме символов в появлении слова Rex, которые должны быть оставлены нетронутыми. Неалфавитные символы также остаются нетронутыми.

Детали : Задача не зависит от регистра, поэтому также rexдолжна быть оставлена ​​нетронутой. Слово Rexможет быть частью другого слова, поэтому, например, anorexicдолжно отображаться как ***rex**.

Обновление : поскольку в первоначальном тексте этого задания не разъяснялось, как следует обращаться с подчеркиванием, цифрами или выделенными символами, я не предъявляю особых требований к этим символам. Таким образом, решение является действительным до тех пор, пока символы в a-zA-Z(а также символы, упомянутые в примерах ,!".) обрабатываются правильно.

Тестовые случаи:

Вход: Rex lives in Rexland.

Выход : Rex ***** ** Rex****.

Вход: To call Rex, just say "Rex".

Выход : ** **** Rex, **** *** "Rex".

Вход: My cat is getting anorexic.

Выход : ** *** ** ******* ***rex**.

Retina , 24 21 байт

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

Попробуйте онлайн!

объяснение

Пропускать rexs проще всего, сопоставляя их, потому что совпадения не могут перекрываться. Поэтому, если мы отдадим приоритет rexнад другими буквами, они будут охвачены в одном совпадении и не затронуты сопоставлениями из отдельных букв.

Но как мы можем делать разные вещи в зависимости от альтернативы, которая использовалась для матча? К сожалению, Retina (пока) не имеет синтаксиса условных подстановок, таких как Boost regex. Но мы можем подделать его, включив обе замены в одну замену и убедившись, что только одна из них не пуста:

• $1первая группа захвата, то есть (rex). Если мы нашли совпадение, rexэто просто записывает его обратно (так что ничего не делает), но если мы не совпали, rexтогда $1пустая строка исчезает.
• $#2$**следует читать как ($#2)$*(*). $#2это количество раз группы 2было использовано, то есть (\w). Если мы сопоставили rexэто 0, но если мы сопоставили любое другое отдельное письмо, это так 1. $*повторяет следующий символ столько раз, сколько его левый операнд. Таким образом, эта часть вставляет сингл *для индивидуально-буквенных совпадений и ничего для rex.

** REXX 151 148 141 байт **

(Kinda показался уместным)

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

Попробуй здесь

Примечания для не REXXers:

1. translate - это функция замены символов (имя происходит из инструкции на ассемблере в IBM MF). Он ищет в строке1 символы в строке3. Каждый раз, когда он находит один, он заменяет его на тот же позиционированный в string2. Если string2 слишком короткая, она дополняется символом pad.

Смотрите здесь для функции перевода

2. оверлей просто накладывает string1 поверх string2 в указанной позиции.

Смотрите здесь для наложения функции

JavaScript (ES6), 42 41 38 байт

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

Попробуй

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>

объяснение

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 байта ^SBCS

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

Попробуйте онлайн!

Простая замена PCRE R

⍠1устанавливает регистронезависимость. Просто заменяет rexсобой и всеми остальными символами слова звездочки.

Perl 5 , 24 байта

23 байта кода + -pфлаг.

Я использовал регулярное выражение Мартина Эндера из его ответа на Retina (который в Perl оказался короче, спасибо \pl), и мне нужно было только адаптировать правую сторону s ///.

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

Попробуйте онлайн!

Retina , 32 31 байт

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

Попробуйте онлайн! Объяснение: разбивает строку на вхождения слова rexи всего остального, но сохраняет совпадения. Затем в строках, которые не начинаются rex(т. Е. «Все остальное»), измените буквы на *s. Наконец, объедините все вместе.

C, 99 97 92 86 74 73 72 65 байт

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

Среда Pelles IDE предоставляет (компилировать с / Go) функцию strnicmp. Эта функция идентична strncasecmp. Посмотрите, как это работает здесь (с функцией замены).

Выход сохраняется в первом параметре, который является параметром входа / выхода.

Спасибо Johan du Toit за сообщение, что рекурсия немного короче.

Рубин, 36 35 32 байта

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

В качестве теста:

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

Это выводит:

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 байт

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

Попробуйте онлайн!

PHP, 84 байта

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

-1 байт \wвместо этого \plв этом случае подчеркивание и цифры тоже заменяются

\pLкороче как [a-z]или[[:alpha:]]

Попробуйте онлайн!

C (GCC на POSIX), 167 118 93 87 байт

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

Попробуйте онлайн!

Python 2 или 3, 75 73 70 байт

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

В основном так же, как ответ моего Руби .

-2 байта благодаря @Wondercricket.

В качестве теста:

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)

Ява 8, 187 192 168 164 159 138 байт

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 байт благодаря @ OlivierGrégoire.

Объяснение:

Попробуйте онлайн.

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 байт

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

Я думаю, что можно сократить? :)

sed , 37 33 байта

36 байт исходного кода + 1 байт для флага -r.

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

Попробуйте онлайн!

Гема, 25 знаков

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

Образец прогона:

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

Больно факт, что может быть \CRex=$0;<L1>=\*, но, к сожалению, $0содержит шаблон, а не совпадение. ☹

Сетчатка , 54 50 49 байтов

Гольф 5 байтов благодаря @MartinEnder

Сетчатка , 49 байт

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

Попробуйте онлайн!

PowerShell, 60 байт

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

Попробуйте онлайн

QuadR , 11 10 + 1 = 11 байт

+1 байт за iфлаг.

rex
\w
&
*

Попробуйте онлайн!

Пояснение: без учета регистра заменить rexи слова-символы на себя и звездочки, соответственно.

MATL , 24 байта

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

Входные данные - это строка, заключенная в одинарные кавычки.

Попробуйте онлайн!

объяснение

Рассмотрим вход '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 байта

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

Попробуйте онлайн!

Perl, 31 байт

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

Вызвать Perl с -nопцией. Например:

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

Баш , 128 байт

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*

Попробуйте онлайн!

Я придерживаюсь tr в моем предыдущем ответе: не функциональная замена массива bash, а не замена preg!

Менее гольф:

    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 *

Пришлось использовать z вместо * из-за расширения

Java 7, 96 98 97 96 байт

+2 байта для пропущенных e, предшествующих r или сопровождаемых x, но не обоими

-1 байт для перехода [a-z&&[^rex]]на(?![rex])\\w

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

Попробуйте онлайн!

Версия регулярного выражения для замены с использованием Java

Все в этом регулярном выражении заменяется на * (примечание в Java \ w должно быть экранировано как \\ 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 байт

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

Поверьте, это первый раз, когда я использовал регулярное выражение в ответе на C # из-за длинного пространства имен System.Text.RegularExpressions.

Я не осознавал этого, когда писал свой ответ, но это, похоже, версия C # ответа @ Shaggy's JavaScript .

CJam , 39 байт

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

Попробуйте онлайн!

Как это устроено

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 байта

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

И вот интересная замена, которая почти работает:

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

Представьте, что вы выполняете это несколько раз в строке. Rex, dex, I told you not to do this! You're making me angry Rex!После первой строки, строка будет Rex, *ex, * **** *** *** ** ** ****! ***'*e ****** *e ***** Rex!Второй проход закончится Rex, **x, * **** *** *** ** ** ****! ***'** ****** ** ***** Rex!, и третий проход завершит его. Любые последующие проходы не изменят строку. Однако для этого может потребоваться более 3 подстановок, например, для строки xxxxxxxx. Таким образом, если бы существовал простой способ выполнить вышеуказанную замену, пока она не перестала что-либо менять, или столько раз, сколько длина ввода, это было бы другим решением. Могу поспорить, что это может быть сделано в V, но это, вероятно, будет длиннее, чем 34 байта.

Желе , 23 байта

В течение 24 часов нет ответа на мой вопрос по делу , поэтому я опубликую эти предварительные 23 байта.

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

Смотрите тестовые примеры на сайте Try it online!

Как?

“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 байт (в верхнем регистре) / 36 байт (с учетом регистра)

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

Попробуйте онлайн!

Если необходимо сохранить регистр букв (поскольку это все еще немного неясно ), это можно сделать с помощью 10 дополнительных байтов:

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

Попробуйте онлайн!

Кстати, при написании этого ответа я обнаружил то, что я бы посчитал ошибкой проектирования в CJam: побитовые операторы &и |они не определены между двумя значениями символов, поэтому я не могу использовать .|для получения побитового ИЛИ двух строк. Решение, которое в итоге обошлось мне в два дополнительных байта, состоит в том, чтобы сначала преобразовать одну из строк :iв массив целых чисел, который затем можно ORed с другой строкой. (На самом деле это стоило мне трех байтов, потому что, если бы &работало между двумя символами, я мог бы также использовать Sf&вместо того, 32f&чтобы сохранить информацию о регистре букв.)

С другой стороны, я обнаружил, что он {...}f%действительно работает, как и ожидалось, для перебора символов в массиве строк. Приятно.

В любом случае, вот (слегка) закомментированная версия 36-байтового кода:

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

Трюк с сохранением регистра работает, потому что регистр букв ASCII определяется исключительно пятым битом кода ASCII: этот бит равен 0 для прописных букв и 1 для строчных букв. Таким образом, взятие поразрядного И для символа кода с 32 = 2 ⁵ извлекает бит регистра, а побитовое ИЛИ с использованием букв в верхнем регистре восстанавливает их первоначальный регистр.

Конечно, неалфавитные символы могут иметь произвольные значения для пятого бита (хотя из-за того, как организованы символы ASCII, большинство символов пунктуации имеют пятый бит, установленный в 1), но это не имеет значения, поскольку эти символы остаются в любом случае, не затрагивается заглавными буквами и циклом цензуры букв, и если OR для символа с его собственным пятым битом не изменит его. Кроме того, удобно, что у *персонажа уже установлен пятый бит, поэтому он также остается неизменным в финале .|.

Пип , 21 19 байт

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

Принимает ввод из stdin, выводит в stdout. Попробуйте онлайн!

объяснение

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 байта

Я оставляю оба ответа, потому что я думаю, что они одинаково интересны.

27 байт

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

Попробуйте онлайн!

Спасибо Брайану Маккатону за его идею сделать это в V

HexDump:

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

Объяснение:

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

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

24 байта

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

Попробуйте онлайн!

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