J'ai lu cette question et j'ai pensé que ce serait un beau défi.

Tâche

Donner une entrée 0<n<10générer un nombre aléatoire avec

• exactement n chiffres
• le premier pas un 0
  • alors f(n)>10**(n-1)-1
• chiffres distincts

Critères gagnants

C'est le code-golf donc le code le plus court gagne.

au hasard

Je veux dire aléatoire réparti uniformément. Du point de vue du programme, chaque nombre possible a donc la même chance. Si la langue dans laquelle vous écrivez a un étrange générateur de nombres aléatoires, vous pouvez l'utiliser.

Exemple

La liste des valeurs à sélectionner aléatoirement n=2est:

[10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98]

Python 2 , 77 octets

from random import*
r=range(10)
while[1]>r:shuffle(r)
print`r`[1:input()*3:3]

Essayez-le en ligne!

Mélange la liste des 10 chiffres jusqu'à ce qu'elle ne commence pas par 0, puis crée un nombre avec les premiers nchiffres répertoriés.

Brachylog , 9 10 octets

{~lℕ₁≜≠}ᶠṛ

Essayez-le en ligne!

Comme d'habitude pour Brachylog, il s'agit d'une soumission de fonction. Le lien TIO ci-dessus a reçu un argument de ligne de commande pour transformer la fonction en programme complet.

J'ai dû ajouter un octet supplémentaire à partir de la première version de ceci, en changeant ℕenℕ₁ , pour interdire la sortie 0 (quelque chose qui a maintenant été clarifié).

Explication

{~lℕ₁≜≠}ᶠṛ
{      }ᶠṛ  Pick a random value with these properties:
 ~l           it has length equal to the input;
   ℕ₁         it's a positive integer;
     ≜        it's a specific value (not a constraint);
      ≠       all its elements (digits in this case) are different.

Assez inefficace, car l'interpréteur génère une liste de toutes les valeurs possibles, puis en choisit une au hasard (c'est ce que ᶠṛsignifie; Brachylog n'avait pas d'option "choisir une solution aléatoire" au moment où cette question a été posée).

Quelques commentaires sur l'étiquetage ici: si le ≜est omis, la section entre les accolades ne produit qu'une seule valeur, une contrainte représentant les nombres avec la propriété que nous voulons; choisir un résultat aléatoire nous donne donc la contrainte, et l'interpréteur sort la valeur absolue minimale qui respecte la contrainte (1, 10, 102, 1023, 10234, etc.), ce qui n'est pas ce que nous voulons. Il faut donc le forcer à construire la liste via une étiquetage explicite.

La plupart des implémentations de Prolog que j'ai vues ont une fonction intégrée pour trouver un résultat aléatoire correspondant à une contrainte, mais généralement pas avec une probabilité uniforme; Brachylog n'en avait pas, cependant (un a été ajouté en réponse à ce défi, mais je ne peux évidemment pas l'utiliser en raison de règles d'échappatoire). Si tel était le cas, et s'il ~lℕ₁≠s'avérait donner une probabilité uniforme sur ce problème, ce programme serait simplement suivi par ce module intégré, pour une longueur probable de 6 octets.

Brachylog , 8 octets, en collaboration avec @Fatalize

~lℕ₁≠≜ᶠṛ

Essayez-le en ligne!

C'est le genre de truc de génie de bas niveau qui n'a de sens que dans la façon dont Prolog fait les choses et n'a pas beaucoup de sens lorsqu'il est décrit mathématiquement.

Comme précédemment, ~lℕ₁≠construit une valeur qui décrit une contrainte ("longueur égale à l'entrée, nombre naturel, tous les éléments différents"). Génère ensuite ≜ᶠtoutes les valeurs possibles qui respectent la contrainte. Le point ici est qu'avec la séquence d'évaluation de Brachylog, aucun choix réel n'est fait jusqu'à ce que ≜s'affiche, donc l'opération "trouver toutes les solutions" ne ᶠdoit s'appliquer qu'à la "valeur spécifique qui remplit une contrainte" ≜. Cela signifie qu'il n'est pas nécessaire pour a {…}de sélectionner sa portée, économisant 2 octets.

