Il existe deux formes de noms, singulier et pluriel. La conversion entre ces deux est assez facile.

1. Normalement, vous y mettez fin s. ex. car=> cars.

2. Si elle se termine par s, x, z, chou sh, fin avec es. ex. bus=> buses.

3. S'il se termine par yune consonne juste avant, changez le ypar ies. ex. penny=> pennies.

4. S'il se termine par fou fe, remplacez-le par ves. ex. knife=> knives.

5. S'il se termine par oune consonne juste avant, changez-la en oes. ex. potato=> potatoes.

Tâche

Vous recevrez un nom singulier. Vous devez convertir le nom donné au pluriel et le sortir.

Règles

• Vous ne recevrez pas de noms irréguliers, comme mouseet moose.

• Vous ne recevrez pas d'exceptions, telles que safe( safes; violation # 4), piano( pianos; violation # 5) et o( oes, violation # 5).

• Vous ne recevrez pas de mots qui ont deux ou plusieurs formes plurielles possibles, telles que mosquito( mosquitosou mosquitoes) et roof( roofsou rooves).

• On ne vous donnera pas de noms innombrables.

• y ne compte pas comme une voyelle.

Exemples

car => cars
bus => buses
potato => potatoes
knife => knives
penny => pennies
exception => exceptions
wolf => wolves
eye => eyes
decoy => decoys
radio => radios

Mathematica, 9 octets

Pluralize

Oui, il y a une fonction intégrée pour cela!

Exemple de sortie

Pluralize["car"]

cars

Pluralize /@ {"bus", "potato", "knife", "penny", "exception", "wolf", "eye"}

{"buses", "potatoes", "knives", "pennies", "exceptions", "wolves", "eyes"}

Rétine , 57 53 56 55 58 57 octets

Merci à MartinEnder pour quelques suggestions de golf

Merci à BusinessCat pour avoir joué au golf 1 octet

([^aeiou]o|sh?|ch|z|x)$
$1e
fe?$
ve
([^aeiou])y$
$1ie
$
s

Essayez-le en ligne!

Explication (obsolète)

([^aeiou])y$
$1ie

Modifications apportées {consonant}yà{consonant}ie

([^aeiou]o|[fxzs]|[sc]h)$
$&e

Ajoute un equand les extrémités de mots avec un {consonant}o, f, x, z, s, shou ch.

fe$
ve

Remplace une fin feparve

$
s

Enfin, ajoutez un sau mot.

Modifications

• Octets ajoutés car j'ai oublié la deuxième règle
• Octets ajoutés pour mettre à jour avec eyecomme exemple

JavaScript (ES6),  109  97 octets

s=>s[R='replace'](/([^aeiou])y$/,'$1ie')[R](/fe?$/,'ve')[R](/([^aeiou]o|[sxz]|[cs]h)$/,'$1e')+'s'

Essayez-le en ligne!

Lot, 325 octets

@set/ps=
@for %%v in (a e i o u)do @(
for %%e in (o y)do @if %s:~-2%==%%v%%e goto s
if %s:~-2%==%%vf set s=%s:~,-1%ve&goto s
if %s:~-3%==%%vfe set s=%s:~,-2%ve&goto s
)
@if %s:~-1%==y set s=%s:~,-1%ie
@for %%e in (o s x z)do @if %s:~-1%==%%e set s=%s%e
@for %%e in (c s)do @if %s:~-2%==%%eh set s=%s%e
:s
@echo %s%s

Haskell, 216 207 205 octets

Merci à @Lynn, @ user1472751 et @Laikoni pour l'aide!

import Data.List
(!)s=or.map(\x->x`isSuffixOf`s)
c=['b'..'z']\\"eiou"
p s|s!(words"s x z ch sh"++map(:"o")c)=s++"es"|s!map(:"y")c=init s++"ies"|s!["f"]=init s++"ves"|s!["fe"]=(init.init)s++"ves"|0<1=s++"s"

Lisible

import Data.List;

endsWithOneOf :: String -> [String] -> Bool
endsWithOneOf str ends = (or . map (\end -> end `isSuffixOf` str)) ends 

consonants :: [Char]
consonants = ['a'..'z'] \\ "aeiou"

pluralize :: String -> String
pluralize str
    | str `endsWithOneOf` (words "s x z ch sh" ++ (map (:"o") consonants)) = str ++ "es"
    | str `endsWithOneOf` (map (:"y") consonants) = init str ++ "ies"
    | str `endsWithOneOf` ["f"] = init str ++ "ves"
    | str `endsWithOneOf` ["fe"] = (init.init) str ++ "ves"
    | otherwise = str ++ "s"

Explication

import Data.Listpour la fonction isSuffixOf. endsWithOneOf( €dans la version golfée) renvoie si l'un des éléments de la liste est une fin de la chaîne. consonants(c)est juste une liste de toutes les consonnes.

Enfin, pluralize(p)vérifie les terminaisons et renvoie la pluralisation appropriée.

