बॉक्स को इंप्लोड करें

Question

ASCII बॉक्स इस तरह दिखते हैं:

++    +---+    +------+    +---+    +---+
++    |   |    |      |    |   |    |   |
      |   |    |      |    |   |    |   |
+-+   |   |    |      |    |   |    |   |
+-+   |   |    |      |    |   |    +---+
      +---+    |      |    |   |
+--+           |      |    |   |    ++
|  |           |      |    |   |    ||
|  |           +------+    |   |    ||
+--+                       |   |    ||
                           +---+    ||
                                    ||
                  +-----+           ||
+------------+    |     |           ++
|            |    |     |
|            |    |     |
+------------+    +-----+

यहाँ एक ही ASCII बक्से के कुछ उदाहरण दिए गए हैं:

++    +- -+    +-    -+    +- -+    +- -+
++    | - |    | -  - |    | - |    | - |
       | |      | -- |      | |      | |
+-+    | |       |  |        "      | - |
+-+   | - |       ||        | |     +- -+
      +- -+      |  |      |   |
+--+            | -- |      | |     ++
|  |           | -  - |      "      ||
|  |           +-    -+     | |     ||
+--+                       | - |   |  |
                           +- -+   |  |
      --                            ||
     -  -         +-   -+           ||
+-  -    -  -+    | - - |           ++
| --      -- |     | = |
| --      -- |    | - - |
+-  -    -  -+    +-   -+
     -  -
      --

यहाँ एक आसान-से-प्रतिलिपि प्रारूप में इन सभी परीक्षण केस बॉक्स का लिंक दिया गया है। आदेश सभी इनपुट के बाद सभी आउटपुट एक ही क्रम में है।

आपका लक्ष्य इनपुट के रूप में एक ASCII बॉक्स लेना है, और फूटा हुआ बॉक्स वापस करना है। प्रत्यारोपण के नियम हैं:

1. "+" कभी नहीं बदलता; न तो "-" या "|" सीधे "+" से सटे
2. कोनों से शुरू, "-" और "|" कोने के करीब एक ही चरित्र की तुलना में एक स्थान से अधिक अंदर की ओर ले जाएँ। अगर एक "-" और "|" कभी भी एक ही स्थान पर जा सकते हैं, न ही चलते हैं।
3. यदि एक "-" और "-" एक ही स्थान पर जाते हैं, तो उस स्थान पर "=" डालें। यदि एक "|" और "|" उसी स्थान पर जाने के लिए, "उस स्थान पर" रखें। ये दोनों एक ही स्थान पर अपने संबंधित वर्णों के विपरीत दिशाओं में चलते हैं।
4. दो "-" या दो "|" एक दूसरे को पीछे छोड़ सकते हैं, जैसा कि नीचे बाएं उदाहरण में देखा गया है।
5. यदि बॉक्स पर्याप्त पतला है, तो यह उसी तरह से बाहर की तरफ विस्तार करना शुरू कर देगा, हमेशा उस तरफ से दूर जा रहा है जहां से यह भाग शुरू हुआ था।
6. परिणाम x और y दोनों दिशाओं में केंद्र रेखा के सममित होना चाहिए (नए सिरे से अनदेखी करना); इसमें रिक्त स्थान शामिल हैं, इसलिए परिणाम को संतुष्ट करने के लिए रिक्त स्थान के साथ गद्देदार होने की आवश्यकता हो सकती है।

नियम विवरण:

