Écrire un programme qui prend en une chaîne contenant uniquement des espaces, les sauts de lignes, et les crochets: <, >( chevrons ). Sortie d' une chaîne d'espaces, les sauts de lignes et des barres obliques: /, \( soliduses ) dont les formes correspondent à l'entrée, mais tournées d' un quart de tour dans le sens horaire, avec une colonne d'espaces insérés entre chaque rangée de l'entrée d' origine (pour l' esthétique).

Par exemple, si l'entrée est la suivante:

<>

La sortie serait la suivante:

/\
\/

Si l'entrée est la suivante:

><<<>
 <><

La sortie serait la suivante:

   \/
/\ /\
\/ /\
/\ /\
   \/

Si l'entrée est la suivante:

>>  <<
<>  <>
  <
  ><

La sortie serait la suivante:

      /\ \/
      \/ \/
\/ /\    
/\      
      /\ /\
      \/ /\

Remarquez comment il y a une seule colonne d'espaces entre les lignes d'entrée d'origine dans les deux derniers exemples.

Vous pouvez écrire un programme complet qui prend l'entrée de n'importe quelle manière habituelle (ligne de commande, stdin) et imprime la sortie, ou vous pouvez écrire une fonction avec un argument de chaîne, qui imprime ou renvoie la sortie.

Les lignes ou colonnes de début et de fin vides d'espaces dans l'entrée n'ont pas besoin d'être présentes dans la sortie. De plus, il peut y avoir n'importe quelle quantité d'espaces de début et / ou de fin et / ou de nouvelles lignes dans la sortie, à n'importe quel emplacement, tant que les formes résultantes sont correctes. En d'autres termes, la traduction de l'art ascii n'a pas d'importance, seules les formes et leur relation les unes aux autres comptent .

Vous pouvez éventuellement supposer que l'entrée a une nouvelle ligne de fin.

Le code le plus court en octets gagne.

CJam, 35 octets

qN/_s,S*f+{iD%[S3*" \/"_$]=}f%W%zN*

Essayez-le en ligne ici

CJam, 37 octets

qN/_z,S*f{+"< >""/\    \/ "3/er}W%zN*

Essayez-le en ligne dans l' interpréteur CJam .

Comment ça marche

qN/                                   e# Read from STDIN and split at linefeeds.
   _z,                                e# Zip a copy and push the results length.
                                      e# This computes the maximum line length.
      S*                              e# Repeat " " that many times.
        f{                     }      e# For each line:
                                      e#   Push the string of spaces.
          +                           e#   Append it to the line.

           "< >""/\    \/ "3/         e#   Push "< >" and ["/\ " "   " "\/ "].
                             er       e#   Perform transliteration.
                                W%z   e# Reverse the lines and zip.
                                      e# This rotates by 90 degrees.
                                   N* e# Join, separating by linefeeds.  

Python 2, 105 octets

def f(s):
 for row in map(None,*s.split("\n")):print" ".join("\/ /\ "[1-cmp(c,"<")::3]for c in row[::-1])

Pour toutes les mauvaises raisons, cela doit être l'une des plus belles utilisations map(None, ...)que j'ai eues jusqu'à présent. La sortie même des pads pour perfectionner le rectangle.

Prenons le deuxième exemple:

><<<>
 <><

map(None,*s.split("\n"))effectue un pauvre homme zip_longest, donnant:

[('>', ' '), ('<', '<'), ('<', '>'), ('<', '<'), ('>', None)]

Remarquez comment la deuxième ligne est plus courte que la première, nous obtenons donc un Noneà la fin. Normalement, ce serait un problème, mais pour une raison quelconque, presque tout est comparable en Python 2, et en particulier

>>> None < ""
True

Cela signifie que l'expression 1-cmp(c,"<")revient 0, 1, 2pour ">", "<", Nonerespectivement, ce qui nous permet d'utiliser l'astuce de découpage de chaîne pour en extraire une "\/", "/\", " ". En utilisant cela, nous imprimons la sortie ligne par ligne, joignant les groupes de 2 caractères avec des espaces.

Scala, 201 188 180 caractères

(s:String)⇒(Seq("")→0/:s.lines.flatMap(l⇒Seq(l,l))){case((v,i),l)⇒(l.map(c⇒if(Set('>','<')(c))if(c%4==i)'/'else'\\'else c)+:v,2-i)}._1.init.transpose.map(_.mkString).mkString("\n")

Remarque:

cela ne fonctionne que si la chaîne fournie a toutes les lignes de même longueur (c'est-à-dire remplies d'espaces)

explication:

J'utilise fold avec la valeur initiale de tuple de a Seq[String]et an Int(au lieu d'écrire Seq.empty[String]im écrit le plus court Seq("")et .initaprès le pli), le pli fonctionne sur une collection de chaînes, chaque chaîne est une ligne dans l'entrée d'origine, et chaque ligne est doublé. l'astuce ici était de tester le modulo du char. puisque la '<'valeur est 60 et la '>'valeur 62, le test de modulo 4 donnera 0 ou 2. c'est pourquoi le pli porte également un Intjeu de retournement à 0. et basculé entre 0 et 2 avec 2-i. chaque ligne impaire doit correspondre '>'à '/'et '<'à '\\', et chaque ligne paire doit correspondre '>'à '\\'et '<'à '/'. c'est pourquoi je testec%4==iet a frappé 2 oiseaux avec 1 pierre. le pli "reconstruit" la séquence initiale de chaînes à l'envers, puis (après avoir laissé tomber la dernière ligne), je transpose la séquence (c'est pourquoi toutes les chaînes doivent être exactement de la même longueur). en raison des implications impliquées, je dois le faire _.mkStringsur chaque ligne (précédemment colonne), puis mkString("\n")pour la sortie finale.

Perl - 119

@l=map[/./g],reverse<>;do{print;$_=join(' ',map({'<'=>'/\\','>'=>'\/'}->{$_->[$b]}||'  ',@l))."\n";$b++;}while(/[^ 
]/)

Tout d'abord, @lest affecté comme une liste de listes représentant les caractères sur chaque ligne d'entrée avec des lignes dans l'ordre inverse. Il parcourt ensuite les colonnes de caractères, remplaçant les chevrons par les barres obliques correspondantes, joignant les éléments par des espaces et imprimant les barres obliques jointes sous forme de ligne.