Una società di lotteria vuole generare un numero di biglietto della lotteria casuale di lunghezza 10 caratteri.

Scrivi un codice in qualsiasi lingua per creare un tale numero in cui ogni cifra arriva una sola volta, ad esempio 9354716208in questo numero tutti i numeri interi da 0 a 9 arrivano solo una volta. Questo numero dovrebbe essere un numero casuale.

• Il numero generato dovrebbe essere mostrato sullo schermo.
• Deve essere in grado di generare tutte le permutazioni di tutti i caratteri consentiti.
• Il codice deve essere il più piccolo possibile (in byte).

J (4 byte)

Non ho resistito.

?~10

In J, se Fè diadico, F~ xè lo stesso di x F x.

J, 5 caratteri e APL, 8 caratteri

J

10?10

J ha l'operatore affare integrato ( ?). Quindi, possiamo prendere 10 su 10 ( 10?10).

APL

1-⍨10?10

APL ha lo stesso operatore che sfortunatamente inizia con uno invece di zero. Ne stiamo quindi sottraendo uno da ciascun numero ( 1-⍨Xsignifica X-1dovuto all'operatore del tragitto giornaliero).

Python 2.7 ( 64 63 57)

Non è una possibilità qui rispetto alle lingue pesanti dell'operatore ea causa della mancanza di default caricati casualmente :) Questo è il più breve che ho potuto inventare;

from random import*
print''.join(sample("0123456789",10))

Crea un intervallo e ne campiona 10 numeri senza sostituzione.

(Grazie a @xfix per la correzione del formato di importazione più breve e @blkknght per aver sottolineato il mio intervallo di campionamento un po 'complicato)

Python 2.7 (40)

Se lo esegui dal prompt interattivo e riesci a leggere la virgola separata, puoi raderlo a 40, ma sembra un po 'come spezzare lo spirito delle regole;

from random import*
sample(range(10),10)

PHP, 29 caratteri

<?=str_shuffle('0123456789');

Con PHP, il tag di chiusura non è richiesto. Ma se questo è contro le regole, puoi sostituirlo; con?> per 1 aumento netto.

Ruby, 18 anni

Esegui questo in irb:

[*0..9].shuffle*''

Se vuoi che questo sia un programma autonomo, con output in stdout(le regole non sembrano richiederlo ), aggiungi questi 4 caratteri all'inizio:

$><<

PHP - 37 personaggi

<?=join('',array_rand(range(0,9),10))

Avevo una soluzione di 18 caratteri che teoricamente dovrebbe funzionare, ma PHP è strano.

Oppure, se vuoi una risposta xkcd:

<?="5398421706" // Chosen by program above; guaranteed to be random ?>

EDIT: grazie a xfix, ora è 5 caratteri più breve e completo. MODIFICA ANCORA: esempio live .

Perl 6 (18 16 caratteri)

print pick *,^10

Questo genera un array contenente tutti gli elementi casuali ( pick *) da 0a 9e genera il risultato ( print).

Uscita campione:

$ perl6 -e 'print pick *,^10'
4801537269
$ perl6 -e 'print pick *,^10'
1970384265
$ perl6 -e 'print pick *,^10'
3571684902

GolfScript, 12 caratteri

10,{;9rand}$

Genera semplicemente l'elenco di cifre ( 10,) e lo ordina in {...}$base ad alcune chiavi casuali, il che produce un ordine casuale delle cifre.

Esempi (prova online ):

4860972315

0137462985

R (23 caratteri)

cat(sample(0:9),sep="")

Uscita campione:

> cat(sample(0:9),sep="")
3570984216
> cat(sample(0:9),sep="")
3820791654
> cat(sample(0:9),sep="")
0548697132

TI-BASIC, 5 byte

randIntNoRep(1,10

Ottava (14)

randperm(10)-1

randperm purtroppo crea una selezione da 1..n, quindi è necessario sottrarre 1 alla fine per ottenere 0-9.

Nel server sql

DECLARE @RandomNo varchar(10)
SET @RandomNo = ''

;WITH num as (
SELECT 0 AS [number]
Union 
select 1
Union 
select 2
Union 
select 3
Union 
select 4
Union 
select 5
Union 
select 6
Union 
select 7
Union 
select 8
Union 
select 9
)
SELECT Top 9 @RandomNo = COALESCE(@RandomNo + '', '') + cast(n.number AS varchar(1))
FROM numbers n
ORDER BY NEWID()

SELECT cast(@RandomNo AS numeric(10,0))

Vedi la demo

O qualcosa di simile (per gentile concessione di @manatwork) usando ricorsione e xml.

with c as(select 0i union all select i+1from c where i<9)select i+0from c order by newid()for xml path('')

Javascript ( 79 78 68 caratteri)

Invece di creare un array con i numeri 0-9 e ordinarlo, ho deciso di generare numeri casuali. Quando è arrivato un numero che non era già nell'array, lo ha aggiunto. Ciò si ripete dieci volte e quindi avvisa l'output.

for(a="";!a[9];){~a.indexOf(b=~~(Math.random()*10))||(a+=b)}alert(a)

Mathematica, 27

Row@RandomSample@Range[0,9]

Shell / Coreutils, 23

shuf -i0-9|paste -sd ''

JavaScript, 82 caratteri

EDIT: grazie a Rob W , la lunghezza del codice è ridotta a 90 caratteri.

EDIT: grazie a George Reith , la lunghezza del codice è ridotta a 82 caratteri (usando per il ciclo).

Modo piuttosto semplice: scegli un elemento casuale [0,1,2,3,4,5,6,7,8,9]dell'array e aggiungilo all'output, quindi riduci l'array e il replay.

Vecchia versione (106 caratteri):

a=[0,1,2,3,4,5,6,7,8,9],l=11,t="";while(--l){r=Math.floor(Math.random()*l);t+=a[r];a.splice(r,1);}alert(t)

Versione leggibile:

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], l = 10,t = "";
while(l--) {
  r = Math.floor(Math.random() * l);
  t += a[r];
  a.splice(r, 1);
}
alert(t);

Versione migliore (90 caratteri):

a="0123456789".split(t=""),l=11;while(--l)t+=a[r=0|Math.random()*l],a.splice(r,1);alert(t)

Ultima versione (82 caratteri):

a="0123456789".split(t='');for(l=11;--l;t+=a.splice(0|Math.random()*l,1));alert(t)

JSFiddle: http://jsfiddle.net/gthacoder/qH3t9/ .

C #, 145 byte

Ungolfed

using System;
using System.Linq;
class P
{
    static void Main()
    {
        Enumerable.Range(0,10).OrderBy(g => Guid.NewGuid()).ToList().ForEach(Console.Write);
    }
}

golfed

using System;using System.Linq;class P{static void Main(){Enumerable.Range(0,10).OrderBy(g => Guid.NewGuid()).ToList().ForEach(Console.Write);}}

JavaScript (80 caratteri)

alert("0123456789".split("").sort(function(){return .5-Math.random()}).join(""))

JS-Fiddle: http://jsfiddle.net/IQAndreas/3rmza/

K / Kona (6)

-10?10

Come per J, ?è l'operatore commerciale; le -forze i valori da non ripetere.

Mathematica 40

Il numero viene creato come una stringa in modo da consentire a zero di essere visualizzato come primo carattere, quando necessario.

""<>RandomSample["0"~CharacterRange~"9"]

Esempi di output

"0568497231"
"6813029574"

Spiegazione

"0"~CharacterRange~"9" è notazione infissa per `CharacterRange [" 0 "," 9 "]". Ognuno di questi restituisce l'elenco, {"0", "1", "2", "3", "4", "5", " 6" , "7", "8", "9"}.

RandomSample[list]per impostazione predefinita restituisce una permutazione dell'elenco. (Può essere utilizzato anche per altri tipi di campionamento, quando sono inclusi parametri. Ad esempio RandomSample[list, 4]restituirà un campione casuale di 4 caratteri, senza ripetizioni.

Scala, 37

util.Random.shuffle(0 to 9).mkString

Avanti, 72

needs random.fs : r ': '0 do i loop 9 for i 1+ random roll emit next ; r

Forse c'è ancora spazio per giocare a golf, ma Forth lo ha reso difficile. Penso.

Prolog, 177/302 caratteri

Sono un principiante su Prolog, quindi probabilmente questo non è il codice più condensato.

:- use_module(library(clpfd)).
sort(N) :-
    N = [N0,N1,N2,N3,N4,N5,N6,N7,N8,N9],
    domain([N0],1,9),
    domain([N1,N2,N3,N4,N5,N6,N7,N8,N9],0,9),
    all_different(N),
    labeling([],N).

Ritorna:

| ?- sort2(N).                                         
N = [1,0,2,3,4,5,6,7,8,9] ? ;
N = [1,0,2,3,4,5,6,7,9,8] ? ;
N = [1,0,2,3,4,5,6,8,7,9] ? ;
N = [1,0,2,3,4,5,6,8,9,7] ? ;
N = [1,0,2,3,4,5,6,9,7,8] ? 
yes

Se vuoi che restituisca un numero intero:

:- use_module(library(clpfd)).
sort(M) :-
    N = [N0,N1,N2,N3,N4,N5,N6,N7,N8,N9],
    domain([N0],1,9),
    domain([N1,N2,N3,N4,N5,N6,N7,N8,N9],0,9),
    all_different(N),
    labeling([],N),
    M is (N0*1000000000)+(N1*100000000)+(N2*10000000)+(N3*1000000)+
         (N4*100000)+(N5*10000)+(N6*1000)+(N7*100)+(N8*10)+N9.

Ritorna:

| ?- sort(N).
N = 1023456789 ? ;
N = 1023456798 ? ;
N = 1023456879 ? ;
N = 1023456897 ? ;
N = 1023456978 ? 
yes

Utilizzando invece:

labeling([down],N)

Fornisce i numeri nell'ordine opposto:

| ?- sort(N).                                        
N = 9876543210 ? n
N = 9876543201 ? n
N = 9876543120 ? n
N = 9876543102 ? n
N = 9876543021 ? 
yes

A differenza di altri codici pubblicati, questo restituisce tutte le possibilità (senza ripetizioni).

q / kdb [6 caratteri]

-10?10

genererà 10 numeri casuali univoci.

√ å ı ¥ ® Ï Ø ¿ , 4 byte

XrśO

X    › Push 10 to the stack
 r   › Push the range from [1...10]
  ś  › Shuffle the stack
   O › Output the whole stack separated by spaces

Clojure, 42

(println (apply str (shuffle (range 10))))

6209847315

Javascript, 83 caratteri

a=[];while(!a[9]){b=Math.floor(Math.random()*10);!a.includes(b)&&a.push(b)}alert(a)

Durante l'esecuzione fino a quando l'array ha 10 elementi.

Generando un numero casuale da 0 a 9, controlla se l'array include questo numero e aggiungilo all'array.

Questo non è molto più piccolo della risposta di JMK, ma ecco una soluzione C # leggermente più piccola (135):

using System;
using System.Linq;
class P { 
    static void Main() 
    { 
        Console.Write(string.Join("", "0123456789".OrderBy(g => Guid.NewGuid()))); 
    } 
}

Compattato (134):

using System;using System.Linq;class P{static void Main(){Console.Write(string.Join("", "0123456789".OrderBy(g => Guid.NewGuid())));}}

Versione alternativa (135):

using System;
using System.Linq;
class P { 
    static void Main() 
    { 
        "0123456789".OrderBy(g => Guid.NewGuid()).ToList().ForEach(Console.Write); 
    } 
}

Compatto:

using System;using System.Linq;class P{static void Main(){"0123456789".OrderBy(g => Guid.NewGuid()).ToList().ForEach(Console.Write);}}

Sono uguali in lunghezza, ma dipende solo se si desidera utilizzare la funzione ForEach di Linq o la funzione Join di String. Sono stato in grado di rimuovere 10 caratteri di lunghezza spiegando l'intervallo "0123456789" in una stringa anziché utilizzare Enumerable.Range (0, 10).

LOGO , 64 caratteri

make "d 1234567890
repeat 10 [
    make "n pick d
    show n
    make "d butmember n d
]

pick restituisce un elemento casuale dell'elenco fornito. butmember restituisce l'elenco con tutte le occorrenze dell'elemento specificato rimosse. Nota: non tutte le implementazioni del logo supportano il butmembercomando.

Racchetta 45 43

(map print(shuffle'(0 1 2 3 4 5 6 7 8 9)))