अंग्रेजी विराम चिह्न नियम लागू करें

आपको डिक्टेशन लेने वाले ऐप के लिए कुछ कोड लिखने के लिए काम पर रखा गया है, जो किसी स्पोक स्रोत से वॉयस इनपुट लेता है, इसे शब्दों के रूप में पार्स करता है, और इसे स्क्रीन पर लिखता है।

प्रबंधन वास्तव में आप पर इतना भरोसा नहीं करता है कि इस परियोजना में बहुत अधिक शक्ति है - आप अपने काम को करने के बजाय पूरे दिन चारों ओर और गोल्फ कोड में बैठने के लिए जाने जाते हैं, दुर्भाग्य से-इसलिए वे सिर्फ आपको प्रदर्शन करने के लिए एक बहुत ही सरल काम देते हैं: बारी उचित रूप से स्वरूपित वाक्य में प्रतिच्छेद विराम चिह्न के साथ वाक्य, जहां 'ठीक से स्वरूपित' को नीचे परिभाषित किया गया है।

वाक्य इनपुट का तार है। एक शब्द, विशिष्ट गैर-अंतरिक्ष वर्णों का एक समूह है। एक विराम चिह्न एक शब्द है जिसका पहला चरित्र है ^।
यदि शब्द का पहला अक्षर एक निचला अक्षर नहीं है, तो एक शब्द को पूंजीकृत किया जाता है (पूंजीकृत शब्द रेगेक्स से मेल खाता है /[^a-z].*/)।
वाक्य का पहला शब्द पूंजीकृत होना चाहिए।
A ^COMMAअल्पविराम वर्ण है ,और इसके पीछे एक स्थान है लेकिन पूर्ववर्ती नहीं है। aaa ^COMMA bbbबन जाता है aaa, bbb।
A ^COLONएक अल्पविराम है जो दिखता है :।
A ^SEMICOLONएक अल्पविराम है जो दिखता है ;।
A ^PERIODएक अल्पविराम है जो दिखता है .। निम्नलिखित शब्द ^PERIODको बड़ा करना होगा।
A एक ^BANGऐसा काल है जो दिखता है !।
A एक ^DASHडैश कैरेक्टर है -और इसमें पूर्ववर्ती और बाद में दोनों जगह है।
A ^HYPHENभी डैश कैरेक्टर है, -लेकिन इसके पीछे कोई जगह नहीं है या पूर्ववर्ती नहीं है।
एक ^EMDASHहाइफ़न है (डैश नहीं!) वर्तनी है --।
एक ^OPENQUOTEउद्धरण चरित्र "है जिसमें एक स्थान है पूर्ववर्ती लेकिन निम्नलिखित नहीं। निम्नलिखित शब्द ^OPENQUOTEको बड़ा होना चाहिए। यदि कोई ^OPENQUOTEऐसे शब्द से पहले है जो विराम चिह्न नहीं है, तो ^COMMAउस शब्द और a के बीच में जोड़ें ^OPENQUOTE। यदि कोई ^OPENQUOTEऐसा पंक्चुएशन है, जो अगले शब्द को बड़ा कर देता है, तो यह ^OPENQUOTEशब्द अगले शब्द पर आ जाता है।
ए ^CLOSEQUOTEवह डाइग्राफ ,"है जिसमें निम्नलिखित स्थान होता है लेकिन पूर्ववर्ती नहीं। यदि एक ^CLOSEQUOTEएक से पहले किया जाता है ^COMMA, ^PERIODया ^BANG, कि विराम चिह्न गायब हो जाता है और ^CLOSEQUOTEलिखा जाता है ,", ."या !"क्रमशः। यदि गायब होने वाले विराम चिह्न ने एक कैपिटलाइज़ेशन निर्दिष्ट किया है, तो वह कैपिटलाइज़ेशन अभी भी अगले उपलब्ध शब्द पर होना चाहिए।
पूर्ण अंतिम परिणाम में प्रारंभिक या अनुगामी रिक्त स्थान को हटाया जाना चाहिए, और एक पंक्ति में दो या दो से अधिक रिक्त स्थान के सभी स्ट्रिंग को एक ही स्थान वर्ण में ढह जाना चाहिए।
किसी भी मामले उपरोक्त में शामिल नहीं (जैसे ^COMMA ^COMMAया ^SEMICOLON ^CLOSEQUOTEया ^UNDEFINEDPUNCTUATION) अच्छी तरह से गठित इनपुट में घटित नहीं होगा और इस प्रकार अपरिभाषित व्यवहार है।