1. यह कोड-गोल्फ है, इसलिए बाइट्स जीत में सबसे छोटा कार्यक्रम है।
2. मानक खामियां लागू होती हैं।
3. आप मान सकते हैं कि एक नई पंक्ति में प्रत्येक पंक्ति समाप्त होती है।
4. इनपुट स्ट्रिंग में केवल वर्ण "+", "-", "|", "", और "\ n" (newline) होंगे, और आपके आउटपुट स्ट्रिंग को "=" जोड़कर समान नियमों का पालन करना चाहिए। और "संभव पात्रों के रूप में।
5. अंतिम पंक्ति के अंत में आपके पास वैकल्पिक रूप से एक एकल अनुगामी नई रेखा हो सकती है।
6. सबसे छोटा ASCII बॉक्स जिसे आपको संभालना है, वह शीर्ष-बाएँ उदाहरण है। प्रत्येक ASCII बॉक्स में इसके कोनों पर ठीक 4 "+" s होगा।
7. आपको m x nकिसी भी पूर्णांक के आकार के बक्से को संभालना होगा m,nजैसे कि 2<=m,n<256(सबसे बड़ा संभव स्ट्रिंग आकार 255*(255+1))
8. आप मान सकते हैं कि आपको इनपुट के रूप में हमेशा एक ही मान्य ASCII बॉक्स मिलेगा।

Comments

मुझे लगता है कि आप नियम विवरणों के अंक 4 के आउटपुट में "संभावित चरित्र के रूप में जोड़ना भूल गए। संपादित करें: क्या हम मान सकते हैं कि इनपुट में कोई खाली रेखा नहीं है?

— थरोट

यह 1x6 उदाहरण कायरतापूर्ण है, यह बाहर की ओर क्यों फैलता है? मुझे लगता ||है कि उस उदाहरण में से एक को एक "या कुछ और होने की जरूरत है ...

— मैजिक ऑक्टोपस Urn

@carusocomputing नीचे बाईं ओर के उदाहरण के समान है, दीवारें एक दूसरे के माध्यम से चलती हैं (इसलिए बॉक्स की मात्रा नकारात्मक है) - नियम 4 और 5

— Lyth

@ लेकिन क्या अब भी नहीं होना चाहिए "? मुझे लगता है कि "केवल 3-चौड़ा या अधिक दिखाई देता है?

— मैजिक ऑक्टोपस Urn

@carusocomputing इस पर विचार करें: कहाँ जाना होगा "? बाईं ओर, या दाईं ओर? यह दोनों नहीं हो सकता है, लेकिन यह नहीं हो सकता है क्योंकि परिणाम सममित है।

— हाइपरनेत्रिनो

Answer 1

पायथन 2 , 591 555 545 527 525 496 436 351 334 333 303 बाइट्स

s=input()
w=len(s[0])
h=len(s)
V=max(0,w/2-h)
H=max(0,h/2-w)
p=[[' ']*w]*V
q=[' ']*H
s=[q+k+q for k in p+s+p]
d,c=' -=',' |"'
exec"c,d,V,H,w,h=d,c,H,V,h,w;s=map(list,zip(*s))[::-1]\nfor j in range(h-4):q=s[V+j+2];q[H]=c[q[H]==c[2]];r=H+min(j+1,h-4-j);q[r]=c[1+(q[r]>' ')]\n"*4
for x in s:print''.join(x)

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

संपादित करें : मेरी पुरानी पद्धति ने पहले ऊपर और नीचे और फिर बाएं और दाएं को फंसाया। इसके बजाय, हम शीर्ष को फंसा सकते हैं, 90 डिग्री घुमा सकते हैं और ऐसा 4 बार कर सकते हैं। इसके अलावा, मैं उपयोगकर्ता के अनुकूल कोड का उपयोग कर रहा था, इसके लिए इनपुट की आवश्यकता होती है [['+', '-', '-', '-', '-', '-', '+'], ['|', ' ', ' ', ' ', ' ', ' ', '|'], ['|', ' ', ' ', ' ', ' ', ' ', '|'], ['|', ' ', ' ', ' ', ' ', ' ', '|'], ['+', '-', '-', '-', '-', '-', '+']]जो कि बदसूरत है, लेकिन कार्यक्रम के लिए छोटा है: पी (उस को पकड़ने के लिए फीनिक्स के लिए धन्यवाद)

