Inspiré par cette question Stack Overflow .

Le défi

Contribution

Un tableau de matrices carrées contenant des entiers non négatifs.

Production

Une matrice carrée construite à partir des matrices d'entrée comme suit.

Soit $N \times N$ la taille de chaque matrice d'entrée et $P$ le nombre de matrices d'entrée.

Pour plus de clarté, considérons les exemples de matrices d'entrée suivantes ( $N=2$ , $P=3$ ):

Commencez avec la première matrice d'entrée.
Décaler la deuxième matrice d'entrée N −1 pas vers le bas et N −1 pas vers la droite, de sorte que son entrée en haut à gauche coïncide avec l'entrée en bas à droite de la précédente.
Imaginez la seconde matrice décalée comme si elle était empilée sur la première. Additionnez les deux valeurs à l'entrée coïncidente. Écrivez les autres valeurs et remplissez les entrées restantes avec 0pour obtenir une matrice $(2N-1)\times(2N-1)$ . Avec l'exemple d'entrée, le résultat jusqu'à présent est
```
 3   5   0
 4  16   8
 0  12  11
```
Pour chaque matrice d'entrée restante, échelonnez-la de sorte que sa partie supérieure gauche coïncide jusqu'à présent avec la partie inférieure droite de la matrice de résultat accumulée. Dans l'exemple, l'inclusion de la troisième matrice d'entrée donne
```
 3   5   0   0
 4  16   8   0
 0  12  13   0
 0   0   9   1
```
La sortie est la matrice $((N−1)P+1)\times((N−1)P+1)$ obtenue après avoir inclus la dernière matrice d'entrée.

Règles et clarifications supplémentaires

$N$ et $P$ sont des entiers positifs.
Vous pouvez éventuellement prendre $N$ et $P$ comme entrées supplémentaires.
L'entrée et la sortie peuvent être prises par tout moyen raisonnable . Leur format est flexible comme d'habitude.
Les programmes ou fonctions sont autorisés, dans n'importe quel langage de programmation . Les failles standard sont interdites .
Le code le plus court en octets gagne.

Cas de test:

Dans chaque cas, les matrices d'entrée sont affichées en premier, puis la sortie.

$N=2$ , $P=3$ :

 3   5
 4  10

 6   8
12  11

 2   0
 9   1

 3   5   0   0
 4  16   8   0
 0  12  13   0
 0   0   9   1

$N=2$ , $P=1$ :
```
 3   5
 4  10

 3   5
 4  10
```
$N=1$ , $P=4$ :
```
 4

 7

23

 5

39
```

$N=3$ , $P=2$ :

11  11   8
 6   8  12
11   0   4

 4   1  13
 9  19  11
13   4   2

11  11   8   0   0
 6   8  12   0   0
11   0   8   1  13
 0   0   9  19  11
 0   0  13   4   2

$N=2$ , $P=4$ :

14  13
10   0

13  20
21   3

 9  22
 0   8

17   3
19  16

14  13   0   0   0
10  13  20   0   0
 0  21  12  22   0
 0   0   0  25   3
 0   0   0  19  16

code-golf number array-manipulation integer Luis Mendo
la source

Quelle est la durée de votre solution MATL pour cela?

Giuseppe

@Giuseppe Je ne l'ai pas essayé en MATL. Pour les cas de test, j'ai utilisé le code MATLAB de ma réponse dans la question liée

Luis Mendo

4

Gelée , 15 12 octets

⁹ṖŻ€ƒZƲ⁺+µ@/

Essayez-le en ligne!

Comment ça fonctionne

⁹ṖŻ€ƒZƲ⁺+µ@/  Main link. Argument: A (array of matrices)

         µ    Begin a monadic chain.
          @/  Reduce A by the previous chain, with swapped arguments.
                Dyadic chain. Arguments: M, N (matrices)
      Ʋ           Combine the links to the left into a monadic chain with arg. M.
⁹                 Set the return value to N.
 Ṗ                Pop; remove its last row.
     Z            Zip; yield M transposed.
    ƒ             Fold popped N, using the link to the left as folding function and
                  transposed M as initial value.
  Ż€                Prepend a zero to each row of the left argument.
                    The right argument is ignored.
       ⁺        Duplicate the chain created by Ʋ.
        +       Add M to the result.

Dennis
la source

6

R , 88 81 octets

function(A,N,P,o=0*diag(P*(N-1)+1)){for(i in 1:P)o[x,x]=o[x<-1:N+i-1,x]+A[[i]];o}

Essayez-le en ligne!

Prend un list des matrices, A, Net P.

Construit la matrice de zéros requise oet ajoute par élément le contenu de Aaux sous-matrices appropriées danso .

