O que meu cachorro realmente ouve

83

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

Ewan Delanoy
fonte
27
Caso de teste: Hello! Isn't this ... a nice challenge?você consegue ouvir o cão *****! ***'* *** ... * **** *********?? Se assim for, você pode considerar a comunicação em morse de agora em diante ...
Stewie Griffin
2
Precisamos apenas apoiar a-zA-Z, ou também 0-9e / ou äëïöüÿãõñáéíóúýàèìòùçetc. etc.? E você poderia adicionar alguns casos de teste a esses?
Kevin Cruijssen
2
@KevinCruijssen Como os caracteres acentuados de US $ 0 a US $ 9 não são mencionados no desafio inicial, não os considere parte do desafio.
Ewan Delanoy
7
Como "cães não conseguem a diferença entre letras minúsculas e maiúsculas" , a caixa de saída pode ser diferente da entrada? (Por exemplo: = entrada "Rex lives in Rexland.", de saída = "rex ***** ** rex****."; ou, alternativamente, de entrada = "My cat is getting anorexic.", saída = "** *** ** ******* ***Rex**.")
Jonathan Allan
5
Por que esse desafio usou asteriscos em vez de "blá" ???
hBy2Py

Respostas:

25

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.
Martin Ender
fonte
A retina não tem \apara [a-z]zB?
Freira vazando
@LeakyNun no. Eu teria que tokenizar o regex (ou mesmo implementar meu próprio sabor) para adicionar quaisquer recursos ao próprio sabor do regex.
Martin Ender
163

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

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

a blitz
fonte
52
... mas o cachorro achou que ele havia programado em REX *.
GuitarPicker
10
Quantos desses upvotes são puramente para a escolha do idioma ?! : D
Shaggy
72
@Shaggy Pelo menos todos eles
TheLethalCoder
24

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 "*".
Shaggy
fonte
1
boa solução !.
Steve Bennett
13

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.

Adão
fonte
\winclui o caractere sublinhado, assumindo que seja RegEx - não conheço o APL.
Shaggy
@ Shaggy Sim, o Dyalog APL usa PCRE, mas não é certo pelo OP que sublinhados ocorrerão. Por exemplo, dígitos não.
Adám
Não precisamos assumir que eles podem ocorrer, a menos que seja dito o contrário?
Shaggy
@ Shagy Normalmente, sim, mas isso parece indicar que o que não é mencionado não ocorrerá. O OP menciona apenas vírgula, ponto, espaço e ponto de exclamação.
Adám
Hmm ... acho que vou esperar pela confirmação de que eles não ocorrerão, já que deixei esse comentário sobre \walgumas respostas agora!
Shaggy
11

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!

dada
fonte
8

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.

Neil
fonte
3
Esta é pelo menos a segunda vez que eu estou pensando modo de transliteração poderia usar uma opção de transliteração do não-jogos ...
Martin Ender
@MartinEnder tarde demais :-D
John Dvorak
8

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.

2501
fonte
Existe um ambiente C que forneceu strncmpi para que você possa obtê-lo em 69. Eu o tenho em CD.
10287 Joshua
1
@ Joshuaua Obrigado. O que é CD?
2501
Borland C ++ 4.5
Joshua
7

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."
Eric Duminil
fonte
6

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!

Jörg Hülsermann
fonte
Você pode usar em \wvez de \pL.
Adám
@ Adám Obrigado faz meu mais abordagem apenas 1 Byte mais curto e não muito mais claro o que deve fazer em caso de sublinhado ou número
Jörg Hülsermann
A entrada nunca terá sublinhados ou números.
Adám 11/11/17
@ Adão, fazer um ponto extra por isso e tem editar a abordagem mais por que eu ter encontrado uma outra melhoria
Jörg Hülsermann
5

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!

betseg
fonte
f(char*s){for(;*s;s++)strncasecmp("Rex",s,3)?putchar(isalpha(*s)?42:*s):write(1,s-2,3,s+=2);}. Que tipo de feitiçaria é f(s)char*s;{}? Eu nunca vi essa sintaxe antes.
Christoph
Ah, ele costumava ter outro parâmetro, mas eu esqueci de removê-lo.
betseg
Não funciona corretamente, porque apenas a primeira chamada para a função funciona. Veja aqui: tio.run/nexus/… Soluções em forma de função, como esta, devem poder ser chamadas novamente e produzir resultados corretos.
2501
@ 2501 obrigado, corrigido.
betseg
5

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)
Eric Duminil
fonte
1
Você poderia salvar 2 bytes, removendo o espaçamento entrex.group(1) or '*'
Wondercricket
@ Wondercricket: Muito obrigado, é a minha primeira resposta de golfe em Python.
Eric Duminil
5

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
Kevin Cruijssen
fonte
@ Shagy deve ser corrigido agora. Isso foi publicado antes de ser especificado nos comentários que 0-9caracteres acentuados não deveriam ser incluídos, apenas a-zA-Zdeveriam.
Kevin Cruijssen
Você poderia substituir "[a-zA-z]"por /[a-z]/i?
Shaggy
@Shaggy Sim / não. Java usa uma sintaxe regex um pouco diferente de python ou C #, por exemplo. Portanto, sim, é possível usar um regex que não diferencia maiúsculas de minúsculas, mas será um byte a mais: "[a-zA-Z]"-> "(?i)[a-z]".
Kevin Cruijssen
1
Eu acho que você deveria usar em s.regionMatches(0<1,i,"rex",0,3)vez de s.toLowerCase().substring(i,i+(i>l-3?1:3)).equals("rex").
Olivier Grégoire
1
@KevinCruijssen Pegue o código atual que você possui (em 168 bytes), remova a variável le salve 4 bytes.
Olivier Grégoire
4

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? :)

