Facey McFaceface

47

Quelqu'un se souvient de Boaty ?

Vous pouvez totalement faire un vieux mot, non?

  • Ecrivez une fonction pour transformer une chaîne en Somethingy McSomethingface.
  • Il devrait accepter une chaîne en entrée. Ignorer la casse de l'entrée.
  • Si le mot se termine par "y", votre fonction ne doit pas ajouter de "y" supplémentaire à la première instance, mais doit la supprimer à la seconde instance.
  • Si le mot se termine par 'ey', il ne devrait pas avoir un 'y' supplémentaire ajouté dans le premier cas, mais devrait supprimer les deux dans le second cas.
  • La sortie ne doit comporter que des lettres majuscules dans le premier caractère, le «M» de «Mc» et le premier caractère après «Mc».
  • il ne doit fonctionner qu'avec des chaînes de 3 caractères ou plus.

Exemples:

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
source
Qu'en est-il des espaces dans la chaîne, est-ce qu'on les laisse intacts? Exemples: ' y'et' '
— touchez mon corps
2
Je vais implémenter une suggestion de @Arnauld et en faire un minimum de trois caractères. Traitez les espaces comme une autre lettre.
— AJFaraday
— Kevin Cruijssen
Peut-on supposer que l'entrée ne contiendra que des lettres majuscules et minuscules?
— Kevin Cruijssen
@KevinCruijssen Je n'ai pas mis de lettres dans les cas de test, ils ne sont donc pas concernés.
— AJFaraday

Réponses:

7

Stax , 26 octets

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

Exécuter et déboguer

^           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

Exécuter celui-ci

— récursif
source
15

V , 27 28 30 octets

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

Essayez-le en ligne!

<Esc> représente 0x1b

  • Golfé deux octets après avoir appris que nous n’avions pas besoin de prendre en charge les entrées de moins de 3 caractères.

  • 1 octet économisé grâce à @DJMcMayhem en travaillant sur la deuxième ligne avant la première, supprimant ainsi la G

L'entrée est dans le tampon. Le programme commence par convertir tout en minuscule

Vsélectionne la ligne et la met en uminuscule

~ fait basculer la casse du premier caractère (en le convertissant en majuscule)

et Ùduplique cette ligne ci-dessus, en laissant le curseur sur la dernière ligne

óet remplace e¿y$, forme comprimée de e\?y$(facultatif eet a yà la fin de la ligne), avec rien (passe sur la deuxième ligne)

H va à la première ligne

óremplace y$( yen fin de ligne) sans rien sur la première ligne

Áajoute un yà la fin de la première ligne

J et joint la dernière ligne avec la première avec un espace au milieu, et le curseur est déplacé vers cet espace

aajoute Mc( <Esc>retourne en mode normal)

Aenfin, ajoute faceau bout de la ligne

— Kritixi Lithos
source
— DJMcMayhem
13

Python, 144 octets

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

Essayez-le en ligne ici

— touche mon corps
source
2
ma première tentative de golf de code ...
— touche mon corps
3
Bienvenue chez PPCG! Puis-je suggérer d'ajouter un lien pour l' essayer en ligne! pour la vérification de l'exactitude?
— Giuseppe
1
f("Face")n'est pas conforme aux cas de test actuels ( TIO ).
— Jonathan Frech
Edited post pour la correction, a également ajouté un Try It Online! lien
— touchez mon corps
1
— totalement humain
12

Excel, 204 144 137 165 octets

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

De l'intérieur vers l'extérieur:

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

Ancienne réponse, créant tous les bits séparément, puis concaténant (176 octets). Ne gère pas correctement les cas délimités par des espaces.

=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
source
Malheureusement, en raison de la nécessité de traiter les cas délimités par des espaces, elle PROPER(A1)est invalide (voir le DJ Grand Master Flashcas de saisie), le meilleur remplaçant que je pouvais trouver en travaillant sur ma solution VBA était LEFT(UPPER(A1))&MID(LOWER(A1),2,LEN(A1))- faites-le-moi savoir si vous échouez à jouer au golf.
— Taylor Scott
1
Merci @TaylorScott. Trouvé 'REMPLACE (LOWER (A1), 1,1, UPPER (LEFT (A1))) »qui est plus court de 2 octets.
— Wernisch
9

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

Merci beaucoup, 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("$","");

Essayez-le en ligne!

C # (.NET Core, avec LINQ), 152 octets

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

Essayez-le en ligne!

— Anderson Pimentel
source
3
Bienvenue sur le site! :)
— DJMcMayhem
7

Ruby , 61 49 octets

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

Essayez-le en ligne!

