Dikdörtgen bir metin ızgarası verildiğinde, sol üst köşeden sağ alt köşeye giden köşegenleri sütunlara hizalayın, böylece tüm köşegenlerin en sağdaki en düşük karakterleri düz olur. Girinti için boşluk kullanın.

Örneğin, metnin giriş ızgarası

abcd
1234
WXYZ

o zaman diyagonallerini hizaya ediyorum W, 1X, a2Y, b3z, c4, ve dbu çıktıyı veren sütunlarda:

  ab
 123c
WXYZ4d

Tüm köşegenlerin en sağdaki en küçük karakterlerinin WXYZ4daynı düzeyde olduğunu unutmayın.

ayrıntılar

• Metnin giriş ızgarası en az 1 × 1 boyutunda olacak ve tüm satırlar aynı uzunlukta olacaktır.

• Giriş ızgarasını çok satırlı bir dize veya tek satırlık dizelerin bir listesi olarak alabilirsiniz.

• Giriş ızgarası yalnızca yazdırılabilir ASCII karakterleri içerecektir (boşluk içerir).

• Çıktı isteğe bağlı olarak bir satırsonu içerebilir ancak başka boş satır olmamalıdır.

• Çıktı çizgileri isteğe bağlı olarak arka boşluklara sahip olabilir, ancak gereksiz boşluk boşluklarına sahip olmamalıdır.

Diğer Örnekler

Boş satırlar örnekleri ayırır. Her girişi doğrudan çıkışı izler.

123
456
789

  1
 452
78963

123.?!
456??!
789!!!

  123.
 456???
789!!!!!

**@
@  

 **
@  @


/\/\
\/ /
/ /\
\/\/

   /
  \/\
 / / /
\/\/\/\

12
34
56
78
90

 7531
908642

Code

Code

G
O
L
F

FLOG

~

~

puanlama

Bayt cinsinden en kısa kod kazanır.

J , 12 bayt

|./.&.|:&.|.

Anonim bir fiil tanımlar. Çevrimiçi deneyin!

açıklama

|./.&.|:&.|.
|.            Reversed
  /.          anti-diagonals
    &.        under
      |:      transpose
        &.    under
          |.  reversal

J dilinde, u &. v (read: uunder v) "v, sonra u, sonra v'nin tersi" anlamına gelir. Tersine çevirme ve devrik kendi kendine ters çevrimlerdir, bu nedenle program gerçekten "ters, devrik, ters anti-diyagonalleri çıkar, devrik, ters" anlamına gelir.

Örnek girdi ile:

abcd
1234
WXYZ

Ters:

WXYZ
1234
abcd

devrik:

W1a
X2b
Y3c
Z4d

Ters çevrilmiş anti-köşegenleri (ve boşluklu ped) çıkarın:

W  
X1 
Y2a
Z3b
4c 
d  

devrik:

WXYZ4d
 123c 
  ab  

Ters:

  ab  
 123c 
WXYZ4d

Jöle , 11 veya 10 bayt

ZŒDṙLUz⁶ṚUY

Çevrimiçi deneyin!

Diğer çözümümden oldukça farklı bir algoritma; bu, bir şeyleri manuel olarak yapmaktan ziyade diyagonallere ulaşmak için bir yerleşik kullanır.

Açıklama:

ZŒDṙLUz⁶ṚUY
Z           transpose
 ŒD         diagonals, main diagonal first
    L       number of lines in the original array
   ṙ        rotate list (i.e. placing the short diagonal first)
     U      reverse inside lines
      z⁶    transpose, padding with spaces
        ṚU  rotate matrix 180 degrees
          Y (possibly unnecessary) join on newlines

Çaprazlar muhtemelen en kötü yönde (tekrarlanan transpozisyonlar, ters dönüşler ve rotasyonlar gerektirir) ve yanlış sırayla ortaya çıkar (Jelly ilk önce ana diyagonal çıkış yapar, bu yüzden onları almak için bazı köşegenleri baştan sona taşımalıyız. sırayla). Ancak, bu hala diğer Jelly çözümümden daha kısa çıkıyor.

CJam , 29 bayt

qN/{)\z}h]2/{~W%+}%eeSf.*W%N*

Çevrimiçi deneyin!

açıklama

Çaprazları çıkarmak yerine, katmanları sondan sola ve sağa sırayla soyarız. Aşağıdaki girdiyi düşünün:

