단수형과 복수형의 두 가지 형태의 명사가 있습니다. 이 둘 사이의 변환은 매우 쉽습니다.

1. 일반적으로으로 끝납니다 s. 전의. car=> cars.

2. 그것으로 끝나는 경우 s, x, z, ch또는 sh, 그것을 끝 es. 전의. bus=> buses.

3. 그것으로 끝나는 경우 y그냥 전에 자음으로의 변경 y에 ies. 전의. penny=> pennies.

4. f또는로 끝나는 경우로 fe변경하십시오 ves. 전의. knife=> knives.

5. o바로 전에 자음으로 끝나는 경우로 변경하십시오 oes. 전의. potato=> potatoes.

태스크

단수 명사를 받게됩니다. 주어진 명사를 복수형으로 변환하여 출력해야합니다.

규칙

• 당신은 같은 불규칙 명사를 제공하지 않습니다 mouse및 moose.

• safe( safes; 위반 # 4), piano( pianos; 위반 # 5) 및 o( oes, 위반 # 5) 와 같은 예외는 제공되지 않습니다 .

• mosquito( mosquitos또는 mosquitoes) 및 roof( roofs또는 rooves) 와 같이 둘 이상의 가능한 복수형을 가진 단어가 제공되지 않습니다 .

• 셀 수없는 명사를받을 수 없습니다.

• y 모음으로 계산되지 않습니다.

예

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

수학, 9 바이트

Pluralize

예,이 기능이 내장되어 있습니다!

샘플 출력

Pluralize["car"]

cars

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

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

레티 나 , 57 53 56 55 58 57 바이트

골프 제안에 대한 MartinEnder에게 감사드립니다.

1 바이트 골프를위한 BusinessCat 덕분에

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

온라인으로 사용해보십시오!

설명 (오래됨)

([^aeiou])y$
$1ie

변경 {consonant}y에{consonant}ie

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

이 추가 e로 때와 단어의 끝 {consonant}o, f, x, z, s, sh또는 ch.

fe$
ve

엔딩 fe을 다음으로 변경ve

$
s

마지막으로 s단어에를 추가하십시오 .

편집

• 두 번째 규칙을 잊어 버렸기 때문에 바이트가 추가되었습니다.
• eye예를 들어 업데이트 할 바이트 추가

자바 스크립트 (ES6),  109  97 바이트

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

온라인으로 사용해보십시오!

배치, 325 바이트

@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

하스켈 216 207 205 바이트

@Lynn, @ user1472751 및 @Laikoni에게 도움을 주셔서 감사합니다!

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"

읽을 수있는

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"

설명

import Data.List기능을 위해 isSuffixOf. endsWithOneOf( €골프 버전에서) 목록 요소 중 하나가 문자열의 끝인지 여부를 반환합니다. consonants(c)모든 자음 목록입니다.

마지막으로 pluralize(p)엔딩을 확인하고 적절한 복수형을 반환합니다.

예:

p "potato" == "potatoes"

Perl, 66 + 2 ( -pl플래그) = 68 바이트

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

사용 :

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

Ideone에서 사용해보십시오.

로다 , 80 바이트

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

이 함수는 인수를 수정합니다. 사용법 : main word { f word; print word }다음은 반환 값 (83 바이트)을 사용하는 버전입니다.

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

아래는 입력 스트림에서 무한히 많은 값을 읽고 복수 형태를 출력 스트림으로 푸시하는 함수입니다 ( 87 83 바이트).

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

명명 된 함수를 만드는 것보다 짧은 익명 함수입니다.

PHP, 103100 바이트

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

온라인으로 사용해보십시오!

이 preg_replace기능은 다양한 패턴과 교체를받습니다.

• Titus 덕분에 2 바이트를 절약했습니다.
• Dewi Morgan 덕분에 1 바이트를 절약했습니다.

Python 3, 271 239 199 바이트

72 바이트만큼 줄인 @ovs에게 감사드립니다!

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"

온라인으로 사용해보십시오!

sed, 70 79 바이트

(BSD) / (GNU) 플래그는 69 78 + 1-E-r

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

망막 답변 의 직접 포트 .

핍 , 63 61 바이트

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

Retina를 잡는 것에 너무 가깝습니다 ! 그러나 아마 일어나지 않을 것입니다. :(

온라인으로 사용해보십시오!

설명

기본 전략 : Replace는 패턴 및 교체 목록이 제공 될 때 차례로 여러 번 교체를 수행합니다. 다음과 같이 교체하고 싶습니다.

• (sh?|x|z|ch)$ -> 추가 e
• [^aeiou]y->는 변경 y에 i하고 추가e
• fe?-> 변경 v및 추가e
• [^aeiou]o -> 추가 e

그런 다음 우리는 무관심에 시달리고 싶습니다 s.

트릭 :

• C정규식 주어진 연산자는 캡처 그룹에서 랩; C`xyz`보다 1 바이트 짧습니다 `(xyz)`.
• 모든 문자에 포함하는 대신 문자를 목록에 연결하여 모두 같은 문자로 끝나는 정규식 또는 대체 목록을 작성할 수 있습니다. 스칼라 (string)를 패턴 (regex / replacement)으로 연결하면 패턴으로 강제됩니다.
• 대신을 연결의 s(그리고 우선 순위의 순서를 처리 할 필요가 R와 .), 우리는 간단하게 할 수 있습니다 O다음 단어의 주요 부분 utput과 인쇄 s별도.

간격이 있고 주석이 달린 코드 :

                  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 바이트 :

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

예, 언어가 내장 된 다른 언어 (에 대한 참조를 추가해야하지만 System.Data.Entity.Design.dll)

쓰다:

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}");
}

산출:

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

파이썬 199 187 176 바이트

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'

레일스 러너, 18 바이트

$><<gets.pluralize

예:

$ echo knife | rails r filename.rb
knives

파이썬, 296 바이트

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

Retina의 직항 :

루비 , 111 바이트

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

온라인으로 사용해보십시오!

첫 번째 CLI 인수 ruby -lpe와 같이 파일을 통해 호출 하고 파일을 제공하십시오 input.txt.

C, 321 바이트

#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;}

테스트:

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

결과 :

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

자바 7, 408 바이트

골프 :

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

기본적으로 문자열의 끝이 무엇인지 테스트하고 어떤 경우에 따라 문자를 추가 / 교체하십시오. 처음에 부울과 문자열은 테스트 사례에서 반복을 제거하고 코드를 더 작게 만들기위한 것입니다.

읽을 수있는 버전 :

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";
}