随机性很有趣。没有意义的挑战很有趣。

编写一个函数，在给定整数输入的情况下n，将输出介于和（包括）之间的一组（无序，唯一的）精确n随机整数，以使所有整数的总和等于。1n^2n^2

随机性也不会是均匀的，只要每个有效集有发生非零机会。

以字节为单位的最短答案（每种语言）获胜。

例子

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

奖励任务：是否有一个公式可以计算给定的有效排列数量n？

Brachylog（v2），15个字节（随机）或13个字节（所有可能性）

随机

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

在线尝试！

函数提交（在TIO中使用包装程序进行查看，使其成为完整的程序）。

说明

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

所有可能性

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

在线尝试！

函数提交，生成所有可能的输出。

说明

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

我对此感到很惊讶∧≜（您通常必须编写∧~≜才能对输出而不是输入进行暴力破解），但是事实证明它≜具有输入=输出假设，因此无论您采用哪种方式运行。

奖励任务

为了深入了解可能性的顺序，我创建了一个不同的TIO包装器，该包装器在连续的整数上运行程序以给出输出计数的顺序：

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

前往OEIS时发现，这已经是一个已知序列A107379，几乎与问题中描述的一样（显然，如果将其限制为奇数，则将获得相同的序列）。该页面列出了该序列的几个公式（尽管没有一个特别简单；第二个看起来像是该值的直接公式，但我不理解该表示法）。

05AB1E，11 个字节

nÅœʒDÙQ}sùΩ

在线尝试或验证所有测试用例。

说明：

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或3），85个字节

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

在线尝试！

R，68、75、48个字节（随机）和70个字节（确定性）

@Giuseppe的拒绝采样方法：

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

在线尝试！

高尔夫原件：

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

在线尝试！

该*!!1:2业务是为了避免奇怪的方式sample行动时，第一个自变量的长度为1。

果冻，9个字节

²œcS=¥Ƈ²X

在线尝试！

生成列表[1..n²]的所有n个组合，进行过滤以保留总和为n²的组合，然后随机选择一个。

爪哇10，250个 242 222字节

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个字节，感谢@nwellnhof。

当心，Java来了。。它只是其他四个答案加起来的五倍，所以我想还不错。
不过，它确实在不到2秒的时间内n=1完成了n=25（合并）运行，因此我也可能会将修改后的版本发布到此挑战的快速版本中（目前仍在沙盒中）。

在线尝试。

说明：

用伪代码执行以下操作：

1）生成一个大小为数组的数组，n+1其中包含：0，n平方和n-1范围内的随机整数[0, n squared)
2）对该数组进行排序
3）创建第二个大小数组，n其中包含对的正向差异
这前三个步骤将为我们提供一个包含n随机数的数组整数（在[0, n squared)求和的n平方的范围内
。4a）如果并非所有随机值都是唯一的，或者它们中的任何一个为0：请从步骤1开始重试
4b）否则：返回此差值数组作为结果

至于实际的代码：

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个字节

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

在线尝试！

• (1 .. $_²) 是从1到输入数字平方的数字范围
• .pick($_) 随机选择该范围的不同子集
• xx * 无限复制前一个表达式
• first *.sum == $_² 选择那些数字集的第一个，其总和为输入数字的平方

Pyth，13 12字节

Ofq*QQsT.cS*

在这里在线尝试。请注意，对于大于5的输入，在线解释器会遇到MemoryError。

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

