CamelCase में परिवर्तित करें

34

चुनौती

मैं दूसरे दिन Google के जावा स्टाइल गाइड को पढ़ रहा था और किसी भी मनमाने स्ट्रिंग को कैमलकेस नोटेशन में बदलने के लिए उनके एल्गोरिथ्म पर ठोकर खाई। इस चुनौती में आपको इस एल्गोरिथ्म को लागू करना होगा क्योंकि आप यह सब कुछ अपने सिर में नहीं करना चाहते हैं जब आप अपने सुपर प्रतिस्पर्धी जावा सबमिशन को कोड-गोल्फ चुनौतियों के लिए लिख रहे हैं।

नोट: मैंने एल्गोरिथ्म में कुछ छोटे समायोजन किए। आपको नीचे निर्दिष्ट एक का उपयोग करने की आवश्यकता है।

एल्गोरिथ्म

आप एक मनमाना इनपुट स्ट्रिंग के साथ शुरू करते हैं और इसके लिए निम्नलिखित ऑपरेशन लागू करते हैं:

  1. सभी apostrophes निकालें `'
  2. परिणाम को शब्दों में विभाजित करके विभाजित करें
    • ऐसे अक्षर जो अल्फ़ान्यूमेरिकल नहीं हैं और अंक नहीं हैं [^a-zA-Z0-9]
    • अपरकेस अक्षर जो दोनों तरफ लोअरकेस अक्षरों से घिरे होते हैं। abcDefGhI jkउदाहरण के लिए पैदावारabc Def Ghi jk
  3. हर शब्द को छोटा करें।
  4. हर शब्द का पहला अक्षर अपरकेस।
  5. सभी शब्दों को एक साथ जोड़ दें।

अतिरिक्त नोट्स

  • इनपुट में केवल मुद्रण योग्य ASCII होगा।
  • यदि कोई अंक किसी शब्द में पहला अक्षर है, तो इसे छोड़ दें और इसे इस शब्द में और कुछ न दें।
  • इनपुट में हमेशा कम से कम एक वर्ण होगा।

नियम

परीक्षण के मामलों

"प्रोग्रामिंग पहेलियाँ और कोड गोल्फ" -> "प्रोग्रामिंगपीकसकोडकोड"
"XML HTTP अनुरोध" -> "xmlHttpRequest"
"iOS पर IPv6 का समर्थन करता है?" -> "supportIpv6OnIos"
"SomeThing w1th, apo'strophe's और 'punc] tuation" -> "someThingW1thApostrophesAndPuncTuation"
"कुछ खास नहीं" -> "कुछ खास नहीं"
"5 स्पेशल सी 5" -> "5 स्पेशल सी 5"
"1337" -> "1337"
"1337-स्पाईक" -> "1337Speak"
"व्हाट्स मेस" -> "व्हाट्सएप"
"abcD" -> "abcd"
"a" -> "a"
"बी" -> "बी"

हैप्पी कोडिंग!

code-golf  string 
— Denker
स्रोत
3
दिलचस्प है, मुझे कभी नहीं पता था कि इसे "कैमलकेस" कहा जाता था। नाम है फिटिंग I suppose ...
— अश्विन गुप्ता
4
अधिक हैं: snake_case&PascalCase
— मार्टिज़न
14
@ पर्टन की snake_caseवजह से मर्टिजन , बिल्कुल। FORTH के पास भी है FORTHCASEऔर एपीएल के पास हैunreadable in any case
— बिल्ली
टेस्ट केस 4 ApostropheSआउटपुट में होना चाहिए ।
— टाइटस
@ टिट्स नहीं, यह सही है। इनपुट के छींटे पड़ने से पहले एपोस्ट्रोफिस हटा दिए जाते हैं।
— डेनकर

जवाबों:

13

रेटिना , 56 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

T`'\`
S_`\W|_|(?<=[a-z])(?=[A-Z][a-z])
T`L`l
T`l`L`¶.
¶

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