विकास दल आपको निम्नलिखित के बारे में सूचित करता है:

इस परियोजना को भाषा [आपकी भाषा यहाँ] में लिखा जा रहा है , और यह जितना संभव हो उतना कम होना चाहिए ताकि यह एंड्रॉइड / आईफोन के लिए एक ऐप के रूप में संभव हो सके। आप यह समझाने की कोशिश करते हैं कि ऐप विकास कैसे काम करता है, लेकिन वे नहीं सुनते। लेकिन हे, क्या संयोग है! आप [अपनी भाषा में] यहाँ एक अद्भुत गोल्फ खिलाड़ी हैं !
ऐप में कोई वेब एक्सेस की अनुमति नहीं होगी, और कोई भी लाइब्रेरी स्थापित नहीं होगी जो आपके लिए यह फ़ॉर्मेटिंग करें। आप अपनी टीम के लिए एक रेगीक्स लाइब्रेरी की अनुमति देने के लिए शायद टीम लीड को मना सकते हैं, हालांकि अगर आपको लगता है कि आपको एक की आवश्यकता है।
नेस्टेड कोटेशन के लिए समर्थन जो एप्लिकेशन के बाद के संस्करण के लिए ठीक से डबल / सिंगल कोट्स का उपयोग करता है, लेकिन उस संस्करण के लिए नहीं, जो आप अभी काम कर रहे हैं, इसलिए इसके बारे में चिंता न करें।
प्रबंधन परीक्षण-संचालित विकास का बहुत बड़ा प्रशंसक है, और इसलिए देव टीम के पास पहले से ही कुछ असहाय कीबोर्ड बंदर है, जो आपके कार्यक्रम के कुछ हिस्सों के लिए कुछ परीक्षण लिखते हैं: (पठनीयता के लिए नए सिरे से जोड़े गए, उन्हें रिक्त स्थान के रूप में मानते हैं)

इनपुट:
```
hello ^COMMA   world ^BANG
```
आउटपुट:
```
Hello, world!
```
इनपुट:
```
once upon a time ^COMMA there was a horse ^PERIOD that horse cost me $50
^PERIOD ^OPENQUOTE eat your stupid oats ^COMMA already ^BANG ^CLOSEQUOTE
I told the horse ^PERIOD the horse neighed back ^OPENQUOTE no ^CLOSEQUOTE
and died ^PERIOD THE END
```
आउटपुट:
```
Once upon a time, there was a horse. That horse cost me $50. "Eat your
stupid oats, already!" I told the horse. The horse neighed back, "No,"
and died. THE END
```
इनपुट:
```
begin a ^PERIOD b ^COMMA c ^COLON d ^SEMICOLON e ^BANG f ^HYPHEN g ^DASH h
^EMDASH i ^OPENQUOTE j ^PERIOD ^OPENQUOTE k ^SEMICOLON ^OPENQUOTE l
^CLOSEQUOTE m ^BANG ^CLOSEQUOTE n ^PERIOD 0x6C6F6C end
```
आउटपुट:
```
Begin a. B, c: d; e! F-g - h--i, "j. "K; "l," m!" N. 0x6C6F6C end
```

यह एक कोड गोल्फ है: सबसे कम स्कोर जीतता है। आप एक स्ट्रिंग तर्क, या एसटीडीआईएन से पढ़ने और एसटीडीयूएसटी पर लिखने का एक कार्यक्रम लिख सकते हैं।

