Bir matris verildiğinde, sol üst elemanın üstte olduğu, matrisin bir temsilini çıktılayın, anti-diyagonal orta satırdır ve sağ alt eleman alttadır.

Örneğin, aşağıdaki matrisi düşünün:

1 2 3
4 5 6
7 8 9

Bu matrisin elmas versiyonu:

  1
 4 2
7 5 3
 8 6
  9

Girdiler ve çıktılar

Bir giriş matrisi bir liste listesi (veya kendi dilinizde benzer herhangi bir şey) olarak verilecektir. Çıktı da bir liste listesi olacaktır.

Matrisler sadece pozitif tamsayıları içerecektir.

Giriş matrisinin mutlaka kare olması gerekmez.

Giriş matrisi en az 1 × 1 olacaktır.

Test Durumları

Input:  [[1]]
Output: [[1]]

Input:  [[1,2],[3,4]]
Output: [[1],[3,2],[4]]

Input:  [[1,2,3],[4,5,6]]
Output: [[1],[4,2],[5,3],[6]]

Input:  [[11,2,5],[3,99,3],[4,8,15],[16,23,42]]
Output: [[11],[3,2],[4,99,5],[16,8,3],[23,15],[42]]

puanlama

Bu kod golf , bu yüzden bayttaki en kısa cevap kazanır.

J, 7 bayt

<@|./.

Bu, bir matris alan ve antidiagonallerin bir listesini döndüren isimsiz bir monadik fiildir:

   input =. i.3 4
   input
0 1  2  3
4 5  6  7
8 9 10 11

   <@|./. input
┌─┬───┬─────┬─────┬────┬──┐
│0│4 1│8 5 2│9 6 3│10 7│11│
└─┴───┴─────┴─────┴────┴──┘

Burada test edin.

açıklama

