Chiến tranh thánh đã được chiến đấu trên không gian so với các tab. (Và tất nhiên là không gian, vượt trội về mặt khách quan, đã thắng.) - Alex A.

S ome peo p le vẫn từ chối để một ccept rằng whi c h là cl e arly s upreme. Bạn vừa nhận được một tập tin bằng cách sử dụng incor lại ct, b quảng cáo và inf e dạng rior của whi t espace, và bây giờ t ông tiếp e nts của tập tin một r e nhiễm và hủy hoại.

Bạn quyết định bạn cũng có thể chỉ cho người đã gửi tệp cho bạn biết họ đã phạm lỗi dữ dội như thế nào.

Sự miêu tả

Như tiêu đề cho thấy, thách thức của bạn là lấy một tệp chứa một hoặc nhiều tab:

this is an evil tab    onoes

và tàn nhẫn phá vỡ chúng thành từng mảnh:

this is an evil tab

                     o
                     n
                     o
                     e
                     s

Lưu ý rằng phần mềm Stack Exchange biến các tab theo nghĩa đen thành bốn khoảng trắng (vì nó đúng), vì vậy các tab trong bài đăng này sẽ được hiển thị dưới dạng bốn khoảng trắng. Tuy nhiên, đầu vào cho chương trình của bạn sẽ chứa các tab thực tế.

Thử thách

Giải pháp nên lấy một chuỗi đơn làm đầu vào, có thể chứa ASCII, dòng mới và tab có thể in được. Sẽ luôn có ít nhất một tab duy nhất trong đầu vào.

Đầu ra phải là cùng một chuỗi, với các quy tắc sau được áp dụng:

• Bắt đầu con trỏ ở tọa độ (0,0) và theo hướng phải. Các tọa độ là (cột, hàng), không có chỉ mục và hướng là cách bạn nên di chuyển con trỏ sau khi in một ký tự.

• Đối với mỗi ký tự trong chuỗi:

  • Nếu đó là một dòng mới, di chuyển đến tọa độ (0, n), trong đó n là số dòng mới trong chuỗi cho đến nay (bao gồm cả dòng này) và đặt lại hướng sang phải.

  • Nếu đó là một tab, hãy xuất hai khoảng trắng, xoay hướng con trỏ 90 độ theo chiều kim đồng hồ và xuất thêm hai khoảng trắng, "phá vỡ" tab một cách hiệu quả. Đây là một ví dụ trực quan, trong đó một tab được biểu diễn dưới dạng --->và khoảng trắng là ·:

    foo--->bar--->baz
    

    trở thành

    foo···
         ·
         b
         a
         r
         ·
         ·
     zab··
    

  • Mặt khác, chỉ cần xuất ký tự tại con trỏ và di chuyển con trỏ một bước theo hướng hiện tại.

Vì bạn đang đọc chuỗi từ đầu đến cuối, có thể bạn sẽ phải viết "trên đầu" các ký tự hiện có. Điều này không sao cả. Ví dụ: đầu vào

foo--->bar


spaces are superior

sẽ dẫn đến một đầu ra của

foo

     b
spaces are superior
     r

Bạn có thể chọn liệu "các tab bị hỏng" có nên ghi đè lên các ký tự khác không, ý định ban đầu là chúng không có, nhưng thông số này không rõ ràng, vì vậy đây là quyết định của bạn.

Hơn nữa, sau khi áp dụng các quy tắc này, bạn cũng có thể

• thêm hoặc xóa nhiều dấu cách như bạn muốn.

• thêm tối đa một dòng mới duy nhất.

Đầu vào sẽ không bao giờ chứa dấu cách; nó cũng sẽ không bao giờ chứa các dòng mới hàng đầu hoặc dấu. Bạn cũng có thể luôn cho rằng bạn sẽ không bao giờ cần phải ghi vào một cột hoặc một hàng nhỏ hơn 0 (tức là tắt màn hình).

Trường hợp thử nghiệm

