एकवचन को बहुवचन में बदलें

Question

संज्ञा के दो रूप हैं, एकवचन और बहुवचन। इन दोनों के बीच रूपांतरण काफी आसान है।

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

Comments

स्पष्टता के लिए संपादित प्रश्न। बेझिझक रोलबैक करें।

— जुन्गवान मिन

आह, अंग्रेजी - मनमाने नियमों और विशेष मामलों का एक बड़ा ढेर :)

— फल

@ Challenger5 हां, लेकिन आप इसे कठिन गहन विचारों के माध्यम से समझ सकते हैं, हालांकि। ;)

— जुंगह्वान मिन

@MatthewRoh मैंने सामने वाले नियम में व्यंजन को स्पष्ट करने के लिए उसे संपादित किया है। उसी के लिए कुछ परीक्षण मामलों को भी जोड़ा। अगर मुझे गलत समझा गया है, तो कृपया इसे स्पष्ट करने के लिए संपादित करें।

— घोस्ट_इन_थे_कोड

@ चैलेंजर 5 यदि आप अंग्रेज़ी की तुलना डच से करते हैं तो बमुश्किल कोई नियम हैं .. डच में नियम और विशेष मामले हैं, और विशेष मामले उन विशेष मामलों के विपरीत हैं, और कुछ मामलों में विशेष मामले भी हैं जो उन विशेष मामलों का खंडन करते हैं जो उन विशेष मामलों के विपरीत हैं। ;)

— केविन क्रूज़सेन

Answer 1

गणितज्ञ, 9 बाइट्स

Pluralize

हां, इसके लिए बिल्ट-इन है!

नमूना उत्पादन

Pluralize["car"]

cars

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

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

Comments

Waaaaaat! क्या कोई ऐसी चीज है जिसे गणितज्ञ के लिए कोई अंतर्निहित नहीं है?

— KeyWeeUsr

डी: बिल्डरों ने इस चुनौती पर भी हमला किया है

— मैथ्यू रो

@KeyWeeUsr codegolf.stackexchange.com/a/71680/56033

— Azor Ahai

Answer 2

रेटिना , 57 53 56 55 58 57 बाइट्स

कुछ गोल्फ सुझावों के लिए मार्टिनएंडर का धन्यवाद

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उदाहरण के रूप में अपडेट करने के लिए बाइट्स जोड़े गए

Comments

क्षमा करें यदि यह एक मूर्खतापूर्ण प्रश्न है, तो मैंने रेटिना का उपयोग नहीं किया है। पहली पंक्ति में गोल कोष्ठक की आवश्यकता क्यों है?

— user2390246

कोई बात नहीं, मुझे लगता है कि मैंने अपने सवाल का जवाब दे दिया है। यह निम्न पंक्ति में लुकबैक संदर्भ के कारण है।

— user2390246

हां, यह इसलिए है क्योंकि हम चरित्र का yउपयोग करने से पहले कब्जा करना चाहते हैं$1

— क्रिति लिथोस

मुझे लगता है कि मुझे यह 57 बाइट्स में मिला है: इसे ऑनलाइन आज़माएं

— बिजनेस कैट

Answer 3

जावास्क्रिप्ट (ईएस 6),  109  97 बाइट्स

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

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

Comments

आपके ()सामने क्यों है fe?

— कोडोस जॉनसन

@KodosJohnson सभी replace()पुनरावृत्तियों में पहले मिलान समूह (के साथ $1) का संदर्भ शामिल है । इसलिए मुझे यहां एक खाली मिलान समूह की आवश्यकता है।

— अरनौलद

क्या आपने कोशिश की है (?<![aeiou])y?

— टाइटस

@Titus दुर्भाग्य से, जेएस दिखावे के दावे को लागू नहीं करता है।

— अरनुलद

Answer 4

बैच, 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

Comments

हर जगह के @echo offबजाय शुरुआत में क्या @? इसके अलावा, @set/ps=एक फोन से थोड़ा सा जंग लगता है। क्या sचर वैसे भी स्लाइसिंग मान को स्वीकार नहीं करेगा ?

— कीवीयूएसआर

@KeyWeeUsr @echo offपहले से ही न्यूलाइन के बिना 9 बाइट्स है, इसलिए यह मुझे कुछ भी नहीं बचाता है। इसके अलावा, @set/ps=पहली जगह में मूल्य इनपुट करने के लिए आवश्यक है।