— algorithmshark
स्रोत

क्या होगा अगर मैं जावास्क्रिप्ट का उपयोग करना चाहता हूं? इसमें कोई मानक इनपुट नहीं है। क्या मैं उपयोग कर सकता हूं prompt()?

— निकेल

@ एनसीएल ओपी एक स्ट्रिंग तर्क का उपयोग करने का उल्लेख करता है, इसलिए मेरे जेएस उदाहरण के लिए मैंने सिर्फ एक फ़ंक्शन बनाया जो एक तर्क लेता है और यह मान लिया कि तर्क

— एसटीडीआईएन के

मुझे आश्चर्य है कि अगर "[आपकी भाषा यहाँ]" नाम का एसोलंग है

— अकाँका

जवाबों:

जावास्क्रिप्ट: 653 611 547 514 487 बाइट्स

हे भगवान। ब्रेंडन ईच मैं इसके लिए बहुत माफी चाहता हूं।

पुनश्च: मैंने पठनीयता के लिए सफेद स्थान जोड़ा है, लेकिन सूचीबद्ध बाइट गिनती में सभी स्वीकार्य सफेद स्थान परिणामों को अलग करना।

सैद्धांतिक रूप से मैं की तरह कुछ भागों को छोटा कर सकता है -e-की तरह कुछ करने के लिए -eया -e, लेकिन यह एक मुद्दा कारण हो सकता है, तो पिछला शब्द या निम्न शब्द के साथ समाप्त होता है, पत्र 'ई' (या जो भी शब्द मैं उपयोग करने का फैसला) के साथ शुरू होता है। मुझे लगता है कि मैं एक ASCII चरित्र का उपयोग कर सकता हूं। मैं उस पर गौर करूंगा।

487 FF22 + केवल