व्याख्या

यह विनिर्देश को सचमुच में लागू करता है:

T`'\`

Apostrophes और backticks निकालें।

S_`\W|_|(?<=[a-z])(?=[A-Z][a-z])

गैर-शब्द वर्णों के चारों ओर स्ट्रिंग को विभाजित करें (regex में यह अंक और अंडरस्कोर को भी बाहर करता है), या अंडरस्कोर या स्थिति जिसमें बाईं ओर एक निचला केस लेटर और ऊपरी केस, दाईं ओर निचला केस होता है। यह कुछ खाली खंडों का निर्माण करेगा जब एक पंक्ति में दो गैर-अक्षर, गैर-अंक वर्ण या स्ट्रिंग की शुरुआत में अधिक महत्वपूर्ण हो। हम _विकल्प के साथ उन लोगों से छुटकारा पा लेते हैं । यहां, "विभाजन" का अर्थ है कि प्रत्येक शेष भाग को अपनी लाइन पर रखा जाए।

T`L`l

लोअर केस में सब कुछ कन्वर्ट करें।

T`l`L`¶.

प्रत्येक वर्ण को कनवर्ट करें जो ऊपरी मामले में लाइनफ़ीड के बाद होता है। यह आसानी से पहला शब्द छोड़ देगा क्योंकि इसके सामने कोई लाइनफीड नहीं है।

सब कुछ एक साथ वापस करने के लिए लाइनफ़ीड से छुटकारा पाएं।

— मार्टिन एंडर
स्रोत
आपने मुझे इसमें हरा दिया। अच्छा है!
— mbomb007
यह सवाल थोड़ा अजीब हो सकता है, लेकिन ... क्या मुझे अपना जवाब पोस्ट करना चाहिए अगर यह आपसे छोटा है और रेटिना में भी है? आपके उत्तर के सामने आने से पहले मैं इस पर काम कर रहा था, लेकिन तब इसने किया और अब मुझे नहीं पता कि मुझे इसे पोस्ट करना चाहिए या नहीं।
— डेवको
5
@daavko ज़रूर, इसे पोस्ट करें (मैं आमतौर पर यह तय करता हूं कि मौजूदा उत्तर के लिए दृष्टिकोण कितना अलग है ... अगर यह बाइट के साथ ठीक वैसा ही है, तो कहीं न कहीं मैं आमतौर पर उस उत्तर पर टिप्पणी करता हूं, लेकिन अगर यह बहुत छोटा है एक अलग दृष्टिकोण का, तो मैं सिर्फ एक अलग उत्तर पोस्ट करूंगा)।
— मार्टिन एंडर
2
@daavko लुकअप हालांकि आवश्यक है। ध्यान दें कि आपका उत्तर Thingहालांकि इसके कैपिटलाइज़ेशन को बरकरार नहीं रखता है ।
— मार्टिन एंडर
1
@ मार्टिनबटनर ओह ... मैंने उस पर ध्यान नहीं दिया। ओह ठीक है, मैं सफलतापूर्वक कुछ अन्य चुनौती का जवाब दूंगा।
— डेवको
11

जावा, 198 190 बाइट्स

+3 बाइट्स क्योंकि मैं भूल गया कि \W+== [^a-zA-Z0-9_]+और मुझे मैच की जरूरत है[^a-zA-Z0-9]+

-11 बाइट्स उपयोगकर्ता20093 के लिए धन्यवाद - के ?:बजाय if/else

क्योंकि, जावा।

s->{String[]a=s.replaceAll("`|'","").split("[\\W_]+|(?<=[a-z])(?=[A-Z][a-z])");s="";for(String w:a){String t=w.toLowerCase();s+=a[0]==w?t:t.toUpperCase().charAt(0)+t.substring(1);}return s;}

यह एक लंबोदर है। ऐसे करें कॉल:

