Dans ce Coding Golf, vous devez convertir une convention de codage avec TitleCase en lower_case_with_underscores. Et vice versa!

spécification

Changez le boîtier de la manière suivante:

• Si le caractère de soulignement est un délimiteur, remplacez la casse par la casse du titre sans aucun délimiteur.
• S'il y a plusieurs mots sans délimiteur, changez la casse en minuscules et ajoutez un caractère de soulignement comme délimiteur.
• Dans le cas d'un seul mot (ou d'un seul caractère): remplacez la casse par la casse du titre si le mot commence par une minuscule; changer la casse en minuscules si le mot commence par les majuscules.

Caractères autorisés:

• De A à Z
• de A à Z
• souligner ( _).

Les entrées avec des mots en casse mixtes sont interdites. Exemples de cas non autorisés:

• Coding_Convention_Conversion
• a_BC

Exemples de cas

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

Règles

• Il est autorisé à utiliser ToUpper, ToLoweretToTitleCase fonctions.
• L'utilisation d'expressions régulières est autorisée.
• code-golf : le code le plus court en octets gagne!

Pyth, 25 octets 29 33 35 40

Sauvegardé 2 octets grâce à @Dennis

4 octets enregistrés grâce à @FryAmTheEggman

?rIz0smrd4cz\_tsXzrG1*\_G

Essayez-le en ligne

Jolf, 35 octets

Enregistre 1 octet grâce à @ Cᴏɴᴏʀ O'Bʀɪᴇɴ . Ceci est codé dans ISO 8859-7.

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

Woohoo mon premier programme Jolf!

Explication

   // 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

Essayez-le en ligne

Rétine , 37

Merci à @ MartinBüttner pour avoir économisé 4 octets!

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

(Notez la nouvelle ligne de fin.)

Essayez-le en ligne. Notez que cela inclut un supplément m`pour configurer quelques lignes pour traiter chaque ligne d'entrée séparément afin que tous les cas de test puissent être exécutés en une seule fois. Ce n'est pas une exigence de la question, donc ceux-ci ne sont pas comptés dans le score.

• Les lignes 1 et 2 sont insérées _au début de la saisie ou avant les lettres majuscules. Tous les mots sont maintenant_ séparés, quel que soit le cas.
• La ligne 3 permute la casse de la première lettre de chaque mot.
• Les lignes 4 et 5 sont supprimées _soit au début de la saisie, soit lorsqu'elles sont suivies d'une lettre majuscule.

GNU Sed, 46

Merci à @TobySpeight pour avoir économisé 2 octets!

Le score inclut +1 pour -E(ou -r) l'option pour sed.

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

Essayez-le en ligne.

Sed assez simple:

• La ligne 1 remplace le début de la ligne ou _, suivi d'une lettre minuscule par la majuscule de cette lettre. Le gdrapeau às effectuer cette substitution pour chaque instance trouvée
• tpasse à l' :étiquette sans nom s'il y a des correspondances pour la substitution ci-dessus. Cette étiquette est implicitement à la fin.
• Sinon, toutes les lettres majuscules sont remplacées par _ le minuscule de cette lettre
• Cela laisse un _début avant la première lettre. s/^_//supprime cela.

JavaScript (ES6), 87 octets

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

Explication

Selon la partie de l'expression rationnelle correspondante, elle remplace la correspondance par le cas contraire.

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

Tester

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>

Rubis, 101 87 75 octets

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

Malheureusement, cela fait exactement la même chose que la solution Retina, car cette méthode a fini par être plus courte que tout ce que j'ai imaginé.

Python 3, 130 octets

Tentative rapide et sale utilisant regex pour diviser les bouchons. Force brute: si quelqu'un peut proposer une approche différente, je suis sûr que cela peut être battu.

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()]

PHP 160 octets

pas le plus court mais pour être complet ici ma solution en PHP, $ s contient la chaîne à convertir:

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),'_')

Perl 6 ,  73 72 71   68 octets

{.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

Usage:

# 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

Explication:

{
  .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
  )
}

Vous vous demandez peut-être pourquoi j'ai utilisé les propriétés Unicode ( <:Lu>, <:Ll>) au lieu d'une simple classe de caractères. En Perl 6, ils ne sont plus orthographiés, [a-z]ils sont épelés <[a..z]>1,6 fois plus gros. Les crochets [ … ]sont utilisés pour le regroupement sans capture à la place, ce qui était orthographié comme (?: … )dans Perl 5.

Japt, 40 octets

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

Testez-le en ligne!

Comment ça fonctionne

           // 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().

Perl 5, 42 octets

40 octets plus 2 pour -p(merci, dev-null )

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

𝔼𝕊𝕄𝕚𝕟 3, 15 caractères / 32 octets (non compétitif)

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

Try it here (Firefox only).

v3 est sorti après ce défi, avec un tas de corrections de bugs et de mises à jour de la bibliothèque.

Explication

Ceci est juste un mashup de builtins.

⟮Ѩ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

Gelée , 24 octets

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

Essayez-le en ligne!

Python 3 , 86 octets

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

Essayez-le en ligne!

Fonctionne également en Python 2 .

En utilisant le fait pratique que la valeur ascii pour _(95) est juste entre celles des lettres majuscules (65-90) et minuscules (97-122), ce qui permet des comparaisons de chaînes faciles.

Forth (gforth) , 129 octets

: 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 ;

Essayez-le en ligne!

Explication du code

: 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