मानव-पठनीय इनपुट को कंप्यूटर-पठनीय इनपुट में परिवर्तित करने के लिए उपयोग किए जाने वाले TIO लिंक में हेडर कोड के लिए लीक नन को क्रेडिट।

-85 बाइट्स लीकी नन की बदौलत!
-17 बाइट्स टॉप-इम्पोसियेशन से लेफ्ट-इम्प्लांटेशन पर स्विच करके जो पूरी पंक्ति को एक चर और संशोधित में संग्रहीत करने की अनुमति देता है। सुझाव के लिए लीक नन को धन्यवाद!
एक जगह को हटाने के लिए चीजों को स्विच करके -1 बाइट।
-30 बाइट्स लीक नन की बदौलत!

Comments

असाइन करें s[0]और S[0]कुछ बाइट्स को बचाने के लिए चर

— caird coinheringaahing

@ इलीकेमिडॉग ओह, राइट। धन्यवाद!

— हाइपरएनुट्रिनो

आप बदल सकते हैं p=s[0]और P=S[0]साथ p=z(s[0])और P=z(S[0]), क्रमशः, और उसके बाद की सभी घटनाओं की जगह z(p)के साथ pऔर सभी z(P)के साथ Pकरने के लिए सेव 18 बाइट्स।

— आर। कप

तुम भी जगह ले सकता है (z(s)-1)/2-pके साथ z(s)/2-.5-pऔर (p-1)/2-z(s)साथ p/2-.5-z(s)2 और बाइट्स को बचाने के लिए।

— आर। कप

@ R.Kap ओह ठीक है। दोनों सुझावों के लिए धन्यवाद!

— हाइपरएनुट्रीनो

Answer 2

सी (क्लैंग) , 693 बाइट्स

पठनीयता के लिए नई लाइनें जोड़ी गईं। पहले दो आवश्यक हैं लेकिन बाकी नहीं हैं।

#define P B[i][l]
#define m malloc(8)
I(B,h,V,S,J,Z,i,j,l,n,H,W,c,C,a,z,_,L,G,u,N,M)char**B,**Z;char*L,*G,*u;{
V=strlen(B[0]);
S=J=0;
Z=m;
for(i=0,j=h-1;i<h/2+h%2;i++,j--){
for(l=0,n=V-1;l<V/2+V%2;l++,n--){
if(P!=43&&((B[i][l-1]!=43&&i<1)||(B[i-1][l]!=43&&l<1))){
H=P==45;
W=P=='|';
P=B[j][l]=B[i][n]=B[j][n]=32;
if(H){
c=(N=i+l-1)==(M=j-l+1)?61:45;
if(M<0)L=m,sprintf(L,"%*s",V,""),L[l]=L[n]=c,Z[J]=L,J++;
else B[N][l]=B[N][n]=B[M][l]=B[M][n]=c;
}
if(W){
c=(N=l+i-1)==(M=n-i+1)?34:'|';
if(M<0)G=m,sprintf(G,"|%*s%s%*s|",i-n-2,"",B[i],i-n-2,""),B[i]=B[j]=G,S++;
else B[i][N]=B[j][N]=B[i][M]=B[j][M]=c;
}
}
}
}
for(a=-J+1;a<=h+J;u=a<1?Z[-a]:a<=h?B[a-1]:Z[a-h-1],C=S+1-strlen(u)/2,printf("%*s%s\n",C>0?C:0,"",u),a++);
}

बड़ी चुनौती के लिए धन्यवाद! यह काफी मुश्किल था लेकिन मुझे अब भी बहुत मज़ा आ रहा था।

यह इनपुट को कमांड-लाइन तर्क के रूप में लेता है और एन्कोडेड बॉक्स के मल्टी-लाइन स्ट्रिंग को STDOUT में आउटपुट करता है। हमेशा की तरह, गोल्फ टिप्स की बहुत सराहना की जाती है।

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