Esta é a minha cabeça:

\         /-- -|
 /   -\  |  |  |
\      \ \  \  |
 --\    | \  | |
    / |--| / / |
 /|-  //--| /  |
| |  ||   //\  |
| \  /|  //  \ |

Consiste em exatamente oito cabelos. Meu cabelo é muito comprido. Corte cada fio individualmente no comprimento que eu especificar.

Entrada

A principal atração nesta seção é a cabeça dos cabelos. Aqui está uma representação gráfica e com código de cores, juntamente com uma animação , para os preguiçosos:

E aqui está uma especificação completa para o que é um conjunto de cabelos:

• Os cabelos individuais, que chamamos de fios , será feita fora das /, \, |, e -caracteres ASCII, doravante conhecido como átomos .
• O head of hear inteiro (todos os fios combinados) será ccolunas por rlinhas, onde c≥ 1 e r≥ 2.
• Cada fio vai ...
  • comece na última linha da cabeça (linha r- 1).
  • tem um comprimento londe l≥ 2.
• As vertentes podem ser analisadas com o seguinte método:
  1. Comece na parte inferior do fio. Este será um /, |ou \átomo, que chamaremos de raiz . (Os fios são analisados ​​da esquerda para a direita, ordenados pela raiz.)
  2. Encontre o átomo que aponta para a raiz.
     • Um |átomo aponta para cima e para baixo. Um -átomo aponta para a esquerda e para a direita (mas nunca pode apontar para a raiz, pois somente as raízes podem estar na linha inferior). Um /átomo aponta para a esquerda e para baixo e para cima e o \átomo faz o contrário.
     • Sempre haverá exatamente um átomo que aponta para o átomo raiz.
  3. Encontre um átomo não utilizado (que ainda não faz parte de nenhum fio) que aponte para esse átomo e também não esteja abaixo deste átomo (o cabelo não pode crescer para baixo, mas lateralmente é bom).
     • Se houver zero, você alcançou o fim do fio!
     • Se houver, este é o próximo átomo da fita. Repita a etapa 3 com este átomo. (Esse átomo agora está marcado como "usado" para os propósitos da etapa 3, pois faz parte de um fio.)
     • Nunca haverá vários átomos não utilizados aqui em nenhum momento da cabeça.

O formato de entrada será:

• Uma cabeça de cabelo. Pode ser inserido como está (entrada multilinha com novas linhas literais) ou com um delimitador de sua escolha no lugar de novas linhas. Observe que a cabeça sempre será um retângulo; ou seja, espaços em branco à direita serão adicionados conforme necessário (o cabelo estranho da linha reta à direita é apenas para eliminar o espaço em branco à direita para evitar confusão).
• Um número ≥ 1 especificando quanto cabelo cortar. Isso será descrito em detalhes na próxima seção.

Você pode aceitar a entrada de uma função, usar STDIN / STDOUT, etc. (qualquer coisa razoável ).

Resultado

Sua saída será a cabeça do cabelo com o corte de cabelo aplicado. Para fazer um corte de cabelo, basta reduzir o comprimento de cada fio de cabelo pela quantidade especificada (que sempre será 1 ou mais), começando pelo ponto final do cabelo, movendo-se em direção à raiz. No entanto, sempre deixe a raiz intacta!

Aqui está um exemplo simples. Digamos que a entrada para a cabeça seja

\ 
 /
| 
| 

Com uma segunda entrada de 2, você cortaria dois átomos da fita e obteria um resultado de

|
|

E com uma entrada de 42, a saída seria apenas

|

Observe que os espaços em branco antes e depois da cabeça são completamente irrelevantes; você pode aparar novas linhas extras ou adicionar mais preenchimento. Não importa, desde que a cabeça permaneça intacta. (Você também pode fazer o que quiser com espaços em branco à direita.)

Casos de teste

Para todos os casos de teste, o exemplo apresentado no início desta postagem será usado.

Comprimento do corte de cabelo = 1:

          /-   |
 /    \  |     |
\      \ \  \  |
 --\    | \  | |
    / |--  / / |
  |-  //--| /  |
| |  ||   //   |
| \  /|  //  \ |

Comprimento de 3:

         |      
         \     |
 --\    | \    |
    / |--  / / |
  |-  //  | /  |
  |  ||   //   |
| \  /|  //  \ |

Comprimento de 7:

  |-  /   |     
  |  |    /    |
| \  /|  //  \ |

Comprimento de 1337:

| \  /|  //  \ |

Pontuação

Isso é código-golfe , então o código mais curto em bytes vencerá!

JavaScript (E6) 195212222232

Usando uma função recursiva R para encontrar o caminho de cada fio e marcando as posições começando de 1 para o mais distante da raiz. Em seguida, é fácil, em um segundo passe, substituir a posição marcada mais baixa por espaços em branco.

F=(h,t,
   n=[...h],c=h.search('\n'),
   R=p=>[1,-1,c+2,c+1,c].some((d,i)=>n[p-d]=='--\\|/'[i]?n[p-=d]=1:0)&&R(p)+(R[p]=l++)
  )=>
  n.map((v,p)=>R[p]<t?' ':h[p],n.map((a,p)=>!h[p+c]&a>' '&&R(p,l=0))).join('')

Teste no console do FireFox / FireBug

head = "\\         /-- -|\n /   -\\  |  |  |\n\\      \\ \\  \\  |\n --\\    | \\  | |\n    / |--| / / |\n /|-  //--| /  |\n| |  ||   //\\  |\n| \\  /|  //  \\ |";
console.log(F(head,0))
console.log(F(head,1))
console.log(F(head,3))
console.log(F(head,7))
console.log(F(head, 1337))

Resultado

\         /-- -|
 /   -\  |  |  |
\      \ \  \  |
 --\    | \  | |
    / |--| / / |
 /|-  //--| /  |
| |  ||   //\  |
| \  /|  //  \ |

          /-   |
 /    \  |     |
\      \ \  \  |
 --\    | \  | |
    / |--  / / |
  |-  //--| /  |
| |  ||   //   |
| \  /|  //  \ |


         |      
         \     |
 --\    | \    |
    / |--  / / |
  |-  //  | /  |
  |  ||   //   |
| \  /|  //  \ |






  |-  /   |     
  |  |    /    |
| \  /|  //  \ |








| \  /|  //  \ |