एक टेबल दी, कुर्सियों में जगह दी

Question

चुनौती

आपको इनपुट के रूप में एक टेबल दी जाएगी, ASCII के साथ |और _। आपका काम इसके चारों ओर कुर्सियां ​​स्थापित करना है।

उदाहरण

इनपुट:

 ____
|    |
|    |
|    |
|    |
|____|

आउटपुट:

 _^_^_
<     >
|     |
<     >
|     |
<_ _ _>
  v v

उन कुर्सियों के बने होते हैं <>और v^।

एक और उदाहरण:

इसमें लाइन में अधिक से अधिक कुर्सियां ​​होनी चाहिए।

  _____
 |     |_____
 |           |
 |           |
 |           |
 |      _____|
 |_____|


  _^_^_
 <     |_^_^_
 |           >
 <           |
 |           |
 <      _ _ _>
 |_ _ _| v v
   v v

हर कुर्सी के बीच रिक्त स्थान होना चाहिए। और >_^_^_<अमान्य है, यह होना चाहिए |_^_^_|।

  _____       _____
 |     |_____|     |
 |                 |
 |                 |
 |                 |
 |      ___________|
 |_____|


  _^_^_       _^_^_
 <     |_^_^_|     >
 |                 |
 <                 >
 |                 |
 <      _ _ _ _ _ _>
 |_ _ _| v v v v v
   v v

कोई भी कुर्सियां ​​"डोनट" के अंदर नहीं हो सकती हैं।

  _________________
 |      _____      |
 |     |     |     |
 |     |     |     |
 |     |_____|     |
 |_________________|


  _^_^_^_^_^_^_^_^_
 <      _____      >
 |     |     |     |
 <     |     |     >
 |     |_____|     |
 <_ _ _ _ _ _ _ _ _>
   v v v v v v v v

^और vप्राथमिकता <और >। इस पर कोई कुर्सी नहीं है (इसे कम से कम एक |या _पंक्ति में होना चाहिए)।

  _________________
 |      _____      |
 |     |     |     |
 |     |     |_____|
 |     |_____
 |___________|


  _^_^_^_^_^_^_^_^_
 <      _ _ _      >
 |     | v v |     |
 <     >     <_ _ _>
 |     |_^_^_  v v
 <_ _ _ _ _ _|
   v v v v v

यह कोड गोल्फ है, इसलिए सबसे छोटा कोड जीतता है।

Comments

मैं असमंजस में हूं, कि कुर्सियां ​​पक्षों से टेबल में क्यों डाली गई हैं?

— ऑप्टिमाइज़र

यदि मुझे सही ढंग से याद है, तो आपके मूल सैंडबॉक्स पोस्ट में वर्टिकल टेबल लाइन और चेयर लाइन के बीच एक जगह थी। जैसे क्षैतिज टेबल लाइनों और कुर्सियों के बीच थोड़ी जगह होती है।

— ऑप्टिमाइज़र

ऐसा लगता है कि कुर्सियों को एक दूसरे के साथ 1 दूरी के साथ रखा गया है, लेकिन किसी भी इनपुट के आस-पास 2 से विभाज्य नहीं है। कैसे कार्यक्रम को कुर्सियां ​​लगाना शुरू करना चाहिए। दक्षिणावर्त या विरोधी घड़ी बुद्धिमान? शीर्ष दाएं कोने, शीर्ष बाएं कोने आदि से?

मुझे यह भी लगता है कि तीसरे नमूने में एक समस्या है - दूसरे और तीसरे "शीर्ष" कुर्सियों के बीच एक अतिरिक्त स्थान है - और अंतिम उदाहरण में भी, नीचे-दाएं कोने

पहला टेस्ट केस टूटा हुआ लग रहा है। इनपुट केवल 4 चौड़ा है और आउटपुट 5 है

— गेहूं जादूगर

Answer 1

अजगर 2, 1033 1007 924 879 829 787 713 699 692 691 688 687 672 670 664 659 654 648 643 642 630 625 623 620 570 560 554 545 518 514 513 510 505 492 476 454 451 443 बाइट्स

6 बाइट्स ने रिले को धन्यवाद दिया

अदनान की बदौलत 6 बाइट बच गईं

चूंकि यह सवाल एक साल से अधिक पुराना है और अभी भी मेरे पास कोई जवाब नहीं है, तो मैंने सोचा कि मैं इसे आज़माऊंगा।

n,i,o,u="\nI _";R=lambda x:range(1,x-1)
b=open(i).read()
s=b.split(n)
z=max(map(len,s))+3
a=[list(i+x.ljust(z,i))for x in[i]+s+[i]]
for x in R(len(a))*len(b):
 A=a[x];B=a[x+1];C=a[x-1]
 for y in R(z):
    D=A[y-1:y+2];k=B[y];j=A[y+1]
    if(i in[C[y],k]+D+(k==u)*B[y-1:y+2]or"V"==j)&(A[y]==o):A[y]=i
    if"|"==A[y]==C[y]:A[y]={i:"|",j:">",A[y-1]:"<"}[i]
    if[u]*3==D:A[y],B[y]={i:u+k,C[y]:"^"+k,k:" V"}[i]
