82

मेरे कुत्ते को रेक्स कहा जाता है। हर बार जब मैं उसे डांटता हूं, तो वह बहुत प्रभावित नहीं होता है और जब मैं उसका नाम सुनता हूं, तो मैं उसे देखकर ही प्रतिक्रिया करता हूं। अगर मैं कहूं

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

code-golf string substitution

— इवान डेलानॉय
स्रोत

27

टेस्ट केस: Hello! Isn't this ... a nice challenge?क्या आप सुन सकते हैं कुत्ता *****! ***'* *** ... * **** *********?? यदि ऐसा है, तो आप अब से मोर्स में संवाद करने पर विचार कर सकते हैं ...

— स्टीवी ग्रिफिन

2

क्या हमें केवल समर्थन की आवश्यकता है a-zA-Z, या 0-9/ और / या äëïöüÿãõñáéíóúýàèìòùçआदि आदि? और क्या आप इन के बारे में कुछ परीक्षण मामलों को जोड़ सकते हैं?

— केविन क्रूज़सेन

2

@ केविनक्रूजसेन $ 0-9 $ या उच्चारण पात्रों का प्रारंभिक चुनौती में उल्लेख नहीं किया गया है, उन्हें चुनौती का हिस्सा न मानें।

— इवान डेलानॉय

7

चूंकि "कुत्तों को लोअरकेस और अपरकेस के बीच अंतर नहीं मिलता है" , क्या आउटपुट केस इनपुट में भिन्न हो सकता है? (उदाहरण के लिए: इनपुट = "Rex lives in Rexland.", आउटपुट = "rex ***** ** rex****."; या वैकल्पिक इनपुट = "My cat is getting anorexic.", आउटपुट = "** *** ** ******* ***Rex**.")

— जोनाथन एलन

5

इस चुनौती ने "ब्ला" के बजाय

— hBy2Py

24

रेटिना , 24 21 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

rexमैचों के साथ-साथ उन्हें लंघन करना सबसे आसान है, क्योंकि मैच ओवरलैप नहीं कर सकते हैं। इसलिए यदि हम rexअन्य पत्रों को प्राथमिकता देते हैं , तो उन्हें एक ही मैच में शामिल किया जाएगा और व्यक्तिगत-पत्र मैचों को नहीं छुआ जाएगा।

लेकिन हम मैच के लिए इस्तेमाल होने वाले विकल्प के आधार पर अलग-अलग चीजें कैसे करते हैं? दुर्भाग्य से, रेटिना में अभी तक बूस्ट रेगेक्स स्वाद की तरह कोई सशर्त प्रतिस्थापन सिंटैक्स नहीं है। लेकिन हम इसे एक प्रतिस्थापन में दोनों प्रतिस्थापनों को शामिल करके नकली बना सकते हैं और यह सुनिश्चित कर सकते हैं कि उनमें से केवल एक गैर-रिक्त है:

$1पहला कैप्चरिंग ग्रुप है, अर्थात (rex)। अगर हमने इसका मिलान rexकिया तो बस इसे वापस लिखते हैं (इसलिए यह कुछ नहीं करता है), लेकिन अगर हम मेल नहीं खाते हैं rexतो $1एक खाली स्ट्रिंग है और गायब हो जाता है।
$#2$**के रूप में पढ़ा जाना चाहिए ($#2)$*(*)। $#2कितनी बार समूह 2का उपयोग किया गया था, अर्थात (\w)। यदि हम इसका मिलान rexकरते हैं 0, लेकिन यदि हम किसी अन्य व्यक्तिगत पत्र से मेल खाते हैं, तो यह है 1। $*अगले चरित्र को उसके बाएं हाथ के ऑपरेंड के रूप में कई बार दोहराता है। इसलिए यह भाग *व्यक्तिगत-पत्र मैचों के लिए एकल सम्मिलित करता है और इसके लिए कुछ भी नहीं है rex।

— मार्टिन एंडर
स्रोत

रेटिना नहीं करता है \aके लिए [a-z]zB?

— लीक नून

@LeakyNun सं। मैं regex (या यहां तक कि अपने स्वयं के स्वाद को लागू) togeise tokenise होगा regex स्वाद के लिए किसी भी सुविधाओं को जोड़ने के लिए।

— मार्टिन एंडर

163

आरएक्सएक्स 151 148 141 बाइट्स

(किंडा उपयुक्त लग रहा था)

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 के लिए नोट्स:

