Giới thiệu

Viết một chương trình hoàn chỉnh xoay một khối hình chữ nhật gồm các ký tự ASCII 90 độ theo chiều kim đồng hồ. Khi chương trình được xoay 90 độ theo chiều kim đồng hồ, nó sẽ xoay một khối các ký tự ASCII 90 ngược chiều kim đồng hồ.

Quy tắc

• Bạn không sử dụng các ma trận tích hợp xoay hoặc hoán vị ma trận. Ví dụ: trong MATLAB / Octave rot90và toán tử chuyển vị 'không được phép.
• Bạn phải viết một chương trình hoàn chỉnh sử dụng STDIN và STDOUT hoặc tương đương gần nhất.
• Chương trình của bạn phải là hình chữ nhật và giả sử đầu vào cũng là hình chữ nhật.
• Đầu vào và đầu ra là một chuỗi phân tách dòng mới và sẽ không có dòng mới.

Khi chạy với mã nguồn làm đầu vào, chương trình của bạn phải tự xoay 90 độ theo chiều kim đồng hồ. Đầu ra phải là chương trình thứ hai trong cùng ngôn ngữ xoay đầu vào 90 độ ngược chiều kim đồng hồ. Khi chương trình được xoay được cung cấp mã nguồn của nó làm đầu vào, nó sẽ xuất mã nguồn của chương trình gốc.

Lưu ý: Cả hai chương trình phải hoạt động cho bất kỳ đầu vào nào , không chỉ mã nguồn riêng của chúng, vì vậy không được phép sử dụng một ký tự một ký tự.

Thí dụ

Nói sau đây là một chương trình hợp lệ xoay 90 độ đầu vào của nó trong một ngôn ngữ giả định exampleLang.

