पवित्र युद्ध अंतरिक्ष बनाम टैब पर लड़े गए हैं। (और निश्चित रूप से बेहतर होने के नाते रिक्त स्थान, जीता।) - एलेक्स ए।

S ome peo p le अभी भी एक ccept से इंकार करता है कि whi c h, cl e arly s upreme है। तुम बस प्राप्त हो गया है एक फ़ाइल incor का उपयोग कर फिर से सीटी, ख विज्ञापन, और inf ई whi के rior प्रपत्र टी स्पास, और अब टी वह शेष भाग ई फ़ाइल एक के एनटीएस आर ई दागी और बर्बाद कर दिया।

आप तय करते हैं कि आप उस व्यक्ति को दिखा सकते हैं जिसने आपको फ़ाइल भेजी थी कि वे कितने गलत हैं - हिंसक तरीके से।

विवरण

जैसा कि शीर्षक से पता चलता है, आपकी चुनौती एक ऐसी फ़ाइल लेने की है जिसमें एक या अधिक टैब हों:

this is an evil tab    onoes

और बेरहमी से उन्हें टुकड़ों में तोड़ दो:

this is an evil tab

                     o
                     n
                     o
                     e
                     s

ध्यान दें कि स्टैक एक्सचेंज सॉफ़्टवेयर शाब्दिक टैब को चार स्थानों में बदल देता है (क्योंकि यह सही है), इसलिए इस पोस्ट के भीतर टैब चार स्थानों पर प्रदर्शित होंगे। हालाँकि, आपके प्रोग्राम के इनपुट में वास्तविक टैब होंगे।

चुनौती

समाधान को इनपुट के रूप में एकल स्ट्रिंग लेना चाहिए, जिसमें मुद्रण योग्य ASCII, newlines और टैब हो सकते हैं। इनपुट में हमेशा कम से कम एक टैब होगा।

निम्नलिखित नियमों के साथ आउटपुट एक ही स्ट्रिंग होना चाहिए:

निर्देशांक (0,0) पर कर्सर शुरू करें और दाईं ओर एक दिशा में। निर्देशांक (स्तंभ, पंक्ति), शून्य-अनुक्रमित हैं, और दिशा वह है जिस तरह से आपको वर्ण को प्रिंट करने के बाद कर्सर को स्थानांतरित करना चाहिए।
स्ट्रिंग में प्रत्येक वर्ण के लिए:
- यदि यह एक नई रेखा है, तो निर्देशांक (0, n) पर जाएं, जहां n स्ट्रिंग में अब तक (इस एक सहित) में नई संख्याओं की संख्या है, और दिशा को दाईं ओर रीसेट करें।
- यदि यह एक टैब है, तो दो रिक्त स्थान, कर्सर दिशा 90 डिग्री दक्षिणावर्त घुमाएं , और दो और रिक्त स्थान आउटपुट करें, टैब में प्रभावी रूप से "ब्रेकिंग" करें। यहां एक दृश्य उदाहरण दिया गया है, जहां एक टैब के रूप में --->और रिक्त स्थान के रूप में दर्शाया गया है ·:
```
foo--->bar--->baz
```
  हो जाता है
```
foo···
     ·
     b
     a
     r
     ·
     ·
 zab··
```
- अन्यथा, बस कर्सर पर चरित्र का उत्पादन करें और कर्सर को वर्तमान दिशा में एक कदम बढ़ाएं।

चूंकि आप स्ट्रिंग को शुरू से अंत तक पढ़ रहे हैं, इसलिए संभव है कि आपको मौजूदा वर्णों के "शीर्ष पर" लिखना होगा - यह ठीक है। उदाहरण के लिए, इनपुट

foo--->bar


spaces are superior

के उत्पादन में परिणाम होना चाहिए

foo

     b
spaces are superior
     r

आप चुन सकते हैं कि "टूटे हुए टैब" को अन्य पात्रों को अधिलेखित करना चाहिए - मूल इरादा यह था कि वे नहीं करते हैं, लेकिन कल्पना अस्पष्ट थी, इसलिए यह आपका निर्णय है।

इसके अलावा, इन नियमों को लागू करने के बाद, आप भी कर सकते हैं

आप जितने चाहें उतने अनुगामी स्थान जोड़ या हटा सकते हैं।
एक एकल अनुगामी न्यूलाइन की एक अधिकतम जोड़ें।

