Ce que mon chien entend vraiment

83

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

Ewan Delanoy
la source
27
Cas de test: Hello! Isn't this ... a nice challenge?pouvez-vous entendre votre chien *****! ***'* *** ... * **** *********?? Si oui, vous pourriez envisager de communiquer en morse à partir de maintenant ...
Stewie Griffin
2
Avons-nous seulement besoin de soutien a-zA-Z, ou aussi 0-9et / ou äëïöüÿãõñáéíóúýàèìòùçetc. etc.? Et pourriez-vous ajouter quelques cas de test à ce sujet?
Kevin Cruijssen
2
@KevinCruijssen Puisque $ 0-9 $ ou les caractères accentués ne sont pas mentionnés dans le défi initial, ne les considérez pas comme faisant partie du défi.
Ewan Delanoy
7
Puisque "les chiens n'obtiennent pas la différence entre les minuscules et les majuscules" , le cas de sortie peut-il être différent de l'entrée? (Par exemple: input = "Rex lives in Rexland.", output = "rex ***** ** rex****."; ou alternativement input = "My cat is getting anorexic.", output = "** *** ** ******* ***Rex**.")
Jonathan Allan
5
Pourquoi ce défi a-t-il utilisé des astérisques au lieu de "bla" ???
hBy2Py

Réponses:

25

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.
Martin Ender
la source
La rétine n'a-t-elle pas \apour [a-z]zB?
Leaky Nun
@ LeakyNun no. Je devrais utiliser la regex (ou même implémenter ma propre saveur) pour ajouter des fonctionnalités à la saveur regex elle-même.
Martin Ender
163

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

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

le blitz
la source
52
... mais le chien a pensé qu'il l'avait programmé dans REX *.
GuitarPicker
10
Combien de ces votes sont purement pour le choix de la langue?! : D
Shaggy
72
@Shaggy Au moins tous
TheLethalCoder
24

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 "*".
Hirsute
la source
1
belle solution !.
Steve Bennett
13

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.

Adam
la source
\winclut le caractère de soulignement, en supposant qu'il s'agisse de RegEx - je ne connais pas APL.
Shaggy
@Shaggy Ouais, Dyalog APL utilise PCRE, mais il n’est pas certain que les soulignements se produisent sous OP. Par exemple, les chiffres ne le seront pas.
Adám
Ne devons-nous pas supposer qu'elles peuvent se produire, sauf indication contraire?
Shaggy
@Shaggy Normalement, oui, mais cela semble indiquer que ce qui n'est pas mentionné ne se produira pas. OP ne mentionne que les virgules, les points, les espaces et les points d'exclamation.
Adám
Hmm ... Je pense que j'attendrai la confirmation qu'ils ne se produiront pas , vu que j'ai laissé ce commentaire à propos \wde quelques réponses maintenant!
Shaggy
11

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!

Dada
la source
8

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.

Neil
la source
3
C'est au moins la deuxième fois que je pense que le mode de translittération pourrait utiliser une option pour translittérer les non-correspondances ...
Martin Ender
@MartinEnder trop tard :-D
John Dvorak
8

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.

2501
la source
Il existe un environnement C qui fournit strncmpi afin que vous puissiez l’obtenir en 69. Je l’ai sur CD.
Josué
1
@ Josué Merci. Qu'est-ce qu'un CD?
2501
Borland C ++ 4.5
Joshua
7

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

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!

Jörg Hülsermann
la source
Vous pouvez utiliser \wau lieu de \pL.
Adám
@ Adám merci, mon approche plus longue ne fait que 1 octet de moins et pas vraiment plus claire ce qui devrait être fait en cas de trait de soulignement ou de chiffre
Jörg Hülsermann
L'entrée n'aura jamais de caractère de soulignement ni de chiffre ..
mercredi
@ Adám j'ai fait un point supplémentaire pour cela et ai édité l'approche plus longue pourquoi j'ai trouvé une autre amélioration
Jörg Hülsermann
5

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!

Betseg
la source
f(char*s){for(;*s;s++)strncasecmp("Rex",s,3)?putchar(isalpha(*s)?42:*s):write(1,s-2,3,s+=2);}. Quel genre de sorcellerie est f(s)char*s;{}? Je n'ai jamais vu cette syntaxe auparavant.
Christoph
Oh, il y avait un autre paramètre mais j’ai oublié de le supprimer.
mardi
Ne fonctionne pas correctement, car seul le premier appel à la fonction fonctionne. Voir ici: tio.run/nexus/… Les solutions sous forme de fonction, comme celle-ci, doivent pouvoir être rappelées et produire des résultats corrects.
2501
@ 2501 merci, corrigé.
mardi
5

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)
Eric Duminil
la source
1
Vous pourriez économiser 2 octets en supprimant l'espacement entrex.group(1) or '*'
Wondercricket
@Wondercricket: Merci beaucoup, c'est ma première réponse au golf en Python.
Eric Duminil
5

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
Kevin Cruijssen
la source
@Shaggy devrait être corrigé maintenant. Cela a été posté avant qu'il soit spécifié dans les commentaires que 0-9les caractères accentués ne devraient pas être inclus, seulement a-zA-Zdevraient.
Kevin Cruijssen
Pourriez-vous remplacer "[a-zA-z]"par /[a-z]/i?
Shaggy
@Shaggy Oui / non. Java utilise une syntaxe regex légèrement différente de celle de python ou de c # par exemple. Donc, oui, il est possible d'utiliser une expression rationnelle insensible à la casse, mais ce sera un octet de plus: "[a-zA-Z]"-> "(?i)[a-z]".
Kevin Cruijssen
1
Je pense que vous devriez utiliser s.regionMatches(0<1,i,"rex",0,3)au lieu de s.toLowerCase().substring(i,i+(i>l-3?1:3)).equals("rex").
Olivier Grégoire
1
@KevinCruijssen Prenez le code actuel que vous avez (à 168 octets), supprimez la variable let enregistrez 4 octets.
Olivier Grégoire
4

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