Exemple:

p "potato" == "potatoes"

Perl, 66 + 2 ( -plindicateur) = 68 octets

$_.=/(ch|sh?|x|z|[^aeiou]o)$/+s/([^aeiou])y$/$1i/+s/fe?$/v/?es:"s"

En utilisant:

perl -ple '$_.=/(ch|sh?|x|z|[^aeiou]o)$/+s/([^aeiou])y$/$1i/+s/fe?$/v/?es:"s"' <<< car

Essayez-le sur Ideone.

Röda , 80 octets

f&s{s~="([^aeiou])y$","$1ie","([sxz]|[cs]h|[^aeiuo]o)$","$1e","fe?$","ve"s.="s"}

La fonction modifie son argument. Utilisation: main word { f word; print word }voici une version qui utilise une valeur de retour (83 octets):

f s{s~="([^aeiou])y$","$1ie","([sxz]|[cs]h|[^aeiuo]o)$","$1e","fe?$","ve";[s.."s"]}

Et ci-dessous est une fonction qui lit une infinité de valeurs du flux d'entrée et pousse plusieurs formes vers le flux de sortie ( 87 83 octets):

{replace"([^aeiou])y$","$1ie","([sxz]|[cs]h|[^aeiuo]o)$","$1e","fe?$","ve","$","s"}

C'est une fonction anonyme, car elle est plus courte que la création d'une fonction nommée.

PHP, 103 100 octets

<?=preg_replace(['/([^aeiou]o|sh?|x|z|ch)$/','/(?<![aeiou])y$/','/fe?$/'],['\1e',ie,ve],$argv[1]).s;

Essayez-le en ligne!

La preg_replacefonction prend dans un tableau de modèles et de remplacements.

• Enregistré 2 octets grâce à Titus.
• Enregistré 1 octet grâce à Dewi Morgan.

Python 3, 271 239 199 octets

Merci à @ovs de l'avoir réduit de 72 octets!

lambda s,v="aeiou":(s[-2:]=="fe"and s[:-2]+"ve"or s[:-1]+((s[-1]=="y"and s[-2]not in v)*"ie"or s[-1]=="f"and"ve"or s[-1]+((s[-1]in"sxz"or s[-2:]in["ch","sh"])+(s[-1]=="o"and s[-2]not in v))*"e"))+"s"

Essayez-le en ligne!

sed, 70 79 octets

69 78 + 1 pour le drapeau -E(BSD) / -r(GNU)

s/([^aeiou])y$/\1ie/
s/([^aeiou]o|[fxzs]|[sc]h)$/&e/
s/fe/ve/
s/$/s/

Port direct de la réponse rétinienne .

Pip , 63 61 octets

Y`[^aeiou]`OaR[C`sh?|x|z|ch`Cy.'y`fe?`y.'o].'$[_B.'i'v_].'e's