print n.join(`y`[2::5]for y in a).replace(i,o)

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

कार्यक्रम तालिका नामक एक फ़ाइल को पढ़ता है Iऔर तालिका को अपनी कुर्सियों के साथ प्रिंट करता है std::out। मुझे किनारे के मामलों के एक समूह के बारे में निश्चित नहीं था इसलिए मैंने अपना सर्वश्रेष्ठ निर्णय लिया (जो भी कम से कम प्रयास किया) लेकिन यह सभी परीक्षण मामलों को पारित करने के लिए लगता है। कुछ आउटपुट बिल्कुल मेल नहीं खाते, लेकिन उन सभी में कुर्सियों की संख्या समान है।

व्याख्या

पहली पंक्ति सुंदर बस कुछ परिभाषाएँ निर्धारित करती है जो हमें भविष्य में बाइट्स बचाएगी:

(मैं भविष्य की लाइनों में पठनीयता के लिए इन मैक्रो को अनपैक करूंगा)

n,i,o="\nI ";R=lambda x:range(1,x-1)

फिर हम एक फ़ाइल खोलेंगे जिसका नाम Iहमारे पास पहले से ही एक चर है जो इसके लिए छोटा है इसलिए यह कुछ बाइट्स बचाता है।

b=open("I").read().split("\n")

तार की सूची (छवि की पंक्तियाँ) बनाने के लिए हम नए सिरे से विभाजित होते हैं

s=b.split(n)

मैं तब सबसे लंबी लाइन की लंबाई का पता लगाता हूं ताकि मैं उस लंबाई तक सभी लाइनों को पैड कर सकूं। (मैं 3 भी जोड़ता हूं क्योंकि हमें अतिरिक्त पैडिंग की आवश्यकता है)

 z=max(map(len,s))+3

फिर हम वास्तविक पैडिंग करते हैं और Iकिनारे के चारों ओर पात्रों की सीमा बनाते हैं । ऐसा इसलिए है क्योंकि हमें बाद में आकार के अंदर और बाहर के बीच के अंतर को बताने की आवश्यकता होगी। हम डेटा प्रकार को स्ट्रिंग की सूची से पात्रों की सूची की सूची (लंबाई 1 स्ट्रिंग्स) में भी बदल देंगे।

a=[list("I"+x.ljust(z,"I"))for x in["I"]+s+["I"]]

अगली पंक्ति सिर्फ एक और बाइट बचत परिभाषा है।

(मैं इसे भी अनपैक करूंगा)

B=R(len(a))

अब हम Iआकृति के बाहर हर जगह वर्ण फैलाना चाहते हैं । हम एक छद्म सेलुलर ऑटोमेटन के साथ ऐसा कर सकते हैं। प्रत्येक Iकिसी भी आसन्न पात्रों में फैल जाएगा । हम तब तक लूप कर सकते हैं जब तक कि ऑटोमेटन स्थिर न हो जाए लेकिन इससे अधिक पुनरावृत्तियां नहीं हो सकती हैं, इसलिए हम हर वर्ण b(मूल इनपुट) के माध्यम से लूप करते हैं

for _ in b:

प्रत्येक पुनरावृत्ति के लिए हम हर पात्र को २ डी सूची में छोड़ना चाहते हैं (सबसे बाहरी गद्दी को छोड़कर)

 for x in range(1,len(a)-1):
    A=a[x]  #<--Another definition I will fill in for clarity
    for y in range(1,z-1):

प्रत्येक स्थिति के लिए हम निम्नलिखित कोड चलाते हैं:

if("I" in[a[x+1][y],a[x-1][y]]+a[x][y-1:y+2])&(a[x][y]==" "):a[x][y]=" "

इससे टूट जाते हैं।

अगर एक &(बिटवाइज़ and) द्वारा अलग दो शर्तों के साथ हम

पहले एक बस की जाँच करता है अगर वहाँ Iआसन्न कोशिकाओं में से एक में है और दूसरा सिर्फ एक जाँच करता है कि क्या वर्तमान सेल एक है " "। यदि हम उन शर्तों को पास करते हैं जो हम वर्तमान सेल को सेट करते हैं a I।

---

अब जब हमने आकार के बाहर और अंदर का निर्धारण किया है, तो हम मेज के चारों ओर कुर्सियां ​​लगाना शुरू कर सकते हैं।

एक बार फिर हम सभी कोशिकाओं के माध्यम से लूप करते हैं (और कुछ और शॉर्टहैंड सेट करते हैं)

for x in range(1,len(a)-1):
 A=a[x]
 for y in range(1,z-1):
        k=a[x+1][y]