erbsenhirn
fonte
1
Você pode se livrar dos espaços após as vírgulas entre os argumentos com 2 bytes de desconto.
Mego
4

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!

Maxim Mikhaylov
fonte
@ Shaggy Obrigado pela atenção!
Maxim Mikhaylov
Você usa o uso em .vez de\*
Kritixi Lithos
3

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

homem a trabalhar
fonte
3

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!

Kritixi Lithos
fonte
@ Emigna Acabei de perceber que minha solução não funciona dex, dá *e*enquanto a sua dá **x.
Kritixi Lithos
Se você agrupar os dois estágios colocando (após o primeiro i, não precisará configurar o segundo estágio.
Martin Ender
E seu primeiro regex pode ser escrito como [a-z-[rex]].
Martin Ender
@MartinEnder Graças, esta é a primeira vez que eu estou vendo classes de personagens, onde pode excluir certos personagens
Kritixi Lithos
eles existem em vários tipos, mas acredito que a sintaxe do .NET para eles é única.
Martin Ender
3

PowerShell, 60 bytes

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

Experimente online

Andrei Odegov
fonte
Minha culpa. Eu troquei \wpara \p{L}.
Andrei Odegov
Idéia interessante. Observe que o uso $argscomo uma matriz tem consequências quando as coisas são citadas, como em um exemplo. E se você estiver usando apenas o primeiro argumento de qualquer maneira, não precisará do foreach.
Joey
@AndreiOdegov Você pode voltar para \w. Nota lateral: os aparelhos são \p{L}realmente necessários?
Adám
1
Regex muito bom, "$args"-replace'(rex)|\p{L}','$1*'-replace'(x)\*','$1'é muito mais curto no geral, agrupar $argsaspas transforma tudo em uma única sequência e economiza muito.
colsw
@ Adám As chaves no .NET são necessárias.
Andrei Odegov
3

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.

Adão
fonte
2

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****.'
Luis Mendo
fonte
2

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!

ovs
fonte
2

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".
gogators
fonte
[a-z]agora pode ser substituído por, \wpois a entrada nunca conterá números ou sublinhados.
Shaggy
Você pode usar -pem vez de -ne remova;print
Wastl
2

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

marcosm
fonte
2
parece que não é a ferramenta certa: P
marcosm
1
Você pode salvar alguns caracteres não citando tros parâmetros quando eles não contêm nada expansível.
manatwork
Em relação à sua outra resposta do bash: Sinta-se à vontade para corrigir e, em seguida, sinalize para atenção moderada solicitando a exclusão.
Rɪᴋᴇʀ
1
Olhando de novo, existem muitos rexes para uma r=REXrexvariável valer a pena.
Manatwork
Se você mantiver $ r fora da cadeia de caracteres citada, não precisará alterar o ambiente 'para ", portanto, não será necessário escapar do literal ". Claro, então você escrever uma nova linha literal, quebrando a linha naquele lugar, em vez de \n: $r'",. !␤'.
Manatwork
2

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
PunPun1000
fonte
2

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 .

TheLethalCoder
fonte
1
Obrigado pela menção, mesmo que você tenha encontrado sua resposta independentemente da minha.
Shaggy
@Shaggy Ah, obrigado, não sabia que tinha sido atualizado #
TheLethalCoder 11/17
1

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.
Gato de negócios
fonte
1

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.

Brian McCutchon
fonte
Obrigado pela ideia! Aqui está uma resposta V . :)
DJMcMayhem
1

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")
Jonathan Allan
fonte
Não tenho certeza se isso é válido. Não corresponde aos casos de teste.
Okx
Veja minha nota no topo e minha pergunta para OP.
Jonathan Allan
(Embora, infelizmente, o comentário que eu ligado a onde o OP disse que "os cães não obter a diferença entre maiúsculas e minúsculas" passou agora)
Jonathan Allan
1

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

Ilmari Karonen
fonte
1

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
DLosc
fonte
1

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
DJMcMayhem
fonte