R = "replace", C = "charAt", U = "toUpperCase";
alert(a[R](/\^((COMMA)|(SEMICOLON)|(COLON)|(PERIOD)|(BANG)|(DASH)|(HYPHEN)|(EMDASH)|(OPENQUOTE)|(CLOSEQUOTE))/g, ((m, _, a, b, c, d, e, f, g, h, i, j) => a ? "," : b ? ";" : c ? ":" : d ? "." : e ? "!" : f ? "-" : g ? "-h-" : h ? "-e-" : i ? ' "' : '" '))[R](/\s((\.)|(\!)|(\,)|(\;)|(\:)|(\-\h\-\s)|(\-\e\-\s))/g, ((k, l, v, n, o, p, q, r, s) => v ? "." : n ? "!" : o ? "," : p ? ";" : q ? ":" : r ? "-" : "--"))[R](/[^!,"'.]\"\s/g, '"')[R](/.+?[\.\?\!](\s|$)/g, (t => t[C](0)[U]() + t.substr(1)))[R](/\"[a-z]/g, (u => u[C](0) + u[C](1)[U]())))

514 FF22 + केवल

alert(function(z) {
    R = "replace", C = "charAt", U = "toUpperCase";
    return z[R](/\^((COMMA)|(SEMICOLON)|(COLON)|(PERIOD)|(BANG)|(DASH)|(HYPHEN)|(EMDASH)|(OPENQUOTE)|(CLOSEQUOTE))/g, ((m, _, a, b, c, d, e, f, g, h, i, j) => a ? "," : b ? ";" : c ? ":" : d ? "." : e ? "!" : f ? "-" : g ? "-h-" : h ? "-e-" : i ? ' "' : '" '))[R](/\s+((\.)|(\!)|(\,)|(\;)|(\:)|(\-\h\-\s+)|(\-\e\-\s+))/g, ((k, l, v, n, o, p, q, r, s) => v ? "." : n ? "!" : o ? "," : p ? ";" : q ? ":" : r ? "-" : "--"))[R](/[^!,"'.]\"\s/g, '"')[R](/.+?[\.\?\!](\s+|$)/g, (t => t[C](0)[U]() + t.substr(1)))[R](/\"[a-z]/g, (u => u[C](0) + u[C](1)[U]()))
}(a))

547 FF22 + केवल

alert(function(z) {
    R = "replace", C = "charAt", U = "toUpperCase";
    return z[R](/\^((COMMA)|(SEMICOLON)|(COLON)|(PERIOD)|(BANG)|(DASH)|(HYPHEN)|(EMDASH)|(OPENQUOTE)|(CLOSEQUOTE))/g, ((m, _, a, b, c, d, e, f, g, h, i, j) => a ? "," : b ? ";" : c ? ":" : d ? "." : e ? "!" : f ? "-" : g ? "-h-" : h ? "-e-" : i ? ' "' : '" '))[R](/\s+((\.)|(\!)|(\,)|(\;)|(\:)|(\-\h\-\s+)|(\-\e\-\s+))/g, ((xx, __, k, l, m, n, o, p, q) => k ? "." : l ? "!" : m ? "," : n ? ";" : o ? ":" : p ? "-" : "--"))[R](/[^!,"'.]\"\s/g, '"')[R](/.+?[\.\?\!](\s+|$)/g, function(r) {
        return r[C](0)[U]() + r.substr(1)
    })[R](/\"[a-z]/g, function(s) {
        return s[C](0) + s[C](1)[U]()
    })
}(a))

611 एफएफ 22+ केवल

alert(function(c) {
    return c.replace(/\^((COMMA)|(SEMICOLON)|(COLON)|(PERIOD)|(BANG)|(DASH)|(HYPHEN)|(EMDASH)|(OPENQUOTE)|(CLOSEQUOTE))/g, ((x, _, a, b, c, d, e, f, g, h, i) = > a ? "," : b ? ";" : c ? ":" : d ? "." : e ? "!" : f ? "-" : g ? "-h-" : h ? "-e-" : i ? ' "' : '" ')).replace(/\s+\./g, ".").replace(/\s+\!/g, "!").replace(/\s+\,/g, ",").replace(/\s+\;/g, ";").replace(/\s+\:/g, ":").replace(/\s\-\h\-\s/g, "-").replace(/[^!,"'.]\"\s/g, '"').replace(/\s+\-\e-\s+/g, "--").replace(/.+?[\.\?\!](\s+|$)/g, function(b) {
        return b.charAt(0).toUpperCase() + b.substr(1)
    }).replace(/\"[a-z]/g, function(b) {
        return b.charAt(0) + b.charAt(1).toUpperCase()
    })
}(a))

653 पार ब्राउज़र

alert(function(c) {
    return c.replace(/\^COMMA/g, ",").replace(/\^SEMICOLON/g, ";").replace(/\^COLON/g, ":").replace(/\^PERIOD/g, ".").replace(/\^BANG/g, "!").replace(/\^DASH/g, "-").replace(/\^HYPHEN/g, "h-h").replace(/\^EMDASH/g, "-e-").replace(/\^OPENQUOTE/g, ' "').replace(/\^CLOSEQUOTE/g, '" ').replace(/\s+\./g, ".").replace(/\s+\!/g, "!").replace(/\s+\,/g, ",").replace(/\s+\;/g, ";").replace(/\s+\:/g, ":").replace(/\s\h\-\h\s/g, "-").replace(/[^!,"'.]\"\s/g, '"').replace(/\s+\-\e-\s+/g, "--").replace(/.+?[\.\?\!](\s|$)/g, function(b) {
        return b.charAt(0).toUpperCase() + b.substr(1)
    }).replace(/\"[a-z]/g, function(b) {
        return b.charAt(0) + b.charAt(1).toUpperCase()
    })
}(a))

यह काम किस प्रकार करता है:

https://gist.github.com/ericlagergren/1a61b5d772ae49ab3aea

JSFiddle (653 बाइट क्रॉस-ब्राउज़र समाधान के लिए)

JSFiddle (595 एफएफ 22+ केवल समाधान के लिए)

JSFiddle (547 एफएफ 22+ केवल समाधान के लिए)

JSFiddle (514 एफएफ 22+ केवल समाधान के लिए)

JSFiddle (487 एफएफ 22+ केवल समाधान के लिए)

यह पहली बार है जब मुझे JS लिखना पड़ा है जो एक से अधिक regex का उपयोग करता है, और आमतौर पर मेरा regex पूर्वनिर्धारित होता है।

मैं जितना हो सके बाइट्स शेव करता रहूंगा।

— एरिक लेगरग्रेन
स्रोत

आप अपने पहले की जगह को इस तरह छोटा कर सकते हैं: c.replace(/\^((COMMA)|(SEMICOLON)|(COLON)|(PERIOD)|(BANG))/g,(m,_,a,b,c,d,e)=>a?',':b?';':c?':':d?'.':'!'))... और इसी तरह। एरो सिंटैक्स छोटा है, लेकिन यहां तक कि 'फ़ंक्शन' को समान वर्णों को सहेजना चाहिए

— edc65

आप सही हे। मैंने Chrome के साथ अपने regexp का परीक्षण किया, और यह वसा तीर का समर्थन नहीं करता है। मैं इसे अभी एफएफ के साथ सीधा करने पर काम कर रहा हूं, लेकिन मुझे नफरत है कि कैसे रेगेक्स के पास वास्तव में "और" ऑपरेटर नहीं है जैसे वे "या" करते हैं। @ edc65

— एरिक लेगरग्रेन

@ edc65 तो मुझे लगता है कि मुझे काम करने के लिए दो =>एस का उपयोग करना होगा, लेकिन तीर का उपयोग करके मुझे 40 बाइट बचाए गए!

— एरिक लेगरग्रेन ने

R = 'प्रतिस्थापित' से प्रतिस्थापित करें ... [R] ;-)