इनपुट में अनुगामी स्थान कभी नहीं होगा ; यह भी अग्रणी या अनुगामी newlines कभी नहीं होगा। आप हमेशा यह मान सकते हैं कि आपको कभी भी कॉलम या पंक्ति से कम 0 (यानी स्क्रीन से दूर) लिखने की आवश्यकता नहीं होगी।

परीक्षण का मामला

इस परीक्षण मामले में टैब का प्रतिनिधित्व --->इसलिए किया जाता है क्योंकि अन्यथा एसई उन्हें जकड़ लेता है।

इनपुट:

Test case. Here's a tab--->there's a tab--->everywhere a tab--->tab--->this is some more text
blah
blah
blah blah blah blah blah blah--->blaah--->blaah--->blah--->blaaaaah--->blah--->blah--->blah--->blah--->blah

आउटपुट:

Test case. Here's a tab
blah
blah                     t
blah blah blah blah blah blah
                        blaablah
                         r     b
                         e     l  b
                      h  'h    a  l
                      a  sa    a  a
                      l   l    h  h
       this is some mobe tbxt

                         haalhalb
     b                   a
     a                   b
     t

        bat a erehwyreve

फैंसी एनीमेशन:

नियम

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

code-golf string whitespace

— Doorknob
स्रोत

जब आप कहते हैं कि कर्सर को शुरू (0,0)करना है तो क्या आपका मतलब है कि हमें पहले कंसोल को खाली करने की आवश्यकता है, या क्या आपको सिर्फ कर्सर की डिफ़ॉल्ट स्थिति से मतलब है?

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

18

मैं इस प्रश्न को ऑफ-टॉपिक के रूप में बंद करने के लिए मतदान कर रहा हूं क्योंकि यह घृणा और निन्दा से भरा है।

— aditsu 6

1

आपका एनीमेशन> <> दुभाषिया की तरह लग रहा है कि मैं अब एक स्व-संशोधित> <> प्रविष्टि देखना चाहता हूं।

— सेंचुरी

1

मुझे शुरुआती पैराग्राफ में छिपे संदेश पसंद आए लेकिन मुझे असहमत होना पड़ा।

— wf4

@ MartinBüttner यह सिर्फ डिफ़ॉल्ट स्थिति का मतलब है।

— दरवाज़े

8

MATLAB, 144 बाइट्स

तार से निपटने के लिए पसंद का हथियार निश्चित रूप से संख्याओं में हेरफेर करने के लिए डिज़ाइन की गई भाषा है [उद्धरण वांछित]। एक तरफ मजाक करते हुए, मतलाब के बारे में महान बात यह है कि यह परवाह नहीं करता है कि आप किसी सरणी से 'सीमा से बाहर' असाइन करते हैं: यह बस एक बड़ा मैट्रिक्स बना देगा। इसके अलावा, डिफ़ॉल्ट मैट्रिक्स तत्व, 0एक nullचरित्र के बजाय एक स्थान के रूप में प्रस्तुत किया जाता है ASCII कल्पना निर्धारित करता है।

टैब केवल निर्देशांक में एक छलांग है, इसलिए टैब के लिए कोई स्थान नहीं हैं।

function o=q(t)
u=2;v=0;x=1;y=1;n=1;for s=t
if s==9 x=x+u-v;y=y+v+u;a=v;v=u;u=-a;elseif s<11
n=n+1;x=1;y=n;else
o(y,x)=s;x=x+u/2;y=y+v/2;end
end

मैंने 209 बाइट्स के साथ शुरुआत की, लेकिन कुछ अधिक सावधान गोल्फिंग ने उस सबसे छुटकारा पा लिया; इस कोड में बहुत दोहराव है, इसलिए मैंने कुछ ट्रायल-एंड-एरर किए, जिनमें से विकल्पों ने सबसे अच्छा काम किया। मुझे नहीं लगता कि इस कोड के साथ अधिक अनुकूलन के लिए बहुत जगह है, लेकिन मैं गलत साबित होने के लिए हमेशा खुश हूं। संपादित करें: टॉम बढ़ई मुझे गलत साबित करने में कामयाब रहे; वह 9 बाइट्स बचाने में कामयाब रहा जिसे मैंने 29 बाइट्स बचाने के लिए अनुकूलित किया। इनपुट में कोई नियंत्रण वर्ण (ASCII <9) नहीं है, यह मानकर सहेजे गए अंतिम बाइट - MATLAB स्ट्रिंग्स को nullनियंत्रित नहीं किया जाता है।

