나는 이 질문을 읽고 그것이 좋은 도전이 될 것이라고 생각했다.

태스크

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

파이썬 2 , 77 바이트

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

온라인으로 사용해보십시오!

0으로 시작하지 않을 때까지 10 자리 목록을 섞은 다음 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 바이트 길이의 내장 프로그램을 따라갈 것입니다.

@Fatalize와 공동으로 Brachylog , 8 바이트

~lℕ₁≠≜ᶠṛ

온라인으로 사용해보십시오!

이것은 일종의 천재 저수준 트릭입니다. Prolog가하는 방식에만 의미가 있고 수학적으로 설명 할 때는 그다지 의미가 없습니다.

이전과 같이 ~lℕ₁≠제약 조건 ( "입력 길이, 자연수, 모든 요소가 다른 길이")을 설명하는 값을 작성합니다. 그런 다음 ≜ᶠ제약 조건을 충족하는 모든 가능한 값을 생성합니다. 여기서 중요한 점은 Brachylog의 평가 시퀀스를 사용하여 ≜나타날 때까지 실제로 선택할 수 없으므로 "모든 솔루션 찾기"작업 ᶠ은 "제약 조건을 충족하는 특정 값 "작업 에만 적용하면됩니다 ≜. 즉 {…}, 범위를 선택할 필요가 없으므로 2 바이트가 절약됩니다.

젤리 , 9 바이트

⁵*ṖQL$€MX

온라인으로 사용해보십시오! (구현의 비 효율성으로 인해 n> 6 동안 TIO에서 작동하지 않음)

또는 같은 것의 대안적인 구현 :

⁵*ṖQL$ÐṀX

방법?

이것은 매우 교활하고 매우 비효율적입니다! 젤리는 원자가 목록을 기대하지만 정수를 받으면 암묵적으로 유용한 것들을 수행합니다 (이것은 의도적으로 설계된 것입니다).
이 코드는 다음과 같은 유용한 암시 적 작업을 사용합니다.

• Ṗ정수 입력으로 호출 될 때 모나 딕 원자 "pop"은 암시 적으로 팝되는 범위를 만들므로 n 의 입력은 먼저 [1, 2, ..., n]을 생성 한 다음 팝하여 [1, 2 , ..., n-1] .

• Q정수 입력으로 호출 될 때 모나 딕 원자 "de-duplicate"또는 "unique"는 내재적으로 10 진수 목록을 사용하여 중복을 제거하므로 n 의 입력은 다음 과 같습니다.
  n = d _k-1 × 10 ^k-1 + d _k-2 × 10 ^k-2 + ... + d ₁ × 10 + d _0은
  먼저
  [d _k-1 , d _k-2 , ..., d ₁ , d ₀ ]
  를 만든 다음 고유 값을 산출합니다. 첫 등장.
  예를 들어, n = 5835518 은 [5, 8, 3, 1]이 됩니다.

