임의성은 재미있다. 무의미한 도전은 재미 있습니다.

정수 입력이 주어지면 모든 정수의 합이 같도록 및 (포함) 사이 의 정확히 임의의 정수 세트 (정렬되지 않은 고유)를 n출력 하는 함수를 작성하십시오 .n1n^2n^2

각 유효한 세트에 0이 아닌 확률이있을 경우 무작위성이 균일 하지 않아도됩니다.

(각 언어마다) 바이트 단위의 최단 답변이 이깁니다.

예

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)

파이썬 (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첫 번째 인수의 길이가 일이있을 때 행동.

젤리 , 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;}}

@nwellnhof 덕분에 -20 바이트 .

조심해, 자바가오고있다. 다른 4 개의 답이 합쳐진 한 5 배에 불과하다. 그래서 나쁘지 않다.. rofl.
그것은 실행됩니까 n=1을 통해 n=25아마뿐만 아니라 (샌드 박스에 여전히 현재의)이 도전의 속도 버전으로 수정 된 버전을 게시합니다 그래서,하지만 2 초 미만 (결합).

온라인으로 사용해보십시오.

설명:

의사 코드에서 다음을 수행합니다.

1) 범위 내에서 , 제곱 및 임의의 정수의 양을 n+1포함하는 크기의 배열을 생성합니다 . 2)이 배열을 정렬합니다. 3) 쌍의 앞으로 차이를 포함 하는 두 번째 크기의 배열을 만듭니다. 이 첫 세 단계는 랜덤을 포함하는 배열을 제공합니다 정수 ( 합계의 제곱 범위 ) 4a) 모든 임의의 값이 고유하지 않거나 그 중 하나가 0 인 경우 : 1 단계 4b 부터 다시 시도하십시오 .) 그렇지 않으면 :이 차이 배열을 결과로 리턴하십시오.0nn-1[0, n squared)

n
n[0, n squared)n

실제 코드는 다음과 같습니다.

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)

펄 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./*

파이썬 3 , 136134127121114 바이트

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 (1) 대신 f (5)에서 재귀 최대 깊이에 도달합니다. 실제 경쟁 답변에 훨씬 가깝습니다.

f (5) 한 번 수행하는 것을 보았 으며 셔플을 사용하여이를 구현하려고 노력하고 있습니다.

에 대한 람다 식을 만들려고했지만 s=...바이트에는 도움이되지 않았습니다. 다른 사람이 이것으로 무언가를 할 수 있습니다. s=(lambda n:{randint(1,n*n)for _ in range(n)})(n)

다른 7 바이트를 면도 해 준 Kevin에게 감사합니다.

APL (Dyalog Unicode) , 20 바이트 ^SBCS

익명 접두사 람다.

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

온라인으로 사용해보십시오!

{… } "dfn"; ⍵논쟁이다

 ⍵*2 논쟁을 제곱하다

 s← 할당 s( s quare)

 ⍵?교체없이 n1…에서 랜덤 인덱스를  찾습니다s

 c← 할당 c( c andidate)

 +/ 그들을 합치다

 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

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

자바 (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 왼쪽으로 시작합니다. 나머지 3 개의 픽은 6 이상을 추가해야하기 때문에 11 개 이상을 선택할 수 없습니다. 또한 5 개만 픽하면 나머지 3 개의 픽은 9 개만 추가 할 수 있기 때문에 6 개 이상을 선택해야합니다. 우리는 6에서 10 사이의 임의의 값을 선택합니다.
• 우리는 10 남았습니다. 나머지 2 개의 픽은 최소 3을 더해야하기 때문에 8 개 이상을 픽킹 할 수 없습니다. 이런 경우, 마지막으로 6 개를 선택했기 때문에 6 개 이상을 픽킹 할 수 없습니다. 4 개만 고르면 나머지 2 개는 5에 더해 총 15 개만 추가 할 수 있기 때문에 5 개 이상을 선택해야합니다. 5에서 5 사이의 임의의 값을 선택합니다 (예 : 5 (!)).
• 5 남았습니다. 나머지 픽은 1 이상을 추가해야하고 마지막으로 5 개를 선택했기 때문에 5 이상을 선택할 수 없습니다. 또한 2를 선택하면 나머지는 1, 총합이 14 일 수 있으므로 최소 3을 선택해야합니다. 3과 4 사이의 임의의 값을 선택합니다 (예 : 4).
• 1 개 남았습니다. 결과적으로 알고리즘은 1에서 1 사이의 범위를 선택하고 1을 최종 숫자로 선택합니다.

자바 스크립트, 647 291 261 260 259 251 239 바이트

원래 버전에서 -10 바이트의 @Veskah 덕분에 "아, 네, 모든 세트를 출력하는 반면, 챌린지는 임의의 세트를 반환하도록 요청합니다"

(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^21 기반의 인덱스, 무작위 정렬 어레이 슬라이스 n배열 요소. 임의의 요소의 합은 임의의 요소의 n^2루프 배열 과 같지 않지만 ; 배열 요소의 합이보다 크고 n^2현재 요소 -1가 0이 아니거나 현재 요소 -1가 현재 배열에없는 경우 빼기 1; 배열의 합이 작고 n^2현재 요소 +1가 배열에 없으면 요소 에 추가하십시오 1. 배열 합계가 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);}

온라인으로 사용해보십시오!

ceilingcat 덕분에 -3 바이트

참고 : 확률은 균일하지 않습니다. 내가 의미하는 바에 대한 설명과 그것이 효과가 있는지 테스트하는 더 좋은 방법을 참조하십시오 (분포를 균일하게 가깝게 만들지 만 여전히 그것과는 거리가 멀어집니다).

방법?

기본 아이디어는 중복에 대해 걱정하지 않도록 숫자를 늘리는 것만 선택하는 것입니다. 우리가 숫자를 선택할 때마다 우리는 허용되는 경우 0이 아닌 '건너 뛰기'가능성이 있습니다.

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는 오히려 1보다 생략된다 50-50 기회가 너무 RAND_MAX주어진 y를 사용하는 것이 기회.

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

온라인으로 사용해보십시오!

파이썬 (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)에서 최대 재귀 깊이에 도달

코 틀린 , 32 바이트

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

온라인으로 사용해보십시오!

Mathematica 40 바이트

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

Wolfram Language (Mathematica) , 49 바이트

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

온라인으로 사용해보십시오!

@ J42161217의 골프 버전.

Wolfram Language (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,{#}]&

온라인으로 사용해보십시오!