कोडिंग कन्वेंशन रूपांतरण

Question

उस कोडिंग गोल्फ में, आपको शीर्षक कोड के साथ एक कोडिंग कन्वेंशन को लोवर_केस_विथ_संडर्सकोर्स में बदलना चाहिए। और इसके विपरीत!

विशिष्टता

आवरण को निम्नलिखित तरीके से बदलें:

• यदि अंडरस्कोर वर्ण एक सीमांकक है, तो केसिंग को बिना किसी परिसीमन के शीर्षक केस में बदल दें।
• यदि कोई सीमांकक के साथ कई शब्द हैं, तो आवरण को निचले मामले में बदलें और एक सीमांकक चरित्र को एक सीमांकक के रूप में जोड़ें।
• केवल एक शब्द (या एक चरित्र) के मामले में: केस को शीर्षक केस में बदल दें यदि शब्द निचले मामले से शुरू होता है; ऊपरी मामले से शुरू होने पर केसिंग को लोअर केस में बदल दें।

अनुमत वर्ण:

• ए से ज़ेड तक
• ए से ज़ेड तक
• अंडरस्कोर ( _)।

मिश्रित आवरण वाले शब्दों के साथ इनपुट अस्वीकृत हैं। अस्वीकृत मामलों के उदाहरण:

• Coding_Convention_Conversion
• a_BC

उदाहरण मामलों

Input                        | Expected Output
===========================================================
CodingConventionConversion   | coding_convention_conversion
coding_convention_conversion | CodingConventionConversion
abc                          | Abc
Abc                          | abc
ABC                          | a_b_c
a_b_c                        | ABC
a                            | A
A                            | a

नियम

• इसे उपयोग करने की अनुमति है ToUpper, ToLowerऔर ToTitleCaseकार्य।
• नियमित अभिव्यक्ति का उपयोग करने की अनुमति है।
• कोड-गोल्फ : बाइट्स जीत में सबसे छोटा कोड!

Comments

क्या एक ToTitleCaseफ़ंक्शन का उपयोग करना ठीक है? आपने निर्दिष्ट नहीं किया, इसलिए मैं मान लूंगा कि यह ठीक है।

— जस्टिन

@ जस्टिन: अच्छा सवाल। चलिए इसे और मज़ेदार बनाते हैं और ToTitleCase फ़ंक्शन को अस्वीकार करते हैं :)

— Dariusz

डारन ... मेरा समाधान इस पर निर्भर करता है

— जस्टिन

@ जस्टिन: ठीक है - मैंने इसे शुरुआत में निर्दिष्ट नहीं किया, इसलिए उस मामले में - चलो इसे वैसे भी अनुमति दें।

— डेरियस वोजनियाक

Answer 1

पायथ, 25 बाइट्स 29 33 35 40

@Dennis के लिए धन्यवाद 2 बाइट्स सहेजे गए

सहेजे गए 4 बाइट्स @FryAmTheEggman की बदौलत

?rIz0smrd4cz\_tsXzrG1*\_G

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

Comments

आपके लिंक को अपडेट करना होगा।

— ईसैक

जब मैं इनपुट के रूप में "एबीसी" डालने की कोशिश करता हूं, तो यह आउटपुट के रूप में "बीसी" देता है। बग? :)

— डेरियस वोजनीक

क्या @ DariuszWoźniak देखा, तो आप से अपनी हालत बदल सकते हैं ठीक करने के लिए /z\_करने के लिए rIz0। मेरा यह भी मानना ​​है कि मुझे अंडरस्कोर प्रोग्राम जोड़ने का एक समान लंबाई वाला विकल्प मिला: tsXzrG1_Mcj\_G2हो सकता है कि कोई इसे और अधिक गोल्फ कर सकता है ...

— FryAmTheEggman

आह, यह पाया:tsXzrG1*\_G

— FryAmTheEggman

Answer 2

जोल्फ, 35 बाइट्स

@ C Sav O'B thanks को 1 बाइट देता है । यह ISO 8859-7 में इनकोडेड है।

? hI'_ΜGI'_dpyH0pxRGIL0"(?=[A-Z])'_

वोहू मेरा पहला जोल्फ कार्यक्रम!

व्याख्या

   // I = input
? hI'_                              // If input contains _
       GI'_                          // Split on _
      Μ    d                         // Loop, then join
            pyH0                     // Make the first character uppercase
                                    // ELSE...
                  RGIL0"(?=[A-Z])    // Split *after* all uppercase chars
                                 '_  // join with _ 
                px                   //Make lowercase

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

