Ho letto questa domanda e ho pensato che sarebbe stata una bella sfida.

Compito

Dai un input 0<n<10genera un numero casuale con

• esattamente n cifre
• il primo non a 0
  • così f(n)>10**(n-1)-1
• cifre distinte

Criteri vincenti

Questo è code-golf, quindi vince il codice più breve.

Casuale

Intendo distribuito uniformemente in modo casuale. Quindi dal punto di vista del programma ogni possibile numero ha le stesse possibilità. Se la lingua in cui stai scrivendo ha uno strano generatore di numeri casuali, va bene usarlo.

Esempio

L'elenco di valori da cui selezionare casualmente per n=2è:

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

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

Provalo online!

Mescola l'elenco di 10 cifre fino a quando non inizia con 0, quindi crea un numero con le prime ncifre elencate.

Brachylog , 9 10 byte

{~lℕ₁≜≠}ᶠṛ

Provalo online!

Come al solito per Brachylog, questa è una presentazione di funzioni. Al link TIO sopra è stato dato un argomento da riga di comando per trasformare la funzione in un programma completo.

Ho dovuto aggiungere un byte extra dalla prima versione di questo, cambiando ℕin ℕ₁, per non consentire l'uscita 0 (qualcosa che ora è stato chiarito).

Spiegazione

{~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.

Abbastanza inefficiente, perché l'interprete genera un elenco di tutti i possibili valori e quindi ne sceglie uno a caso (questo è ciò che ᶠṛsignifica; Brachylog non aveva un'opzione "scegli una soluzione casuale" al momento in cui è stata posta questa domanda).

Alcuni commenti sull'etichettatura qui: se ≜omesso, la sezione tra parentesi graffe produce solo un valore, un vincolo che rappresenta i numeri con la proprietà che vogliamo; la scelta di un risultato casuale ci dà quindi il vincolo e l'interprete emette il valore assoluto minimo che soddisfa il vincolo (1, 10, 102, 1023, 10234, ecc.), che non è quello che vogliamo. Dobbiamo quindi costringerlo a costruire l'elenco tramite un'etichettatura esplicita.

La maggior parte delle implementazioni di Prolog che ho visto hanno un builtin per trovare un risultato casuale corrispondente a un vincolo, ma in genere non con probabilità uniforme; Brachylog non ne aveva uno, però (uno è stato aggiunto in risposta a questa sfida, ma ovviamente non posso usarlo a causa delle regole di scappatoia). In tal caso, e se si fosse trattato di dare una probabilità uniforme su questo problema, questo programma sarebbe ~lℕ₁≠seguito da quel built-in, per una probabile lunghezza di 6 byte.

Brachylog , 8 byte, in collaborazione con @Fatalize

~lℕ₁≠≜ᶠṛ

Provalo online!

Questo è il tipo di geniale trucco di basso livello che ha senso solo nel modo in cui Prolog fa le cose e non ha molto senso se descritto matematicamente.

Come prima, ~lℕ₁≠crea un valore che descrive un vincolo ("lunghezza uguale all'input, numero naturale, tutti gli elementi diversi"). Quindi ≜ᶠgenera tutti i possibili valori che soddisfano il vincolo. Il punto qui è che con la sequenza di valutazione di Brachylog, non vengono fatte scelte effettive fino a quando non ≜appare, quindi l'operazione "trova tutte le soluzioni" non si ᶠapplica a nient'altro che all'operazione "valore specifico che soddisfa un vincolo" ≜. Ciò significa che non è necessario che {…}a ne selezioni l'ambito, risparmiando 2 byte.

Gelatina , 9 byte

⁵*ṖQL$€MX

Provalo online! (non funzionerà in TIO per n> 6 a causa dell'inefficienza dell'implementazione)

o un'implementazione alternativa della stessa cosa:

⁵*ṖQL$ÐṀX

Come?

Questo è piuttosto subdolo e molto inefficiente! Jelly fa alcune cose utili implicitamente quando un atomo si aspetta un elenco ma riceve un numero intero (questo è di progettazione).
Questo codice utilizza un paio di queste utili azioni implicite:

• L'atomo monadico Ṗ, "pop", quando chiamato con un input intero fa implicitamente un intervallo da cui pop, quindi un input di n fa prima [1, 2, ..., n] , quindi si apre, producendo [1, 2 , ..., n-1] .