अनुवाद एक चरित्र प्रतिस्थापन कार्य है (नाम आईबीएम एमएफ पर एक कोडांतरक निर्देश से आता है)। यह string3 में वर्णों के लिए string1 खोजता है। हर बार जब वह इसे पाता है तो इसे स्ट्रिंग 2 में उसी के साथ बदल देता है। यदि string2 बहुत छोटा है, तो यह पैड कैरेक्टर के साथ गद्देदार है।

अनुवाद कार्य के लिए यहाँ देखें

ओवरले केवल स्ट्रिंग 2 के ऊपर स्ट्रिंग 1 को निर्दिष्ट स्थान पर ओवरले करता है।

ओवरले फ़ंक्शन के लिए यहां देखें

— बम बरसाना
स्रोत

52

... लेकिन कुत्ते ने सोचा कि उसने इसे आरईएक्स * में प्रोग्राम किया है।

— गिटारपिकर

10

इनमें से कितने upvotes विशुद्ध रूप से भाषा की पसंद के लिए हैं ?! : डी

— झबरा

72

@ शैगी उन सभी में से कम से कम

— TheLethalCoder

24

जावास्क्रिप्ट (ईएस 6), 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 "*".

— झबरा
स्रोत

देखें codegolf.stackexchange.com/questions/119718/...

— एडम

1

अच्छा समाधान !.

— स्टीव बेनेट

13

एपीएल (Dyalog यूनिकोड) , 22 बाइट्स ^SBCS

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

इसे ऑनलाइन आज़माएं!

सरल पीसीआरई आर ईएमएल।

⍠1केस असंवेदनशीलता सेट करता है। बस rexअपने आप को और अन्य सभी वर्ण वर्णों के साथ बदल देता है ।

— एडम
स्रोत

\wअंडरस्कोर वर्ण शामिल है, यह मानते हुए कि यह RegEx है - मुझे एपीएल नहीं पता है।

— झबरा

@ शैगी हाँ, डायलाग एपीएल पीसीआरई का उपयोग करता है, लेकिन यह ओपी से निश्चित नहीं है कि अंडरस्कोर होगा। जैसे अंक नहीं होंगे।

— एडम

क्या हमें यह मानने की ज़रूरत नहीं है कि वे हो सकते हैं, जब तक कि अन्यथा न कहा जाए?

— झबरा

@ सामान्य रूप से, हाँ, लेकिन यह इंगित करता है कि जो उल्लेख नहीं किया गया है वह घटित नहीं होगा। ओपी केवल अल्पविराम, अवधि, स्थान और विस्मयादिबोधक बिंदु का उल्लेख करता है।

— एडम

हम्म ... मुझे लगता है कि मैं पुष्टि के लिए प्रतीक्षा करूँगा कि वे घटित नहीं होंगे , यह देखकर कि मैंने \wकुछ उत्तरों के बारे में उस टिप्पणी को छोड़ दिया है !

— झबरा

11

पर्ल 5 , 24 बाइट्स

कोड + -pध्वज के 23 बाइट्स ।

मैंने अपने रेटिना उत्तर से मार्टिन एंडर के रेगेक्स का उपयोग किया (जो पर्ल में छोटा होता है, धन्यवाद \pl), और केवल s /// के दाईं ओर को अनुकूलित करना था।

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

इसे ऑनलाइन आज़माएं!

— बापू
स्रोत

8

रेटिना , 32 31 बाइट्स

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

इसे ऑनलाइन आज़माएं! स्पष्टीकरण: स्ट्रिंग को शब्द rexऔर अन्य सभी चीजों की घटनाओं में विभाजित करता है, लेकिन मैचों को रखता है। फिर, उन पंक्तियों पर जो शुरू नहीं होती हैं rex(यानी "सब कुछ"), पत्र को *एस में बदलें । अंत में, सब कुछ वापस एक साथ जुड़ें।

— नील
स्रोत

3

यह कम से कम दूसरी बार है जब मैं सोच रहा हूं कि लिप्यंतरण मोड गैर-मैचों का अनुवाद करने के लिए एक विकल्प का उपयोग कर सकता है ...

— मार्टिन एंडर

@MartinEnder बहुत देर से :-D

— जॉन ड्वोरक

8

C, 99 97 92 86 74 74 73 72 बाइट्स

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

