Matrix mit 1 bis L (n) in allen n Spalten

18

Herausforderung:

Nehmen Sie eine Liste, L mit positiven ganzen Zahlen als Eingabe:

3 5 2 1 6

und erstellen Sie eine Matrix, in der die n-te Spalte den Vektor 1: L (n) enthält , wobei kürzere Zeilen mit Nullen aufgefüllt werden.

Testfälle:

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

Regeln:

  • Optionale Eingabe- und Ausgabeformate
    • Listenliste ist ein akzeptables Ausgabeformat
  • Die Matrix muss so klein wie möglich sein (Sie dürfen sie nicht mit mehr Nullen als nötig auffüllen)
  • Der kürzeste Code in jeder Sprache gewinnt
  • Erklärungen sind ausdrücklich erwünscht
code-golf  matrix 
— Stewie Griffin
quelle
Dürfen wir die Bereiche stattdessen horizontal verteilen?
— Mr. Xcoder
Nein, sie sollten vertikal sein. Wenn Sie eine Sprache verwenden, in der die Wörter horizontal / vertikal keine Bedeutung haben, ist dies optional. (Könnte für Sprachen relevant sein, in denen Listen mit keiner horizontalen / vertikalen Richtung verknüpft sind.)
— Stewie Griffin
1
@StewieGriffin Welche vernünftige Sprache verknüpft Dimensionen nicht mit verschachtelten Listen?
— Erik der Outgolfer
4
@EriktheOutgolfer, Wie viele verrückte Sprachen werden auf dieser Site verwendet?
— Stewie Griffin
2
@EriktheOutgolfer R sieht Matrizen nicht als verschachtelte Liste, sondern als lange Liste, die zeilenweise umbrochen wird.
— JAD

Antworten:

18

R , 40 38 Bytes

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

Probieren Sie es online!

Erläuterung:

outerWendet sein drittes Argument (die Funktion) auf alle Elementkombinationen seiner ersten beiden Argumente an und generiert eine Matrix von TRUEund FALSEwobei jede Spalte enthält, TRUEwo 1:max(l)kleiner oder gleich dem entsprechenden Element von list. Beispiel 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

Angenommen, die resultierende Matrix ist Adann A*m->, A[i,j]=A[i,j]*iwas TRUEauf 1 und FALSEauf 0 zwingt und das gewünschte Ergebnis erzeugt.

— Giuseppe
quelle
Ich glaube - Sie 2 Bytes speichern kann, durch den Austausch function(l)mitl=scan();
— AndriusZ
@AndriusZ aber dann müsste ich alles in eine umschließen, printdamit ich diese Bytes verliere.
— Giuseppe
Ich denke, Sie müssen nicht alles
— einpacken
2
@AndriusZ darüber haben wir definitiv schon gesprochen. Die einzige Antwort auf diese Meta-Frage gibt eine Strafe von +4 für die Verwendung source(...,echo=TRUE)und das Lesen von stdin als volles Programm, wenn Sie einen alternativen Vorschlag haben zu einem R-Konsens über vollständige Programme und es steht vorerst.
— Giuseppe
— JayCe
7

MATL , 8 Bytes

"@:]Xho!

Probieren Sie es online!

Erläuterung

"      % 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
quelle
5

Mathematica, 20 Bytes

PadRight@Range@#&

Enthält U + F3C7 (eingebaute Mathematica- TransposeFunktion)

Probieren Sie es auf Wolfram Sandbox

Verwendung

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

Erläuterung

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
quelle
@Downvoters warum die Downvotes? Kannst du das erklären?
— JungHwan Min
Ich habe nicht abgelehnt, aber ich vermute, es liegt daran, dass Ihnen die Funktionssignatur oder die Eingabe von Argumenten fehlt, was dazu führt, dass Ihr Code-Snippet keine Black Box ist!
— Sergiol
5

Oktave , 26 Bytes

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

Anonyme Funktion, die einen Zeilenvektor eingibt und eine Matrix ausgibt.

Probieren Sie es online!

Erläuterung

Betrachten Sie die Eingabe x = [3 5 2 1 6]. Dies ist ein Zeilenvektor der Größe 1 × 5.

