Я прочитав це запитання і подумав, що це приємно викличе.

Завдання

Дайте вхід 0<n<10генерувати випадкове число з

• рівно n цифр
• перший не a 0
  • так f(n)>10**(n-1)-1
• виразні цифри

Критерії виграшу

Це код-гольф, тому виграє найкоротший код.

Випадкові

Я маю на увазі рівномірно розподілений випадковий характер. Отже, з точки зору програми, кожен можливий номер має однаковий шанс. Якщо мова, якою ви пишете, має дивний генератор випадкових чисел, добре використовувати її.

Приклад

Список значень, для яких можна випадковим чином вибрати 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 байт

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

Спробуйте в Інтернеті!

Переміщує список з 10 цифр, поки він не починається з 0, а потім робить число з перерахованими першими nцифрами.

Брахілог , 9 10 байт

{~lℕ₁≜≠}ᶠṛ

Спробуйте в Інтернеті!

Як зазвичай для Брахілога, це подання функції. Наведене вище посилання TIO отримало аргумент командного рядка, щоб перетворити функцію на повну програму.

Я повинен був додати додаткові байти з першої версії цього, зміни ℕв ℕ₁, щоб заборонити вихід 0 (то , що зараз були топленим).

Пояснення

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

Досить неефективно, тому що інтерпретатор формує список усіх можливих значень, а потім вибирає їх випадково (ось що ᶠṛозначає; Брахілог не мав варіант "вибрати випадкове рішення" на той час, коли це питання було задано).

Деякі зауваження щодо мітки тут: якщо ≜пропущено, розділ в дужках створює лише одне значення, обмеження, що представляє числа із властивістю, яку ми хочемо; вибір випадкового результату, таким чином, дає нам обмеження, і інтерпретатор виводить мінімальне абсолютне значення, яке відповідає обмеженню (1, 10, 102, 1023, 10234 тощо), яке не є тим, чого ми хочемо. Таким чином, ми мусимо змусити його скласти список шляхом явної мітки.

Більшість реалізацій Prolog, які я бачив, мають вбудований файл, щоб знайти випадковий результат, що відповідає обмеженню, але, як правило, не з однаковою ймовірністю; У Brachylog не було жодного (хоча його додали у відповідь на цей виклик, але я, очевидно, не можу його використовувати через правила лазівки). Якби це було, і якщо це трапилося б надати однакову ймовірність цій проблемі, за цією програмою просто ~lℕ₁≠слідкував би той вбудований, імовірно, довжина 6 байт.

Брахілог , 8 байт, у співпраці з @Fatalize

~lℕ₁≠≜ᶠṛ

Спробуйте в Інтернеті!

Це такий собі геніальний трюк низького рівня, який має сенс лише у тому, як Пролог робить справи, і не має особливого сенсу, коли описується математично.

Як і раніше, ~lℕ₁≠створює значення, яке описує обмеження ("довжина, рівна вводу, натуральне число, всі елементи різні"). Потім ≜ᶠгенеруються всі можливі значення, що відповідають обмеженню. Сенс у тому, що при послідовності оцінювання Брахілогів фактичний вибір не робиться до ≜появи, тому операція "знайти всі рішення" не ᶠповинна застосовуватися ні до чого, окрім "конкретного значення, що відповідає обмеженню" ≜. Це означає, що не потрібно {…}вибирати область його використання, економлячи 2 байти.

Желе , 9 байт

⁵*ṖQL$€MX

Спробуйте в Інтернеті! (не працюватиме в TIO протягом n> 6 через неефективність впровадження)

або альтернативної реалізації того ж самого:

⁵*ṖQL$ÐṀX

Як?

Це досить підлий, і дуже неефективний! Jelly робить деякі корисні речі неявно, коли атом очікує список, але отримує ціле число (це за задумом).
Цей код використовує пару таких корисних неявних дій:

• Монадичний атом Ṗ, "pop", коли викликається з цілим входом неявно, робить діапазон, з якого потрібно випливати, тому вхід n спочатку робить [1, 2, ..., n] , потім спливає, поступаючись [1, 2 , ..., n-1] .

