Viết chương trình nhận một chuỗi chỉ chứa khoảng trắng, dòng mới và dấu ngoặc nhọn : <, >( chevrons ). Xuất ra một chuỗi các khoảng trắng, dòng mới và dấu gạch chéo : /, \( soliduses ) có hình dạng tương ứng với đầu vào, nhưng xoay một phần tư theo chiều kim đồng hồ, với một cột khoảng trắng được chèn giữa mỗi hàng của đầu vào ban đầu (cho tính thẩm mỹ).

Ví dụ: nếu đầu vào là thế này:

<>

Đầu ra sẽ là thế này:

/\
\/

Nếu đầu vào là thế này:

><<<>
 <><

Đầu ra sẽ là thế này:

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

Nếu đầu vào là thế này:

>>  <<
<>  <>
  <
  ><

Đầu ra sẽ là thế này:

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

Lưu ý cách có một cột khoảng trắng giữa các hàng đầu vào ban đầu trong hai ví dụ cuối.

Bạn có thể viết một chương trình đầy đủ lấy đầu vào theo bất kỳ cách thông thường nào (dòng lệnh, stdin) và in đầu ra hoặc bạn có thể viết một hàm với một đối số chuỗi, in hoặc trả về đầu ra.

Các hàng hoặc cột trống hàng đầu và dấu của khoảng trắng trong đầu vào không cần phải có trong đầu ra. Ngoài ra, có thể có bất kỳ số lượng không gian hàng đầu và / hoặc dấu và / hoặc dòng mới trong đầu ra, ở bất kỳ vị trí nào, miễn là hình dạng kết quả là chính xác. Nói cách khác, bản dịch của nghệ thuật ascii không quan trọng, chỉ có hình dạng và mối quan hệ của chúng với nhau mới làm .

Bạn có thể tùy ý giả sử đầu vào có một dòng mới.

Mã ngắn nhất tính bằng byte thắng.

CJam, 35 byte

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

Dùng thử trực tuyến tại đây

CJam, 37 byte

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

Hãy thử trực tuyến trong trình thông dịch CJam .

Làm thế nào nó hoạt động

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])

Vì tất cả các lý do sai, điều này đã trở thành một trong những cách sử dụng tốt nhất của map(None, ...)tôi cho đến nay. Các đầu ra thậm chí miếng đệm để hình chữ nhật hoàn hảo.

Hãy lấy ví dụ thứ hai:

><<<>
 <><

map(None,*s.split("\n"))thực hiện một người đàn ông nghèo zip_longest, cho:

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

Lưu ý cách dòng thứ hai ngắn hơn dòng đầu tiên, vì vậy chúng tôi nhận được một dòng Noneở cuối. Thông thường đây sẽ là một vấn đề, nhưng vì một số lý do, hầu hết mọi thứ đều có thể so sánh được trong Python 2 và đặc biệt

>>> None < ""
True

Điều này có nghĩa rằng các biểu hiện 1-cmp(c,"<")lợi nhuận 0, 1, 2cho ">", "<", Nonetương ứng, cho phép chúng ta sử dụng chuỗi cắt lừa để trích xuất một trong "\/", "/\", " ". Sử dụng điều này, chúng tôi in dòng đầu ra theo dòng, tham gia các nhóm 2 char có khoảng trắng.

Scala, 201 188 180 ký tự

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

chú thích:

điều này chỉ hoạt động nếu chuỗi được cung cấp có tất cả các dòng có độ dài bằng nhau (nghĩa là được đệm bằng khoảng trắng)

giải trình:

Tôi đang sử dụng nếp gấp với giá trị ban đầu là tuple của a Seq[String]và Int(thay vì viết là Seq.empty[String]viết ngắn hơn Seq("")và .initsau nếp gấp), nếp gấp hoạt động trên một tập hợp các chuỗi, mỗi chuỗi là một dòng trong đầu vào ban đầu và mỗi dòng được nhân đôi. mẹo ở đây là kiểm tra modulo của char. vì '<'giá trị là 60 và '>'giá trị là 62, thử nghiệm cho modulo 4, sẽ mang lại 0 hoặc 2. đó là lý do tại sao nếp gấp cũng mang một Intbộ lật thành 0. và lật giữa 0 và 2 với 2-i. mọi dòng lẻ nên ánh xạ '>'tới '/'và '<'đến '\\', và mọi dòng chẵn nên ánh xạ '>'tới '\\'và '<'tới '/'. đây là lý do tại sao tôi kiểm trac%4==ivà đánh 2 con chim bằng 1 hòn đá. nếp gấp "xây dựng lại" chuỗi ban đầu theo chiều ngược lại, và sau đó (sau khi thả dòng cuối cùng), tôi hoán đổi chuỗi (đây là lý do tại sao tất cả các chuỗi phải có cùng độ dài). vì những ẩn ý liên quan, tôi cần phải _.mkStringtrên mỗi dòng (cột trước đó), và sau đó mkString("\n")cho đầu ra cuối cùng.

Perl - 119

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

Đầu tiên, @lđược gán dưới dạng danh sách các danh sách đại diện cho các ký tự trên mỗi dòng đầu vào với các dòng theo thứ tự ngược lại. Sau đó, nó lặp qua các cột của các ký tự, thay thế các dấu ngoặc góc bằng các dấu gạch chéo tương ứng, nối các phần tử với khoảng trắng và in các dấu gạch chéo đã nối thành một dòng.