编写一个使用正整数N的程序或函数。输出所有可以使用数字（），小数点（）和负号（）精确写成N个字符的十进制数的列表。0123456789.-

例如，一些数字，这将是在N = 4输出列表是1337，3.14，.999，-789，-2.7，和-.09。

数字应以正常方式书写，但应尽可能短。这表示：

• 如果数字不是整数，则仅应包括小数点。

  • 例如45.0，45.应该写成普通的45
  • -45.00 应该写成 -45

• 小数点左边不应有前导零。

  • 03并003应为书面3，但30并300都很好，因为它们是
  • 0.3并且00.3应该写成刚.3
  • -03 应该写成 -3
  • -0.3 应该写成 -.3

• 小数点右边不应有尾随零

  • .50并且.500应写为.5
  • 900.090 应该写成 900.09

• 最后两个规则的例外是零本身，应始终将其写为plain0。

• +请勿使用正号（），因为它们会不必要地加长数字。

另请注意，负号（-）不应用作减号。它只能作为小于零的数字的第一个字符出现。

格式化

数字输出列表的顺序无关紧要。它可以是上升，下降或完全混合。仅存在所有可以用N个字符写入的不同数字的问题。

列表可以使用空格，换行符，逗号或数字之间的其他某种形式的合理格式设置，只要条件保持一致即可。前括号和后括号（或类似的括号）都可以，但数字引号之类的东西却不是。（即，不要在输出中明显混淆字符串和整数/浮点数。）

例如，当N = 1时，一些有效输出将是：

0 1 2 3 4 5 6 7 8 9

[1, 2, 3, 4, 5, 6, 7, 9, 0]

ans = { 5 8 9 1 3 2 0 3 4 7 6 }

但这将是无效的：

[0, 1, 2, 3, 4, "5", "6", "7", "8", "9"]

例子

N = 1 -> 0 1 2 3 4 5 6 7 8 9

N = 2 -> -9 -8 -7 -6 -5 -4 -3 -2 -1 .1 .2 .3 .4 .5 .6 .7 .8 .9 10 11 12 ... 97 98 99

N = 3 -> -99 -98 ... -11 -10 -.9 -.8 ... -.2 -.1 .01 .02 ... .98 .99 1.1 1.2 ... 1.9 2.1 2.2 ... 2.9 3.1 ...... 9.9 100 101 ... 998 999

列表按升序排列，在某些地方为省略而省略以方便阅读。

计分

以字节为单位的最短代码获胜。如果是平局，则以投票较高的答案为准

Pyth，47个 45字节

由于FryAmTheEggman用于提的是，顺序并不重要。

jf!sm:Td)c".- \..*\. ^-?0. [.-]0*$"d^{`c_T17Q

在线尝试。

运行时非常糟糕，基本上是O（12 ⁿ），但是我n在计算机上测试了= 6（耗时2分钟）。运行n≥5 将在网上超时。

由于我生成字符的方式0123456789.-，输出的顺序确实很奇怪。

从技术上讲，可以删除{近端，但是这会导致O（19 ⁿ）的复杂性。（它也会产生很多重复，但这是允许的。）

说明

                  _T       -10
                 c  17     -10 / 17 = -0.5882352941176471
                `          representation: "-0.5882352941176471"
               {           uniquify: "-0.582394176"
              ^       Q    input'th Cartesian power
 f                         filter on:
         c"…"d               split this string by spaces
    m:Td)                    check if the parts match the current string
  !s                         true if none of the parts matched
j                            join by newlines

该代码的主要部分是".- \..*\. ^-?0. [.-]0*$"，其中包含任何输出不得匹配的正则表达式。

.-         minus must be first character
\..*\.     there may only be one decimal point
^-?0.      no extra leading zeroes
[.-]0*$    number must not end with decimal/minus and 0+ zeroes

Pyth，57个字节

j-f:T"^0$|^-?([1-9]\d*)?(\.\d*[1-9])?$"0{.P*Q+jkUT".-"Q\-

在在线解释器上尝试一下。

太长了，而且运行时令人恐惧（N = 4需要花费几秒钟，不建议N = 5运行）。

            .P           Q    all permutations of length (input) of
                 jkUT         ... the string "0123456789"
                +    ".-"     ... plus the chars "." and "-"
              *Q              ... whole thing times the input -- pyth has
                              no repeated_permutation, so this is necessary
           {                  uniquify
  f                           filter by
   :T"..."0                   does it match the really long regex?
 -                        \-  get rid of "-"
j                             join on newline

正则表达式说明：

^0$|            "0", or...
^
 -?             optional negative sign
 ([1-9]\d*)?    optional part-before-decimal
 (\.\d*[1-9])?  optional part-after-decimal
$

利亚，126个 117字节

n->filter(i->ismatch(r"^0$|^-?([1-9]\d*)?(\.\d*[1-9])?$",i)&&i!="-",∪(map(join,combinations((".-"join(0:9))^n,n))))

这是一个lambda函数，它接受一个整数并返回一个字符串数组。要调用它，请将其分配给变量。这里的方法与Doorknob的Pyth 答案相同。

取消高尔夫：

function g(n::Int)
    # Get all n-character combinations of .-0123456789
    c = combinations((".-"join(0:9))^n, n)

    # Join each group of n characters into a string and take unique
    u = ∪(map(join, c))

    # Filter to only appropriately formatted strings
    filter(i -> ismatch(r"^0$|^-?([1-9]\d*)?(\.\d*[1-9])?$", i) && i != "-", u)
end

MATL，60字节

45:57iZ^!"@!'^(-?(([1-9]\d*)|([1-9]\d*)?(\.\d*[1-9]))|0)$'XX

在线尝试！

它使用超强力（通过笛卡尔幂），然后使用滤波（通过正则表达式）。稍后再添加解释。

结果显示在程序末尾。可能还要等一下。如果要在生成结果时查看它们，请在末尾添加D：

45:57iZ^!"@!'^(-?(([1-9]\d*)|([1-9]\d*)?(\.\d*[1-9]))|0)$'XXD