Comments

आप अंत में स्ट्रिंग जुदाई का उपयोग कर सकते हैं, इसलिए यह बन जाता है "(?=[A-Z])'_। स्ट्रिंग स्वचालित रूप से बंद है।

— कॉनर ओ'ब्रायन

@ C @O'Bʀɪᴇɴ ओह, शांत, धन्यवाद!

— डाउनगेट

Answer 3

रेटिना , ३,

4 बाइट बचाने के लिए @ मार्टिनबटनर को धन्यवाद!

^|[A-Z]
_$0
T`Ll`lL`_.
^_|_(?=[A-Z])

(अनुगामी न्यूलाइन पर ध्यान दें।)

इसे ऑनलाइन आज़माएं। ध्यान दें m`कि प्रत्येक इनपुट लाइन को अलग से इलाज करने के लिए कुछ पंक्तियों को कॉन्फ़िगर करने के लिए अतिरिक्त शामिल है ताकि सभी टेस्टकेस को एक बार में चलाया जा सके। यह प्रश्न की आवश्यकता नहीं है, इसलिए इन्हें अंक में नहीं गिना जाता है।

• लाइन्स 1 और 2 _या तो इनपुट की शुरुआत में या अपरकेस अक्षरों से पहले डालें । सभी शब्द अब हैं_मामले की परवाह किए बिना, -separated ।
• पंक्ति 3 प्रत्येक शब्द में पहले अक्षर का स्वैप मामला।
• लाइन्स 4 और 5 _इनपुट की शुरुआत में या तो अपरकेस अक्षर के बाद निकालते हैं।

Comments

यह चार बाइट्स बचाता है: retina.tryitonline.net/…

— मार्टिन

इसके अलावा, आप अंतिम पंक्ति को छोड़ कर ?=और उस चरण को प्रतिस्थापित करने से खाली रेखा से बच सकते हैं $1(हालांकि बाइट गिनती को प्रभावित नहीं करता है)।

— मार्टिन एंडर

@Martin बहुत अच्छा - धन्यवाद!

— डिजिटल ट्रॉमा

Answer 4

जीएनयू सैड, 46

2 बाइट बचाने के लिए @TobySpeight का शुक्रिया!

स्कोर में विकल्प -E(या -r) के लिए +1 शामिल है sed।

s/(^|_)([a-z])/\u\2/g
t
s/[A-Z]/_\l&/g
s/^_//

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

एकदम सीधी सीड:

• पंक्ति 1 के विकल्प पंक्ति की शुरुआत या _उसके बाद उस पत्र के ऊपरी मामले के साथ एक लोअरकेस अक्षर। gकरने के लिए ध्वज sप्रदर्शन पाया प्रत्येक उदाहरण के लिए इस प्रतिस्थापन
• t:अनाम प्रतिस्थापन के लिए कूदता है अगर उपरोक्त प्रतिस्थापन के लिए कोई मैच थे। यह लेबल अंत में निहित है।
• अन्यथा सभी अपरकेस अक्षरों को _उस पत्र के निचले मामले के साथ प्रतिस्थापित किया जाता है
• यह _पहले अक्षर से पहले एक अग्रणी छोड़ देता है। s/^_//वह निकाल देता है।

Comments

@ टॉबी धन्यवाद -Eमेरे GNU sed 4.2.2 (Ubuntu 14.04.3) में काम करता है, हालाँकि यह मैन पेज में नहीं है। मैंने कहीं पढ़ा [उद्धरण वांछित] कि -Eनया पॉज़िक्स विकल्प है जिसे आधिकारिक तौर पर एक नए रिलीज़ में जीएनयू सेड में जोड़ा जाएगा, लेकिन पहले से ही अनौपचारिक रूप से है। भले ही, -rसही काम -Eकरता है अगर आप के लिए काम नहीं करता है।

— डिजिटल ट्रॉमा

@ टॉबी लाइन 280-282 की sed / sed.c हैं /* Undocumented, for compatibility with BSD sed. */ case 'E': case 'r':।

— डिजिटल ट्रामा

@ दिगीतल - मुझसे गलती हुई; मेरे sed के लिए एक पर्याय के रूप में स्वीकार करता है । मैं सही ढंग से एक न्यूनतम कार्यक्रम पास नहीं कर रहा था जैसे-E-rsed -E -e Q

— टोबी स्पाइट

Answer 5

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

