Je répondais à un défi ici et cette tâche faisait partie du défi. J'ai une solution de 73 octets en javascript. Mais je pense que c'est trop pour une chose simple.

Défi

Étant donné en entrée deux entiers:

• N la longueur du tableau attendu
• Rla plage de l'intervalle commençant par un:, 1..Rpas0..R-1

Sortez à chaque exécution de votre programme / fonction un tableau différent de longueur Navec des valeurs comprises 1..Rde telle manière qu'aucune valeur ne se produit plus d'une fois.

Vous devez utiliser R-valuedans votre code.

Restrictions

Vous pouvez supposer: 2 <= N <= R.

Je voudrais vraiment voir une solution javascript plus courte que la mienne 73 octets.

Mais bien sûr, il est ouvert à toutes les langues!

Si votre langue ne peut pas renvoyer un tableau, vous pouvez imprimer tous les nombres;)

Dyalog APL, 1 octet

?

Juste un intégré. Essayez-le ici .

JavaScript (ES6), 68 66 octets

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

Appelé comme F(N)(R)(), où Fest l'affectation de fonction et N/ Rsont les valeurs.

Vous avez demandé moins de 73 octets en Js;)

EDIT: La réponse de @ C5H8NNaO4 fonctionne dans le fait que les règles ne spécifient pas que les valeurs doivent être uniformes à travers 1..R. Étant donné que, voici une version qui fonctionne en 63 octets (appelés comme F(R)(N)):

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

Octave, 22 19 9 octets

@randperm

randperm(r,n)fait exactement ce qui est demandé. Notez que cela ne fonctionne pas (du moins pas dans les versions plus anciennes) dans Matlab.

TI-84 BASIC OS 4.0, 12 octets

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

La TI-84 + CSE (2013) et la CE (2015) sont essentiellement le même dialecte BASIC limité que la TI-84 +, mais il y a quelques nouvelles fonctionnalités. L'un d'eux est le troisième argument de randIntNoRep.

MATL , 2 octets

Zr

Les entrées sont: d'abord R, puis N.

Essayez-le en ligne!

Explication

La fonction Zrprend deux entrées (implicitement dans ce cas) et effectue un échantillonnage aléatoire sans remplacement. La première entrée,, Rspécifie que la population est [1,2,...,R]; et la deuxième entrée,, Nindique le nombre d'échantillons à prélever dans la population.

J, 4 3 octets

Un octet sauvé grâce à Zgarb! ( _{Quatre barrés est toujours un quatre régulier: D} )

1+?

appeler comme N (1+?) R, par exemple 3 (1+?) 10. Cela utilise l'opérateur "Roll" et fait exactement ce qui est décrit, sauf sous 0...n-1. Si nous étions autorisés à le faire, la réponse serait 1 octet,

?

Pyth, 6 octets

<.SSQE

Essayez-le ici!

La plage vient sur la première ligne et la longueur sur la seconde.

Explication

<.SSQE # Q = plage, E = longueur

   SQ # génère la plage 1 ... Q
 .S # mélange la liste
<E # prendre les premiers éléments E

Version 5 octets non concurrente

Le dernier ajout à Pyth ajoute des Qs implicites à la fin du programme si nécessaire. Nous pouvons l'utiliser ici en inversant le format d'entrée, de sorte que la longueur vient en premier, puis la plage.

<.SSE

Essayez-le ici!

Voici Ela plage, avec laquelle nous transformons une liste basée sur 1 S, mélangez-la avec .Set prenez les premiers Qéléments avec <. <attend un entier qui est implicitement ajouté avec un Q.

Reng V.2.1, 140 103 98 97 octets

Cela devrait également fonctionner dans les versions antérieures.

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

Vous pouvez l'essayer ici! L'entrée est maximum length, comme 10 3.

J'en suis tellement fier, tu ne sais même pas. Si quelqu'un me bat avec une réponse Java, cela fera ma journée. Si je bat une réponse Java, pensez aussi à ma journée.

Je l'expliquerai plus tard, une fois que je serai rétabli. Généralement, cependant:

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

Cela génère des nombres aléatoires. L'autre partie vérifie s'il y a des doublons et, s'il y en a, le processus est répété. Sinon, les résultats sont imprimés, avec des espaces joignant les résultats.

Voici quelques exemples:

CJam, 8 octets

{,:)mr<}

Essayez-le ici!

Il s'agit d'un bloc sans nom qui attend la plage en haut de la pile et la longueur en bas et laisse une liste sur la pile.

Explication

, plage basée sur e # 0
:) e # inkrement chaque élément de la liste de sorte que sa base 1
monsieur e # mélangez la liste
<e # prendre les n premiers éléments

Lisp commun, 90

^{52 pour l'expression seulement}

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

Non golfé

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

Comme pour les autres réponses, si je ne compte pas use-package et lambda , l'expression restante est (coerce(subseq(shuffle(iota R :start 1))0 N)'vector), pour 52 octets.

Rubis, 27 23 octets

Fonction anonyme, raisonnablement courte et douce.

-4 octets de @manatwork

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

𝔼𝕊𝕄𝕚𝕟, 10 caractères / 13 octets

Ѩŝ⩤⁽1í)ą-î

Try it here (Firefox only).

Explication

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

Bash + coreutils, 16

Je pense que cela va de soi:

seq $2|shuf -n$1

Entrez Net Rcomme paramètres de ligne de commande.

Ou comme le souligne @rici, pour le même score:

shuf -n$1 -i1-$2

Ideone.

PowerShell v2 +, 30 octets

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

Prend des entrées $net $rconstruit une plage 1..$r, les dirige vers Get-Randomune -Cquantité de $n, qui sélectionnera $ndes éléments uniques de la plage. La sortie est laissée sur le pipeline sous la forme d'un tableau implicite.

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

Clojure, 38 bytes

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

An anonymous function taking N first and R second.

Perl 6, 32 bytes

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

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.

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)

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

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.

Python, 56 (the obvious way)

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

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

TI-84 BASIC, 21 bytes

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