UnaryOperator<String> op = s->{String[]a=s.replaceAll("`|'","").split("[\\W_]+|(?<=[a-z])(?=[A-Z][a-z])");s="";for(String w:a){String t=w.toLowerCase();s+=a[0]==w?t:t.toUpperCase().charAt(0)+t.substring(1);}return s;};
System.out.println(op.apply("Programming Puzzles & Code Golf"));

पठनीय संस्करण:

public static String toCamelCase(String s) {
    String[] tokens = s
            .replaceAll("`|'", "") // 1. Remove all apostrophes
            .split("[\\W_]+|(?<=[a-z])(?=[A-Z][a-z])"); // 2. Split on [\W_]+ or between [a-z] and [A-Z][a-z]
    s = ""; // Reusing s for building output is cheap
    for (String token : tokens) {
        String lowercaseToken = token.toLowerCase(); // 3. Lowercase every word
        s += tokens[0].equals(token)?lowercaseToken:lowercaseToken.toUpperCase().charAt(0) + lowercaseToken.substring(1); // 4. Uppercase first char of all but first word
        // ^ 5. Join all words back together
    }
    return s;
}
— CAD97
स्रोत
1
यह स्विफ्ट नहीं है ...
— कैलकुलेटर
2
प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! यह एक अच्छा पहला जवाब है!
— एलेक्स ए।
1
@CatsAreFluffy क्या?
— बिल्ली
यदि आप सशर्त अभिव्यक्ति (यदि / और) को सशर्त अभिव्यक्ति के साथ प्रतिस्थापित करते हैं (! :) आप लगभग 9 बाइट बचा सकते हैं
— user902383
पता नहीं कैसे मैंने याद किया कि @ user902383 - -11 बाइट्स के लिए जोड़ा गया। दुर्भाग्य से मुझे मैच के साथ 3 भी जोड़ना पड़ा_ एक टोकन सीमांकक के रूप में ।
— CAD97
10

जावास्क्रिप्ट (ईएस 6), 156 154 152 148 145 141 140 बाइट्स

धन्यवाद @Neil (6 बाइट्स), @ETHproductions (3 बाइट्स), और @ edc65 (7 बाइट्स)

