इनपुट के प्रत्येक शब्द के पहले अक्षर को कैपिटलाइज़ करें

34

यह एक अपेक्षाकृत जल्दी है, लेकिन मुझे यकीन है कि आप इसे पसंद करेंगे।

कोडगॉल्फ एक प्रोग्राम है जो एक वाक्य के रूप में इनपुट लेगा और फिर प्रत्येक शब्द में पहले अक्षर को कैपिटल के साथ आउटपुट प्रदान करेगा।

नियम:

  1. प्रस्तुतियाँ एक फ़ंक्शन के रूप में नहीं हो सकती हैं। तो नहीं:

    function x(y){z=some_kind_of_magic(y);return z;} आपके अंतिम उत्तर के रूप में ... आपके कोड को दिखाना होगा कि यह इनपुट लेता है, और आउटपुट प्रदान करता है।

  2. इनपुट के पास कोड को किसी अन्य कैपिटल अक्षरों को संरक्षित करना चाहिए। इसलिए

    eCommerce and eBusiness are cool, don't you agree, Richard III?

    के रूप में प्रस्तुत किया जाएगा 

    ECommerce And EBusiness Are Cool, Don't You Agree, Richard III?

  3. आप में से कुछ सोच रहे होंगे, "आराम से, मैं सिर्फ रेगेक्स का उपयोग करूंगा!" और इसलिए अपनी चुनी हुई गोल्फ भाषा में देशी रेगेक्स का उपयोग करने से एक 30 वर्ण जुर्माना लगेगा जो आपके अंतिम कोड की संख्या पर लागू होगा। राक्षसी हँसी

  4. इस मामले में एक "शब्द" एक अंतरिक्ष द्वारा अलग किया गया कुछ भी है। इसलिए palate cleanserदो शब्द हैं, जबकि pigeon-toedएक शब्द माना जाता है। if_you_love_her_then_you_should_put_a_ring_on_itएक शब्द माना जाता है। यदि कोई शब्द एक गैर-वर्णमाला वर्ण से शुरू होता है, तो शब्द संरक्षित है, इसलिए _thisप्रतिपादन के बाद जैसा रहता है _this। (इस टेस्ट केस को इंगित करने के लिए मार्टिन बटनर को कुडोस)।

    • 4 बी। इसमें कोई गारंटी नहीं है कि इनपुट वाक्यांश में शब्दों को एक ही स्थान से अलग किया जाएगा।

  5. टेस्ट केस, (कृपया अपने कोड का परीक्षण करने के लिए उपयोग करें):

    इनपुट: 

    eCommerce rocks. crazyCamelCase stuff. _those  pigeon-toed shennanigans. Fiery trailblazing 345 thirty-two Roger. The quick brown fox jumped over the lazy dogs. Clancy Brown would have been cool as Lex Luthor. good_bye

    आउटपुट:

    ECommerce Rocks. CrazyCamelCase Stuff. _those  Pigeon-toed Shennanigans. Fiery Trailblazing 345 Thirty-two Roger. The Quick Brown Fox Jumped Over The Lazy Dogs. Clancy Brown Would Have Been Cool As Lex Luthor. Good_bye

  6. यह कोड गोल्फ है, सबसे छोटा कोड जीतता है ...

सौभाग्य...

code-golf  string  restricted-source 
— WallyWest
स्रोत
1
लाइन के अंत में रिक्त स्थान के बारे में क्या? क्या हमें उनका संरक्षण करना है? क्या हम एक जोड़ सकते हैं अगर यह हमारी आवश्यकताओं को पूरा करता है?
— डेनिस
2
डेनिस, कृपया इनपुट से रिक्त स्थान सुरक्षित रखें ...
— वैलीवेस्ट
3
यह शीर्षक बांध! c # खो देता है!
— इवांका
1
@Tim कबूतर से पहले डबल स्थान सही है । उन्होंने स्पेसिंग को संरक्षित करने के लिए कहा।
— mbomb007
2
शब्दों को क्या अलग करता है? कोई व्हाट्सएप (टैब, न्यूलाइन, आदि) या सिर्फ रिक्त स्थान?
— स्टीवन रंबलस्की

जवाबों:

21

सीजाम, 15 13 बाइट्स

Lq{_eu?_S-}/;

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

स्यूडोकोड

L             e# B := ""
 q            e# Q := input()
  {       }/  e# for C in Q:
   _eu?       e#     C := B ? C : uppercase(C)
       _S-    e#     B := string(C).strip(" ")
            ; e# discard(B)

सभी संशोधित वर्ण C को स्टैक पर छोड़ दिया जाता है और इसलिए, बाहर निकलते समय मुद्रित किया जाता है।

— डेनिस
स्रोत
3
लानत है यह चतुर। डी:
— मार्टिन एंडर
मुझे सहमत होना होगा, एक कोडगॉल्फ भाषा में किसी व्यक्ति को 4 वर्णों से बहिष्कृत करना अपने आप में एक उपलब्धि है ... अच्छी तरह से किया गया।
— वैलीवेस्ट
12
@WallyWest: गोल्फ भाषाएं इस बात का आभास दे सकती हैं कि वे खुद गोल्फ की तरह हैं, लेकिन मैं आपको विश्वास दिलाता हूं कि वे नहीं करते। TMTOWTDI सभी भाषाओं के लिए सच है और विशेष रूप से बहुत सारे बिल्ट-इन वाले लोगों के लिए। कभी आप जीतते हैं , कभी आप हारते हैं और कभी-कभी आपको ऐसा लगता है कि आप ट्रक से टकरा गए हैं ।
— डेनिस
13

सीएसएस 2.1, 49

:after{content:attr(t);text-transform:capitalize}