Si près d'attraper la rétine! Mais cela n'arrivera probablement pas. :(

Essayez-le en ligne!

Explication

Stratégie de base: Replace effectue plusieurs remplacements les uns après les autres lorsque des listes de modèles et de remplacements sont fournies. Nous voulons effectuer les remplacements suivants:

• (sh?|x|z|ch)$ -> ajouter un e
• [^aeiou]y-> changez le yen iet ajoutez une
• fe?-> modifier vet ajouter une
• [^aeiou]o -> ajouter un e

Ensuite, nous voulons aborder un speu importe.

Des trucs:

• L' Copérateur, étant donné une expression régulière, l'enveloppe dans un groupe de capture; C`xyz`est un octet plus court que `(xyz)`.
• Une liste d'expressions régulières ou de remplacements qui se terminent tous par le même caractère peut être créée en concaténant le personnage à la liste au lieu de l'inclure dans tous les éléments. La concaténation d'un scalaire (chaîne) à un motif (regex / remplacement) contraint à un motif.
• Au lieu de concaténer le s(et d'avoir à traiter l'ordre de priorité de Ret .), nous pouvons simplement Oémettre la partie principale du mot puis l'imprimer sséparément.

Code espacé et commenté:

                  a is 1st cmdline input (implicit)
Y`[^aeiou]`       Yank the consonant regex into the y variable
O a R             Output (without newline): a, with the following replacements:
 [                List of regexes to replace:
  C `sh?|x|z|ch`    (sh?|x|z|ch)
  Cy . 'y           ([^aeiou])y
  `fe?`             fe?
  y . 'o            [^aeiou]o
 ] . '$           End of list; concatenate $ to each item
 [                List of replacements:
  _                 Identity function (replace with whole match)
  B                 B is short for {b}, a function returning its second argument; as a
                    callback function for regex replacement, the second argument is
                    the value of capturing group 1 (the consonant before y)
    . 'i            To that, concatenate i
  'v                Scalar literal v
  _                 Identity function
 ] . 'e           End of list; concatenate e to each item
's                Return Scalar literal s, which is autoprinted

C #, 73 163 octets:

Func<string,string>p=System.Data.Entity.Design.PluralizationServices.PluralizationService.CreateService(System.Globalization.CultureInfo.CurrentCulture).Pluralize

Oui, une autre langue avec elle intégrée (bien que vous deviez ajouter une référence System.Data.Entity.Design.dll)

Utiliser:

var words = new[] { "car", "bus", "potato", "knife", "penny", "exception", "wolf", "eye", "decoy", "radio" };
foreach (var word in words)
{
    var plural = p(word);
    Console.Out.WriteLine($"{word} => {plural}");
}

Sortie:

car => cars
bus => buses
potato => potatoes
knife => knives
penny => pennies
exception => exceptions
wolf => wolves
eye => eyes
decoy => decoys
radio => radios

Python 199 187 176 176 octets

lambda s:s+'\bve'*(s[-1]=='f')+'\b\bve'*(s[-2:]=='fe')+'e'*(s[-1]in'sxz'or s[-2:]in('ch','sh')or s[-1]=='o'and s[-2]not in'aiueo')+'\bie'*(s[-1]=='y'and s[-2]not in'aiueo')+'s'

Rails runner, 18 octets

$><<gets.pluralize

Exemple:

$ echo knife | rails r filename.rb
knives

Python, 296 octets

z = input()
if z[-1]in['s','x','z','ch','sh']:print(z+'es')
elif z[-1]=='y'and z[-2]not in['a','e','i','o','u']:print(z[:-1]+'ies')
elif z[-2:]=='fe':print(z[:-2]+'ves')
elif z[-1]=='f':print(z[:-1]+'ves')
elif z[-1]=='o'and z[-2]not in['a','e','i','o','u']:print(z[:-1]+'oes')
else:print(z+'s')

Port direct de Retina:

Rubis , 111 octets

'sub(/([^aeiou])y/){"#{$1}ie"};sub(/(.*)([^aeiou]o|[fxzs]|[sc]h)$/){"#{$1}#{$2}e"};sub(/fe/,"ve");sub(/$/,"s")'

Essayez-le en ligne!

Appelez via ruby -lpeet fournissez un fichier comme input.txtpour le premier argument CLI.

C, 321 octets

#define E else if(
#define C unsigned char
C*p(C*b){static C r[999],i,w,n,m;for(n=w=i=0;r[i]=b[i];n=w,w=b[i++]);m=!strchr("aeiou",n);if(strchr("sxz",w)||(w=='h'&&strchr("cs",n))||(w=='o'&&m))r[i++]='e';E'y'==w&&m)r[i-1]='i',r[i++]='e';E'f'==w)r[i-1]='v',r[i++]='e';E'f'==n&&w=='e')r[i-2]='v';r[i++]='s';r[i]=0;return r;}

tester:

C*mx[]={"car","bus","potato","knife","penny","exception","wolf","eye","decoy","radio",0};

main()
{unsigned i;
 for(i=0;mx[i];++i)
    printf("[%s] [%s]\n", mx[i], p(mx[i]));
 return 0;
}

résultats:

[car] [cars]
[bus] [buses]
[potato] [potatoes]
[knife] [knives]
[penny] [pennies]
[exception] [exceptions]
[wolf] [wolves]
[eye] [eyes]
[decoy] [decoys]
[radio] [radios]
[radio] [radios]

Java 7, 408 octets

Golfé:

boolean b="bcdfghjklmnpqrstvwxyzs".contains(String.valueOf(s.charAt(s.length()-2))); String x=s.substring(0,s.length()-1);if(s.endsWith("s")||s.endsWith("x")||s.endsWith("z")||s.endsWith("ch")||s.endsWith("sh"))return s+"es";if(s.endsWith("y")&&b)return x+"ies";if(s.endsWith("f")) return x+"ves";if(s.endsWith("fe"))return s.substring(0,s.length()-2)+"ves";if(s.endsWith("o")&&b)return s+"es";return s+="s";

Fondamentalement, tester la fin de la chaîne et ajouter / remplacer des lettres selon le cas. Le booléen et la chaîne au début sont juste pour supprimer la répétition dans les cas de test et rendre le code plus petit.

Version lisible:

public static String pluralize(String s){

// Consonant at the 2nd last position?
boolean b = "bcdfghjklmnpqrstvwxyzs".contains(String.valueOf(s.charAt(s.length()-2))); 

// Substring for cases where last letter needs to be replaced
String x = s.substring(0,s.length()-1);

if(s.endsWith("s") || s.endsWith("x") || s.endsWith("z") || s.endsWith("ch") || s.endsWith("sh"))
    return s + "es";
if(s.endsWith("y") && b)
    return x + "ies";
if(s.endsWith("f")) 
    return x + "ves";
if(s.endsWith("fe"))
    return s.substring(0,s.length()-2) + "ves";
if(s.endsWith("o") && b)
    return s + "es";

return s += "s";
}