GFDB
EEDB
CCCB
AAAA

Eğer meydan okumaların gerektirdiği şekilde köşegenleri yazarsak, şunu elde ederiz:

   G
  EEF
 CCCDD
AAAABBB

Bunun basitçe (aşağıdan yukarıya), en sağdaki sütunla birleştirilmiş en alt satır olduğunu unutmayın. Bu tanım, giriş dikdörtgense de işe yarar.

{      e# Run this loop while there are still lines left in the input.
  )    e#   Pull off the bottom-most row.
  \    e#   Swap with the remaining rows.
  z    e#   Transpose the grid so that the next iteration pulls off the last
       e#   column instead. However, it should be noted that transposing
       e#   effectively reverses the column, so the second half of each output
       e#   line will be the wrong way around. We'll fix that later.
}h     e# When the loop is done, we'll have all the individual layers on the
       e# stack from bottom to top, alternating between horizontal and vertical
       e# layers. There will be an empty string on top.
]      e# Wrap all those strings in a list.
2/     e# Split into pairs. There may or may not be a trailing single-element
       e# list with the empty string.
{      e# Map this block over each pair...
  ~    e#   Dump the pair on the stack.
  W%   e#   Reverse the second element.
  +    e#   Append to first element.
       e#   If there was a trailing single-element list, this will simply
       e#   add the empty string to the previous pair, which just removes
       e#   the empty string.
}%
ee     e# Enumerate the list, which pairs each string (now containing both halves)
       e# of an output line from bottom to top) with its index.
Sf.*   e# Turn those indices X into strings of X spaces, to get the correct
       e# indentation.
W%     e# Reverse the list of strings so the longest line ends up on the bottom.

JavaScript, 116101 bayt

f=(s,r='$&',l='',z=s.replace(/.$|\n?(?!.*\n)..+/gm,x=>(l=x+l,'')))=>l?f(z,r+' ')+l.replace(/\n?/,r):l


G.onclick=()=>O.textContent=f(I.value);

<textarea id=I style=height:100px>/\/\
\/ /
/ /\
\/\/</textarea><button id=G>Go</button><pre id=O></pre>