编辑：采用其他方法保存了一个字节。先前版本： Of&qQlT{IT./*

Python 3中，136个134 127 121 114字节

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)

在线尝试！

一个评论者纠正了我，这现在在f（5）而不是f（1）处达到了递归最大深度。更接近成为一个真正的竞争性答案。

我已经看过它一次执行f（5），并且我正在尝试使用shuffle来实现它。

我尝试为做一些lambda表达式s=...，但这对字节没有帮助。也许其他人可以这样做： s=(lambda n:{randint(1,n*n)for _ in range(n)})(n)

感谢Kevin削减了另外7个字节。

APL（Dyalog Unicode），20 字节^SBCS

匿名前缀lambda。

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

在线尝试！

{…… } “ dfn”；⍵是争论

 ⍵*2 争论的平方

 s← 分配给s（平方）

 ⍵?n从1…中 找到随机索引，s而无需替换

 c← 分配给c（代表c）

 +/ 总结一下

 s= 相比于 s

 : 如果相等

  c 返回候选人

 ⋄ 其他

  ∇⍵ 递归论证

APL（Dyalog Classic），18字节

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

在线尝试！

用途 ⎕io←1

⍳ 产生数字 1 2 ... n

(... )⍣(... )继续应用左侧的功能，直到右侧的功能返回true

≢ 长度，即 n

≢?≢×≢选择n1到²之间的随机不同整数n

+.-∘≢ 从每个数字中减去长度并求和

0= 如果总和为0，请停止循环，否则重试

MATL，18 13字节

`xGU:GZrtsGU-

在线尝试！

`	# 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

Japt，12个字节

²õ àU ö@²¥Xx

试试吧

                 :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个字节

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

在线尝试！

无限循环，直到符合条件的集合匹配为止。

我希望您有时间，因为它非常实用！如果不超时，它甚至不能达到10。

批处理，182145字节

@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%%

说明：给定降序选择数字，计算最小和最大允许拾取，并选择范围内的随机值。输入示例4：

• 我们从左16开始。我们不能选择11个或更多，因为剩余的3个选择必须加到至少6个。我们还需要选择至少6个，因为如果我们仅选择5个，则剩余的3个选择只能添加到9个，这不是足够用于16。我们从6到10中选择一个随机值，例如6。
• 我们还有10个。我们不能选择8个或更多，因为其余2个必须至少增加3个。碰巧的是，我们不能选择6个或更多，因为我们上次选择6个。我们还需要至少选择5个，因为如果我们仅选择4个，则其余2个选择只能加到5，总共15个。我们选择5到5之间的随机值，例如5（！）。
• 我们还有5个。我们不能选择5个或更多，因为剩余的选择必须加到至少1，并且因为我们上次选择5个。我们还需要至少选择3个，因为如果我们仅选择2个，则剩余的选择只能是1个，总计14个。我们选择3到4个随机值，例如4。
• 我们还有1个。事实证明，该算法选择1到1的范围，我们选择1作为最终数字。

JavaScript中，647个 291 261 260 259 251 239字节

感谢@Veskah原始版本中的-10个字节，“哦，是的，您输出了所有的集合，而挑战要求返回一个随机的集合”

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

在线尝试！

创建一个n^2基于1的索引的数组，对数组进行随机排序，n从数组中切片元素。随机元素的总和不等于n^2随机元素的循环数组；如果数组元素的总和大于n^2且当前元素-1不等于零或当前元素-1不在当前数组中，则减去1; 如果array的总和小于n^2且当前元素+1不在array中，则添加1到element。如果数组和等于n^2中断循环，则输出数组。

Japt，20字节

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

在线尝试！

极其大量地利用“非均匀”随机性，几乎总是输出第一个n奇数，恰好相加为n^2。从理论上讲，它可以输出任何其他有效集，尽管我只能为small确认这一点n。

说明：

²õ                      :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

红宝石，46个字节

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

在线尝试！

C（GCC） ，128个 125字节

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

在线尝试！

-3个字节，感谢ceilingcat

注意：该概率离统一非常非常远。请参阅解释以了解我的意思，以及一种更好的方法来测试其工作原理（通过使分布更接近于均匀[但仍与之相去甚远]）。

怎么样？

基本思想是只选择递增的数字，而不用担心重复。每当我们选择一个数字时，如果允许的话，我们都有非零的机会“跳过”它。

xky

尽管如此，逻辑上还是有机会丢弃任何y满足上述方程式的东西。

代码

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.

我提到的用于更好地测试代码的技巧包括用替换rand()&&，rand()%2&&以便跳过给定y的可能性为50-50，而不是使用RAND_MAX任何给定y的机会为1 。

干净，172字节

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

在线尝试！

Python（2或3），84个字节

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

在线尝试！

达到最大递归深度约l（5）

Kotlin，32字节

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

在线尝试！

Mathematica 40字节

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

Wolfram语言（Mathematica），49个字节

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

在线尝试！

@ J42161217的高尔夫版本。

Wolfram语言（Mathematica），62字节

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

在线尝试！

怎么运行的

$n^2$$n$$n^2 - (n^2-n)/2 = (n^2+n)/2$$0 \cdots n-1$$n-1 \cdots 0$

奖励任务的答案

奖励任务：是否有一个公式可以计算给定的有效排列数量n？

$part(n,k)$$n$$k$

$part(n,1) = 1$$n < k \Rightarrow part(n,k) = 0$

在Mathematica中：

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

在线尝试！