Các tab trong trường hợp thử nghiệm này được thể hiện là --->vì nếu không SE sẽ ngấu nghiến chúng.

Đầu vào:

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

Đầu ra:

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

Hoạt hình lạ mắt:

Quy tắc

• Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte sẽ giành chiến thắng!

MATLAB, 144 byte

Vũ khí được lựa chọn để xử lý các chuỗi dĩ nhiên là một ngôn ngữ được thiết kế để thao túng các con số [cần dẫn nguồn]. Bỏ qua một bên, điều tuyệt vời ở Matlab là nó không quan tâm nếu bạn gán cho một mảng 'ngoài giới hạn': nó chỉ đơn giản sẽ tạo ra một ma trận lớn hơn. Hơn nữa, phần tử ma trận mặc định 0, được hiển thị dưới dạng khoảng trắng thay vì nullký tự mà thông số ASCII quy định.

Các tab chỉ đơn giản là một bước nhảy trong tọa độ, vì vậy không có khoảng trắng nào được xuất ra cho một tab.

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

Tôi đã bắt đầu với 209 byte, nhưng một số môn đánh gôn cẩn thận hơn đã loại bỏ hầu hết điều đó; có rất nhiều sự lặp lại trong mã này, vì vậy tôi đã thực hiện một số thử nghiệm và lỗi mà các lựa chọn thay thế hoạt động tốt nhất. Tôi không nghĩ có nhiều không gian để tối ưu hóa hơn với mã này, nhưng tôi luôn vui khi được chứng minh là sai. Chỉnh sửa: Tom Carpenter quản lý để chứng minh tôi sai; anh quản lý để lưu 9 byte mà tôi đã tối ưu hóa để tiết kiệm được 29 byte. Byte cuối cùng được lưu bằng cách giả sử không có ký tự điều khiển (ASCII <9) trong đầu vào - chuỗi MATLAB không bị nullhủy.

Python 3, 272 270 266 262 255 253 244 byte

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='')

Các \tphải là một ký tự tab thực tế.

Mã này hoạt động hơi giống câu trả lời của Zach Gates, đầu tiên tạo ra một lưới Mtheo Mđó Mlà tổng độ dài của các dòng. (Đó là một lượng dư thừa khổng lồ, nhưng làm cho mã ngắn hơn.) Sau đó, nó lặp qua các ký tự, đặt chúng vào đúng vị trí, theo dõi hàng được truy cập cuối cùng. Cuối cùng, nó in tất cả các dòng lên đến hàng đó.

Đầu ra chứa (thường là một lượng lớn) dấu cách và 1 dòng mới.

Javascript (ES6), 264 245 byte

Đã thử phương pháp "tạo ra một lưới không gian khổng lồ, lấp đầy và cắt xén", kết thúc ngắn hơn 19 byte so với phương pháp khác.

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())

Bằng cách sửa đổi dòng thứ hai đến cuối cùng như vậy, bạn có thể loại bỏ một lượng lớn khoảng trắng ở mỗi dòng:

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

Hãy thử nó ở đây:

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>

Giải thích sắp ra mắt; đề nghị chào mừng!

JavaScript (ES6), 180 183

Sử dụng chuỗi mẫu, có một số dòng mới có ý nghĩa và được tính.

Đó là một hàm trả về đầu ra được yêu cầu (được đệm bằng hàng tấn dấu cách)

Có rất ít để giải thích: các hàng được xây dựng như đã được xem. Không có biến hướng, chỉ có 2 offset cho x và y, vì trong xoay theo chiều kim đồng hồ, chúng dễ dàng được quản lý:dx <= -dy, dy <= dx

Kiểm tra chạy đoạn mã dưới đây trong Firefox

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>

Python 2, 370 369 369 byte

Cảm ơn @sanchises và @ edc65 đã tiết kiệm cho tôi mỗi byte.

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()

Nó tạo ra lưới lớn nhất có thể và sau đó lặp lại, theo từng ký tự, chuyển hướng ở mỗi tab.