在此挑战中，您将获得四个不同但有些相关的任务，必须以特定的方式解决它们。首先，我将解释任务，然后解释如何解决它。

您的代码在所有四个任务中都应使用两个正整数作为输入：n,m，其中n<m。所有任务必须以相同的语言解决。矩阵的方向是可选的（n×m可以解释为“ n行，m列”或“ n列，m行”）。

任务1：

创建（并输出/打印）由以下元素组成的矢量/列表：n, n+1 ... m-1, m。因此，对于n=4, m=9，您应该输出：4,5,6,7,8,9。

任务2：

创建（并输出/打印）矩阵/数组/列表列表（或等效列表），如下所示：

n,   n+1, ... m-1, m
n+1, n+2, ... m-1, m+1
...
n+m, n+m+1, ... 2*m-1, 2*m

对于n=4, m=9您应该输出：

4, 5, 6, 7, 8, 9
5, 6, 7, 8, 9, 10
...
13, 14, 15, 16, 17, 18

任务3：

创建（并输出/打印）n×m乘法表（采用任何合适的格式）。示例n=4, m=9：

1   2   3  4
2   4   6  8
3   6   9  12
4   8  12  16
5  10  15  20
6  12  18  24
7  14  21  28
8  16  24  32
9  18  27  36

任务4：

输出/打印由任务3的乘法表中的元素组成的矢量/列表，并按升序排序，并保留重复的值。为此n=4, m=9，您应输出：1, 2, 2, 3, 3, 4, 4, 4, 5, 6, 6, 6, 7, 8, 8, 8, 9, 9, 10, 12, 12, 12, 14, 15, 16, 16, 18, 18, 20, 21, 24, 24, 27, 28, 32, 36。

挑战：

现在，以上所有任务都很简单。真正的挑战在于，任务2的代码必须以任务1的代码开头，任务3的代码必须以任务2的代码开头，任务4的代码必须以任务3的代码开头。

为了更清楚一点：

假设任务1的代码是（在Octave中可用）：

@(n,m)(n:m)

然后，任务2的代码可能是（在Octave中可用）：

@(n,m)(n:m)+(0:m)'

任务Task 3的代码必须是（在Octave中不起作用）：

@(n,m)(n:m)+(0:m)'"Code_for_task_3"

最后，任务4的代码必须是（在Octave中不起作用）：

@(n,m)(n:m)+(0:m)'"Code_for_task_3""Code_for_task_4"

这是代码高尔夫球，因此使用每种语言以任务4的最短代码提交的提交将获胜。与往常一样：强烈建议进行解释。

果冻，12字节

任务1

r

在线尝试！

任务2

r+þ0r$}

在线尝试！

任务3

r+þ0r$}
×þ

在线尝试！

任务4

r+þ0r$}
×þFṢ

在线尝试！

怎么运行的

任务1

r是二进位范围原子，并且确实完成了任务要求的工作。

任务2

以三个二元链接开头的二元链是叉子 ; 首先评估最外部的链接，然后调用中间的链接，并将双方的结果作为参数。

• r像以前一样，产生[n，…，m]。

• 0r$} 是一个快速链接（或快速链接，如果可以的话）。

  快速$（monadich链）消耗链接0（收益率0）和r（二进位范围），并将它们变成单子链。用参数调用时 k，将产生[0，…，k]。

  快速}（正确的参数）采用由创建的快速链接$并将其变成二进位链接的呼叫0r$与0r$}的权利的说法。

  0r$}将使用左参数n和右参数m调用，因此0r$将与参数m并产生收益 [0，…，m]。

• +þ 是另一个快速链接。 þ（表）将+为其左参数中的每个元素及其右参数中的任何元素调用（加法），将每个右参数的结果分组为一行。

  +þ将使用左参数[n，…，m]和右参数[0，…，m]调用，产生所需的表。

任务3

Jelly程序中的每一行都定义一个不同的链接。最后一个是主要链接并且像C的main函数一样，是默认情况下唯一执行的链接。其余的链接可以从主链接中调用，但是我们在这里不会这样做。

和以前一样，þ（表）将调用×为其左侧参数中的每个元素及其右侧参数中的任何元素（add），将每个右侧参数的结果分组为一行。

由于to的两个参数×þ都是整数，þ请将其强制转换为范围，将参数n和m转换为[1，…，n]和[1，…，m]。

任务4

×þ像以前一样工作。以下链接是单子链接，使它们位于顶部，即，它们被应用在先前链接的顶部。

执行之后×þ，展F平结果2D数组，并对Ṣ结果1D数组排序。

05AB1E，18 17字节

任务1

Ÿ

在线尝试

任务2

Ÿ²FD>})

在线尝试

任务3

Ÿ²FD>})v¹LN*})¦

在线尝试

任务4

Ÿ²FD>})v¹LN*})¦˜{

在线尝试

说明

任务1

Ÿ     # range[n ... m]

任务2

Ÿ        # range[n ... m]
 ²F      # m times do:
   D     # duplicate
    >    # increment
     }   # end loop
      )  # wrap in list

任务3