12 doux octets sauvés grâce à @MartinEnder:

— Rétablir Monica iamnotmaynard
source
1
En utilisant l'expression rationnelle de ma réponse Retina et de faire un peu plus l' utilisation de l' interpolation de chaîne obtient cela à 49: tio.run/##DcxBCsIwEEDRqwxJBF3Y4lpSN0U3igcQwTQmGFptMVNkTOLVY3bvb/...
— Martin Ender
@MartinEnder Wow, c'est toute une différence. Je ne pense pas avoir vu l'interpolation de chaîne sans crochets. Je vais le prendre si vous ne voulez pas l'utiliser pour votre propre réponse Ruby.
— Rétablir Monica iamnotmaynard
Nah, c'est bon, je n'aurais pas imaginé utiliser =~et construire la chaîne entière au lieu d'utiliser sub. L'interpolation de chaîne peut être utilisée sans crochets si la variable est une variable globale, d'instance ou de classe.
— Martin Ender
Vous pouvez le réduire à 44 + 1 octets en utilisant le -pdrapeau et en utilisant sub: tio.run/…
— Jordanie
5

Java 8, 121 112 107 106 octets

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

-1 octet grâce à @ OliverGrégoire .

Explication:

Essayez-le en ligne.

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
source
Et si le premier caractère n'est pas alphabétique? Ou peut-être pourrions-nous ajouter une règle à ce sujet ...
— streetster Le
1
@streetster Vient de demander à OP, et il semble que l'entrée ne contienne que des lettres majuscules et / ou minuscules.
— Kevin Cruijssen
1
~32-> 95pour 1 octet enregistré
— Olivier Grégoire
@ OlivierGrégoire Il faut vraiment que je commence à en apprendre un peu plus sur les opérations binaires ..>.>
— Kevin Cruijssen
4

JavaScript, 103 à 96 94 octets

Première passe assez naïve à cela.

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

Essayez-le en ligne

— Hirsute
source
s =>${s=s[0].toUpperCase()+s.slice(1).toLowerCase().replace(/y$/,``)}y Mc${s.replace(/e?y$/,``)}face
— Benjamin Gruenbaum Le
Un de moins: s =>${s=s[0].toUpperCase()+s.slice(1).toLowerCase().replace(/y$/,'')}y Mc${s.replace(/e$/,``)}face
— Benjamin Gruenbaum
Merci, @BenjaminGruenbaum, mais le premier échoue Donkeyet le second échoue Face.
— Shaggy
— Benjamin Gruenbaum
@Shaggy j'ai réussi à réduire la fonction g de quelques caractères :). vous pouvez regarder dans ma solution
— DanielIndie
3

vim, 35 34 octets

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

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

Essayez-le en ligne!

Enregistré 1 octet grâce à DJMcMayhem

— Rayon
source
1
Vous pouvez faire Yau lieu deyy
— DJMcMayhem
3

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

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

Notez que clang ne compilera pas ceci.

Le crédit va à Kevin Cruijssen et Olivier Grégoire pour la&95 affaire.

Merci à Chris avoir joué au golf 11 octets.

Essayez-le en ligne ici .

Version non-golfée:

