La casualità è divertente. Le sfide senza senso sono divertenti.

Scrivi una funzione a cui, dato l'input intero n, verrà emesso un insieme (non ordinato, unico) di ninteri esattamente casuali tra 1e n^2(compreso) in modo che la somma di tutti gli interi sia uguale n^2.

La casualità non deve essere uniforme, a condizione che ogni set valido abbia una probabilità diversa da zero.

Vince la risposta più breve in byte (per ogni lingua).

Esempi

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

Attività bonus: esiste una formula per calcolare il numero di permutazioni valide per un dato n?

Brachylog (v2), 15 byte (casuali) o 13 byte (tutte le possibilità)

Casuale

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

Provalo online!

Invio di funzioni (visto in TIO con un wrapper che lo rende un programma completo).

Spiegazione

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

Tutte le possibilità

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

Provalo online!

Invio di funzioni, che genera tutti i possibili output.

Spiegazione

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

Sono abbastanza sorpreso che ∧≜funzioni (normalmente dovresti scrivere ∧~≜per forzare l'output piuttosto che l'input), ma si scopre che ≜ha un presupposto input = output quindi non importa in che modo intorno a te eseguirlo.

Compito bonus

Al fine di ottenere alcune informazioni sulla sequenza del numero di possibilità, ho creato un wrapper TIO diverso che esegue il programma su numeri interi successivi per fornire la sequenza dei conteggi di output:

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

Un viaggio in OEIS scopre che questa è già una sequenza nota, A107379 , descritta praticamente come nella domanda (apparentemente ottieni la stessa sequenza se la limiti a numeri dispari). La pagina elenca diverse formule per la sequenza (anche se nessuna è particolarmente semplice; la seconda sembra una formula diretta per il valore ma non capisco la notazione).

05AB1E , 11 byte

nÅœʒDÙQ}sùΩ

Provalo online o verifica tutti i casi di test .

Spiegazione:

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 o 3), 85 byte

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

Provalo online!

R , 68, 75 48 byte (casuale) e 70 byte (deterministico)

@ Metodo di campionamento del rifiuto di Giuseppe:

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

Provalo online!

Originale golfato:

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

Provalo online!

Il *!!1:2business è quello di evitare il modo strano di sampleagire quando il primo argomento ha lunghezza 1.

Gelatina , 9 byte

²œcS=¥Ƈ²X

Provalo online!

Genera tutte le n-combinazioni dell'elenco [1..n²], filtra per mantenere quelle con somma n², quindi scegline una casuale.

Java 10, 250 242 222 byte

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 byte grazie a @nwellnhof .

Fai attenzione, Java arriva ... Sono "solo" cinque volte più lunghe delle altre quattro risposte combinate, quindi non male, immagino ... rofl.
Esso viene eseguito n=1attraverso n=25(combinato) in meno di 2 secondi, però, così io probabilmente posterò una versione modificata alla versione velocità di questa sfida (che è attualmente ancora in Sandbox) pure.

Provalo online.

Spiegazione:

Nello pseudo-codice facciamo quanto segue:

1) Generare un array di dimensione n+1contenente: 0, nquadrato, e n-1quantità di numeri interi casuali compresi nell'intervallo tra [0, n squared)
2) In ordine questa matrice
3) Creare un secondo array di dimensione ncontenente le differenze anteriori delle coppie
Questi primi tre passi ci daranno un array contenente ncasuale numeri interi (nell'intervallo [0, n squared)che si somma al nquadrato.
4a) Se non tutti i valori casuali sono univoci o uno qualsiasi di essi è 0: riprovare dal passaggio 1
4b) Altrimenti: restituire questo array di differenze come risultato

Per quanto riguarda il codice attuale:

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 byte

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

Provalo online!

• (1 .. $_²) è l'intervallo di numeri compreso tra 1 e il quadrato del numero di input
• .pick($_) sceglie casualmente un sottoinsieme distinto di quell'intervallo
• xx * replica l'espressione precedente all'infinito
• first *.sum == $_² seleziona il primo di quei set di numeri che si sommano al quadrato del numero di input

Pyth, 13 12 byte

Ofq*QQsT.cS*

Provalo online qui . Si noti che l'interprete online si imbatte in un MemoryError per input maggiori di 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