a=>a[r='replace'](/`|'/g,a='')[r](/[a-z](?=[A-Z][a-z])/g,'$& ')[r](/[^\W_]+/g,b=>a+=(a?b[0].toUpperCase():'')+b.slice(!!a).toLowerCase())&&a

एपोस्ट्रोफ्स को हटाता है, फिर विशेष वर्णों पर विभाजित करने के लिए प्रतिस्थापित करता है / पहले से घिरा हुआ राजधानियों से, फिर उचित आवरण के साथ जोड़ता है। दुर्भाग्य से, toLowerCase()और toUpperCase()यहाँ से बचने के लिए लंबे और कठिन हैं ...

— Mwr247
स्रोत
1
मैं एक अलग दृष्टिकोण पर काम कर रहा था, जो कि आपका b.slice(i>0)दृष्टिकोण पानी से बाहर निकलता है, लेकिन इस बीच में मेरा मैच रेगेक्स /[A-Z]?([a-z0-9]|[0-9A-Z]{2,})+([A-Z](?![a-z]))?/gआपके अन्यथा सरल replaceदृष्टिकोण पर 2 बाइट्स को बचाने के लिए प्रकट होता है ।
— नील
1
या मैं आपके replaceसीधे पर 2 बाइट्स बचा सकता था :replace(/[a-z](?=[A-Z][a-z])/g,'$& ')
— नील
1
आमतौर पर match...mapइसके साथ प्रतिस्थापित किया जा सकता हैreplace
— edc65
1
@ edc65 मुझे उस दृष्टिकोण के साथ न्यूनतम 160 बाइट्स a=>a.replace(/`|'/g,'').replace(/[a-z](?=[A-Z][a-z])/g,'$& ').replace(/[\W_]*([a-z0-9]+)[\W_]*/gi,(_,b,i)=>(i?b[0].toUpperCase():'')+b.slice(i>0).toLowerCase())
— मिलते हैं
2
दूसरी ओर, मैं पेशकश करना चाहूंगा b=>a+=(a?b[0].toUpperCase():'')+b.slice(!!a).toLowerCase()जो मेरा मानना ​​है कि आपको एक और 4 बाइट्स बचाता है।
— नील
7

विम, ६ ९ 68 66

:s/[`']//g<cr>:s/[a-z]\zs\ze[A-Z][a-z]\|\W\|_/\r/g<cr>o<esc>guggj<C-v>GgU:%s/\n<cr>

पर्ल की तुलना में कम विम ?! ये क्या पागलपन हे?

:s/[`']//g<cr>           remove ` and '
:s/                      match...
 [a-z]\zs\ze[A-Z][a-z]   right before a lowercase-surrounded uppercase letter
 \|\W\|_                 or a non-word char or underscore
 /\r/g<cr>               insert newlines between parts
o<esc>                   add an extra line at the end, necessary later...
gugg                     lowercasify everything
j                        go to line 2 (this is why we added the extra line)
<C-v>G                   visual select the first char of all-but-first line
gU                       uppercase
:%s/\n<cr>               join all lines into one

एक बेकार कीस्ट्रोक को खोलने के लिए नील को धन्यवाद !

— Doorknob
स्रोत
मैं देख सकता हूं कि आखिरी क्यों :sहै %लेकिन पहले दो में असंगति क्यों है?
— नील
@ नील बह, मांसपेशी स्मृति। धन्यवाद!
— दरवाज़े
5
पर्ल से भी कम पठनीय होने का प्रबंधन करता है, बहुत +1
— बिल्ली
मैं इसे पूरी तरह से अपने .vimrc
— Moopet
1
@fruglemonkey 1. :%j<cr>समकक्ष और छोटा है। 2. जो लाइनों के बीच रिक्त स्थान जोड़ता है।
— दरवाज़े
5

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

""<>(ToCamelCase@{##2}~Prepend~ToLowerCase@#&@@StringCases[StringDelete[#,"`"|"'"],WordCharacter..])&

अनिर्दिष्ट का उपयोग करता है ToCamelCase, जो समान रूप से काम करता है, Capitalizeलेकिन अन्य वर्णों को कम करने के लिए सेट करता है ।

— LegionMammal978
स्रोत
10.3.0 में नहीं ..
— ए सिमन्स 14
है ToCamelCase[n_,m_]:=n<>Capitalize/@mसही? इसी की तरह लगता है। और Prependजब #~ToCamelCase~{##2}काम करता है तो उपयोग क्यों करें ?
— कैलक्यूलेटरफलाइन
@CatsAreFluffy जो मुझे देता हैToCamelCase::argx: ToCamelCase called with 2 arguments; 1 argument is expected.
— लीजनमैनल 978
खैर, CamelCase कैसे काम करता है? बस ToCamelCase[n_]:=""<>Capitalize/@n?
— कैलक्यूलेटरफलाइन
@CatsAreFluffy, देखना यह ।
— लीजियनममाल 978
5

जूलिया, 98 89 बाइट्स

s->lcfirst(join(map(ucfirst,split(replace(s,r"['`]",""),r"[a-z]\K(?=[A-Z][a-z])|\W|_"))))

यह एक अनाम फ़ंक्शन है जो एक स्ट्रिंग को स्वीकार करता है और एक स्ट्रिंग लौटाता है। इसे कॉल करने के लिए, इसे एक वैरिएबल पर असाइन करें।

दृष्टिकोण यहाँ में दरवाज़े के रूप में ही है पर्ल जवाब : replace, अक्षर लोप और रिक्त स्ट्रिंग के साथ बैकटिक splitकि आवश्यक मामलों से मेल खाता है एक नियमित अभिव्यक्ति पर एक सरणी में, सरणी पर समारोह प्रत्येक तत्व, के पहले अक्षर को अपरकेस में सरणी वापस एक स्ट्रिंग में, और पहले चरित्र को लोअरकेस में बदलने के लिए परिणाम।mapucfirstjoinlcfirst

— एलेक्स ए।
स्रोत
मैंने जूलिया को हमेशा एक अधिक कार्यात्मक, अधिक दिलचस्प पायथन के रूप में पसंद किया है लेकिन मुझे endवाक्य रचना से नफरत है । शायद मैं हर चीज के लिए अनाम कार्यों का उपयोग करूंगा, फिर मुझे कभी टाइप नहीं करना होगा end: D
— cat
4

पर्ल 67 + 1 = 68 बाइट्स

y/'`//d;s/([a-z](?=[A-Z][a-z]))|\W|_/$1 /g;$_=lc;s/^ +| +(.)/\u$1/g

-pध्वज की आवश्यकता है , और -lबहु लाइन के लिए:

$ perl -pl camelCase.pl input.txt
programmingPuzzlesCodeGolf
xmlHttpRequest
supportsIpv6OnIos:
someThingW1thApostrophesAndPuncTuation
nothingSpecial
5pecialCa5e
1337
1337Speak
abcd

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

y/'`//d;                            # Remove ' and `
s/([a-z](?=[A-Z][a-z]))|\W|_/$1 /g; # Replace according to '2. Split...' this will create
                                    #   a space separated string.
$_=lc;                              # lower case string
s/^ +| +(.)/\u$1/g                  # CamelCase the space separated string and remove any
                                    #   potential leading spaces.
— andlrc
स्रोत
2

पर्ल, 87 80 78 बाइट्स

y/'`//d;$_=join'',map{ucfirst lc}split/[a-z]\K(?=[A-Z][a-z])|\W|_/,$_;lcfirst

बाइट -pध्वज के लिए जोड़ा गया ।

सबसे पहले, हम इनपुट में सभी वर्णों y///को dहटाने के लिए लिप्यंतरण ऑपरेटर का उपयोग करते हैं '`:

y/'`//d;

फिर कोड का मांस आता है:

                         split/[a-z]\K(?=[A-Z][a-z])|\W|_/,$_;

( वास्तविक स्ट्रिंग से पूर्ववर्ती भाग को बाहर करने के लिए मैच स्ट्रिंग में $_फैंसी का उपयोग करके उचित स्थानों में इनपुट स्ट्रिंग को विभाजित करें \K)

          map{ucfirst lc}

(स्ट्रिंग के प्रत्येक विभाजित हिस्से पर मैप करें और पूरे स्ट्रिंग को लोअरकेस करें, फिर संशोधित स्ट्रिंग अपरकेस का पहला चरित्र बनाएं)

$_=join'',

(खाली स्ट्रिंग में शामिल हों और मैजिक अंडरस्कोर पर फिर से असाइन करें $_, जो अंत में प्रिंट हो जाता है)

अंत में, हम पहले अक्षर को रेगेक्स-मेल करके इसे कम करते हैं और\l पिछली स्ट्रिंग के साथ 2 बाइट्स को बचाते हुए, बिलिन के साथ रिप्लेसमेंट स्ट्रिंग में उपयोग करते हैं :

lcfirst

7 बाइट्स ( -> ) के लिए @ मार्टिनबटनर को धन्यवाद ![^a-zA-Z\d]\W|_

— Doorknob
स्रोत
1
मैं कैसे ईर्ष्या करता हूं कि \K...;)
— मार्टिन एंडर
2

लूआ, 127 बाइट्स

t=''l=t.lower z=io.read()for x in z:gmatch('%w+')do t=t..(t==''and l(x:sub(1,1))or x:sub(1,1):upper())..l(x:sub(2))end return t

स्टड से एक स्ट्रिंग स्वीकार करता है और संगठित परिणाम देता है।

शायद अभी भी एक बेहतर समाधान के लिए देखने के लिए के रूप में एक चर में सब कुछ अक्षम लगता है।

लेकिन किसी भी तरह, सामान्य में बहुत सरल:

 z:gmatch('%w+')

यही वह सौंदर्य है जिसने मुझे थोड़ी-बहुत बाइट्स से बचाया। gmatch पैटर्न के आधार पर स्ट्रिंग को विभाजित करेगा:%w+ जो केवल अल्फ़ान्यूमेरिक्स को पकड़ता है।

इसके बाद यह सरल स्ट्रिंग ऑपरेशन है। string.upper, string.lower और किया।

— Skyl3r
स्रोत
2

PHP, 145 122 133 बाइट्स

<?=join(split(" ",lcfirst(ucwords(strtolower(preg_replace(["#`|'#","#\W|_#","#([a-z])([A-Z][a-z])#"],[""," ","$1 $2"],$argv[1]))))));

फ़ाइल को सहेजें, सीएलआई से कॉल करें।
एक एकल कमांड लाइन तर्क से इनपुट लेता है; जहाँ आवश्यक हो, उद्धरण और व्हाट्सएप से बच जाएँ।

टूट - फूट

<?=                 // 9. print result
join(split(" ",     // 8. remove spaces
    lcfirst(        // 7. lowercase first character
    ucwords(        // 6. uppercase first character in every word
    strtolower(     // 5. lowercase everything
    preg_replace(
        ["#`|'#",   "#\W|_#",   "#([a-z])([A-Z][a-z])#"],
        ["",        " ",        "$1 $2"],
        // 2. replace apostrophes with empty string (remove them)
                    // 3. replace non-word characters with space
                                // 4. insert space before solitude uppercase
        $argv[1]    // 1. take input from command line
    ))))
));

lcfirst23 बाइट्स सहेजते हुए, इसे एक एकल आदेश में कम करने की अनुमति दी गई है।
अतिरिक्त रिप्लेस केस के लिए एपोस्ट्रोफिस को ठीक करने में 11 बाइट्स का खर्च आता है।

— टाइटस
स्रोत
1

कोटलिन , 160 बाइट्स

fun a(s: String)=s.replace(Regex("['`]"),"").split(Regex("[\\W_]+|(?<=[a-z])(?=[A-Z][a-z])")).map{it.toLowerCase().capitalize()}.joinToString("").decapitalize()

मेरा लक्ष्य स्कैला होना था, अन्य "वैकल्पिक जावा", इसलिए मैं अपने परिणामों से कुछ खुश हूं। मैंने जावा से रेगेक्स चुरा लिया उत्तर ।

इसके साथ परीक्षण करें: 

fun main(args: Array<String>) {
    val testCases = arrayOf(
            "Programming Puzzles & Code Golf",
            "XML HTTP request",
            "supports IPv6 on iOS?",
            "SomeThing w1th, apo'strophe's and' punc]tuation",
            "nothing special",
            "5pecial ca5e",
            "1337",
            "1337-spEAk",
            "abcD",
            "a",
            "B")
    testCases.forEach { println(a(it)) }

}
— नाथन मेरिल
स्रोत
इस बिंदु पर मुझे लगता है कि हर कोई अनुकूलित रेगेक्स को "उधार" ले रहा है \W|_|(?<=[a-z])(?=[A-Z][a-z])या इसे थोड़ा संशोधित कर रहा है। [\W_]+
— 20 नवंबर को CAD97
आप नक्शे और विस्तार समारोह पर कुछ बचा सकता हैfun String.a()=replace(Regex("['`]"),"").split(Regex("[\\W_]+|(?<=[a-z])(?=[A-Z][a-z])")).joinToString(""){it.toLowerCase().capitalize()}.decapitalize()
— poss
1

स्काला, 181 170 144

def f(s:String)={val l=s.replaceAll("'|`","")split("[\\W_]+|(?<=[a-z])(?=[A-Z][a-z])")map(_.toLowerCase);l(0)+l.tail.map(_.capitalize).mkString}

परीक्षक:

val testCases = List(
  "Programming Puzzles & Code Golf" -> "programmingPuzzlesCodeGolf",
  "XML HTTP request" -> "xmlHttpRequest"
  // etc
)
println(testCases.map(t=>if(t._2!=f(t._1))s"FAIL:${f(t._1)}"else"PASS").mkString("\n"))

CAD97 को प्रमाणित करता है और नाथन मेरिल को माफी देता है :)

— gladed
स्रोत
1
के [^a-zA-Z0-9]+साथ बदलकर आप 6 बाइट्स बचा सकते हैं [\\W_]+।
— 2097 पर CAD97
0

C 272 वर्ण

C प्रोग्राम पास स्ट्रिंग स्ट्रिंग टू कैमेलकेस इन कोट्स 1 आर्ग्युमेंट 1. इस समस्या स्टेटमेंट में बहुत सारे गोटेक हैं ...

#define S strlen(t)
#define A isalnum(t[i])
j=0;main(i,v)char**v;{char*p=v[1],*t;char o[99]={0};while(t=strtok(p," [{(~!@#$%^*-+=)}]")){i=0;p+=S+1;while((!A)&&i<S)i++;if(i!=S){o[j]=((j++==0)?tolower(t[i++]):toupper(t[i++]));while(i<S){if(A)o[j++]=t[i];i++;}}}puts(o);}
— cleblanc
स्रोत
आप की जरूरत #include<string.h>के लिए strlen, strtokहै, और toupper, और #include<ctype.h>के लिए isalnum।
— मेगो
मुझे इसकी जरूरत नहीं थी। उन्हें अपने आप में जुड़ा हुआ होना चाहिए, बाहरी अंतरंग मानते हुए।
— क्लेब्लांक
साथ ./camel "Programming Puzzles & Code Golf"cygwin पर (जीसीसी 3.4.4 के साथ संकलित), मैं programmingPuzzlesCodeEGolf। 5.3.0 के साथ एक ही आउटपुट।
— मेगो
बकवास। मैं भी। मैंने इसे गोल्फ करते समय एक बग बनाया होगा। मैं इसे अब देख रहा हूँ ...
— क्लेब्लांक
समस्या यह थी कि मुझे गोल्फिंग के बाद अन्य टोकेन्जर तार जोड़े गए और इसका पर्याप्त परीक्षण नहीं किया। यदि आप strtok कॉल से '&' हटाते हैं तो यह उस इनपुट पर काम करता है।
— क्लेब्लांक
0

जावास्क्रिप्ट, 123 बाइट्स

v=>v[r="replace"](/[`']/g,"")[r](/^.|.$|[A-Z][^a-z]+/g,x=>x.toLowerCase())[r](/[^a-z0-9]+./ig,x=>x.slice(-1).toUpperCase())

पठनीय संस्करण

v=>
  v.replace(/[`']/g,"")
  .replace(/^.|.$|[A-Z][^a-z]+/g,x=>x.toLowerCase())
  .replace(/[^a-z0-9]+./ig,x=>x.slice(-1).toUpperCase())

एपोस्ट्रोफ़्स निकालें, पहला चरित्र कम केस, अंतिम चरित्र लोअरकेस, और कई अपरकेस वर्णों के किसी भी समूह को 1 या अधिक गैर-अल्फ़ान्यूमेरिक वर्ण + 1 अन्य वर्ण के किसी भी समूह से मिलाएं, उस अंतिम अक्षरों को कैपिटल में बदलें।

[r = "बदलें"] Mrw247 के समाधान से चाल।

— Grax32
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.