— edc65

बस यही किया गया :) इसे 563 @ edc65 पर ले जाया गया

— एरिक लेगरग्रेन ने

PHP, 412 बाइट्स

(स्पष्टता के लिए यहां अपुष्ट; गोल्फ संस्करण के लिए विचारधारा देखें ।)

PHP का preg_replace () फ़ंक्शन सरणी तर्कों को स्वीकार करेगा, जो कि यहां बहुत उपयोगी है। मुझे लगता है कि निम्नलिखित कोड वह सब कुछ करता है जो आवश्यक है। यह सभी परीक्षण मामलों को कम से कम पास करता है।

function x($s) {
    $r='preg_replace';
    $s=$r('/ +/',' ',$s);
    $s=$r(array('/ \^COMMA/','/ \^COLON/','/ \^SEMICOLON/','/ \^PERIOD/','/ \^BANG/',
                '/\^DASH/','/ \^HYPHEN /','/ \^EMDASH /','/\^OPENQUOTE /','/ \^CLOSEQUOTE/'),
          array(',',':',';','.','!','-','-','--','"',',"'),
          $s);
    $s=$r('/(^\W*\w|([\.!]| ")\W+\w)/e','strtoupper("$0")',$s);
    $s=$r('/([,\.!]),/','\1',$s);
    $s=$r('/(\w)( "\w)/e','"$1,".strtoupper("$2")',$s);
    echo $s;
}

— r3mainer
स्रोत

अच्छी तरह से काम! ideone.com/AYtTiI हालांकि मैं किस बारे में भ्रमित हूं, क्या हम खुले उद्धरणों से पहले अल्पविराम लगाने वाले हैं? क्योंकि, व्याकरणिक रूप से बोलना, उद्धरण चिह्नों को भाषण से अधिक के लिए है, फिर भी केवल उद्धरण से पहले भाषण में अल्पविराम होता है। मुझे लगता है कि जब से एक ^ COMMA हम उपयोगकर्ता इनपुट कॉमा दे रहा होगा

— एरिक Lagergren