s=>s.replace(/[A-Z]|(^|_)(.)/g,(c,_,l,i)=>l?l.toUpperCase():(i?"_":"")+c.toLowerCase())

व्याख्या

रेगेक्स का कौन सा हिस्सा मेल खाता है इसके आधार पर, यह मैच को विपरीत स्थिति से बदल देता है।

s.replace(
  /[A-Z]|(^|_)(.)/g,
  (c,_,l,i)=>
    l?
      (i?"_":"")+c.toLowerCase()
    :l.toUpperCase()
)

परीक्षा

var solution = s=>s.replace(/[A-Z]|(^|_)(.)/g,(c,_,l,i)=>l?l.toUpperCase():(i?"_":"")+c.toLowerCase())

<input type="text" id="input" value="coding_convention_conversion" />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>

Answer 6

रूबी, 101 87 75 बाइट्स

->s{s.gsub(/^.|[A-Z]/,'_\0').gsub(/_./,&:swapcase).gsub(/_(?=[A-Z])|^_/,'')}

दुर्भाग्य से, यह बिल्कुल रेटिना समाधान के रूप में एक ही बात करता है, क्योंकि यह विधि समाप्त हो गई थी कि मैं जो कुछ भी आया था उससे कम है।

Answer 7

पायथन 3, 130 बाइट्स

कैप्स में विभाजित करने के लिए रेगेक्स का उपयोग करके त्वरित और गंदा प्रयास। सुंदर जानवर बल: अगर किसी को एक अलग दृष्टिकोण के साथ आ सकता है मुझे यकीन है कि यह पीटा जा सकता है।

import re
lambda s:('_'.join(re.findall('[A-Z][a-z]*',s)).lower(),''.join([a[0].upper()+a[1:]for a in s.split('_')]))[s.islower()]

Answer 8

PHP 160 बाइट्स

कम से कम नहीं, लेकिन पूर्णता के लिए यहाँ PHP में मेरा समाधान, $ s को बदलने के लिए स्ट्रिंग रखती है:

trim(preg_replace_callback('/((^[a-z]|_[a-z])|([A-Z]))/',function($m){return empty($m[2])?'_'.strtolower($m[3]):strtoupper(str_replace('_','',$m[2]));},$s),'_')

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ स्टैक एक्सचेंज में आपका स्वागत है। अच्छी तरह से एक भाषा में कुछ पोस्ट करने के लिए किया गया था जिसे आप जानते थे कि जीतने के लिए नहीं जा रहा है। कोड-गोल्फ चुनौतियां ज्यादातर भाषाओं में हैं, इसलिए गैर-गोल्फ भाषा का उपयोग करना अच्छा है। +1 d: -D

— wizzwizz4

Answer 9

पर्ल 6 ,  73 72 71   68 बाइट्स

{.comb(/<:Lu><:Ll>*|<:Ll>+/).map({/<:Lu>/??.lc!!.tc}).join('_'x?/<:Lu>/)} # 73
{.comb(/<:Lu><:Ll>*|<:L>+/).map({/<:Lu>/??.lc!!.tc}).join('_'x?/<:Lu>/)}  # 72
{/<:Lu>/??S:g/(^)?(<:Lu>)/{$0||'_'}$1.lc()/!!S:g/[^|_](<:Ll>)/$0.tc()/}   # 71
{.comb(/<:Lu><:Ll>*|<:L>+/).map({/<:Lu>/??.lc!!.tc}).join('_'x!/_/)}      # 68

उपयोग:

# give it a lexical name
my &code = {...}

for <CodingConventionConversion coding_convention_conversion abc Abc ABC a_b_c a A>
{ say .&code }

coding_convention_conversion
CodingConventionConversion
Abc
abc
a_b_c
ABC
A
a

स्पष्टीकरण:

{
  .comb( / <:Lu><:Ll>* | <:L>+ / ) # grab the "words" only
  .map({
      /<:Lu>/ # if the word has uppercase
    ??
      .lc     # lowercase the whole word
    !!
      .tc     # otherwise titlecase the word
   })
  .join(  # join the words
    '_'   # with '_'
    x     # repeated
    !/_/  # zero times if it had a _, otherwise once
  )
}

