Случайность это весело. Проблемы без смысла весело.

Напишите функцию, которая при заданном целочисленном вводе nвыведет набор (неупорядоченный, уникальный) точно nслучайных целых чисел между 1и n^2(включительно) таким образом, чтобы сумма всех целых чисел была равна n^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.

Я довольно удивлен, что это ∧≜работает (вам, как правило, придется писать ∧~≜для того, чтобы перебрать выходные данные, а не входные данные), но оказывается, что ≜имеет предположение input = output, поэтому не имеет значения, в какую сторону вас обойти запустить его.

Бонусное задание

Чтобы получить представление о последовательности числа возможностей, я создал другую оболочку 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 байтов (детерминированный)

Метод выборки отклонения @ Джузеппе:

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

Попробуйте онлайн!

Создайте все n-комбинации из списка [1..n²], отфильтруйте их с суммой n², затем выберите случайную.

Java 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 приходит ... Это «всего» в пять раз дольше, чем остальные четыре ответа вместе взятые, так что, думаю, не так уж и плохо… rofl.
Он мчит n=1через n=25(комбинированный) менее чем за 2 секунды , хотя, так что я , вероятно , опубликовать измененную версию до версии скорости этой задачи (которая в настоящее время все еще находится в песочнице) , а также.

Попробуйте онлайн.

Объяснение:

В псевдокоде мы делаем следующее:

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*

Попробуйте это онлайн здесь . Обратите внимание, что онлайн-интерпретатор сталкивается с MemoryError для входных данных больше 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

Изменить: сохранить байт, используя альтернативный подход. Предыдущая версия: 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.

Я попытался сделать несколько лямбда-выражений для s=..., но это не помогло в байтах. Может быть, кто-то еще может что-то сделать с этим: s=(lambda n:{randint(1,n*n)for _ in range(n)})(n)

Спасибо Кевину за то, что он сбрил еще 7 байтов.

APL (Dyalog Unicode) , 20 байтов ^SBCS

Анонимный префикс лямбда.

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

Попробуйте онлайн!

{… } "Дфн"; ⍵это аргумент

 ⍵*2 приводить аргументы

 s← назначить s(для s quare)

 ⍵? найти nслучайные индексы от 1… sбез замены

 c← назначить c(для c andidate)

 +/ суммировать их

 s= по сравнению с s

 : если равно

  c вернуть кандидата

 ⋄ еще

  ∇⍵ повторять аргумент

APL (Dyalog Classic) , 18 байт

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

Попробуйте онлайн!

использования ⎕io←1

⍳ генерирует числа 1 2 ... n

(... )⍣(... )продолжайте применять функцию слева, пока функция справа не вернет true

≢ длина, т.е. n

≢?≢×≢выбирайте случайно nразные целые числа от 1 до 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 без времени ожидания.

Пакет, 182 145 байтов

@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; если сумма массива меньше, чем n^2текущий элемент +1отсутствует в массиве, добавьте 1к элементу. Если сумма массива равна n^2разрывному циклу, выведите массив.

Japt , 20 байт

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

Попробуйте онлайн!

Чрезвычайно сильно использует «неравномерную» случайность, почти всегда выводит первые nнечетные числа, которые суммируются с n^2. Теоретически он может вывести любой другой допустимый набор, хотя я смог подтвердить это только для малого 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 байта благодаря потолку

ПРИМЕЧАНИЕ: вероятность очень очень далеко от равномерной. См. Объяснение того, что я имею в виду, и лучший способ проверить, работает ли он (сделав распределение ближе к равномерному [но все еще очень далеким от него]).

Как?

Основная идея состоит в том, чтобы выбирать только увеличивающиеся числа, чтобы не беспокоиться о дубликатах. Всякий раз, когда мы выбираем число, у нас есть ненулевой шанс «пропустить» его, если это допустимо.

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&&так, что есть вероятность 50-50, что любой заданный y будет пропущен, а не 1, 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)))))

Попробуйте онлайн!

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)

Котлин , 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,{#}]&

Попробуйте онлайн!