A aleatoriedade é divertida. Desafios sem sentido são divertidos.

Escreva uma função que, dada a entrada inteira n, produza um conjunto (não ordenado, exclusivo) de nnúmeros inteiros exatamente aleatórios entre 1e n^2(inclusive), de modo que a soma de todos os números inteiros seja igual a n^2.

A aleatoriedade não precisa ser uniforme, desde que cada conjunto válido tenha uma chance diferente de zero.

A resposta mais curta em bytes (por cada idioma) vence.

Exemplos

Input (n) = 1, Target (n^2) = 1
Sample of possible outputs:
1

Input = 2, Target = 4
Sample of possible outputs:
3, 1
1, 3

Input = 3, Target = 9
Sample of possible outputs:
6, 1, 2
3, 5, 1
4, 3, 2

Input = 4, Target = 16
Sample of possible outputs:
1, 3, 5, 7
2, 4, 1, 9
8, 3, 1, 4

Input = 5, Target = 25
Sample of possible outputs:
11, 4, 7, 1, 2
2, 3, 1, 11, 8
6, 1, 3, 7, 8

Input = 8, Target = 64
Sample of possible outputs:
10, 3, 9, 7, 6, 19, 8, 2
7, 16, 2, 3, 9, 4, 13, 10
7, 9, 21, 2, 5, 13, 6, 1

Tarefa bônus: Existe uma fórmula para calcular o número de permutações válidas para um determinado n?

Brachylog (v2), 15 bytes (aleatório) ou 13 bytes (todas as possibilidades)

Aleatória

~lℕ₁ᵐA+√?∧A≜₁ᵐ≠

Experimente online!

Envio de função (visto no TIO com um wrapper transformando-o em um programa completo).

Explicação

~lℕ₁ᵐA+√?∧A≜₁ᵐ≠
~l               Specify a property of a list: its length is equal to the input,
    ᵐ              and it is composed entirely of
  ℕ₁                 integers ≥ 1,
       √           for which the square root of the
      +              sum of the list
        ?              is the input.
     A   ∧A      Restricting yourself to lists with that property,
           ≜₁      pick random possible values
             ᵐ       for each element in turn,
              ≠    until you find one whose elements are all distinct.

Todas as possibilidades

~lℕ₁ᵐ<₁.+√?∧≜

Experimente online!

Envio de função, que gera todas as saídas possíveis.

Explicação

~lℕ₁ᵐ<₁.+√?∧≜
~l               Specify a property of a list: its length is equal to the input,
    ᵐ              it is composed entirely of
  ℕ₁                 integers ≥ 1,
     <₁            it is strictly increasing,
         √         and the square root of the
        +            sum of the list
          ?            is the input.
       .   ∧≜    Generate all specific lists with that property.

Estou bastante surpreso que ∧≜funcione (você normalmente teria que escrever ∧~≜para forçar a saída em vez da entrada), mas acontece que ≜tem uma suposição de entrada = saída, portanto, não importa o caminho que você executá-lo.

Tarefa bônus

Para ter uma ideia da sequência do número de possibilidades, criei um wrapper TIO diferente que executa o programa em números inteiros sucessivos para fornecer a sequência das contagens de saída:

1,1,3,9,30,110,436,1801,7657,33401

Uma viagem ao OEIS descobre que essa já é uma sequência conhecida, A107379 , descrita praticamente como na pergunta (aparentemente, você obtém a mesma sequência se a restringir a números ímpares). A página lista várias fórmulas para a sequência (embora nenhuma seja particularmente simples; a segunda parece uma fórmula direta para o valor, mas eu não entendo a notação).

05AB1E , 11 bytes

nÅœʒDÙQ}sùΩ

Experimente online ou verifique todos os casos de teste .

Explicação:

n             # Take the square of the (implicit) input
              #  i.e. 3 → 9
 Ŝ           # Get all integer-lists using integers in the range [1, val) that sum to val
              #  i.e. 9 → [[1,1,1,1,1,1,1,1,1],...,[1,3,5],...,[9]]
   ʒ   }      # Filter the list to only keep lists with unique values:
    D         # Duplicate the current value
     Ù        # Uniquify it
              #  i.e. [2,2,5] → [2,5]
      Q       # Check if it's still the same
              #  i.e. [2,2,5] and [2,5] → 0 (falsey)
        s     # Swap to take the (implicit) input again
         ù    # Only leave lists of that size
              #  i.e. [[1,2,6],[1,3,5],[1,8],[2,3,4],[2,7],[3,6],[4,5],[9]] and 3
              #   → [[1,2,6],[1,3,5],[2,3,4]]
          Ω   # Pick a random list from the list of lists (and output implicitly)