आप सोच रहे होंगे कि मैंने सिर्फ एक चरित्र वर्ग के बजाय यूनिकोड गुण ( <:Lu>, <:Ll>) का उपयोग क्यों किया । में पर्ल 6 वे अब से लिखे गए हैं [a-z]वे से लिखे गए हैं <[a..z]>जो बड़ा के रूप में 1.6 गुना है। कोष्ठकों [ … ]को गैर-कैप्चरिंग ग्रुपिंग के लिए उपयोग किया जाता है, जिसे (?: … )पर्ल 5 के रूप में लिखा गया था ।

Answer 10

जाप, 40 बाइट्स

UfV="%A" ?UrV@'_s!Y +Xv} :Ur"^.|_."_sJ u

इसे ऑनलाइन टेस्ट करें!

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

           // Implicit: U = input string
UfV="%A"   // Set variable V to the string "\\A", and get all matches in U.
?          // If the list is not null:
UrV@     } //  Replace each match X and its index Y with this function:
'_s!Y +Xv  //   Return "_".slice(!Y) (1 for Y=0, 0 for anything else) + X.toLowerCase().
:          // Otherwise:
Ur"^.|_."  //  Replace the char at the beginning and each char following an underscore with:
_sJ u      //   The last char of the match (the letter) .toUpperCase().

Answer 11

पर्ल 5, 42 बाइट्स

40 बाइट्स प्लस 2 के लिए -p(धन्यवाद, देव-नल )

s/[A-Z]/_\l$&/g||s/(^|_)(.)/\u$2/g;s/_//

Comments

विंडोज पर, पर्ल और MINGW32 का उपयोग करके, मुझे कोई आउटपुट नहीं मिलता है, मैं क्या याद कर रहा हूं?

— चैट्टरने

@ChatterOne मुझे नहीं पता कि MINGW32 क्या है, लेकिन इसने मेरे लिए स्ट्राबेरी पर्ल पर ठीक काम किया। के -Eबजाय का उपयोग करें -e।

— msh210

Answer 12

𝔼𝕊𝕄𝕚𝕟 3, 15 वर्ण / 32 बाइट्स (गैर-समरूप)

⟮ѨDZï⟯≠ï?Ⅰ:ѨȎѨƎï

Try it here (Firefox only).

v3 इस चुनौती के बाद जारी किया गया था, जिसमें बगफिक्स और लाइब्रेरी अपडेट्स का एक गुच्छा था।

व्याख्या

यह बिल्‍डिन का एक मैशअप है।

⟮ѨDZï⟯≠ï?Ⅰ:ѨȎѨƎï // implicit: ï=input
⟮ѨDZï⟯≠ï?        // check if ï is NOT in snake_case
       Ⅰ       // if so, then convert to snake_case
        :ѨȎѨƎï // otherwise, convert to camelCase and make the first letter UPPERCASE

Answer 13

जेली , 24 बाइट्स

e€ØAḊkŒlj”_$ʋ⁾_ yŒtḲƲ}Ẹ?

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

Answer 14

पायथन 3 , 86 बाइट्स

lambda s,u='_':''.join([u[i>u:]+i.lower()for i in(s<u)*s]or[u]+s.title().split(u))[1:]

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

पायथन 2 में भी काम करता है ।

सुविधाजनक तथ्य का उपयोग करना, जो कि _(95) के लिए एस्की वैल्यू अपरकेस (65-90) और लोअरकेस (97-122) अक्षरों के बीच सही है, जो आसान स्ट्रिंग तुलना की अनुमति देता है।

Answer 15

फोर्थ (gforth) , 129 बाइट्स

: f bounds dup c@ 32 xor emit 1+ ?do i c@ '_ < if ." _"i c@ 32 + emit then i c@ '_ > if i 1- c@ '_ = 32 * i c@ + emit then loop ;

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

कोड स्पष्टीकरण

: f              \ start a new word definition
  bounds         \ convert string address and length to beginning and ending address
  dup c@         \ get the first character
  32 xor emit    \ convert to the opposite case and output
  1+             \ add 1 to beginning of string (skip starting char)
  ?do            \ begin counted loop over string character addresses
    i c@ '_ <    \ check if char is uppercase 
    if           \ if it is:
      ." _"      \ output underscore
      i c@       \ get current char
      32 + emit  \ convert to lowercase and output
    then         \ end if block
    i c@ '_ >    \ check if lowercase (not '_')
    if           \ if it is:
      i 1- c@    \ get the previous character
      '_ = 32 *  \ if it's an underscore, multiply by 32 (true = -1 in forth)
      i c@ +     \ add result to current char (make uppercase if previous was '_')
      emit       \ output resulting char
    then         \ end if block
  loop           \ end loop
;                \ end word definition