Escreva um programa ou função que receba um número inteiro positivo N. Emita uma lista de todos os números decimais distintos que podem ser escritos com exatamente N caracteres usando dígitos ( 0123456789), pontos decimais ( .) e sinais negativos ( -).

Por exemplo, alguns números que seriam na lista de saída N = 4 s 1337, 3.14, .999, -789, -2.7, e -.09.

Os números devem ser escritos da maneira normal, mas da forma mais curta possível . Isso significa:

• O ponto decimal só deve ser incluído se o número não for um número inteiro.

  • por exemplo, 45.0e 45.deve ser escrito como simples45
  • -45.00 deve ser escrito como -45

• Não deve haver zeros à esquerda do ponto decimal.

  • 03e 003deve ser escrito como 3, mas 30e 300está bem como está
  • 0.3e 00.3deve ser escrito como.3
  • -03 deve ser escrito como -3
  • -0.3 deve ser escrito como -.3

• Não deve haver zeros à direita do ponto decimal

  • .50e .500deve ser escrito como.5
  • 900.090 deve ser escrito como 900.09

• A exceção às duas últimas regras é o próprio zero, que deve sempre ser escrito como simples0 .

• Sinais positivos ( +) não devem ser usados, pois aumentam desnecessariamente o número.

Observe também que o sinal negativo ( -) não deve ser usado como sinal de subtração. Ele deve aparecer apenas como o primeiro caractere de números menores que zero.

Formatação

A ordem da lista de números de saída não importa. Pode ser ascendente, descendente ou completamente misturado. É importante apenas que todos os números distintos que podem ser escritos em N caracteres estejam presentes.

A lista pode ser formatada de maneira razoável, usando espaços, novas linhas, vírgulas ou talvez algo mais entre os números, desde que as coisas sejam consistentes. Os colchetes à esquerda e à direita (ou similares) estão bem, mas coisas como aspas em torno dos números não. (ou seja, não misture visivelmente strings e ints / floats na saída.)

Por exemplo, quando N = 1, algumas saídas válidas seriam:

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 }

Mas isso seria inválido:

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

Exemplos

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

As listas estão em ordem crescente, elipsizadas em alguns lugares para facilitar a leitura.

Pontuação

O código mais curto em bytes vence. Em caso de empate, a resposta mais votada ganha

Pitão, 47 45 bytes

Agradecemos a FryAmTheEggman por observar que o pedido não importa.

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

Experimente online.

O tempo de execução é horrível, basicamente O (12 ⁿ ), mas eu testei para n= 6 no meu computador (o que levou 2 minutos). A execução n≥ 5 atingirá o tempo limite online.

Devido à maneira como eu gero os caracteres, 0123456789.-a saída está em uma ordem realmente estranha.

Pode-se remover tecnicamente o {próximo ao fim, mas isso resultaria em uma complexidade de O (19 ⁿ ). (Também produziria muitas duplicatas, mas isso é permitido.)

Explicação

                  _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

A parte principal do código é ".- \..*\. ^-?0. [.-]0*$", que contém as expressões regulares que qualquer saída não deve corresponder.

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

Pitão, 57 bytes

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

Experimente no intérprete online .

Tempo demais e com tempo de execução horrível (leva alguns segundos para N = 4, não é recomendável executar 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

Explicação Regex:

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

Julia, 126 117 bytes

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

Esta é uma função lambda que aceita um número inteiro e retorna uma matriz de seqüências de caracteres. Para chamá-lo, atribua-o a uma variável. A abordagem aqui é a mesma da resposta Pyth da maçaneta da porta .

Ungolfed:

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 bytes

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

Experimente online!

Utiliza força super bruta (via potência cartesiana) seguida de filtragem (através de uma expressão regular). Vou adicionar uma explicação mais tarde.

Os resultados são exibidos no final do programa. Isso pode demorar um pouco. Se você deseja ver os resultados à medida que são gerados, adicione Dno final :

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