Facey McFaceface

47

Erinnert sich jemand an Boaty ?

Du könntest ein altes Wort schreiben, richtig?

  • Schreiben Sie eine Funktion, um einen String in Somethingy McSomethingface zu verwandeln.
  • Es sollte eine Zeichenfolge als Eingabe akzeptieren. Ignorieren Sie den Fall der Eingabe.
  • Wenn das Wort mit "y" endet, sollte Ihre Funktion der ersten Instanz kein zusätzliches "y" hinzufügen, sondern es in der zweiten Instanz entfernen.
  • Wenn das Wort mit "ey" endet, sollte in der ersten Instanz kein zusätzliches "y" hinzugefügt werden, in der zweiten Instanz sollten jedoch beide entfernt werden.
  • Die Ausgabe sollte nur Großbuchstaben im ersten Zeichen, dem 'M' von 'Mc' und dem ersten Zeichen nach 'Mc' enthalten.
  • Es muss nur mit Zeichenfolgen mit 3 oder mehr Zeichen gearbeitet werden.

Beispiele:

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
quelle
Was ist mit Leerzeichen in der Zeichenfolge? Lassen wir sie intakt? Beispiele: ' y'und' '
— meinen Körper berühren
2
Ich werde einen Vorschlag von @Arnauld implementieren und ihn auf mindestens drei Zeichen beschränken. Behandle Whitespace wie einen anderen Buchstaben.
— AJFaraday
— Kevin Cruijssen
Können wir davon ausgehen, dass die Eingabe nur Groß- und Kleinbuchstaben enthält?
— Kevin Cruijssen
@KevinCruijssen Ich habe keine Buchstaben in die Testfälle eingefügt, sie sind also praktisch nicht betroffen.
— AJFaraday

Antworten:

7

Stax , 26 Bytes

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

Führen Sie es aus und debuggen Sie es

^           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

Führen Sie dieses aus

— rekursiv
quelle
15

V , 27 28 30 Bytes

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

Probieren Sie es online!

<Esc> repräsentiert 0x1b

  • Golfed zwei Bytes nach dem Lernen, dass wir Eingaben mit weniger als 3 Zeichen nicht unterstützen mussten.

  • Dank @DJMcMayhem wird 1 Byte gespart, indem in der zweiten Zeile vor der ersten gearbeitet wird, wodurch die entfernt wird G

Die Eingabe erfolgt im Puffer. Das Programm konvertiert zunächst alles in Kleinbuchstaben

VWählt die Linie aus und setzt usie in die untere Zeile

~ Schaltet die Groß- / Kleinschreibung des ersten Zeichens um (konvertiert es in Großbuchstaben)

und Ùdupliziert diese Zeile oben, wobei sich der Cursor in der untersten Zeile befindet

óund ersetzt e¿y$, komprimierte Form von e\?y$(optional eund a yam Ende der Zeile), mit nichts (geschieht in der zweiten Zeile)

H geht in die erste Zeile

ówird y$( yam Ende der Zeile) durch nichts in der ersten Zeile ersetzt

ÁFügt ein yan das Ende der ersten Zeile an

J und verbindet die letzte mit der ersten Zeile mit einem Leerzeichen in der Mitte, und der Cursor wird auf dieses Leerzeichen bewegt

ahängt an Mc( <Esc>kehrt zum normalen Modus zurück)

Awird schließlich faceam Ende der Zeile angehängt

— Kritixi Lithos
quelle
— DJMcMayhem
13

Python, 144 Bytes

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

Probieren Sie es hier online aus

— berühre meinen Körper
quelle
2
Mein allererster Code Golf Versuch ...
— Berühre meinen Körper
3
Willkommen bei PPCG! könnte ich vorschlagen, einen Link zu Try it Online hinzuzufügen ! zur Überprüfung der Richtigkeit?
— Giuseppe
1
f("Face")entspricht nicht den aktuellen Testfällen ( TIO ).
— Jonathan Frech
Der Beitrag wurde aus Gründen der Korrektheit bearbeitet. Außerdem wurde ein Online-Test hinzugefügt. link
— touch my body
1
— Totalhuman
12