स्पष्टीकरण :

  • attrसमारोह एक से इनपुट लेता है t(पाठ) एचटीएमएल विशेषता।
  • इनपुट को सेट करके कैपिटल किया text-transformजाता है capitalize।
  • आउटपुट एक उत्पन्न सामग्री के रूप में प्रदान किया जाता है, contentजो छद्म तत्व पर संपत्ति का उपयोग करता है ।::after

चल स्निपेट :

:after {
    content: attr(t);
    text-transform: capitalize;
}
<div t="eCommerce rocks. crazyCamelCase stuff. _those  pigeon-toed shennanigans. Fiery trailblazing 345 thirty-two Roger. The quick brown fox jumped over the lazy dogs. Clancy Brown would have been cool as Lex Luthor. good_bye"></div>
स्निपेट का विस्तार करें

नोट : CSS 2.1 ने वांछित व्यवहार को निर्दिष्ट किया: capitalizeप्रत्येक शब्द के पहले वर्ण को अपरकेस किया। हालाँकि, CSS3 प्रत्येक शब्द के पहले टाइपोग्राफिक अक्षर इकाई को अपरकेस करता है। तो ऊपर वाला स्निपेट ठीक से न तो पुराने IE पर काम करेगा, जो CSS 2.1 का पालन नहीं करता; न ही नए अनुरूप ब्राउज़रों पर जो CSS3 का पालन करते हैं।

