Bu soruyu okudum ve güzel bir meydan okuma olacağını düşündüm.

Görev

Bir giriş ver 0<n<10rastgele bir sayı ile

• tam olarak n basamak
• ilk değil bir 0
  • yani f(n)>10**(n-1)-1
• farklı basamaklar

Kazanan kriterler

Bu kod golf yani en kısa kod kazanır.

rasgele

Eşit dağılımlı rasgele demek istiyorum. Yani programın görüşüne göre, her olası sayı aynı şansa sahip. Yazdığınız dilin tuhaf bir rasgele sayı üreteci varsa, onu kullanmanız sorun değil.

Örnek

Şunun için rastgele seçilecek değerlerin listesi 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 bayt

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

Çevrimiçi deneyin!

10 basamaklı listeyi 0 ile başlamayacak şekilde karıştırır, sonra nlistelenen ilk basamaklarla bir sayı yapar .

Brachylog , 9 10 bayt

{~lℕ₁≜≠}ᶠṛ

Çevrimiçi deneyin!

Brachylog için her zamanki gibi, bu bir işlev sunumu. Yukarıdaki TIO bağlantısına, işlevi tam bir program haline getirmek için bir komut satırı argümanı verilmiştir.

Bunun ilk versiyonundan ek bir bayt eklemek zorunda kaldım , 0 çıkışını (şimdi açıklığa kavuşturulmuş olan bir şeye) izin ℕvermek ℕ₁için değiştirdim .

açıklama

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

