Scrivere un programma che prende in una stringa che contiene solo spazi, a capo, e parentesi angolari: <, >( chevron ). Uscita una serie di spazi, a capo e barre: /, \( soliduses ) le cui forme corrisponde all'ingresso, ma ruotata di un quarto di giro in senso orario, con una colonna di spazi inseriti tra ogni riga della ingresso originale (per l'estetica).

Ad esempio, se l'input è questo:

<>

L'output sarebbe questo:

/\
\/

Se l'input è questo:

><<<>
 <><

L'output sarebbe questo:

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

Se l'input è questo:

>>  <<
<>  <>
  <
  ><

L'output sarebbe questo:

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

Si noti come vi sia una singola colonna di spazi tra le righe di input originali negli ultimi due esempi.

È possibile scrivere un programma completo che accetta l'input in qualsiasi modo normale (riga di comando, stdin) e stampa l'output, oppure è possibile scrivere una funzione con un argomento stringa, che stampa o restituisce l'output.

Non è necessario che nell'output siano presenti righe o colonne vuote iniziali e finali di spazi bianchi nell'input. Inoltre, ci può essere qualsiasi quantità di spazi iniziali e / o finali e / o newline nell'output, in qualsiasi posizione, purché le forme risultanti siano corrette. In altre parole, la traduzione dell'arte ascii non ha importanza, ma solo le forme e la loro relazione reciproca .

Puoi facoltativamente supporre che l'input abbia una nuova riga finale.

Vince il codice più breve in byte.

CJam, 35 byte

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

Provalo online qui

CJam, 37 byte

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

Provalo online nell'interprete CJam .

Come funziona

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 byte

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

Per tutte le ragioni sbagliate, questo deve essere stato uno degli usi più belli map(None, ...)che abbia avuto finora. L'output si adatta anche al rettangolo perfetto.

Facciamo il secondo esempio:

><<<>
 <><

map(None,*s.split("\n"))esegue un povero zip_longest, dando:

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

Nota come la seconda riga è più corta della prima, quindi otteniamo un Nonealla fine. Normalmente questo sarebbe un problema, ma per qualche ragione quasi tutto è paragonabile in Python 2, e in particolare

>>> None < ""
True

Ciò significa che l'espressione 1-cmp(c,"<")ritorna rispettivamente 0, 1, 2per ">", "<", None, permettendoci di usare il trucco di affettare le stringhe per estrarne uno "\/", "/\", " ". Usando questo, stampiamo l'output riga per riga, unendo i gruppi a 2 caratteri con spazi.

Scala, 201 188 180 caratteri

(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:

funziona solo se la stringa fornita ha tutte le linee di uguale lunghezza (ovvero riempite di spazi)

spiegazione:

Sto usando fold con il valore iniziale di tupla di a Seq[String]e an Int(invece di scrivere Seq.empty[String]im scrivendo il più breve Seq("")e .initdopo il fold), il fold opera su una raccolta di stringhe, ogni stringa è una riga nell'input originale e ogni riga è raddoppiato. il trucco qui era testare il modulo del carattere. dato che il '<'valore è 60 e il '>'valore è 62, testando per modulo 4, produrrà 0 o 2. ecco perché il fold porta anche un Intset di lanci su 0. e capovolto tra 0 e 2 con 2-i. ogni linea dispari dovrebbe essere mappata '>'su '/'e '<'verso '\\', e ogni linea pari dovrebbe mappare '>'su '\\'e '<'su '/'. questo è il motivo per cui provoc%4==ie colpisci 2 uccelli con 1 pietra. la piega "ricostruisce" la sequenza iniziale di stringhe al contrario, e quindi (dopo aver lasciato cadere l'ultima riga), traspongo la sequenza (ecco perché tutte le stringhe devono avere la stessa identica lunghezza). a causa degli impliciti coinvolti, ho bisogno di _.mkStringogni riga (precedentemente colonna), e quindi mkString("\n")per l'output finale.

Perl - 119

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

Innanzitutto, @lviene assegnato come un elenco di elenchi che rappresentano i caratteri su ciascuna riga di input con righe in ordine inverso. Quindi scorre tra le colonne di caratteri, sostituendo le parentesi angolari con le corrispondenti barre, unendo gli elementi con spazi e stampando le barre unite come una linea.