18

Étant donné 2 entrées, C = columns and rows, S = starting pointune matrice est produite comme suit:

Input 4, 3

1   2   3   0
2   2   3   0
3   3   3   0
0   0   0   0

Explication

Donné C = 4, S = 3

1) Créez une C x Cmatrice remplie de0

         4 columns
4     _____|____
     |          |
r  --0  0   0   0
o |  0  0   0   0
w |  0  0   0   0
s  --0  0   0   0

2) Remplissez avec des Svaleurs dans la ligne et la colonne S, puis soustrayez 1 de Set répétez jusqu'à S = 0. Ce casS = 3

             Column 3 
S = 3           |
                v
        0   0   3   0
        0   0   3   0
Row 3-->3   3   3   0
        0   0   0   0


         Column 2
S = 2       |
            v
        0   2   3   0
Row 2-->2   2   3   0
        3   3   3   0
        0   0   0   0


     Column 1
S=1     |
        v
Row 1-->1   2   3   0
        2   2   3   0
        3   3   3   0
        0   0   0   0



Final Result

1   2   3   0
2   2   3   0
3   3   3   0
0   0   0   0

Règles

Présumer C >= S >= 0
La sortie peut être une matrice, une liste de listes, un tableau (unidimensionnel ou bidimensionnel), etc.
Vous pouvez prendre des entrées via n'importe quel format d'E / S par défaut
Votre programme, fonction, etc ... peut être à 1 indexation ou à 0 indexation. Veuillez préciser lequel.

Remarque L' explication est l'indexation 1

Critères gagnants code-golf

code-golf matrix

— Luis felipe De jesus Munoz
source

6

Gelée , 8 octets

»>⁴¬×»µþ

Essayez-le en ligne!

Comment ça fonctionne

Jelly's Outer Product Atom ( þ)

Vous pouvez penser à l'atome de produit externe de Jelly þ, comme un (opérateur) rapide qui, étant donné les arguments entiers et (dans ce cas, ), produit la matrice de tuples suivante: $X$ $Y$ $X=Y=\text{first argument }$

[\begin{matrix} (1, 1) & (2, 1) & (3, 1) & \dots & (X, 1) \\ (1, 2) & (2, 2) & (3, 2) & \dots & (X, 2) \\ ⋮ & ⋮ & ⋮ & ⋱ & ⋮ \\ (1, Oui) & (2, Oui) & (3, Oui) & \dots & (X, Oui) \end{matrix}]

$\left[\begin{matrix} (1, 1) & (2, 1) & (3, 1) & \cdots & (X, 1) \\ (1, 2) & (2, 2) & (3, 2) & \cdots & (X, 2) \\ \vdots & \vdots & \vdots & \ddots & \vdots \\ (1, Y) & (2, Y) & (3, Y) & \cdots & (X, Y) \end{matrix}\right]$

Il applique également le lien juste avant lui à toutes les paires, appelons-le , qui se comporte comme une fonction qui prend deux arguments, produisant quelque chose comme ceci: $\:f$

[\begin{matrix} F (1, 1) & F (2, 1) & F (3, 1) & \dots & F (X, 1) \\ F (1, 2) & F (2, 2) & F (3, 2) & \dots & F (X, 2) \\ ⋮ & ⋮ & ⋮ & ⋱ & ⋮ \\ F (1, Oui) & F (2, Oui) & F (3, Oui) & \dots & F (X, Oui) \end{matrix}]

$\left[\begin{matrix} f(1, 1) & f(2, 1) & f(3, 1) & \cdots & f(X, 1) \\ f(1, 2) & f(2, 2) & f(3, 2) & \cdots & f(X, 2) \\ \vdots & \vdots & \vdots & \ddots & \vdots \\ f(1, Y) & f(2, Y) & f(3, Y) & \cdots & f(X, Y) \end{matrix}\right]$

En quoi est-elle pertinente pour la tâche à accomplir?

Cela fonctionne en notant que chaque valeur dans la sortie attendue n'est qu'un tableau d'indices maximaux, ou si ce maximum dépasse notre deuxième argument. Par conséquent, nous pouvons créer le lien suivant pour effectuer ce mappage: $0$

»>⁴¬×» – Dyadic (2-argument) link.
»      – Maximum of the X, Y coordinates.
 >⁴    – Check if this exceeds the second argument of the program.
   ¬   – Negate this boolean.
    ×» – And multiply by the maximum, computed again.

— M. Xcoder
source

6

R , 47 41 octets

function(C,S,m=outer(1:C,1:C,pmax))m*!m>S

Essayez-le en ligne!

1 indexé. Génère les sorties pour S==C(pas de zéros) puis zéros les cellules qui ont une valeur en >Sutilisant la multiplication matricielle (merci Giuseppe pour 4 octets!).

— JayCe
source

Soigné! la multiplication vous permettra d'obtenir un bon kilométrage: 43 octets

— Giuseppe