Gelée , 9 octets

⁵*ṖQL$€MX

Essayez-le en ligne! (ne fonctionnera pas chez TIO pour n> 6 en raison de l'inefficacité de la mise en œuvre)

ou une implémentation alternative de la même chose:

⁵*ṖQL$ÐṀX

Comment?

C'est assez sournois et très inefficace! Jelly fait certaines choses utiles implicitement lorsqu'un atome attend une liste mais reçoit un entier (c'est voulu par la conception).
Ce code utilise quelques-unes de ces actions implicites utiles:

• L'atome monadique Ṗ, "pop", lorsqu'il est appelé avec une entrée entière crée implicitement une plage à partir de laquelle éclater, donc une entrée de n fait d'abord [1, 2, ..., n] , puis éclate, donnant [1, 2 , ..., n-1] .

• L'atome monadique Q, "de-dupliquer" ou "unique", lorsqu'il est appelé avec une entrée entière fait implicitement une liste décimale à dédoublonner, donc une entrée de n où:
  n = d _k-1 × 10 ^k-1 + d _k-2 × 10 ^k-2 + ... + d ₁ × 10 + d ₀
  crée d'abord
  [d _k-1 , d _k-2 , ..., d ₁ , d ₀ ]
  puis donne les valeurs uniques par première impression.
  Ainsi, par exemple, n = 5835518 donnerait [5, 8, 3, 1] .

De plus, l'atome monadique M, "index d'éléments maximaux", renvoie les index des éléments maximaux d'une liste, ce qui économise deux octets par rapport à l'alternative beaucoup plus évidente de tester l'égalité avec l'entrée et de trouver des index véridiques ⁵*ṖQL$€=⁸TX, ou⁵*ṖðQL⁼ð€TX

⁵*ṖQL$€MX - Main link: n                       e.g. 2
⁵         - literal 10
 *        - exponentiate: 10^n                      100
  Ṗ       - pop (make range 1 to 10^n, then pop)    [1  ,2  ,...,21   ,22 ,23   ,...,97   ,98   ,99]
     $€   - last two links as a monad for €ach:
   Q      -   unique (makes a decimal list first)   [[1],[2],...,[2,1],[2],[2,3],...,[9,7],[9,8],[9]]
    L     -   length                                [1  ,1  ,...,2    ,1  ,2    ,...,2    ,2    ,1  ]
       M  - indexes of maximal elements             [        ...,21       ,23,   ...,97   ,98       ]
          -                                         - i.e. all n-digit numbers with n-distinct digits.
        X - pick a random element from that list

Tout cela est assez inefficace, à la fois en temps et en mémoire: d'abord une liste de 10 ⁿ entiers est faite et un est rejeté, puis pour chacun d'eux une liste de n entiers (pas un objet 4 bits ou une énumération de fantaisie) est faite puis dédoublonné. Cette déduplication a une implémentation entièrement basée sur une liste (aucun ensemble, ensemble trié ou dictionnaire n'est impliqué sous le capot, chaque chiffre est vérifié pour l'existence dans la liste qui obtient finalement la sortie).
Hors ligne n = 7 utilise ~ 0,5 Go et prend ~ 25 secondes, tandis que n = 8 utilise ~ 4 Go et prend ~ 5 minutes - je n'ai pas pris la peine de courir n = 9 car je n'ai que 16 Go de RAM (je suppose que cela prendrait ~ 45 minutes ).

L'implémentation alternative utilise simplement le ÐṀfiltre rapide intégré pour conserver le minimum (ce qui ajoute juste un peu de surcharge dans la gestion pour le même nombre d'octets).

Gelée , 11 octets

9Xœ|⁵ḶẊ¤ḣ¹Ḍ

Essayez-le en ligne!

Comment ça marche

9Xœ|⁵ḶẊ¤ḣ¹Ḍ  Main link. Argument: n

9            Set the return value to 9.
 X           Pick; pseudo-randomly select an integer from [1, ..., 9].
       ¤     Combine the three preceding links into a niladic chain.
    ⁵          Yield 10.
     Ḷ         Unlength; yield [0, ..., 9].
      Ẋ        Shuffle; pseudo-randomly select a permutation of [0, ..., 9].
  œ|         Multiset OR; prepend the selected integer to the selected permutation
             and remove the second occurrence of the first element.
         ¹   Identity; yield n.
        ḣ    Head; keep the first n digits of the permutation.
          Ḍ  Undecimal; convert from base 10 to integer.

JavaScript (ES6), 72 71 70 69 octets

f=(x,y="")=>x?!y.match(z=Math.random()*10|0)&&y|z?f(x-1,y+z):f(x,y):y

Il s'agit d'une fonction récursive qui prend le nombre de chiffres x . Le deuxième paramètre y , initialement défini sur la chaîne vide, garde une trace du nombre lorsque nous le générons chiffre par chiffre.

D'abord, nous générons un chiffre aléatoire z avec Math.random()*10|0. Maintenant, nous voulons vérifier que le y ne contient pas z , et que y et z ne sont pas tous les deux 0 .

On peut calculer la première condition avec !y.match(z). y.match(z)renvoie un tableau (toujours vrai) si y contient z , null (faux) sinon; le !convertit en un booléen et l'inverse.

La deuxième condition est vérifiée avec y|z. Bien que y soit une chaîne, JS la convertit implicitement en un entier lors de l'utilisation |. Il s'agit d'un entier positif si y contient déjà des chiffres, 0 sinon. Le résultat net est que y|zrenvoie 0 si y est vide et z est 0 , ou un entier positif sinon.

Si ces deux conditions sont remplies, nous ajoutons le chiffre à y , décrémentons x et recommençons le processus. Sinon, nous revenons simplement au début et espérons que le prochain chiffre aléatoire fonctionne. Lorsque x atteint 0 , nous renvoyons simplement la chaîne vide pour terminer la récursivité.

La version précédente:

f=(x,y)=>x?~y>>(z=Math.random()*10|0)&1&&y|z?z+f(x-1,y|1<<z):f(x,y):""

Il s'agit d'une fonction récursive qui prend le nombre de chiffres. Le deuxième paramètre initialement indéfini, y , est une table de recherche à 10 bits qui nous indique les chiffres que nous avons déjà, commodément stockés sous forme d'entier.

D'abord, nous générons un chiffre aléatoire z avec Math.random()*10|0. Maintenant, nous voulons vérifier que le zième bit le moins significatif de y n'est pas défini, et que y et z ne sont pas tous les deux 0 .

On peut calculer la première condition avec ~y>>z&1; inverser y , le déplacer de z bits vers la droite et ne prendre que le bit le moins significatif. Cela donne 1 si nous n'avons pas encore généré le chiffre en question, ou 0 sinon.

La deuxième condition était initialement assez difficile à comprendre (j'ai essayé d'utiliser y/zd'abord pour générer NaNs'ils sont tous les deux 0), mais à un moment donné, j'ai réalisé que cela y|zferait tout simplement l'affaire. Le résultat est 0 ssi y et z sont 0 ; sinon un entier positif.

Si ces deux conditions sont vraies ( ~y>>z&1&&y|z), alors nous générons le reste du nombre et ajoutons z . Le reste du nombre est généré en appelant à nouveau la fonction avec x-1et y|1<<z( y , mais avec le bit d'index z mis à 1 ). Lorsque x atteint 0 , nous renvoyons simplement la chaîne vide pour terminer la récursivité.

ClojureScript, 81 79 octets

#(let[a(subvec(shuffle(range 10))0 %)](if(=(a 0)0)(recur %)(int(apply str a))))

Il s'agit d'une fonction anonyme, vous devez donc l'utiliser comme ceci:

(#(...) {arguments})

Où vous remplacez {arguments} par vos arguments.

Vous pouvez essayer le code ici (ClojureScript REPL).

Merci d' @cliffrootavoir rasé 2 octets!

Code développé:

(defn random-digits [n]
  (let [num-vector
        (subvec
          (shuffle (range 10))
          0 n)]
    (if (= (num-vector 0) 0)
      (recur n)
      (int (apply str num-vector)))))

Explication:

Je vais parcourir les lignes une par une, en utilisant un exemple d'entrée de 8.

(defn random-digits [n] ...)

Assez simple, cela définit la fonction random-digitsavec un argument, appelé n. Dans ma réponse, j'ai utilisé une fonction anonyme ( #(...)), pour économiser des octets.

(let [num-vector ...] ...)

Examinons de l'intérieur let, de l'intérieur:

(shuffle (range 10))

En ClojureScript (et Clojure), (range n)est similaire à Python range(n): il vous donne une liste avec chaque numéro de 0à n - 1( 9dans ce cas).

shuffleprend une liste et renvoie un vecteur (qui est légèrement différent d'une liste) avec tous ses éléments mélangés. Donc, en utilisant notre exemple, nous obtenons quelque chose comme ceci:

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

(subvec {see above} 0 n)

(subvec vector start end)prend un vecteur (seulement un vecteur) et retourne un vecteur qui a tous les éléments de l'index startà end. Dans ce cas, nous prenons des éléments du 0th élément à l'argument donné à random-digits. Si nous appliquons cela à notre exemple, nous obtenons:

[1 0 8 3 6 7 9 2]

(if (= (num-vector 0) 0)
  (recur n)
  (int (apply str num-vector)))

Cette ifinstruction vérifie si le premier élément de num-vectorest a 0.

Si c'est le cas 0, alors nous appelons à nouveau la fonction, avec l'argument n, en utilisant recur.

Si ce n'est pas le cas 0:

(int (apply str num-vector))

(apply function list)prend une liste et les crache dans la fonction comme arguments. Par exemple:

(apply + [2 3 4])

Se transforme en:

(+ 2 3 4)

Ce qui équivaut 9.

(str items)transforme chaque élément itemsen une chaîne, puis les concatène. intconvertit n'importe quoi en entier. Donc, si nous appliquons cela à notre exemple, nous obtenons:

   (int (apply str [1 0 8 3 6 7 9 2]))
=> (int (str 1 0 8 3 6 7 9 2))
=> (int "10836792")
=> 10836792

Quelle est notre réponse finale.

Python 2, 89 81 80 octets

from random import*
lambda n:choice([i for i in range(10**n)if`set(`i`)`[5*n:]])

Essayez-le en ligne

R, 45 octets

k=0
i=scan()
while(!k[1])k=sample(0:9)[1:i]
k

Utilitaires Bash + GNU, 46

seq 1e$[$1-1] 1e$1|egrep -v '(.).*\1'|shuf -n1

Essayez-le en ligne .

Cela prend beaucoup de temps pour les n plus grands - environ 30 secondes pour n = 7, et augmente 10 fois pour chaque incrément, donc probablement 8 à 9 heures pour n = 10.

Java 7, 150 147 145 134 octets

String c(int n){String r="";for(int l,x;(l=r.length())<n;)if(l<1&(x=(int)(Math.random()*10))>0|(l>0&!r.contains(""+x)))r+=x;return r;}

-2 octets grâce à @TheLethalCoder

(ancienne) Explication:

String c(int n){                           // Method with integer parameter and String return-type
  String r="";                             //  Result-String
  for(int l=0,x;l<n;l=r.length()){         //  Loop until the length of the result-String is equal to the parameter integer
    x=new java.util.Random().nextInt(10);  //   Random digit
    if((l<1&x>0)                           //   If the length is zero and the random digit is not zero
       |(l>0&!r.contains(""+x)))           //     or the length is at least 1, and the result-String does not contain this random digit yet
      r+=x;                                //    Append the random digit to the result-String
  }                                        //  End of for-loop
  return r;                                //  Return result-String
}                                          // End of method

Code de test:

Essayez-le ici.

class M{
  String c(int n){String r="";for(int l,x;(l=r.length())<n;)if(l<1&(x=(int)(Math.random()*10))>0|(l>0&!r.contains(""+x)))r+=x;return r;}

  public static void main(String[] a){
    M m = new M();
    System.out.println(m.c(4));
    System.out.println(m.c(10));
  }
}

Exemple de sortie:

7194
8672953041

Perl 6 , 44 octets

{(->{+[~] (^10).pick($_)}...*>9 x$_-1).tail}

Essayez-le

Étendu:

{  # bare block with implicit parameter ｢$_｣
  (

    ->{  # pointy block lambda with no parameters

      +                # turn the following into a numeric
      [~]              # concatenate the following

        (^10).pick($_) # grab $_ digits at random from 0..9
    }

    ...                # keep doing that until

    * > 9 x $_-1       # one of them is big enough

  ).tail # return the last one (only valid one)
}

PHP, 67 octets

Version en ligne

Toutes les versions basées sur un mélange des chiffres de 0 à 9

for($a=range(0,9);!$a[0];)shuffle($a);for(;$i<$argn;)echo$a[+$i++];

71 octets

for($s="0123456789";!$s[0];)$s=str_shuffle($s);echo substr($s,0,$argn);

73 octets

for($a=range(0,9);!$a[0];)shuffle($a);echo join(array_slice($a,0,$argn));

MATL , 15 octets

`4Y2GZr1)48=]8M

Essayez-le sur MATL Online!

Explication

`        % Do...while
  4Y2    %   Push predefined literal '0123456789'
  G      %   Push input n
  Zr     %   Random sample of n unique characters from that string
  1)     %   Pick the first
  48=    %   Is it 48? This is the loop condition
]        % End. If top of the stack evaluates to true: next iteration
8M       % Push the latest random sample. Implicitly display

Gelée , 12 octets

9×!X+!Œ?’ḣƓḌ

Actuellement, un octet derrière mon autre réponse Jelly, mais j'aime vraiment celle-ci.

Essayez-le en ligne!

Comment ça marche

9×!X+!Œ?’ḣƓḌ  Main link. No arguments.

9             Set the argument and the return value to 9.
  !           Yield 9!
 ×            Compute 9 × 9!.
   X          Pick; pseudo-randomly select an integer j from [1, ..., 9 × 9!].
     !        Yield 9!
    +         Compute k := j + 9!.
              The result will belong to [9! + 1, 10!].
      Œ?      Get the permutation P of R := [1, ..., r], with minimal r, such that
              P is the lexicographically k-th permutation of R.
              Since k belongs to [9! + 1, 10!], r = 10 and this generates a per-
              mutation between [2,1,3,4,5,6,7,8,9,10] and [10,9,8,7,6,5,4,3,2,1].
        ’     Subtract 1 from all integers in P.
          Ɠ   Read an integer n from STDIN and yield it.
         ḣ    Head; keep the first n digits of the permutation.
           Ḍ  Undecimal; convert from base 10 to integer.

APL (Dyalog) , 27 19 17 octets

Requiert ⎕IO←0ce qui est par défaut sur de nombreux systèmes.

10⊥⊢↑{?⍨10}⍣{×⊃⍺}

Essayez-le en ligne!

Mélange les chiffres jusqu'à ce qu'ils soient valides:

10⊥ décoder des chiffres de base 10 en nombre régulier,

⊢ puis

↑ premiers éléments de

{... }⍣{... } répéter la fonction ...
 ?⍨10 mélanger les dix premiers entiers positifs
jusqu'à ce que ...
 ⊃⍺ le premier chiffre de la dernière tentative
 × est positive

Python 2 , 100 93 92 90 octets

Merci à @ mbomb007 pour avoir rasé 2 octets

from random import*
def f(n):k=randint(10**~-n,10**n-1);return(n==len(set(`k`)))*k or f(n)

Essaie les nombres dans le champ requis jusqu'à ce que l'un soit trouvé avec des chiffres uniques. Je parie qu'il existe une façon beaucoup plus propre de le faire, mais aucune ne me vient à l'esprit.

Pyth , 11 octets

jk<{+OS9.ST
jk<{+OS9.STQ implicit Q

       9     9
      S      [1,2,3,4,5,6,7,8,9]
     O       random element

          T  10
        .S   random permutation of [0,1,2,3,4,5,6,7,8,9]

    +        add the results from the previous two paragraphs together
   {         deduplicate
  <        Q first (input) elements
jk           join by empty string

Utilise le même algorithme que la réponse de Dennis .

Essayez-le en ligne!

Perl, 48 octets

1until$_=1+int rand 10**$n-1,/.{$n}/&&!/(.).*\1/

Explication:

Générez de manière répétée des entiers aléatoires de 1 à 10 ** $ n-1, en les rejetant jusqu'à ce qu'il y en ait un de la bonne longueur (donc au moins 10 ** ($ n-1)) sans chiffres répétés.

Lot, 156 octets

@set/af=9,r=x=0
@for /l %%i in (1,1,%1)do @call:c
@echo %r%
@exit/b
:c
@set/a"d=9-%random%%%f,e=x>>d&1
@if %e%==1 goto c
@set/a"r=r*10+d,f=10,x|=1<<d

xconserve un masque de bits de chiffres utilisés. findique le nombre de chiffres disponibles (compte à rebours de 9). Des chiffres aléatoires sont générés jusqu'à ce qu'un chiffre inutilisé soit trouvé. n=10pourrait être pris en charge pour 165 octets:

@set/af=9,r=x=0
@for /l %%i in (1,1,%1)do @call:c
@echo %r:~1%
@exit/b
:c
@set/a"d=9-%random%%%f,e=x>>d&1
@if %e%==1 goto c
@set r=%r%%d%
@set/a"f=10,x|=1<<d

( rcontient un zéro de tête supplémentaire car il est golfeur de cette façon.) L'approche précédente pour 165 octets a mis en majuscule le premier chiffre, et s'est également avérée fonctionner avec n=10(la version numérique a en fait pris 166 octets!):

@set/ar=%random%%%9+1,x=0
@for /l %%i in (2,1,%1)do @set/a"x|=1<<d"&call:c
@echo %r%
@exit/b
:c
@set/a"d=%random%%%10,e=x>>d&1
@if %e%==1 goto c
@set r=%r%%d%

L'approche originale pour 170 octets a également fonctionné pour n=10:

@set/ar=%random%%%9+1
@for /l %%i in (2,1,%1)do @call:c
@echo %r%
@exit/b
:c
@set/ad=%random%%%10
@call set s=%%r:%d%=%%
@if not "%s%"=="%r%" goto c
@set r=%r%%d%

Utilise la manipulation de chaînes pour détecter les chiffres en double.

Bash , 66 octets

a=0;while [[ $a == 0* ]];do a=`shuf -i0-9 -n$1|xargs`;done;echo $a

Essayez-le en ligne!

Simple, utilise shuf, xargs est utilisé pour joindre les lignes et continue d'essayer pendant que la combinaison commence par 0.

Cant beat 46 char from other answer but is is fast!

Pyth, 15 28 octets

=+YhO9VtQ#KOTI!hxYK=+YKB;jkY

Essayez-le ici

C #, 127 132 128 126 125 125 octets

n=>{var s="";for(int l,r;(l=s.Length)<n;)if((l<1&(r=new System.Random().Next(10))>0)|(l>0&!s.Contains(r+"")))s+=r;return s;};

Essayez-le en ligne!

A emprunté l'idée de la réponse de @ KevinCruijssen pour initialiser l'aléatoire r, dans leif instruction pour économiser 2 octets.

Je suis sûr que cela peut être joué plus loin, mais je n'ai pas le temps pour le moment.

Ancienne version utilisant une whileboucle:

n=>{var s="";while(s.Length<n){int r=new System.Random().Next(10);if(s.Length<1&r>0)s+=r;else if(!s.Contains(r+""))s+=r;}return s;};

C (gcc) , 123 122 100 95 104 103 99 97 octets

Celui-ci génère un nombre aléatoire réel

j;f(n){for(int i,k=n,s[10]={j=0};n;s[i+=i?0:k==n]=!s[i]?j+=i*pow(10,--n):1)i=rand()%10;return j;}

Essayez-le en ligne!

C (gcc) , 87 85 octets

Ici, il imprime une chaîne de chiffres.

f(n){for(int i,k=n,s[10]={0};n;s[i+=i?0:k==n]=!s[i]?--n,putchar(48+i):1)i=rand()%10;}

Essayez-le en ligne!

PHP, 65 63 octets

while(count(count_chars($x=rand(1,10**$argn),1))<$argn);echo$x;

prend l'entrée de STDIN; courir avec-nR .

créer un nombre aléatoire entre 1et 10^Ninclusif;
répéter pendant que le nombre de caractères distincts est < N.

Mathematica 65 60 octets

0For[a=11,Max@DigitCount@a>1,a=RandomInteger[10^{#-1,#}]]+a&

Voici une version plus rapide mais ajoute 9 octets:

FromDigits@Join[f=(s=RandomSample)[r=Range@9,1],s[r/.f[[1]]->0,#-1]]&

Java 9 JShell, 86 octets

n->new Random().longs(0,10).limit(n-1).reduce(new Random().nextInt(9)+1,(a,b)->a*10+b)

Essayez-le en ligne!

Remarque: je ne compte pas les importations car ces packages sont importés par défaut dans JShell, mais il n'y a pas de lien Try-it-online que je connaisse pour JShell, donc j'en ai fourni un pour Java 9 avec le code d'en-tête et de pied de page à faire fonctionner dans ce contexte. Dans JShell, vous pouvez simplement faire:

jshell> Function<Integer,Long> f =
   ...> n->new Random().longs(0,10).limit(n-1).reduce(new Random().nextInt(9)+1,(a,b)->a*10+b)
f ==> $Lambda$27/633070006@5702b3b1

Et alors:

jshell> f.apply(6)
$26 ==> 746202

Comment ça marche:

Nous définissons une fonction de Integer à Long et créons un flux infini de longs aléatoires dans la plage de 0-9, la limitons aux n-1 premiers éléments, puis la réduisons avec un int aléatoire de 1-9 comme valeur initiale et une fonction qui multiplie la valeur par 10 et ajoute la valeur suivante du flux.

J'ai utilisé des longs donc cela devrait fonctionner jusqu'à environ 18 chiffres (n = 18).

C, 96 93 octets

f(n){char d[11],i=0,r;for(;i++^10;d[i-1]=d[r=rand()%i],d[r]=47+i);*d^48?d[n]=0,puts(d):f(n);}

Fisher-Yates mélange l'initialisation jusqu'à ce que le premier chiffre ne soit pas nul.

Est uniforme, en supposant qu'il rand()%iest uniforme. (Puisque pour la plupart i RAND_MAX/ilaisse un petit reste, il y a un très petit biais. Ce biais devient plus petit à mesure que RAND_MAX grandit.)

Voyez-le fonctionner en ligne .

Voyez-le générer des nombres corrects lorsque n est égal à 2, comme indiqué dans la question .

Axiome, 191 octets

g(a:NNI):Complex INT==(a<1 or a>9=>%i;r:List NNI:=[];b:=a;repeat(a=0=>break;d:=random()$INT rem 10;a=b and d=0=>0;~member?(d,r)=>(a:=a-1;r:=cons(d,r)));reduce(+,[r.i*10^(i-1)for i in 1..#r]))

débloquer, résultat du test

-- Return one number of 'a' different random digits if 0<a<10
f(a:NNI):Complex INT==
    a<1 or a>9=>%i
    r:List NNI:=[];b:=a
    repeat
       a=0=>break
       d:=random()$INT rem 10
       a=b and d=0  =>0
       ~member?(d,r)=>(a:=a-1;r:=cons(d,r))
    reduce(+,[r.i*10^(i-1)for i in 1..#r])

(4) -> [[i,g(i)] for i in 0..10]
   (4)
   [[0,%i], [1,9], [2,76], [3,135], [4,6810], [5,48675], [6,415768],
    [7,7461539], [8,98421537], [9,825046739], [10,%i]]
                                          Type: List List Complex Integer
(5) -> [[i,g(i)] for i in [3,3,3,3,3,3,3,3,3]]
   (5)
   [[3,653],[3,128],[3,254],[3,268],[3,914],[3,594],[3,276],[3,240],[3,398]]

Méduse , 17 octets

p
d^u ?
 j?r10
10

Essayez-le en ligne!

Fork de la réponse de Dennis 'Jelly .

Rubis, 53 52 octets

Mélangez jusqu'à ce que le premier chiffre ne soit pas 0, puis combinez les chiffres et convertissez-les en entier.

->n{a=*0..9;a.shuffle!while a[0]==0;eval a[0,n]*''}

Essayez-le en ligne!