• L'atomo monadico Q, "de-duplicato" o "unico", quando viene chiamato con un input intero fa implicitamente un elenco decimale da de-duplicare, quindi un input di n dove:
  n = d _k-1 × 10 ^k-1 + d _k-2 × 10 ^k-2 + ... + d ₁ × 10 + d ₀
  crea prima
  [d _k-1 , d _k-2 , ..., d ₁ , d ₀ ]
  e quindi restituisce i valori univoci di prima impressione.
  Quindi, ad esempio, n = 5835518 darebbe [5, 8, 3, 1] .

Inoltre, l'atomo monadico M, "indici degli elementi massimi", restituisce gli indici degli elementi massimi da un elenco, risparmiando due byte sull'alternativa molto più ovvia di testare l'uguaglianza con l'input e trovare indici di verità ⁵*ṖQL$€=⁸TX, oppure⁵*Ṗð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

Tutto questo è abbastanza inefficiente, sia nel tempo che nella memoria: prima viene creato un elenco di 10 ⁿ numeri interi e uno viene scartato, quindi per ognuno di questi viene creato un elenco di n numeri interi (non un oggetto o enum di fantasia a 4 bit) e quindi de-duplicato. Questa deduplicazione ha un'implementazione completamente basata su elenco (non sono inclusi set, set ordinati o dizionari sottotitoli, ogni cifra viene verificata per l'esistenza nell'elenco che alla fine ottiene l'output).
Non in linea n = 7 utilizza ~ 0,5 GB e impiega ~ 25 secondi, mentre n = 8 utilizza ~ 4 GB e impiega ~ 5 minuti - Non mi sono preoccupato di correre n = 9 poiché ho solo 16 GB di RAM (suppongo che impiegherebbe ~ 45 minuti ).

L'implementazione alternativa utilizza solo il ÐṀrapido incorporato per filtrare e mantenere il minimo (che qui aggiunge solo un po 'di sovraccarico nella gestione per lo stesso conteggio byte).

Gelatina , 11 byte

9Xœ|⁵ḶẊ¤ḣ¹Ḍ

Provalo online!

Come funziona

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 byte

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

Questa è una funzione ricorsiva che accetta il numero di cifre x . Il secondo parametro y , inizialmente impostato sulla stringa vuota, tiene traccia del numero mentre lo generiamo cifra per cifra.

Innanzitutto generiamo una cifra casuale z con Math.random()*10|0. Ora, vogliamo verificare che la y non contiene z , e che y e z non sono entrambi 0 .

Possiamo calcolare la prima condizione con !y.match(z). y.match(z)restituisce un array (sempre true) se y contiene z , null (falsy) altrimenti; il !converte in booleano e lo inverte.

La seconda condizione è verificata con y|z. Sebbene y sia una stringa, JS la converte implicitamente in un numero intero durante l'utilizzo |. Questo è un numero intero positivo se y contiene già cifre, 0 altrimenti. Il risultato netto è che y|zrestituisce 0 se y è vuoto e z è 0 , altrimenti un numero intero positivo.

Se entrambe queste condizioni sono vere, allora aggiungiamo la cifra a y , diminuiamo x e ricominciamo il processo. Altrimenti, torniamo semplicemente all'inizio e speriamo che la prossima cifra casuale funzioni. Quando x raggiunge 0 , restituiamo semplicemente la stringa vuota per terminare la ricorsione.

Versione precedente:

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

Questa è una funzione ricorsiva che accetta il numero di cifre. Il secondo parametro inizialmente indefinito, y , è una tabella di ricerca a 10 bit che ci dice quali cifre abbiamo già, comodamente memorizzate come numeri interi.

Innanzitutto generiamo una cifra casuale z con Math.random()*10|0. Ora, vogliamo verificare che la z 'esimo bit meno significativo di y non è impostato, e che y e z non sono entrambi 0 .

Possiamo calcolare la prima condizione con ~y>>z&1; invertire y , spostarlo di z bit verso destra e prendere solo il bit meno significativo. Questo dà 1 se non abbiamo ancora generato la cifra in questione, o 0 altrimenti.

