Matrice avec 1 à L (n), dans toutes les n colonnes

18

Défi:

Prenez une liste, L contenant des entiers positifs en entrée:

3 5 2 1 6

et créer une matrice où la nième colonne contient le vecteur 1: L (n) , où les lignes plus courtes sont remplies de zéros.

Cas de test:

3   5   2   1   6
-----------------
1   1   1   1   1
2   2   2   0   2
3   3   0   0   3
0   4   0   0   4
0   5   0   0   5
0   0   0   0   6

1
-
1

1   2   3   4   3   2   1
-------------------------
1   1   1   1   1   1   1
0   2   2   2   2   2   0
0   0   3   3   3   0   0
0   0   0   4   0   0   0

Règles:

  • Formats d'entrée et de sortie en option
    • La liste des listes est un format de sortie acceptable
  • La matrice doit être aussi petite que possible (vous ne pouvez pas la remplir avec plus de zéros que nécessaire)
  • Le code le plus court dans chaque langue gagne
  • Les explications sont fortement encouragées
code-golf  matrix 
— Stewie Griffin
source
Pouvons-nous plutôt distribuer les plages horizontalement?
— M. Xcoder
Non, ils doivent être verticaux. Si vous utilisez une langue où les mots horizontal / vertical n'ont aucune signification, alors c'est facultatif. (Peut être pertinent pour les langues où les listes de listes ne sont associées à aucune direction horizontale / verticale)
— Stewie Griffin
1
@StewieGriffin Quel langage sensé n'associe pas les dimensions aux listes imbriquées?
— Erik the Outgolfer du
4
@EriktheOutgolfer, Combien de langues insensées sont utilisées sur ce site?
— Stewie Griffin, le
2
@EriktheOutgolfer R, pour sa part, ne considère pas les matrices comme une liste imbriquée, mais plutôt une longue liste, qui se déroule en ligne.
— JAD

Réponses:

18

R , 40 38 octets

function(l)outer(m<-1:max(l),l,"<=")*m

Essayez-le en ligne!

Explication:

outerapplique son troisième argument (la fonction) à toutes les combinaisons d'éléments de ses deux premiers arguments, générant une matrice de TRUEet FALSEoù chaque colonne a TRUEoù 1:max(l)est inférieur ou égal à l'élément correspondant de l, par exemple où l=c(3,5,2,1,6):

      [,1]  [,2]  [,3]  [,4] [,5]
[1,]  TRUE  TRUE  TRUE  TRUE TRUE
[2,]  TRUE  TRUE  TRUE FALSE TRUE
[3,]  TRUE  TRUE FALSE FALSE TRUE
[4,] FALSE  TRUE FALSE FALSE TRUE
[5,] FALSE  TRUE FALSE FALSE TRUE
[6,] FALSE FALSE FALSE FALSE TRUE

Supposons alors que la matrice résultante est A, puis A*m-> A[i,j]=A[i,j]*iqui contraint TRUEà 1 et FALSEà 0, produisant le résultat souhaité.

— Giuseppe
source
Je pense - vous pouvez économiser 2 octets, en remplaçant function(l)parl=scan();
— AndriusZ
@AndriusZ mais alors je devrais tout emballer dans un printafin de perdre ces octets.
— Giuseppe
Je pense que vous n'avez pas besoin de tout emballer - TOI
— AndriusZ
2
@AndriusZ, nous en avons définitivement parlé auparavant. La seule réponse à cette méta-question donne une pénalité de +4 pour l'utilisation source(...,echo=TRUE)et la lecture de stdin en tant que programme complet, si vous avez une suggestion alternative, pesez certainement là-dedans, mais pour autant que je sache, c'est le plus proche que nous avons à un consensus R sur les programmes complets et il est pour le moment.
— Giuseppe
Tard dans le jeu: économisez deux octets en utilisant [cette astuce] ( codegolf.stackexchange.com/a/111578/80010 )
— JayCe
7

