Stavo rispondendo a una sfida qui e questo compito faceva parte della sfida. Ho una soluzione di 73 byte in javascript. Ma penso che sia troppo per una cosa semplice.

Sfida

Dato come input due numeri interi:

• N la lunghezza dell'array previsto
• Rl'intervallo dell'intervallo inizia in uno:, 1..Rno0..R-1

Emette in ogni esecuzione del tuo programma / funzione un diverso array di lunghezza Ncon valori 1..Rin modo tale che nessun valore si presenti più di una volta.

Devi usare R-valuenel tuo codice.

restrizioni

Si può assumere: 2 <= N <= R.

Mi piacerebbe davvero vedere una soluzione javascript più corta dei miei 73 byte.

Ma ovviamente è aperto a tutte le lingue!

Se la tua lingua non può restituire un array, puoi stampare tutti i numeri;)

Dyalog APL, 1 byte

?

Solo un built-in. Provalo qui .

JavaScript (ES6), 68 66 byte

n=>r=>G=(s=new Set)=>s.size<n?G(s.add(Math.random()*r+1|0)):[...s]

Chiamato come F(N)(R)(), dove si Ftrova l'assegnazione della funzione e N/ Rsono i valori.

Hai richiesto meno di 73 byte in Js;)

EDIT: la risposta di @ C5H8NNaO4 funziona nel fatto che le regole non specificano che i valori devono essere uniformi 1..R. Detto questo, ecco una versione che funziona in 63 byte (chiamata come F(R)(N)):

r=>G=(n,s=[])=>n--?G((s[n]=n+1,n),s):s.sort(a=>new Date/a%1-.5)

Ottava, 22 19 9 byte

@randperm

randperm(r,n)fa esattamente ciò che è richiesto. Nota che questo non funziona (almeno non nelle versioni precedenti) in Matlab.

TI-84 BASIC OS 4.0, 12 byte

Prompt N,R:randIntNoRep(1,R,N

La TI-84 + CSE (2013) e la CE (2015) sono essenzialmente lo stesso dialetto BASIC limitato della TI-84 +, ma ci sono alcune nuove funzionalità. Uno di questi è il terzo argomento di randIntNoRep.

MATL , 2 byte

Zr

Gli input sono: prima R, quindi N.

Provalo online!

Spiegazione

La funzione Zraccetta due input (implicitamente in questo caso) ed esegue un campionamento casuale senza sostituzione. Il primo input, Rspecifica che la popolazione è [1,2,...,R]; e il secondo input, Nindica il numero di campioni da prelevare dalla popolazione.

J, 4 3 byte

Un byte salvato grazie a Zgarb! ( _{Quattro barrati sono ancora quattro regolari: D} )

1+?

chiama come N (1+?) R, ad es 3 (1+?) 10. Questo utilizza l'operatore "Rotolo" e fa esattamente ciò che è descritto, tranne sotto 0...n-1. Se ci fosse permesso farlo, la risposta sarebbe 1 byte,

?

Pyth, 6 byte

<.SSQE

Provalo qui!

La distanza arriva sulla prima riga e la lunghezza sulla seconda.

Spiegazione

<.SSQE # Q = intervallo, E = lunghezza

   SQ # genera l'intervallo 1 ... Q
 .S # rimescola l'elenco
<E # prende i primi elementi E.

Versione a 5 byte non competitiva

L'ultima aggiunta a Pyth aggiunge Q, se necessario, impliciti alla fine del programma. Possiamo usarlo qui invertendo il formato di input, quindi la lunghezza viene prima e poi l'intervallo.

<.SSE

Provalo qui!

Ecco El'intervallo, che trasformiamo in un elenco basato su 1 S, lo mescoliamo con .Se prendiamo i primi Qelementi con <. <si aspetta un numero intero che viene aggiunto implicitamente con a Q.

Reng v.2.1, 140 103 98 97 byte

Questo dovrebbe funzionare anche nelle versioni precedenti.

v      v      $/$'l#y0#z>(:)):(ez+#z zt>a$;!
>i#ci#x>cu1+lxetv    j21\!q   yy#-1y($/^
>n?~v
^oW <

Puoi provarlo qui! L'input è maximum length, come ad esempio 10 3.

Sono così orgoglioso di questo, non lo sai nemmeno. Se qualcuno mi batte con una risposta Java, questo renderà la mia giornata. Se ho battuto una risposta Java, considera anche la mia giornata fatta.

Lo spiegherò più tardi, una volta guarito. In generale, però:

v         v      $/$r$
>i#bbi1+#x>:u1+lxet

Questo genera i numeri casuali. L'altra parte controlla se ci sono duplicati e, se ci sono, il processo viene ripetuto. Altrimenti, i risultati vengono stampati, con spazi che uniscono i risultati.

Ecco alcuni esempi:

CJam, 8 byte

{,:)mr<}

