C'est ma tête:

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

Il se compose exactement de huit cheveux. Mes cheveux sont trop longs. Veuillez couper chaque brin individuel à une longueur que je spécifie.

Contribution

L'attraction principale de cette section est la véritable chevelure. Voici une représentation graphique, codée par couleur, avec une animation , pour les paresseux:

Et voici une spécification complète pour ce qu'est un ensemble de cheveux:

• Les poils individuels, que nous appellerons brins , seront fabriqués à partir des /, \, |et les -caractères ASCII, désormais connu sous le nom des atomes .
• L'ensemble de la tête d'audition (tous les brins combinés) sera ccolonnes par rlignes, où c≥ 1 et r≥ 2.
• Chaque volet va ...
  • commencer au dernier rang de la tête (rang r- 1).
  • avoir une longueur loù l≥ 2.
• Les brins peuvent être analysés avec la méthode suivante:
  1. Commencez au bas du brin. Ce sera un /, |ou un \atome, que nous appellerons la racine . (Les brins sont analysés de gauche à droite, ordonnés par la racine.)
  2. Trouvez l'atome qui pointe vers la racine.
     • Un |atome pointe de haut en bas. Un -atome pointe vers la gauche et la droite (mais ne peut jamais pointer vers la racine car seules les racines peuvent être dans la rangée du bas). Un /atome pointe de gauche à droite et de haut en bas, et un \atome fait le contraire.
     • Il y aura toujours exactement un atome qui pointe vers l'atome racine.
  3. Trouvez un atome inutilisé (qui ne fait pas encore partie d'un brin) qui pointe vers cet atome et n'est pas non plus en dessous de cet atome (les cheveux ne peuvent pas pousser vers le bas, mais sur le côté, ça va).
     • S'il y a zéro, vous avez atteint la fin du brin!
     • S'il y en a un, c'est l'atome suivant du brin. Répétez l'étape 3 avec cet atome. (Cet atome est désormais marqué comme "utilisé" aux fins de l'étape 3, car il fait partie d'un brin.)
     • Il n'y aura jamais plusieurs atomes inutilisés ici à aucun moment dans la tête.

Le format d'entrée sera:

• Une chevelure. Peut être entré tel quel (entrée multiligne avec des retours à la ligne littéraux), ou avec un délimiteur de votre choix à la place des retours à la ligne. Notez que la tête sera toujours un rectangle; c'est-à-dire que des espaces blancs arrière seront ajoutés si nécessaire (les cheveux en ligne droite étranges à droite sont juste pour éliminer les espaces blancs arrière supplémentaires pour éviter toute confusion).
• Un nombre ≥ 1 spécifiant la quantité de cheveux à couper. Cela sera décrit en détail dans la section suivante.

Vous pouvez accepter l'entrée d'une fonction, utiliser STDIN / STDOUT, etc. (tout ce qui est raisonnable ).

Production

Votre sortie sera la chevelure avec la coupe de cheveux appliquée. Pour donner une coupe de cheveux, réduisez simplement la longueur de chaque mèche de cheveux de la quantité spécifiée (qui sera toujours 1 ou plus), en commençant par le point final des cheveux se déplaçant vers la racine. Cependant, laissez toujours la racine intacte!

Voici un exemple simple. Disons que l'entrée pour la tête est

\ 
 /
| 
| 

Avec une deuxième entrée de 2, vous couperiez deux atomes du brin et obtiendriez un résultat de

|
|

Et avec une entrée de 42, la sortie serait juste

|

Notez que les espaces avant et après la tête sont complètement hors de propos; vous pouvez supprimer des sauts de ligne supplémentaires ou ajouter plus de rembourrage. Peu importe, tant que la tête reste intacte. (Vous pouvez également faire ce que vous voulez avec des espaces de fin.)

Cas de test

Pour tous les cas de test, l'exemple présenté au tout début de cet article sera utilisé.

Longueur de coupe de cheveux = 1:

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

Longueur de 3:

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

Longueur de 7:

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

Longueur de 1337:

| \  /|  //  \ |

Notation

Il s'agit de code-golf , donc le code le plus court en octets gagnera!

JavaScript (E6) 195212222232

Utiliser une fonction récursive R pour trouver le chemin de chaque brin et marquer les positions à partir de 1 pour le plus éloigné de la racine. Ensuite, il est facile, dans un deuxième passage, de remplacer la position marquée inférieure par des blancs.

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

Test dans la console 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))

Production

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

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


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






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








| \  /|  //  \ |