Escribir un programa que se lleva en una cadena que contiene sólo espacios, saltos de línea, y entre paréntesis angulares: <, >( galones ). Salida de una serie de espacios, saltos de línea, y rayas verticales: /, \( soliduses ) cuyas formas corresponden a la entrada, pero girada un cuarto de vuelta en sentido horario, con una columna de espacios insertados entre cada fila de la entrada original (por estética).

Por ejemplo, si la entrada es esta:

<>

El resultado sería este:

/\
\/

Si la entrada es esta:

><<<>
 <><

El resultado sería este:

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

Si la entrada es esta:

>>  <<
<>  <>
  <
  ><

El resultado sería este:

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

Observe cómo hay una sola columna de espacios entre las filas de entrada originales en los últimos dos ejemplos.

Puede escribir un programa completo que tome la entrada de la manera habitual (línea de comando, stdin) e imprima la salida, o puede escribir una función con un argumento de cadena que imprima o devuelva la salida.

Las filas o columnas de espacios en blanco iniciales y finales vacías en la entrada no necesitan estar presentes en la salida. Además, puede haber cualquier cantidad de espacios iniciales y / o finales y / o nuevas líneas en la salida, en cualquier ubicación, siempre que las formas resultantes sean correctas. En otras palabras, la traducción del arte ascii no importa, solo las formas y su relación entre sí .

Opcionalmente, puede suponer que la entrada tiene una nueva línea final.

El código más corto en bytes gana.

CJam, 35 bytes

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

Pruébalo en línea aquí

CJam, 37 bytes

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

Pruébelo en línea en el intérprete de CJam .

Cómo funciona

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 bytes

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

Por todas las razones equivocadas, este tiene que ser uno de los mejores usos map(None, ...)que he tenido hasta ahora. La salida incluso se adapta al rectángulo perfecto.

Tomemos el segundo ejemplo:

><<<>
 <><

map(None,*s.split("\n"))realiza a un hombre pobre zip_longest, dando:

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

Observe cómo la segunda línea es más corta que la primera, por lo que obtenemos una Noneal final. Normalmente esto sería un problema, pero por alguna razón casi todo es comparable en Python 2, y en particular

>>> None < ""
True

Esto significa que la expresión 1-cmp(c,"<")vuelve 0, 1, 2para ">", "<", Nonerespectivamente, lo que nos permite utilizar el truco de corte de cadena para extraer uno de "\/", "/\", " ". Con esto, imprimimos la salida línea por línea, uniendo los grupos de 2 caracteres con espacios.

Scala, 201 188 180 caracteres

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

Nota:

esto solo funciona si la cadena proporcionada tiene todas las líneas de igual longitud (es decir, rellenas con espacios)

explicación:

Estoy usando pliegue con el valor inicial de tupla de a Seq[String]y an Int(en lugar de escribir, Seq.empty[String]estoy escribiendo el más corto Seq("")y .initdespués del pliegue), el pliegue opera en una colección de cadenas, cada cadena es una línea en la entrada original, y cada línea se duplica El truco aquí fue probar el módulo del char. dado que el '<'valor es 60, y el '>'valor es 62, las pruebas para el módulo 4 producirán 0 o 2. es por eso que el doblez también lleva un Intconjunto de volteo a 0. y se voltea entre 0 y 2 con 2-i. cada línea impar debería mapearse '>'hacia '/'y '<'hacia '\\', y cada línea par debería mapearse '>'hacia '\\'y '<'hacia '/'. es por eso que prueboc%4==iy golpeó 2 pájaros con 1 piedra. el pliegue "reconstruye" la secuencia inicial de cadenas en reversa, y luego (después de soltar la última línea), transpongo la secuencia (es por eso que todas las cadenas deben tener exactamente la misma longitud). Debido a las implicidades involucradas, necesito hacerlo _.mkStringen cada línea (anteriormente columna), y luego mkString("\n")para la salida final.

Perl - 119

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

Primero, @lse asigna como una lista de listas que representan los caracteres en cada línea de entrada con líneas en orden inverso. Luego recorre las columnas de caracteres, reemplazando los corchetes angulares con las barras inclinadas correspondientes, uniendo los elementos con espacios e imprimiendo las barras inclinadas como una línea.