Provalo qui!

Questo è un blocco senza nome che prevede l'intervallo in cima alla pila e la lunghezza in fondo e lascia un elenco sulla pila.

Spiegazione

, intervallo basato su e # 0
:) e # inkrement ogni elemento dell'elenco in modo che sia basato su 1
mr e # rimescola l'elenco
<e # accetta i primi n elementi

Lisp comune, 90

^{52 solo per l'espressione}

(use-package :alexandria)(lambda(R N)(coerce(subseq(shuffle(iota R :start 1))0 N)'vector))

Ungolfed

;; Well known library
(use-package :alexandria)

(lambda(R N)
  (coerce                   ; make a vector from a list 
    (subseq                 ; take the sublist from 0 to N
      (shuffle              ; shuffle a list
        (iota R :start 1))  ; build a list from 1 to R
    0 N)
    'vector))

Come altre risposte, se non conto use-package e lambda , l'espressione rimanente è (coerce(subseq(shuffle(iota R :start 1))0 N)'vector), per 52 byte.

Rubino, 27 23 byte

Funzione anonima, ragionevolmente breve e dolce.

-4 byte da @manatwork

->n,r{[*1..r].sample n}

𝔼𝕊𝕄𝕚𝕟, 10 caratteri / 13 byte

Ѩŝ⩤⁽1í)ą-î

Try it here (Firefox only).

Spiegazione

           // implicit: î=input1, í=input2
  ⩤⁽1í)    // Inclusive range from 1 to í
Ѩŝ         // Shuffle resulting range
       ą-î // Get last îth items

Bash + coreutils, 16

Penso che questo sia autoesplicativo:

seq $2|shuf -n$1

Input Ne Rcome parametri della riga di comando.

O come sottolinea @rici, per lo stesso punteggio:

shuf -n$1 -i1-$2

Ideone.

PowerShell v2 +, 30 byte

param($n,$r)1..$r|Random -c $n

Prende l'input $ne $r, costruisce un intervallo 1..$r, i tubi che Get-Randomcon una -Concia di $n, che selezionerà $nelementi unici dall'intervallo. L'output viene lasciato sulla pipeline come un array implicito.

Scherzi a parte, 5 byte

,,R╨J

Provalo online!

Spiegazione:

,,R╨J
,,R    push N, range(1, R+1)
   ╨   push a list containing all N-length permutations of range(1, R+1)
    J  select a random element from the list

Clojure, 38 byte

#(take %1(shuffle(map inc(range %2))))

Una funzione anonima che prende N per primo e R per secondo.

Perl 6, 32 byte

{(^$^a).permutations.pick[^$^b]}

Python 3.5 - 54 53 byte:

from random import*;lambda a,c:sample(range(1,c+1),a)

Questo utilizza la sample()funzione del modulo casuale per restituire un array con lunghezza "a" costituito da elementi casuali e unici nell'intervallo 1 => c.

D, 29 byte (solo espressione)

Supponendo che std.random e std.range siano stati importati e che n e r siano definiti come variabili, il programma può essere risolto nella singola espressione:

iota(1,r).randomCover.take(n)

ES6, 72

r=>n=>[...Array(-~r).keys()].sort(a=>new Date/a%1-.5).filter(a=>a&&n-->0)

Come nella risposta di @ Mwr247 , puoi chiamarlo F(R)(N), Fessendo l'espressione della funzione

Mathcad, 67 "byte"

crea un vettore di colonna di numeri interi consecutivi nell'intervallo 1..R, lo unisce a un vettore di colonna di lunghezza R di numeri casuali (uniformi), ordina la matrice Rx2 risultante sulla colonna di numeri casuali, quindi estrae i primi n numeri dal colonna casuale di numeri interi.

Python, 56 (il modo ovvio)

lambda N,R:__import__('random').sample(range(1,R+1),k=N)

Perl 5, 51 43 byte

sub{@a=1..pop;map{splice@a,rand@a,1}1..pop}

Sottotitoli anonimi piuttosto semplici che generano un array da 1 a R e quindi uniscono N elementi casuali da restituire. Chiama con ->(N, R).

TI-84 BASIC, 21 byte

Prompt R,N:randIntNoRep(1,R→A:N→dim(ʟA:ʟA