Scrivi un programma o una funzione che accetta un numero intero positivo. Stampa un elenco di tutti i numeri decimali distinti che possono essere scritti esattamente in N caratteri usando cifre ( 0123456789), punti decimali ( .) e segni negativi ( -).

Ad esempio, alcuni numeri che sarebbero nell'elenco uscita N = 4 sono 1337, 3.14, .999, -789, -2.7, e -.09.

I numeri devono essere scritti nel modo normale, ma nella forma più breve possibile . Questo significa:

• Il punto decimale deve essere incluso solo se il numero non è un numero intero.

  • ad es. 45.0e 45.dovrebbe essere scritto come semplice45
  • -45.00 dovrebbe essere scritto come -45

• Non dovrebbero esserci zero iniziali a sinistra del punto decimale.

  • 03e 003dovrebbe essere scritto come 3, ma 30e va 300bene così come sono
  • 0.3e 00.3dovrebbe essere scritto come giusto.3
  • -03 dovrebbe essere scritto come -3
  • -0.3 dovrebbe essere scritto come -.3

• Non ci dovrebbero essere zero finali alla destra del punto decimale

  • .50e .500dovrebbe essere scritto come.5
  • 900.090 dovrebbe essere scritto come 900.09

• L'eccezione alle ultime due regole è lo stesso zero, che dovrebbe sempre essere scritto come semplice0 .

• I segni positivi ( +) non devono essere utilizzati poiché allungano inutilmente il numero.

Si noti inoltre che il segno negativo ( -) non deve essere utilizzato come segno di sottrazione. Dovrebbe apparire solo come primo carattere di numeri inferiori a zero.

Formattazione

L'ordine dell'elenco di output dei numeri non ha importanza. Potrebbe essere crescente, decrescente o completamente confuso. Importa solo che sono presenti tutti i numeri distinti che possono essere scritti in N caratteri.

L'elenco può essere formattato in modo ragionevole, usando spazi, newline, virgole o forse qualcos'altro tra i numeri, purché le cose siano coerenti. Le parentesi iniziali e finali (o simili) vanno bene, ma cose come le virgolette attorno ai numeri no. (cioè non mescolare visibilmente stringhe e ints / float nell'output.)

Ad esempio, quando N = 1, alcuni output validi sarebbero:

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 }

Ma questo non sarebbe valido:

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

Esempi

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

Gli elenchi sono in ordine crescente, ellissi in alcuni punti per comodità di lettura.

punteggio

Vince il codice più breve in byte. In caso di parità vince la risposta con il voto più alto

Pyth, 47 45 byte

Grazie a FryAmTheEggman per aver notato che l'ordine non ha importanza.

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

Provalo online.

Il tempo di esecuzione è orribile, sostanzialmente O (12 ⁿ ), ma l'ho provato per n= 6 sul mio computer (che ha richiesto 2 minuti). Esecuzione n≥ 5 sarà timeout on-line.

A causa del modo in cui generi i caratteri, 0123456789.-l'output è in un ordine davvero strano.

Si potrebbe rimuovere tecnicamente il {vicino, ma ciò comporterebbe una complessità di O (19 ⁿ ). (Produrrebbe anche molti duplicati, ma questo è permesso.)

Spiegazione

                  _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 principale del codice è ".- \..*\. ^-?0. [.-]0*$", che contiene le regex che qualsiasi output non deve corrispondere.

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

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

Provalo sull'interprete online .

Troppo lungo e con un tempo di esecuzione orribile (richiede diversi secondi per N = 4, non è consigliabile correre 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

Spiegazione Regex:

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

Julia, 126 117 byte

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

Questa è una funzione lambda che accetta un numero intero e restituisce una matrice di stringhe. Per chiamarlo, assegnarlo a una variabile. L'approccio qui è lo stesso della risposta Pyth di Doorknob .

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 byte

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

Provalo online!

Questo utilizza una forza super-bruta (tramite il potere cartesiano) seguita da un filtro (tramite un'espressione regolare). Aggiungerò una spiegazione più tardi.

I risultati vengono visualizzati alla fine del programma. Questo potrebbe richiedere del tempo. Se vuoi vedere i risultati mentre vengono generati, aggiungi Dalla fine :

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