Excel, 204 144 137 165 Bytes

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

Von innen nach außen:

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

Alte Antwort, alle Bits separat erstellen und dann verketten (176 Bytes). Behandelt durch Leerzeichen begrenzte Fälle nicht korrekt.

=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
quelle
Leider ist aufgrund der Anforderung der Behandlung von durch Leerzeichen begrenzten Fällen PROPER(A1)(siehe DJ Grand Master FlashEingabefall) der beste Ersatz, den ich bei der Arbeit an meiner VBA-Lösung finden konnte , ungültig LEFT(UPPER(A1))&MID(LOWER(A1),2,LEN(A1))- lassen Sie es mich bitte wissen, wenn Sie am Ende Golf spielen.
— Taylor Scott
1
Vielen Dank an TaylorScott. Es wurde "REPLACE (LOWER (A1), 1,1, UPPER (LEFT (A1))" gefunden, was 2 Byte kürzer ist.
— Wernisch
9

C # (.NET Core) , 122 108 139 175 180 179 154 Bytes

Vielen Dank, Lee!

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

Probieren Sie es online!

C # (.NET Core, mit LINQ), 152 Byte

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

Probieren Sie es online!

— Anderson Pimentel
quelle
3
Willkommen auf der Seite! :)
— DJMcMayhem
7

Ruby , 61 49 Bytes

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

Probieren Sie es online!

12 süße Bytes dank @MartinEnder gespeichert:

— iamnotmaynard
quelle
1
Mit dem regulären Ausdruck meiner Retina Antwort und ein bisschen mehr Einsatz von String - Interpolation machen wird diese bis auf 49: tio.run/##DcxBCsIwEEDRqwxJBF3Y4lpSN0U3igcQwTQmGFptMVNkTOLVY3bvb/...
— Martin Ender
@MartinEnder Wow, das ist ein ziemlicher Unterschied. Ich glaube nicht, dass ich eine String-Interpolation ohne Klammern gesehen habe. Ich nehme es, wenn Sie es nicht für Ihre eigene Ruby-Antwort verwenden möchten.
— Iamnotmaynard
Nein, es ist in Ordnung, ich hätte mir nicht ausgedacht, =~die ganze Saite zu benutzen und zu bauen, anstatt sie zu benutzen sub. Die String-Interpolation kann ohne eckige Klammern verwendet werden, wenn die Variable eine globale Variable, eine Instanzvariable oder eine Klassenvariable ist.
— Martin Ender
Sie können diese bis zu 44 + 1 Bytes erhalten , indem die Verwendung von -pFlagge und mit sub: tio.run/...
— Jordan
5

Java 8, 121 112 107 106 Bytes

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

-1 Byte danke an @ OliverGrégoire .

Erläuterung:

Probieren Sie es online aus.

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"
— Kevin Cruijssen
quelle
Was ist, wenn das erste Zeichen nicht alphabetisch ist? Oder vielleicht können wir eine Regel hinzufügen ..
— Streetster
1
@streetster Habe gerade nach OP gefragt und es scheint, dass die Eingabe nur Groß- und / oder Kleinbuchstaben enthält.
— Kevin Cruijssen
1
~32-> 95für 1 Byte gespeichert
— Olivier Grégoire
@ OlivierGrégoire Ich muss wirklich anfangen, ein bisschen mehr über bitweise Operationen zu lernen ..>.>
— Kevin Cruijssen
4

JavaScript, 103 96 94 Bytes

Ziemlich naiv erster Versuch.

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

Probieren Sie es online aus

— Zottelig
quelle
s =>${s=s[0].toUpperCase()+s.slice(1).toLowerCase().replace(/y$/,``)}y Mc${s.replace(/e?y$/,``)}face
— Benjamin Gruenbaum
Eins weniger: s =>${s=s[0].toUpperCase()+s.slice(1).toLowerCase().replace(/y$/,'')}y Mc${s.replace(/e$/,``)}face
— Benjamin Gruenbaum
Danke, @BenjaminGruenbaum, aber der erste schlägt fehl Donkeyund der zweite für Face.
— Shaggy
Der Abschlag
— Benjamin Gruenbaum
@ Shaggy Ich habe es geschafft, die g-Funktion um einige Zeichen zu reduzieren :). Sie können in meiner Lösung suchen
— DanielIndie
3