MATL , 8 octets

"@:]Xho!

Essayez-le en ligne!

Explication

"      % Implicit input, L. For each k in L
  @    %   Push k
  :    %   Range [1 2 ... k]
]      % End
Xh     % Collect all stack contents in a cell array
o      % Convert to double matrix. The content of each cell is
       % right-padded with zeros if needed
!      % Transpose. Implicitly display
— Luis Mendo
source
5

Mathematica, 20 octets

PadRight@Range@#&

Contient U + F3C7 ( Transposefonction intégrée de Mathematica )

Essayez-le sur Wolfram Sandbox

Usage

PadRight@Range@#&[{3, 5, 2, 1, 6}]

{
 {1, 1, 1, 1, 1},
 {2, 2, 2, 0, 2},
 {3, 3, 0, 0, 3},
 {0, 4, 0, 0, 4},
 {0, 5, 0, 0, 5},
 {0, 0, 0, 0, 6}
}

Explication

PadRight@Range@#&

         Range@#    (* Generate {1..n} for all elements of input *)
PadRight@           (* Right-pad 0s so that all lists are equal length *)
                   (* Transpose the result *)
— JungHwan Min
source
@downvoters pourquoi les downvotes? Pourriez-vous tous expliquer?
— JungHwan Min
Je n'ai pas downvote, mais je soupçonne que c'est parce que vous n'avez pas la signature de fonction ou une entrée d'arguments, ce qui fait que votre extrait de code n'est pas une boîte noire!
— sergiol
5

Octave , 26 octets

