Ottieni un numero casuale di n cifre con cifre distinte e prima non uno 0


22

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 è 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]
code-golf  number  random  grid  game  king-of-the-hill  javascript  code-golf  arithmetic  statistics  code-golf  math  code-golf  math  code-golf  string  palindrome  code-golf  string  interactive  code-golf  quine  polyglot  code-golf  string  stack-exchange-api  code-golf  number-theory  decision-problem  code-golf  tips  code-golf  string  internet  code-golf  graphical-output  image-processing  fractal  code-golf  ascii-art  geometry  hexagonal-grid  code-golf  string  restricted-source  hello-world  code-golf  game  code-golf  cipher  code-golf  permutations  cops-and-robbers  permutations  cops-and-robbers  code-golf  internet  stack-exchange-api  code-golf  ascii-art  random  code-golf  tips  code-golf  ascii-art  code-golf  code-golf  kolmogorov-complexity  code-golf  string  unicode  code-golf  number  sequence  primes  palindrome  code-golf  game  decision-problem  code-golf  math  geometry  code-golf  graphical-output  interactive  code-golf  set-partitions  code-golf  number  arithmetic  restricted-source  code-golf  decision-problem  python  recursion  code-golf  ascii-art  code-golf  source-layout  code-golf  function  recursion  functional-programming  code-golf  game  combinatorics  permutations  code-golf  string  file-system  code-golf  string  hashing  code-golf  stack-exchange-api  code-golf  string  code-golf  math  number  arithmetic  polyglot 


ritorna come numero intero, non come stringa, sì?
Giuseppe,

@Giuseppe genera un numero casuale
mbomb007,

4
Penso a questo ogni volta che qualcuno fa una domanda a numero casuale xkcd.com/221
Thunda

1
@ ais523 "Dai un input 0 <n <10 genera un numero casuale con"
cleblanc

Risposte:


17

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.


Sicuramente funziona più velocemente e con meno memoria per l'input di 9o 10.
mbomb007,

Soluzione ordinata! Potresti spiegare come [1::3]funziona per convertirlo da un elenco a una stringa? Non l'ho mai visto prima.
Julian Wolf,

@JulianWolf Funziona solo se ogni elemento dell'elenco ha la stessa lunghezza. Prende effettivamente la rappresentazione in formato stringa dell'elenco, quindi lo suddivide prendendo ogni terzo carattere dopo aver saltato il primo [.
mbomb007,

@JulianWolf [1::3]ottiene il personaggio all'indice 1, quindi ogni terzo. Per [1, 2, 3], che dà 123, saltando le parentesi, le virgole e gli spazi.
Dennis,

Spara, okay, ha senso. Stavo dimenticando che [1, 2, 3]era già stato rigoroso e che le virgole e gli spazi dovevano essere saltati. Grazie!
Julian Wolf,

10

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.


Avevo intenzione di pubblicare una soluzione con ≜₁prima di rendermi conto che era stata aggiunta a causa di questa sfida
Unrelated String

8

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 1 × 10 + d 0
    crea prima
    [d k-1 , d k-2 , ..., d 1 , d 0 ]
    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 n 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).


Oh wow Stavo provando qualcosa di molto simile a questo, ma mi mancava il trucco di memorizzare i valori da restituire negli indici dell'elenco (tramite un'adeguata compilazione dell'elenco), piuttosto che cercare di memorizzarli separatamente. Questo è un trucco utile in Jelly abbastanza spesso e mi sembra sempre che mi manchi.

7

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.

È un modo molto intelligente per rimuovere il duplicato ...
Leaky Nun

7

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.


5

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.


2
Devo amare ClojureScript per averlo permesso (int string)invece di (Integer/parseInt string):)
cliffroot il

1
@cliffroot Voglio dire, puoi farlo read-stringa Clojure, ma non è molto meglio ...
clismique,

2 byte salvati #(let[a(subvec(shuffle(range 10))0 %)](if(=(a 0)0)(recur %)(int(apply str a))))spostano la apply strparte alla fine, consentono di confrontare 0invece di \0e usa subvecinvece di takeconsente di utilizzare il vettore come funzione e quindi di rimuoverefirst
cliffroot