• Монадичний атом Q, "дедублікат" або "унікальний", коли викликається з цілим введенням, неявно робить десятковий список для дедуплікації, тому введення n де:
  n = d _k-1 × 10 ^k-1 + d _k-2 × 10 ^k-2 + ... + d ₁ × 10 + d ₀
  спочатку складає
  [d _k-1 , d _k-2 , ..., d ₁ , d ₀ ],
  а потім дає унікальні значення за перша поява.
  Так, наприклад, n = 5835518 дасть [5, 8, 3, 1] .

Крім того, монадичний атом M, "максимальні індекси елементів", повертає індекси максимальних елементів зі списку, це зберігає два байти на набагато більш очевидну альтернативу тестування рівності з вхідними та знаходженням правдоподібних індексів ⁵*ṖQL$€=⁸TX, або⁵*Ṗð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

Це все досить неефективно, як у часі, так і в пам’яті: спочатку складається список з 10 ⁿ цілих чисел і одне відкидається, потім для кожного з них складається список з n цілих чисел (не якийсь фантазійний 4-розрядний об'єкт чи enum). а потім дедублюється. Це дедублювання має повністю реалізовану на основі списку реалізацію (ніякі набори, відсортовані набори чи словники не задіяні під кришкою, кожна цифра перевіряється на наявність у списку, який з часом отримує вихід).
В режимі офлайн n = 7 використовується ~ 0,5 Гб і займає ~ 25 секунд, тоді як n = 8 використовує ~ 4 ГБ і займає ~ 5 хвилин - я не заважав працювати n = 9, оскільки у мене є лише 16 ГБ (я думаю, це займе ~ 45 хвилин ).

Альтернативна реалізація просто використовує вбудований ÐṀшвидкий фільтр-мінімум (що тут лише додає невеликі накладні витрати в управлінні на той самий підрахунок байтів).

Желе , 11 байт

9Xœ|⁵ḶẊ¤ḣ¹Ḍ

Спробуйте в Інтернеті!

Як це працює

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 байт

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

Це рекурсивна функція, яка бере кількість цифр x . Другий параметр y , спочатку встановлений у порожній рядок, відстежує число, коли ми генеруємо його цифру за цифрою.

Спочатку генеруємо випадкову цифру z з Math.random()*10|0. Тепер ми хочемо перевірити, що y не містить z , і що y і z не є обома 0 .

Ми можемо розрахувати першу умову за допомогою !y.match(z). y.match(z)повертає масив (завжди truthy), якщо y містить z , null (фальшивий) в іншому випадку; !перетворює це логічне і інвертує його.

Друга умова перевіряється y|z. Хоча y - рядок, JS неявно перетворює його на ціле число при використанні |. Це натуральне число, якщо y вже містить цифри, 0 - інакше. Чистий результат полягає в тому, що y|zповертається 0 iff y порожній, а z дорівнює 0 , або додатне ціле число в іншому випадку.

Якщо обидві ці умови істинні, ми додаємо цифру до y , декремент x і починаємо процес заново. В іншому випадку ми просто повернемося до початку і сподіваємось, що наступна випадкова цифра спрацює. Коли х досягає 0 , ми просто повертаємо порожній рядок, щоб закінчити рекурсію.

Попередня версія:

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

Це рекурсивна функція, яка бере кількість цифр. Спочатку невизначений другий параметр, y - це 10-розрядна таблиця пошуку, яка говорить нам, які цифри ми вже маємо, зручно зберігати як ціле число.

Спочатку генеруємо випадкову цифру z з Math.random()*10|0. Тепер ми хочемо перевірити, що z 'найменший значущий біт y не встановлений, і що y і z не є обома 0 .

Ми можемо обчислити першу умову за допомогою ~y>>z&1; інвертувати y , змістити його z біт вправо і взяти лише найменший значущий біт. Це дає 1, якщо ми ще не створили відповідну цифру, або 0 .

Другу умову спочатку було досить важко розібрати (я спробував використовувати y/zспочатку, щоб створити, NaNякщо вони обоє 0), але в якийсь момент я зрозумів, що просто y|zзробив би трюк. Результат дорівнює 0 iff, і y і z дорівнюють 0 ; додатне ціле число інакше.

Якщо обидві ці умови вірні ( ~y>>z&1&&y|z), тоді ми генеруємо решту числа і додаємо z . Решта числа генерується повторним викликом функції з x-1і y|1<<z( y , але з бітом в індексі z, встановленому на 1 ). Коли х досягає 0 , ми просто повертаємо порожній рядок, щоб закінчити рекурсію.

ClojureScript, 81 79 байт

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

Це анонімна функція, тому ви повинні використовувати її так:

(#(...) {arguments})

Де ви заміните {arguments}своїми аргументами.

Ви можете спробувати код тут (ClojureScript REPL).

Дякуємо @cliffrootза те, що голили 2 байти!

Розширений код:

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

Пояснення:

Я збираюся пройти по рядках по одному, використовуючи приклад введення 8.

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

Досить просто, це визначає функцію random-digitsодним аргументом, який називається n. У своїй відповіді я використовував анонімну функцію ( #(...)), щоб зберегти байти.

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

Розглянемо всередині let, зсередини:

(shuffle (range 10))

У ClojureScript (і Clojure) (range n)подібний до Python's range(n): він дає вам список з кожним числом від 0до n - 1( 9у цьому випадку).

shuffleбере список і повертає вектор (який трохи відрізняється від списку) з усіма його елементами перетасовується. Отже, використовуючи наш приклад, ми отримуємо щось подібне:

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

(subvec {see above} 0 n)

(subvec vector start end)приймає вектор (тільки вектор) і повертає вектор, у якого є всі елементи від індексу startдо end. У цьому випадку ми беремо елементи від цього 0елемента до аргументу, наданому random-digits. Якщо ми застосуємо це до нашого прикладу, отримаємо:

[1 0 8 3 6 7 9 2]

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

Це ifтвердження перевіряє, чи є першим елементом num-vectora 0.

Якщо це так 0, то ми знову викликаємо функцію, аргументуючи n, використовуючи recur.

Якщо це не так 0:

(int (apply str num-vector))

(apply function list)бере список і вкладає їх у функції як аргументи. Наприклад:

(apply + [2 3 4])

Перетворюється на:

(+ 2 3 4)

Який дорівнює 9.

(str items)перетворює кожен елемент у itemsрядок, а потім з'єднує їх. intперетворює що-небудь у ціле число. Тож якщо ми застосуємо це до нашого прикладу, отримаємо:

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

Яка наша остаточна відповідь.

Python 2, 89 81 80 байт

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

Спробуйте в Інтернеті

R, 45 байт

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

Bash + GNU утиліти, 46

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

Спробуйте в Інтернеті .

Це займе тривалий час для більших n - приблизно 30 s для n = 7, і збільшення в 10 разів за кожен приріст, тому, ймовірно, 8-9 годин для n = 10.

Java 7, 150 147 145 134 байт

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 байти завдяки @TheLethalCoder

(стара) Пояснення:

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

Код тесту:

Спробуйте тут.

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

Приклад виводу:

7194
8672953041

Perl 6 , 44 байти

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

Спробуй це

Розширено:

{  # 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 байт

Інтернет-версія

Усі версії, засновані на переміщенні цифр від 0-9

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

71 байт

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

73 байт

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

MATL , 15 байт

`4Y2GZr1)48=]8M

Спробуйте MATL Online!

Пояснення

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

Желе , 12 байт

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

На даний момент один байт позаду моєї іншої відповіді Jelly, але мені це дуже подобається.

Спробуйте в Інтернеті!

Як це працює

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 (Діалог) , 27 19 17 байт

Потрібно, ⎕IO←0що для багатьох систем за замовчуванням.

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

Спробуйте в Інтернеті!

Переміщує цифри до дійсного:

10⊥ декодування від базової 10 цифр до звичайного числа,

⊢ потім

↑ Перші елементи

{... }⍣{... } повторюючи функцію ...
 ?⍨10 перетасувати перші десять позитивних цілі числа ,
поки ...
 ⊃⍺ перша цифра останньої спроби
 × не є позитивною

Пітон 2 , 100 93 92 90 90 байт

Завдяки @ mbomb007 за бриття 2 байтів

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

Пробує номери в необхідному, поки не знайдеться унікальна цифра. Б'юсь об заклад, що існує набагато чистіший спосіб зробити це, але ніхто не спадає на думку.

Pyth , 11 байт

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

Використовується той же алгоритм, що і відповідь Денніса .

Спробуйте в Інтернеті!

Perl, 48 байт

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

Пояснення:

Неодноразово генеруйте випадкові цілі числа від 1 до 10 ** $ n-1, відхиляючи їх, поки не з’явиться одна правильна довжина (так щонайменше 10 ** ($ n-1)) без повторних цифр.

Пакетна, 156 байт

@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

xпідтримує біт-маску використаних цифр. fвказує кількість доступних цифр (відлік від 9). Випадкові цифри створюються, поки не буде знайдена невикористана цифра. n=10може підтримуватися на 165 байт:

@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

( rмістить додатковий нульовий нуль, тому що це гольфіст.) Попередній підхід для 165 байтів спеціально обробляв першу цифру, а також траплялося працювати n=10(числова версія фактично займала 166 байт!):

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

Оригінальний підхід для 170 байт також працював для 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%

Використовує обробку рядків для виявлення повторюваних цифр.

Баш , 66 байт

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

Спробуйте в Інтернеті!

Прямо вперед, usues shuf, xargs використовується для з'єднання ліній і продовжує намагатися, коли комбінація починається з 0.

З іншого відповіді не вдалося побити 46 знаків, але це швидко!

Pyth, 15 28 байт

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

Спробуйте тут

C #, 127 132 128 126 125 байт

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

Спробуйте в Інтернеті!

Позичив ідею з відповіді @ KevinCruijssen про ініціалізацію випадкового r, уif заяві, щоб зберегти 2 байти.

Досить впевнений, що це можна пограти далі в гольф, але на даний момент у мене немає часу.

Стара версія з використанням whileциклу:

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 байт

Цей генерує фактичне випадкове число

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

Спробуйте в Інтернеті!

C (gcc) , 87 85 байт

Тут він друкує рядок цифр.

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

Спробуйте в Інтернеті!

PHP, 65 63 байт

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

приймає вхід від STDIN; бігати з-nR .

створити випадкове число між 1та 10^Nвключно;
повторити, поки кількість чітко виражених знаків становить < N.

Mathematica 65 60 байт

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

Ось більш швидка версія, але додає 9 байт:

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

Java 9 JShell, 86 байт

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

Спробуйте в Інтернеті!

Примітка. Я не рахую імпорт, оскільки ці пакети за замовчуванням імпортуються в JShell, але для JShell я не знаю пробного онлайн-посилання, тому я надав для Java 9 код з кодом колонтитула та колонтитула змусити його працювати в цьому контексті. У JShell ви можете просто зробити:

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

І потім:

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

Як це працює:

Ми визначаємо функцію від Integer до Long і створюємо нескінченний потік випадкових довгих в діапазоні від 0 до 9, обмежуємо її на перші n-1 пункти, потім зменшуємо її до випадкової int від 1-9 як початкове значення і функція, яка помножує значення на 10 і додає наступне значення з потоку.

Я використовував longs, тому це повинно працювати приблизно до 18 цифр (n = 18).

C, 96 93 байт

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

Фішер-Йейт переміщує ініціалізацію, поки перша цифра не дорівнює нулю.

Є рівномірним, якщо вважати rand()%iрівномірним. (Оскільки для більшості я RAND_MAX/iзалишає невеликий залишок, існує дуже невеликий ухил. Цей зміщення стає меншим, коли RAND_MAX зростає.)

Дивіться, як це працює в Інтернеті .

Дивіться, що вона генерує правильні числа, коли n дорівнює 2, як показано в питанні .

Аксіома, 191 байт

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

ungolf це, результат тесту

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

Медузи , 17 байт

p
d^u ?
 j?r10
10

Спробуйте в Інтернеті!

Вилка Jelly відповіді Денніса .

Рубі, 53 52 байти

Перемішуйте, поки перша цифра не дорівнює 0, потім комбінуйте цифри та перетворіть у ціле число.

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

Спробуйте в Інтернеті!