Copodope Gopolopfop

Question

भाषा: विरोध

बोलने की एक मज़ेदार भाषा प्रत्येक शब्द के लिए निम्नलिखित प्रक्रिया को लागू करके बनाई गई है:

1. opप्रत्येक व्यंजन के बाद रखें । तो Codeबन जाता है Copodope।

हाँ बस यही। इस चुनौती के उद्देश्य के लिए, yहमेशा एक व्यंजन है।

चैलेंज: डी-उत्पीड़न

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

परीक्षण के मामलों:

Oppified      ->         Original 
a                        a
I                        I
itop                     it
opop                     op
Opop                     Op
popopop                  pop
Copopop                  Cop
opopopop                 opop
Kopicopkop               Kick
Asopia                   Asia
soptopopop               stop
hopoopopsop              hoops
hopoopopedop             hooped
ooooohop                 oooooh
aaaopopaaa               aaaopaaa
Popopopsopicoplope       Popsicle
gopaloplopopopinopgop    galloping
aopopbopopopcopopop      aopbopcop

Comments

आपके किसी भी परीक्षण के मामले में एक स्वर शामिल नहीं होता है op, इसलिए उनकी तर्ज पर एक उत्तर replace(/(.)op/, '\1')उनमें से किसी को भी विफल नहीं करेगा। मेरा सुझाव है कि आप एक शब्द जैसे hoopया loopedपरीक्षण मामलों को जोड़ते हैं।

— दरवाज़े

@ mbomb007 मैंने कुछ और पेचीदा परीक्षण मामले जोड़े।

— 20

क्या जवाब में केवल प्री-इनपुट इनपुट या सभी इनपुट के लिए काम करना है?

— कैलक्यूलेटरफल

@ कलकटरफेलिन "एक उत्पीड़ित शब्द को देखते हुए"

— mbomb007

क्या हम एक परीक्षण मामले के रूप में "mopmopmopbopopop" जोड़ सकते हैं? :)

— user2390246

Answer 1

वी , 12 , 5 बाइट्स

Í.“op

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

00000000: cd2e 936f 70                             ...op

सहेजे गए 7 बाइट्स @ Xnor के अहसास की बदौलत कि चूंकि इनपुट पर हमेशा अत्याचार किया जाना चाहिए, हमें ज्वेल्स के लिए जाँच नहीं करनी होगी।

Comments

हम्म, यह हरा करने के लिए इतना कठिन लगता है ...

— एरिक द आउटगलर

हेक्स डंप: ...op क्या मुझे हंसने के तरीके से ज्यादा मुश्किल होना चाहिए

— nmjcman101

Answer 2

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

(?!\G)op

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

यह जाँचने के बजाय कि पूर्ववर्ती वर्ण एक व्यंजन है, हम सिर्फ यह सुनिश्चित करते हैं कि वर्तमान opया तो स्ट्रिंग या पिछले मैच की शुरुआत के निकट नहीं है। एकमात्र मामला जहां हम गलत मिलान कर सकते हैं opयदि मूल स्ट्रिंग में एक op(परिणामस्वरूप opop) निहित है । लेकिन उस स्थिति में हम opदूसरे के बजाय पहले को हटा देंगे और परिणाम समान होगा।

Comments

क्या यह इनपुट जैसे गलत उत्तर नहीं देगा loop?

— सिंह

@Lio loopएक वैध इनपुट नहीं है क्योंकि आप इसे किसी अन्य शब्द पर अत्याचार करने से प्राप्त नहीं कर सकते।

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

@MartinEnder lopoop( लेकिन का उत्पीड़ित संस्करण loop) मान्य है, और इसके लिए डी-उत्पीड़ित नहीं किया जाता है loop।

— Imus

@Imus नहीं, का उत्पीड़ित संस्करण loopहै lopoopop।

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

इसे पोस्ट करने के कुछ ही समय बाद मेरी गलती का एहसास हुआ :) हटाने में बहुत धीमी थी। अच्छी बात।

— Imus

Answer 3

पायथन , 42 बाइट्स

lambda s:re.sub('(.)op',r'\1',s)
import re

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

अगर मैं गलत नहीं हूँ, तुम सिर्फ सभी स्थानापन्न कर सकते हैं ?opके साथ ?स्वर के बारे में देखभाल के बिना। यदि मूल स्ट्रिंग opसम्‍मिलित है, तो इसका उत्पीड़न किया जाता है opop, और प्रतिस्थापन इसे वापस लौटा देता है opऔर आगे नहीं। इसका कारण यह है कि पैटर्न ?opओवरलैप नहीं हो सकता है, इसलिए केवल एक opको हटा दिया जाता है।