Python (2 ou 3), 85 bytes

def f(n):r=sample(range(1,n*n+1),n);return(n*n==sum(r))*r or f(n)
from random import*

Experimente online!

R , 68, 75 48 bytes (aleatório) e 70 bytes (determinístico)

@ Método de amostragem por rejeição de Giuseppe:

function(n){while(sum(F)!=n^2)F=sample(n^2,n);F}

Experimente online!

Original de golfe:

function(n,m=combn(1:n^2,n))m[,sample(which(colSums(m)==n^2)*!!1:2,1)]

Experimente online!

O *!!1:2negócio é evitar a maneira estranha de sampleagir quando o primeiro argumento tiver comprimento 1.

Geléia , 9 bytes

²œcS=¥Ƈ²X

Experimente online!

Gere todas as n combinações da lista [1..n²], filtre para manter as que possuem a soma n² e escolha uma aleatória.

Java 10, 250 242 222 bytes

import java.util.*;n->{for(;;){int i=n+1,r[]=new int[i],d[]=new int[n];for(r[n<2?0:1]=n*n;i-->2;r[i]=(int)(Math.random()*n*n));var S=new HashSet();for(Arrays.sort(r),i=n;i-->0;)S.add(d[i]=r[i+1]-r[i]);if(!S.contains(0)&S.size()==n)return S;}}

-20 bytes graças a @nwellnhof .

Cuidado, o Java está chegando .. É 'apenas' cinco vezes, enquanto as outras quatro respostas combinadas, então não é tão ruim, eu acho .. rofl.
Ele n=1atravessan=25 (combinado) em menos de 2 segundos, então eu provavelmente vou postar uma versão modificada para a versão de velocidade deste desafio (que é actualmente ainda no Sandbox) também.

Experimente online.

Explicação:

No pseudo-código, fazemos o seguinte:

1) Gerar uma matriz de tamanho n+1contendo: 0, nquadrado, e n-1quantidade de números inteiros aleatórios no intervalo [0, n squared)
2) Separar esta matriz
3) Criar uma segunda gama de tamanho ncontendo as diferenças para a frente de pares
Estes três primeiros passos nos dará uma matriz contendo naleatório números inteiros (no intervalo [0, n squared)que soma ao nquadrado.
4a) Se nem todos os valores aleatórios forem únicos, ou se algum deles for 0: tente novamente a partir da etapa 1
4b) Outro: retorne essa matriz de diferenças como resultado

Quanto ao código real:

import java.util.*;      // Required import for HashSet and Arrays
n->{                     // Method with int parameter and Set return-type
  for(;;){               //  Loop indefinitely
    int i=n+1,           //   Set `i` to `n+1`
        r[]=new int[i];  //   Create an array of size `n+1`
    var S=new HashSet(); //   Result-set, starting empty
    for(r[n<2?           //   If `n` is 1:
           0             //    Set the first item in the first array to:
          :              //   Else:
           1]            //    Set the second item in the first array to:
             =n*n;       //   `n` squared
        i-->2;)          //   Loop `i` in the range [`n`, 2]:
      r[i]=              //    Set the `i`'th value in the first array to:
           (int)(Math.random()*n*n); 
                         //     A random value in the range [0, `n` squared)
    for(Arrays.sort(r),  //   Sort the first array
        i=n;i-->0;)      //   Loop `i` in the range (`n`, 0]:
      S.add(             //    Add to the Set:
        r[i+1]-r[i]);    //     The `i+1`'th and `i`'th difference of the first array
    if(!S.contains(0)    //   If the Set does not contain a 0
       &S.size()==n)     //   and its size is equal to `n`:
      return S;}}        //    Return this Set as the result
                         //   (Implicit else: continue the infinite loop)

Perl 6 , 41 bytes