[] (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
source
Je ne connais pas très bien le C ++, mais vous pouvez jouer au golf 9 octets: essayez-le en ligne 172 octets. Résumé des modifications: s[0]=s[0]&~32;to s[0]&=~32;; s[i++]=s[i]|32;à s[i++]|=32; et int i=1,n=s.length()-1,b;vous n'avez donc besoin que de 1 int.
— Kevin Cruijssen
Oh, et encore un octet en supprimant la place de#include<string>
— Kevin Cruijssen
@KevinCruijssen merci d'avoir attrapé ça! J'ai édité.
— OOBalance
Vous pouvez enregistrer 11 octets en ne définissant pas net en utilisant simplement la valeur de iafter the while loop. Essayez-le en ligne!
— Chris
@ Chris Merci! J'ai réussi à raser 2 octets de plus.
— OOBalance
2

V , 38 36 32 octets

-5 octets grâce à @Cows Quack

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

<esc>est un caractère d'échappement littéral et [^est codé comme\x84

Essayez-le en ligne!

— Herman L
source
gu$peut devenirVu
— Kritixi Lithos
2
Étant donné qu’il [^s’agit d’un raccourci regex (voir ici ), vous pouvez utiliser 0x84 au lieu de [^pour enregistrer un octet. De même, \?peut être simplifié <M-?>pour enregistrer un autre octet. Et $a=>A
— Kritixi Lithos
2

Python 3 , 117 114 octets

-3 octets grâce à 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'

Essayez-le en ligne!

— Dat
source
Le 3ème élément de la liste [s,s[:-1],'',s[:-2]peut être changé 0pour sauvegarder 1 octet.
— Dead Possum
En 'y'*1 *1n'est pas nécessaire. 2 octets de plus
— Dead Possum
Passer de Python 3 à Python 2 et le remplacer returnpar printun octet est plus court.
— Kevin Cruijssen
2

JavaScript (Node.js) , 87 octets

  • grâce à @Shaggy pour 5 réduction de 5 octets
s=>(g=r=>Buffer(s.replace(r,"")).map((x,i)=>i?x|32:x&~32))(/y$/)+`y Mc${g(/e?y$/)}face`

Essayez-le en ligne!

— DanielIndie
source
2
Vous n'êtes pas obligé de nommer des fonctions non récursives.
— Dennis
1
Bien fait. Je ne pense jamais utiliser Buffer, devra essayer de s'en souvenir pour les défis futurs. Je l'ai eu à 87 octets pour vous.
— Shaggy
2

K4 , 74 69 68 octets

Solution:

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

Exemples:

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"

Explication:

Déterminez si les derniers caractères sont égaux "ey", convertissez le résultat en base 2 afin d'ignorer les mots qui se terminent "e?". Index dans une liste de nombres de caractères à couper.

J'ai réussi à supprimer 5 octets de mon code pour déterminer si les deux derniers caractères étaient à, "ey"mais peinaient à l'améliorer ...

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

Prime:

Port de 67 octets à K (oK) :

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

Essayez-le en ligne!

— streetster
source
1
Quel est le point dans le K4 si votre port oK le bat?
— Zacharý
Je ne pensais pas que ce serait le cas, et le port ne fonctionne pas si le premier caractère n'est pas alphabétique, car je soustrais aveuglément 32 de la valeur ASCII - il n'y a pas d'intégré "supérieur".
— streetster
2

Ruby , 69 octets

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

Explication:

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

Essayez-le en ligne!

— dkudriavtsev
source
Pourriez-vous ajouter un lien TIO? Je ne connais pas Ruby, mais s.capitalizeremplace-t-il le précédent s? Dans la négative, /e?y$/gère un test se terminant par Y, EYou Eybien?
— Kevin Cruijssen
1
@KevinCruijssen s.capitalizevs s.capitalize!(fonctions différentes). s.capitalize!clobbers l'ancienne version.
— dkudriavtsev
@KevinCruijssen J'ai ajouté un lien TIO.
— dkudriavtsev
@KevinCruijssen a également ajouté une explication
— dkudriavtsev
Ah ok, merci pour l'explication et les informations sur s.capitalize!. Jamais programmé en Ruby, mais ajouter un repère explicatif pour remplacer la valeur précédente est plutôt cool. +1 de moi.
— Kevin Cruijssen
2

Jstx , 27 octets

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

Explication

      # 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

Essayez-le en ligne!

— Quantum64
source
Je n'ai pas vu cette langue avant. Ça a l'air intéressant. Y a-t-il de la documentation?
— récursif
1
— Quantum64
Wow, c'est vraiment impressionnant. Surtout pour si peu de temps de développement. Je suis excité de voir où cela va.
— récursive
2

Rouge , 143 142 octets

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

Essayez-le en ligne!

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
source
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';}

Explication:

<?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
source
2

Gelée , 77 75 74 73 octets

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

Essayez-le en ligne!

Toutes les suggestions de golf sont les bienvenues (et recherchées)!

— Zacharý
source
2

Pyth, 36 34 octets

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

Essayez-le en ligne!

Explication:

++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.
source
Malheureusement, cela ne fonctionne pas, car le dernier cas de test échoue.
— Zacharý
Basculez rz3sur rz4pour que cela fonctionne correctement pour le dernier cas de test.
— hakr14
Oh oups, je vais arranger ça: P
— RK.
2

Elixir , 112 110 107 106 octets

maintenant aussi court que java

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

Essayez-le en ligne!

Explication:

x=String.capitalize x

Obtient xavec le premier caractère en majuscule et tous les autres en minuscules.

#{ code }

Évaluez le code et insérez-le dans la chaîne.

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

Concatène x avec ys'il ne se termine pas par y(c.-à-d. Qu'il ne correspond pas à l'expression régulière y$).

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

Supprime les traînées eyet les traînées y.

— Okx
source
1

Pyth, 60 59 octets SBCS

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

Suite de tests

Ils ne présentent pas ici, mais trois octets, \x9c, \x82et \x8csont dans la chaîne tassée entre set÷ . Rassurez-vous, le lien les inclut.

Traduction Python 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
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.