1:max(x)gibt den Zeilenvektor an [1 2 3 4 5 6], der der Variablen zugeordnet ist y.

Die Transponierte davon, dh der Spaltenvektor [1; 2; 3; 4; 5; 6], wird <=(elementweise mit Broadcast) mit der Eingabe verglichen [3 5 2 1 6]. Das Ergebnis ist die 6 × 5-Matrix

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

Schließlich ergibt das Multiplizieren (elementweise mit Rundsendung) mit dem Spaltenvektor [1; 2; 3; 4; 5; 6], der wie ytransponiert erhalten wird, das gewünschte Ergebnis:

[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
quelle
1
Ich hatte gehofft, eine MATLAB / Octave-Einreichung zu sehen. Ich habe das implementiert, ohne darüber nachzudenken, also waren es wahrscheinlich mehr als 40 Bytes. Sehr schöne Lösung :)
— Stewie Griffin
3

Pyth , 6 Bytes

.tSMQZ

Probieren Sie es hier aus! oder Überprüfen Sie alle Testfälle (mit Pretty-Print)!

Erläuterung

.tSMQZ - Volles Programm.

  SMQ - Holen Sie sich die einschließlichen unären Bereiche für jeden.
.t - Transponieren, Auffüllen mit Kopien von ...
     Z - ... Null.
         - Impliziter Druck.

Eine nicht eingebaute transponierte Version wäre :

mm*hd<dkQeS

Das funktioniert wie folgt:

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.
— Mr. Xcoder
quelle
3

Eigentlich 17 Bytes

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

Probieren Sie es online!

Erläuterung:

;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
quelle
Ja, eigentlich braucht Reißverschluss mit Polsterunterstützung ...
— Erik the Outgolfer
2

Pyke , 3 Bytes

Dies nutzt die neue Funktion von Pyke, Hex-Codierungen ... Das Beste daran ist, dass wir Jelly binden! Rohe Bytes:

4D 53 AC

Probieren Sie es hier aus!

Das ASCII-Pyke-Äquivalent wäre 4 Bytes :

MS.,

Wie?

4D 53 AC - Volles Programm.

4D - Karte.
   53 - Inklusivangebot.
      AC - Mit Nullen transponieren.
           - Implizit ausgeben.

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

MS., - Volles Programm.

M - Karte.
 S - Inklusivangebot.
  ., - Mit Nullen transponieren.
       - Implizit ausgeben.

Hier ist eine hübsche Druckversion mit ASCII, und hier ist eine mit Hex-Codierungen.

— Mr. Xcoder
quelle
2

Perl 6 , 39 Bytes

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

Versuch es

Erweitert:

{                # 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)
      )
    }
}

Beachten Sie, dass zipder Vorgang beendet wird, sobald die Liste der kürzesten Eingaben erschöpft ist.

— Brad Gilbert b2gills
quelle
2

C # , 136 Bytes

Daten

  • Eingabe Int32[] i Ein Array von Ints
  • Ausgabe Int32[,] Ein bidimentionales Array.

Golf gespielt

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;};

Ungolfed

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;
};

Ungolfed lesbar

// 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;
};

Vollständiger Code

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]" );
        }
    }
}

Releases

  • v1.0 - 136 bytes- Anfangslösung.

Anmerkungen

  • Keiner
— auhmaan
quelle
1

Java 10, 115 Bytes

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;}

Erläuterung:

Probieren Sie es online aus.

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
quelle
0

Proton , 38 Bytes

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

Probieren Sie es online!

— HyperNeutrino
quelle
Lassen Sie mich raten, der Fehler ist der Raum danach?
— Caird Coinheringaahing
@cairdcoinheringaahing Ja. Das Fragezeichen verbraucht das nachfolgende Zeichen, um sicherzustellen, dass es sich nicht um ein weiteres Fragezeichen handelt. Ich habe jedoch vergessen, das zusätzliche Zeichen zu kompensieren, das zum Überspringen des Zeichens geführt hat.
— HyperNeutrino
Scheint, als hätten Sie einen
— Ruck bekommen
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.