Inizialmente la seconda condizione era piuttosto difficile da capire (ho provato a usare y/zinizialmente per generare NaNse sono entrambi 0), ma a un certo punto mi sono reso conto che y|zavrebbe semplicemente funzionato. Il risultato è 0 se sia y che z sono 0 ; un numero intero positivo altrimenti.

Se entrambe queste condizioni sono vere ( ~y>>z&1&&y|z), generiamo il resto del numero e anteponiamo z . Il resto del numero viene generato chiamando nuovamente la funzione con x-1e y|1<<z( y , ma con il bit all'indice z impostato su 1 ). Quando x raggiunge 0 , restituiamo semplicemente la stringa vuota per terminare la ricorsione.

ClojureScript, 81 79 byte

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

Questa è una funzione anonima, quindi devi usarla in questo modo:

(#(...) {arguments})

Dove sostituisci {arguments}con i tuoi argomenti.

Puoi provare il codice qui (ClojureScript REPL).

Grazie @cliffrootper aver rasato 2 byte!

Codice espanso:

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

Spiegazione:

Esaminerò le righe una ad una, usando un input di esempio di 8.

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

Abbastanza semplice, questo definisce la funzione random-digitscon un argomento, chiamato n. Nella mia risposta ho usato una funzione anonima ( #(...)), per salvare byte.

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

Esaminiamo dentro let, da dentro e fuori:

(shuffle (range 10))

In ClojureScript (e Clojure), (range n)è simile a quello di Python range(n): ti dà un elenco con tutti i numeri da 0a n - 1( 9in questo caso).

shuffleprende un elenco e restituisce un vettore (che è leggermente diverso da un elenco) con tutti i suoi elementi mescolati. Quindi, usando il nostro esempio, otteniamo qualcosa del genere:

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

(subvec {see above} 0 n)

(subvec vector start end)prende un vettore (solo un vettore) e restituisce un vettore che ha tutti gli elementi dall'indice starta end. In questo caso, stiamo prendendo elementi dal 0th elemento all'argomento dato a random-digits. Se lo applichiamo al nostro esempio, otteniamo:

[1 0 8 3 6 7 9 2]

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

Questa ifaffermazione verifica se il primo elemento di num-vectorè a 0.

Se lo è 0, allora chiamiamo di nuovo la funzione, con l'argomento n, usando recur.

Se non lo è 0:

(int (apply str num-vector))

(apply function list)prende un elenco e li sputa nella funzione come argomenti. Per esempio:

(apply + [2 3 4])

Diventa:

(+ 2 3 4)

Che è uguale 9.

(str items)trasforma ogni elemento itemsin una stringa e quindi li concatena. intconverte qualsiasi cosa in un numero intero. Quindi se applichiamo questo al nostro esempio, otteniamo:

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

Qual è la nostra risposta finale.

Python 2, 89 81 80 byte

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

Provalo online

R, 45 byte

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

Utilità Bash + GNU, 46

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

Provalo online .

Questo richiede molto tempo per n più grandi - circa 30 secondi per n = 7 e aumentando di 10 volte per ogni incremento, quindi probabilmente 8-9 ore per n = 10.

Java 7, 150 147 145 134 byte

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 byte grazie a @TheLethalCoder

(vecchio) Spiegazione:

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

Codice di prova:

Provalo qui.

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));
  }
}

Esempio di output:

7194
8672953041

Perl 6 , 44 byte

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

Provalo

Allargato:

{  # 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 byte

Versione online

Tutte le versioni basate su mescolano le cifre da 0-9

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

71 byte

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

73 byte

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

MATL , 15 byte

`4Y2GZr1)48=]8M

Provalo su MATL Online!

Spiegazione

`        % 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

Gelatina , 12 byte

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

Attualmente un byte dietro l'altra mia risposta di Jelly, ma questo mi piace molto.

Provalo online!

Come funziona

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 byte

Richiede il ⎕IO←0valore predefinito su molti sistemi.

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

Provalo online!

Mescola le cifre fino a quando non sono valide:

10⊥ decodifica da cifre in base 10 a numero normale,

⊢ poi

↑ primi elementi di

{... }⍣{... } ripetendo la funzione ...
 ?⍨10 mescola i primi dieci numeri interi positivi
fino a ...
 ⊃⍺ la prima cifra dell'ultimo tentativo
 × è positiva

Python 2 , 100 93 92 90 byte

Grazie a @ mbomb007 per la rasatura di 2 byte

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

Cerca i numeri nel campo richiesto finché non ne viene trovato uno con cifre univoche. Scommetto che c'è un modo molto più pulito per farlo, ma non me ne viene in mente nessuno.

Pyth , 11 byte

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

Utilizza lo stesso algoritmo di della risposta di Dennis .

Provalo online!

Perl, 48 byte

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

Spiegazione:

Generare ripetutamente numeri interi casuali da 1 a 10 ** $ n-1, respingendoli fino a raggiungere una lunghezza corretta (quindi almeno 10 ** ($ n-1)) senza cifre ripetute.

Lotto, 156 byte

@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

xmantiene una maschera di bit di cifre usate. findica il numero di cifre disponibili (conto alla rovescia da 9). Le cifre casuali vengono generate fino a quando non viene trovata una cifra non utilizzata. n=10potrebbe essere supportato per 165 byte:

@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

( rcontiene uno zero iniziale in più perché è più golfista in quel modo.) L'approccio precedente per 165 byte ha inserito in modo speciale la prima cifra e ha funzionato anche con n=10(la versione numerica in realtà ha preso 166 byte!):

@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'approccio originale per 170 byte ha funzionato anche per 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%

Utilizza la manipolazione di stringhe per rilevare cifre duplicate.

Bash , 66 byte

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

Provalo online!

Semplicemente, usa shuf, xargs viene usato per unire le linee e continua a provare mentre la combinazione inizia con 0.

Non posso battere 46 caratteri da un'altra risposta, ma è quindi veloce!

Pyth, 15 28 byte

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

Provalo qui

C #, 127 132 128 126 125 byte

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;};

Provalo online!

Preso in prestito l'idea da @ risposta di KevinCruijssen per inizializzare il caso, rnella ifdichiarazione di risparmiare 2 byte.

Abbastanza sicuro che questo possa essere ulteriormente approfondito, ma al momento non ho tempo.

Vecchia versione usando un whileloop:

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 byte

Questo genera un numero casuale effettivo

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;}

Provalo online!

C (gcc) , 87 85 byte

Qui sta stampando una serie di cifre.

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;}

Provalo online!

PHP, 65 63 byte

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

accetta input da STDIN; Corri con-nR .

creare un numero casuale compreso 1e 10^Ncompreso;
ripetere mentre il conteggio di caratteri distinti è < N.

Mathematica 65 60 byte

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

Ecco una versione più veloce ma aggiunge 9 byte:

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

Java 9 JShell, 86 byte

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

Provalo online!

Nota: non conto le importazioni poiché tali pacchetti vengono importati per impostazione predefinita in JShell, ma non esiste un collegamento Try-it-online che conosco per JShell, quindi ne ho fornito uno per Java 9 con codice di intestazione e piè di pagina in farlo funzionare in quel contesto. In JShell puoi semplicemente fare:

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

E poi:

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

Come funziona:

Definiamo una funzione da Integer a Long e creiamo un flusso infinito di long casuali nell'intervallo da 0-9, limitiamolo ai primi n-1 elementi, quindi riduciamolo con un int casuale da 1-9 come valore iniziale e una funzione che moltiplica il valore per 10 e aggiunge il valore successivo dal flusso.

Ho usato longs, quindi dovrebbe funzionare fino a circa 18 cifre (n = 18).

C, 96 93 byte

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);}

Inizializzazione shuffle Fisher-Yates fino a quando la prima cifra non è zero.

È uniforme, supponendo rand()%i sia uniforme. (Poiché per la maggior parte ho RAND_MAX/ilasciato un piccolo residuo, c'è un pregiudizio molto piccolo. Questo pregiudizio diventa più piccolo quando RAND_MAX diventa più grande.)

Guardalo funzionare online .

Vedilo generare numeri corretti per quando n è uguale a 2, come mostrato nella domanda .

Assioma, 191 byte

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

deselezionalo, risultato del 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]]

Medusa , 17 byte

p
d^u ?
 j?r10
10

Provalo online!

Risposta di Fork of Dennis 'Jelly .

Rubino, 53 52 byte

Mescola fino a quando la prima cifra non è 0, quindi combina le cifre e converti in un numero intero.

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

Provalo online!