^f a2% 3
lk (^_^&
       v
D8 $4  /

Khi chạy với chính nó như là đầu vào, nó xuất ra một chương trình hợp lệ khác để quay đầu vào ngược chiều kim đồng hồ:

D l^
8 kf

$ (a
4 ^2
  _%
  ^ 
/v&3

Chương trình thứ hai này, khi được trao cho chính nó làm đầu vào, sẽ xuất ra chương trình gốc. Lưu ý rằng dòng trống nên có bốn khoảng trắng và có một khoảng trắng ở dòng thứ hai đến dòng cuối cùng không thể được hiển thị trong đánh dấu. Làm rõ:

$ examplelang program < program > rotProg
$ examplelang rotProg < rotProg > program1
$ diff -s program program1
Files program and program1 are identical

Chương trình ngắn nhất sẽ thắng. Sơ hở tiêu chuẩn bị cấm.

CJam, 26 25 21 byte

WqN/":.+""\%"(~+N-~N*

Cảm ơn @ MartinBüttner vì đã chơi golf 4 byte!

Dùng thử trực tuyến trong trình thông dịch CJam: chương trình gốc | chương trình luân chuyển

Đây là chương trình xoay vòng:

W
q
N
/
"
:
.
+
"
"
\
%
"
(
~
+
N
-
~
N
*

Ý kiến

Chúng ta có thể xoay đầu vào một phần tư theo chiều kim đồng hồ bằng cách chia nó tại các nguồn cấp dữ liệu, đảo ngược thứ tự của các hàng kết quả, hoán đổi các hàng với các cột và cuối cùng nối các hàng, được phân tách bằng các nguồn cấp.

Tương tự như vậy, chúng ta có thể xoay ngược chiều kim đồng hồ bằng cách hoán vị trước, sau đó đảo ngược các hàng.

Vì việc tích hợp chuyển vị zbị cấm, chúng ta có thể sử dụng :.+(giảm theo ký tự vectơ hoặc nối chuỗi ký tự) để đạt được hiệu quả tương tự.

:.+là phần duy nhất của mã nguồn không thể bị phá vỡ. Chúng tôi đẩy các chuỗi "W%"và ":.+", điều kiện đảo ngược chúng nếu chuỗi thứ hai chứa một nguồn cấp dữ liệu, nối, loại bỏ tất cả các nguồn cấp dữ liệu và đánh giá kết quả.

Mã

W     e# Push -1.
qN/   e# Read all input at split it at linefeeds.
":.+" e# Push a string that, when evaluated, transposes rows and columns.
      e# As explained in the previous section, this does NOT use a built-in
      e# for matrix transposition.
"\%"  e# Push a string that, when evaluated, reverses the rows.
(~    e# Shift out the first character and evaluate it.
      e# For the original code, this evaluates '\', swapping the strings on
      e# the stack. For the rotated code, this evaluates `\n', doing nothing.
+N-   e# Concatenate and remove linefeeds.
      e# The stack now contains:   -1 input "%:.+"   or   -1 input ":.+\%"
~     e# Evaluate the string on top of the stack.
N*    e# Join the resulting array, separating by linefeeds.

C (gcc) , 1420 1399 463 byte

À ... niềm vui của những chuỗi dài không xác định!

Giả định sizeof(char*) == sizeof(int)và sizeof(char**) <= 16.

Cách tiếp cận mới

char**L,*r;n,i//j=>]l n}q(( 
,j,q;R(l){for(//,l)l, +;;rr 
r=l=0;(j=     //i=)[r +))oa 
getchar())>10;//,r(r( *l(fh}
r[l++]=j,r[l]=//n(r,c=6=R)c;
0)r=realloc(r,//;rajoL1q()t)
l+2);l&&R((L= //roh=l(,,r"u)
realloc(L,++n*//*fc]l(Lro"p]
16))[n-1]=r,q=//,{t+aR(=f(;q
l);}main(){for//L)e+e&c]{sn[
(R();i<q;i++, //*lglr&o1)t<]
puts(""))for(j//*(=[=ll-(uj+
=n;j--;putchar//rRjrr;lnnp;+
(L[j][i]));}  //a;(;))a[i;0j
////////////////hq;002e)a-=[
////////////////c,01=+r)m-jL

Hãy thử trực tuyến!

Đầu ra của ở trên

Giải pháp cuối cùng thật dễ dàng. Bạn tạo một chương trình A xoay mọi thứ theo chiều kim đồng hồ và một chương trình B xoay theo chiều ngược kim đồng hồ:

Một

char**L,*r;n,i,j,q;R(l){for(r=l=0;(j=getchar())>10;r[l++]=j,r[l]=0)r=realloc(r,l+2);l&&R((L=realloc(L,16*++n))[n-1]=r,q=l);}main(){for(R();i<q;i++,puts(""))for(j=n;j--;)putchar(L[j][i]);}

B

char**L,*r;n,i,j,q;R(l){for(r=l=0;(j=getchar())>10;r[l++]=j,r[l]=0)r=realloc(r,l+2);l&&R((L=realloc(L,16*++n))[n-1]=r,q=l);}main(){for(R();q--;puts(""))for(j=0;j<n;j++)putchar(L[j][q]);}

Tạo một hình chữ nhật có tỷ lệ hợp lý và giới hạn A với điều đó, và đặt các bình luận xung quanh nó:

char**L,*r;n,i//
,j,q;R(l){for(//
r=l=0;(j=     //
getchar())>10;//
r[l++]=j,r[l]=//
0)r=realloc(r,//
l+2);l&&R((L= //
realloc(L,++n*//
16))[n-1]=r,q=//
l);}main(){for//
(R();i<q;i++, //
puts(""))for(j//
=n;j--;putchar//
(L[j][i]));}  //
////////////////
////////////////

Giới hạn chương trình B thành một hình vuông có cùng chiều rộng với hình vuông cho A cộng hai (đối với các dòng chú thích bổ sung ở cạnh dưới), xoay CCW và đặt nó sang bên phải của chương trình A và bạn có được giải pháp ở trên.

Cách tiếp cận cũ

 /*                                       r                               c                                                         c                                                  r               
r                                         a                               o                         n                               o                          s                       a               
a                          r              h                               l                         i       r                       l             r      -     t        r  =    +      h         q     
h                          o              c        0     +                l                         a       o             +         l       6     o      -     u    "   o  j<   +      c  */           
char**L,*s,*r;n,i,q;R(l,c){for(r=l=0;(c=getchar())>10;r[l++]=c,r[l]=0)r=realloc(r,l+2);q=l?l:q;l=r;}main(j){for(;s=R();L[n++]=s)L=realloc(L,16*n);for(;i<q;i++,puts(""))for(j=n;j--;)putchar(L[j][i]);}
 ///                        //          //e////     /     /             //e////                      ///     //            /      //e////    /     //  //  //// ///  /   // ;/   /// //u////      /    
 ///                        //          //g////     /     /             //r////                      ///     //            /      //r////    /     //  //  //// ///  /   // 0/   /// //p////      /    

Hãy thử trực tuyến!

Đầu ra của ở trên