또한 모나드 원자 M, "최대 요소의 인덱스가"목록에서 최대 항목의 인덱스를 반환이 저장 이 입력와 동일한 지 어떤지를 테스트하고 truthy 인덱스를 찾는 훨씬 더 확실한 대안을 통해 바이트, ⁵*Ṗ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 개의} 정수 목록 이 만들어지고 하나는 버린 다음이 각각에 대해 n 개의 정수 (일부 멋진 4 비트 객체 또는 열거 아님) 목록이 만들어집니다 그런 다음 중복 제거되었습니다. 이 중복 제거는 완전히 목록 기반으로 구현됩니다 (세트, 정렬 세트 또는 사전은 실제로 사용되지 않으며, 각 숫자는 목록에 출력되어 있는지 확인).
오프라인 n = 7 은 ~ 0.5GB를 사용하고 ~ 25 초가 걸리는 반면 n = 8 은 ~ 4GB를 사용하고 ~ 5 분이 걸립니다 .16GB 램만 있으면 n = 9 를 실행하는 데 방해가되지 않았습니다 (~ 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.

자바 스크립트 (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 가 z를 포함 y.match(z)하면 배열을 (항상 진실 임) 반환하고 , 그렇지 않으면 null (거짓)을 반환합니다. 는 부울 및 반전 그것을 변환합니다.!

두 번째 조건은로 확인됩니다 y|z. 비록 Y가 문자열 인 사용시, JS 내재적 정수로 변환한다 |. y에 이미 숫자가 포함되어 있으면 양의 정수이고 , 그렇지 않으면 0 입니다. 그물 결과이다 y|z복귀 0 IFF Y가 비어 있고 , Z는 이고 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 비트 룩업 테이블로, 이미 보유하고있는 숫자를 알려주며 정수로 편리하게 저장합니다.

먼저 와 함께 임의의 숫자 z 를 생성합니다 Math.random()*10|0. 이제, z 의 최하위 비트 y 가 설정되어 있지 않은지, y 와 z 가 모두 0 이 아닌지 확인하려고합니다 .

첫 번째 조건은 다음과 같이 계산할 수 있습니다 ~y>>z&1. y를 반전 시키고 z 비트를 오른쪽으로 쉬프트하고 최하위 비트 만 취합니다. 이것은 제공 한 우리는 아직 문제의 숫자 또는 발생하지 않은 경우 0을 , 그렇지.

두 번째 조건은 처음에는 이해하기가 매우 어려웠습니다 (처음에는 둘 다 0 인 경우 y/z생성 하려고 시도 NaN했지만) 어떤 시점에서 나는 단순히 y|z트릭을 수행 한다는 것을 깨달았습니다 . y 와 z 가 모두 0이면 결과는 0입니다 . 그렇지 않으면 양의 정수

이 두 조건이 모두 참 ( ~y>>z&1&&y|z) 이면 나머지 숫자를 생성하고 z 앞에 붙습니다 . 나머지 숫자는 x-1and를 사용 하여 함수를 다시 호출하여 생성됩니다 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).

@cliffroot2 바이트를 제거해 주셔서 감사 합니다!

확장 코드 :

(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)파이썬의 유사합니다 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. 이 경우, 우리는 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

이것이 우리의 최종 답변입니다.

파이썬 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

배쉬 + GNU 유틸리티, 46

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

온라인으로 사용해보십시오 .

n = 7의 경우 n -30 정도가 큰 경우에는 시간이 오래 걸리고 각 증분마다 10 배씩 증가하므로 n = 10의 경우 8-9 시간이 걸립니다.

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

@TheLethalCoder 덕분에 -2 바이트

(이전) 설명 :

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

펄 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+!Œ?’ḣƓḌ

현재 다른 젤리 답변 뒤에 1 바이트가 있지만 실제로이 것을 좋아합니다.

온라인으로 사용해보십시오!

작동 원리

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 자리에서 일반 숫자로 디코딩

⊢ n

↑ 의 첫 번째 요소

{... }⍣{... } ... 기능을 반복
 ?⍨10 처음 10 양의 정수 셔플
까지 ...
 ⊃⍺ 마지막 시도의 첫 번째 숫자는
 × 긍정적이다

파이썬 2 , 100 93 92 90 바이트

2 바이트를 줄인 @ mbomb007에게 감사합니다.

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의 답변 과 동일한 알고리즘을 사용합니다 .

온라인으로 사용해보십시오!

펄, 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=10165 바이트를 지원할 수 있습니다.

@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이 방법은 골퍼이기 때문에 추가 0을 포함합니다.) 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

온라인으로 사용해보십시오!

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

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

작동 방식 :

정수에서 Long까지의 함수를 정의하고 0-9 범위의 무한 길이의 무한 스트림을 만들고 첫 번째 n-1 항목으로 제한 한 다음 초기 값으로 1-9의 임의 정수를 사용하여 줄입니다. 값에 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는 첫 번째 숫자가 0이 될 때까지 초기화를 섞습니다.

균일하다고 가정하면 rand()%i균일합니다. (대부분의 경우 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

온라인으로 사용해보십시오!

데니스 젤리 포크 대답 .

루비, 53 52 바이트

첫 번째 숫자가 0이 될 때까지 섞은 다음 숫자를 결합하여 정수로 변환하십시오.

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

온라인으로 사용해보십시오!