Kutsal savaşlar mekanlara karşı sekmelere karşı savaştı. (Ve elbette uzaylar nesnel olarak üstündür, kazandı.) - Alex A.

S azı PEO s le hala çöp için bir o ccept WHI C h Cl e arly s upreme. Sadece aldık bir yanış kullanarak dosyayı yeniden ct, b reklamı ve inf e WHI anterior formunu t espace ve şimdi t he devam e bir dosyanın NTS r e kusurlu ve harap.

Dosyayı size gönderen kişiyi, ne kadar yanlış olduklarını - şiddetli bir şekilde - göstermeye de karar verebilirsiniz.

Açıklama

Başlığın önerdiği gibi, zorluğunuz bir veya daha fazla sekme içeren bir dosya almak:

this is an evil tab    onoes

ve acımasızca onları paramparça eder:

this is an evil tab

                     o
                     n
                     o
                     e
                     s

Stack Exchange yazılımının değişmez sekmeleri dört boşluğa dönüştürdüğünü unutmayın (çünkü doğru), bu yazıdaki sekmeler dört boşluk olarak görüntülenecektir. Programınıza giriş, ancak gerçek sekmeler içerecektir.

Meydan okuma

Çözüm, yazdırılabilir ASCII, yeni satırlar ve sekmeler içerebilecek giriş olarak tek bir dize almalıdır. Girişte her zaman en az tek bir sekme olacaktır.

Çıktı, aşağıdaki kuralların uygulandığı şekilde aynı dizge olmalıdır:

• İmleci koordinatlarda (0,0) ve sağa doğru başlatın. Koordinatlar (sütun, satır), sıfır dizinli ve karakter yazdırdıktan sonra imleci hareket ettirmeniz gereken yön.

• Dizedeki her karakter için:

  • Eğer yeni bir satırsa, şimdiye kadar (n dahil) dizedeki yeni satırların sayısı n olan koordinatlara (0, n) gidin ve yönü sağa sıfırlayın.

  • Bu bir sekme ise, iki boşluk bırakın , imleç yönünü saat yönünde 90 derece döndürün ve sekmeyi yarıya indirerek "boşluk bırakarak" iki boşluk daha verin. İşte bir sekmenin temsil edildiği --->ve boşlukları aşağıdaki gibi gösteren görsel bir örnek ·:

    foo--->bar--->baz
    

    olur

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

  • Aksi takdirde, imleci imleç üzerine getirin ve imleci geçerli yönde bir adım hareket ettirin.

Dizgiyi baştan sona okuduğunuz için, mevcut karakterlerin "üstüne" yazmanız gerekebilir - bu sorun değil. Örneğin, giriş

foo--->bar


spaces are superior

çıktısı ile sonuçlanmalı

foo

     b
spaces are superior
     r

"Kırık sekmeler" in diğer karakterlerin üzerine yazılmasını isteyip istemediğinizi seçebilirsiniz - asıl amaç onların yapmamasıydı, ancak belirsizlik belirsizdi, bu yüzden karar sizin.

Ayrıca, bu kuralları uyguladıktan sonra

• İstediğiniz kadar sondaki boşlukları ekleyin veya kaldırın.

• tek bir son satırın maksimum satırını ekleyin.

Girdi asla takip eden boşluk içermez; ayrıca hiçbir zaman öncü veya izleyen satırlar içermez. Ayrıca her zaman 0'dan küçük bir sütuna veya bir satıra yazmak zorunda olmayacağınızı da varsayabilirsiniz (örn. Ekran dışı).

Test durumu

Bu sınama durumundaki sekmeler, --->aksi halde SE onları yukarı yitirdiği için temsil edilir .

Giriş:

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

Çıktı:

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

Süslü animasyon:

kurallar

• Bu kod golf , yani bayttaki en kısa kod kazanacak!

MATLAB, 144 bayt

Dizelerle başa çıkmak için tercih edilen silah elbette sayıları manipüle etmek için tasarlanmış bir dildir (gerekli alıntı). Bir kenara atmak, Matlab'ın en güzel yanı, 'sınırların dışında' bir diziye atamanızın umrunda olmamasıdır: basitçe daha büyük bir matris yapar. Ayrıca, varsayılan matris elemanı, ASCII spec'in belirttiği karakter 0yerine boşluk olarak oluşturulmuştur null.

Sekmeler sadece koordinatlarda bir atlamadır, dolayısıyla bir sekme için boşluk bırakılmaz.

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 byte ile başladım, ancak biraz daha dikkatli golf oynamak bundan kurtuldu; bu kodda çok fazla tekrarlama var, bu yüzden alternatiflerin en iyi şekilde çalıştığı deneme yanılma yaptım. Bu kodla daha fazla optimizasyon için fazla yer olduğunu sanmıyorum, ancak her zaman yanlış olduğunu kanıtlamaktan mutlu oluyorum. Düzenleme: Tom Carpenter beni yanlış kanıtlamayı başardı; Bir kuyruklu 29 byte tasarruf etmek için optimize ettiğim 9 byte kaydetmeyi başardı. Girdide kontrol karakterlerinin (ASCII <9) bulunmadığı varsayılarak kaydedilen son bayt - MATLAB karakter dizileri nullsonlandırılmaz.

Python 3, 272 270 266 262 255 253 244 bayt

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

\tGerçek bir sekme karakter olmalıdır.

Kod ilk olarak üretilmesi, biraz Zach Gates yanıt gibi çalışır Mgöre Mızgara Mhatlarının uzunlukları toplamıdır. (Bu aşırı miktarda bir fazlalıktır, ancak kodu daha kısa hale getirir.) Daha sonra ziyaret edilen en alt sırayı izleyerek karakterleri dolaştırır, doğru noktalara yerleştirir. Sonunda, tüm satırları bu satıra kadar yazdırır.

Çıktı (genellikle çok büyük miktarda) izleyen boşluklar ve izleyen yeni satırlar içerir.

Javascript (ES6), 264 245 bayt

Diğerlerinden 19 byte kısa süren “dev bir boşluk ızgarası yarat, doldur ve kes” yaklaşımı denendi.

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

İkinci-son çizgisini bu şekilde değiştirerek, her bir satırdaki büyük miktarda boşluk alanını kaldırabilirsiniz:

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

Burada dene:

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>

Açıklama çok yakında; öneri hoş geldiniz!

JavaScript (ES6), 180 183

Şablon dizgileri kullanarak, önemli ve sayılan bazı yeni satırlar vardır.

İstenen çıktıyı döndüren bir işlev (tonlarca iz bırakma alanıyla doldurulmuş)

Açıklamak için çok az şey var: satırlar gerektiği gibi inşa edilmiştir. Bir yön değişkeni yoktur, saat yönünde döndürüldüğü gibi kolayca x ve y için 2 ofset vardır:dx <= -dy, dy <= dx

Aşağıdaki pasajı Firefox'ta çalıştırmayı test edin

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 368 bayt

Her birini bayttan kurtardığı için @sanchises ve @ edc65'e teşekkürler .

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

Mümkün olan en büyük ızgarayı üretir ve daha sonra her sekmede yön değiştirerek karakter karakter etrafında döner.