{first *.sum==$_²,(1..$_²).pick($_)xx*}

Experimente online!

• (1 .. $_²) é o intervalo de números de 1 ao quadrado do número de entrada
• .pick($_) escolhe aleatoriamente um subconjunto distinto desse intervalo
• xx * replica a expressão anterior infinitamente
• first *.sum == $_² seleciona o primeiro desses conjuntos de números que soma ao quadrado do número de entrada

Pitão, 13 12 bytes

Ofq*QQsT.cS*

Experimente online aqui . Observe que o intérprete online executa um MemoryError para entradas maiores que 5.

Ofq*QQsT.cS*QQQ   Implicit: Q=eval(input())
                 Trailing QQQ inferred
          S*QQQ   [1-Q*Q]
        .c    Q   All combinations of the above of length Q, without repeats
 f                Keep elements of the above, as T, where the following is truthy:
      sT            Is the sum of T...
  q                 ... equal to...
   *QQ              ... Q*Q?
O                 Choose a random element of those remaining sets, implicit print

Editar: salvou um byte usando uma abordagem alternativa. Versão anterior: Of&qQlT{IT./*

Python 3 , 136 134 127 121 114 bytes

from random import*
def f(n):
	s={randint(1,n*n)for _ in range(n)}
	return len(s)==n and sum(s)==n*n and s or f(n)

Experimente online!

Um comentarista me corrigiu, e isso agora atinge a profundidade máxima da recursão em f (5) em vez de f (1). Muito mais perto de ser uma resposta real e competitiva.

Eu já vi fazer (5) uma vez e estou tentando implementar isso com o shuffle.

Tentei criar algumas expressões lambda para s=..., mas isso não ajudou em bytes. Talvez alguém possa fazer algo com isso: s=(lambda n:{randint(1,n*n)for _ in range(n)})(n)

Obrigado a Kevin por remover outros 7 bytes.

APL (Dyalog Unicode) , ^{SBCS de} 20 bytes

Prefixo anônimo lambda.

{s=+/c←⍵?s←⍵*2:c⋄∇⍵}

Experimente online!

{...}  "dfn"; ⍵é argumento

 ⍵*2 esquadrar o argumento

 s← atribuir a s(para s quare)

 ⍵? encontre níndices aleatórios de 1…s sem substituição

 c← atribuir a c(para c andidate)

 +/ somar eles

 s= comparado a s

 : se igual

  c devolver o candidato

 ⋄ outro

  ∇⍵ recuar sobre o argumento

APL (Dyalog Classic) , 18 bytes

(≢?≢×≢)⍣(0=+.-∘≢)⍳

Experimente online!

usa ⎕io←1

⍳ gera os números 1 2 ... n

(... )⍣(... )continue aplicando a função à esquerda até que a função à direita retorne verdadeira

≢ comprimento, ie n

≢?≢×≢escolha nnúmeros inteiros aleatoriamente distintos entre 1 e n²

+.-∘≢ subtrair o comprimento de cada número e soma

0= se a soma for 0, pare de repetir, caso contrário, tente novamente

MATL , 18 13 bytes

`xGU:GZrtsGU-

Experimente online!

`	# do..while:
x	# delete from stack. This implicitly reads input the first time
	# and removes it. It also deletes the previous invalid answer.
GU:	# paste input and push [1...n^2]
GZr	# select a single combination of n elements from [1..n^2]
tsGU-	# is the sum equal to N^2? if yes, terminate and print results, else goto top

Japonês, 12 bytes

²õ àU ö@²¥Xx

Tente

                 :Implicit input of integer U
²                :U squared
 õ               :Range [1,U²]
   àU            :Combinations of length U
      ö@         :Return a random element that returns true when passed through the following function as X
        ²        :  U squared
         ¥       :  Equals
          Xx     :  X reduced by addition

Java (JDK) , 127 bytes

n->{for(int s;;){var r=new java.util.TreeSet();for(s=n*n;s>0;)r.add(s-(s-=Math.random()*n*n+1));if(r.size()==n&s==0)return r;}}

Experimente online!

Loop infinito até que um conjunto com os critérios corresponda.

Espero que você tenha tempo, porque é muito sloooooow! Não pode nem chegar a 10 sem tempo limite.

Lote, 182 145 bytes

@set/an=%1,r=n*n,l=r+1
@for /l %%i in (%1,-1,1)do @set/at=n*(n-=1)/2,m=(r+t+n)/-~n,r-=l=m+%random%%%((l-=x=r+1-t)*(l^>^>31)+x-m)&call echo %%l%%

Explicação: Calcula a seleção mínima e máxima permitida, considerando que os números devem ser selecionados em ordem decrescente e escolhe um valor aleatório dentro do intervalo. Exemplo para uma entrada de 4:

• Começamos com 16 à esquerda. Não podemos escolher 11 ou mais porque as 3 escolhas restantes devem adicionar pelo menos 6. Também precisamos escolher pelo menos 6, porque se escolhermos apenas 5, as 3 escolhas restantes poderão adicionar apenas 9, o que não é suficiente para 16. Escolhemos um valor aleatório de 6 a 10, digamos 6.
• Temos 10 restantes. Não podemos escolher 8 ou mais, porque as 2 escolhas restantes devem adicionar pelo menos 3. Como acontece, não podemos escolher 6 ou mais porque escolhemos 6 da última vez. Também precisamos escolher pelo menos 5, porque se escolhermos apenas 4, as 2 escolhas restantes só podem adicionar a 5, para um total geral de 15. Nós escolhemos um valor aleatório de 5 a 5, digamos 5 (!).
• Temos 5 restantes. Não podemos escolher 5 ou mais porque a seleção restante deve adicionar pelo menos 1 e também porque escolhemos 5 da última vez. Também precisamos escolher pelo menos 3, porque se escolhermos apenas 2, a escolha restante poderá ser apenas 1, para um total geral de 14. Escolhemos um valor aleatório de 3 a 4, digamos 4.
• Temos 1 restantes. Como se vê, o algoritmo escolhe um intervalo de 1 a 1, e escolhemos 1 como o número final.

JavaScript, 647 291 261 260 259 251 239 bytes

Obrigado a @Veskah por -10 bytes na versão original e "Ah, sim, você está produzindo todos os conjuntos, enquanto o desafio pede que um aleatório seja retornado"

(n,g=m=n**2,r=[...Array(g||1)].map(_=>m--).sort(_=>.5-Math.random()).slice(-n),c=_=>eval(r.join`+`),i=_=>r.includes(_))=>[...{*0(){while(g>1&&c()!=g){for(z of r){y=c();r[m++%n]=y>g&&!(!(z-1)||i(z-1))?z-1:y<g&&!i(z+1)?z+1:z}}yield*r}}[0]()]

Experimente online!

Crie uma matriz de n^2índices baseados em 1, classifique a matriz aleatoriamente, corte nelementos da matriz. Enquanto a soma dos elementos aleatórios não é igual à n^2matriz de loop de elementos aleatórios; se a soma dos elementos da matriz for maior que n^2e o elemento atual -1não for igual a zero ou o elemento atual -1não estiver na matriz atual, subtraia 1; se a soma da matriz for menor que n^2e o elemento atual +1não estiver na matriz, adicione 1ao elemento Se a soma da matriz for igual ao n^2loop de interrupção, imprima a matriz.

Japonês , 20 bytes

²õ ö¬oU íUõ+)Õæ@²¥Xx

Experimente online!

Extremamente tira proveito da aleatoriedade "Não uniforme", quase sempre gera os primeiros nnúmeros ímpares, que somam n^2. Em teoria, ele pode gerar qualquer outro conjunto válido, embora eu tenha sido capaz de confirmar isso apenas para pequenos n.

Explicação:

²õ                      :Generate the range [1...n^2]
   ö¬                   :Order it randomly
     oU                 :Get the last n items
        í   )Õ          :Put it in an array with...
         Uõ+            : The first n odd numbers
              æ_        :Get the first one where...
                  Xx    : The sum
                ²¥      : equals n^2

Ruby , 46 bytes

->n{z=0until(z=[*1..n*n].sample n).sum==n*n;z}

Experimente online!

C (gcc) , 128 125 bytes

p(_){printf("%d ",_);}f(n,x,y,i){x=n*n;y=1;for(i=0;++i<n;p(y),x-=y++)while(rand()&&(n-i)*(n-i+1)/2+(n-i)*(y+1)+y<x)y++;p(x);}

Experimente online!

-3 bytes graças a ceilingcat

NOTA: A probabilidade está muito longe de ser uniforme. Veja a explicação do que quero dizer e um meio melhor de testar se ele funciona (tornando a distribuição mais próxima do uniforme [mas ainda muito longe disso]).

Quão?

A idéia básica é escolher apenas números crescentes para não se preocupar com duplicatas. Sempre que escolhemos um número, temos uma chance diferente de zero de ignorá-lo, se permitido.

Para decidir se podemos pular um número, precisamos saber xo total restante a ser atingido, ko número de elementos que ainda precisamos usar e yo valor atual do candidato. O menor número possível que ainda poderíamos escolher consistiria em

No entanto, a lógica é ter a chance de descartar qualquer yque satisfaça a equação acima.

O código

p(_){printf("%d ",_);}  // Define print(int)
f(n,x,y,i){             // Define f(n,...) as the function we want
    x=n*n;              // Set x to n^2
    y=1;                // Set y to 1
    for(i=0;++i<n;){    // n-1 times do...
        while(rand()&&  // While rand() is non-zero [very very likely] AND
            (n-i)*      // (n-i) is the 'k' in the formula
            (n-i+1)/2+  // This first half takes care of the increment
            (n-i)*(y+1) // This second half takes care of the y+1 starting point
            +y<x)       // The +y takes care of the current value of y
        y++;            // If rand() returned non-zero and we can skip y, do so
    p(y);               // Print y
    x-=y++;             // Subtract y from the total and increment it
    }p(x);}             // Print what's left over.

O truque que mencionei para testar melhor o código envolve a substituição rand()&&por, rand()%2&&para que haja uma chance de 50 a 50 de que qualquer y seja ignorado, em vez de 1 em RAND_MAXchance de que qualquer y seja usado.

Limpo , 172 bytes

import StdEnv,Math.Random,Data.List
? ::!Int->Int
?_=code{
ccall time "I:I"
}
$n=find(\s=length s==n&&sum s==n^2)(subsequences(nub(map(inc o\e=e rem n^2)(genRandInt(?0)))))

Experimente online!

Python (2 ou 3), 84 bytes

from random import*;l=lambda n,s=[]:(sum(s)==n*n)*s or l(n,sample(range(1,n*n+1),n))

Experimente online!

Atinge a profundidade máxima de recursão em torno de l (5)

Kotlin , 32 bytes

{(1..it*it).shuffled().take(it)}

Experimente online!

Mathematica 40 bytes

RandomChoice[IntegerPartitions[n^2, {n}]]

Wolfram Language (Mathematica) , 49 bytes

(While[Tr[s=RandomSample[Range[#^2],#]]!=#^2];s)&

Experimente online!

Versão Golfed por @ J42161217.

Wolfram Language (Mathematica) , 62 bytes

Range[#-1,0,-1]+RandomChoice@IntegerPartitions[#*(#+1)/2,{#}]&

Experimente online!

Como funciona

Principalmente com base em esta questão Math.SE . Para obter partições de$n^2$ para dentro $n$ partes distintas, obtenha partições de $n^2 - (n^2-n)/2 = (n^2+n)/2$ em vez disso e adicione $0 \cdots n-1$para cada elemento. Como o Mathematica fornece as partições em ordem decrescente,$n-1 \cdots 0$ é adicionado em seu lugar.

A resposta para a tarefa de bônus

Tarefa bônus: Existe uma fórmula para calcular o número de permutações válidas para um determinado n?

Sim. Definir$part(n,k)$ como o número de partições de $n$ exatamente $k$peças. Em seguida, ele satisfaz a seguinte relação de recorrência:

Você pode entendê-lo como "Se uma partição contiver 1, remova-a; caso contrário, subtraia 1 de cada termo". Mais explicações aqui na outra pergunta Math.SE . Combinado com as condições iniciais$part(n,1) = 1$ e $n < k \Rightarrow part(n,k) = 0$, você pode computá-lo com um programa. A resposta desejada será:

ou seja, no Mathematica:

Length@IntegerPartitions[#*(#+1)/2,{#}]&

Experimente online!