挑战：

取一个列表，L包含正整数作为输入：

3 5 2 1 6

并创建一个矩阵，其中第n列包含矢量1：L（n），其中较短的行用零填充。

测试用例：

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

规则：

可选的输入和输出格式
- 列表列表是可接受的输出格式
矩阵必须尽可能小（您可能无法用比所需更多的零填充）
每种语言中最短的代码获胜
鼓励解释

code-golf matrix

— 斯蒂夫·格里芬
source

我们可以改为水平分布范围吗？

— Xcoder先生17年

不，它们应该是垂直的。如果您使用的语言中“水平/垂直”一词没有任何意义，那么它是可选的。（可能与列表的列表不与水平/垂直方向相关的语言有关）

— Stewie Griffin

1

@StewieGriffin哪种理智的语言无法将尺寸与嵌套列表相关联？

— Erik the Outgolfer

4

@EriktheOutgolfer，此网站上使用了几种疯狂的语言？

— Stewie Griffin

2

@EriktheOutgolfer R不会将矩阵视为嵌套列表，而会将一个长列表视为逐行包装。

— JAD

18

R，40 38字节

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

在线尝试！

说明：

outer应用它的第三个参数（函数），以它的前两个参数元素的所有组合，产生的矩阵TRUE和FALSE每列具有TRUE其中1:max(l)是小于或等于相应的元件l，用于示例，其中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

然后假设结果矩阵为A，然后A*m-> A[i,j]=A[i,j]*i强制TRUE为1和FALSE0，产生所需的结果。

— 朱塞佩
source

我认为-您可以节省2个字节，而替换function(l)为l=scan();

— AndriusZ

@AndriusZ，但随后我必须将所有内容包装在a中，print这样我会丢失那些字节。

— Giuseppe

我想，你不需要换行的一切- TOI

— AndriusZ

2

@AndriusZ我们之前肯定已经讨论过。对于这个元问题，唯一的答案是将source(...,echo=TRUE)stdin作为完整程序使用和读取，如果您有其他建议，请在其中加4磅的罚款，但据我所知，这是我们拥有的最接近的建议在整个程序上达成R共识，这是暂时的。

— 朱塞佩

游戏后期：使用[this tip]（codegolf.stackexchange.com/a/111578/80010）保存两个字节

— JayCe

7

MATL，8字节

"@:]Xho!

在线尝试！

说明

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

— 路易斯·门多
source

6

Python 3，54个字节

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

在线尝试！

— 哈佛哈默尔
source

5

Mathematica，20个字节

PadRight@Range@#&

包含U + F3C7（Mathematica的内置Transpose函数）

在Wolfram Sandbox上尝试

用法

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

说明

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

— 郑焕民
source

@downvoters为什么要投票？你们可以解释吗？

— JungHwan Min'9

我没有拒绝投票，但我怀疑这是因为您缺少函数签名或参数输入，这导致您的代码片段不是黑匣子！

— sergiol

5

八度，26字节

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

输入行向量并输出矩阵的匿名函数。

在线尝试！

说明

考虑输入x = [3 5 2 1 6]。这是大小为1×5的行向量。

1:max(x)给出行向量[1 2 3 4 5 6]，该向量被分配给变量y。

的所述转置的，即列向量[1; 2; 3; 4; 5; 6]，是<=-compared（逐元素与广播）与输入[3 5 2 1 6]。结果是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]

最后，将转置后[1; 2; 3; 4; 5; 6]获得的列向量乘以（逐个广播），即可得到y所需的结果：

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

— 路易斯·门多
source

1

我希望看到MATLAB / Octave提交。我在没有考虑的情况下实现了此功能，因此它可能超过40个字节。非常好的解决方案:)

— Stewie Griffin

4

05AB1E，4个字节

€L0ζ

在线尝试！或作为格式正确的测试套件

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

— 赖利
source

3

外壳，4个字节

返回列表列表

T0mḣ

在线尝试！

说明

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

— 普维兹
source

3

Pyth，6个字节

.tSMQZ

在这里尝试！或验证所有测试用例（打印精美）！

说明

.tSMQZ-完整程序。

  SMQ-获取每个的包含一元范围。
.t-转置，填充...的副本
     Z-...为零。
         -隐式打印。

非内置的转置版本为：

mm*hd<dkQeS

其工作原理如下：

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.

— Xcoder先生
source

3

果冻，3个字节

Rz0

在线尝试！

说明

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

— 英里
source

3

其实是17个位元组

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

在线尝试！

说明：

;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

— 梅果
source

是的，实际上实际上需要拉链和衬垫支持...

— Erik the Outgolfer

2

派克（Pyke），3个字节

它使用了Pyke的新功能，即十六进制编码...最好的部分是我们将Jelly绑起来了！原始字节：

4D 53 AC

在这里尝试！

ASCII-Pyke等效为4个字节：

MS.,

怎么样？

4D 53 AC-完整程序。

4D-地图。
   53-包含范围。
      AC-用零换位。
           -隐式输出。

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

MS。-完整程序。

M-地图。
 S-包含范围。
  。，-用零换位。
       -隐式输出。

这是带有ASCII的精美印刷版本，这是带有十六进制编码的版本。

— Xcoder先生
source

2

Perl 6，39个字节

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

尝试一下

展开：

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

请注意，zip一旦用尽最短的输入列表，该操作就会终止。

— 布拉德·吉尔伯特b2gills
source

2

C＃，136字节

数据

输入 Int32[] i一个整数数组
输出 Int32[,]一个双向数组。

打高尔夫球

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

不打高尔夫球

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

非高尔夫可读

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

完整代码

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

发布

1.0 - 136 bytes-初始溶液。

笔记

没有

— 奥马
source

1

C（gcc），142字节

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

在线尝试！

— 克莱布朗
source

1

Java 10，115个字节

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

说明：

在线尝试。

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

— 凯文·克鲁伊森
source

0

Perl 5，62 + 1（`-a`）= 63字节

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

在线尝试！

— Xcali
source

0

质子 38字节

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

在线尝试！

— 超中微子
source

让我猜猜，bug是后面的空间吗？

— caird coinheringaahing

@cairdcoinheringaahing是的。问号将消耗掉它后面的字符，以确保它不是另一个问号，但是我忘记补偿多余的字符，从而导致该字符被跳过。

— HyperNeutrino

似乎您受到了

— 打击

0

加++，37字节

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

在线尝试！

— 开斋节
source

0

JavaScript（Node.js），55字节

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

在线尝试！

JavaScript（Node.js），63字节

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

在线尝试！

— 平方米
source

在所有n列中具有1到L（n）的矩阵

挑战：

测试用例：

规则：

R，40 38字节

MATL，8字节

说明

Python 3，54个字节

Mathematica，20个字节

用法

说明

八度，26字节

说明

05AB1E，4个字节

外壳，4个字节

说明

Pyth，6个字节

说明

果冻，3个字节

说明

其实是17个位元组

派克（Pyke），3个字节

怎么样？

Perl 6，39个字节

展开：

C＃，136字节

数据

打高尔夫球

不打高尔夫球

非高尔夫可读

完整代码

发布

笔记

C（gcc），142字节

Java 10，115个字节

Perl 5，62 + 1（-a）= 63字节

质子 38字节

加++，37字节

JavaScript（Node.js），55字节

JavaScript（Node.js），63字节

Perl 5，62 + 1（`-a`）= 63字节