फेसि मैकफ़ेसफेस

47

किसी को बोटी याद है ?

आप किसी भी पुराने शब्द को पूरी तरह से सही बना सकते हैं?

  • एक स्ट्रिंग को समसामयिक McSomethingface में बदलने के लिए एक फ़ंक्शन लिखें।
  • इसे इनपुट के रूप में एक स्ट्रिंग को स्वीकार करना चाहिए। इनपुट के मामले पर ध्यान न दें।
  • यदि शब्द 'y' में समाप्त होता है, तो आपके फ़ंक्शन को पहले उदाहरण में अतिरिक्त 'y' नहीं जोड़ना चाहिए, लेकिन इसे दूसरे उदाहरण में निकाल देना चाहिए।
  • यदि शब्द 'आंख' में समाप्त होता है, तो इसमें पहले उदाहरण में अतिरिक्त 'y' नहीं होना चाहिए, लेकिन दूसरे उदाहरण में दोनों को हटा देना चाहिए।
  • आउटपुट में पहले अक्षर में केवल ऊपरी अक्षर, 'Mc' का 'M' और 'Mc' के बाद पहला अक्षर होना चाहिए।
  • इसे केवल 3 या अधिक वर्णों के तार के साथ काम करने की आवश्यकता है।

उदाहरण:

boat                  =>  Boaty McBoatface
Face                  =>  Facey McFaceface
DOG                   =>  Dogy McDogface
Family                =>  Family McFamilface
Lady                  =>  Lady McLadface
Donkey                =>  Donkey McDonkface
Player                =>  Playery McPlayerface
yyy                   =>  Yyy McYyface
DJ Grand Master Flash =>  Dj grand master flashy McDj grand master flashface
code-golf  string 
— AJFaraday
स्रोत
स्ट्रिंग में रिक्त स्थान के बारे में क्या, क्या हम उन्हें बरकरार रखते हैं? उदाहरण: ' y'और' '
— मेरे शरीर
2
मैं @Annauld से एक सुझाव को लागू करने जा रहा हूं और इसे तीन वर्ण न्यूनतम करूंगा। दूसरे अक्षर की तरह ही व्हाट्सएप का इलाज करें।
— AJFaraday
— केविन क्रूज़सेन
क्या हम मान सकते हैं कि इनपुट में केवल ऊपरी और निचले अक्षर होंगे?
— केविन क्रूज़सेन
@ केविनक्रूजसेन मैंने परीक्षण के मामलों में कोई गैर-पत्र नहीं डाला है, इसलिए वे प्रभावी रूप से चिंतित नहीं हैं।
— AJFaraday

जवाबों:

7

स्टेक्स , 26 बाइट्स

ëO╛εh╕⌠î&!}∞┌C^U╟«äδ◙Bg⌠└¿

इसे चलाएं और डीबग करें

^           convert input to upper case                     "FACE"
B~          chop first character and push it back to input  70 "ACE"
v+          lowercase and concatenate                       "Face"
c'yb        copy, push "y", then copy both                  "Face" "Face" "y" "Face" "y"
:]          string ends with?                               "Face" "Face" "y" 0
T           trim this many character                        "Face" "Face" "y"
+           concatenate                                     "Face" "Facey"
p           output with no newline                          "Face"
"e?y$"z     push some strings                               "Face" "e?y$" ""
" Mc`Rface  execute string template; `R means regex replace " Mc Faceface"
            result is printed because string is unterminated

इसको चलाओ

— पुनरावर्ती
स्रोत
15

वी , 27 28 30 बाइट्स

Vu~Ùóe¿y$
Hóy$
ÁyJaMc<Esc>Aface

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

<Esc> प्रतिनिधित्व करता है 0x1b

  • यह जानने के बाद कि हमें 3 से कम वर्णों वाले इनपुट का समर्थन करने की आवश्यकता नहीं है, दो बाइट्स को गॉल्फ़ किया गया।

  • 1 बाइट ने पहले लाइन से पहले दूसरी पंक्ति में काम करके @DJMcMayhem को धन्यवाद दिया, इस प्रकार हटा दिया G

इनपुट बफर में है। कार्यक्रम सब कुछ लोअरकेस में परिवर्तित करके शुरू होता है

Vलाइन का चयन करता है और uइसे कम करता है

~ पहले चरित्र के मामले को जन्म देता है (इसे अपरकेस में बदलना)