@cliffroot Huh, non sapevo che ha shuffletrasformato la collezione in un vec. Grazie! Dovrà scrivere una nuova spiegazione, però ...
clismique,

5

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


Non penso che tu abbia bisogno di un valore iniziale per l'intervallo.
Dennis,

Bello! Questo rallenterà. : D Peccato che non riesco a usare un generatore invece di un elenco.
mbomb007,

Solo dell'11%. Inserisci un secchio per il codice golf.
Dennis,

Sì, dovrei usare 99**n, solo per essere sicuro di averli tutti. : D
mbomb007,

Ho visto farlo anche in questo modo, ma ne ho ottenuti 80 usando if`set(`i`)`[5*n:]].
Jonathan Allan,

5

R, 45 byte

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

Penso che puoi semplicemente impostare k=0poiché è un vettore implicito di lunghezza uno e puoi usare i = scan () per prendere l'input da stdin come numero. Inoltre, non sono sicuro che un elenco di cifre sia una presentazione "corretta", ma non sono il giudice.
Giuseppe,

@Giuseppe Grazie per l'input, aggiornato entrambi i tuoi suggerimenti (su entrambi i post), grazie.
Neil,

Funzionerebbe while(!k[1])per salvare 2 byte?
BLT,

@BLT Aggiornato, grazie.
Neil,

3

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.


per la domanda, n = 10 non ha nemmeno bisogno di funzionare, tanto meno di essere veloce
ysth

3

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

Non puoi usare un'espressione lambda qui? cioè n->...o è Java 8+?
TheLethalCoder

1
Puoi anche prendere in prestito il trucco che ho appena usato nella mia risposta, impostare la lunghezza nel controllo comparativo, ad esempio for(int l,x;(l=r.length())<n;)e dovresti salvare un byte.
TheLethalCoder

1
@TheLethalCoder Ah ovviamente, grazie. Ottimo lavoro di squadra! ;) E sì, n->...è Java 8. Personalmente preferisco codegolf in Java 7, anche se 8 è sempre più corto.
Kevin Cruijssen,

2

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

2

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

2

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

2

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.

2

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


1

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.


return(n==len(set(`k`)))*k or f(n). Provalo online
mbomb007,

1

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!


1

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.


1

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.


1

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!


1

Pyth, 15 28 byte

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

Provalo qui


1
Benvenuto in PPCG e ottimo lavoro nell'uso del linguaggio del golf :-) Vedo 2 piccoli problemi: 1) sembra che la seconda cifra sia sempre 0, quindi penso che vorrai passare ^TttQa ^TtQ(-1 byte, bonus!). 2) tutte le cifre nell'output devono essere univoche, quindi dovrai forzare che ciò accada in qualche modo.
ETHproductions

@ETHproductions Arg !! Grazie per la segnalazione. L'ho risolto.
Maria,

1

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

Non penso sia corretto. Diciamo che il primo numero intero casuale è 0, sarebbe prima prova if(s.Length<1&r>0)che è falso, ma poi lo farà if(!s.Contains(r+""))il che è vero ed ancora di accodamento "0"per scome prima cifra.
Kevin Cruijssen,

@KevinCruijssen Risolto e continuato a
giocare a

1
@KevinCruijssen Ah, l'ho risolto, nel tuo esempio non finisci il .Next(10)... con un ;. Quindi non ci sono ulteriori miglioramenti, ma buona idea.
TheLethalCoder

1
L'ho appena pubblicato. E oops, hai ragione, mi mancava quel punto e virgola. Puoi comunque giocare a golf così: n=>{var s="";for(int l=0,r;l<n;l=s.Length)if((l<1&(r=new System.Random().Next(10))>0)|(l>0&!s.Contains(r+"")))r+=x;return s;};:)
Kevin Cruijssen,

1
@KevinCruijssen Ho appena preso in prestito l'idea dalla tua risposta mentre stavi scrivendo quel commento! Bel miglioramento grazie
TheLethalCoder

1

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!


1

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.


1
while(count(count_chars($x=rand(1,10**$argn),1))<$argn);echo$x;-2 byte
Jörg Hülsermann

0

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

0

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


0

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 .


0

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


0

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!

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.