Dado um hexágono de arte ASCII como entrada, produza um cujos lados tenham uma unidade a mais.

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

Os hexágonos de entrada terão simetria de 180 graus, mas, caso contrário, os lados podem ter comprimentos diferentes. Acima, os comprimentos laterais (2, 4, 3) aumentam para (3, 5, 4). Os comprimentos laterais serão diferentes de zero.

Os hexágonos são feitos de sublinhados _, barras /e barras invertidas \. Observe que nas bordas horizontais (feitas com sublinhados), a borda superior está em sua própria linha, mas a borda inferior não.

I / O

Vou ser um defensor e exigir formatação ASCII aqui: a entrada e a saída devem ser uma string com novas linhas representando a imagem, não uma lista de linhas. Obviamente, seu código pode imprimir cada linha sucessivamente para produzir a imagem ou ler STDIN uma linha por vez para inserir se o seu idioma puder fazer isso.

Detalhes

A entrada pode incluir uma nova linha à direita opcional, se você desejar, mas, caso contrário, não terá linhas vazias. Você pode optar por não ter espaços à direita na entrada ou espaços para preencher cada linha no mesmo comprimento (o da linha mais longa).

A saída deve estar nivelada com a borda esquerda da tela, como a entrada. Você pode ter novas linhas extras acima e abaixo, além de espaços à direita.

Casos de teste

Entrada seguida de saída.

 _
/ \
\_/

  __
 /  \
/    \
\    /
 \__/

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

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

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

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

Entre os melhores

<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→│╧(╡¢╩

Execute e depure

Parece que deve haver uma maneira de fazer isso principalmente com regex, mas ainda estou procurando ...

Retina 0.8.2 , 84 bytes

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

Experimente online! Funciona com hexágonos irregulares. A E / S está sem preenchimento. Explicação:

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

Amplie o interior do hexágono.

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

Arrume a parte superior.

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

Arrume o fundo.

JavaScript (ES6),  159 156 153  150 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](/_/,'__'))

Experimente online!

Comentado

^{Nota: caracteres alternativos são usados ​​abaixo para os delimitadores de expressões regulares para impedir que o marcador de sintaxe SE fique furioso.}

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

Carvão , 48 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

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

Insira e concatene todas as linhas, exceto a primeira. (A entrada no formato JSON tornaria a maior parte disso desnecessária, com uma economia de 11 bytes.)

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

Conte o número de /s, se /es _na sequência e use-a para calcular os novos comprimentos laterais (no caso de _s, como uma sequência de _s desse comprimento).

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

Desenhe o hexágono aumentado.

Solução alternativa, também 48 bytes:

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

Experimente online! Link é a versão detalhada do código. Explicação:

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

Insira todas as linhas. (A entrada no formato JSON tornaria isso desnecessário com uma economia de 17 bytes.)

Ｆ²«

Desenhe as seções superior direita e inferior esquerda do hexágono separadamente.

≔Ｅ\/_⊕⊘№θκ

Contar o número de /s, /s, e _s na cadeia e uso que para calcular os novos comprimentos laterais.

η×_⊟ηＭ⁰¬ι

Saída na parte superior ou inferior e mova para baixo uma linha, se essa for a linha superior.

Ｆη«↷¹κ↷¹¶

Desenhe os lados direito ou esquerdo.

APL (Dyalog Unicode) , ^{SBCS de} 75 e 74 bytes

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

Experimente online!

'.+'⎕s'&' dividir entrada em linhas

↑⍵ misturar linhas em uma matriz

⍺⍳substitua ' /\_'por0 1 2 3

(0,0,⍨⍉)⍣3⍉ surround com uma camada de 0s na parte superior e inferior e duas camadas de 0s na esquerda e direita

{⊃0~⍨1⌷⍵,⍨⍉⍵}⌺3 3 para cada célula, escolha o primeiro não-0 entre: superior, inferior, esquerda e direita, no bairro 3x3 centralizado

2⌈/ max em pares horizontalmente

a×1=(+⍀×a)⌊⊖+⍀⊖×a← mantenha apenas o limite externo de não-0s

⍺[ ]substitua 0 1 2 3por' /\_'

PowerShell , 126 bytes

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

Experimente online!

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

Poderia ser mais curto? Não vejo como ainda. Com comentários e novas linhas adicionadas e cabeçalho + rodapé:

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
}

Experimente online!

A linha 1 divide a sequência de entrada de várias linhas na matriz @l.

A linha 2 duplica a segunda e a última linha sem os _ caracteres.

A linha 3 adiciona espaços onde for necessário na linha 2 ao penúltimo lugar.

A linha 4 amplia os dois lados ___ com um _ e retorna a matriz de linhas @l como uma sequência de várias linhas.