Étant donné une matrice, affichez une représentation de la matrice où l'élément en haut à gauche est en haut, l'anti-diagonale est la ligne centrale et l'élément en bas à droite est en bas.

Par exemple, considérez la matrice suivante:

1 2 3
4 5 6
7 8 9

La version diamant de cette matrice est:

  1
 4 2
7 5 3
 8 6
  9

Entrées et sorties

Une matrice d'entrée sera donnée comme une liste de listes (ou quelque chose de similaire dans la langue de votre choix). La sortie doit également être une liste de listes.

Les matrices ne contiendront que des entiers positifs.

La matrice d'entrée ne sera pas nécessairement carrée.

La matrice d'entrée sera au moins 1 × 1.

Cas de test

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]]

Notation

Il s'agit de code-golf , donc la réponse la plus courte en octets l'emporte.

J, 7 octets

<@|./.

Il s'agit d'un verbe monadique sans nom qui prend une matrice et renvoie une liste d'antidiagonales:

   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│
└─┴───┴─────┴─────┴────┴──┘

Testez-le ici.

Explication

• /.est intégré à J pour appliquer une fonction à chaque anti-diagonale. Malheureusement, ces anti-diagonales sont données dans l'ordre inverse de ce que nous voulons ici.
• Dans <@|., nous appliquons d'abord |.ce qui inverse l'anti-diagonale, puis la <mettre en boîte (ce qui est le seul moyen de renvoyer un tableau irrégulier en J, car les tableaux normaux sont toujours rectangulaires, de sorte que les antidiagonales seraient remplies de zéros).

Python, 91 octets

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

Testez-le sur Ideone .

Python + NumPy, 69 octets

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

Attend un tableau NumPy 2D en entrée et renvoie une liste de tableaux NumPy. Testez-le sur Ideone .

Gelée, 7 octets

ṚŒDṙZL$

Essayez-le en ligne!

Explication

Ṛ         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 octets

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

Fonction anonyme, prend des tableaux imbriqués.

CJam, 17 octets

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

Un bloc sans nom (fonction) qui attend la matrice sur la pile et la remplace par ses antidiagonales.

Testez-le ici.

Cela (trouvé par Sp3000) fonctionne pour le même nombre d'octets:

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

Explication

Ceci est mieux expliqué avec un exemple. Considérez l'entrée:

[[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 octets

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

Ajoutez 0, zippez, puis supprimez les éléments falsifiés. Renvoie une liste de tuples. Cela permet map(None,...)d'effectuer zip_longest (rembourrer les points manquants avec None) et filter(None,...)d'éliminer les éléments falsifiés.

De façon ennuyeuse, nous devons ajouter une []ligne supplémentaire à mappour garantir qu'une liste de tuples est retournée, car map(None,*[[1]])retourne [1]plutôt que [(1,)]pour une matrice 1x1. La rangée supplémentaire est alors supprimée filter.

(Merci à @Dennis pour -1 octet)

Rubis, 68 66 octets

Fonction anonyme.

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

• En raison du fonctionnement de l'opérateur splat, j'ai pu économiser 2 octets en renonçant à l'ajout du tableau.

Mathematica, 60 octets

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

où est un caractère Unicode que Mathematica lit comme l' \[Transpose]opérateur de suffixe .

C'est un peu plus long que l'autre solution Mathematica, mais j'ai pensé que je la posterais car elle n'utilise pas la fonction Diagonalsintégrée et utilise une approche complètement différente.

Explication

MapIndexed[List,#,{2}]

Cela transpose d'abord la matrice (de telle sorte que les antidiagonales apparaissent dans le bon ordre si la matrice a été aplatie). Ensuite, nous cartographions Listles cellules de la matrice avec l'indice, ce qui transforme chaque élément de la matrice ien {i, {x, y}}où xet ysont les coordonnées de l'élément dans la matrice.

Join@@...

Cela aplatit la dimension la plus externe, de sorte que nous avons maintenant une liste plate des éléments de la matrice (avec leurs coordonnées) dans l'ordre des colonnes principales.

GatherBy[..., Tr@*Last]

Cela regroupe ces éléments par la somme de leurs coordonnées. Notez que les antidiagonales sont des lignes de constante x+y, donc cela fait exactement le regroupement que nous voulons. L'ordre au sein de chaque groupe est préservé. Il ne nous reste plus qu'à nous débarrasser des coordonnées. Cela se fait via le plutôt cryptique:

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

Ceci mappe la fonction #&@@@#&sur chaque groupe, qui s'applique lui-même #&à chaque élément du groupe, et #est simplement le premier argument, c'est-à-dire l'élément de matrice d'origine.

Octave, 77 octets

Avec un petit abus de la accumarrayfonction:

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

Cela définit une fonction anonyme. Pour l'utiliser, attribuez à une variable ou utilisez ans.

L'entrée est la matrice avec :comme séparateur de ligne. La sortie est un tableau de cellules contenant un tableau pour chaque ligne (l'équivalent d'Octave aux tableaux irréguliers). Ceci est affiché par Octave montrant les indices du réseau de cellules et le contenu de chaque cellule. Essayez-le ici .

Pour afficher le résultat séparé par des espaces et des sauts de ligne uniquement: 83 octets

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

Vous pouvez également l' essayer ici .

JavaScript (Firefox), 86 75 octets

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

Enregistré 11 octets grâce à @Neil!

Fonctionne dans Firefox 30+. Prend un tableau de tableaux.

Octave, 63 62 octets

Suppression d'un octet grâce à @DonMue ... @LuisMendo!

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

J'ai emprunté la route ennuyeuse et ai croisé les antidiagonales.

Exemple de run sur ideone .

Haskell, 83 82 octets

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

nimi a enregistré un octet. Merci!

Python, 128 octets (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 octets

tm_<dx+dYk.T+LaYk

Essayez-le en ligne!

Inspiré par la solution de @ Doorknob à un autre problème .

Comment ça fonctionne:

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

Tentative précédente:

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

Essayez-le en ligne!

Comment ça fonctionne:

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]

Groovy, 77 73 75

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

Prend un tableau de tableaux en entrée et renvoie un tableau de tableaux.

Essayez-le

EDIT: J'ai oublié de sortir la réponse, après avoir ajouté le score monte à 75.