Pour ce défi, vous devez écrire un programme ou une fonction qui génère les diagonales d'une matrice carrée donnée. Cependant, si vous transposez les lignes et les colonnes du code source de votre solution, il devrait plutôt devenir un programme ou une fonction qui renvoie les antidiagonales de la matrice. Lisez la suite pour plus de détails ...

Règles

• Le code source de votre solution est considéré comme une grille 2D de caractères, séparés par une nouvelle ligne standard de votre choix (saut de ligne, retour chariot ou une combinaison des deux).

• Aucune ligne de votre code source ne peut être plus longue que la précédente. Voici quelques exemples de dispositions valides:

  ###
  ###
  ###
  

  ########
  #######
  ###
  ###
  #
  

  Et voici un exemple de mise en page invalide (car la troisième ligne est plus longue que la seconde):

  ######
  ####
  #####
  ###
  

• Vos deux solutions doivent être mutuellement transposées, c'est-à-dire que vous devez obtenir l'une de l'autre en échangeant des lignes et des colonnes. Voici deux paires valides:

  abc
  def
  ghi
  

  adg
  beh
  cfi
  

  Et

  print 10
  (~^_^)~
  foo
  bar
  !
  

  p(fb!
  r~oa
  i^or
  n_
  t^
   )
  1~
  0
  

  Notez que les espaces sont traités comme tous les autres caractères. En particulier, les espaces de fin sont importants car ils peuvent ne pas être des espaces de fin dans la transposition.

• Chaque solution doit être un programme ou une fonction qui prend en entrée une matrice carrée non vide d'entiers à un chiffre. Une solution doit produire une liste de toutes les diagonales de la matrice et l'autre doit produire une liste de toutes les antidiagonales. Vous pouvez utiliser des formats d'entrée et de sortie raisonnables et sans ambiguïté, mais ils doivent être identiques entre les deux solutions (cela signifie également qu'ils doivent être à la fois des fonctions ou des deux programmes).

• Chaque diagonale va du haut à gauche au bas à droite, et elles doivent être commandées de haut en bas.
• Chaque antidiagonale s'étend du bas à gauche vers le haut à droite, et elles doivent être commandées de haut en bas.

Notation

Pour encourager des solutions aussi «carrées» que possible, le score principal est le nombre de lignes ou le nombre de colonnes de votre solution, selon le plus élevé . Moins c'est mieux. Les liens sont rompus par le nombre de caractères dans la solution, sans compter les sauts de ligne. Encore une fois, moins c'est mieux. Exemple:

abcd
efg
h

Cela et sa transposition auraient un score primaire de 4 (car il y a 4 colonnes) et un score de départage de 8 (car il y a 8 caractères non-newline). Veuillez citer les deux valeurs dans l'en-tête de votre réponse.

Cas de test

La tâche réelle effectuée par les deux solutions ne devrait pas être le principal défi ici, mais voici deux exemples pour vous aider à tester vos solutions:

Input:
1 2 3
4 5 6
7 8 9
Diagonals:
3
2 6
1 5 9
4 8
7
Antidiagonals:
1
4 2
7 5 3
8 6
9

Input:
1 0 1 0
0 1 0 1
1 0 1 0
0 1 0 1
Diagonals:
0
1 1
0 0 0 
1 1 1 1
0 0 0
1 1
0
Antidiagonals:
1
0 0
1 1 1
0 0 0 0
1 1 1
0 0
1

Javascript, marque 20 14, ( 258 176 caractères non-newline)

///mmm()mu[=+r
///=.av=a,pr"=
///> p,>px=[ [
m=>//(yv()xp"]
m. ////.(=+]+)
map((////>y?u&
v,y)=>v//r]r:&
.map((u,x//[ur
)=>r[p=m.//p)
length-1-//],
x+y]=r[p]////
?r[p]+" "+u//
:u),r=[])&&r

et

