在一个蒸汽朋克的多维世界中，我们的老板想在集团的多维文件柜中的每个抽屉上粘贴打印的索引标签。

老板希望使用仅为此目的而购买的字体将整个标签纸排版为单个表格，因此我们必须订购分类（金属符号片）。由于排序非常昂贵，因此我们的订购必须针对每个数字符号的准确计数。

对于给定的（以任何方式）长度≥0的一组长度，返回（以任何方式）我们的命令，这是排版所有笛卡尔坐标所需的数字频率表。它必须按键盘的出现顺序排列（即9之后为0），并且可能不包含0种排序的顺序，因此，如果根本不排序（因为尺寸的长度为0），则不能排序。什么都不打印。

• 如果您的代码也可以处理（即不打印任何内容）0个维度，则-3分的奖励。
• 最终换行符是可以接受的。
• 禁止使用标准漏洞。
• 如前所述，排序很昂贵，因此是codecolf。

善良的灵魂可能会编辑此挑战，以包括自动评分，因此请添加标题，例如：
# LanguageName, 123 sorts

测试用例

给定11，打印：

1 4
2 1
3 1
4 1
5 1
6 1
7 1
8 1
9 1
0 1

因为所需要的标签1，2，3，4，5，6，7，8，9，10，和11。

给定2 3，打印：

1 5
2 5
3 2

因为所需要的标签1 1， 1 2， 1 3， 2 1， 2 2，和2 3。

给定2 0，打印一个空行：

或者什么都没有。

给定1 2 3，打印：

1 11
2  5
3  2

因为所需要的标签1 1 1，1 1 2，1 1 3，1 2 1，1 2 2，和1 2 3

给定5 5 5 5，打印：

1 500
2 500
3 500
4 500
5 500

不，我不会列出所有625个标签。

Dyalog APL，10 7

该代码长10个字节，有资格获得赠金。

感谢user46915的3个字节！

,∘≢⌸∊⍕¨∊⍳⎕

注意，⎕（输入）在TryAPL上不起作用；您可以在这里尝试功能表格。

            ⎕      Get input
           ⍳       Index vector
       ∊⍕¨∊        Flatten, stringify, flatten again
      ⌸            From the key, display the
{⍺,  }             elements concatenated with the
   ≢⍵              number of times they occur

我不完全理解⌸运算符，但是{⍺}⌸列出了采用的唯一值，并{⍵}⌸列出了它们在参数中的位置。

这具有正确的顺序，因为它是数字在标签的多维数组中出现的顺序。

Mathematica，48个字节-3 = 45

Grid@Tally@Flatten@IntegerDigits@Tuples@Range@#&

Mathematica，111个 85字节

Grid[Thread@{Range@10~Mod~10,DigitCount@Tuples@Range@#~Total~2}~DeleteCases~{_,‌​0}]&

这里的大部分工作是由DigitCount。

R，110字节

由于Alex A.而保存了4个（谢谢！）

U=unlist
X=table(U(strsplit(as.character(U(expand.grid(Map(seq_len,scan())))),"")))
z=Map(cat,names(X),X,"\n")

Ruby，92个字节

f,*r=$*.map{|n|[*1..n.to_i]}
a=f.product(*r)*''
puts a.chars.uniq.map{|c|[c,a.count(c)]*" "}

将长度作为命令行参数：

$ ruby foo.rb 1 2 3
1 11
2 5
3 2

CJam，31个字节

Laq~{,m*}/e_:)s{_'0=A*+}$e`{(S\N}%

在线尝试

代码为34字节，使用空的输入列表需要3字节的奖励。输入是CJam格式的列表，例如：

[1 2 3]

说明：

La    Push list containing empty list to seed Cartesian products.
q~    Get and interpret input.
{     Loop over values in input list.
  ,     Built range from 0 to value-1.
  m*    Form Cartesian product with the list we already have.
}/    End loop over values in input list.
e_    Resulting list has extra nesting. Flatten it.
:)    Increment all values in list, since it is 0-based, and we need 1-based.
s     Convert it to string, so we can operate on digits.
{     Block to calculate source key, needed to get 0 to the end.
  _     Copy the digit.
  '0=   Compare with '0.
  A*    Multiply comparison result by 10...
  +     ... and add it to digit.
}$    End of sort key block.
e`    RLE.
{     Start of loop over RLE entries, for generating output in specified format.
  (     Pop off the first value, which is the count.
  S     Push a space...
  \     ... and swap it with the count.
  N     Push a newline.
}%    End of loop over RLE entries.

Pyth，15个字节

rjko%N_Ts*FSMQ8

Haskell，125个字节

import Data.List
l=mapM_(putStrLn.(\(h:r)->h:' ':show(length r+1))).group.sort.concatMap show.concat.sequence.map(\n->[1..n])