Modifica: salvato un byte adottando un approccio alternativo. Versione precedente: Of&qQlT{IT./*

Python 3 , 136 134 127 121 114 byte

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)

Provalo online!

Un commentatore mi ha corretto, e questo ora colpisce la profondità massima di ricorsione in f (5) invece di f (1). Molto più vicino ad essere una vera risposta competitiva.

L'ho visto fare f (5) una volta , e sto lavorando per cercare di perseguire questo obiettivo con shuffle.

Ho provato a creare alcune espressioni lambda per s=..., ma questo non ha aiutato i byte. Forse qualcun altro può fare qualcosa con questo: s=(lambda n:{randint(1,n*n)for _ in range(n)})(n)

Grazie a Kevin per essersi rasato altri 7 byte.

APL (Dyalog Unicode) , 20 byte ^SBCS

Prefisso anonimo lambda.

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

Provalo online!

{... } "dfn"; ⍵è argomento

 ⍵*2 piazza l'argomento

 s← assegnare a s(per s quare)

 ⍵? trova nindici casuali da 1 ... ssenza sostituzione

 c← assegnare a c(per c andidate)

 +/ sommarli

 s= confrontare con s

 : se uguale

  c restituire il candidato

 ⋄ altro

  ∇⍵ fare affidamento sull'argomento

APL (Dyalog Classic) , 18 byte

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

Provalo online!

usi ⎕io←1

⍳ genera i numeri 1 2 ... n

(... )⍣(... )continua ad applicare la funzione a sinistra finché la funzione a destra non ritorna vera

≢ lunghezza, ad es n

≢?≢×≢scegli nnumeri interi casualmente distinti tra 1 e n²

+.-∘≢ sottrarre la lunghezza da ciascun numero e somma

0= se la somma è 0, interrompere il ciclo, altrimenti riprovare

MATL , 18 13 byte

`xGU:GZrtsGU-

Provalo 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

Japt, 12 byte

²õ àU ö@²¥Xx

Provalo

                 :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 byte

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

Provalo online!

Ciclo infinito fino a quando un set con i criteri corrisponde.

Spero che tu abbia il tempo, perché è molto sloooooow! Non può nemmeno andare a 10 senza timeout.

Lotto, 182 145 byte

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

Spiegazione: Calcola la selezione minima e massima consentita, dato che i numeri devono essere scelti in ordine decrescente e sceglie un valore casuale all'interno dell'intervallo. Esempio per un input di 4:

• Iniziamo con 16 rimasti. Non possiamo scegliere 11 o più perché le restanti 3 scelte devono aggiungere almeno a 6. Dobbiamo anche scegliere almeno 6, perché se selezioniamo solo 5, le restanti 3 scelte possono aggiungere solo a 9, che non è abbastanza per 16. Scegliamo un valore casuale da 6 a 10, diciamo 6.
• Ne rimangono 10. Non possiamo scegliere 8 o più perché le restanti 2 scelte devono aggiungere almeno a 3. In effetti, non possiamo scegliere 6 o più perché ne abbiamo scelte 6 l'ultima volta. Dobbiamo anche scegliere almeno 5, perché se selezioniamo solo 4, le restanti 2 scelte possono solo aggiungere a 5, per un totale complessivo di 15. Selezioniamo un valore casuale da 5 a 5, diciamo 5 (!).
• Ne rimangono 5. Non possiamo scegliere 5 o più perché la scelta rimanente deve aggiungere almeno 1, e anche perché abbiamo scelto 5 l'ultima volta. Dobbiamo anche scegliere almeno 3, perché se selezioniamo solo 2, la scelta rimanente può essere solo 1, per un totale complessivo di 14. Selezioniamo un valore casuale da 3 a 4, ad esempio 4.
• Ne rimane 1. A quanto pare, l'algoritmo sceglie un intervallo da 1 a 1 e scegliamo 1 come numero finale.

JavaScript, 647 291 261 260 259 251 239 byte

Grazie a @Veskah per -10 byte nella versione originale e "Oh sì, stai emettendo tutti i set mentre la sfida richiede un ritorno casuale"

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

Provalo online!

Crea una matrice di n^2indici basati su 1, ordina la matrice in modo casuale, suddivide gli nelementi dalla matrice. Mentre la somma degli elementi casuali non equivale alla n^2matrice di loop di elementi casuali; se la somma degli elementi dell'array è maggiore di n^2e l'elemento corrente -1non è uguale a zero o l'elemento corrente -1non è nell'array corrente, sottrarre 1; se la somma dell'array è minore di n^2e l'elemento corrente +1non è nell'array, aggiungi 1all'elemento. Se la somma dell'array è uguale al n^2ciclo di interruzione, output array.

Japt , 20 byte

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

Provalo online!

Sfrutta enormemente la casualità "Non uniforme", quasi sempre produce i primi nnumeri dispari, che si sommano n^2. In teoria può produrre qualsiasi altro set valido, anche se sono stato in grado di confermarlo solo per piccoli n.

Spiegazione:

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

Rubino , 46 byte

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

Provalo online!

C (gcc) , 128 125 byte

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

Provalo online!

-3 byte grazie a ceilingcat

NOTA: la probabilità è molto lontana dall'uniforme. Vedi la spiegazione di cosa intendo e un mezzo migliore per testare che funzioni (rendendo la distribuzione più vicina all'uniforme [ma ancora lontana da essa]).

Come?

L'idea di base è quella di scegliere solo numeri crescenti per non preoccuparsi dei duplicati. Ogni volta che scegliamo un numero, abbiamo una possibilità diversa da zero di 'saltarlo' se consentito.

xky

Tuttavia, la logica è quella di avere la possibilità di scartare qualsiasi ycosa soddisfi l'equazione di cui sopra.

Il codice

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.

Il trucco ho menzionato prova migliore il codice consiste nella sostituzione rand()&&con rand()%2&&modo che ci sia un 50-50 probabilità che un dato y viene saltata, piuttosto che un 1 nella RAND_MAXprobabilità che un dato y viene utilizzato.

Pulito , 172 byte

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

Provalo online!

Python (2 o 3), 84 byte

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

Provalo online!

Colpisce la profondità massima di ricorsione a circa l (5)

Kotlin , 32 byte

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

Provalo online!

Mathematica 40 byte

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

Wolfram Language (Mathematica) , 49 byte

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

Provalo online!

Versione golfata di @ J42161217.

Wolfram Language (Mathematica) , 62 byte

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

Provalo online!

Come funziona

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

La risposta all'attività bonus

Attività bonus: esiste una formula per calcolare il numero di permutazioni valide per un dato n?

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

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

che è, in Mathematica:

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

Provalo online!