90 ° सेल्फ-रोटेटिंग प्रोग्राम

Question

परिचय

एक पूरा कार्यक्रम लिखें जो ASCII वर्णों के आयताकार ब्लॉक को 90 डिग्री दक्षिणावर्त घुमाता है। जब प्रोग्राम को स्वयं 90 डिग्री दक्षिणावर्त घुमाया जाता है, तो यह ASCII वर्णों के एक ब्लॉक को 90 वामावर्त घुमाता है।

नियम

• आप कई बिल्ट-इन का उपयोग नहीं करते हैं जो मेट्रिसेस को घुमाते या स्थानांतरित करते हैं। उदाहरण के लिए, MATLAB / ऑक्टेव rot90और पारगमन ऑपरेटर 'की अनुमति नहीं है।
• आपको एक पूरा कार्यक्रम लिखना होगा जो STDIN और STDOUT या निकटतम समकक्ष का उपयोग करता है।
• आपका प्रोग्राम आयताकार होना चाहिए और मान लें कि इनपुट भी आयताकार है।
• इनपुट और आउटपुट एक नई लाइन से अलग किए गए तार हैं और इसमें नई सीमाएँ नहीं होंगी।

जब इनपुट के रूप में इसके स्रोत कोड के साथ चलाया जाता है, तो आपके प्रोग्राम को 90 डिग्री दक्षिणावर्त घुमाना चाहिए। आउटपुट का उसी भाषा में एक दूसरा प्रोग्राम होना चाहिए जो अपने इनपुट को 90 डिग्री वामावर्त घुमाए। जब घुमाए गए कार्यक्रम को इनपुट के रूप में अपना स्रोत कोड दिया जाता है, तो उसे मूल कार्यक्रम के स्रोत कोड का उत्पादन करना चाहिए।

नोट: दोनों कार्यक्रमों को किसी भी इनपुट के लिए काम करना चाहिए , न कि केवल अपने स्वयं के स्रोत कोड के लिए, इसलिए एक वर्ण की अनुमति नहीं है।

उदाहरण

निम्नलिखित कहें कि एक वैध कार्यक्रम है जो अपने इनपुट को 90 डिग्री तक काल्पनिक भाषा में घुमाता है।

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

जब इनपुट के रूप में स्वयं के साथ चलाया जाता है, तो यह एक अन्य वैध प्रोग्राम को आउटपुट करता है जो इसके इनपुट वामावर्त को घुमाता है:

D l^
8 kf

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

यह दूसरा कार्यक्रम, जब खुद को इनपुट के रूप में दिया जाता है, तो मूल कार्यक्रम का आउटपुट होता है। ध्यान दें कि रिक्त रेखा में चार स्थान होने चाहिए और दूसरी से अंतिम पंक्ति के लिए एक अनुगामी स्थान है जिसे मार्कडाउन में प्रस्तुत नहीं किया जा सकता है। स्पष्टीकरण देना:

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

सबसे छोटा कार्यक्रम जीतता है। मानक खामियों पर रोक लगाई जाती है।

Answer 1

CJam, 26 25 21 बाइट्स

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

4 बाइट बंद करने के लिए @ मार्टिनबटनर को धन्यवाद!

CJam दुभाषिया में इसे ऑनलाइन आज़माएं: मूल कार्यक्रम | घुमाया गया कार्यक्रम

यह घुमाया गया कार्यक्रम है:

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

विचार

हम इनपुट को एक चौथाई मोड़ को दक्षिणावर्त घुमा सकते हैं, इसे लाइनफीड में विभाजित करके, परिणामी पंक्तियों के क्रम को उलट कर, पंक्तियों के साथ पंक्तियों को स्थानांतरित कर, और अंत में पंक्तियों को जोड़कर, पंक्तिबद्ध करके अलग किया जा सकता है।

इसी तरह, हम पहले ट्रांसकॉन्कवाइज़ घुमा सकते हैं, फिर पंक्तियों को उलट कर।

चूंकि ट्रांसपोज़ेशन बिल्ट-इन zनिषिद्ध है, इसलिए हम :.+उसी प्रभाव को प्राप्त करने के लिए (वेक्टर वर्ण या स्ट्रिंग-वर्ण संयोजन द्वारा कम कर सकते हैं) का उपयोग कर सकते हैं ।

:.+स्रोत कोड का एकमात्र हिस्सा है जिसे तोड़ा नहीं जा सकता। हम स्ट्रिंग्स को धक्का देते हैं "W%"और ":.+", सशर्त रूप से उन्हें उल्टा करते हैं यदि दूसरे स्ट्रिंग में एक लाइनफीड, कॉन्फेटनेट, सभी लाइनफीड को हटा दें, और परिणाम का मूल्यांकन करें।

कोड

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.

Comments

यह इतना छोटा कैसे है? गंभीरता से हालांकि, क्यों :.+कई लाइनों पर नहीं तोड़ा जा सकता है?

— इंट्रेपिडकोडर

वाक्य रचना संबंधी कारणों से @intrepidcoder। दोनों का अर्थ :और उनके बाद. के चरित्र पर निर्भर करता है, और उन लोगों में से किसी के बाद भी लाइनफीड वैध नहीं है (और यदि वे थे भी, तो इससे प्रोग्राम का अर्थ बदल जाएगा)।

— मार्टिन एंडर

Answer 2

सी (जीसीसी) , 1420 1399 463 बाइट्स

आह ... अनिर्धारित लंबाई के तार की खुशी!

मान लेता है sizeof(char*) == sizeof(int)और sizeof(char**) <= 16।

नया तरीका

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

इसे ऑनलाइन आज़माएं!

ऊपर का आउटपुट

समाधान अंत में शर्मनाक रूप से आसान था। आप एक प्रोग्राम ए बनाते हैं जो चीजों को दक्षिणावर्त घुमाता है, और एक प्रोग्राम बी जो काउंटर-क्लॉकवाइज घुमाता है:

ए

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

बी

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

उचित अनुपातों की एक आयत बनाएँ और A को उस तक सीमित रखें, और उसके चारों ओर टिप्पणियों का रख दें:

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]));}  //
////////////////
////////////////

प्रोग्राम बी को एक वर्ग में परिभाषित करें जो ए प्लस दो (नीचे किनारे पर टिप्पणियों की अतिरिक्त पंक्तियों के लिए) के समान है, इसे CCW घुमाएं और इसे प्रोग्राम A के दाईं ओर थप्पड़ मारें और आपको ऊपर समाधान मिल जाए।

पुराना दृष्टिकोण

 /*                                       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////      /    

इसे ऑनलाइन आज़माएं!

ऊपर का आउटपुट