और Ùनीचे की लाइन पर कर्सर को छोड़ते हुए इस लाइन को डुप्लिकेट करता है

óऔर (दूसरी पंक्ति में होता है) के साथ (वैकल्पिक और लाइन के अंत में) के e¿y$संकुचित रूप को बदल देता हैe\?y$ey

H पहली पंक्ति में जाता है

óबदल देता है y$( yपंक्ति के अंत में) पहली पंक्ति पर कुछ भी नहीं के साथ

Áyपहली पंक्ति के अंत में जोड़ता है

J और बीच में एक स्थान के साथ पहली के साथ अंतिम पंक्ति में मिलती है, और कर्सर को इस स्थान पर ले जाया जाता है

aएपेंड करता है Mc( <Esc>सामान्य मोड में लौटता है)

Aअंत में, faceपंक्ति के अंत में जोड़ता है

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

अजगर, 144 बाइट्स

def f(s):
 s=s[0].upper()+s[1:].lower()
 y=lambda s:s[:-1]if s[-1]=='y'else s
 t=y(s)
 u=s[:-2]if s[-2:]=='ey'else y(s)
 return t+'y Mc%sface'%u

इसे यहाँ ऑनलाइन आज़माएँ

— मेरे बदन को स्पर्श करो
स्रोत
2
मेरी पहली बार गोल्फ की कोशिश ...
— मेरे शरीर को
3
PPCG में आपका स्वागत है! क्या मैं इसे ऑनलाइन आज़माने के लिए एक लिंक जोड़ने का सुझाव दे सकता हूँ ! शुद्धता के सत्यापन के लिए?
— Giuseppe
1
f("Face")वर्तमान परीक्षण मामलों ( TIO ) का अनुपालन नहीं करता है ।
— जोनाथन फ्रीच
शुद्धता के लिए संपादित पोस्ट, इसे ऑनलाइन आज़माएं! लिंक
— मेरे शरीर को
1
— 19
12

एक्सेल, 204 144 137 165 बाइट्स

=SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(REPT(REPLACE(LOWER(A1),1,1,UPPER(LEFT(A1)))&"~",2),"~","y Mc",1),"yy ","y "),"ey~","~"),"y~","~"),"~","face")

अंदर से बाहर की ओर:

REPLACE(LOWER(A1),1,1,UPPER(LEFT(A1)))      Replaces PROPER to handle space-delimited cases
REPT(%&"~",2)                   Duplicate.                    Donkey~Donkey~
SUBSTITUTE(%,"~","y Mc",1)      Replace first ~.              Donkeyy McDonkey~
SUBSTITUTE(%,"yy ","y ")        Handle words ending in 'y'.   Donkey McDonkey~
SUBSTITUTE(%,"ey~","~")         Handle words ending in 'ey'   Donkey McDonk~
SUBSTITUTE(%,"y~","~")          Handle words ending in 'y'    Donkey McDonk~
SUBSTITUTE(%,"~","face")        Adding face.                  Donkey McDonkface

पुराना उत्तर, सभी बिट्स को अलग-अलग बनाना, और फिर कंक्रीटिंग (176 बाइट्स)। अंतरिक्ष-सीमांकित मामलों को सही तरीके से नहीं संभालता है।

=PROPER(A1)&IF(LOWER(RIGHT(A1,1))="y",,"y")&" Mc"&IF(LOWER(RIGHT(A1,2))="ey",LEFT(PROPER(A1),LEN(A1)-2),IF(LOWER(RIGHT(A1,1))="y",LEFT(PROPER(A1),LEN(A1)-1),PROPER(A1)))&"face"
— Wernisch
स्रोत
दुर्भाग्य से, अंतरिक्ष-सीमांकित मामलों को संभालने की आवश्यकता के कारण, PROPER(A1)अमान्य है ( DJ Grand Master Flashइनपुट केस देखें ), मेरे वीबीए समाधान पर काम करते समय मुझे जो सबसे अच्छा प्रतिस्थापन मिला वह था LEFT(UPPER(A1))&MID(LOWER(A1),2,LEN(A1))- कृपया मुझे बताएं कि क्या आप नीचे गोल्फिंग करते हैं।
— टेलर स्कॉट
1
साभार @TaylorScott मिला 'REPLACE (LOWER (A1), 1,1, UPPER (LEFT (A1))) `जो 2 बाइट्स छोटा है।
— वेर्निस्क
9

C # (.NET Core) , 122 108 139 175 180 179 154 बाइट्स