— नील

Answer 5

हास्केल, 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"

Comments

अच्छा समाधान! यह 216 अक्षर है , लेकिन €कई बाइट्स लंबी है, जो आपके समाधान को 226 बाइट बनाती है। (कोड गोल्फ चुनौतियों को स्पष्ट रूप से बाइट्स में स्कोर किया जाता है, क्योंकि गिनती वर्ण आपको कभी-कभी धोखा देते हैं।) आप इसे केवल नाम बदल सकते हैं !, हालांकि! इसके अलावा, words"s x z ch sh"5 बाइट्स बचाता है। चारों ओर परेंसियों को हटाना (map(:"o")c))और (map(:"y")c))4 और बचाना ।

— लिन

मदद के लिए धन्यवाद, @ लियन! मैंने आपके सुझावों पर अमल किया।

— इज़िपुन्के

आप हमेशा हटाए जाने के c=['b'..'z']\\"eiou"बाद से एक बाइट बचा सकते हैं 'a'।

— 1514 पर user1472751

0<1एक बाइट से छोटा है True। इसके अलावा newlines एक ही बाइट की गिनती के रूप में हैं ;लेकिन गोल्फ कोड को थोड़ा बेहतर पठनीय बनाते हैं।

— लकोनी

Answer 6

पर्ल, 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 पर इसे आज़माएं।

Answer 7

रोड़ा , 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"}

यह एक अनाम फ़ंक्शन है, जैसा कि नामांकित फ़ंक्शन बनाने से कम है।

Comments

आपको पहले फ़ंक्शन (जिसके साथ शुरू होता है f&s) का परिणाम प्रदर्शित करने के लिए कैसे मिलता है ? बस f("word")कुछ भी प्रदर्शित करने के लिए प्रतीत नहीं होता है

— Kritii Lithos

@KritiiLithos पैरामीटर एक संदर्भ है, इसलिए तर्क एक चर होना चाहिए।

— फर्ग्यूसक

Answer 8

PHP, 103 100 बाइट्स

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

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

preg_replaceसमारोह पैटर्न और प्रतिस्थापन की एक सरणी में ले जाता है।

• टाइटस की बदौलत 2 बाइट्स बचाए।
• डेवी मोर्गन के लिए 1 बाइट धन्यवाद।

Comments

मुझे लगता है कि आप एक बाइट के साथ -Rऔर बचा सकते हैं $argn। और yदो के साथ एक जोर का उपयोग करता है : प्रतिस्थापन के रूप में (?<![aeiou])y$अनुमति देता है ie: नहीं \1, कोई उद्धरण नहीं।

— टाइटस

एक अन्य बाइट([^aeiou]o|sh?|x|z|ch)$

— डेवी मॉर्गन

@ टिट्स वास्तव में ऐसा लगता है कि उपयोग करने के लिए 1 बाइट जुर्माना है -R(लेकिन नहीं -r) ताकि बाइट गिनती में बदलाव न हो, दुर्भाग्य से। लेकिन देखने का सुझाव बहुत अच्छा काम करता है। धन्यवाद।

— कोदोस जॉनसन

Answer 9

पायथन 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"

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

Comments

आप कुछ अनावश्यक व्हाट्सएप हटा सकते हैं और पहले और आखिरी को जोड़ सकते हैं elif। एकल वर्ण सूचियों को स्ट्रिंग द्वारा प्रतिस्थापित किया जा सकता है। अजगर पर स्विच करने से अतिरिक्त 3 बाइट बचती हैं। tio

— ovs

@ नोव्स डन, थैंक्स! मैंने elifहालांकि एस को संयोजित नहीं किया , क्योंकि इसका मतलब potatoयह है potaties।

— नंबरमानस

मैंने गलत लाइन में देखा;)। यदि आप अंतिम एलिफ के साथ संयोजन कर सकते हैं। कुछ और बाइट्स को बचाने के लिए अंतिम पंक्ति को बदलें print(s+"s")और बाकी मामले को हटा दें और साथ ही हर उस शब्द को जोड़ रहे हैं। Tio

— OVS

