En ese Golf de codificación, debe convertir una convención de codificación con TitleCase a lower_case_with_underscores. ¡Y viceversa!

Especificación

Cambie la carcasa de la siguiente manera:

• Si el carácter de subrayado es un delimitador, cambie la carcasa a Título de caso sin ninguno de los delimitadores.
• Si hay varias palabras sin delimitador, cambie la carcasa a minúsculas y agregue un carácter de subrayado como delimitador.
• En el caso de una sola palabra (o un carácter): cambie la carcasa a Título de caso si la palabra comienza con minúscula; cambie la carcasa a minúscula si la palabra comienza con mayúscula.

Caracteres permitidos:

• De la A a la Z
• de la A a la Z
• subrayado ( _).

La entrada con palabras mixtas en mayúsculas no está permitida. Ejemplos de casos no permitidos:

• Coding_Convention_Conversion
• a_BC

Casos de ejemplo

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

Reglas

• Está permitido usar ToUpper, ToLowery ToTitleCasefunciones.
• Se permite el uso de expresiones regulares.
• code-golf : ¡el código más corto en bytes gana!

Pyth, 25 bytes 29 33 35 40

Guardado 2 bytes gracias a @Dennis

Guardado 4 bytes gracias a @FryAmTheEggman

?rIz0smrd4cz\_tsXzrG1*\_G

Pruébalo en línea

Jolf, 35 bytes

Ahorra 1 byte gracias a @ Cᴏɴᴏʀ O'Bʀɪᴇɴ . Esto está codificado en ISO 8859-7.

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

Woohoo mi primer programa Jolf!

Explicación

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

Pruébalo en línea

Retina , 37

¡Gracias a @ MartinBüttner por guardar 4 bytes!

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

(Tenga en cuenta la nueva línea final).

Pruébalo en línea. Tenga en cuenta que esto incluye un extra m`para configurar un par de líneas para tratar cada línea de entrada por separado, de modo que todos los casos de prueba se puedan ejecutar de una vez. Este no es un requisito de la pregunta, por lo que no se cuentan en el puntaje.

• Las líneas 1 y 2 se insertan _al principio de la entrada o antes de las letras mayúsculas. Todas las palabras ahora están _separadas, sin importar el caso.
• La línea 3 cambia el caso de la primera letra de cada palabra.
• Las líneas 4 y 5 se eliminan _al comienzo de la entrada o cuando van seguidas de una letra mayúscula.

GNU Sed, 46

¡Gracias a @TobySpeight por guardar 2 bytes!

La puntuación incluye +1 para -E(o -r) la opción de sed.

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

Pruébalo en línea.

Sed bastante sencillo:

• La línea 1 sustituye el comienzo de la línea o _, seguido de una letra minúscula con la mayúscula de esa letra. La gmarca para srealizar esta sustitución para cada instancia encontrada
• tsalta a la :etiqueta sin nombre si hubo coincidencias para la sustitución anterior. Esta etiqueta está implícitamente al final.
• De lo contrario, todas las letras mayúsculas se sustituyen por _las minúsculas de esa letra
• Esto deja un guión _antes de la primera letra. s/^_//elimina eso.

JavaScript (ES6), 87 bytes

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

Explicación

Dependiendo de qué parte de la expresión regular coincida, reemplaza la coincidencia con el caso opuesto.

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

Prueba

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>

Ruby, 101 87 75 bytes

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

Desafortunadamente, esto hace exactamente lo mismo que la solución Retina, ya que ese método terminó siendo más corto que cualquier otra cosa que se me ocurrió.

Python 3, 130 bytes

Intento rápido y sucio con expresiones regulares para dividir las tapas. Fuerza bruta: si alguien puede llegar a un enfoque diferente, estoy seguro de que esto puede ser vencido.

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 bytes

No es el más corto, pero para completar aquí mi solución en PHP, $ s contiene la cadena para 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 bytes

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

Uso:

# 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

Explicación:

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

Puede que se pregunte por qué usé las propiedades Unicode ( <:Lu>, <:Ll>) en lugar de solo una clase de caracteres. En Perl 6 ya no se deletrean [a-z], se deletrean, <[a..z]>que es 1.6 veces más grande. Los corchetes [ … ]se usan para agrupar sin capturar, que se deletreaba como (?: … )en Perl 5.

Japt, 40 bytes

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

¡Pruébelo en línea!

Cómo funciona

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

40 bytes más 2 para -p(gracias, dev-null )

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

𝔼𝕊𝕄𝕚𝕟 3, 15 caracteres / 32 bytes (no competitivo)

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

Try it here (Firefox only).

v3 se lanzó después de este desafío, con un montón de correcciones de errores y actualizaciones de la biblioteca.

Explicación

Esto es solo 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

Jalea , 24 bytes

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

Pruébalo en línea!

Python 3 , 86 bytes

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

Pruébalo en línea!

También funciona en Python 2 .

Aprovechando el hecho conveniente de que el valor ascii para _(95) está justo entre los de las letras mayúsculas (65-90) y minúsculas (97-122), lo que permite una fácil comparación de cadenas.

Adelante (gforth) , 129 bytes

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

Pruébalo en línea!

Explicación del código

: 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