Thử thách:

Lấy danh sách, L chứa số nguyên dương làm đầu vào:

3 5 2 1 6

và tạo một ma trận trong đó cột thứ n chứa vectơ 1: L (n) , trong đó các hàng ngắn hơn được đệm bằng các số không.

Các trường hợp thử nghiệm:

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

Quy tắc:

• Các định dạng đầu vào và đầu ra tùy chọn
  • Danh sách danh sách là một định dạng đầu ra chấp nhận được
• Ma trận phải càng nhỏ càng tốt (bạn không thể đệm nó với nhiều số không hơn mức cần thiết)
• Mã ngắn nhất trong mỗi ngôn ngữ sẽ thắng
• Giải thích rất được khuyến khích

R , 40 38 byte

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

Hãy thử trực tuyến!

Giải trình:

outeráp dụng đối số thứ ba (hàm) cho tất cả các kết hợp các phần tử của hai đối số đầu tiên của nó, tạo ra một ma trận TRUEvà FALSEtrong đó mỗi cột có TRUEvị trí 1:max(l)nhỏ hơn hoặc bằng phần tử tương ứng của l, ví dụ 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

Sau đó, giả sử ma trận kết quả là A, sau đó A*m-> A[i,j]=A[i,j]*isẽ ép TRUEthành 1 và FALSE0, tạo ra kết quả mong muốn.

MATL , 8 byte

"@:]Xho!

Hãy thử trực tuyến!

Giải trình

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

Python 3 , 54 byte

lambda x:[[-~i*(i<a)for a in x]for i in range(max(x))]

Hãy thử trực tuyến!

Toán học, 20 byte

PadRight@Range@#&

Chứa U + F3C7 ( TransposeHàm dựng sẵn của Mathicala )

Dùng thử trên Wolfram Sandbox

Sử dụng

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

Giải trình

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 *)

Octave , 26 byte

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

Hàm ẩn danh nhập vào một vectơ hàng và xuất ra một ma trận.

Hãy thử trực tuyến!

Giải trình

Xem xét đầu vào x = [3 5 2 1 6]. Đây là một vectơ hàng có kích thước 1 × 5.

1:max(x)đưa ra vectơ hàng [1 2 3 4 5 6], được gán cho biến y.

Sự hoán vị của điều đó, tức là vectơ cột [1; 2; 3; 4; 5; 6], được tính <=toán (yếu tố khôn ngoan với phát sóng) với đầu vào [3 5 2 1 6]. Kết quả là ma trận 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]

Cuối cùng, nhân (phần tử khôn ngoan với phát sóng) với vectơ cột [1; 2; 3; 4; 5; 6], thu được dưới dạng ychuyển vị, cho kết quả mong muốn:

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

05AB1E , 4 byte

€L0ζ

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm được định dạng độc đáo

€L   # For each: get the range 1..input
  0ζ # zip, padding with 0s

Husk , 4 byte

Trả về danh sách các danh sách

T0mḣ

Hãy thử trực tuyến!

Giải trình

  m    Map over the input
   ḣ   Range from 1 to n
T0     Transpose, padding with 0s

Bình thường , 6 byte

.tSMQZ

Hãy thử nó ở đây! hoặc Xác minh tất cả các trường hợp thử nghiệm (với bản in đẹp)!

Giải trình

.tSMQZ - Chương trình đầy đủ.

  SMQ - Nhận phạm vi unary bao gồm cho mỗi.
.t - Chuyển vị, đệm với các bản sao của ...
     Z - ... Không.
         - In ngầm.

Một phiên bản chuyển đổi không tích hợp sẽ là :

mm*hd<dkQeS

Điều này hoạt động như sau:

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.

Thạch , 3 byte

Rz0

Hãy thử trực tuyến!

Giải trình

Rz0  Input: array A
R    Range, vectorizes to each integer
 z0  Transpose and fill with 0

Trên thực tế , 17 byte

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

Hãy thử trực tuyến!

Giải trình:

;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

Pyke , 3 byte

Điều này sử dụng tính năng mới của Pyke, mã hóa hex ... Phần tốt nhất là chúng ta buộc Jelly! Byte thô:

4D 53 AC

Hãy thử nó ở đây!

Tương đương ASCII-Pyke sẽ là 4 byte :

MS.,

Làm sao?

4D 53 AC - Chương trình đầy đủ.

4D - Bản đồ.
   53 - Phạm vi bao gồm.
      AC - Chuyển vị với số không.
           - Đầu ra ngầm.

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

MS., - Chương trình đầy đủ.

M - Bản đồ.
 S - Phạm vi bao gồm.
  ., - Chuyển vị với số không.
       - Đầu ra ngầm.

Đây là một phiên bản in đẹp với ASCII, và đây là một phiên bản có mã hóa hex.

Perl 6 , 39 byte

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

Thử nó

Mở rộng:

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

Lưu ý rằng zipchấm dứt khi danh sách đầu vào ngắn nhất đã hết.

C # , 136 byte

Dữ liệu

• Đầu vào Int32[] i Một mảng các số nguyên
• Đầu ra Int32[,] Một mảng hai chiều.

Chơi gôn

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

Ung dung

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 có thể đọc được

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

Mã đầy đủ

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

Phát hành

• v1.0 - 136 bytes- Giải pháp ban đầu.

Ghi chú

• không ai

C (gcc) , 142 byte

i,j,k;main(c,v)char**v;{for(;++i<c;k=k<*v[i]?*v[i]:k)printf("%c ",*v[i]);for(i=48;puts(""),i++<k;)for(j=1;j<c;)printf("%c ",i<=*v[j++]?i:48);}

Hãy thử trực tuyến!

Java 10, 115 byte

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

Giải trình:

Hãy thử trực tuyến.

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

Perl 5 , 62 + 1 ( -a) = 63 byte

$,=$";map$m=$_>$m?$_:$m,@F;say map$_&&$_--&&$i,@F while$i++-$m

Hãy thử trực tuyến!

Proton , 38 byte

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

Hãy thử trực tuyến!

Thêm ++ , 37 byte

D,g,@@*,bL_1+0XA$p$+bUp
L~*,€RAbM€gBc

Hãy thử trực tuyến!

JavaScript (Node.js) , 55 byte

x=>f=(t=1,s,e=x.map(y=>y<t?0:s|=t))=>s?[e,...f(++t)]:[]

Hãy thử trực tuyến!

JavaScript (Node.js) , 63 byte

x=>[...Array(Math.max(...x,t=0))].map(_=>x.map(y=>y<t?0:t,++t))

Hãy thử trực tuyến!