Eu estava respondendo a um desafio aqui e essa tarefa fazia parte do desafio. Eu tenho uma solução de 73 bytes em javascript. Mas acho que é demais para uma coisa simples.

Desafio

Dado como entrada dois números inteiros:

• N o comprimento da matriz esperada
• Ro intervalo do intervalo começando em um:, 1..Rnão0..R-1

Produza em cada execução do seu programa / função uma matriz diferente de comprimento Ncom valores entre 1..Rde tal maneira que nenhum valor ocorra mais de uma vez.

Você deve usar R-valueno seu código.

Restrições

Você pode assumir: 2 <= N <= R.

Eu realmente gostaria de ver uma solução javascript menor que a minha 73 bytes.

Mas é claro, está aberto a todas as línguas!

Se o seu idioma não puder retornar uma matriz, você poderá imprimir todos os números;)

Dyalog APL, 1 byte

?

Apenas um builtin. Experimente aqui .

JavaScript (ES6), 68 66 bytes

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

Chamado como F(N)(R)(), onde Festá a atribuição da função e N/ Rsão os valores.

Você solicitou menos de 73 bytes em Js;)

EDIT: A resposta de @ C5H8NNaO4 funciona dentro do fato de que as regras não especificam os valores devem ser uniformes 1..R. Dado que, aqui está uma versão que funciona em 63 bytes (chamada comoF(R)(N) ):

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

Oitava, 22 19 9 bytes

@randperm

randperm(r,n)faz exatamente o que é solicitado. Observe que isso não funciona (pelo menos não nas versões mais antigas) no Matlab.

TI-84 BASIC OS 4.0, 12 bytes

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

A TI-84 + CSE (2013) e a CE (2015) são essencialmente o mesmo dialeto BASIC limitado da TI-84 +, mas existem alguns novos recursos. Um deles é o terceiro argumento de randIntNoRep.

MATL , 2 bytes

Zr

As entradas são: primeiro Re depois N.

Experimente online!

Explicação

A função Zrrecebe duas entradas (implicitamente neste caso) e faz uma amostragem aleatória sem substituição. A primeira entrada,, Respecifica que a população é [1,2,...,R]; e a segunda entrada,, Nindica o número de amostras a serem coletadas da população.

J, 4 3 bytes

Um byte economizado graças ao Zgarb! ( _{Riscado quatro ainda é um regular quatro: D} )

1+?

ligue como N (1+?) R, por exemplo 3 (1+?) 10,. Isso usa o operador "Rolar" e faz exatamente o que é descrito, exceto em 0...n-1. Se pudéssemos fazer isso, a resposta seria 1 byte,

?

Pitão, 6 bytes

<.SSQE

Experimente aqui!

O alcance vem na primeira linha e o comprimento na segunda.

Explicação

<.SSQE # Q = intervalo, E = comprimento

   SQ # gera o intervalo 1 ... Q
 .S # embaralha a lista
<E # pegue os primeiros elementos E

Versão não concorrente de 5 bytes

A última adição ao Pyth adiciona Qs implícitos no final do programa, se necessário. Podemos usar isso aqui revertendo o formato de entrada, para que o comprimento chegue primeiro e depois o intervalo.

<.SSE

Experimente aqui!

Aqui Eestá o intervalo, com o qual transformamos em uma lista baseada em 1 S, embaralha-o .Se pega os primeiros Qelementos <. <espera um número inteiro que é implicitamente adicionado com a Q.

Reng v.2.1, 140 103 98 97 bytes

Isso deve funcionar em versões anteriores também.

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

Você pode tentar aqui! A entrada é maximum length, como 10 3.

Estou tão orgulhoso disso que você nem sabe. Se alguém me vencer com uma resposta Java, isso fará o meu dia. Se eu vencer uma resposta Java, considere meu dia também.

Vou explicar mais tarde, depois que eu me recuperar. Geralmente, porém:

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

Isso gera os números aleatórios. A outra parte verifica se há duplicatas e, se houver, o processo é repetido. Senão, os resultados são impressos, com espaços unindo os resultados.

aqui estão alguns exemplos:

CJam, 8 bytes

{,:)mr<}

Experimente aqui!

Este é um bloco sem nome que espera o intervalo no topo da pilha e o comprimento na parte inferior e deixa uma lista na pilha.

Explicação

, e # 0-based range
:) e # imprima cada elemento da lista para que seja baseado em 1
Sr. e # embaralhe a lista
<e # pega os primeiros n elementos

Lisp comum, 90

^{52 apenas para a expressão}

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

Como outras respostas, se eu não contar o pacote de uso e o lambda , a expressão restante será (coerce(subseq(shuffle(iota R :start 1))0 N)'vector)52 bytes.

Ruby, 27 23 bytes

Função anônima, razoavelmente curta e doce.

-4 bytes de @manatwork

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

, 10 caracteres / 13 bytes

Ѩŝ⩤⁽1í)ą-î

Try it here (Firefox only).

Explicação

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

Bash + coreutils, 16

Eu acho que isso é auto-explicativo:

seq $2|shuf -n$1

Entrada Ne Rcomo parâmetros de linha de comando.

Ou como @rici aponta, para a mesma pontuação:

shuf -n$1 -i1-$2

Ideone.

PowerShell v2 +, 30 bytes

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

Recebe entrada $ne $r, constrói um intervalo 1..$r, canaliza Get-Randomcom um -Count de $n, que selecionará$n elementos exclusivos do intervalo. A saída é deixada no pipeline como uma matriz implícita.

Sério, 5 bytes

,,R╨J

Experimente online!

Explicação:

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

Uma função anônima que leva N primeiro e R segundo.

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)

Isso usa a sample()função do módulo aleatório para retornar uma matriz com o comprimento "a" que consiste em elementos únicos e aleatórios no intervalo 1 => c.

D, 29 bytes (apenas expressão)

Supondo que std.random e std.range tenham sido importados e que n e r sejam definidos como variáveis, o programa pode ser resolvido na expressão única:

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)

Como na resposta do @ Mwr247 , você pode chamá-lo com F(R)(N), Fsendo a expressão da função

Mathcad, 67 "bytes"

cria um vetor de coluna de números inteiros consecutivos no intervalo 1..R, une-o a um vetor de coluna de comprimento R de números aleatórios (uniformes), classifica a matriz Rx2 resultante na coluna de número aleatório e extrai os primeiros n números do coluna aleatória de números inteiros.

Python, 56 (o caminho óbvio)

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}

Sub anônimo bastante direto que gera uma matriz de 1 a R e, em seguida, emenda N elementos aleatórios a partir dela para retornar. Ligue com ->(N, R).

TI-84 BASIC, 21 bytes

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