Escriba un programa o función que tome un entero positivo N. Genere una lista de todos los números decimales distintos que pueden escribirse exactamente en N caracteres usando dígitos ( 0123456789), puntos decimales ( .) y signos negativos ( -).

Por ejemplo, algunos números que serían en la lista de salida N = 4 son 1337, 3.14, .999, -789, -2.7, y -.09.

Los números deben escribirse de la manera normal, pero de la forma más corta posible . Esto significa:

• El punto decimal solo debe incluirse si el número no es un entero.

  • por ejemplo, 45.0y 45.debe escribirse como simple45
  • -45.00 debe escribirse como -45

• No debería haber ceros a la izquierda del punto decimal.

  • 03y 003debe ser escrito como 3, pero 30y 300están bien como están
  • 0.3y 00.3debe escribirse como solo.3
  • -03 debe escribirse como -3
  • -0.3 debe escribirse como -.3

• No debe haber ceros a la derecha del punto decimal

  • .50y .500debe escribirse como.5
  • 900.090 debe escribirse como 900.09

• La excepción a las dos últimas reglas es cero en sí, que siempre debe escribirse como simple0 .

• Los signos positivos ( +) no deben usarse ya que alargan innecesariamente el número.

También tenga en cuenta que el signo negativo ( -) no debe usarse como un signo de resta. Solo debe aparecer como el primer carácter de números menores que cero.

Formateo

El orden de la lista de números de salida no importa. Podría ser ascendente, descendente o completamente mezclado. Solo importa que todos los números distintos que se pueden escribir en N caracteres estén presentes.

La lista puede formatearse de manera razonable, utilizando espacios, líneas nuevas, comas o quizás algo más entre los números, siempre que las cosas sean consistentes. Los corchetes iniciales y finales (o similares) están bien, pero no lo son las comillas alrededor de los números. (es decir, no mezcle cadenas e ints / flotantes en la salida).

Por ejemplo, cuando N = 1, algunas salidas válidas serían:

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 }

Pero esto sería inválido:

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

Ejemplos

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

Las listas están en orden ascendente, elipses en algunos lugares para facilitar la lectura.

Puntuación

El código más corto en bytes gana. En caso de empate, la respuesta más votada gana

Pyth, 47 45 bytes

Gracias a FryAmTheEggman por señalar que el orden no importa.

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

Pruébalo en línea.

El tiempo de ejecución es horrible, básicamente O (12 ⁿ ), pero lo probé para n= 6 en mi computadora (que tomó 2 minutos). Ejecución de n≥ 5 será el tiempo de espera en línea.

Debido a la forma en que genero los caracteres, 0123456789.-la salida está en un orden realmente extraño.

Técnicamente, se podría eliminar el {extremo cercano, pero daría como resultado una complejidad de O (19 ⁿ ). (También produciría muchos duplicados, pero eso está permitido).

Explicación

                  _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

La parte principal del código es ".- \..*\. ^-?0. [.-]0*$", que contiene las expresiones regulares que cualquier salida no debe coincidir.

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

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

Pruébelo en el intérprete en línea .

Demasiado tiempo y con un tiempo de ejecución horrible (toma varios segundos para N = 4, no se recomienda ejecutar con 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

Explicación de expresiones regulares:

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

Julia, 126117 bytes

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

Esta es una función lambda que acepta un número entero y devuelve una matriz de cadenas. Para llamarlo, asígnelo a una variable. El enfoque aquí es el mismo que la respuesta Pyth de Doorknob .

Sin golf:

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

Pruébalo en línea!

Utiliza la fuerza súper bruta (a través del poder cartesiano) seguido de filtrado (a través de una expresión regular). Agregaré una explicación más tarde.

Los resultados se muestran al final del programa. Esto puede tardar un rato. Si desea ver los resultados a medida que se generan, agregue Dal final :

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