Erbsenhirn
la source
1
Vous pouvez supprimer les espaces après les virgules entre les arguments pour 2 octets désactivés.
Mego
4

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!

Maxim Mikhaylov
la source
@Shaggy Merci pour le heads-up!
Maxim Mikhaylov
Vous utilisez utilisez à la .place de\*
Kritixi Lithos
3

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

homme au travail
la source
3

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!

Kritixi Lithos
la source
@ Emigna Je viens de me rendre compte que ma solution ne fonctionne pas dex, elle donne, *e*tandis que la vôtre donne **x.
Kritixi Lithos
Si vous regroupez les deux étapes en plaçant (après la première, ivous n'avez pas besoin de configurer la deuxième étape.
Martin Ender
Et votre première expression régulière peut être écrite comme [a-z-[rex]].
Martin Ender
@MartinEnder Merci, c'est la première fois que je vois des classes de caractères dans lesquelles vous pouvez en exclure certains
Kritixi Lithos
ils existent sous plusieurs versions, mais je pense que la syntaxe .NET est unique.
Martin Ender
3

PowerShell, 60 octets

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

Essayez-le en ligne

Andrei Odegov
la source
Ma faute. Je remplace \wà \p{L}.
Andrei Odegov
Idée intéressante. Notez que l'utilisation en $argstant que tableau a des conséquences lorsque des choses sont citées, comme dans un exemple. Et si vous n’utilisez que le premier argument de toute façon, vous n’avez pas besoin de foreach.
Joey
@AndreiOdegov Vous pouvez revenir à \w. Note latérale: les accolades sont-elles \p{L}vraiment nécessaires?
Adám
1
très agréable Regex, "$args"-replace'(rex)|\p{L}','$1*'-replace'(x)\*','$1'est globalement beaucoup plus court, le fait $argsde mettre des guillemets en fait un tout en une seule chaîne et vous épargne beaucoup.
Colsw
@ Adám Les accolades dans .NET sont obligatoires.
Andrei Odegov
3

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.

Adam
la source
2

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

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!

ovs
la source
2

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".
gogator
la source
[a-z]peut maintenant être remplacé par \wcar l'entrée ne contiendra jamais de chiffres ni de soulignés.
Shaggy
Vous pouvez utiliser à la -pplace de -net supprimer;print
wastl
2

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

marcosme
la source
2
semble pas le bon outil: P
marcosm
1
Vous pouvez enregistrer quelques caractères en ne citant pas trles paramètres quand ils ne contiennent rien d’extensible.
manatwork
En ce qui concerne votre autre réponse bash: n'hésitez pas à résoudre le problème, puis indiquez que l'attention du mod exige une annulation de rappel.
Rɪᴋᴇʀ
1
En regardant à nouveau, il y a beaucoup de rexes pour une r=REXrexvariable.
manatwork
Si vous gardez $ r de chaîne entre guillemets, vous pas besoin de changer les environs 'de ", donc pas besoin d'échapper au littéral ". Bien sûr, vous écrivez un retour ligne en brisant la ligne à cet endroit au lieu de \n: $r'",. !␤'.
manatwork
2

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
PunPun1000
la source
2

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 .

TheLethalCoder
la source
1
Merci pour la mention, même si vous avez trouvé votre réponse indépendamment de la mienne.
Shaggy
@Shaggy Ah, merci, je ne savais pas qu'il avait été mis à jour
TheLethalCoder
1

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.
Chat d'affaires
la source
1

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.

Brian McCutchon
la source
Merci pour l'idée! Voici une réponse V . :)
DJMcMayhem
1

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")
Jonathan Allan
la source
Je ne suis pas sûr que cela soit valide. Cela ne correspond pas aux cas de test.
Okx
Voir ma note tout en haut et ma question à OP.
Jonathan Allan
(Bien que, malheureusement, le commentaire que j'ai lié à l'endroit où le PO a déclaré que "les chiens ne comprennent pas la différence entre les minuscules et les majuscules" a maintenant disparu)
Jonathan Allan
1

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

Ilmari Karonen
la source
1

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
DLosc
la source
1

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
DJMcMayhem
la source