Escreva um programa que leva em uma seqüência de caracteres contendo apenas espaços, novas linhas e colchetes: <, >( chevrons ). Saída de uma série de espaços, novas linhas, barras e: /, \( soliduses ) cujas formas correspondem à entrada, mas rodado um quarto de volta no sentido horário, com uma coluna de espaços inseridos entre cada linha de entrada original (para a estética).

Por exemplo, se a entrada for esta:

<>

A saída seria esta:

/\
\/

Se a entrada for esta:

><<<>
 <><

A saída seria esta:

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

Se a entrada for esta:

>>  <<
<>  <>
  <
  ><

A saída seria esta:

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

Observe como há uma única coluna de espaços entre as linhas de entrada originais nos dois últimos exemplos.

Você pode escrever um programa completo que aceita a entrada da maneira usual (linha de comando, stdin) e imprime a saída, ou pode escrever uma função com um argumento string, que imprime ou retorna a saída.

Linhas ou colunas iniciais e finais vazias de espaço em branco na entrada não precisam estar presentes na saída. Além disso, pode haver qualquer quantidade de espaços iniciais e / ou finais e / ou novas linhas na saída, em qualquer local, desde que as formas resultantes estejam corretas. Em outras palavras, a tradução da arte ascii não importa, apenas as formas e sua relação umas com as outras .

Opcionalmente, você pode assumir que a entrada tem uma nova linha à direita.

O código mais curto em bytes vence.

CJam, 35 bytes

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

Experimente online aqui

CJam, 37 bytes

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

Experimente online no intérprete CJam .

Como 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 as razões erradas, esse deve ser um dos usos mais agradáveis map(None, ...)que já tive até agora. A saída é uniforme até o retângulo perfeito.

Vamos dar o segundo exemplo:

><<<>
 <><

map(None,*s.split("\n"))realiza um homem pobre zip_longest, dando:

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

Observe como a segunda linha é mais curta que a primeira, então obtemos um Noneno final. Normalmente isso seria um problema, mas por alguma razão quase tudo é comparável no Python 2, e em particular

>>> None < ""
True

Isso significa que a expressão 1-cmp(c,"<")retorna 0, 1, 2para ">", "<", Nonerespectivamente, permitindo o uso do truque de cortar fatias para extrair um dos "\/", "/\", " ". Usando isso, imprimimos a linha de saída linha por linha, juntando os grupos de 2 caracteres com espaços.

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:

isso só funciona se a string fornecida tiver todas as linhas com o mesmo comprimento (ou seja, preenchidas com espaços)

explicação:

Estou usando fold com o valor inicial da tupla de ae Seq[String]an Int(em vez de escrever, Seq.empty[String]estou escrevendo o menor Seq("")e o .initdepois da dobra), a dobra opera em uma coleção de strings, cada string é uma linha na entrada original e cada linha é dobrado. o truque aqui era testar o módulo do char. como o '<'valor é 60 e o '>'valor é 62, o teste para o módulo 4 produzirá 0 ou 2. é por isso que a dobra também carrega um Intconjunto de inversão para 0. e alternada entre 0 e 2 com 2-i. toda linha ímpar deve mapear '>'para '/'e '<'para '\\', e toda linha par deve mapear '>'para '\\'e '<'para '/'. é por isso que eu testeic%4==ie bata em 2 pássaros com 1 pedra. a dobra "reconstrói" a sequência inicial de seqüências de caracteres em sentido inverso e, depois de soltar a última linha, transponho a sequência (é por isso que todas as seqüências de caracteres devem ter exatamente o mesmo comprimento). por causa dos implícitos envolvidos, preciso _.mkStringem cada linha (coluna anterior) e depois mkString("\n")na saída final.

Perl - 119

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

Primeiro, @lé atribuído como uma lista de listas que representam os caracteres em cada linha de entrada com linhas na ordem inversa. Em seguida, percorre as colunas de caracteres, substituindo os colchetes angulares pelas barras correspondentes, unindo os elementos com espaços e imprimindo as barras unidas como uma linha.