v          # for each list in result of Task 2 do
 ¹L        # push range[1 ... n]
   N*      # multiply by index
     }     # end loop
      )    # wrap in list
       ¦   # discard first element

任务4

˜          # flatten the result from Task 3
 {         # sort

MATL，18 17字节

任务1

&:

在线尝试！

任务2

&:O2G:h!+

在线尝试！

任务3

&:O2G:h!+:7M!*

在线尝试！

任务4

&:O2G:h!+:7M!*1eS

在线尝试！

说明

任务1

&:    % Binary range [n n+1 ... m] from implicit inputs n, m

任务2

      % ... Stack contains [n n+1 ... m]
O     % Push 0
2G    % Push second input, m
:     % Unary range: gives [1 2 ... m]
h     % Concatenate horizontally: gives [0 1 2 ... m]
!     % Transpose into a column vector
+     % Add with broadcast

任务3

      % ... Stack contains matrix from task 2
:     % Unary range. For matrix input it uses its (1,1) entry. So this gives [1 2 ... n]
7M    % Push [1 2 ... m] again
!     % Transpose into a column vector
*     % Multiply with broadcast

任务4

      % ... Stack contains matrix from task 3
1e    % Linearize into a row vector
S     % Sort

Mathematica，84 77字节

编辑：感谢Martin Ender节省了7个字节。

任务1：

{n,m}n~Range~m

Function带有参数n且m输出的纯n~Range~m形式的前缀Range[n,m]。

任务2：

{n,m}n~Range~m~Table~(m+1)//0~Range~m+#&

n~Range~m~Table~(m+1)创建一个带有m+1行的2D数组，其中每一行都是上一个任务的输出。然后//0~Range~m+#&是函数的后缀应用0~Range~m+#&这有效地增加了0以第一行，1第二行，依此类推，直到到m了m+1第一行。

任务3：

{n,m}n~Range~m~Table~(m+1)//0~Range~m+#&//1##&~Array~{n,m}&

这只是将常量函数应用于1##&~Array~{n,m}&上一个任务的输出。

任务4：

{n,m}n~Range~m~Table~(m+1)//0~Range~m+#&//1##&~Array~{n,m}&//Flatten//Sort

Flatten和Sort乘法表。

Python，183个字节

任务1，29个字节

r=range
a=lambda n,m:r(n,m+1)

在线尝试！

任务2，84个字节

r=range
a=lambda n,m:r(n,m+1)
s=lambda n,m:[[w+i for w in r(n,m)] for i in a(0,m+1)]

在线尝试！

任务3，137个字节

r=range
a=lambda n,m:r(n,m+1)
s=lambda n,m:[[w+i for w in r(n,m)] for i in a(0,m+1)]
d=lambda n,m:[[w*i for w in a(1,n)] for i in a(1,m)]

在线尝试！

任务4，183个 167字节

r=range
a=lambda n,m:r(n,m+1)
s=lambda n,m:[[w+i for w in r(n,m)] for i in a(0,m+1)]
d=lambda n,m:[[w*i for w in a(1,n)] for i in a(1,m)]
f=lambda(z):sorted(sum(z,[]))

在线尝试！

说明：

任务1：

很简单，它使用Python的内置函数生成一个n要m列出的列表range。

任务2：

对于0to的每个数字m+1，它将该数字添加到from n到列表的每个项目中m。

任务3：

对于from 1到的每个数字m，它将该数字乘以from 1到列表中的每个数字n。

任务4：

这使用了Python的内置sorted函数，该函数从最小到最大对列表进行排序。函数中的列表理解用于将列表展平。它在任务3为其指定的列表的每个项目中创建每个项目的列表。

• 感谢@math_junkie，节省了很多字节。
• @ThisGuy节省了16个字节

感谢@math_junkie，节省了很多字节。

PHP 7，200字节

使用输出缓冲区清除先前的输出。

任务1

[,$n,$m]=$argv;ob_start();eval($s='echo join(" ",$v?:range($n+$i,$m+$i)),"
";');

将代码保存在其中$s以供以后重用。的$v变量用于最后一个任务。

任务2

[,$n,$m]=$argv;ob_start();eval($s='echo join(" ",$v?:range($n+$i,$m+$i)),"
";');for(;++$i<=$m;)eval($s);

打印剩余的行。

任务3

[,$n,$m]=$argv;ob_start();eval($s='echo join(" ",$v?:range($n+$i,$m+$i)),"
";');for(;++$i<=$m;)eval($s);for(($c=ob_clean)();++$j<=$m;print"
")for(;++$$j<=$n;sort($v))echo$v[]=$j*$$j,' ';

清除输出缓冲区并打印乘法表，将数字保存到 $v。

任务4

[,$n,$m]=$argv;ob_start();eval($s='echo join(" ",$v?:range($n+$i,$m+$i)),"
";');for(;++$i<=$m;)eval($s);for(($c=ob_clean)();++$j<=$m;print"
")for(;++$$j<=$n;sort($v))echo$v[]=$j*$$j,' ';$c();eval($s);

再次清除输出缓冲区并打印$v。

电源外壳，126字节

任务1

param($n,$m)$n..$m

在线尝试！

使用..内置的范围运算符。隐含的默认行为Write-Output在元素之间插入换行符，这就是为什么输出显示为换行符分隔的原因。

任务2

param($n,$m)$n..$m>2;0..$m|%{$i=$_;($n..$m|%{$_+$i})-join','}

在线尝试！

使用第一个任务将第一个任务转储到STDERR >2;，然后从循环0到$m每个迭代设置帮助器，$i然后再次从循环$n到$m每个数字并以递增$i。那些是-join与逗号一起编辑，否则这将是模棱两可的巨大的长每行一个元素的输出。

任务3

param($n,$m)$n..$m>2;0..$m|%{$i=$_;($n..$m|%{$_+$i})-join','}>2;(1..$m|%{$i=$_;(1..$n|%{$_*$i})-join' '})

在线尝试！

>2;将以前的内容转储到STDERR 的事情也是如此。然后，我们简单地从1到到$m进行双循环，在此过程1中$n设置辅助程序$i，将值相乘，并-join用空格使它成为表格。请注意封装的括号-它们将在下一个任务中发挥作用-但在这里，它们只是确保将输出放置到管道中（它已经是原来的，因此是多余的）。

任务4

param($n,$m)$n..$m>2;0..$m|%{$i=$_;($n..$m|%{$_+$i})-join','}>2;(1..$m|%{$i=$_;(1..$n|%{$_*$i})-join' '})-split' '|%{+$_}|sort

在线尝试！

啊哈！最后有些冗余。由于上一个任务具有可扩展性，因此我们可以-split放心地在空白上进行处理，将每个都转换为整数|%{+$_}，然后转换为|sort。输出再次换行分隔。

我认为有一些方法可以更好地利用任务之间的冗余性-仍然需要打高尔夫。

ES2016-ish，401 384个字符

这是第一次尝试。我敢肯定它可能会被压缩，但是很短。箭头功能FTW！（喜欢那些隐式的return语句。）新增和改进的模板字符串！

任务1

var a=Array,l=console.log,f=(n,m)=>a.from(a(1+m-n),(w,i)=>n+i),z=(n,m)=>l(f(n,m).join`, `)

调用z(n,m)日志输出。（我为console.log加上别名，以便以后打高尔夫球。）

任务2

第二节...在第一节上扩展。

var a=Array,l=console.log,f=(n,m)=>a.from(a(1+m-n),(w,i)=>n+i),z=(n,m)=>l(f(n,m).join`, `),p,o,g=(n,m)=>{p=n,o=m;return [...a(m+1).keys()].map((d)=>f(d+p,d+o))},y=(n,m)=>l(g(n,m).join`\n`

现在致电y(n,m)。漂亮，不是吗？

任务3

必须绕过大多数现有功能<sadface />。

var a=Array,l=console.log,f=(n,m)=>a.from(a(1+m-n),(w,i)=>n+i),z=(n,m)=>l(f(n,m).join`, `),p,o,g=(n,m)=>{p=n,o=m;return [...a(m+1).keys()].map((d)=>f(d+p,d+o))},y=(n,m)=>l(g(n,m).join`\n`,h=(n,m)=>[...a(m).keys()].map((d)=>(d+1)*n).join`\t`,i=(n,m)=>[...a(n).keys()].map((d)=>h((d+1),m)),v=(n,m)=>i(n,m).join`\n`

现在方法名称为v。用同样的方式称呼它。

任务4

现在我们可以再次重用。

var a=Array,l=console.log,f=(n,m)=>a.from(a(1+m-n),(w,i)=>n+i),z=(n,m)=>l(f(n,m).join`, `),p,o,g=(n,m)=>{p=n,o=m;return [...a(m+1).keys()].map((d)=>f(d+p,d+o))},y=(n,m)=>l(g(n,m).join`\n`,h=(n,m)=>[...a(m).keys()].map((d)=>(d+1)*n).join`\t`,i=(n,m)=>[...a(n).keys()].map((d)=>h((d+1),m)),v=(n,m)=>i(n,m).join`\n`,t=(n,m)=>l(v(n,m).match(/\d+/g).sort((a,b)=>+a>+b||+(a===b)*2-1).join(`, `)

必须跳过u我的方法，所以是t。我不得不放入该排序函数，因为String.match返回值是...字符串。

Ruby，121103字节

在红宝石一切是除了truthy nil和false，这意味着该任务可以被设置为忽略与零但一个有利的位置之前的输入and/ &&。

任务1

在线尝试！

n,m=$*.map &:to_i
p [*n..m]

任务2

在线尝试！

n,m=$*.map &:to_i
p [*n..m]&&(0..m).map{|i|[*n+i..m+i]}

任务3

在线尝试！

n,m=$*.map &:to_i
p [*n..m]&&(0..m).map{|i|[*n+i..m+i]}&&(1..m).map{|i|(1..n).map{|j|i*j}}

任务4

在线尝试！

n,m=$*.map &:to_i
p [*n..m]&&(0..m).map{|i|[*n+i..m+i]}&&(1..m).map{|i|(1..n).map{|j|i*j}}.flatten.sort