vim, 35 34 bytes

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

<ESC> ist 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

Probieren Sie es online!

1 Byte dank DJMcMayhem gespeichert

— Strahl
quelle
1
Sie können Yanstelle vonyy
— DJMcMayhem
3

C ++ 14 (g ++), 181 171 148 147 134 Bytes

[](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";}

Beachten Sie, dass Clang dies nicht kompiliert.

Der Trick geht an Kevin Cruijssen und Olivier Grégoire&95 .

Vielen Dank an Chris für das Golfen mit 11 Bytes.

Probieren Sie es hier online aus .

Ungolfed-Version:

[] (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
quelle
Ich kenne C ++ nicht so gut, aber Sie können 9 Bytes Golf spielen: Probieren Sie es online 172 Bytes. Zusammenfassung der Änderungen: s[0]=s[0]&~32;bis s[0]&=~32;; s[i++]=s[i]|32;zu s[i++]|=32; und int i=1,n=s.length()-1,b;so brauchst du nur 1 int.
— Kevin Cruijssen
Oh, und noch ein Byte durch Entfernen des Leerzeichens bei#include<string>
— Kevin Cruijssen
@ KevinCruijssen danke für den Fang! Ich habe bearbeitet.
— Bilanz
Sie können 11 Bytes einsparen, nindem Sie den Wert inach der while-Schleife nicht definieren und nur verwenden . Probieren Sie es online!
— Chris
@ Chris Danke! Ich habe es geschafft, 2 weitere Bytes zu entfernen.
— Bilanz
2

V , 38 36 32 Bytes

-5 byte dank @Cows quack

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

<esc>ist ein buchstäbliches Escapezeichen und [^wird als codiert\x84

Probieren Sie es online!

— Herman L
quelle
gu$kann werdenVu
— Kritixi Lithos
2
Da [^es sich um eine Regex-Verknüpfung handelt (siehe hier ), können Sie 0x84 verwenden, anstatt [^ein Byte zu speichern. Ebenso \?kann vereinfacht ein <M-?>weiteres Byte eingespart werden. Und $a=>A
— Kritixi Lithos
2

Python 3 , 117 114 Bytes

-3 Bytes dank Dead Possum

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'

Probieren Sie es online!

— Dat
quelle
Das dritte Element der Liste [s,s[:-1],'',s[:-2]kann geändert werden 0, um 1 Byte zu speichern.
— Dead Possum
In 'y'*1 *1wird nicht benötigt. 2 weitere Bytes
— Dead Possum
Das Wechseln von Python 3 zu Python 2 und das Ersetzen returndurch printist 1 Byte kürzer.
— Kevin Cruijssen
2

JavaScript (Node.js) , 87 Byte

  • danke an @Shaggy für 5 reduzierende 5 bytes
s=>(g=r=>Buffer(s.replace(r,"")).map((x,i)=>i?x|32:x&~32))(/y$/)+`y Mc${g(/e?y$/)}face`

Probieren Sie es online!

— DanielIndie
quelle
2
Sie müssen keine nicht rekursiven Funktionen benennen.
— Dennis
1
Schön gemacht. Ich denke nie daran, es zu benutzen Buffer, ich werde versuchen müssen, es für zukünftige Herausforderungen in Erinnerung zu behalten. Ich habe es auf 87 Bytes reduziert.
— Shaggy
2

K4 , 74 69 68 Bytes

Lösung:

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

Beispiele:

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"

Erläuterung:

Finden Sie heraus, ob die letzten Zeichen gleich "ey"sind. Konvertieren Sie das Ergebnis in Basis-2, damit wir Wörter, die enden, ignorieren können "e?". Indexieren Sie eine Liste mit der Anzahl der zu trimmenden Zeichen.

Es ist mir gelungen, 5 Bytes meines Codes zu sparen "ey", um festzustellen, ob die letzten beiden Zeichen nicht besser sind ...

{$[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)

Bonus:

67-Byte- Port in K (OK) :

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

Probieren Sie es online!

— Streetster
quelle
1
Was nützt der K4, wenn Ihr OK-Port ihn besiegt?
— Zacharý
Ich hätte es nicht gedacht, und der Port funktioniert nicht, wenn das erste Zeichen nicht alphabetisch ist, da ich blind 32 vom ASCII-Wert subtrahiere - es ist kein "oberes" eingebaut.
— Streetster
2

Ruby , 69 Bytes

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

Erläuterung:

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

Probieren Sie es online!

— dkudriavtsev
quelle
Könnten Sie einen TIO-Link hinzufügen? Ich kenne Ruby nicht, aber s.capitalizeersetzt es das vorherige s? Wenn nicht, wird /e?y$/ein Testfall Y, der EYmit oder endet , Eykorrekt behandelt?
— Kevin Cruijssen
1
@ KevinCruijssen s.capitalizevs s.capitalize!(verschiedene Funktionen). s.capitalize!verstopft die alte Version.
— Dkudriavtsev
@ KevinCruijssen Ich habe einen TIO-Link hinzugefügt.
— Dkudriavtsev
@ KevinCruijssen Auch eine Erklärung hinzugefügt
— dkudriavtsev
Ah ok, danke für die Erklärung und die Information über s.capitalize!. Nie in Ruby programmiert, aber das Hinzufügen eines Erklärungszeichens, um den vorherigen Wert zu ersetzen, ist ziemlich cool. +1 von mir.
— Kevin Cruijssen
2

JSTX , 27 Byte

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

Erläuterung

      # 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

Probieren Sie es online!

— Quantum64
quelle
Ich habe diese Sprache noch nie gesehen. Es sieht interessant aus. Gibt es Unterlagen?
— rekursive
1
— Quantum64
Wow, das ist wirklich beeindruckend. Vor allem für so wenig Entwicklungszeit. Ich bin gespannt, wohin das führt.
— rekursive
2

Rot , 143 142 Bytes

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

Probieren Sie es online!

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"
    ]
]
— Galen Ivanov
quelle
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';}

Erläuterung:

<?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';
}
— Chris Forrence
quelle
2

Jelly , 77 75 74 73 Bytes

2ḶNṫ@€⁼"“y“ey”S
ØA;"ØaF
¢y⁸µ¢Uyµ1¦
Çṫ0n”yẋ@”y;@Ç;“ Mc”
⁸JU>ÑTị3Ŀ;@Ç;“face

Probieren Sie es online!

Anregungen zum Golfen sind willkommen (und erwünscht)!

— Zacharý
quelle
2

Pyth, 36 34 Bytes

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

Probieren Sie es online!

Erläuterung:

++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
— RK.
quelle
Leider funktioniert dies nicht, da der letzte Testfall fehlschlägt.
— Zacharý
Wechseln Sie rz3zu rz4, damit dies für den letzten Testfall ordnungsgemäß funktioniert.
— hakr14
Oh hoppla, ich werde das beheben: P
— RK.
2

Elixir , 112 110 107 106 Bytes

jetzt so kurz wie java

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

Probieren Sie es online!

Erläuterung:

x=String.capitalize x

Ruft xdas erste Zeichen in Großbuchstaben und alle anderen in Kleinbuchstaben ab.

#{ code }

Bewerten Sie den Code und fügen Sie ihn in die Zeichenfolge ein.

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

Verkettet x mit, ywenn es nicht mit endet y(dh es stimmt nicht mit dem regulären Ausdruck überein y$).

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

Entfernt Trailing eyund Trailing y.

— Okx
quelle
1

Pyth, 60 59 Bytes SBCS

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

Testsuite

Sie zeigen nicht hier, sondern drei Bytes \x9c, \x82und \x8csind in dem gepackten String zwischen sund ÷. Seien Sie versichert, der Link enthält sie.

Python 3 Übersetzung: 
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
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.