बहुत बहुत धन्यवाद, ली!

s=>((s.EndsWith("y")?s:s+"y")+" Mc"+(s+"$").Replace("ey$","")+"face").Replace(s,s.ToUpper()[0]+s.Substring(1).ToLower()).Replace("y$","").Replace("$","");

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

सी # (.NET कोर, लिनक्यू के साथ), 152 बाइट्स

s=>((s.Last()=='y'?s:s+"y")+" Mc"+(s+"$").Replace("ey$","")+"face").Replace(s,s.ToUpper()[0]+s.Substring(1).ToLower()).Replace("y$","").Replace("$","");

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

— एंडरसन पिमेंटेल
स्रोत
3
साइट पर आपका स्वागत है! :)
— DJMcMayhem
7

रूबी , 61 49 बाइट्स

->s{s.capitalize=~/(e)?y$|$/;"#$`#$1y Mc#$`face"}

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

12 मीठे बाइट्स का धन्यवाद @MartinEnder को दिया:

— iamnotmaynard
स्रोत
1
: मेरे रेटिना जवाब से regex का उपयोग करना और स्ट्रिंग प्रक्षेप का एक सा अधिक इस्तेमाल कर रही है 49 को यह नीचे हो जाता है tio.run/##DcxBCsIwEEDRqwxJBF3Y4lpSN0U3igcQwTQmGFptMVNkTOLVY3bvb/...
— मार्टिन Ender
@MartinEnder वाह, यह काफी अंतर है। मुझे नहीं लगता कि मैंने ब्रैकेट के बिना स्ट्रिंग प्रक्षेप देखा है। यदि आप इसे अपने रूबी जवाब के लिए उपयोग नहीं करना चाहते हैं तो मैं इसे ले जाऊंगा।
— नॉटमनेयार्ड
नहीं, यह ठीक है, मैं उपयोग =~करने के बजाय पूरे स्ट्रिंग का उपयोग करने और बनाने के साथ नहीं आया हूं sub। स्ट्रिंग इंटरपोलेशन का उपयोग ब्रैकेट्स के बिना किया जा सकता है यदि चर वैश्विक, उदाहरण या वर्ग चर है।
— मार्टिन एंडर
आप -pध्वज का उपयोग करके और उपयोग करके इसे नीचे 44 + 1 बाइट्स पर प्राप्त कर सकते हैं sub: tio.run/…
— जॉर्डन
5

जावा 8, 121 112 107 106 बाइट्स

s->(s=(char)(s.charAt(0)&95)+s.toLowerCase().substring(1)).split("y$")[0]+"y Mc"+s.split("e?y$")[0]+"face"

-1 ऑल्ट @GliGrégoire को धन्यवाद ।

स्पष्टीकरण:

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

s->                         // Method with String as both parameter and return-type
  (s=                       //  Replace and return the input with:
     (char)(s.charAt(0)&95) //   The first character of the input as Uppercase
     +s.toLowerCase().substring(1))
                            //   + the rest as lowercase
  .split("y$")[0]           //  Remove single trailing "y" (if present)
  +"y Mc"                   //  Appended with "y Mc"
  +s.split("e?y$")[0]       //  Appended with the modified input, with "y" or "ey" removed
  +"face"                   //  Appended with "face"
— केविन क्रूज़सेन
स्रोत
यदि पहला वर्ण वर्णानुक्रम में न हो तो क्या होगा? या हो सकता है कि हम इसके बारे में एक नियम जोड़
— सकें
1
@streetster बस ओपी से पूछा, और ऐसा लगता है कि इनपुट में केवल अपरकेस और / या लोअरकेस अक्षर होंगे।
— केविन क्रूज़सेन
1
~32-> 951 बाइट के लिए बचा लिया गया
— ओलिवियर ग्रैगोइरे
@ ओलिविएरग्रेयर मुझे वास्तव में बिटवाइज़ ऑपरेशंस के बारे में थोड़ा और सीखना शुरू करना होगा ..>।>
— केविन क्रूज़सेन
4

जावास्क्रिप्ट, 103 96 94 बाइट्स

सुंदर भोला पहले इस पर से गुज़रा।

s=>(g=r=>s[0].toUpperCase()+s.slice(1).toLowerCase().split(r)[0])(/y$/)+`y Mc${g(/e?y$/)}face`

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

