Contexte
(Basé sur une histoire vraie et déchirante)
À mon époque, j'ai souvent joué avec le lisp et des langues similaires. J'ai écrit avec eux, les ai exécutés, les ai interprétés, les ai conçus et j'ai fait écrire des machines avec eux ... Et s'il y a une chose qui me dérange, c'est de voir Lisp qui ne correspond pas à mon style de formatage spécifique.
Malheureusement, certains éditeurs de texte ( cough XCode cough ) ont tendance à dépouiller mes beaux onglets et espaces chaque fois que le code est copié et collé ... Prenez cette syntaxe de type Lisp magnifiquement espacée:
(A
(B
(C)
(D))
(E))
(Où ABCDE
sont les fonctions arbitraires)
CERTAINS éditeurs de texte massacrent ce joli code à la fin suivante:
(A
(B
(C)
(D))
(E))
Quel bordel! Ce n'est pas lisible!
Aidez-moi, ici?
Le défi
Votre objectif dans ce défi est de prendre une série de fonctions séparées par des sauts de ligne dans un format décrit ci-dessous et de retourner un arrangement plus beau qui met en valeur la lisibilité et l'élégance.
L'entrée
Nous définissons une fonction F
d' N
arguments d' arité comme une construction similaire à la suivante:
(F (G1 ...) (G2 ...) (G3 ...) ... (GN ...))
où G1, G2, ..., GN
sont toutes les fonctions en soi. Une 0
fonction d' arité A
est simplement (A)
, tandis qu'une 2
fonction d' arité B
est de la forme(B (...) (...))
Votre code doit prendre la saisie comme une série de fonctions avec une seule nouvelle ligne avant la parenthèse principale de chaque fonction (sauf pour la première fonction). L'exemple ci-dessus est une entrée valide.
Vous pouvez supposer:
- Les parenthèses sont équilibrées.
- Une fonction ne devra jamais être mise en retrait plus de 250 fois.
- CHAQUE fonction est entourée de parenthèses:
()
- Le nom d'une fonction ne contiendra que des caractères ASCII imprimables.
- Le nom d'une fonction ne contiendra jamais de parenthèses ou d'espaces.
- Il y a un retour à la ligne de fin facultatif en entrée.
Le résultat
Votre code doit générer le même ensemble de fonctions, où les seules modifications apportées sont les ajouts d'espaces ou de tabulations avant les parenthèses de début des fonctions. La sortie doit respecter les règles suivantes:
- La première fonction (et les fonctions de niveau supérieur ultérieures) fournies ne doit pas avoir d'espaces précédents
- Un argument à l'emplacement horizontal d'une fonction est exactement un onglet à droite de l'emplacement horizontal de cette fonction.
- Un onglet est défini par l'implémentation, mais doit comporter au moins 3 espaces.
- Vous pouvez éventuellement imprimer un maximum de deux espaces après chaque ligne.
Règles
- C'est le code-golf: le code le plus court gagne!
- Les échappatoires standard ne sont pas autorisées.
Exemples
Contribution:
(A
(B
(C)
(D))
(E))
Sortie:
(A
(B
(C)
(D))
(E))
Contribution:
(!@#$%^&*
(asdfghjklm
(this_string_is_particularly_long
(...))
(123456789)))
(THIS_IS_TOP_LEVEL_AGAIN
(HERE'S_AN_ARGUMENT))
Sortie:
(!@#$%^&*
(asdfghjklm
(this_string_is_particularly_long
(...))
(123456789)))
(THIS_IS_TOP_LEVEL_AGAIN
(HERE'S_AN_ARGUMENT))
Contribution:
(-:0
(*:0
(%:0
(Arg:6)
(Write:0
(Read:0
(Arg:30))
(Write:0
(Const:-6)
(Arg:10))))
(%:0
(Const:9)
(/:0
(Const:-13)
(%:0
(Arg:14)
(Arg:0)))))
(WriteArg:22
(-:0
(Const:45)
(?:0
(Arg:3)
(Arg:22)
(Arg:0)))))
Sortie:
(-:0
(*:0
(%:0
(Arg:6)
(Write:0
(Read:0
(Arg:30))
(Write:0
(Const:-6)
(Arg:10))))
(%:0
(Const:9)
(/:0
(Const:-13)
(%:0
(Arg:14)
(Arg:0)))))
(WriteArg:22
(-:0
(Const:45)
(?:0
(Arg:3)
(Arg:22)
(Arg:0)))))
()
?