@Giuseppe tx! J'ai pu sauver deux autres :)

— JayCe

5

Octave , 31 octets

@(C,S)(u=max(t=1:C,t')).*(u<=S)

Fonction anonyme qui renvoie une matrice. Utilise l'indexation basée sur 1.

Essayez-le en ligne!

— Luis Mendo
source

5

Haskell , 47 45 octets

^{-2 octets en changeant le format de sortie en liste unidimensionnelle.}

c&s|x<-[1..c]=[sum[j|j<=s]|j<-x>>=(<$>x).max]

Essayez-le en ligne!

Explication

Le terme x >>= (<$> x) . maxest une version golfée de

concat [ max i <$> x | i <- x ]

qui évalue à [1,2,3,4..c, 2,2,3,4..c, 3,3,3,4..c, ..., c,c,c,c..c]. Il nous suffit maintenant de forcer les valeurs à0 une fois qu'ils dépassent sque nous atteignons avec sum [ j | j <= s].

— ბიმო
source

5

APL (Dyalog Classic), 12 octets

{⍺ ⍺↑∘.⌈⍨⍳⍵}

Essayez-le en ligne!

Tous les conseils pour en faire un train sont les bienvenus.

— jslip
source

Mon train est plus long de 2

— heures

13 octets

— FrownyFrog

3

APL (Dyalog) , 12 octets

o×⎕≥o←∘.⌈⍨⍳⎕

Essayez-le en ligne!

— Uriel
source

Est-ce que quelque chose comme ça o×⎕≥o←∘.⌈⍨⍳serait autorisé, ou devrais-tu l'assigner à une fonction pour que cela compte?

— Zacharý

@ Zacharý ma conjecture est qu'il faudrait le mettre dans un tradfn avec un argument ou un dfns

— Uriel

3

JavaScript (ES6), 61 octets

Prend l'entrée dans la syntaxe de curry (c)(s), où s est indexé 1. Renvoie un tableau à 1 dimension.

c=>s=>[...Array(c*c)].map((_,k)=>(k=k%c>k/c?k%c:k/c)<s?-~k:0)

Essayez-le en ligne!

— Arnauld
source

3

Gelée , 6 octets

⁴Ri»µþ

Un programme complet * prenant des entiers Cet Squi imprime la représentation Jelly d'une liste de listes d'entiers telles que définies (1-indexées).

Essayez-le en ligne! (formate le résultat de la dyade sous forme de grille de nombres pour une lecture plus facile)

Comment?

⁴Ri»µþ - Main Link: C, S
     þ - outer product with:
    µ  -   the monadic function (i.e. f(x,y) for x in [1..C] for y in [1..C]):
   »   -     maximum (of x and y)
⁴      -     program's 4th argument = 2nd input = S
 R     -     range = [1,2,3,...S]
  i    -     first index of (the maximum) in (the range) or 0 if not found
       - as a full program: implicit print

^{* La raison pour laquelle c'est un programme complet est en baisse à l'utilisation de l'accès des arguments du programme, ⁴. En tant que lien dyadique, ce code dépendrait de la façon dont le programme qui l'utilise est appelé.

Lien dyadique réutilisable en 8 octets (en prenant S à gauche et C à droite):
Lien dyadique réutilisable en 8 octets (en prenant C à gauche et S à droite):RiⱮⱮ»þ`}
RiⱮⱮ⁹»þ¤}

— Jonathan Allan
source

2

Java 10, 88 octets

C->S->{var r=new int[C][C];for(;S>0;)for(int s=S--;s-->0;)r[S][s]=r[s][S]=S+1;return r;}

Essayez-le en ligne.

Explication:

C->S->{                     // Method with two int parameters and int-matrix return-type
  var r=new int[C][C];      //  Result-matrix of size `C` by `C`
  for(;S>0;)                //  Loop as long as `S` is not 0 yet:
    for(int s=S--;s-->0;)   //   Inner loop `s` in the range (`S`, 0]
                            //   (and decrease `S` by 1 in the process with `S--`)
      r[S][s]=r[s][S]=S+1;  //    Set the values at both {`S`,`s`} and {`s`,`S`} to `S+1`
  return r;}                //  Return the result

— Kevin Cruijssen
source

2

PHP , 92 octets

C'est "1-indexation".

<?list(,$c,$s)=$argv;for(;$i++<$c;print"\n")for($j=0;$j++<$c;)echo$s<$i||$s<$j?0:max($i,$j);

Pour l'exécuter:

php -n <filename> <c> <s>

Exemple:

php -n collapsing_matrice.php 8 6

Ou essayez-le en ligne!

— Nuit2
source

2

Stax , 10 octets

▓╜.→,cΘ○╤æ

Exécuter et déboguer

Comment ça fonctionne:

R(Xm]i*xit+J Full program, implicit input.
R            1-based range of S
 (           Right-pad with zeroes to length C
  X          Save to X register
   m         Map (same as here):
    ]          Wrap in list
     i*        repeat by iteration index
       xit     Remove first  elements from X register
          +    Append
           J   Stringify each element, and join by space

— wastl
source

2

Excel VBA, 65 octets

Une fonction de fenêtre immédiate qui prend des entrées [A1:B1]et des sorties dans la plage [C1].Resize([A1],[A1]).

[C1].Resize([A1],[A1])=0:For s=-[B1]To-1:[C1].Resize(-s,-s)=-s:Next

Entrée sortie

L'entrée est dans la plage [A1:B1]

— Taylor Scott
source

2

J , 18 octets

,~@[{.[:>./~1+i.@]

Beaucoup plus long que les deux solutions APL.

Essayez-le en ligne!

— Galen Ivanov
source

2

MATLAB, 58 octets (Merci à un utilisateur anonyme)

function o=f(c,s);o=zeros(c);for j=s:-1:1;o(1:j,1:j)=j;end

Il suffit de remplir les éléments de la matrice avec le nombre approprié, de faire une boucle. Peut-être possible d'être plus intelligent avecarrayfun

— aaaaa dit réintégrer Monica
source

Vous n'avez pas besoin de nommer la fonction et vous pouvez utiliser zeros(c)quels coffres-forts certains octets. Avez-vous également vu cette réponse Octave, je suppose que cela fonctionnerait aussi dans Matlab?

— ბიმო

@ OMᗺ Octave, vous ne pouvez pas nommer de variables dans des fonctions anonymes dans matlab. De plus, il max()faut prendre les mêmes arguments

— aaaaa dit de réintégrer Monica le

1

Un utilisateur anonyme a suggéré function o=f(c,s);o=zeros(c);for j=s:-1:1;o(1:s,1:s)=j;end.

— Jonathan Frech

@JonathanFrech oh my so so simpler simple :-( il suffit de l'êtreo(1:j,1:j)=j

— aaaaa dit réintégrer Monica le

1

C # (.NET Core) , 85 octets

c=>s=>{var r=new int[c,c];for(;s>0;)for(int j=s--;j-->0;)r[s,j]=r[j,s]=s+1;return r;}

Essayez-le en ligne!

Un port de la réponse de Kevin Cruijssen , bien meilleur que le mien.

— Charlie
source

1

Python 2 , 58 octets

lambda C,S:[-~max(i%C,i/C)*(i%C<S>i/C)for i in range(C*C)]

Essayez-le en ligne!

Génère une liste 1D de longueur C*C.

— Chas Brown
source

1

Fusain , 19 octets

Ｅθ⪫ＩＥＥθ⌈⟦ιλ⟧∧‹λη⊕λ

Essayez-le en ligne! Le lien est vers la version détaillée du code. 3 octets utilisés pour convertir la sortie en décimal et la formater correctement. Explication:

 θ                  Input `C`
Ｅ                   Map over implicit range
      θ             Input `C`
     Ｅ              Map over implicit range
          λ         Inner index
         ι          Outer index
       ⌈⟦  ⟧        Maximium
    Ｅ               Map over results
              λ     Current value
               η    Input `S`
             ‹      Less than
                 λ  Current value
                ⊕   Incremented
            ∧       Logical AND
   Ｉ                Cast to string
  ⪫                 Join with spaces
                    Implicitly print on separate lines

— Neil
source

1

Nettoyer , 67 octets

import StdEnv
$n s=[[if(i>s||j>s)0(max i j)\\i<-[1..n]]\\j<-[1..n]]

Essayez-le en ligne!

Définit $ :: Int Int -> [[Int]]donner une réponse en utilisant l'indexation basée sur 1.

— Οurous
source

1

Perl 6 , 37 octets

{((^$^c+1 Xmax^$c+1)Xmin$^s+1)X%$s+1}

Essayez-le en ligne!

Renvoie la matrice sous forme de tableau à 1 dimension.

— nwellnhof
source

0

Mathematica 44 octets

Table[If[i <= s && j <= s, Max[i, j], 0], {i, c}, {j, c}]

— David G. Stork
source

Êtes-vous certain que l'espace est nécessaire? Je ne peux pas tester Mathematica mais je ne pense pas.

— Post Rock Garf Hunter

Réduire les matrices

Gelée , 8 octets

Comment ça fonctionne

R , 47 41 octets

Octave , 31 octets

Haskell , 47 45 octets

Explication

APL (Dyalog) , 12 octets

JavaScript (ES6), 61 octets

Gelée , 6 octets

Comment?

Java 10, 88 octets

PHP , 92 octets

Stax , 10 octets

Excel VBA, 65 octets

Entrée sortie

J , 18 octets

MATLAB, 58 octets (Merci à un utilisateur anonyme)

C # (.NET Core) , 85 octets

Python 2 , 58 octets

Fusain , 19 octets

Nettoyer , 67 octets

Perl 6 , 37 octets

Mathematica 44 octets