Oldukça verimsizdir, çünkü tercüman olası tüm değerlerin bir listesini oluşturur ve daha sonra rastgele birini seçer (bu ᶠṛ, Brachylog'un bu soru sorulduğunda "rastgele bir çözüm seç" seçeneğine sahip olmadığı anlamına gelir).

Buradaki etiketlendirmeyle ilgili bazı yorumlar: ≜Atlanırsa, parantez içindeki bölüm yalnızca bir değer üretir, istediğimiz özellikle ilgili sayıları temsil eden bir kısıtlama; Bu nedenle rastgele bir sonuç seçmek bize kısıtlama getirir ve tercüman, kısıtlamayı karşılayan minimum mutlak değeri (1, 10, 102, 1023, 10234 vb.) çıkarır, bu bizim istediğimiz şey değildir. Dolayısıyla, listeyi açık bir etiketleme yoluyla oluşturmaya zorlamalıyız.

Gördüğüm Prolog uygulamalarının çoğunda, bir sınırlamaya uyan rastgele bir sonuç bulmak için bir yapıya sahip, ancak genellikle tekdüze bir olasılık bulunmuyor; Gerçi Brachylog'da bir tane yoktu (biri bu zorluğa cevaben eklendi, ancak bariz boşluk kuralları nedeniyle kullanamıyorum). Olsaydı ve bu sorunla ilgili tekdüze bir olasılık ortaya çıkarsa, bu programı sadece ~lℕ₁≠6 baytlık bir süre boyunca bu yerleşik tarafından takip ederdi .

Brachylog , 8 byte, @Fatalize işbirliğiyle

~lℕ₁≠≜ᶠṛ

Çevrimiçi deneyin!

Bu, yalnızca Prolog'un işlerini yapma şekliyle mantıklı olan ve matematiksel olarak tanımlandığında pek mantıklı gelmeyen bir tür dahi düşük seviye hilesidir.

Daha önce ~lℕ₁≠olduğu gibi, bir kısıtlamayı tanımlayan bir değer oluşturur ("girişe eşit uzunluk, doğal sayı, farklı tüm öğeler"). Ardından ≜ᶠkısıtlamayı karşılayan tüm olası değerleri üretir. Buradaki nokta, Brachylog'un değerlendirme sekansı ile, ≜görünene kadar gerçek bir seçim yapılmadığı , bu nedenle "tüm çözümleri bulma" işleminin ᶠ, "bir kısıtlama sağlayan özel değer" işleminden başka hiçbir şey için geçerli olmaması gerektiğidir ≜. Bu {…}, 2 bayt tasarrufu yaparak, kapsamını seçmeye gerek olmadığı anlamına gelir .

Jöle , 9 bayt

⁵*ṖQL$€MX

Çevrimiçi deneyin! (uygulamanın yetersizliği nedeniyleTIO'da n> 6 için çalışmayacak)

veya aynı şeyin alternatif bir uygulamasını:

⁵*ṖQL$ÐṀX

Nasıl?

Bu oldukça sinsi ve çok verimsiz! Jöle, bir atom bir liste beklerken ancak bir tam sayı aldığında dolaylı olarak bazı yararlı şeyler yapar (bu, tasarım gereğidir).
Bu kod, bu yararlı gizli işlemlerden birkaçını kullanır:

• ṖBir tamsayı girişi ile çağrıldığında monadik atom , "pop", dolaylı olarak pop'dan bir aralık yapar, bu yüzden n'in girişi ilk önce [1, 2, ..., n] yapar , sonra çıkar, [1, 2. , ..., n-1] .

• QBir tamsayı girişi ile çağrıldığında monadik atom , "de-duplicate" veya "unique", çoğaltmak için ondalık bir liste yapar, yani n'nin girişi :
  n = d _k-1 × 10 ^k-1 + d _k-2 × 10 ^k-2 + ... + d ₁ × 10 + d ₀
  ilk önce
  [d _k-1 , d _k-2 , ..., d ₁ , d ₀ ] yapar
  ve sonra benzersiz değerleri verir ilk görünüm
  Böylece, örneğin, n = 5835518 , [5, 8, 3, 1] verim elde eder .

Ayrıca, monadik atom M, "maksimal element indeksleri", bir listedeki maksimal maddelerin endekslerini döndürür, bu girdi ile eşitlik testi ve truthy indeksleri bulma konusunda çok daha belirgin bir alternatif alternatifi üzerinden iki bayt tasarruf eder ⁵*ṖQL$€=⁸TXveya⁵*Ṗð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

Bunların hepsi hem zaman hem de bellekte oldukça verimsizdir: ilk önce 10 ⁿ tamsayıların bir listesi yapılır ve bir tanesi atılır, daha sonra bunların her biri için bir n tamsayıların listesi yapılır (bazı süslü 4-bit nesneler veya enumlar değil) ve sonra çoğaltıldı. Bu kopyalamanın tamamen listeye dayalı bir uygulaması vardır (setler, sıralı kümeler veya sözlükler başlık altında yer almaz, her basamak sonunda sonuç alan listede var olup olmadığını kontrol eder).
Çevrimdışı n = 7 , ~ 0.5GB kullanır ve ~ 25 saniye sürer, n = 8 ise ~ 4GB kullanır ve ~ 5 dakika sürer - Sadece 16GB koçluk yaptığım için n = 9 çalıştırma zahmetine girmedim (Sanırım ~ 45 dakika sürer) ).

Alternatif uygulama, yalnızca ÐṀfiltreyi en düşük seviyede tutmak için yerleşik hızlı bir şekilde kullanır (burada aynı bayt sayısı için yönetimde biraz ek yük sağlar).

Jöle , 11 bayt

9Xœ|⁵ḶẊ¤ḣ¹Ḍ

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

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

Bu, x basamağı sayısını alan özyinelemeli bir işlevdir . Başlangıçta boş dizgeye ayarlanan ikinci parametre y , sayıyı rakam olarak ürettiğimiz sayıyı izler.

İlk önce rastgele bir rakam z ile üretiyoruz Math.random()*10|0. Şimdi, y'nin z içermediğini ve y ve z'nin her ikisinin de 0 olmadığını kontrol etmek istiyoruz .

İlk durumu ile hesaplayabiliriz !y.match(z). y z , null (falsy) içeriyorsa , y.match(z)bir dizi döndürür (her zaman truthy) ; Bir boole ve ters çevirir o bu dönüştürür.!

İkinci durum ile kontrol edilir y|z. Y bir dize olmasına rağmen , JS kullanırken onu tam olarak bir tam sayıya dönüştürür |. Bu zaten y rakamları içeriyorsa, aksi takdirde 0 ise pozitif bir tamsayıdır . Net sonuç, yani y|zdöner 0 IFF y boştur ve Z ise 0 ya da pozitif bir tamsayı, aksi.

Bu koşulların her ikisi de doğruysa, o zaman rakamı y'ye ekler, x'i azaltır ve işlemi yeniden başlatırız. Aksi takdirde, sadece başlangıca geri döneriz ve bir sonraki rasgele rakamın işe yaramasını umarız. Ne zaman x ulaşır 0 , biz sadece özyinelemeye sonlandırmak için boş bir dize döndürür.

Önceki versiyon:

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

Bu rakam sayısını alan özyinelemeli bir işlevdir. Başlangıçta tanımsız olan ikinci parametre olan y , bize hangi rakamlara sahip olduğumuzu ve tamsayı olarak uygun bir şekilde depolandığımızı gösteren 10 bitlik bir arama tablodur.

İlk önce rastgele bir rakam z ile üretiyoruz Math.random()*10|0. Şimdi, z'nin en az anlamlı bitinin y ayarlanmadığını ve y ve z'nin her ikisinin de 0 olmadığını kontrol etmek istiyoruz .

İlk koşulu şu şekilde hesaplayabiliriz ~y>>z&1; ters y , o kayması z sağa bit ve sadece en az önemli bit alır. Bu veriyor 1 henüz söz konusu rakamı, ya da üretilen değil eğer 0 aksi.

İkinci koşulun başlangıçta çözülmesi oldukça zordu ( y/zilk önce NaNher ikisi de 0 ise üretmek için kullanmayı denedim ), ama bir noktada y|zhile yapacağımı fark ettim . Sonucudur 0 hem IFF y ve z olan 0 ; aksi halde pozitif bir tamsayı.

Bu koşulların her ikisi de (doğru ise ~y>>z&1&&y|z), o zaman numarası ve başa getirebilir geri kalanını oluşturur z . Sayının geri kalanı, işlev tekrar x-1ve y|1<<z( y ile , ancak z indeksindeki bit 1'e ayarlanmış olarak ) çağrılarak üretilir . Ne zaman x ulaşır 0 , biz sadece özyinelemeye sonlandırmak için boş bir dize döndürür.

ClojureScript, 81 79 bayt

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

Bu anonim bir işlevdir, bu nedenle bunu kullanmak zorundasınız:

(#(...) {arguments})

{arguments}Argümanların yerine .

Kodu burada deneyebilirsiniz (ClojureScript REPL).

@cliffroot2 byte'ı tıraş ettiğiniz için teşekkür ederiz !

Genişletilmiş kod:

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

Açıklama:

Örnek bir giriş kullanarak satırları birer birer inceleyeceğim 8.

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

Oldukça basit, bu işlevi random-digitsçağırılan tek bir argümanla tanımlar n. #(...)Cevabımda bayt kaydetmek için adsız bir işlev ( ) kullandım .

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

İçeriden içeriye doğru inceleyelim let:

(shuffle (range 10))

ClojureScript (ve Clojure) olarak, (range n)Python en benzer range(n): Bu her sayı ile bir listesini verir 0için n - 1( 9bu durumda).

shufflebir liste alır ve tüm öğeleri karıştırılmış olarak (listeden biraz farklı olan) bir vektör verir. Yani, örneğimizi kullanarak şöyle bir şey elde ediyoruz:

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

(subvec {see above} 0 n)

(subvec vector start end)bir vektörü (yalnızca vektör) alır ve dizinden tüm öğeleri içeren bir vektör ile döner startiçin end. Bu durumda, 0th öğesinden verilen argümana elementleri alıyoruz random-digits. Bunu örneğimize uygularsak, şunu alırız:

[1 0 8 3 6 7 9 2]

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

Bu ifdeyim kontroller ilk öğesi ise num-vectorbir olduğunu 0.

Öyleyse 0, işlevini tekrar nkullanarak , argümanla birlikte çağırıyoruz recur.

Eğer değilse 0:

(int (apply str num-vector))

(apply function list)bir liste alır ve onları argüman olarak işleve dağıtır. Örneğin:

(apply + [2 3 4])

Dönüşür:

(+ 2 3 4)

Hangi eşittir 9.

(str items)her öğeyi itemsbir dizgeye dönüştürür ve ardından birleştirir. inther şeyi bir tamsayıya dönüştürür. Dolayısıyla, bunu örneğimize uygularsak, şunu elde ederiz:

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

Bu bizim son cevabımız.

Python 2, 89 81 80 bayt

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

Çevrimiçi deneyin

R, 45 Bayt

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

Bash + GNU yardımcı programları, 46

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

Çevrimiçi deneyin .

Bu daha büyük bir uzun zaman alır , n , n = 7 için 30s ilgili ve = 10, n için, yani muhtemelen her bir fazlalık için 8-9 saat 10 kat artarak -.

Java 7, 150 147 145 134 bayt

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 sayesinde -2 bayt

(eski) Açıklama:

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

Test kodu:

Burada dene.

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

Örnek çıktı:

7194
8672953041

Perl 6 , 44 bayt

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

Dene

Expanded:

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

Çevrimiçi sürüm

Tüm sürümler 0-9 arasındaki rakamları karıştırmak

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

71 Bayt

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

73 Bayt

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

MATL , 15 bayt

`4Y2GZr1)48=]8M

Denemek MATL Online'da !

açıklama

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

Jöle , 12 bayt

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

Şu anda diğer Jelly cevabımın arkasındaki bir bayt ama bunu gerçekten seviyorum.

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

⎕IO←0Birçok sistemde varsayılan olanı gerektirir .

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

Çevrimiçi deneyin!

Geçerli olana kadar rakamları karıştırır:

10⊥ 10 basamaktan 10 haneye kadar kod çözme,

⊢ sonra

↑ ilk unsurları

{... }⍣{... } ... fonksiyonunu tekrar
 ?⍨10 ilk on pozitif tamsayılar karıştırmak
kadar ...
 ⊃⍺ Geçen girişimi ilk basamak
 × pozitiftir

Python 2 , 100 93 92 90 bayt

2 byte tıraş için @ mbomb007 sayesinde

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

Benzersiz rakamlarla bulunana kadar gerekli sayıları girer. Bahse girerim bunu yapmanın çok daha temiz bir yolu vardır, ama hiçbiri akla gelmiyor.

Pyth , 11 bayt

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'in cevabıyla aynı algoritmayı kullanır .

Çevrimiçi deneyin!

Perl, 48 bayt

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

Açıklama:

1'den 10'a kadar ** rasgele tamsayılar üretin ** $ n-1;

Toplu iş, 156 bayt

@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

xkullanılan basamakların bir bit maskesini tutar. fmevcut hane sayısını gösterir (9'dan geri sayım). Kullanılmayan bir rakam bulunana kadar rastgele rakamlar üretilir. n=10165 bayt için desteklenebilir:

@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

( rbu şekilde golfçu olduğu için fazladan önde gelen bir sıfır içerir.) 165 byte'lık önceki yaklaşım ilk basamağı özel olarak kaydetti ve aynı zamanda işe yaradı n=10(sayısal sürüm aslında 166 byte aldı!):

@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 bayt için orijinal yaklaşım aynı zamanda 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%

Çift basamakları tespit etmek için string manipülasyon kullanır.

Bash , 66 bayt

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

Çevrimiçi deneyin!

Dümdüz ileri, shuf kullanır, xargs satırları birleştirmek için kullanılır ve kombinasyon 0 ile başlarken denemeye devam eder.

Cant diğer cevabından 46 karakter yendi ancak bu yüzden hızlı!

Pyth, 15 28 bayt

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

Burada dene

C #, 127 132 128 126 125 bayt

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

Çevrimiçi Deneyin!

@ KevinCruijssen'in cevabını rastgele başlatmak için verdiği fikirden r,if 2 bayt kaydetmek için deyimi.

Bundan daha iyi golf oynayacağına eminim ama şu an vaktim yok.

whileDöngü kullanan eski sürüm :

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 bayt

Bu bir gerçek rasgele sayı üreten

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

Çevrimiçi deneyin!

C (gcc) , 87 85 bayt

Burada bir rakam dizisi basıyor.

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

Çevrimiçi deneyin!

PHP, 65 63 bayt

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

STDIN'den girdi alır; koşmak-nR .

1ve 10^Nkapsayıcı arasında rasgele sayı oluşturmak ;
farklı karakterlerin sayısı <iken tekrarlayın N.

Mathematica 65 60 Bayt

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

İşte daha hızlı bir sürüm ancak 9 bayt ekliyor:

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

Java 9 JShell, 86 bayt

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

Çevrimiçi deneyin!

Not: Bu paketler varsayılan olarak JShell'de içe aktarıldığı için içe aktarımları saymıyorum, ancak JShell için bildiğim bir çevrimiçi bağlantı yok, bu nedenle Java 9 için bir başlık ve altbilgi kodu verdim. bu bağlamda çalışmasını sağlayın. JShell'de yapabilecekleriniz:

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

Ve sonra:

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

Nasıl çalışır:

Tamsayı'dan Uzun'a bir fonksiyon tanımlarız ve 0-9 aralığında sonsuz bir rasgele uzun akış oluştururuz, ilk n-1 maddelere sınırlar, sonra ilk değer olarak 1-9 arasında bir rasgele int ile azaltır ve değeri 10 ile çarpan ve akıştan sonraki değeri ekleyen bir işlev.

Uzunları kullandım, bu yüzden yaklaşık 18 haneye kadar çalışmalı (n = 18).

C, 96 93 bayt

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 ilk rakamı sıfır olana kadar başlatma başlatır.

Tekdüzen, tekdüze olduğu varsayılır rand()%i. (Çoğu RAND_MAX/iiçin küçük bir geri kalanı bıraktığım için, çok küçük bir önyargı var. Bu önyargı RAND_MAX büyüdükçe küçülüyor.)

Çevrimiçi çalıştığını görün .

Soruda gösterildiği gibi n'nin 2'ye eşit olduğu zamanlar için doğru sayılar ürettiğini görün .

Aksiyom, 191 bayt

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, test sonucu

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

Denizanası , 17 bayt

p
d^u ?
 j?r10
10

Çevrimiçi deneyin!

Dennis'in Jelly cevabının çatalı .

Ruby, 53 52 bayt

İlk rakam 0 olana kadar karıştırın, ardından rakamları birleştirin ve bir tamsayıya dönüştürün.

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

Çevrimiçi deneyin!