एक गैर-रेगेक्स समाधान 5 बाइट्स लंबा है।

पायथन , 47 बाइट्स

f=lambda s:s and s[0]+f(s[1+2*(s[1:3]=='op'):])

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

Comments

आप इसे संदर्भ के re बाद आयात कर सकते हैं

— 20

@ Adám Python इसका मूल्यांकन तब नहीं करता है जब फ़ंक्शन को परिभाषित किया जाता है, केवल जब इसे बुलाया जाता है।

— xnor

वाह, यह एक समय हो गया है जब से मैंने देखा है कि किसी ने एक इंटरबॉन्ग का उपयोग किया है। मुझे लगता है कि यह एक तरह से अपनी टिप्पणी थोड़ा गोल्फ है।

— बाल्ड्रिक

@ बाल्ड्रिक लेकिन बाइट्स में , इंटररोबैंग में> = बाइट्स सिर्फ स्ट्रिंग से ""? "

— MilkyWay90

Answer 4

पर्ल 5 , 10 + 1 = 11 बाइट्स

s/.\Kop//g

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

साथ चलाएं -p(1 बाइट पेनल्टी); गोल्फ भाषाएं I / O को स्वचालित रूप से निहित कर सकती हैं, लेकिन पर्ल को इसके लिए एक विकल्प की आवश्यकता है।

जब मैंने @ xnor का उत्तर देखा , तो मुझे एहसास हुआ कि इसे पर्ल-विशिष्ट रेगेक्स फीचर का उपयोग करके बेहतर बनाया जा सकता है; s/a\Kb/c/gके बराबर है s/ab/ac/g(दूसरे शब्दों में, s///केवल पहले के बाद की चीजों को बदल देता है \K)। तो यहाँ कैसे पर्ल में दिखता है।

Answer 5

रेटिना , 15 8 बाइट्स

(.)op
$1

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

-7 बाइट्स केविन क्रूज़सेन को धन्यवाद

Comments

के [^aeiou]साथ बदलकर आप 7 बाइट्स बचा सकते हैं .। उनके पायथन उत्तर में @xnor की व्याख्या देखें ।

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

Answer 6

जाओ , १०३ ९ २ बाइट्स

अवश्य ... संकलन करें ... निर्मित कार्यों में अजीब नाम हैं। : पी

import."regexp"
func f(s string)string{return MustCompile("(.)op").ReplaceAllString(s,"$1")}

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

Answer 7

हास्केल (93 62 61 बाइट्स)

a(x:'o':'p':r)|notElem x"aeiouAEIOU"=x:a r
a(x:r)=x:a r
a x=x

टिप्पणियों में @nimi सुझावों के लिए धन्यवाद!

Comments

कुछ सुझाव: जैसा कि आप उपयोग कर रहे हैं vऔर oकेवल एक बार, आप इसे इनलाइन कर सकते हैं। notElemसे छोटा है not(...elem...)। आप &&किसी गार्ड के साथ बदल सकते हैं a ,। के लिए अंतिम मामला के aरूप में लिखा जा सकता है a x=x। में कोई जरूरत नहीं ()है x:(a r)।

— नामी

... ओह, और के लिए परीक्षण =="op"एक शाब्दिक पैटर्न मैच के साथ बदला जा सकता है:a(x:'o':'p':r)|notElem x"aeiouAEIOU"=x:a r

— nimi

अपडेट किया गया। धन्यवाद @nimi

— Davide

सहेजने के लिए एक और बाइट: आप xऔर के बीच की जगह को छोड़ सकते हैं "।

— nimi

Answer 8

PHP , 36 बाइट्स

<?=preg_replace("#.\Kop#","",$argn);

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

Comments

इसे कैसे चलाया जाए?

— टाइटस

यह पहले दो परीक्षण मामलों के लिए विफल रहता है। preg_replaceठीक करने के लिए उपयोग करें ।

— टाइटस

आप किसी भी एकल वर्ण के लिए चर का नाम बदलकर 3 बाइट्स बचा सकते हैं, $ एक उदाहरण के लिए

— जंकफूडजंकिए

@junkfoodjunkie $argnएक आरक्षित वैरिएबल है जो -R

— PHPb

आह, ठीक है, वह नहीं जानता था। ऑनलाइन परीक्षक इसके लिए जिम्मेदार नहीं है। :-)

— जंकफूडजंकाइ

Answer 9

जाप , 9 बाइट्स

r"%Vop"_g

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

