Random array without repetition

Question

I was answering one challenge here and this task was part of the challenge. I've got a 73 bytes solution in javascript. But I think it is too much for a simple thing.

Challenge

Given as input two integers:

• N the length of the expected array
• R the interval's range starting in one: 1..R, not 0..R-1

Output in each run of your program/function one different array of length N with values between 1..R in such a way no one value occurs more than once.

You must use R-value in your code.

Restrictions

You can assume: 2 <= N <= R.

I really would like to see a javascript solution shorter than mine 73 bytes.

But of course, it is open to all languages!

If your language can not return an array, you can print all the numbers ;)

Answer 1

Dyalog APL, 1 byte

?

Just a builtin. Try it here.

Answer 2

JavaScript (ES6), 68 66 bytes

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

Called as F(N)(R)(), where F is the function assignment, and N/R are the values.

You asked for shorter than 73 bytes in Js ;)

EDIT: The answer by @C5H8NNaO4 works within the fact that the rules don't specify the values must be uniform across 1..R. Given that, here's a version works in 63 bytes (called as F(R)(N)):

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

Answer 3

Octave, 22 19 9 bytes

@randperm

randperm(r,n) does exactly what is requested. Note that this does not work (at least not in oldder versions) in Matlab.

Answer 4

MATL, 2 bytes

Zr

Inputs are: first R, then N.

Try it online!

Explanation

The function Zr takes two inputs (implicitly in this case) and does a random sampling without replacement. The first input, R, specifies that the population is [1,2,...,R]; and the second input, N, indicates the number of samples to take from the population.

Answer 5

TI-84 BASIC OS 4.0, 12 bytes

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

The TI-84+ CSE (2013) and the CE (2015) are essentially the same limited BASIC dialect as the TI-84+, but there are a few new features. One of them is randIntNoRep's third argument.

Answer 6

Pyth, 6 bytes

<.SSQE

Try it here!

Range comes on the first line and the length on the second.

Explanation

<.SSQE    # Q = range, E = length

   SQ     # generate the range 1...Q
 .S       # shuffle the list
<    E    # take the first E elements

Non-competing 5-byte version

The lastest addition to Pyth adds implicit Qs at the end of the program if needed. We can use this here by reversing the input format, so the length comes first and then the range.

<.SSE

Try it here!

Here E is the range, which we turn into a 1-based list with S, shuffle it with .S and take the first Q elements with <. < expects an integer which is implicitly added with a Q.

Answer 7

J, 4 3 bytes

One byte saved thanks to Zgarb! (_{Crossed out four is still a regular four :D})

1+?

call like N (1+?) R, e.g., 3 (1+?) 10. This uses the "Roll" operator, and does exactly what is described, except under 0...n-1. If we were allowed to do this, then the answer would be 1 byte,

?

Answer 8

Reng v.2.1, 140 103 98 97 bytes

This should work in earlier versions, too.

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

You can try it here! Input is maximum length, such as 10 3.

I am so proud of this, you don't even know. If someone beats me with a Java answer, that will make my day. If I beat a Java answer, consider my day made as well.

I will explain it more later, once I recover. Generally, though:

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

This generates the random numbers. The other part checks if there are duplicates, and, if there are, the process is repeated. Else, the results are printed, with spaces joining the results.

Here are some examples:

Answer 9

CJam, 8 bytes

{,:)mr<}

Try it here!

This is an unnamed block which expect the range on top of the stack and the length at the bottom and leaves a list on the stack.

Explanation

,   e# 0-based range
:)  e# inkrement each element of the list so its 1-based
mr  e# shuffle the list
<   e# take the first n elements

Answer 10

Bash + coreutils, 16

I think this is self-explanatory:

seq $2|shuf -n$1

Input N and R as command-line parameters.

Or as @rici points out, for the same score:

shuf -n$1 -i1-$2

Ideone.

Answer 11

Ruby, 27 23 bytes

Anonymous function, reasonably short and sweet.

-4 bytes from @manatwork

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

Answer 12

Common Lisp, 90

^{52 for the expression only}

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

Like other answers, if I don't count use-package and lambda, the remaining expression is (coerce(subseq(shuffle(iota R :start 1))0 N)'vector), for 52 bytes.

Answer 13

, 10 chars / 13 bytes

Ѩŝ⩤⁽1í)ą-î

Try it here (Firefox only).

Explanation

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

Answer 14

PowerShell v2+, 30 bytes

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

Takes input $n and $r, constructs a range 1..$r, pipes that to Get-Random with a -Count of $n, which will select $n unique elements from the range. Output is left on the pipeline as an implicit array.

Answer 15

Seriously, 5 bytes

,,R╨J

Try it online!

Explanation:

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

Answer 16

Python 3.5 - 54 53 bytes:

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

This uses the random module's sample() function to return an array with length "a" consisting of random, unique elements in the range 1 => c.

Answer 17

Clojure, 38 bytes

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

An anonymous function taking N first and R second.

Answer 18

Perl 6, 32 bytes

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

Answer 19

D, 29 bytes (expression only)

Assuming that std.random and std.range have been imported and that n and r are defined as variables, the program can be solved in the single expression:

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

Answer 20

ES6, 72

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

Like in @Mwr247's answer, you can call it with F(R)(N), F being the function expression

Answer 21

Mathcad, 67 "bytes"

creates a column vector of consecutive integers in range 1..R, joins it to a column vector of length R of (uniform) random numbers, sorts the resulting Rx2 matrix on the random number column, and then extracts the first n numbers from the randomized column of integers.

Answer 22

Python, 56 (the obvious way)

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

Answer 23

TI-84 BASIC, 21 bytes

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

Answer 24

Perl 5, 51 43 bytes

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

Pretty straightforward anonymous sub that generates an array from 1 to R and then splices N random elements from it to return. Call with ->(N, R).