Sadece bu normal ifade deseni /.$|\n?(?!.*\n)..+/gmfikrini kullanmak istedim . ^{( https://regex101.com/r/mjMz9i/2 )}

JavaScript regex lezzet hayal kırıklığı yaratıyor, uygulamamıştım (?!.*\n)çünkü kullanmak zorundaydım \Zve bir şekilde kullanmak alamadım \0.

• 15 bytes kapalı teşekkürler @Neil.

Jöle , 15 veya 14 bayt

L’⁶x;\Ṛ;"µZUZṚY

Çevrimiçi deneyin!

Bu, Jelly'nin yerleşik özelliklerini köşegenler için kullanmayan bir algoritmadır. Bunu yapmak onu kısaltabilir; Bunu bir daha deneyebilirim.

Algoritma şöyle çalışır. Bu girişle başlayalım:

["abc",
 "def",
 "ghi"]

İle başlıyoruz L’⁶x;\. L’bize giriş eksi 1'in uzunluğunu verir (bu durumda 2). Sonra ⁶xbize bu uzunlukta bir dizi boşluk verir ( " "bu durumda); ve ;\birleştirirken bize kümülatif sonuçlar verir (boşluk üçgeni). Daha sonra üçgeni tersine çeviririz ve orijinalin sol tarafına ;"birleştiririz (listelerin karşılık gelen öğelerini birleştirir, µzorla ayrıştırmada bir kırılmaya neden olur ve böylece orijinal girişi varsayılan olarak ikinci liste olarak kullanırız):

["  abc",
 " def",
 "ghi"]

Bu neredeyse istediğimiz çözümdür, ancak son dizeyle aynı hizada olmak için öğeleri aşağı doğru hareket ettirmemiz gerekir. Bu transposing ( Z), her satırın ( U) tersine çevrilmesi , tekrar transposing ( Z) ve satırların ( Ṛ) tersine çevrilmesi meselesidir :

["  abc",
 " def",
 "ghi"]

devrik

["  g",
 " dh",
 "aei",
 "bf",
 "c"]

satırlar içinde ters

["g  ",
 "hd ",
 "iea",
 "fb",
 "c"]

devrik

["ghifc",
 " deb",
 "  a"]

satırları tersine çevir

["  a",
 " deb",
 "ghifc"]

Son olarak, Yyeni satırlara katılır. Bunun spesifikasyona uyması gerekip gerekmediği belirsizdir (dizelerin bir listesi olarak girişe izin verir, ancak çıktı hakkında aynı şeyi söylemez), bu nedenle tam bayt sayısı dahil edilip edilmediğine bağlıdır.

Pyth, 16 bayt

j_.t_M.Tm+*;l=tQ

Büyük Pyth :

join-on-newline
reverse transpose-and-fill-with-spaces reverse func-map transpose-justified
map
  plus
    times innermost-var
      length assign tail input
    implicit-innermost-var
  implicit-input

İnsanlar golf dillerinin okunmasının zor olduğunu söylediğinden, hem kolayca okunabilen hem de Pyth'e kolayca çevrilebilen Big Pyth'i tasarladım. Bağlantılı dosya, Big Pyth'in bir girdi akışını Pyth'e çevirir. Boşlukla ayrılmış her Büyük Pyth jetonu, bir karakter veya bir. ardından gelen . İstisnalar implicitPyth kodunda örtülü olan tokenlerdir.

Büyük Pyth'in açıklayıcı bir formatın ne kadar iyi olduğunu görmek istiyorum, bu yüzden başka bir açıklama yapmayacağım. Ancak bana bir şeyin açıklanmasını isteyip istemediğinizi sorun.

JavaScript (ES6), 140 bayt

a=>[...Array(m=(h=a.length)<(w=a[0].length)?h:w)].map((_,i)=>[...Array(h+w-1)].map((_,j)=>(a[x=i+h-m-(++j>w&&j-w)]||``)[x+j-h]||` `).join``)

Girdi ve çıktıları dizgiler dizisi olarak alır. Ayrıca iki boyutlu karakter dizisi girişini kabul eder ve iki boyutlu karakter dizisi çıktısı kabul edilebilirse 7 bayt tasarruf eder. Açıklama: Sonucun myüksekliği , orijinal dizinin yüksekliğinin hve genişliğinin minimumudur, genişlik wise orijinal dizinin yükseklik ve genişliğinin toplamından basittir. Sonucun ana bölümündeki karakterlerin kaynak satırı, doğrudan orijinal dizinin ilgili satırından gelir, aşağıdan yukarıya doğru sayılırken, sonucun ekstra kısmında kaynak satır her ek sütun için bir satır yukarı taşınır. Sonucun her iki yarısı için kaynak sütunun, alttan yukarıdaki her kaynak satırı için bir sütun sola taşınan hedef sütuna eşit olduğu ortaya çıkar.

Oktav, 57 bayt

@(A){B=spdiags(A),C=B>0,D='  '(C+1),D(sort(C))=B(C),D}{5}

Python 3, 247 bayt

def a(s):
 s=s.split('\n')
 for i,l in enumerate(s):r=len(s)-i-1;s[i]=' '*r+l+' '*(len(s)-r-1)
 print(*[''.join(i) for i in list(zip(*[''.join(a).rstrip([::-1].ljust(min(len(s),len(s[0])))for a in zip(*[list(i)for i in s])]))[::-1]],sep='\n')`

Python 2, 150 bayt

def f(l):w=len(l[0]);h=len(l);J=''.join;R=range;print'\n'.join(map(J,zip(*['%%-%ds'%h%J(l[h+~i][j-i]for i in R(h)if-w<i-j<1)for j in R(h-~w)]))[::-1])

Girdi dizeleri listesi olarak alır.

Clojure, 194 bayt

Karakterleri gruplara ayırarak Gve ardından satırlar oluşturarak zor yolu uyguladı .

#(let[n(count %)m(count(% 0))G(group-by first(for[i(range n)j(range m)][(min(- n i)(- m j))((% i)j)]))](apply str(flatten(for[k(reverse(sort(keys G)))][(repeat(dec k)" ")(map last(G k))"\n"]))))

Bir şekilde girişi alır vecait vecgibi s [[\a \b \c \d] [\1 \2 \3 \4] [\W \X \Y \Z]]. Misal:

(def f #( ... ))
(print (str "\n" (f (mapv vec(re-seq #".+" "abcd\n1234\nWXYZ")))))

  ab
 c123
d4WXYZ