Esta es mi cabeza:

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

Se compone de exactamente ocho pelos. Mi pelo es demasiado largo. Corte cada hebra individual a la longitud que especifique.

Entrada

La atracción principal en esta sección es el cabello real. Aquí hay una representación gráfica codificada por colores, junto con una animación , para los perezosos:

Y aquí hay una especificación completa de lo que es un conjunto de pelos:

• Los pelos individuales, que llamaremos hebras , se pueden hacer fuera de las /, \, |, y -caracteres ASCII, de ahora en adelante conocido como átomos .
• La cabeza de audición completa (todos los hilos combinados) serán ccolumnas por rfilas, donde c≥ 1 y r≥ 2.
• Cada hebra ...
  • comience en la última fila de la cabeza (fila r- 1).
  • tener una longitud ldonde l≥ 2.
• Los hilos se pueden analizar con el siguiente método:
  1. Comience en la parte inferior del hilo. Esto será un /, |o \átomo, que llamaremos la raíz . (Los hilos se analizan de izquierda a derecha, ordenados por la raíz).
  2. Encuentra el átomo que apunta hacia la raíz.
     • Un |átomo apunta hacia arriba y hacia abajo. Un -átomo apunta a izquierda y derecha (pero nunca puede apuntar a la raíz ya que solo las raíces pueden estar en la fila inferior). Un /átomo apunta hacia la izquierda hacia abajo y hacia la derecha, y un \átomo hace lo contrario.
     • Siempre habrá exactamente un átomo que apunte hacia el átomo raíz.
  3. Encuentre un átomo no utilizado (uno que aún no sea parte de ninguna hebra) que apunte hacia este átomo y que tampoco esté debajo de este átomo (el cabello no puede crecer hacia abajo, pero de lado está bien).
     • Si hay cero, ¡has llegado al final del hilo!
     • Si hay uno, este es el siguiente átomo de la cadena. Repita el paso 3 con este átomo. (Este átomo ahora está marcado como "usado" para los fines del paso 3, ya que es parte de un filamento).
     • Nunca habrá múltiples átomos no utilizados aquí en ningún punto de la cabeza.

El formato de entrada será:

• Una cabellera. Se puede ingresar como está (entrada multilínea con nuevas líneas literales), o con un delimitador de su elección en lugar de nuevas líneas. Tenga en cuenta que la cabeza siempre será un rectángulo; es decir, se agregará espacio en blanco al final según sea necesario (el extraño cabello en línea recta a la derecha es solo para eliminar el espacio en blanco adicional para evitar confusiones).
• Un número ≥ 1 que especifica cuánto pelo cortar. Esto se describirá en detalle en la siguiente sección.

Puede aceptar la entrada a una función, usar STDIN / STDOUT, etc. (cualquier cosa razonable ).

Salida

Su salida será la cabeza del cabello con el corte de pelo aplicado. Para realizar un corte de pelo, simplemente reduzca la longitud de cada mechón de cabello en la cantidad especificada (que siempre será 1 o mayor), comenzando desde el punto final del cabello que se mueve hacia la raíz. Sin embargo, ¡ siempre deja la raíz intacta!

Aquí hay un ejemplo simple. Digamos que la entrada para la cabeza es

\ 
 /
| 
| 

Con una segunda entrada de 2, cortarías dos átomos de la cadena y obtendrías un resultado de

|
|

Y con una entrada de 42, la salida sería

|

Tenga en cuenta que los espacios en blanco antes y después de la cabeza son completamente irrelevantes; puede recortar nuevas líneas adicionales o puede agregar más relleno. No importa, siempre y cuando la cabeza permanezca intacta. (También puede hacer lo que quiera con espacios en blanco al final).

Casos de prueba

Para todos los casos de prueba, se utilizará el ejemplo presentado al comienzo de esta publicación.

Longitud de corte de pelo = 1:

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

Longitud de 3:

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

Longitud de 7:

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

Longitud de 1337:

| \  /|  //  \ |

Puntuación

Este es el código de golf , por lo que el código más corto en bytes ganará

JavaScript (E6) 195 212 222 232

Usando una función recursiva R para encontrar la ruta de cada hebra y marcando las posiciones a partir de 1 para el más alejado de la raíz. Entonces es fácil, en una segunda pasada, sustituir la posición marcada más baja con espacios en blanco.

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

Prueba en la consola 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))

Salida

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

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


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






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








| \  /|  //  \ |