///mmmv.)lx?:
///=.a,m=e+ru
///> pya>ny[)
m=>//()prg]p,
m. //(=([t=]r
map(//>(phr+=
(v,y//vu=-["[
)=>v.//,m1p ]
map((//x.-]")
u,x)=>r////+&
[p=x+y]////u&
=r[p]?r[p]//r
+" "+u:u),//
r=[])&&r

Exemple d'extrait de code:

f=

///mmm()mu[=+r
///=.av=a,pr"=
///> p,>px=[ [
m=>//(yv()xp"]
m. ////.(=+]+)
map((////>y?u&
v,y)=>v//r]r:&
.map((u,x//[ur
)=>r[p=m.//p)
length-1-//],
x+y]=r[p]////
?r[p]+" "+u//
:u),r=[])&&r

console.log(f([
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]))

et

f=

///mmmv.)lx?:
///=.a,m=e+ru
///> pya>ny[)
m=>//()prg]p,
m. //(=([t=]r
map(//>(phr+=
(v,y//vu=-["[
)=>v.//,m1p ]
map((//x.-]")
u,x)=>r////+&
[p=x+y]////u&
=r[p]?r[p]//r
+" "+u:u),//
r=[])&&r

console.log(f([
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]))

MATL , marque 10 (100 caractères non-newline)

%P!       
  Q&%     
  TXd!    
  %d      
     P!   
      "@% 
       Xz 
      %z  
         q
         !

Il y a 10 lignes de 10 caractères (notez les espaces de fin).

Le code ci-dessus produit les diagonales. Essayez-le en ligne!

La version transposée produit les anti-diagonales. Essayez-le en ligne!

Explication

Notez que

• % est un symbole de commentaire, qui ignore le reste de la ligne.

• Les fonctions à deux caractères comme Xdne peuvent pas être divisées en une Xet une den lignes consécutives.

Code d'origine

Le code original, linéarisé et sans la partie commentée, est

Q&TXd!P!"@Xzq!

qui fonctionne comme suit:

Q      % Implicit input. Add 1 to each entry to make them positive
&      % This modifes default inputs/ouputs of next function, which is Xd
       % Specifically, it specifies 2 inputs and 1 ouput
T      % Push true
Xd     % Diagonals of matrix. With second input true, it gives all diagonals,
       % starting from below. The columns are arranged as columns of a matrix,
       % padding with zeros
!P!    % Flip horizontally. This is to produce the correct display order
"      % For each column
  @    %   Push current column
  Xz   %   Remove zeros
  q    %   Subtract 1
  !    %   Transpose into a row
       % Implicit end. Implicit display of stack contents

Code transposé

Le code transposé, linéarisé, est

P!QT&Xd!P!"@Xzq!

qui présente les deux différences suivantes par rapport au code d'origine:

• Tet &sont échangés. Cela n'a aucun effet, carT c'est un littéral, pas une fonction, donc il n'intercepte pas la &spécification.
• P! est ajouté au début.

Le code ajouté modifie la matrice d'entrée afin que les diagonales de la matrice modifiée soient les anti-diagonales de l'entrée:

P      % Implicit input. Flip vertically
!      % Transpose

Gelée , Score 7, 49 octets non-retour à la ligne

Programme d'impression diagonale

......U
......Œ
......D
......ṙ
......L
......Ṛ
ŒDṙLṚUU

Essayez-le en ligne!

Programme d'impression anti-diagonale

......Œ
......D
......ṙ
......L
......Ṛ
......U  
UŒDṙLṚU

Essayez-le en ligne!

Ancienne réponse (sortie non ordonnée), Score 3, 6 octets non-retour à la ligne

Programme d'impression diagonale

UU
UŒ
ŒD

Essayez-le en ligne!

Programme d'impression anti-diagonale

UUŒ
UŒD

Essayez-le en ligne!

Jelly , marque 4 (12 caractères)

^{partitions précédentes: 5 (16 caractères), 4 (16 caractères)}

Original

ŒDṙṚ
D  ñ
ṙLñL

Essayez-le en ligne!