— Sanchises
स्रोत

काम करने के लिए प्रकट नहीं होता है। मैंने यह कोशिश की q('hello<tab>my name<tab>is tom<tab>c'), लेकिन यह कुछ की तर्ज पर है Attempted to access o(11,-2); on line 7। हालांकि यह प्रश्न में एक मुद्दे के साथ करने के लिए अधिक हो सकता है - यदि कर्सर पीछे की ओर बढ़ रहा है और पहले कॉलम से परे चला जाता है तो बाकी पंक्ति में क्या होता है।

— टॉम कारपेंटर

हां, मेरा बुरा मैं उस बिट याद किया। मैं अब चला जाऊँगा;)

— टॉम बढ़ई

1

आप dचर को हटाकर एक और 9 वर्णों को बचा सकते हैं और इसके बजाय 4 चर हैं जो एक लूप के लिए [1 0 -1 0] पैटर्न को इस तरह बनाते हैं:

function o=q(t) u=1;v=0;w=-1;z=0;x=0;y=1;n=1;for s=t if s==9 x=x+2*u-2*v;y=y+2*v+2*u;a=z;z=w;w=v;v=u;u=a;elseif s==10 n=n+1;x=0;y=n;else x=x+u;y=y+v;o(y,x)=s;end end

(जाहिर है टिप्पणियों में यह सभी लाइनों को हटा दिया गया है, इसलिए आपके पास होगा यह देखने के लिए कि मैंने क्या किया है

— टॉम कारपेंटर

@TomCarpenter कि ... वास्तव में बदसूरत है। मुझे यह पसंद है।

— सैनचाइज़्स

5

पायथन 3, 272 270 266 262 255 253 244 बाइट्स

I=[]
try:
 while 1:I+=[input()]
except:r=m=0
M=sum(map(len,I))
O=[M*[' ']for _ in[0]*M]
for l in I:
 x=b=0;y=r;a=1;r+=1
 for c in l:
  if'\t'==c:a,b=-b,a;x+=a+2*b;y+=b-2*a
  else:O[y][x]=c
  x+=a;y+=b;m=max(m,y)
for l in O[:m+1]:print(*l,sep='')

\tएक वास्तविक टैब वर्ण होना चाहिए।

कोड Zach Gates के उत्तर की तरह कुछ काम करता है, पहले एक ग्रिड Mद्वारा उत्पन्न होता Mहै जहां Mलाइनों की लंबाई का योग होता है। (यह बहुत अधिक मात्रा में है, लेकिन कोड को छोटा बनाता है।) इसके बाद पात्रों के माध्यम से लूप होता है, उन्हें सही स्थानों पर रखते हुए, बॉटलमॉस्ट विज़िट की गई पंक्ति पर नज़र रखता है। अंत में, यह उस पंक्ति तक सभी पंक्तियों को प्रिंट करता है।

आउटपुट में (आमतौर पर भारी मात्रा में) अनुगामी रिक्त स्थान और 1 अनुगामी न्यूलाइन होती है।

— PurkkaKoodari
स्रोत

3

जावास्क्रिप्ट (ईएस 6), 264 245 बाइट्स

"रिक्त स्थान की एक विशाल ग्रिड बनाएं, भरें और ट्रिम करें" दृष्टिकोण की कोशिश की, जो दूसरे से 19 बाइट्स को समाप्त कर दिया।

a=t=>(o=`${' '.repeat(l=t.length)}
`.repeat(l).split`
`.map(q=>q.split``),d=x=y=z=0,s=c=>o[d>2?y--:d==1?y++:y][d?d==2?x--:x:x++]=c,[...t].map(c=>c=='\t'?(s` `,s` `,++d,d%=4,s` `,s` `):c==`
`?(x=d=0,y=++z):s(c)),o.map(p=>p.join``).join`
`.trim())

दूसरी-से-अंतिम पंक्ति को इस तरह से संशोधित करके, आप प्रत्येक पंक्ति पर बड़ी मात्रा में अनुगामी रिक्त स्थान को निकाल सकते हैं:

...o.map(p=>p.join``.trimRight())...

इसे यहाँ आज़माएँ:

कोड स्निपेट दिखाएं

a=t=>(o=`${' '.repeat(l=t.length)}
`.repeat(l).split`
`.map(q=>q.split``),d=x=y=z=0,s=c=>o[d>2?y--:d==1?y++:y][d?d==2?x--:x:x++]=c,[...t].map(c=>c=='\t'?(s` `,s` `,++d,d%=4,s` `,s` `):c==`
`?(x=d=0,y=++z):s(c)),o.map(p=>p.join``.trimRight()).join`
`.trim())

function submit(){ O.innerHTML = a(P.value.replace(/\\t|-+>/g,'\t')); }

<p>Input: (Use <code>\t</code> or <code>---></code> for a tab.)</p>
<textarea id=P rows="10" cols="40">this is an evil tab\tonoes</textarea>
<br><button onclick="submit()">Try it!</button>
<p>Output: (Looks best in full-page mode.)</p>
<pre id=O>

स्निपेट का विस्तार करें

स्पष्टीकरण जल्द ही आ रहा है; सुझावों का स्वागत है!

— ETHproductions
स्रोत

3

जावास्क्रिप्ट (ईएस 6), 180 183

टेम्प्लेट स्ट्रिंग्स का उपयोग करते हुए, कुछ नई किस्में हैं जो महत्वपूर्ण और गिनी जाती हैं।

यह एक ऐसा अनुरोध है, जो अनुरोधित आउटपुट देता है (अनुगामी स्थानों के टन के साथ गद्देदार)

व्याख्या करने के लिए बहुत कम है: पंक्तियों को नीड के रूप में बनाया गया है। एक दिशा चर नहीं है, x और y के लिए सिर्फ 2 ऑफसेट, जैसे कि दक्षिणावर्त रोटेशन में वे आसानी से प्रबंधित होते हैं:dx <= -dy, dy <= dx

फ़ायरफ़ॉक्स में नीचे स्निपेट का परीक्षण करें

f=s=>[...s].map(c=>c<`
`?(x+=2*(d-e),y+=2*(e+d),[d,e]=[-e,d]):c<' '?(y=++r,e=x=0,d=1):(t=[...(o[y]||'')+' '.repeat(x)],t[x]=c,o[y]=t.join``,x+=d,y+=e),o=[r=x=y=e=0],d=1)&&o.join`
`

// TEST  

// Avoid evil tabs even in this source 
O.innerHTML = f(`Test case. Here's a tab--->there's a tab--->everywhere a tab--->tab--->this is some more text
blah
blah
blah blah blah blah blah blah--->blaah--->blaah--->blah--->blaaaaah--->blah--->blah--->blah--->blah--->blah`
 .replace(/--->/g,'\t'))

<pre id=O></pre>

स्निपेट का विस्तार करें

— edc65
स्रोत

काश सभी भाषाओं में [x, y] = [expr1, expr2] होता ...

— Sanchises

1

पायथन 2, 370 369 368 बाइट्स

मुझे बाइट बचाने के लिए @sanchises और @ edc65 का शुक्रिया ।

J=''.join
u=raw_input().replace('\t','  \t  ')
w=u[:]
G=range(len(u))
d,r=0,[[' 'for _ in G]for _ in G]
u=u.split('\n')
for t in G:
 x,y=0,0+t
 for c in u[t]:
  if c=='\t':d=(d+1)%4
  if c!='\t':
   if c.strip():r[y][x]=c
   if d<1:x+=1
   if d==1:y+=1
   if d==2:x-=1
   if d>2:y-=1
r=r[:max(i for i,n in enumerate(r)if J(n).strip())+1]
for i in r:print J(i).rstrip()

यह संभव सबसे बड़ा ग्रिड उत्पन्न करता है और फिर चारों ओर छोरों, चरित्र द्वारा चरित्र, प्रत्येक टैब पर स्विचन दिशा।

— Zach गेट्स
स्रोत

संकेत: if !dऔरif d>2

— 20

!dमान्य सिंटैक्स नहीं है। @sanchises d>2टिप के लिए धन्यवाद , यद्यपि।

— जैच गेट्स

क्षमा करें, मैं वास्तव में अजगर को नहीं जानता हूं :) बस यह मान लिया जाए कि यह उसी तरह काम करेगा।

— सेंचुरी

मैं भी अजगर समझ में नहीं आता, लेकिन अगर घ में 0 ... 3, d==0->d<1

— edc65

हाँ, तुम सही हो। बाइट के लिए धन्यवाद। @ edc65

— Zach गेट्स

आधे में टैब तोड़ो