पेल्स आईडीई पर्यावरण फ़ंक्शन स्ट्रिइम्पैम्प के साथ (गो / संकलन) प्रदान करता है। यह फ़ंक्शन strncasecmp के समान है। इसे यहां काम करें (प्रतिस्थापन फ़ंक्शन के साथ) देखें।

आउटपुट को पहले पैरामीटर में संग्रहीत किया जाता है जो कि एक इन / आउट पैरामीटर है।

जोहान डु टिट के लिए धन्यवाद मुझे यह बताने के लिए कि पुनरावृत्ति थोड़ी कम है।

— 2501
स्रोत

वहाँ एक C वातावरण है जो strncmpi प्रदान करता है ताकि आप इसे 69 में प्राप्त कर सकें। मैंने इसे CD पर प्राप्त किया है।

— जोशुआ

1

@ जोशुआ धन्यवाद सीडी क्या है?

— 2501

बोरलैंड C ++ 4.5

— जोशुआ

7

रूबी, 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."

— एरिक डुमिनील
स्रोत

6

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:]]

इसे ऑनलाइन आज़माएं!

— जार्ग हुल्सरमैन
स्रोत

आप उपयोग कर सकते हैं \wके बजाय \pL।

— एडम

@ Adám धन्यवाद, यह मेरे लंबे दृष्टिकोण को केवल 1 बाइट को छोटा बनाता है और वास्तव में स्पष्ट नहीं है कि अंडरस्कोर या संख्या के मामले में क्या करना चाहिए

— Jörg Hülsermann

इनपुट में कोई अंडरस्कोर या संख्या नहीं होगी ..

— Adám

@ Adám मैंने इसके लिए एक अतिरिक्त बिंदु बनाया है और लंबे समय तक दृष्टिकोण को संपादित किया है कि मुझे एक और सुधार क्यों मिला है

— Jörg Hülsermann

5

C (GCC on 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);}

इसे ऑनलाइन आज़माएं!

— betseg
स्रोत

f(char*s){for(;*s;s++)strncasecmp("Rex",s,3)?putchar(isalpha(*s)?42:*s):write(1,s-2,3,s+=2);}। टोना किस प्रकार का है f(s)char*s;{}? मैंने इस सिंटैक्स को पहले कभी नहीं देखा है।

— क्रिस्टोफ

ओह, यह एक और पैरामीटर हुआ करता था लेकिन मैं इसे हटाना भूल गया।

— betseg

सही ढंग से काम नहीं करता है, क्योंकि फ़ंक्शन के लिए केवल पहला कॉल काम करता है। यहाँ देखें: tio.run/nexus/… फंक्शन फॉर्म में समाधान, जैसे कि यह एक, फिर से कॉल करने और सही परिणाम देने में सक्षम होना चाहिए।

— 2501

@ 2501 धन्यवाद, निश्चित।

— g१ '

5

पायथन 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)

— एरिक डुमिनील
स्रोत

1

आप के बीच अंतर को दूर करके 2 बाइट्स बचा सकते हैंx.group(1) or '*'

— Wondercricket

@Wondercricket: बहुत-बहुत धन्यवाद, यह पायथन में मेरा पहला गोल्फ जवाब है।

— एरिक डुमिनील

5

जावा 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

— केविन क्रूज़सेन
स्रोत

@ शगुन को अभी तय किया जाना चाहिए। इससे पहले कि यह टिप्पणी में निर्दिष्ट किया गया था कि पोस्ट किया गया था 0-9और उच्चारण पात्रों को शामिल नहीं किया a-zA-Zजाना चाहिए , केवल होना चाहिए।

— केविन क्रूज़सेन

आप के "[a-zA-z]"साथ बदल सकता है /[a-z]/i?

— शैगी

@ शग्गी हां / नहीं। जावा उदाहरण के लिए अजगर या C # की तुलना में थोड़ा अलग रेक्सक्स सिंटैक्स का उपयोग करता है। तो हां, केस-असंवेदनशील रेगेक्स का उपयोग करना संभव है, लेकिन यह एक बाइट लंबा होगा: "[a-zA-Z]"-> "(?i)[a-z]"।

— केविन क्रूज़सेन

1

मुझे लगता है कि आपको s.regionMatches(0<1,i,"rex",0,3)इसके बजाय उपयोग करना चाहिए s.toLowerCase().substring(i,i+(i>l-3?1:3)).equals("rex")।

— ओलिवियर ग्रेजायर

1