— झबरा
स्रोत
s =>${s=s[0].toUpperCase()+s.slice(1).toLowerCase().replace(/y$/,``)}y Mc${s.replace(/e?y$/,``)}face
— बेंजामिन ग्रुएनबाम
एक कम: s =>${s=s[0].toUpperCase()+s.slice(1).toLowerCase().replace(/y$/,'')}y Mc${s.replace(/e$/,``)}face
— बेंजामिन Gruenbaum
धन्यवाद, @BenjaminGruenbaum, लेकिन पहले के लिए विफल रहता है Donkeyऔर दूसरे के लिए Face।
— शैगी
— बेंजामिन
@ शैगी मैं कुछ वर्णों द्वारा छ समारोह को कम करने में कामयाब रहा :)। आप मेरे समाधान में देख सकते हैं
— DanielIndie
3

vim, 35 34 बाइट्स

Vu~Yp:s/ey$
:%s/y$
kgJiy Mc<ESC>Aface<ESC>

<ESC> है 0x1b

Ungolfed

Vu~                      # Caseify McCaseface
Yp                       # dup line
:s/ey$ 
:%s/y$                   # Get the suffixes right
kgJiy Mc<ESC>Aface<ESC>  # Join lines and add the extra chars

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

डीजेएमकेमहेम के लिए 1 बाइट धन्यवाद

— रे
स्रोत
1
आप क्या कर सकते हैं Yके बजायyy
— DJMcMayhem
3

पर्ल 5 -p , 47 39 बाइट्स

@ ओएलवीवी। वोल्वोव के सुझावों के साथ 6 बाइट्स सहेजे गए, 1 @ mwellnhof's के साथ, और 1 मेरे खुद के साथ

$_=lc^$";$_=s/y?$/y Mc/r.s/e?y$//r.face

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

— Xcali
स्रोत
आप इससे छुटकारा पा सकते हैं ucfirst:$_=lc^$";
— ओलेग वी। वोल्कोव
$_=s/y$//r."y Mc".s/e?y$//r.faceएक बाइट कम है
— nwellnhof
1
/y$|$/->/y?$/
— ओलेग वी। वोल्कोव
ओह। मुझे इसका एहसास होना चाहिए था।
— Xcali
3

सी ++ 14 (जी ++), 181 171 148 147 134 बाइट्स

[](auto s){s[0]&=95;int i=1,b;for(;s[i];)s[i++]|=32;b=s[--i]-'y';return s+(b?"y":"")+" Mc"+(b?s:s.substr(0,s[i-1]-'e'?i:i-1))+"face";}

ध्यान दें कि क्लैंग इसका संकलन नहीं करेगा।

ट्रिक के लिए क्रेडिट केविन क्रूज़सेन और ओलिवियर ग्रेजायर को जाता है &95।

क्रिस को 11 बाइट के लिए धन्यवाद ।

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

Ungolfed संस्करण:

[] (auto s) { // lambda taking an std::string as argument and returning an std::string
    s[0] &= 95; // convert the first character to upper case
    int i = 1, // for iterating over the string
    b; // we'll need this later
    for(; s[i] ;) // iterate over the rest of the string
        s[i++] |= 32; // converting it to lower case
    // i is now s.length()
    b = s[--i] - 'y'; // whether the last character is not a 'y'
    // i is now s.length()-1
    return s + (b ? "y" : "") // append 'y' if not already present
    + " Mc"
    + (b ? s : s.substr(0, s[i-1] - 'e' ? i : i-1)) // remove one, two, or zero chars from the end depending on b and whether the second to last character is 'e'
    + "face";
}
— OOBalance
स्रोत
मैं C ++ को अच्छी तरह से नहीं जानता, लेकिन आप 9 बाइट्स गोल्फ कर सकते हैं: इसे ऑनलाइन 172 बाइट्स आज़माएँ । परिवर्तनों का सारांश: s[0]=s[0]&~32;से s[0]&=~32;; s[i++]=s[i]|32;को s[i++]|=32; और int i=1,n=s.length()-1,b;इसलिए आपको केवल 1 की आवश्यकता है int।
— केविन क्रूज़सेन
ओह, और एक और बाइट में अंतरिक्ष को हटाकर#include<string>
— केविन क्रूज़सेन
@KevinCruijssen कि पकड़ने के लिए धन्यवाद! मैंने संपादित किया है।
— ओबैलेंस
आप 11 बाइट्स को परिभाषित नहीं करके nऔर केवल iलूप के बाद के मूल्य का उपयोग करके बचा सकते हैं । इसे ऑनलाइन आज़माएं!
— क्रिस
@ क्रिस धन्यवाद! मैं 2 और बाइट्स शेव करने में कामयाब रहा।
— ओबैलेंस
2

