Dado un hexágono de arte ASCII como entrada, salida uno cuyos lados son todos una unidad más larga.

                     _____
  ____              /     \
 /    \            /       \
/      \          /         \
\       \   =>    \          \
 \      /          \         /
  \____/            \       /
                     \_____/

Los hexágonos de entrada tendrán una simetría de 180 grados, pero de lo contrario los lados pueden tener diferentes longitudes. Arriba, las longitudes laterales (2, 4, 3) se agrandan a (3, 5, 4). Las longitudes laterales serán distintas de cero.

Los hexágonos están hechos de guiones bajos _, barras diagonales /y barras diagonales inversas \. Tenga en cuenta que de los bordes horizontales (hechos con guiones bajos), el borde superior está en su propia línea pero el borde inferior no.

I / O

Voy a ser riguroso y requeriré un formato de arte científico aquí: la entrada y la salida deben ser una cadena con líneas nuevas que representen la imagen, no una lista de líneas. Por supuesto, su código puede imprimir cada línea a su vez para producir la imagen, o leer STDIN una línea una vez para ingresar si su idioma puede hacerlo.

Detalles

La entrada puede incluir una nueva línea final opcional si lo desea, pero de lo contrario no tendrá líneas vacías. Puede elegir no tener espacios finales en la entrada o espacios para rellenar cada línea a la misma longitud (la de la línea más larga).

La salida debe estar al ras del borde izquierdo de la pantalla, como la entrada. Puede tener nuevas líneas adicionales arriba y abajo, así como espacios finales.

Casos de prueba

Entrada seguida de salida.

 _
/ \
\_/

  __
 /  \
/    \
\    /
 \__/

  ____
 /    \
/      \
\       \
 \      /
  \____/

   _____
  /     \
 /       \
/         \
\          \
 \         /
  \       /
   \_____/

     _
    / \
   /  /
  /  /
 /  /
/  /
\_/

      __  
     /  \
    /    \
   /     /
  /     /
 /     /
/     /
\    /
 \__/

Tabla de clasificación

<iframe src="https://xmikee1.github.io/ppcg-leaderboard/?id=185760" width="100%" height="100%" style="border: none;">Oops, your browser is too old to view this content! Please upgrade to a newer version of your browser that supports HTML5.</iframe><style>html,body{margin:0;padding:0;height:100%;overflow:hidden}</style>

Stax , 28 bytes