@KevinCruijssen आपके पास (168 बाइट्स पर) वर्तमान कोड लें, वेरिएबल को हटा दें lऔर 4 बाइट्स बचाएं।

— ओलिवियर ग्रेजायर

4

पायथन 2, 87 बाइट्स

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

मुझे लगता है कि छोटा किया जा सकता है? :)

— erbsenhirn
स्रोत

1

2 बाइट्स के लिए तर्कों के बीच अल्पविराम के बाद आप रिक्त स्थान से छुटकारा पा सकते हैं।

— Mego

4

सीड , 37 33 बाइट्स

36 बाइट्स सोर्सकोड + 1 बाइट -r फ्लैग के लिए।

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

इसे ऑनलाइन आज़माएं!

— मैक्सिम मिखायलोव
स्रोत

@ शैगी सिर के लिए धन्यवाद!

— मैक्सिम मिखायलोव

आप .इसके बजाय का उपयोग करें\*

— क्रिति लिथोस

3

गामा, 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से टेम्पलेट शामिल है, मैच नहीं। ☹

— आदमी काम पर है
स्रोत

3

रेटिना , 54 50 49 बाइट्स

@MartinEnder को 5 बाइट्स दिए गए

रेटिना , 49 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— क्रिक्टी लिथोस
स्रोत

@Emigna बस एहसास हुआ कि मेरे समाधान के लिए काम नहीं करता है dex, यह *e*तुम्हारा देते समय देता है **x।

— कृति लिथोस

यदि आप (पहले चरण के बाद दोनों चरणों को समूह iबनाते हैं तो आपको दूसरे चरण को कॉन्फ़िगर करने की आवश्यकता नहीं है।

— मार्टिन एंडर

और आपके पहले रेगेक्स के रूप में लिखा जा सकता है [a-z-[rex]]।

— मार्टिन एंडर

@MartinEnder धन्यवाद, यह पहली बार है जब मैं चरित्र वर्ग देख रहा हूँ जहाँ आप कुछ पात्रों को बाहर कर सकते हैं

— क्रिस्ति लिथोस

वे कई स्वादों में मौजूद हैं, लेकिन मेरा मानना है कि उनके लिए .NET का सिंटैक्स अद्वितीय है।

— मार्टिन एंडर

3

पॉवरशेल, 60 बाइट्स

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

इसे ऑनलाइन आज़माएं

— आंद्रेई ओडेगो
स्रोत

मेरी गलती। मैंने बदल \wदिया है \p{L}।

— आंद्रेई ओडेगो

दिलचस्प विचार। ध्यान दें कि $argsएक सरणी के रूप में उपयोग करने के परिणाम हैं जब चीजें उद्धृत की जाती हैं, जैसे कि एक उदाहरण में। और अगर आप केवल पहले तर्क का उपयोग कर रहे हैं, तो आपको इसकी आवश्यकता नहीं है foreach।

— जॉय

@AndreiOdegov आप वापस जा सकते हैं \w। साइड नोट: क्या ब्रेसिज़ \p{L}वास्तव में आवश्यक हैं?

— 17'14

1

बहुत अच्छा रेगेक्स, "$args"-replace'(rex)|\p{L}','$1*'-replace'(x)\*','$1'कुल मिलाकर बहुत छोटा है, $argsउद्धरणों में लपेटकर यह सब एक ही स्ट्रिंग में बदल जाता है और आपको बहुत बचाता है।

— colsw

@ विज्ञापन .NET में घुंघराले ब्रेसिज़ की आवश्यकता है।

— आंद्रेई ओडेगो

3

QuadR , 11 10 + 1 = 11 बाइट्स

iध्वज के लिए +1 बाइट ।

rex
\w
&
*

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण: केस-असंवेदनशील rexक्रमशः और स्वयं और तारांकन के साथ शब्द-वर्ण को प्रतिस्थापित करते हैं।

— एडम
स्रोत

2

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

— लुइस मेंडो
स्रोत

2

पायथन 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:]))

इसे ऑनलाइन आज़माएं!

— OVS
स्रोत

2

पर्ल, 31 बाइट्स

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

-nऑप्शन के साथ perl मंगवाएं । उदाहरण के लिए:

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

— gogators
स्रोत

[a-z]अब के साथ प्रतिस्थापित किया जा सकता है \wक्योंकि इनपुट में कभी भी नंबर या अंडरस्कोर नहीं होंगे।

— झबरा

आप उपयोग कर सकते हैं -pके बजाय -nऔर हटाने;print

