我读了这个问题，并认为这将是一个不错的挑战。

任务

给一个输入0<n<10生成一个随机数

• 正好n位数字
• 第一个不是 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列出的第一位数字进行编号。

Brachylog，9 10字节

{~lℕ₁≜≠}ᶠṛ

在线尝试！

与Brachylog一样，这是一个函数提交。上面的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.

效率相当低，因为解释器会生成所有可能值的列表，然后随机选择一个（这就是什么ᶠṛ意思；在问这个问题时，Brachylog没有“选择随机解”选项）。

这里有一些关于标签的注释：如果≜省略，括号中的部分只会产生一个值，一个约束表示具有我们想要属性的数字；因此，选择随机结果会给我们带来约束，并且解释器输出满足约束的最小绝对值（1、10、102、1023、10234等），这不是我们想要的。因此，我们必须强制它通过显式标签构造列表。

我见过的大多数Prolog实现都有内置功能，可以找到匹配约束的随机结果，但通常不具有统一的概率。但是Brachylog没有一个（为了应对这一挑战而增加了一个，但是显然是由于漏洞规则，我无法使用它）。如果这样做，并且恰好在这个问题上给出了统一的概率，则该程序将~lℕ₁≠紧随其后，内置程序的长度可能为6个字节。

Brachylog，8字节，与@Fatalize合作

~lℕ₁≠≜ᶠṛ

在线尝试！

这是一种天才的低级技巧，仅对Prolog的处理方式有意义，而在进行数学描述时则没有太大意义。

如前所述，~lℕ₁≠建立一个描述约束的值（“长度等于输入，自然数，所有元素都不同”）。然后≜ᶠ生成满足约束的所有可能值。这里的要点是，在Brachylog的评估序列中，直到≜出现之前都没有做出任何实际选择，因此“查找所有解决方案”操作只ᶠ适用于“满足约束的特定值”操作≜。这意味着不需要a {…}选择其范围，从而节省了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位对象或枚举）。然后进行重复数据删除。这种重复数据删除具有完全基于列表的实现（引擎盖下不涉及任何集合，排序集合或字典，在列表中检查每个数字是否存在，最终可以输出）。
离线n = 7使用〜0.5GB并花费〜25秒，而 n = 8使用分钟-我没有打扰n = 9，因为我只有16GB的ram（我估计它将花费〜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最初设置为空字符串在逐位生成数字时会跟踪该数字。

首先，我们生成一个随机数字ž用Math.random()*10|0。现在，我们要检查y不包含z，并且y和z都不都是0。

我们可以用计算第一个条件!y.match(z)。y.match(z)如果y包含z，则返回一个数组（总是真实的），否则返回null（虚假的）；将其!转换为布尔值并将其反转。

第二个条件用检查y|z。尽管y是一个字符串，但JS在使用时会将其隐式转换为整数|。如果y已经包含数字，则为正整数，否则为0。净结果是，y|z返回0当且仅当ÿ是空的并且Ž是0或正整数，否则。

如果这两个条件都成立，则将数字附加到y上，然后递减x，然后重新开始该过程。否则，我们只是回到起点，并希望下一个随机数起作用。当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位的查找表，告诉我们我们已经拥有哪些数字，并方便地存储为整数。

首先，我们生成一个随机数字ž用Math.random()*10|0。现在，我们要检查是否未设置y的z '最低有效位，并且y和z都不均为0。

我们可以用来计算第一个条件~y>>z&1：反转y，将其z位右移，仅取最低有效位。这使得1，如果我们还没有产生问题的数字或0，否则。

最初很难弄清第二个条件（我尝试y/z首先使用NaN它们是否均为0 来生成），但是在某个时候，我意识到简单地y|z就能解决问题。其结果是0当且仅当两者ÿ和ž是0 ; 否则为正整数。

如果这两个条件都为true（~y>>z&1&&y|z），那么我们将生成其余的数字，并在z之前加上。通过使用x-1和y|1<<z（y，但索引z的位设置为1）再次调用该函数来生成其余的数字。当x达到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的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)接受一个向量（仅一个向量），并返回一个向量，该向量具有从index start到的所有元素end。在这种情况下，我们将元素从0th元素传递到指定给的参数random-digits。如果将其应用于示例，我们将得到：

[1 0 8 3 6 7 9 2]

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

该if语句检查的第一个元素num-vector是否为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 utils，46

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

在线尝试。

较大的n需要很长时间-对于n = 7大约需要30秒，并且每次增加10倍，因此对于n = 10可能需要8-9个小时。

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在线上尝试一下！

说明

`        % 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（Dyalog），27 19 17字节

要求⎕IO←0在许多系统上是默认设置。

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

在线尝试！

调整数字直到有效：

10⊥ 从基数10位解码为常规数字，

⊢ 然后

↑ 的第一要素

{... }⍣{... } 重复的功能......
 ?⍨10 洗牌的前十个正整数
，直到......
 ⊃⍺ 最后一次尝试的第一个数字
 × 为正

Python 2中，100 93 92 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

使用与Dennis的答案相同的算法。

在线尝试！

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

在线尝试！

直截了当，使用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的Try-it-online链接，因此我为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的无限long的无限流，将​​其限制在前n-1个项目中，然后将其取值为1-9的随机int作为初始值并将其减少，该函数将值乘以10，然后将流中的下一个值相加。

我使用了long，因此它最多可以使用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);}

Fisher-Yates随机播放初始化，直到第一个数字不为零。

是统一的，假设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]))

解开测试结果

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

在线尝试！

丹尼斯的果冻叉子。

Ruby，53 52字节

随机播放，直到第一个数字不为0，然后合并这些数字并转换为整数。

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

在线尝试！