Answer 10

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

f=शुरुआत में जोड़ें और जैसे आह्वान करें f(arg)।

s=>s.replace(/([^aeiou])op/gi,"$1")

मुझे आश्चर्य है कि किसी ने अभी तक जावास्क्रिप्ट समाधान पोस्ट नहीं किया है ...।

टेस्ट स्निपेट

let f=
s=>s.replace(/([^aeiou])op/gi,"$1")

console.log("a" + " -> " + f("a"));
console.log("I" + " -> " + f("I"));
console.log("itop" + " -> " + f("itop"));
console.log("opop" + " -> " + f("opop"));
console.log("Opop" + " -> " + f("Opop"));
console.log("popopop" + " -> " + f("popopop"));
console.log("Copopop" + " -> " + f("Copopop"));
console.log("opopopop" + " -> " + f("opopopop"));
console.log("Kopicopkop" + " -> " + f("Kopicopkop"));
console.log("Asopia" + " -> " + f("Asopia"));
console.log("soptopopop" + " -> " + f("soptopopop"));
console.log("hopoopopsop" + " -> " + f("hopoopopsop"));
console.log("hopoopopedop" + " -> " + f("hopoopopedop"));
console.log("ooooohop" + " -> " + f("ooooohop"));
console.log("aaaopopaaa" + " -> " + f("aaaopopaaa"));
console.log("Popopopsopicoplope" + " -> " + f("Popopopsopicoplope"));
console.log("gopaloplopopopinopgop" + " -> " + f("gopaloplopopopinopgop"));
console.log("aopopbopopopcopopop" + " -> " + f("aopopbopopopcopopop"));

Answer 11

सी (जीसीसी) , 83 बाइट्स

main(c,v)char**v;{for(;*v[1];strchr("aAeEiIoOuU",putchar(*v[1]++))?:printf("op"));}

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

Answer 12

/// , 18 बाइट्स

/op/.//../o\p//.//

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

ध्यान दें कि यह स्निपेट opएक के साथ बदलना चाहता है ., लेकिन बाद में एक प्रतिस्थापन परिभाषित किया गया है जहां opवापस स्ट्रिंग में डाला जा रहा है। उस दूसरे निर्देश को opएक .(और इस प्रकार .अंतिम परिणाम में सम्मिलित किया जाएगा) द्वारा प्रतिस्थापित किया जाएगा , इसलिए मैंने पैटर्न को तोड़ने के \लिए oऔर बीच का उपयोग किया है p।

Answer 13

एपीएल (डायलॉग) , 13 बाइट्स

'(.)op'⎕R'\1'

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

बस पीसीआर आर किसी भी चरित्र को "ओप" के बाद चरित्र के साथ ग्रहण करता है।

Answer 14

क्रिस्टल, 39 बाइट्स

def o(s)s.gsub(/([^aeiou])op/,"\\1")end

यह काम किस प्रकार करता है

यह बस प्रत्येक व्यंजन की खोज करता है, उसके बाद क्रम से op। यदि हां, तो उस अनुक्रम को केवल पहले पाए गए व्यंजन के साथ बदलें ([^aeiou]):।

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

Answer 15

जावा 8, 36 26 बाइट्स

s->s.replaceAll("(.)op","$1")

-10 बाइट्स के [^aeiou]साथ प्रतिस्थापित करके ., अपने पायथन उत्तर में @xnor की व्याख्या के लिए धन्यवाद ।

इसे यहाँ आज़माएँ।

Answer 16

रूबी , 34 27 22 + 1 = 23 बाइट्स

-4 बाइट्स आरजेहंटर को धन्यवाद।

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

$_.gsub!(/(.)op/,'\1')

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

Comments

रूबी के -pविकल्प का उपयोग करने पर एक बाइट खर्च होगी, लेकिन अपनी स्क्रिप्ट को सीधे शुरू करने की अनुमति दें gsub।

— RJHunter

Answer 17

sed, 22 बाइट्स

sed -E 's/(.)op/\1/g'

एसटीडीआईएन से ईओएफ तक आउटपुट और डी-उत्पीड़ित स्ट्रिंग को आउटपुट
करता है @ xnor के पायसॉन उत्तर से एक ही लंबाई में कमी तकनीक का उपयोग करता है

Answer 18

आर , 29 बाइट्स

gsub("(.)op","\\1",scan(,''))

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

यहां ज्यादातर अन्य समाधानों की तरह, ऑप द्वारा पीछा चरित्र को कैप्चर करता है, इसे चरित्र के साथ बदल देता है।