— Oriol
स्रोत
ओह, यह चतुर है!
— IQAndreas
1
( _thoseCSS3 ब्राउज़रों पर समस्या के बारे में बहुत बुरा है, लेकिन समस्या को हल करने के अनूठे तरीके के कारण मैं अभी भी
— परेशान हूं
@ ओरियल, "ओह यह चतुर है!" वास्तव में! क्षमा करें IQAndreas, मुझे आपकी टिप्पणी यहाँ उधार लेनी है ... यह समस्या को हल करने के लिए एक सरल दृष्टिकोण है ... मुझे इस दृष्टिकोण का उपयोग करना होगा ...
— WallyWest
10

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

alert(prompt().split(' ').map(x=>x&&x[0].toUpperCase()+x.slice(1)).join(' '))
स्निपेट का विस्तार करें

टिप्पणी की गई

alert( // output
    prompt(). // take input
    split(' '). // split by spaces
    map(x=> // map function to array
        x && // if x, empty string "" is falsey and returns itself
        x[0].toUpperCase() + x.slice(1) // capaitalize 1st char and concatenate the rest
    ).
    join(' ') // join array with spaces
)
— nderscore
स्रोत
यदि शब्द कई स्थानों से अलग हो जाते हैं तो क्या होता है? [४ बी]
— काक
3
@ केक यह द्वारा नियंत्रित किया जाता है x&&। एक खाली स्ट्रिंग गलत है इसलिए &&शॉर्ट-सर्किट और बाएं ओपेरा , खाली स्ट्रिंग लौटाता है। रिक्त स्थान संरक्षित हैं।
— दोपहर
बहुत बढ़िया, स्पष्टीकरण के लिए धन्यवाद। मुझे यह पता लगाने में मदद मिल सकती है कि मैं इसे अब कैसे काम कर सकता हूं।
— केक
यह गैर असिसी पात्रों को भी कैपिटल करेगा, ताकि become non बन जाएगा!
— leo
9

पर्ल, 13 बाइट्स

perl -040pe '$_="\u$_"'

9 बाइट्स प्लस 4 बाइट्स के लिए 040p(यह मानते हुए कि मैंने विशेष चालान पर नियमों की सही व्याख्या की है)।

-040$/एकल स्थान पर इनपुट रिकॉर्ड विभाजक सेट करता है, इसलिए रिक्त स्थान संरक्षित हैं; \uएस्केप अनुक्रम शीर्षक केस में अगले वर्ण बदल देता है।

— ThisSuitIsBlackNot
स्रोत
महान कार्य, कमांड लाइन का उपयोग करने के लिए सम्मानजनक उल्लेख!
— वैलेस्ट
7

CJam, 17 15 बाइट्स

lS/{S+(eu\+}/W<

इसका परीक्षण यहां करें।

कल्पना का सीधा कार्यान्वयन। {}&लगातार रिक्त स्थान के लिए त्रुटियों से बचने के लिए नए का उपयोग करें ।

डेनिस द्वारा बचाए गए दो बाइट्स।

— मार्टिन एंडर
स्रोत
उत्तम सामग्री! क्या सीजेएम मुख्य रूप से सिर्फ एक गोल्फ भाषा है या इसमें कुछ व्यावहारिक वाणिज्यिक अनुप्रयोग हैं?
— व्लादिस्ट
6
@WallyWest नहीं यह सिर्फ एक गोल्फ भाषा है। इसमें निश्चित रूप से व्यावसायिक अनुप्रयोग नहीं हैं , लेकिन मैं व्यक्तिगत रूप से इसे त्वरित फेंक-दूर स्क्रिप्ट के लिए कभी-कभी उपयोग करता हूं (क्योंकि इसमें बहुत सारे बिल्ट-इन हैं, और यदि आप जानते हैं कि आप क्या कर रहे हैं, तो टाइपिंग की तुलना में कम अक्षर टाइप करना जल्दी है। अधिक वर्ण;))।
— मार्टिन एंडर
आप प्रत्येक शब्द के लिए एक स्थान जोड़कर कुछ बाइट्स बचा सकते हैं। मेरे सवाल के ओपी के जवाब के आधार पर, यह आपको 14 या 12 बाइट्स तक पहुंचा सकता है।
— डेनिस
@ डेनिस ओह ठीक है, मैं उस के साथ खेल रहा था, लेकिन पहले चरित्र को खींचने से पहले बस इसे जोड़ने पर विचार नहीं किया। मैं उस कल को बदल दूंगा, धन्यवाद!
— मार्टिन एंडर
@ डेनिस धन्यवाद, मैंने इसे बदल दिया, लेकिन मुझे यकीन नहीं है कि 14-बाइट संस्करण का क्या मतलब है। यदि आप दूसरे को छोड़ने के बारे में बात कर रहे हैं +, तो वह टूट जाता है यदि इनपुट में अनुगामी स्थान होते हैं।
— मार्टिन एंडर
7

सी, 64 63 बाइट्स

a;main(c){while(~(c=getchar()))putchar(a?c:toupper(c)),a=c-32;}

फिक्स: कुछ कंपाइलर (जैसे क्लैंग) को argv के स्थान पर एक अंतर पैरामीटर पसंद नहीं है, इसलिए मैंने इसे एक वैश्विक चर में स्थानांतरित कर दिया। बाइट काउंट वही रहता है। ध्यान देने के लिए स्क्वीश ossifrage के लिए धन्यवाद। डाउन टू 63 बाइट्स, धन्यवाद डेनिस।

Ungolfed:

int a;

int main(int c) {
    while(~(c = getchar()))
        putchar(a ? c : toupper(c)),
        a = c - ' ';
}

बहुत सीधा: यदि असत्य है, तो चरित्र अपरकेस में बदल जाता है। यह एक स्थान को पढ़ने के बाद सेट किया गया है: c - '' केवल c == '' गलत है। टॉपर () उन सभी चीजों को अनदेखा करता है जो लोअरकेस अक्षर नहीं है, इसलिए प्रतीक और कई रिक्त स्थान ठीक हैं। -1 में सभी बिट्स सेट हैं, इसलिए जब गेटचैट () रिटर्न होता है -1 नहीं ऑपरेटर इसे शून्य बनाता है, और लूप बंद हो जाता है। a को वैश्विक चर के रूप में घोषित किया जाता है, इसलिए यह शून्य (झूठा) के लिए आरम्भिक है। यह सुनिश्चित करता है कि पहला शब्द पूंजीकृत है।

— एंड्रिया बियोन्डो
स्रोत
1
while(~(c=getchar())- मुझे वह पसंद है। क्लैंग वास्तव में इसे संकलित नहीं करेगा, लेकिन आप एक ही वर्ण गणना के साथ प्राप्त कर सकते हैंc;main(a){...}
— स्क्विश ओस्सिफ्रेज
1
आप की घोषणाओं स्वैप हैं aऔर cऔर त्रिगुट ऑपरेटर के आदेश, आप बदल सकते हैं ==के साथ -एक बाइट को बचाने के लिए।
— डेनिस
आप निश्चित रूप से सही कह रहे हैं।
— एंड्रिया बियोनडो
अच्छा! +1 का उपयोग करते समय कार्यक्रम समान काम करेगा while(!(c = getchar())), है ना?
— स्पिकैट्रिक्स
1
@ कूल गाइ: नहीं, बिट वाइज ~और लॉजिकल !समान नहीं हैं। C में ऐसी कोई भी चीज़ जो शून्य नहीं है, सत्य मानी जाती है, इसलिए आपकी स्थिति ऐसी होगी while((c = getchar()) == 0)जो निश्चित रूप से काम नहीं करेगी। बिटवाइज़ NOT ऑपरेटर ~बिट-बाय-बिट का मान घटाता है। लूप को तोड़ने के लिए, ~cशून्य होना चाहिए: इसका मतलब है कि सभी बिट्स को एक होना चाहिए, ताकि जब नकारात्मक हो जाए तो वे सभी शून्य हो जाएं। वह मान (एक 32 बिट इंट के लिए) है 0xFFFFFFFF, जो यदि हस्ताक्षरित है, तो -1(ईओएफ) है।
— एंड्रिया बियोनडो
7

अजगर 3, 59 56 बाइट्स

f=1
for c in input():print(end=f*c.upper()or c);f=c==" "

3 बाइट्स के लिए @Reticality का धन्यवाद।

— Sp3000
स्रोत
3
कैसे के बारे में print(end=f*c.upper()or c)? इससे 4 बाइट्स
@Reticality ओह वाह, मुझे नहीं पता था कि आपके पास सिर्फ एक कीवर्ड arg के साथ एक खाली प्रिंट हो सकता है। धन्यवाद!
— Sp3000
7

पर्ल संस्करण <5.18, 30 27 26 25

say map"\u$_",split$,=$"

24 वर्ण +1 के लिए -n।

\u एक स्ट्रिंग में अगले चरित्र बनाता है अपरकेस । @ThisSuitIsBlackNot ने 1 बाइट बचाने के लिए इसे इंगित किया। इससे पहले कि हम फ़ंक्शन का उपयोग कर रहे थे ucfirst।

से perldocs ,

एक अन्य विशेष मामले के रूप में, स्प्लिट कमांड लाइन टूल के डिफ़ॉल्ट व्यवहार को जागृत करता है जब PATTERN या तो छोड़ा गया है या एक सिंगल स्पेस कैरेक्टर (जैसे '' या "\ x20" से बना शाब्दिक स्ट्रिंग है, लेकिन उदा / / नहीं)। इस मामले में, EXPR में किसी भी प्रमुख व्हाट्सएप को विभाजित होने से पहले हटा दिया जाता है, और PATTERN के बजाय ऐसा माना जाता है जैसे कि यह / \ s + / था; विशेष रूप से, इसका मतलब यह है कि किसी भी सन्निहित व्हाट्सएप (न केवल एक एकल अंतरिक्ष चरित्र) को विभाजक के रूप में उपयोग किया जाता है। हालांकि, इस विशेष उपचार को पैटर्न / / स्ट्रिंग के बजाय "" निर्दिष्ट करके बचा जा सकता है, जिससे केवल एक ही अंतरिक्ष वर्ण एक विभाजक हो सकता है। पहले के पर्ल्स में यह विशेष मामला एक सादा "" के उपयोग के लिए प्रतिबंधित था, जिसे पैटर्न तर्क के रूप में विभाजित किया गया था, पर्ल 5.18 में।

चूंकि $"किसी स्थान का मूल्यांकन करता है, यह रिक्त स्थान को संरक्षित करेगा। चूँकि हम दोनों $,एक स्पेस कैरेक्टर पर सेट होना चाहते हैं , और स्प्लिट के लिए स्पेस कैरेक्टर इनपुट करते हैं, @ कुटकी ने बताया कि हम दोनों को स्प्लिट के इनपुट के रूप में कर सकते हैं। जो हमारे पास पहले था, जो पहले सेटिंग था, उससे 3 बाइट्स बचाता है$, और फिर $"विभाजन पर इनपुट कर रहा था।

इसका उपयोग करना ,{}@ अलेक्जेंडर-ब्रेट ने बताया कि अतिरिक्त बाइट के बजाय मानचित्र के लिए ।

साथ दौड़ो:

echo 'eCommerce     rocks. crazyCamelCase stuff. _those  pigeon-toed shennanigans. Fiery trailblazing 345 thirty-two Roger. The quick brown fox jumped over the lazy dogs. Clancy Brown would have been cool as Lex Luthor. good_bye' | perl -nE'say map"\u$_",split$,=$"'
— hmatt1
स्रोत
1
1 बाइट के साथ सहेजें...map"\u$_",split...
— अलेक्जेंडर-ब्रेट
@ अलेक्जेंडर-ब्रेट धन्यवाद! मैंने जवाब अपडेट किया।
— hmatt1
5

> <> (मछली) , 39 बाइट्स

</?-' 'o:;?(0:<-*' '*('{'$)'`'::i
i/.0e

तरीका:

  • एक चार ले लो और इसे कैपिटलाइज़ करें अगर रेंज में है a-zतो इसे प्रिंट करें। (इस भाग के लिए बाएं से दाएं कोड है i::'backquote')$'{'(*' '*+)
  • यदि अंतिम लिया गया चार्ट EOF char है तो बाहर निकलें और उसे प्रिंट करें
  • यदि अंतिम लिया गया char एक space char है तो बिंदु 1 पर जाएं और नया अक्षर लें और बिंदु 2 पर जाएं।
— randomra
स्रोत
5

जावा, 273 बाइट्स

संपादित करें

import static java.lang.System.*;class x{public static void main(String[] s){char[] a=new java.util.Scanner(in).nextLine().toCharArray();boolean f=1>0;for(int i=0;i<a.length;i++){if(a[i]==' '){f=1>0;continue;}if(f){a[i]=Character.toUpperCase(a[i]);f=1<0;}}out.println(a);}}
— अतुल कुंभार
स्रोत
पीसीजी में यह मेरा पहला जवाब है, यकीन नहीं होता कि यह स्वीकार्य है।
— अतुल कुंभार
नाव पर स्वागत है! आप व्हॉट्सएप को हटाने और चर नामों के लिए एकल वर्णों का उपयोग करने का प्रयास कर सकते हैं। वहाँ भी JAVA गोल्फिंग के लिए कुछ अन्य सुझाव दिए गए हैं ।
— दोपहर
संकेत के लिए @nderscore धन्यवाद, मैंने युक्तियों का उपयोग करके अपना उत्तर संपादित किया है।
— अतुल कुंभार
बेहतर लग रही है! मैंने आपके लिए अपनी पोस्ट में बाइट काउंट को भी जोड़ा है।
— अंडरस्कोर
1
@TuukkaX उसके publicसामने नहीं है class.. और अगर आपका मतलब है कि वह publicसामने वाले को हटा सकता है static void main(..., तो आप गलत हैं, जब तक कि वह जावा 8+ classको बदलकर interfaceउपयोग नहीं करता।
— केविन क्रूज़सेन
5

जावास्क्रिप्ट (रेगेक्स समाधान) - 104 बाइट्स

किसी को गोली काटकर RegEx समाधान पोस्ट करना होगा! 74 वर्ण, प्लस +30 वर्ण दंड:

alert(prompt().replace(/(^| )[a-z]/g,function(m){return m.toUpperCase()}))

या यदि आप अपने गैर-संकुचित फैशन में कोड को पढ़ना और समझना चाहते हैं:

//     Matches the (beginning of the line or a space), followed by a lowercase English character.  
string.replace( /(^| )[a-z]/g ,
                function(match) { return match.toUpperCase(); }
— IQAndreas
स्रोत
1
चतुर ... हालांकि, आप एक 30 चरित्र जुर्माना के साथ कीमत चुका चुके हैं ... मैं बुलेट काटने के लिए मेरी टोपी आपसे दूर ले
— जाऊंगा
4

पायथन 2, 73 बाइट्स

i=raw_input()
print''.join((c,c.upper())[p==' ']for p,c in zip(' '+i,i))

यह प्रोग्राम एक अक्षर को कैपिटल करता है यदि एक स्थान से पहले (स्ट्रिंग में पहले वर्ण के लिए एक कीचड़ के साथ)। यह .upper()सही तरीके से कैपिटल करने के लिए स्ट्रिंग विधि पर निर्भर करता है।

— तर्क नाइट
स्रोत
2
आप पायथन 3. (-4 raw_input=> input, +2 print=> print()) को पोर्ट करके 2 बाइट्स बचा सकते हैं
— स्टीवन रूंबल्स्की
धन्यवाद स्टीवन। मैंने पायथन 3. में कोडिंग करके बाइट्स में बचत पर विचार किया था। तब मैंने सोचा, अगर मुझे भाषा को प्रतिस्पर्धी बनाने के लिए बदलना है, तो मैं पायथ में बदलूंगा। मैं पायथन 2 उप-लीग में प्रतिस्पर्धा करके खुश हूं। मैं काम के लिए हर दिन अजगर 2 में कोड करता हूं, इसलिए यह अनुभव मुझे मेरी नौकरी पर बेहतर बनाता है (लेकिन मेरा काम कोड नहीं है!)।
— लॉजिक नाइट
4

PHP 64 76 77 83 84 89 बाइट्स

क्या $_GETPHP में इनपुट के रूप में गिना जाता है?
यदि हां, तो यहां मेरा पहला सीजी प्रयास है

foreach(explode(' ',$_GET[@s])as$k=>$v)echo$k?' ':'',ucfirst($v)

धन्यवाद मैनेटवर्क :)

कोई केवल ucwordsफ़ंक्शन का उपयोग कर सकता है , जिसके परिणामस्वरूप 21 बाइट्स होंगे: 

<?=ucwords($_GET[@s])

धन्यवाद हैरी मस्टो-प्लेफेयर :)

— Octfx
स्रोत
व्यक्तिगत रूप से मैं केवल fgets(STDIN)इनपुट पढ़ने के लिए विचार करता हूं । लेकिन $_GETजहां तक ​​मुझे पता है, हमारी कोई सहमति नहीं है।
— सुबह 11:52
— यूप
आपको चेतावनियों को बंद करने के लिए ट्रिक्स की आवश्यकता नहीं है। वे चेतावनी दे रहे हैं! किसी को उनकी परवाह नहीं है।
— इस्माइल मिगुएल
खैर, यह नहीं सोचा था। मुझे लगता है कि मैं सामग्री से चिपके रहना होगा
— Octfx
उसकी कोई ज़रूरत नहीं। इसे हटाने के बारे में मेरी पहले की सलाह को भूलने का समय आ गया है $k=>। : इसे वापस रखforeach(split(' ',$_GET[@s])as$k=>$v)echo$k?' ':'',ucfirst($v);
— manatwork
4

हास्केल, 69

import Data.Char
main=interact$tail.scanl(!)' '
' '!c=toUpper c;_!c=c

स्पष्टीकरण:

scanlएक फ़ंक्शन (a -> b -> a)और एक प्रारंभिक मूल्य लेता है a, फिर [b]s की सूची बनाने के लिए s की सूची पर पुन: प्रसारित करता है [a]:

scanl (!) z [a,b,c] == [   z
                       ,   z ! a
                       ,  (z ! a) ! b
                       , ((z ! a) ! b) ! c]

यह बार-बार पिछले परिणाम लेता है क्योंकि फ़ंक्शन के बाएं तर्क ने इसे पास किया है, और इनपुट सूची से सही तर्क के रूप में एक मूल्य , अगले को बनाने के लिए।

मैंने एक फ़ंक्शन लिखा है (!) :: Char -> Char -> Charजो आपके द्वारा पारित सही वर्ण लौटाता है, लेकिन इसे कैपिटल करता है यदि बाएं चार ' '(स्पेस) है। इसके लिए scanl, इसका अर्थ है: इनपुट सूची से मान लौटाएं , लेकिन यदि पिछले परिणाम में जगह थी , तो इसे कैपिटल करें । तो scanl (!) ' ' "ab cd"बन जाता है:

    scanl (!) ' ' "ab cd"
==> ' ' : scanl (!) (' ' ! 'a') "b cd"
==> ' ' : scanl (!)     'A'     "b cd"
==> ' ' : 'A' : scanl (!) ('A' ! 'b') " cd"
==> ' ' : 'A' : scanl (!)     'b'     " cd"
==> ' ' : 'A' : 'b' : scanl (!) ('b' ! ' ') "cd"
==> ' ' : 'A' : 'b' : scanl (!)     ' '     "cd"
==> ' ' : 'A' : 'b' : ' ' : scanl (!) (' ' ! 'c') "d"
==> ' ' : 'A' : 'b' : ' ' : scanl (!)     'C'     "d"
==> ' ' : 'A' : 'b' : ' ' : 'C' : scanl (!) ('C' ! 'd') ""
==> ' ' : 'A' : 'b' : ' ' : 'C' : scanl (!)     'd'     ""
==> ' ' : 'A' : 'b' : ' ' : 'C' : 'd' : ""
==> " Ab Cd"

हमें ' 'पहले अक्षर को कैपिटल करने के लिए प्रारंभिक मूल्य की आवश्यकता है, लेकिन फिर हम tailअपना अंतिम परिणाम प्राप्त करने के लिए इसे काट देते हैं ।

— लिन
स्रोत
अच्छा! क्या आप मेरे लिए इसे समझा सकते हैं?
— पोइदा
मैंने एक स्पष्टीकरण लिखा।
— लिन
कुछ और scanlउदाहरण: एक , दो ।
— लिन
इस तरह के एक महान एल्गोरिदम का उपयोग करने के लिए @ मौरिस यश ... :)
— WallyWest
3

अजगर, 20 बाइट्स

uXGHr@GH1fqd@+dzTUzz

ये कई रिक्त स्थान वास्तव में बेकार हैं। अन्यथा वहाँ एक बहुत आसान 12 बाइट्स समाधान होता।

इसे ऑनलाइन आज़माएं: पायथ कंपाइलर / एक्ज़ीक्यूटर

व्याख्या

                      implicit: z = input string
         f       Uz   filter [0, 1, 2, ..., len(z)-1] for elements T, which satisfy:
          qd@+dzT        " " == (" " + z)[T]
                      (this finds all indices, which should be capitalized)
u                  z  reduce, start with G = z, for H in idices ^ update G by
 XGH                     replace the Hth char of G by
    r   1                upper-case of
     @GH                 G[H]
                      implicitly print result

संपादित करें: @ डेनिस एल्गोरिथ्म के साथ 16 वर्ण संभव है।

— Jakube
स्रोत
1
कई जगह की बात यह है कि इसे और अधिक चुनौतीपूर्ण बनाने के लिए ... अन्यथा यह string.split ("") या कुछ इसी तरह का एक सरल मामला होगा ... लेकिन आपने इसे 20 अक्षरों में करने के लिए अच्छा किया है
— वैलीवेस्ट
3

CJam, 14 बाइट्स

यह सबसे छोटा नहीं है, लेकिन ...

qS/Sf.{\eu}s1>

इसी तरह के विचारों का उपयोग करते हुए एक और उत्तर:

qS/Laf.{;eu}S*

.x केवल पहला आइटम बदलता है यदि किसी पैरामीटर में केवल एक आइटम है।

— jimmy23013
स्रोत
1
जंजीर fऔर .बहुत सरल है। एक और 14 बाइट्स प्रकार:qS/Sf.{\eu}S.-
— डेनिस
3

लुआ, 64 62 61 बाइट्स

Lua गोल्फ के लिए एक भयावह भाषा है, इसलिए मुझे इस पर अपने लिए बहुत गर्व है।

print(string.gsub(" "..io.read(),"%s%l",string.upper):sub(2))

[इसे यहाँ आज़माएं] 1 आउटडेटेड, टोमोरो को अपडेट करेगा

1
PPCG में आपका स्वागत है! निश्चित रूप से, आपको कॉमा के बाद उन स्थानों की आवश्यकता नहीं है?
— मार्टिन एंडर
वाह, मैं यह करने के लिए बहुत नया हूँ मैं भी नहीं पता रिक्त स्थान गिने। 62 बाइट्स!
2
मैंने यह भी देखा कि यह पूरी तरह से सही नहीं है: आप सभी गैर-पत्रों के बाद अक्षरों को बड़ा कर रहे हैं, इसलिए abc_defयह आपको देगा Abc_Def। हालांकि रिक्त स्थान के बाद केवल अक्षर ऊपरी मामले में बदल जाना चाहिए। अच्छी खबर यह है, इसे ठीक करने से एक बाइट बचती है। ;)
— मार्टिन एंडर
3

जावा, 204 211 226 बाइट्स

CG पर मेरी पहली प्रविष्टि, मुझे आशा है कि यह ठीक है:

class U{public static void main(String[]s){int i=0;char[]r=s[0].toCharArray();r[0]=Character.toUpperCase(r[0]);for(char c:r){if(c==' '&&i>0)r[i+1]=Character.toUpperCase(r[i+1]);i++;System.out.print(c);}}}

@TNT को 7 बाइट्स धन्यवाद से बचाया

— एंजेलो ट्रिकारिको
स्रोत
मेरे गरीब जावा कौशल को शामिल:public class U{public static void main(String[]s){int i=-1,j;char[]r=s[0].toCharArray();for(char c:r)if(++i==0||c==' '&&i>0)r[j=i+(i==0?0:1)]=Character.toUpperCase(r[j]);System.out.print(r);}}
— manatwork
1
PPCG में आपका स्वागत है! publicताकि आप 7 अधिक बचा सकता है संशोधक आवश्यक नहीं है।
— टीएनटी
3

PHP: 76 74 वर्ण

foreach($l=str_split(fgets(STDIN))as$c){echo$l?ucfirst($c):$c;$l=$c==" ";}

नमूना रन:

bash-4.3$ php -r 'foreach($l=str_split(fgets(STDIN))as$c){echo$l?ucfirst($c):$c;$l=$c==" ";}' <<< 'eCommerce rocks. crazyCamelCase stuff. _those  pigeon-toed shennanigans. Fiery trailblazing 345 thirty-two Roger. The quick brown fox jumped over the lazy dogs. Clancy Brown would have been cool as Lex Luthor. good_bye'
ECommerce Rocks. CrazyCamelCase Stuff. _those  Pigeon-toed Shennanigans. Fiery Trailblazing 345 Thirty-two Roger. The Quick Brown Fox Jumped Over The Lazy Dogs. Clancy Brown Would Have Been Cool As Lex Luthor. Good_bye
— आदमी काम पर है
स्रोत
इसके बजाय ucfirst($c), उपयोग करें $c^' '। (टिप: यदि आप bitwise-xorएक स्थान के साथ एक पत्र है, तो यह अपरकेस से लोअरकेस में परिवर्तित हो जाएगा, और ऑपोजिट भी लागू होता है)
— इस्माइल मिगुएल
@IsmaelMiguel, जो आपके समाधान में ठीक काम करता है क्योंकि आप केवल अक्षरों को कम करते हैं। लेकिन मेरे समाधान में सभी पहले अक्षर संसाधित हैं। तो (अन्यथा महान) xor ट्रिक के लिए मेरे कोड को कुछ वर्ण प्रकार छानने की भी आवश्यकता होगी। :(
— मैनेटवर्क
यह मेरे दिमाग को पार नहीं किया। यह जांचने के लिए एक बिटवाइज़ ट्रिक होनी चाहिए कि क्या यह एक पत्र है या नहीं।
— इस्माईल मिगुएल
1
एक चीज जो आप कर सकते हैं $l=str_split(fgets(STDIN)), वह कोड को 2 बाइट्स से कम कर देता है!
— इस्माइल मिगुएल
1
अब मैं पागल हो रहा हूं। यार, मैंने उस इनिशियलाइज़ेशन को कितनी देर तक देखा और याद किया। धन्यवाद, @IsmaelMiguel
— शाम
3

सी, 74 बाइट्स

a,b=1;main(){while((a=getchar())>0)b=isspace(putchar(b?toupper(a):a));}

रन-टाइम कैरेक्टर सेट (ASCII, EBCDIC, Baudot, ... जो भी हो) के बारे में कोई धारणा नहीं बनाता है। क्या यह माना जाता है कि EOF नकारात्मक है (मुझे लगता है कि C गारंटी देता है कि)।

a,b=1;
main()
{
    while((a=getchar())>0)
        b=isspace(putchar(b?toupper(a):a));
}

ए इनपुट चरित्र है; ख सत्य है यदि अंतिम वर्ण स्थान था। केवल गैर-स्पष्ट बिट यह है कि हम इस तथ्य का उपयोग करते हैं कि putcharकोई त्रुटि नहीं होने पर मुद्रित वर्ण लौटाता है।

— टोबी स्पाईट
स्रोत
3

सी # लाइनक - 187

यह जीतने के करीब नहीं है, लेकिन मैं सिर्फ लिनक को बहुत प्यार करता हूं।

namespace System{using Linq;class P{static void Main(string[]a){Console.Write(a[0].Substring(1).Aggregate(a[0][0].ToString().ToUpper(),(b,c)=>b[b.Length-1]==32?b+char.ToUpper(c):b+c));}}}
— ldam
स्रोत
3

विम, 11 , 10 बाइट्स

qqvUW@qq@q

स्पष्टीकरण:

qq           #Start recording in register 'q'
  vU        #Make the character under the cursor uppercase
     W       #Move forward a WORD
      @q     #recursively call macro 'q'
        q    #stop recording
         @q  #Call the recursive macro

क्या डेनिस को पछाड़ने के लिए मुझे एक गोल्ड-बैज मिलेगा?

— DJMcMayhem
स्रोत
3
— डाउनगोट
2

बैश, 61

a="${@//: / }"
a=(${a//: / })
a="${a[@]^}"
echo "${a//:/ }"

ध्यान दें कि कॉलोन बस कार्यक्रम को यहां ठीक प्रदर्शित करने के लिए हैं। वास्तव में ये कुछ गैर-मुद्रण योग्य चरित्र हो सकते हैं, जैसे कि बीईएल।

उत्पादन

$ ./cap1st.sh "eCommerce rocks. crazyCamelCase stuff. _those  pigeon-toed shennanigans. Fiery trailblazing 345 thirty-two Roger. The quick brown fox jumped over the lazy dogs. Clancy Brown would have been cool as Lex Luthor. good_bye"
ECommerce Rocks. CrazyCamelCase Stuff. _those  Pigeon-toed Shennanigans. Fiery Trailblazing 345 Thirty-two Roger. The Quick Brown Fox Jumped Over The Lazy Dogs. Clancy Brown Would Have Been Cool As Lex Luthor. Good_bye
$

बैश, १२

अफसोस की बात है कि यह प्रमुख / उत्परिवर्ती / अनुगामी स्थानों को संरक्षित नहीं करता है, लेकिन अन्यथा यह काम करता है:

echo "${@^}"

उत्पादन

$ ./cap1st.sh eCommerce rocks. crazyCamelCase stuff. _those  pigeon-toed shennanigans. Fiery trailblazing 345 thirty-two Roger. The quick brown fox jumped over the lazy dogs. Clancy Brown would have been cool as Lex Luthor. good_bye
ECommerce Rocks. CrazyCamelCase Stuff. _those Pigeon-toed Shennanigans. Fiery Trailblazing 345 Thirty-two Roger. The Quick Brown Fox Jumped Over The Lazy Dogs. Clancy Brown Would Have Been Cool As Lex Luthor. Good_bye
$
— डिजिटल आघात
स्रोत
5
लेकिन वह आधी चुनौती है!
— Sp3000
1
@ Sp3000 वहाँ मैंने इसे तय किया (49 शुल्क की लागत के रूप में)
— डिजिटल ट्रॉमा
2

पिप , 15 + 1 -s= 16 के लिए

{IaUC:a@0a}Ma^s

स्पष्टीकरण:

                  a is first cmdline arg (implicit)
            a^s   Split a on spaces
{         }M      Map this function to each element:
 Ia                 If the word is not empty,
   UC:a@0             uppercase its first character
         a          Return the word
                  Output the resulting list (implicit) joined on spaces (-s flag)

पिप की एक दिलचस्प विशेषता यह है कि यह कार्यक्रम ड्रॉ पर :असाइनमेंट मेटा-ऑपरेटर है। अधिकांश सी-लाइक भाषाओं में कम्प्यूट-एंड-असाइन ऑपरेटर्स के कुछ सेट होते हैं: जैसे x*=5वही काम करता है x=x*5। पिप में, हालांकि, आप हमले कर सकते हैं :पर किसी भी ऑपरेटर और यह एक गणना और असाइन ऑपरेटर में बदल जाते हैं। यह भी एकतरफा ऑपरेटरों के लिए जाता है। तो -:xगणना करता है -xऔर इसे वापस करने के लिए असाइन करता है x, जैसा कि x:-xहोगा। इस मामले में,UC: एक शब्द के पहले चरित्र को बड़ा करने के लिए (पिप के उत्परिवर्तनीय तार के साथ) का उपयोग किया जाता है।

प्रोग्राम कमांड-लाइन से इनपुट लेता है, इस तरह एक आह्वान की आवश्यकता होती है:

python3 pip.py -se "{IaUC:a@0a}Ma^s" "test teSt TEST  _test"
— DLosc
स्रोत
2

सी, 125

समाधान की कमी नहीं है, लेकिन मैं वास्तव में सी में गोल्फ पसंद करता हूं।

char b[99];main(c){while(scanf("%[A-Za-z_-]",b)==1)islower(*b)&&(*b&=223),printf("%s",b);~(c=getchar())&&putchar(c)&&main();}

ungolfed:

char b[99];
main(c)
{
  while(scanf("%[A-Za-z_-]", b) == 1) {
    if(islower(b[0])) {
      b[0] &= 0xDF;
    }
    printf("%s", b);
  }
  if((c = getchar()) != -1) {
      putchar(c);
      main();
  }
}

मुझे नहीं पता कि रेगेक्स की तरह सिंटैक्स का उपयोग करने वाले scanfमट्ठे नियमों को तोड़ रहे हैं, लेकिन यह काफी अच्छी तरह से काम करता है। (खैर, तकनीकी रूप से यह पूर्ण रीगेक्स नहीं है )

एक अन्य बात पर विचार करना है कि यह कोड केवल 99 बाइट्स से कम शब्दों के लिए काम करता है। लेकिन मुझे लगता है कि यह समाधान ज्यादातर मामलों के लिए काम करेगा।

— MarcDefiant
स्रोत
संकेत: & = 223 -> - = 32
— edc65
2

PHP, 82

echo join(' ',array_map(function($s){return ucfirst($s);},explode(' ',$argv[1])));

उपयोग: 

$ php code.php "eCommerce rocks. crazyCamelCase stuff. _those  pigeon-toed shennanigans. Fiery trailblazing 345 thirty-two Roger. The quick brown fox jumped over the lazy dogs. Clancy Brown would have been cool as Lex Luthor. good_bye"
— kuldeep.kamboj
स्रोत
2

सी #, 133 131

using C=System.Console;class P{static void Main(){var s=2>1;foreach(var c in C.ReadLine()){C.Write(s?char.ToUpper(c):c);s=c==32;}}}
— Blorgbeard
स्रोत
क्या आपको जरूरत है &&c!=32? मैं C # में बहुत ज्यादा धाराप्रवाह नहीं हूं, लेकिन मुझे लगता है कि एक स्पेस को अपरकेस में बदलना एक स्पेस में परिणाम देगा।
— DLosc
वूप्स, धन्यवाद - इससे पहले कि मैं कुछ और बदलाव करता, मुझे लगता है। आप सही हैं इसकी जरूरत नहीं है।
— ब्लोर्गरर्ड
"C = System.Console का उपयोग करके देखें" सिस्टम का उपयोग करने के बजाय
— इवान
2

मैथेमेटिका, 66 बाइट्स

Print@StringReplace[InputString[],WordBoundary~~a_:>ToUpperCase@a]

मैं उपयोग करूँगा ToCamelCase, लेकिन यह रिक्ति को संरक्षित नहीं करता है।

— LegionMammal978
स्रोत
2

आर, 139 105 बाइट्स

for(i in 1:length(p<-strsplit(readline(),"")[[1]])){if(i<2||p[i-1]==" ")p[i]=toupper(p[i])};cat(p,sep="")

असंगठित + स्पष्टीकरण:

# Assign p to be a vector of the input read from stdin, split into characters

for(i in 1:length(p <- strsplit(readline(), "")[[1]])) {

    # If we're at the first iteration or the previous character was a space

    if (i < 2 || p[i-1] == " ") {

        # Convert the current character to its uppercase equivalent

        p[i] <- toupper(p[i])
    }
}

# Join the vector elements into a single string and print it to stdout
cat(p, sep = "")

आरजेक्स के साथ आर, 49 41 + 30 = 71 बाइट्स

मैं वास्तव में चकित हूँ; यह वास्तव में दंड के साथ नियमित अभिव्यक्ति का उपयोग करते हुए एक बेहतर स्कोर है।

gsub("(^.| +.)","\\U\\1",readline(),pe=T)

यह स्ट्रिंग की शुरुआत में या किसी भी स्थान के बाद किसी भी एकल वर्ण से मेल खाता है और इसे कैप्चर के अपरकेस संस्करण के साथ बदल देता है। ध्यान दें कि आवेदन \\Uकरना वैध है और गैर-पत्रों के लिए कोई प्रभाव नहीं है। pe=Tइसकी व्याख्या इसलिए की जाती है perl = TRUEक्योंकि यह R के आंशिक रूप से फ़ंक्शन मापदंडों के मिलान और उसके पर्याय का लाभ उठाता है TRUE। जो भी कारण के लिए, आर डिफ़ॉल्ट रूप से पर्ल-शैली नियमित अभिव्यक्ति का उपयोग नहीं करता है।

Regex दृष्टिकोण पर 8 बाइट्स को बचाने में मदद करने के लिए मिकी का धन्यवाद!

— एलेक्स ए।
स्रोत
अपने regex के साथ मिलान स्ट्रिंग हो सकता है (^.| +.)। किसी भी चीज को ऊपर ले जाना ठीक है।
— मिकी
@ मिक्की: अच्छा विचार, धन्यवाद! अपने सुझाव का उपयोग करने के लिए संपादित।
— एलेक्स ए
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.