वी , 38 36 32 बाइट्स

-5 बाइट थैंक्स टू @ क्वॉक्स

Vu~hy$ó[^y]$/&y
A Mc<esc>póe¿y$
Aface

<esc>एक शाब्दिक बच चरित्र है और के [^रूप में इनकोडिंग है\x84

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

— हरमन एल
स्रोत
gu$बन सकते हैंVu
— क्रिक्सी लिथोस
2
चूंकि [^रेगेक्स शॉर्टकट है ( यहां देखें ), आप [^बाइट को बचाने के बजाय 0x84 का उपयोग कर सकते हैं । इसी तरह, एक और बाइट को बचाने के लिए \?सरलीकृत किया जा सकता है <M-?>। और $a=>A
— क्रिकटी लिथोस
2

पायथन 3 , 117 114 बाइट्स

-3 बाइट्स डेड पॉसम के लिए धन्यवाद

def f(s):s=s.title();return s+'y'*(s[-1]!='y')+' Mc'+([s,s[:-1],0,s[:-2]][(s[-1]=='y')+((s[-2:]=='ey')*2)])+'face'

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

— Dat
स्रोत
1 बाइट को बचाने के [s,s[:-1],'',s[:-2]लिए सूची के 3 तत्व को बदला जा सकता है 0।
— मृत पोसम
की 'y'*1 *1जरूरत नहीं है। 2 और बाइट्स
— मृत पोसुम
पायथन 3 से पायथन 2 तक स्विच करना और उसके returnसाथ बदलना print1 बाइट कम है।
— केविन क्रूज़सेन 12
2

जावास्क्रिप्ट (Node.js) , 87 बाइट्स

  • 5 बाइट्स कम करने के लिए @ शागी को धन्यवाद
s=>(g=r=>Buffer(s.replace(r,"")).map((x,i)=>i?x|32:x&~32))(/y$/)+`y Mc${g(/e?y$/)}face`

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

— DanielIndie
स्रोत
2
आपको गैर-पुनरावर्ती कार्यों का नाम नहीं देना है।
— डेनिस
1
अच्छी तरह से किया। मैं उपयोग करने के लिए कभी नहीं सोचता Buffer, भविष्य की चुनौतियों के लिए इसे याद रखने की कोशिश करनी होगी। आपके लिए यह 87 बाइट्स तक सीमित रहा।
— शैगी
2

K4 , 74 69 68 बाइट्स

उपाय:

{$[r;x;x,"y"]," Mc",_[r:0&1-2/:"ye"=2#|x;x:@[_x;0;.q.upper]],"face"}

उदाहरण:

q)k)f:{$[r;x;x,"y"]," Mc",_[r:0&1-2/:"ye"=2#|x;x:@[_x;0;.q.upper]],"face"}
q)f each ("boat";"Face";"DOG";"Family";"Lady";"Donkey";"Player")
"Boaty McBoatface"
"Facey McFaceface"
"Dogy McDogface"
"Family McFamilface"
"Lady McLadface"
"Donkey McDonkface"
"Playery McPlayerface"

स्पष्टीकरण:

यदि अंतिम वर्ण बराबर हैं "ey", तो परिणाम को बेस -2 में बदलें ताकि हम उन शब्दों को अनदेखा कर सकें जो समाप्त होते हैं "e?"। ट्रिम करने के लिए वर्णों की संख्या की सूची में अनुक्रमणिका।

प्रबंधित करने के लिए 5 बाइट्स को दाढ़ी बनाने के लिए प्रबंधित किया गया है, यह निर्धारित करने के लिए कि क्या पिछले दो वर्ण हैं "ey"लेकिन इसे बेहतर करने के लिए संघर्ष कर रहे हैं ...

{$[r;x;x,"y"]," Mc",_[r:0&1-2/:"ye"=2#|x;x:@[_x;0;.q.upper]],"face"} / the solution
{                                                                  } / lambda function
                                                            ,"face"  / join with "face"
                    _[                  ;                  ]         / cut function
                                           @[_x; ;        ]          / apply (@) to lowercased input
                                                0                    / at index 0
                                                  .q.upper           / uppercase function
                                         x:                          / save back into x
                                      |x                             / reverse x
                                    2#                               / take first two chars of x
                               "ye"=                                 / equal to "ye"?
                             2/:                                     / convert to base 2
                           1-                                        / subtract from 1
                         0&                                          / and with 0 (take min)
                       r:                                            / save as r
             ," Mc",                                                 / join with " Mc"
 $[r;x;x,"y"]                                                        / join with x (add "y" if required)

बोनस:

K (oK) में 67 बाइट पोर्ट :

{$[r;x;x,"y"]," Mc",((r:0&1-2/"ye"=2#|x)_x:@[_x;0;`c$-32+]),"face"}

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

— streetster
स्रोत
1
यदि आपका ओके पोर्ट इसे हरा देता है तो K4 में क्या बात है?
— ज़ाचारि
मुझे नहीं लगता था कि यह होगा, और पोर्ट काम नहीं करता है, अगर पहले चार वर्णमाला के रूप में मैं आँख बंद करके 32 ASCII मूल्य से घटाता नहीं है - कोई "ऊपरी" अंतर्निहित नहीं है।
— स्ट्रीटस्टर
2

रूबी , 69 बाइट्स

->s{"#{(s.capitalize!||s)[-1]==?y?s:s+?y} Mc#{s.gsub /e?y$/,""}face"}

स्पष्टीकरण:

->s{                                                                } # lambda 
    "#{                                 } Mc#{                }face" # string interpolation
       (s.capitalize!||s) # returns string capitalized or nil, in that case just use the original string
                         [-1]==?y # if the last character == character literal for y
                                 ?s:s+?y # then s, else s + "y"
                                              s.gsub /e?y$/,"" # global substitute
                                                               # remove "ey" from end

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

— dkudriavtsev
स्रोत
क्या आप एक TIO लिंक जोड़ सकते हैं? मैं रूबी को नहीं जानता, लेकिन s.capitalizeपिछले की जगह लेता है s? यदि नहीं, तो करता है /e?y$/संभाल एक टेस्ट केस में समाप्त होने वाले Y, EYया Eyसही ढंग से?
— केविन क्रूज़सेन
1
@ केविनक्रूजसेन s.capitalizeबनाम s.capitalize!(विभिन्न कार्य)। s.capitalize!पुराने संस्करण clobbers।
— dkudriavtsev
@KevinCruijssen मैंने एक TIO लिंक जोड़ा है।
— dkudriavtsev
@KevinCruijssen ने एक स्पष्टीकरण भी जोड़ा
— dkudriavtsev
आह ठीक है, स्पष्टीकरण और जानकारी के लिए धन्यवाद s.capitalize!। रूबी में कभी भी प्रोग्राम नहीं किया गया, लेकिन पिछले मूल्य को बदलने के लिए स्पष्टीकरण चिह्न जोड़ना बहुत अच्छा है। मुझ से +1।
— केविन क्रूज़सेन
2

जेस्टेक्स , 27 बाइट्स

h</►yT↓►y/◙♂ Mc♀/◄eyg►yg/íå

व्याख्या

      # Command line args are automatically loaded onto the stack
h     # Title case the top of the stack
<     # Duplicate the top value on the stack twice
/     # Print the top value on the stack
►y    # Load 'y' onto the stack
T     # Returns true if the 2nd element on the stack ends with the top
↓     # Execute block if the top of the stack is false
  ►y  # Load 'y' onto the stack
  /   # Print the top value on the stack
◙     # End the conditional block
♂ Mc♀ # Load ' Mc' onto the stack
/     # Print the top value on the stack
◄ey   # Load 'ey' onto the stack
g     # Delete the top of the stack from the end of the 2nd element on the stack if it exists
►y    # Load 'y' onto the stack
g     # Delete the top of the stack from the end of the 2nd element on the stack if it exists
/     # Print the top of the stack
íå    # Load 'face' onto the stack
      # Print with newline is implied as the program exits

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

— Quantum64
स्रोत
मैंने पहले इस भाषा को नहीं देखा है। दिलचस्प लगता है। प्रलेखन है?
— पुनरावर्ती
1
— क्वांटम 64
वाह, यह वास्तव में प्रभावशाली है। खासकर इतने कम विकास के समय के लिए। मैं यह देखने के लिए उत्साहित हूं कि यह कहां जाता है।
— पुनरावर्ती
2

लाल , 143 142 बाइट्स

func[s][s: lowercase s s/1: uppercase s/1
w: copy s if"y"<> last s[append w"y"]rejoin[w" Mc"parse s[collect keep to[opt["y"|"ey"]end]]"face"]]

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

Ungolfed:

f: func[s][
   s: lowercase s                      ; make the entire string lowercase
   s/1: uppercase s/1                  ; raise only its first symbol to uppercase 
   w: copy s                           ; save a copy of it to w
   if "y" <> last s[append w "y"]     ; append 'y' to w if it doesn't have one at its end
   rejoin[w                            ; assemble the result by joining:
          " Mc"
          ; keep the string until "y", "ey" or its end
          parse s[collect keep to [opt ["y" | "ey"] end]]
          "face"
    ]
]
— गैलेन इवानोव
स्रोत
2

PHP: 132

<?php function f($s){$s=ucfirst(strtolower($s));return $s.(substr($s,-1)=='y'?'':'y').' Mc'.preg_replace('/(ey|y)$/','',$s).'face';}

स्पष्टीकरण:

<?php

function f($s)
{
    // Take the string, make it all lowercase, then make the first character uppercase
    $s = ucfirst(strtolower($s));

    // Return the string, followed by a 'y' if not already at the end, then ' Mc'
    // and the string again (this time, removing 'y' or 'ey' at the end), then
    // finally tacking on 'face'.
    return $s
        . (substr($s, -1) == 'y' ? '' : 'y')
        . ' Mc'
        . preg_replace('/(ey|y)$/', '', $s)
        . 'face';
}
— क्रिस Forrence
स्रोत
2

Pyth, 36 34 बाइट्स

++Jrz4*\yqJK:J"e?y$"k+" Mc"+K"face

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

स्पष्टीकरण:

++Jrz4*\yqJK:J"(e)?y$"k+" Mc"+K"face

  Jrz4                                  Set J to the titlecase of z (input)
           K:J"e?y$"k                   Set K to (replace all matches of the regex e?y$ in J with k (empty string))
         qJ                             Compare if equal to J
      *\y                               Multiply by "y" (if True, aka if no matches, this gives "y", else it gives "")
 +                                      Concatenate (with J)
                             +K"face    Concatenate K with "face"
                       +" Mc"           Concatenate " Mc" with that
+                                       Concatenate
— आर।
स्रोत
अफसोस की बात है कि यह काम नहीं करता है, क्योंकि अंतिम परीक्षा का मामला विफल रहता है।
— जकार्इ
अंतिम परीक्षण मामले के लिए ठीक से काम करने के लिए इसे प्राप्त rz3करने के rz4लिए स्विच करें ।
— hakr14
ओह, मैं इसे ठीक कर दूँगा: पी
— आरके।
2

अमृत , 112 110 107 106 बाइट्स

अब जावा जितना छोटा

fn x->x=String.capitalize x;"#{x<>if x=~~r/y$/,do: "",else: "y"} Mc#{String.replace x,~r/e?y$/,""}face"end

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

स्पष्टीकरण:

x=String.capitalize x

xअपरकेस और अन्य सभी लोअरकेस में पहले चरित्र के साथ हो जाता है ।

#{ code }

कोड का मूल्यांकन करें और इसे स्ट्रिंग में डालें।

#{x<>if x=~ ~r/y$/, do: "", else: "y"}

यदि यह समाप्त नहीं होता है (यानी यह रेगेक्स से मेल नहीं खाता है ) के साथ एक्स को समेटता है ।yyy$

#{String.replace x, ~r/e?y$/, "")}

अनुगामी eyऔर अनुगामी को निकालता है y।

— Okx
स्रोत
1

Pyth, 60 59 बाइट्स SBCS

K"ey"Jrz4Iq>2JK=<2J=kK.?=k\yIqeJk=<1J))%." s÷   WZÞàQ"[JkJ

परीक्षण सूट

वे यहाँ प्रदर्शित नहीं है, लेकिन तीन बाइट्स, \x9c, \x82, और \x8cके बीच पैक स्ट्रिंग में हैं sऔर ÷। निश्चिंत रहें, लिंक में वे शामिल हैं।

पायथन 3 अनुवाद: 
K="ey"
J=input().capitalize()
if J[-2:]==K:
    J=J[:-2]
    k=K
else:
    k="y"
    if J[-1]==k:
        J=J[:-1]
print("{}{} Mc{}face".format(J,k,J))
— hakr14
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.