जब आप के साथ अपने अगर / elif तर्क की जगह and/*और or/+और एक अनाम लैम्ब्डा समारोह बनाने आप इसे प्राप्त कर सकते हैं 200 बाइट्स से कम (मैं मामलों में थोड़ा बदली)

— OVS

@ ओव्स ओओह, वह print(s+"s")चतुर है। सब बदल गया; आप बहुत ज्यादा पूरी बात को फिर से लिखते हैं। धन्यवाद! (मुझे यह भी नहीं पता था कि आप ऐसा कर सकते हैं True and "string")

— नंबरमैन

Answer 10

sed, 70 79 बाइट्स

६ ९ / + १ -E(बीएसडी) / -r(जीएनयू) ध्वज के लिए

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

रेटिना उत्तर का सीधा पोर्ट ।

Answer 11

पिप , 63 61 बाइट्स

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

तो रेटिना को पकड़ने के करीब ! लेकिन ऐसा शायद होने वाला नहीं है। :(

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

व्याख्या

बुनियादी रणनीति: Replace पैटर्न और प्रतिस्थापन की सूचियों को दिए जाने के बाद एक के बाद एक कई प्रतिस्थापन करता है। हम निम्नलिखित प्रतिस्थापन करना चाहते हैं:

• (sh?|x|z|ch)$ -> एक जोड़ें e
• [^aeiou]y-> बदलने yके लिए iऔर एक जोड़नेe
• fe?-> बदलने vऔर जोड़ने के लिए एकe
• [^aeiou]o -> एक जोड़ें e

फिर हम sबिना किसी चिंता के निपटना चाहते हैं ।

ट्रिक्स:

• Cऑपरेटर, एक regex को देखते हुए एक कैप्चरिंग समूह में लपेटता; C`xyz`एक बाइट से छोटा है `(xyz)`।
• सभी वस्तुओं में इसे शामिल करने के बजाए उसी चरित्र के साथ समाप्त होने वाले रीगेक्स या प्रतिस्थापन की सूची बनाई जा सकती है। एक पैटर्न (regex / प्रतिस्थापन) एक पैटर्न के लिए एक स्केलर (स्ट्रिंग) से संबंधित।
• श्रृंखलाबद्ध के बजाय 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

Answer 12

सी #, 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

Comments

साइट पर आपका स्वागत है। मैं यह कोड कैसे चलाऊं?

— गेहूं जादूगर

@HeatWizard अपडेट किया गया। क्या मुझे बाइट की गिनती में अधिक विवरण (बयानों आदि का उपयोग करके) को शामिल करना चाहिए?

— रोडीविच

ट्रिविया के दिलचस्प बिट, इस (सिंगुलराइज) का उल्टा काफी सरल परीक्षण मामलों में विफल रहता है। उदाहरण के लिए, यह "पाठ्यक्रम" का एकवचन है "कॉर्स"।

— मॉर्गन थ्रैप

मुझे लगता है कि नाम स्थान को इस बाइट की गिनती में शामिल करने की आवश्यकता है, विशेष रूप से यह देखते हुए कि यह 'सामान्य' लोगों में से एक नहीं है। लेकिन मुझे लगता है कि आपको कम से कम इसे एक लंबोदर में लपेटने की भी ज़रूरत है, इस तर्क को विधि में पास करना। जैसा कि यह सिर्फ एक विधि समूह है

— Pinkfloydx33

@ pinkfloydx33 अब बेहतर है?

— रोडीरिच

Answer 13

पायथन 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'

Answer 14

रेल धावक, 18 बाइट्स

$><<gets.pluralize

उदाहरण:

$ echo knife | rails r filename.rb
knives

Comments

अब यह एक गूढ़ भाषा है।

— वेन

Answer 15

पायथन, 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')

Answer 16

रेटिना का प्रत्यक्ष बंदरगाह:

रूबी , 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।

Comments

शायद अधिक 'गोल्फ' हो सकता है। Btw .: क्या कोई TIO में फाइल जोड़ सकता है?

— Stephanmg

Answer 17

सी, 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]

Comments

यह wolvesनहीं होना चाहिए wolfves।

— mbomb007 18

@ceilingcat के बारे में क्या "स्थिर सी आर [256], / * Z =" aeiou ", i = 0, w, n;" "स्थिर C r [256] के स्थान पर; C / * Z =" aeiou ", i = 0, w, n;"

— RosLuP

260 बाइट्स

— सीलिंगकैट

Answer 18

जावा 7, 408 बाइट्स

golfed:

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

Comments

आप स्निपेट का उपयोग नहीं कर सकते।

— ओकेक्स