Écrivez un programme ou une fonction qui accepte un entier positif N. Générez une liste de tous les nombres décimaux distincts qui peuvent être écrits avec exactement N caractères à l' aide des chiffres ( 0123456789), des décimales ( .) et des signes négatifs ( -).

Par exemple, quelques chiffres qui seraient dans la liste de sortie N = 4 sont 1337, 3.14, .999, -789, -2.7et -.09.

Les chiffres doivent être écrits de la manière habituelle, mais sous une forme aussi courte que possible . Ça signifie:

• Le point décimal ne doit être inclus que si le nombre n'est pas un entier.

  • par exemple 45.0et 45.doit être écrit en clair45
  • -45.00 devrait être écrit comme -45

• Il ne doit pas y avoir de zéros non significatifs à gauche du séparateur décimal.

  • 03et 003devrait être écrit comme 3, mais 30et 300sont très bien comme ils sont
  • 0.3et 00.3doit être écrit comme juste.3
  • -03 devrait être écrit comme -3
  • -0.3 devrait être écrit comme -.3

• Il ne doit pas y avoir de zéros de fin à droite de la virgule décimale

  • .50et .500doit être écrit comme.5
  • 900.090 devrait être écrit comme 900.09

• L'exception aux deux dernières règles est zéro lui-même, qui doit toujours être écrit en clair0 .

• Les signes positifs ( +) ne doivent pas être utilisés car ils allongent inutilement le nombre.

Notez également que le signe négatif ( -) ne doit pas être utilisé comme signe de soustraction. Il ne doit apparaître que comme le premier caractère des nombres inférieurs à zéro.

Mise en page

L'ordre de la liste de sortie des numéros n'a pas d'importance. Elle peut être ascendante, descendante ou complètement mélangée. Il importe seulement que tous les nombres distincts pouvant être écrits en N caractères soient présents.

La liste peut être formatée de manière raisonnable, en utilisant des espaces, des sauts de ligne, des virgules ou peut-être quelque chose d'autre entre les nombres, tant que les choses sont cohérentes. Les crochets de début et de fin (ou similaire) sont corrects, mais pas les choses comme les guillemets autour des nombres. (c.-à-d. ne mélangez pas visiblement les chaînes et les entiers / flottants dans la sortie.)

Par exemple, lorsque N = 1, certaines sorties valides seraient:

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 }

Mais cela serait invalide:

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

Exemples

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

Les listes sont en ordre croissant, ellipsées à certains endroits pour faciliter la lecture.

Notation

Le code le plus court en octets gagne. En cas d'égalité, la réponse la plus votée l'emporte

Pyth, 47 45 octets

Merci à FryAmTheEggman d' avoir noté que la commande n'a pas d'importance.

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

Essayez-le en ligne.

Le temps d'exécution est horrible, essentiellement O (12 ⁿ ), mais je l'ai testé pour n= 6 sur mon ordinateur (ce qui a pris 2 minutes). Exécution de n≥ 5 sera chronométrer en ligne.

En raison de la façon dont je génère les personnages, 0123456789.-la sortie est dans un ordre vraiment bizarre.

On pourrait techniquement supprimer la {fin proche, mais cela entraînerait une complexité de O (19 ⁿ ). (Cela produirait également de nombreux doublons, mais cela est autorisé.)

Explication

                  _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 partie principale du code est ".- \..*\. ^-?0. [.-]0*$", qui contient les expressions rationnelles auxquelles aucune sortie ne doit correspondre.

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

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

Essayez-le sur l'interprète en ligne .

Beaucoup trop long et avec un temps d'exécution horrible (cela prend plusieurs secondes pour N = 4, il n'est pas recommandé de courir avec 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

Explication de l'expression régulière:

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

Julia, 126117 octets

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

Il s'agit d'une fonction lambda qui accepte un entier et renvoie un tableau de chaînes. Pour l'appeler, affectez-le à une variable. L'approche ici est la même que la réponse Pyth de Doorknob .

Non 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 octets

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

Essayez-le en ligne!

Cela utilise une force super brute (via la puissance cartésienne) suivie d'un filtrage (via une expression régulière). J'ajouterai une explication plus tard.

Les résultats sont affichés à la fin du programme. Cela peut prendre un peu de temps. Si vous souhaitez voir les résultats lorsqu'ils sont générés, ajoutez Dà la fin :

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