— wastl

2

बैश , 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*

इसे ऑनलाइन आज़माएं!

मैं अपने पिछले उत्तर, गैर-कार्यात्मक बैश सरणी स्ट्रिंग को प्रतिस्थापित करने के लिए चिपका रहा हूँ और कोई भी प्रीग रिप्लेस नहीं कर रहा हूँ!

कम गोल्फ वाला:

    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 का उपयोग करना पड़ा

— marcosm
स्रोत

2

इसका सही उपकरण नहीं दिखता: P

— marcosm

1

trजब वे विस्तार योग्य कुछ नहीं होते हैं, तो आप मापदंडों के एक जोड़े को नहीं बचा सकते हैं ।

— मैनेटवर्क

आपके अन्य बैश उत्तर के संबंध में: ठीक करने के लिए स्वतंत्र महसूस करें, और फिर ध्यान देने के अनुरोध के लिए मध्यम ध्यान दें।

— R

1

फिर से देखना, एक r=REXrexचर के लायक होने के लिए काफी सारे रेक्स हैं ।

— मैनेटवर्क

यदि आप उद्धृत स्ट्रिंग से $ r बाहर रखते हैं, तो आपको आसपास के 'को बदलने की आवश्यकता नहीं है ", इसलिए शाब्दिक रूप से भागने की कोई आवश्यकता नहीं है "। बेशक, तो आप के बजाय उस जगह में लाइन तोड़ कर एक शाब्दिक न्यू लाइन लिखने \n: $r'",. !␤'।

— manatwork

2

जावा 7, 96 98 97 96 बाइट्स

+2 बाइट्स के लिए मिसिंग ई के पहले आर या उसके बाद एक्स नहीं बल्कि दोनों

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

— PunPun1000
स्रोत

2

सी #, 93 90 बाइट्स

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

माना कि यह पहली बार है जब मैंने लंबे नाम स्थान के कारण C # उत्तर में regex का उपयोग किया है System.Text.RegularExpressions।

इसका एहसास तब नहीं हुआ जब मैंने अपना उत्तर लिखा था लेकिन यह @ शागी के जावास्क्रिप्ट उत्तर का # संस्करण है ।

— TheLethalCoder
स्रोत

1

उल्लेख के लिए धन्यवाद, भले ही आप स्वतंत्र रूप से मेरे जवाब के साथ आए।

— झबरा

@ शिग्गी आह धन्यवाद यह अद्यतन नहीं किया गया था

— TheLethalCoder

1

सीजेएम , 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.

— बिजनेस कैट
स्रोत

1

विमस्क्रिप्ट, 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। इसलिए, अगर उपरोक्त चीजों को चलाने के लिए एक आसान तरीका था, जब तक कि यह चीजों को बदलना बंद न कर दे, या जितनी बार इनपुट की लंबाई हो, उतना ही एक और समाधान होगा। मुझे यकीन है कि यह वी में किया जा सकता है, लेकिन यह अभी भी 34 बाइट्स से अधिक लंबा होगा।

— ब्रायन मैककियॉन
स्रोत

विचार के लिए धन्यवाद! यहाँ एक V उत्तर है । :)

— DJMcMayhem

1

जेली , 23 बाइट्स

मामले के बारे में मेरे सवाल पर 24 घंटे से अधिक कोई प्रतिक्रिया नहीं है , इसलिए मैं इस अस्थायी 23 बायटर को पोस्ट करूंगा।

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

परीक्षण मामलों को ऑनलाइन देखें।

कैसे?

“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")

— जोनाथन एलन
स्रोत

मुझे यकीन नहीं है कि यह वैध है। यह परीक्षण के मामलों से मेल नहीं खाता है।

— ओकेक्स

शीर्ष पर मेरा नोट सही देखें, और ओपी के लिए मेरा प्रश्न।

— जोनाथन एलन

(हालांकि दुर्भाग्य से टिप्पणी मैं जहां ओपी ने कहा था कि "कुत्तों को लोअरकेस और अपरकेस के बीच अंतर नहीं मिलता है" अब चला गया है)

— जोनाथन एलन

1

CJam , 26 बाइट्स (अपरकेस आउटपुट) / 36 बाइट्स (केस- प्रोटेक्शन )

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

इसे ऑनलाइन आज़माएं!