Giuseppe
la source

4

JavaScript (ES6), 102 octets

Prend l'entrée comme (n,p,a).

(n,p,a)=>[...Array(--n*p+1)].map((_,y,r)=>r.map((_,x)=>a.map((a,i)=>s+=(a[y-i*n]||0)[x-i*n]|0,s=0)|s))

Essayez-le en ligne!

Comment?

$0$ $w$

w = (n - 1) \times p + 1

$w=(n-1)\times p+1$

$(x,y)$

s_{x, y} = \sum_{i = 0}^{p - 1} a_{i} (x - i \times (n - 1), y - i \times (n - 1))

$s_{x,y}=\sum_{i=0}^{p-1}{a_i(x-i\times (n-1),y-i\times (n-1))}$

où les cellules non définies sont remplacées par des zéros.

Arnauld
la source

3

Python 2 , 124 octets

def f(m,N,P):w=~-N*P+1;a=[w*[0]for _ in' '*w];g=0;exec"x=g/N/N*~-N;a[x+g/N%N][x+g%N]+=m[x][g/N%N][g%N];g+=1;"*P*N*N;return a

Essayez-le en ligne!

ovs
la source

3

Gelée , 12 octets

Z€Ż€’}¡"Jµ⁺S

Essayez-le en ligne!

Z€Ż€’}¡"Jµ⁺S
         µ    Everything before this as a monad.
          ⁺   Do it twice
Z€            Zip €ach of the matrices
        J     1..P
       "      Pair the matrices with their corresponding integer in [1..P] then apply the 
              following dyad:
  Ż€            Prepend 0 to each of the rows
      ¡         Repeat this:
    ’}          (right argument - 1) number of times
              Doing everything before µ twice adds the appropriate number of rows and
              columns to each matrix. Finally:
           S  Sum the matrices.

12 octets

J’0ẋ;Ɱ"Z€µ⁺S

Si des zéros supplémentaires étaient autorisés, ZŻ€‘ɼ¡)⁺Sc'est une solution cool de 9 octets. TIO .

dylnan
la source

2

Gelée , 20 octets

µ;€0Zð⁺0ṁ+ṚU$}ṚU+⁸µ/

Essayez-le en ligne!

Bah, Jelly a une attitude aujourd'hui ...

Erik le Outgolfer
la source

2

Pip , 37 octets

{i:0{Y#i-1aM:0RLyAL_i+:yZG#@aALa}Mai}

Une fonction qui prend une liste de listes de listes. Essayez-le en ligne!

DLosc
la source

2

Python 2 , 124 octets

def f(A,N,P):M=N-1;R=G(M*P+1);return[[sum(A[k][i-k*M][j-k*M]for k in G(P)if j<N+k*M>i>=k*M<=j)for j in R]for i in R]
G=range

Essayez-le en ligne!

Chas Brown
la source

1

Fusain , 52 octets

≦⊖θＥ⊕×θηＥ⊕×θηΣＥＥη×θξ∧¬∨∨‹ιν›ι⁺θν∨‹λν›λ⁺θν§§§ζξ⁻ιν⁻λν

Essayez-le en ligne! Le lien est vers une version détaillée du code et comprend deux octets pour une mise en forme quelque peu utilisable. J'ai commencé avec une version qui rembourrait tous les tableaux, puis je les ai sommés, mais j'ai pu utiliser cette version pour être plus courte à la place. Explication:

≦⊖θ

Décrémenter la valeur d'entrée $N$ .

Ｅ⊕×θηＥ⊕×θη

Calculez la taille du résultat $(N-1)P+1$ et mapper sur la plage implicite deux fois, produisant ainsi une matrice de résultats qui est implicitement imprimée.

ΣＥＥη×θξ

Mapper sur la plage implicite sur la valeur d'entrée $P$ et multipliez chaque élément par $N-1$ . Ensuite, cartographiez la plage résultante et additionnez le résultat final.

∧¬∨∨‹ιν›ι⁺θν∨‹λν›λ⁺θν

Vérifiez qu'aucun des indices n'est hors de portée.

§§§ζξ⁻ιν⁻λν

Décalage dans l'entrée d'origine pour récupérer la valeur souhaitée.

Neil
la source

Décaler, empiler, somme

Le défi

Contribution

Production

Règles et clarifications supplémentaires

Cas de test:

Réponses:

Gelée , 15 12 octets

Comment ça fonctionne

R , 88 81 octets

JavaScript (ES6), 102 octets

Comment?

Python 2 , 124 octets

Gelée , 12 octets

Gelée , 20 octets

Pip , 37 octets

Python 2 , 124 octets

Fusain , 52 octets