Transposer

ŒDṙ
D L
ṙ ñ
ṚñL

Essayez-le en ligne!

Contexte

Diagonales

La manière simple d'obtenir les diagonales (du plus haut au plus bas) d'une matrice carrée est la suivante.

ŒDṙLṚ

Pour une matrice d'entrée M , ŒDrépertorie les diagonales de M , en commençant par la diagonale principale et en remontant.

Pour l'entrée

1 2 3
4 5 6
7 8 9

cela donne

1 5 9
2 6
3
7
4 8

ṙLcalcule ensuite la longueur de M avec Let fait pivoter les unités de longueur de résultat (M) vers la gauche.

Pour notre exemple, la longueur est de 3 et nous obtenons

7
4 8
1 5 9
2 6
3

Enfin, Ṛinverse l'ordre des diagonales, revenant

3
2 6
1 5 9
4 8
7

pour notre exemple d'entrée.

Anti-diagonales

Les mêmes blocs de construction peuvent être utilisés pour obtenir les anti-diagonales (encore une fois, du plus haut au plus bas) d'une matrice carrée.

ṚŒDṙL

Pour une matrice d'entrée M ,Ṛ inverse d'abord l'ordre des lignes.

Pour l'entrée

1 2 3
4 5 6
7 8 9

cela donne

7 8 9
4 5 6
1 2 3

Comme précédemment, ŒDṙLgénère les diagonales (du bas vers le haut) du résultat.

Pour notre exemple, cela renvoie

1
4 2
7 5 3
8 6
9

comme voulu.

Comment ça marche

Dans Jelly, chaque ligne définit un lien (fonction). En particulier, la dernière ligne définit le lien principal , qui est exécuté au démarrage du programme.

D'autres liens doivent être appelés. Cette réponse utilise ñ, qui exécute le lien ci-dessous dyadiquement. ñs'enroule autour, donc quand il est appelé à partir du lien principal, il exécute le lien sur la première ligne.

Original

Le maillon principal

ṙLñL

prend une matrice d'entrée M , calcule sa longueur avec L, puis fait pivoter les unités de longueur d' entrée (M) vers la gauche avec ṙ(notez que cela ne modifie pas M ), et appelle finalement le premier lien avec le résultat ( M ) et la longueur ( M) comme arguments.

Le premier lien

ŒDṙṚ

calcule les diagonales de M avec ŒD(comme vu dans la section précédente), fait pivoter les unités de longueur de résultat (M) vers la gauche avec ṙ, puis inverse l'ordre du résultat avec Ṛ.

Le deuxième lien n'est jamais appelé.

Transposer

Le maillon principal

 ṚñL

prend une matrice d'entrée M et calcule son inverse avecṚ . Il calcule ensuite la longueur de M avec Let appelle le premier lien avec les arguments reverse (M) et length (M) .

Le premier lien

ŒDṙ

calcule ensuite les diagonales de inverse (M) avec ŒD(comme on le voit dans la section précédente), et finalement tourne les unités de longueur de résultat (M) vers la gauche avec ṙ.

Les liens restants ne sont jamais appelés.

R, score 14 13 11 ( 99 95 caractères non-retour à la ligne)

Merci à @Giuseppe d'avoir amélioré le score de 1. Réduit quelques caractères en utilisant des redondances dans les transpositions. Actuellement le meilleur score pour une langue non golfique!

######`,scr
`::`(#:fpoo
pryr,#:)llw
f)(###`(i((
split (#tmm
p,col(p#())
)+row#r#m-)
(p)))#y#,#)
######r

Et transposé:

#`pfsp)(#
#:r)p,+p#
#:y(lcr)#
#`r#ioo)#
#(,#tlw)#
#### (###
`::`(pryr
,f)(####
split(m,
col(m)-#
row(m)))

Essayez-le en ligne!

Husk , 7 9 4 caractères, marque 4 3

∂T
m
↔

Essayez-le en ligne!

-4 personnages grâce à BMO .