यदि पत्र मामले को संरक्षित करने की आवश्यकता है (क्योंकि यह अभी भी थोड़ा अस्पष्ट है ), जिसे 10 अतिरिक्त बाइट्स के साथ पूरा किया जा सकता है:

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

इसे ऑनलाइन आज़माएं!

वैसे, इस उत्तर को लिखते समय, मैंने पाया कि मैं सीजेएम में एक डिज़ाइन बग के रूप में क्या विचार करूंगा: बिटवाइज़ ऑपरेटर &और |दो चार मूल्यों के बीच परिभाषित नहीं हैं, इसलिए मैं .|बिटवाइज़ या दो तारों का उपयोग करने के लिए उपयोग नहीं कर सकता । समाधान, जो मुझे दो अतिरिक्त बाइट की लागत को समाप्त करता है, पहले स्ट्रिंग्स :iको एक पूर्णांक के एक सरणी में परिवर्तित करना है, जो तब दूसरे स्ट्रिंग के साथ ओआरड किया जा सकता है। (वास्तव में यह मेरे लिए तीन बाइट का खर्च है , क्योंकि अगर &दो वर्णों के बीच काम किया जाता है, तो मुझे पत्र मामले की जानकारी को बचाने के 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 है), लेकिन इससे कोई फर्क नहीं पड़ता, क्योंकि वे वर्ण शेष हैं। अपरकेसिंग से अछूता है और पत्र वैसे भी लूप को सेंसर करता है, और अपने स्वयं के पांचवें बिट के साथ एक चरित्र को ऑर्ड करना इसे बदल नहीं सकता है। इसके अलावा, आसानी से, *चरित्र में पहले से ही पांचवां बिट सेट है, इसलिए इसे फाइनल तक अपरिवर्तित भी छोड़ दिया जाता है .|।

— इल्मरी करोनें
स्रोत

1

पिप , 21 19 बाइट्स

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

स्टड से इनपुट लेता है, स्टडआउट के आउटपुट। इसे ऑनलाइन आज़माएं!

व्याख्या

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
स्रोत

1

वी , 27 , 24 बाइट्स

मैं दोनों उत्तर छोड़ रहा हूं, क्योंकि मुझे लगता है कि वे समान रूप से दिलचस्प हैं।

27 बाइट्स

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

इसे ऑनलाइन आज़माएं!

वी में ऐसा करने के लिए अपने विचार के लिए ब्रायन मैककुटन का धन्यवाद

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

— DJMcMayhem
स्रोत

मेरा कुत्ता वास्तव में क्या सुनता है

रेटिना , 24 21 बाइट्स

व्याख्या

** आरएक्सएक्स 151 148 141 बाइट्स **

जावास्क्रिप्ट (ईएस 6), 42 41 38 बाइट्स

कोशिश करो

व्याख्या

एपीएल (Dyalog यूनिकोड) , 22 बाइट्स SBCS

पर्ल 5 , 24 बाइट्स

रेटिना , 32 31 बाइट्स

C, 99 97 92 86 74 74 73 72 बाइट्स

रूबी, 36 35 32 बाइट्स

PHP, 78 बाइट्स

PHP, 84 बाइट्स

C (GCC on POSIX), 167 118 93 87 बाइट्स

पायथन 2 या 3, 75 73 70 बाइट्स

जावा 8, 187 192 168 164 159 138 बाइट्स

पायथन 2, 87 बाइट्स

सीड , 37 33 बाइट्स

गामा, 25 अक्षर

रेटिना , 54 50 49 बाइट्स

रेटिना , 49 बाइट्स

पॉवरशेल, 60 बाइट्स

QuadR , 11 10 + 1 = 11 बाइट्स

MATL , 24 बाइट्स

व्याख्या

पायथन 2 , 93 92 बाइट्स

पर्ल, 31 बाइट्स

बैश , 128 बाइट्स

जावा 7, 96 98 97 96 बाइट्स

सी #, 93 90 बाइट्स

सीजेएम , 39 बाइट्स

विमस्क्रिप्ट, 34 बाइट्स

जेली , 23 बाइट्स

कैसे?

CJam , 26 बाइट्स (अपरकेस आउटपुट) / 36 बाइट्स (केस- प्रोटेक्शन )

पिप , 21 19 बाइट्स

व्याख्या

वी , 27 , 24 बाइट्स

27 बाइट्स

24 बाइट्स

आरएक्सएक्स 151 148 141 बाइट्स

एपीएल (Dyalog यूनिकोड) , 22 बाइट्स ^SBCS