@(x)((y=1:max(x))'<=x).*y'

Fonction anonyme qui entre un vecteur ligne et sort une matrice.

Essayez-le en ligne!

Explication

Tenez compte des commentaires x = [3 5 2 1 6]. Il s'agit d'un vecteur ligne de taille 1 × 5.

1:max(x)donne le vecteur ligne [1 2 3 4 5 6], qui est affecté à la variable y.

La transposition de celui-ci, c'est-à-dire le vecteur colonne [1; 2; 3; 4; 5; 6], est <=comparée (élément par élément avec diffusion) à l'entrée [3 5 2 1 6]. Le résultat est la matrice 6 × 5

[1 1 1 1 1;
 1 1 1 0 1;
 1 1 0 0 1;
 0 1 0 0 1;
 0 1 0 0 1;
 0 0 0 0 1]

Enfin, la multiplication (par élément avec diffusion) par le vecteur colonne [1; 2; 3; 4; 5; 6], obtenu tel que ytransposé, donne le résultat souhaité:

[1 1 1 1 1;
 2 2 2 0 2;
 3 3 0 0 3;
 0 4 0 0 4;
 0 5 0 0 5;
 0 0 0 0 6]
— Luis Mendo
source
1
J'espérais voir une soumission MATLAB / Octave. J'ai implémenté cela sans y penser, donc c'était probablement plus de 40 octets. Très belle solution :)
— Stewie Griffin
3

Pyth , 6 octets

.tSMQZ

Essayez-le ici! ou Vérifiez tous les cas de test (avec une jolie impression)!

Explication

.tSMQZ - Programme complet.

  SMQ - Obtenez les plages unaires inclusives pour chacune.
.t - Transposer, rembourrage avec copies de ...
     Z - ... Zéro.
         - Impression implicite.

Une version de transposition non intégrée serait :

mm*hd<dkQeS

Cela fonctionne comme suit:

mm*hd<dkQeS   - Full program.

m        eS   - Map over [0, max(input)) with a variable d.
 m      Q     - Map over the input with a variable k.
   hd         - d + 1.
  *           - Multiplied by 1 if...
     <dk      - ... d is smaller than k, else 0.
              - Output implicitly.
— M. Xcoder
source
3

En fait , 17 octets

;M╗♂R⌠╜;0@α(+H⌡M┬

Essayez-le en ligne!

Explication:

;M╗♂R⌠╜;0@α(+H⌡M┬
;M╗                store the maximal element (M) of the input in register 0
   ♂R              range(1, n+1) for each n in input
     ⌠╜;0@α(+H⌡M   for each range:
      ╜;0@α          push a list containing M 0s
           (+        append to range
             H       take first M elements
                ┬  transpose
— Mego
source
Oui, en fait, a besoin d'un zip avec un support de rembourrage ...
— Erik the Outgolfer
2

Pyke , 3 octets

Cela utilise la nouvelle fonctionnalité de Pyke, les encodages hexadécimaux ... La meilleure partie est que nous lions Jelly! Octets bruts:

4D 53 AC

Essayez-le ici!

L'équivalent ASCII-Pyke serait de 4 octets :

MS.,

Comment?

4D 53 AC - Programme complet.

4D - Carte.
   53 - Gamme inclusive.
      AC - Transposer avec des zéros.
           - Sortie implicitement.

-------------------------------------

MS., - Programme complet.

M - Carte.
 S - Gamme inclusive.
  ., - Transposer avec des zéros.
       - Sortie implicitement.

Voici une jolie version imprimée avec ASCII, et voici une avec des encodages hexadécimaux.

— M. Xcoder
source
2

Perl 6 , 39 octets

{zip (1 X..$_).map:{|@_,|(0 xx.max-1)}}

Essayez-le

Étendu:

{                # bare block lambda with implicit parameter ｢$_｣

  zip

    (1 X.. $_)   # turn each input into a Range that starts with 1

    .map:        # map each of those Ranges using the following code

    {            # bare block lambda with implicit parameter ｢@_｣ 
                 # (｢@_｣ takes precedence over ｢$_｣ when it is seen)

      |@_,       # slip the input into a new list

      |(         # slip this into the list

        0        # a ｢0｣
        xx       # list repeated by

          .max   # the max of ｢$_｣ (implicit method call)
          - 1    # minus 1 (so that zip doesn't add an extra row)
      )
    }
}

Notez que se ziptermine une fois que la liste d'entrée la plus courte est épuisée.

— Brad Gilbert b2gills
source
2

C # , 136 octets

Les données

  • Entrée Int32[] i Un tableau d'entiers
  • Sortie Int32[,] Un tableau bidimentionnel.

Golfé

i=>{int m=System.Linq.Enumerable.Max(i),l=i.Length,x,y;var o=new int[m,l];for(y=0;y<m;y++)for(x=0;x<l;)o[y,x]=i[x++]>y?y+1:0;return o;};

Non golfé

i => {
    int
        m = System.Linq.Enumerable.Max( i ),
        l = i.Length,
        x, y;

    var o = new int[ m, l ];

    for( y = 0; y < m; y++ )
        for( x = 0; x < l; )
            o[ y, x ] = i[ x++ ] > y ? y + 1 : 0;

    return o;
};

Non lisible non lisible

// Take an array of Int32
i => {

    // Store the max value of the array, the length and declare some vars to save some bytes
    int
        m = System.Linq.Enumerable.Max( i ),
        l = i.Length,
        x, y;

    // Create the bidimensional array to output
    var o = new int[ m, l ];

    // Cycle line by line...
    for( y = 0; y < m; y++ )

        // ... and column by column...
        for( x = 0; x < l; )

            // And set the value of the line in the array if it's lower than the the value at the index of the input array
            o[ y, x ] = i[ x++ ] > y ? y + 1 : 0;

    // Return the bidimentional array.
    return o;
};

Code complet

using System;
using System.Collections.Generic;

namespace TestBench {
    public class Program {
        // Methods
        static void Main( string[] args ) {
            Func<Int32[], Int32[,]> f = i => {
                int
                    m = System.Linq.Enumerable.Max( i ),
                    l = i.Length,
                    x, y;
                var o = new int[ m, l ];
                for( y = 0; y < m; y++ )
                    for( x = 0; x < l; )
                        o[ y, x ] = i[ x++ ] > y ? y + 1 : 0;
                return o;
            };

            List<Int32[]>
                testCases = new List<Int32[]>() {
                    new[] { 1, 2, 5, 6, 4 },
                    new[] { 3, 5, 2, 1, 6 },
                    new[] { 1, 2, 3, 4, 3, 2, 1 },
                };

            foreach( Int32[] testCase in testCases ) {
                Console.WriteLine( " INPUT: " );
                PrintArray( testCase );

                Console.WriteLine( "OUTPUT: " );
                PrintMatrix( f( testCase ) );
            }

            Console.ReadLine();
        }

        public static void PrintArray<TSource>( TSource[] array ) {
            PrintArray( array, o => o.ToString() );
        }
        public static void PrintArray<TSource>( TSource[] array, Func<TSource, String> valueFetcher ) {
            List<String>
                output = new List<String>();

            for( Int32 index = 0; index < array.Length; index++ ) {
                output.Add( valueFetcher( array[ index ] ) );
            }

            Console.WriteLine( $"[ {String.Join( ", ", output )} ]" );
        }

        public static void PrintMatrix<TSource>( TSource[,] array ) {
            PrintMatrix( array, o => o.ToString() );
        }
        public static void PrintMatrix<TSource>( TSource[,] array, Func<TSource, String> valueFetcher ) {
            List<String>
                output = new List<String>();

            for( Int32 xIndex = 0; xIndex < array.GetLength( 0 ); xIndex++ ) {
                List<String>
                    inner = new List<String>();

                for( Int32 yIndex = 0; yIndex < array.GetLength( 1 ); yIndex++ ) {
                    inner.Add( valueFetcher( array[ xIndex, yIndex ] ) );
                }

                output.Add( $"[ {String.Join( ", ", inner )} ]" );
            }

            Console.WriteLine( $"[\n   {String.Join( ",\n   ", output )}\n]" );
        }
    }
}

Communiqués

  • v1.0 - 136 bytes- Solution initiale.

Remarques

  • Aucun
— auhmaan
source
1

Java 10, 115 octets

a->{int l=a.length,m=0;for(int j:a)m=j>m?j:m;var r=new int[m][l];for(;l-->0;)for(m=0;m<a[l];r[m][l]=++m);return r;}

Explication:

Essayez-le en ligne.

a->{                  // Method with integer-array parameter and integer-matrix return-type
  int l=a.length,     //  Length of the array
      m=0;            //  Largest integer in the array, 0 for now
  for(int j:a)        //  Loop over the array
    m=j>m?            //   If the current item is larger than `m`:
       j              //    Set `m` to this item as new max
      :               //   Else:
       m;             //    Leave `m` the same
  var r=new int[m][l];//  Result-matrix of size `m` by `l`, filled with zeroes by default
  for(;l-->0;)        //  Loop over the columns
    for(m=0;m<a[l];   //   Inner loop over the rows
      r[m][l]=++m);   //    Set the cell at position `m,l` to `m+1`
  return r;}          //  Return the result-matrix
— Kevin Cruijssen
source
0

Proton , 38 octets

a=>[[i<j?-~i:0for j:a]for i:0..max(a)]

Essayez-le en ligne!

— HyperNeutrino
source
Laissez-moi deviner, le bug est l'espace après ça?
— caird coinheringaahing
@cairdcoinheringaahing Oui. Le point d'interrogation consommera le caractère après lui pour s'assurer qu'il ne s'agit pas d'un autre point d'interrogation, mais j'ai oublié de compenser le caractère supplémentaire entraînant son saut.
— HyperNeutrino
Il semble que vous ayez tiré, vous pouvez maintenant supprimer l'avis :)
— Erik the Outgolfer
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.