अब यहाँ मेरा पसंदीदा हिस्सा है। यदि आपने मेरी उबाऊ, अधिकतर परिभाषा के आधार पर ट्राउडिंग की है, तो अब तक मैं आपको चतुर गोल्फिंग (यदि मैं स्वयं ऐसा कहता हूं) का एक अच्छा tidbit के साथ पुरस्कृत करने जा रहा हूं।

अजगर में थोड़ी पृष्ठभूमि:

पायथन में यदि आप एक शब्दकोश कुंजी को दो बार असाइन करने का प्रयास करते हैं तो यह बाद वाले को असाइन करता है। उदाहरण के लिए

>>> {1:"a",1:"b"}[1]
'b'

हम वर्तमान संपत्ति को किसी विशेष वर्ण को निर्दिष्ट करने के लिए इस संपत्ति का दुरुपयोग करेंगे।

पहली शर्त है

if["_"]*3==a[x][y-1:y+2]:a[x][y],a[x+1][y]={"I":"_"+a[x+1][y],a[x-1][y]:"^ ",a[x+1][y]:" V"}["I"]

यदि सेल 3 _अक्षरों के किनारे के बीच में है, तो हम वर्तमान सेल और उसके नीचे की सेल को फिर से असाइन करेंगे। हम इसे एक अतिभारित शब्दकोश अनुक्रमित करने के परिणाम के लिए आवंटित करेंगे I। हम पहले जोड़े के साथ अपना डिफ़ॉल्ट सेट करते हैं "I":"_"+a[x+1][y]इसका मतलब यह है कि अगर कोई बदलाव नहीं है तो हम दो कोशिकाओं को उनके मूल मूल्यों को वापस सौंप देंगे। अगला हम जोड़ी को जोड़ते हैं a[x-1][y]:"^ "। यह तब तक कुछ भी नहीं करता है (महत्वपूर्ण) जब तक कि वर्तमान एक ( a[x-1][y]) के ऊपर की कोशिका a से न भर जाए I। यदि इसमें यह है तो यह Iहमें वर्तमान सेल में एक कुर्सी रखने के लिए कह रही डिफ़ॉल्ट को ओवरराइड करेगा। इसके बाद हम वर्तमान सेल के नीचे सेल पर जाते हैं यदि वह सेल है Iतो हम फिर से ओवरराइड का सामना करने के लिए वर्तमान जगह के नीचे कुर्सी पर बैठ जाते हैं।

अगली स्थिति एक बालक सरल है

if"|"==a[x][y]==a[x-1][y]:a[x][y]={"I":"|",A[y+1]:">",A[y-1]:"<"}["I"]   

हम जांचते हैं कि क्या वर्तमान सेल और इसके ऊपर की सेल दोनों हैं |। यदि ऐसा है तो हम एक शब्दकोश सेट करते हैं।

शब्दकोश में पहला जोड़ा "I":"|"डिफ़ॉल्ट सेट करता है। चूँकि हम कुंजी को एक्सेस करने जा रहे हैं, Iअगर Iइसे फिर से असाइन नहीं किया जाता है तो यह वापस से डिफ़ॉल्ट हो जाएगा |(यह चरित्र पहले से ही है) और कुछ भी नहीं करें।

हम दो कुंजी जोड़ते हैं A[y+1]:">",A[y-1]:"<"यदि बाईं और दाईं ओर दो कोशिकाएं हैं, Iतो यह वर्तमान सेल को एक कुर्सी पर फिर से इंगित करेगी जो बाहर की दिशा में इंगित करती है।

---

अब हमें सिर्फ आउटपुट देना है। हालाँकि हम सिर्फ प्रिंट नहीं कर सकते हैं, कुछ हाउसकीपिंग चीजें हैं जो हमें पहले करनी हैं। हमें एक स्ट्रिंग में वापस बदलना होगा और Iहमारे द्वारा बनाए गए सभी को हटाना होगा । यह एक पंक्ति में किया जाता है।

print "\n".join(`y`[2::5]for y in a).replace("I"," ")

Comments

क्या आप इंडेंट के पहले स्तर के लिए एक स्थान, दो के लिए टैब, एक टैब और तीन के लिए एक स्थान का उपयोग नहीं कर सकते? वह कुछ बाइट्स बचा लेगा।

— रिले

यह सबसे पुन: गोल्फ जवाब हो सकता है।

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

करता है i,o="I "के बजाय i="I";o=" "काम करता है?

— अदनान

@ErikGolfer エ リ fer fer fer フ ーn4 4 बनाने की लागत ४ बाइट्स होती है और मुझे बचाती है ६. हालाँकि मैं इसका उपयोग नहीं करता हूं लेकिन यह २ बाइट्स बचाती है।

— गेहूं जादूगर

@ Pietu1998 यह इंगित करने के लिए धन्यवाद। मैंने समस्या तय की

— गेहूं जादूगर