Schreiben Sie ein Programm oder eine Funktion, die eine positive Ganzzahl N akzeptiert. Geben Sie eine Liste aller eindeutigen Dezimalzahlen aus, die mit Ziffern ( 0123456789), Dezimalpunkten ( .) und negativen Vorzeichen ( -) in genau N Zeichen geschrieben werden können .

Zum Beispiel sind einige Zahlen , die in der N = 4 Ausgabeliste sein würden , sind 1337, 3.14, .999, -789, -2.7, und -.09.

Die Zahlen sind wie gewohnt, aber so kurz wie möglich zu schreiben . Das heisst:

• Der Dezimalpunkt sollte nur eingefügt werden, wenn die Zahl keine Ganzzahl ist.

  • zB 45.0und 45.sollte als klar geschrieben werden45
  • -45.00 sollte geschrieben werden als -45

• Vor dem Dezimalpunkt dürfen keine führenden Nullen stehen.

  • 03und 003sollte so geschrieben werden 3, aber 30und 300sind in Ordnung, wie sie sind
  • 0.3und 00.3sollte als gerecht geschrieben werden.3
  • -03 sollte geschrieben werden als -3
  • -0.3 sollte geschrieben werden als -.3

• Nach dem Komma dürfen keine nachgestellten Nullen stehen

  • .50und .500sollte geschrieben werden als.5
  • 900.090 sollte geschrieben werden als 900.09

• Die Ausnahme zu den beiden letzten Regeln ist die Null selbst, die immer als einfach geschrieben werden sollte0 .

• Positive Zeichen ( +) sollten nicht verwendet werden, da sie die Zahl unnötig verlängern.

Beachten Sie auch, dass das negative Vorzeichen ( -) nicht als Subtraktionszeichen verwendet werden darf. Es sollte nur als erstes Zeichen von Zahlen kleiner als Null erscheinen.

Formatierung

Die Reihenfolge der ausgegebenen Nummernliste spielt keine Rolle. Es kann aufsteigend, absteigend oder völlig durcheinander sein. Es kommt nur darauf an, dass alle eindeutigen Zahlen, die in N Zeichen geschrieben werden können, vorhanden sind.

Die Liste kann in angemessener Weise mit Leerzeichen, Zeilenumbrüchen, Kommas oder anderen Zeichen zwischen den Zahlen formatiert werden, sofern die Dinge konsistent sind. Führende und nachfolgende Klammern (oder ähnliches) sind in Ordnung, Anführungszeichen um Zahlen jedoch nicht. (dh verwechseln Sie Strings und Ints / Floats nicht sichtbar in der Ausgabe.)

Wenn beispielsweise N = 1 ist, sind einige gültige Ausgaben:

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 }

Das wäre aber ungültig:

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

Beispiele

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

Die Listen sind in aufsteigender Reihenfolge und an einigen Stellen zum besseren Lesen mit Auslassungspunkten versehen.

Wertung

Der kürzeste Code in Bytes gewinnt. Bei Stimmengleichheit gewinnt die höher gewählte Antwort

Pyth, 47 45 Bytes

Vielen Dank an FryAmTheEggman für die Feststellung, dass die Bestellung keine Rolle spielt.

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

Probieren Sie es online aus.

Die Laufzeit ist schrecklich, im Grunde genommen O (12 ⁿ ), aber ich habe es nauf meinem Computer auf = 6 getestet (was 2 Minuten gedauert hat). Laufen n≥ 5 wird Online - Zeit aus.

Aufgrund der Art und Weise, wie ich die Zeichen generiere, erfolgt 0123456789.-die Ausgabe in einer wirklich seltsamen Reihenfolge.

Man könnte das {nahe Ende technisch entfernen , aber es würde zu einer Komplexität von O (19 ⁿ ) führen. (Es würde auch viele Duplikate produzieren, aber das ist erlaubt.)

Erläuterung

                  _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

Der Hauptteil des Codes ist ".- \..*\. ^-?0. [.-]0*$", der die regulären Ausdrücke enthält, mit denen eine Ausgabe nicht übereinstimmen darf .

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

Probieren Sie es mit dem Online-Dolmetscher aus .

Viel zu lang und mit schrecklicher Laufzeit (dauert mehrere Sekunden für N = 4, die Ausführung mit N = 5 wird nicht empfohlen).

            .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

Regex Erklärung:

^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))))

Dies ist eine Lambda-Funktion, die eine Ganzzahl akzeptiert und ein Array von Zeichenfolgen zurückgibt. Um es aufzurufen, weisen Sie es einer Variablen zu. Der Ansatz hier ist der gleiche wie bei Doorknobs Pyth- Antwort .

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

Probieren Sie es online!

Dies verwendet Super-Brute-Force (über kartesische Potenz), gefolgt von Filterung (über einen regulären Ausdruck). Ich werde später eine Erklärung hinzufügen.

Die Ergebnisse werden am Ende des Programms angezeigt. Das kann eine Weile dauern. Wenn Sie die Ergebnisse sehen möchten, während sie generiert werden, fügen Sie Dam Ende Folgendes hinzu :

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