• /.J, her bir anti-diyagonal üzerine bir işlev uygulamak için yerleşiktir. Ne yazık ki, bu anti-köşegenler burada istediğimiz şeyin tersi sırada verilmektedir.
• İçinde <@|., önce |.anti-diyagonali tersine çeviren ve daha sonra <kutuyu uygularız (normal diziler her zaman dikdörtgen olduğu için J'de düzensiz bir dizi döndürmenin tek yolu budur, bu nedenle antidiagonaller sıfırlarla doldurulur).

Python, 91 bayt

e=enumerate
lambda M:[[r[n-i]for i,r in e(M)if-1<n-i<len(r)][::-1]for n,_ in e(M[1:]+M[0])]

Ideone üzerinde test edin .

Python + NumPy, 69 bayt

import numpy
lambda M:map(M[::-1].diagonal,range(1-len(M),len(M[0])))

2D NumPy dizisini girdi olarak bekler ve NumPy dizilerinin listesini döndürür. Ideone üzerinde test edin .

Jöle, 7 bayt

ṚŒDṙZL$

Çevrimiçi deneyin!

açıklama

Ṛ         Reverse the matrix vertically.
 ŒD       Get its diagonals. However these start from 
          the main diagonal, not the corners.
    ZL$   Get the width of the input matrix.
   ṙ      Rotate the list of diagonals left by that many 
          places to obtain the correct order.

Mathematica, 58 56 bayt

a=Length;Reverse@#~Diagonal~b~Table~{b,1-a@#,a@#&@@#-1}&

Anonim işlev, iç içe diziler alır.

CJam, 17 bayt

{eeSf.*::+W%zSf-}

Yığındaki matrisi bekleyen ve antidiagonalleriyle değiştiren isimsiz bir blok (işlev).

Burada test edin.

Bu (Sp3000 tarafından bulunan) aynı bayt sayısı için çalışır:

{_,,Sf*\.+W%zSf-}

açıklama

Bu en iyi bir örnekle açıklanabilir. Girişi düşünün:

[[0  1  2  3]
 [4  5  6  7]
 [8  9 10 11]]

ee    e# Enumerate matrix, turning each row [x ... z] into [i [x ... z]] where
      e# i is the vertical index from the top.

[[0 [0  1  2  3]]
 [1 [4  5  6  7]]
 [2 [8  9 10 11]]]

Sf.*  e# Replace each i with a string of i spaces.

[[""   [0  1  2  3]]
 [" "  [4  5  6  7]]
 ["  " [8  9 10 11]]]

::+   e# Prepend these strings to the rows.

[[0  1  2  3]
 ['  4  5  6  7]
 ['  '  8  9 10 11]]   e# Note that each '  corresponds to a space character.

W%    e# Reverse the rows.

[['  '  8  9 10 11]
 ['  4  5  6  7]
 [0  1  2  3]]

z     e# Zip/transpose.

[[ '  '  0]
 [ '  4  1]
 [ 8  5  2]
 [ 9  6  3]
 [10  7]
 [11]]

Sf-   e# Remove spaces from each row.

[[ 0]
 [ 4  1]
 [ 8  5  2]
 [ 9  6  3]
 [10  7]
 [11]]

Python 2, 88 87 bayt

lambda L:[filter(None,x)[::-1]for x in map(None,[],*[i*[0]+r for i,r in enumerate(L)])]

0'ları ekleyin, sıkıştırın, sonra falsy öğelerini çıkarın. Bir tuples listesi döndürür. Bu kullanımlar map(None,...)gerçekleştirmek için zip_longest (ile lekeler eksik doldurma None) ve filter(None,...)falsy elemanları kaldırın.

Can sıkıcı bir şekilde, 1x1 matrisinden ziyade döndürmelerden dolayı, tuples listesinin döndürülmesini garanti []etmek için fazladan bir satır eklememiz gerekir . Ekstra sıra olsa çıkarılır .mapmap(None,*[[1]])[1][(1,)]filter

(@Dennis'e -1 bayt için teşekkürler)

Yakut, 68 66 bayt

Anonim işlev.

->l{i=-1;k=[];l.map{|r|i-=j=-1;r.map{|e|k[i+j+=1]=[e,*k[i+j]]}};k}

• Uyarıcı işleci nasıl çalıştığından dolayı, dizi eklemesini yaparak 2 bayt kaydedebildim.

Mathematica, 60 bayt

#&@@@#&/@GatherBy[Join@@MapIndexed[List,#,{2}],Tr@*Last]&

burada Mathematica'nın postfix \[Transpose]operatörü olarak okuduğu bir Unicode karakteri .

Bu, diğer Mathematica çözümünden biraz daha uzun ama Diagonalsyerleşik olanı kullanmadığı ve tamamen farklı bir yaklaşım kullandığı için göndereceğimi düşündüm .

açıklama

MapIndexed[List,#,{2}]

Bu ilk önce matrisi aktarır (matris düzleştirilmişse antidiagonallar doğru sırada görünür). Daha sonra List, her matris öğesini matristeki öğenin nereye ve koordinatlarına idönüştüren dizinle birlikte matris hücreleri üzerinde eşleştiriyoruz .{i, {x, y}}xy

Join@@...

Bu, en dıştaki boyutu düzleştirir, böylece artık sütun ana düzeninde matris öğelerinin (koordinatlarıyla) düz bir listesine sahibiz.

GatherBy[..., Tr@*Last]

Bu, bu öğeleri koordinatlarının toplamına göre gruplandırır. Antidiagonallerin sabit çizgiler olduğuna dikkat edin, x+ybu da tam olarak istediğimiz gruplamayı yapar. Her grup içindeki düzen korunur. Şimdi sadece koordinatlardan tekrar kurtulmamız gerekiyor. Bu oldukça şifreli olarak yapılır:

#&@@@#&/@...

Bu, #&@@@#&gruptaki her öğe için geçerli #& olan ve #yalnızca ilk argüman olan orijinal matris öğesi olan işlevi her grup üzerinde eşler .

Oktav, 77 bayt

accumarrayİşlevi biraz kötüye kullanarak :

@(M)char(accumarray(((1:size(M,1))+(0:size(M,2)-1)')(:),M(:),[],@(x){num2str(x')}))

Bu anonim bir işlevi tanımlar. Kullanmak için bir değişkene atayın veya kullanın ans.

Girdi, :satır ayırıcılı matristir . Çıktı, her satır için bir dizi içeren bir hücre dizisidir (Octave, tırtıklı dizilere eşdeğerdir). Bu, hücre dizisinin indekslerini ve her hücrenin içeriğini gösteren Octave tarafından görüntülenir. Burada deneyin .

Sonucu yalnızca boşluk ve satırsonu ile ayrılmış olarak görüntülemek için: 83 bayt

@(M)char(accumarray(((1:size(M,1))+(0:size(M,2)-1)')(:),M(:),[],@(x){num2str(x')}))

Ayrıca Burada deneyebilirsiniz .

JavaScript (Firefox), 86 75 bayt

a=>a.concat(a[0]).slice(1).map((_,i)=>[for(v of a)if(n=v[i--])n].reverse())

@Neil sayesinde 11 bayt tasarruf edildi!

Firefox 30+ ile çalışır. Bir dizi dizi alır.

Oktav, 63 62 bayt

@DonMue ... @LuisMendo sayesinde bir bayt kaldırıldı !

@(a)cellfun(@(x)x(x>0)',num2cell(spdiags(flipud(a)),1),'un',0)

Sıkıcı rotaya gittim ve antidiagonalleri aradım.

İdeone üzerinde örnek çalışma .

Haskell, 83 82 bayt

r=zip[0..]
\o->fst$span(any(>0))[reverse[e|(x,t)<-r o,(v,e)<-r t,x+v==a]|a<-[0..]]

nimi bir bayt kurtardı. Teşekkürler!

Python, 128 bayt (numpy)

(lambda A: (lambda A,S:[[A[U][I-U] for U in range(min(S[1]-1,I),max(I-S[0]+1,0)-1,-1)] for I in range(S[1]+S[0]-1)])(A,A.shape))

Pyth , 41 17 bayt

tm_<dx+dYk.T+LaYk

Çevrimiçi deneyin!

@ Doorknob'un başka bir soruna çözümünden ilham aldı .

Nasıl çalışır:

tm_<dx+dYk.T+LaYk
            +L      prepend to each subarray...
              aYk   (Y += ''). Y is initialized to [],
                    so this prepends [''] to the first
                    subarray, ['', ''] to the second, etc.
                    ['' 1  2  3
                     '' '' 4  5  6
                     '' '' '' 7  8  9
                     '' '' '' '' 10 11 12
                     '' '' '' '' '' 13 14 15]
          .T        transpose, giving us
                    ['' '' '' '' ''
                     1  '' '' '' ''
                     2  4  '' '' ''
                     3  5  7  '' ''
                     6  8  10 ''
                     9  11 13
                     12 14
                     15]
 m_<dx+dYk          removes all empty strings in the
                    subarrays while reversing each one
t                   remove the first subarray

Önceki deneme:

JlQKlhQm_m@@Qk-dk}h.MZ,0-dtKh.mb,tJdUt+JK

Çevrimiçi deneyin!

Nasıl çalışır:

JlQKlhQm_m@@Qk-dk}h.MZ,0-dtKh.mb,tJdUt+JK    input array stored as Q
JlQ                                          J = len(Q)
   KlhQ                                      K = len(Q[0])
       m                            Ut+JK    list for d from 0 to J+K-1:
        _m       }AAAAAAAAAABBBBBBBB             reversed list for k from A to B, where:
                  h.MZ,0-dtK                       A = max(0, d-(K-1))
                       0-dtK                               0  d-(K-1)
                            h.mb,tJd               B = min(J-1, d)
                                 tJd                       J-1  d
          @@Qk-dk                                    Q[k][d-k]

Harika, 77 73 75

{i->o=[].withDefault{[]};a=0;i.each{b=0;it.each{o[a+b++].add(0,it)};a++};o}

Dizi dizisini girdi olarak alır ve dizi dizisini döndürür.

Dene

DÜZENLEME: Ben puan sonra 75'e kadar gider ekledikten sonra anwser çıktı unuttum.