╙Σ■♀♪«G[▀[TÖe╟╗ê'○▀ÄT→│╧(╡¢╩

Ejecutar y depurarlo

Parece que debería haber una manera de hacerlo principalmente con expresiones regulares, pero todavía estoy buscando ...

Retina 0.8.2 , 84 bytes

m`(¶.*)( .)$
$1   $2
(_+¶)(( */)  ( *.))
 _$1 $3$4¶$2
( *.)(_+/)$
$1$.2$*   /¶ $1_$2

Pruébalo en línea! Funciona con hexágonos irregulares. La E / S no está acolchada. Explicación:

m`(¶.*)( .)$
$1   $2

Ensancha el interior del hexágono.

(_+¶)(( */)  ( *.))
 _$1 $3$4¶$2

Arregla la parte superior.

( *.)(_+/)$
$1$.2$*   /¶ $1_$2

Arregla el fondo.

JavaScript (ES6),  15915615350  bytes

s=>s[r='replace'](/\S /g,'$&   ')[r](/.*/,s=>s[r](e=/_+/,` $&_
`+s[r](e,'/$& \\')[r](e=/_/g,' ')))[r](/ *\\_+/,s=>s[r](e,' ')+`   /
 `+s[r](/_/,'__'))

Pruébalo en línea!

Comentado

^{NB: los caracteres alternativos se utilizan a continuación para los delimitadores de expresiones regulares para evitar que el resaltador de sintaxis SE se vuelva loco.}

s =>                       // s = input
  s[r = 'replace'](        // r = alias for 'replace'
                           // STEP #1
    ∕\S ∕g,                // insert two middle spaces for all lines
    '$&   '                // that contain a border, followed by a space
  )                        // (i.e. all lines except the first and the last one)
  [r](                     // STEP #2
    ∕.*∕,                  // isolate the first line
    s =>                   // let s be this first line
      s[r](                //
        e = ∕_+∕,          // find the sequence of underscores and replace it with:
        ` $&_\n` +         //   the same sequence preceded by a space and followed by '_'
        s[r](              //   followed by a linefeed and:
          e,               //     the same sequence preceded by '/' and followed by ' \'
          '/$& \\'         //     
        )                  //     with:
        [r](e = ∕_∕g, ' ') //     all underscores replaced with spaces
  ))                       //
  [r](                     // STEP #3
    ∕ *\\_+∕,              // isolate the last line, without the trailing '/'
    s =>                   // let s be this last line
      s[r](e, ' ') +       // replace all underscores with spaces
      `   /\n ` +          // append 3 spaces and a trailing '/', followed by a linefeed
      s[r](∕_∕, '__')      // append s with an extra underscore
  )                        //

Carbón , 48 bytes

ＳθＷ¬№ω_≔⁺ωＳω≔⊕⊘№ω\η≔⊕⊘№ω/ζ≔×_⊕№ω_θ↗ζθ↓↘η←↙ζ↑←θ↖η

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

ＳθＷ¬№ω_≔⁺ωＳω

Ingrese y concatene todas las líneas excepto la primera. (La entrada en formato JSON haría que la mayoría de esto sea innecesario con un ahorro de 11 bytes).

≔⊕⊘№ω\η≔⊕⊘№ω/ζ≔×_⊕№ω_θ

Cuente el número de /s, /s y_ s en la cadena y úselo para calcular las nuevas longitudes de los lados (en el caso de _s, como una cadena de _s de esa longitud).

↗ζθ↓↘η←↙ζ↑←θ↖η

Dibuja el hexágono ampliado.

Solución alternativa, también 48 bytes:

ＳθＷ¬№ω_≔⁺ωＳω≔⁺θωθＦ²«≔Ｅ\/_⊕⊘№θκη×_⊟ηＭ⁰¬ιＦη«↷¹κ↷¹¶

Pruébalo en línea!El enlace es a la versión detallada del código. Explicación:

ＳθＷ¬№ω_≔⁺ωＳω≔⁺θωθ

Ingrese todas las líneas. (La entrada en formato JSON haría que esto sea innecesario con un ahorro de 17 bytes).

Ｆ²«

Dibuja las secciones superior derecha e inferior izquierda del hexágono por separado.

≔Ｅ\/_⊕⊘№θκ

Cuente el número de /s, /s y_ s en la cadena y úsela para calcular las nuevas longitudes de los lados.

η×_⊟ηＭ⁰¬ι

Imprima la parte superior o inferior y baje una línea si esta era la línea superior.

Ｆη«↷¹κ↷¹¶

Dibuja ambos lados derecho o izquierdo.

APL (Dyalog Unicode) , 75 74 bytes ^SBCS

' /\_'∘{⍺[a×1=(+⍀×a)⌊⊖+⍀⊖×a←2⌈/{⊃0~⍨1⌷⍵,⍨⍉⍵}⌺3 3(0,0,⍨⍉)⍣3⍉⍺⍳↑⍵]}'.+'⎕s'&'

Pruébalo en línea!

'.+'⎕s'&' dividir la entrada en líneas

↑⍵ mezclar líneas en una matriz

⍺⍳reemplazar ' /\_'con0 1 2 3

(0,0,⍨⍉)⍣3⍉ rodea con una capa de 0s en la parte superior e inferior y dos capas de 0s en la izquierda y derecha

{⊃0~⍨1⌷⍵,⍨⍉⍵}⌺3 3 para cada celda, elija la primera no 0 de: superior, inferior, izquierda, derecha del vecindario 3x3 centrado en ella

2⌈/ max en pares horizontalmente

a×1=(+⍀×a)⌊⊖+⍀⊖×a← mantener solo el límite exterior de los no 0

⍺[ ]reemplazar 0 1 2 3con' /\_'

PowerShell , 126 bytes

$args-replace' *\S +','$0   '-replace'( +)(_+)','$1 $2_
$1/$2 \'-replace'( *)(\\_+)/','$1$2   /
$1 $2_/'-replace'_(?=.* )',' '

Pruébalo en línea!

Perl 5 , 177 156 145 bytes

@l=pop=~/.+/g;splice@l,$_,0,$l[$_]=~s,_, ,gr for-1,1;$l[$_]=~s, (\S)( +)(\S),$_<2?" $1$2 $3":"$1$2   $3",e for 1..@l-2;join("\n",@l)=~s,_+,$&_,gr

¿Podría ser más corto? No veo cómo todavía. Con comentarios y nuevas líneas agregadas y encabezado + pie de página:

sub f {
@l=pop=~/.+/g;                                                      #1
splice@l,$_,0,$l[$_]=~s,_, ,gr for-1,1;                             #2
$l[$_]=~s, (\S)( +)(\S),$_<2?" $1$2 $3":"$1$2   $3",e for 1..@l-2;  #3
join("\n",@l)=~s,_+,$&_,gr                                          #4
}

Pruébalo en línea!

La línea n. ° 1 divide la cadena de entrada de varias líneas en la matriz @l.

La línea # 2 duplica la segunda y la última línea sin los caracteres _.

La línea n. ° 3 agrega espacios donde sea necesario en la línea 2 al penúltimo.

La línea # 4 ensancha los dos lados ___ con un _ y devuelve la matriz @l de líneas como una cadena de varias líneas.