यादृच्छिकता मजेदार है। बिना किसी बिंदु के चुनौतियां मजेदार हैं।

एक फ़ंक्शन लिखें, जो पूर्णांक इनपुट देता है 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?

code-golf random combinatorics

— Skidsdev
स्रोत

2

संबंधित , लेकिन काफी अलग

— Giuseppe

1

(p / s: यदि आपके पास तेज़ एल्गोरिथम है, लेकिन अधिक बाइट्स लेता है, तो गति संस्करण तक प्रतीक्षा करने पर विचार करें (वर्तमान में सैंडबॉक्स में इसे पोस्ट करने के लिए।)

— user202729

1

@EriktheOutgolfer हालांकि सभी सेट बनाने और रैंडम लेने की तुलना में (बहुत) बेहतर तरीके हैं, वे लागू करने और लंबे समय तक चलने के लिए बहुत कठिन हैं। उन्हें गति संस्करण के लिए रखें।

— user202729

2

सेटों की संख्या OEIS A107379 है ।

— nwellnhof

1

यह दोनों है। टिप्पणी देखें "n ^ 2 के विभाजन की संख्या भी अलग-अलग भागों में।"

— nwellnhof

9

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 , का वर्णन इस प्रश्न के रूप में बहुत अधिक किया गया है (यदि आप इसे विषम संख्या में प्रतिबंधित करते हैं तो आपको वही अनुक्रम मिलता है)। पृष्ठ अनुक्रम के लिए कई सूत्रों को सूचीबद्ध करता है (हालांकि कोई भी विशेष रूप से सरल नहीं है; दूसरा मूल्य के लिए एक प्रत्यक्ष सूत्र जैसा दिखता है लेकिन मैं नोटेशन को नहीं समझता हूं)।

— रीस ais523
स्रोत

दूसरा सूत्र " x^(n*(n-1)/2)श्रृंखला विस्तार में गुणांक Product_{k=1..n} 1/(1 - x^k)" है (बिल्कुल भी प्रत्यक्ष नहीं, दुर्भाग्य से)

— user202729

यादृच्छिक लेबलिंग कदम (जैसे A≠≜₁ᵐ) से पहले "सभी अलग" बाधा को रखने से रन टाइम औसतन बहुत तेज हो जाता है।

— घातक

मुझे समझ नहीं आ रहा है कि आपने इसे सामुदायिक विकि क्यों बनाया है। इससे पहले कि यह संभव हो संपादन योग्य पदों के लिए एक पुरातन तरीका है।

— पाइप

@ पाइप

— questions/

7

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)

— केविन क्रूज़सेन
स्रोत

5

पायथन (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*

इसे ऑनलाइन आज़माएं!

— जोनाथन एलन
स्रोत

5

आर , 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 हो, तो विषम तरीके के कार्य से बचना चाहिए ।

— एन जी एम
स्रोत

@Giuseppe "तय" :-)

— एनएमसी

बहुत अच्छा। pइसे गणना करने के बजाय एक सूचकांक के रूप में सीधे उपयोग करना और इसे फिर से उपयोग करके कुछ बाइट्स को बचाना चाहिए।

— Giuseppe

1

मेरे पास function(n){while(sum(F)!=n^2)F=sample(n^2,n);F}48 के रूप में अच्छी तरह से ...

— Giuseppe

1

@ जे। डिओ मुद्दे से बचने के लिए जब ऐसा कुछ sample(2,1)होता है जिसके साथ होता है n=2। तो repबस गारंटी है कि ऐसा कभी नहीं होगा। एक बेहतर तरीका हो सकता है लेकिन यह जल्दी था और मैं पागल था sample।

— एनएमसी

1

आप के साथ एक बाइट बचा सकता x*!!1:2से अधिक rep(x,2)है, तो अपने मेटा सवाल एक नहीं हो जाता है।

— जे। नोवे २०'१

4

जेली , 9 बाइट्स

²œcS=¥Ƈ²X

इसे ऑनलाइन आज़माएं!

सूची के सभी n- संयोजनों को उत्पन्न करें [1..n combinations], जिन्हें राशि n के साथ रखने के लिए फ़िल्टर करें, फिर एक यादृच्छिक चुनें।

— user202729
स्रोत

4

जावा 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 को धन्यवाद ।

बाहर देखो, जावा के माध्यम से आ रहा है .. यह केवल 'पाँच बार' के रूप में लंबे समय के रूप में अन्य चार जवाब संयुक्त है, इसलिए बहुत बुरा नहीं मुझे लगता है .. rofl।
यह चलता है n=1के माध्यम से n=25तो मैं शायद ही साथ इस चुनौती की गति संस्करण के लिए एक संशोधित संस्करण (सैंडबॉक्स में अभी भी वर्तमान में है कि) पोस्ट करेंगे, कम से कम 2 सेकंड हालांकि में (संयुक्त)।

इसे ऑनलाइन आज़माएं।

स्पष्टीकरण:

छद्म कोड में हम निम्नलिखित करते हैं:

1) आकार की एक सरणी उत्पन्न n+1युक्त 0, nचुकता है, और n-1रेंज में यादृच्छिक पूर्णांकों की राशि [0, n squared)
2) क्रमबद्ध इस सरणी
3) आकार के एक दूसरी सरणी बनाएँ nजोड़े के आगे मतभेद युक्त
ये पहले तीन चरणों हमें युक्त एक सरणी दे देंगे nयादृच्छिक पूर्णांक (उस सीमा में [0, n squared)जो nचुकता करने के लिए योग ।
4 ए) यदि सभी यादृच्छिक मान अद्वितीय नहीं हैं, या उनमें से कोई भी 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)

— केविन क्रूज़सेन
स्रोत

1

n=252 सेकंड के भीतर प्रभावशाली है! मुझे स्पष्टीकरण के माध्यम से पढ़ना होगा और देखना होगा कि यह कैसे करता है। क्या यह अभी भी एक क्रूर विधि है?

— स्काइड्सदेव

क्या यह एक समान है? -

— 17:20 बजे user202729

@ user202729 हालांकि मुझे यकीन नहीं है कि इसे कैसे साबित किया जाए, मुझे लगता है कि यह है। जावा बिलिन एक समान है, और यह इसका उपयोग करता है कि [0, n squared)पहले सीमा में यादृच्छिक मान प्राप्त करने के लिए , और फिर उन क्रमबद्ध यादृच्छिक मूल्यों (अग्रणी 0और अनुगामी सहित) के बीच अंतर की गणना करता है n squared। इसलिए मुझे पूरा यकीन है कि वे अंतर समान हैं। , मुझे यकीन नहीं है कि इसे कैसे साबित किया जाए? यादृच्छिकता में एकरूपता वास्तव में मेरी विशेषज्ञता tbh नहीं है।

— केविन क्रूज़सेन

3

आप मतभेद सरणी से कभी नहीं पढ़ते हैं dया मैं कुछ याद कर रहा हूं?

— nwellnhof

1

मैं अपने 127 बाइट्स समाधान के साथ खुश हूं : डी

— ओलिवियर ग्रेजायर

4

पर्ल 6 , 41 बाइट्स

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

इसे ऑनलाइन आज़माएं!

(1 .. $_²) 1 से इनपुट संख्या के वर्ग की संख्या है
.pick($_) बेतरतीब ढंग से उस सीमा का एक अलग सबसेट चुनता है
xx * पूर्ववर्ती अभिव्यक्ति को असीम रूप से दोहराता है
first *.sum == $_² उन संख्याओं में से पहला का चयन करता है जो इनपुट संख्या के वर्ग के लिए sums

— शॉन
स्रोत

40 बाइट्स

— जो किंग

2

पायथ, 13 12 बाइट्स

Ofq*QQsT.cS*

इसे यहाँ ऑनलाइन आज़माएँ । ध्यान दें कि ऑनलाइन इंटरप्रेटर 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./*

— सोक
स्रोत

2

पायथन 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 (1) के बजाय f (5) पर पुनरावर्तन अधिकतम गहराई देता है। असली प्रतिस्पर्धी होने के बहुत करीब।

मैंने इसे एक बार f (5) करते देखा है , और मैं इसे फेरबदल के साथ लागू करने की कोशिश कर रहा हूं।

मैं के लिए कुछ भेड़ का बच्चा अभिव्यक्ति बनाने की कोशिश की s=..., लेकिन यह बाइट्स पर मदद नहीं की। शायद कोई और इसके साथ कुछ कर सकता है: s=(lambda n:{randint(1,n*n)for _ in range(n)})(n)

एक और 7 बाइट्स को शेव करने के लिए केविन का धन्यवाद।

— Gigaflop
स्रोत

1

तो यह सेट को पुन: उत्पन्न करने के लिए पुनरावृत्ति का उपयोग करता है "" यदि एक उत्पन्न अवैध है? निश्चित रूप से आपके कोड के साथ कुछ गलत है अगर यह पुनरावृत्ति की गहराई को मार रहा है f(1), तो एकमात्र संभव सरणी जो यहां उदार होनी चाहिए n=1वह [1]भी है कि यहां बहुत से बाहरी व्हाट्सएप को हटाया जाना है। याद रखें कि यह एक कोड-गोल्फ चुनौती है, इसलिए लक्ष्य सबसे कम बायटेकाउंट को प्राप्त करना है

— स्काइड्सडेव

1

range(1,n)-> range(n)मेरा मानना है कि बग को हल करना चाहिए।

— जोनाथन एलन

1

यह आपके बग को ठीक करना चाहिए, और बाहर के व्हाट्सएप को भी हटा देता है। मुझे लगता है कि गोल्फिंग के लिए बहुत अधिक जगह है

— स्काईसदेव

1

यद्यपि पुनरावृत्ति 5 से 4 से थोड़ी बिगड़ती है, आप अपने दो रिटर्न स्टेटमेंट को इस तरह से जोड़ सकते हैं: return len(s)==n and sum(s)==n*n and s or f(n)( इसे ऑनलाइन 114 बाइट्स आज़माएं )।

— केविन क्रूज़सेन

1

आप यह सब एक लाइन पर कर सकते हैं। 111 बाइट्स

— जो किंग

2

एपीएल (Dyalog यूनिकोड) , 20 बाइट्स ^SBCS

अनाम उपसर्ग लंबोदर।

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

इसे ऑनलाइन आज़माएं!

{... } "dfn"; ⍵तर्क है

⍵*2 तर्क को चौकोना

s← असाइन करना s( s quare के लिए)

⍵?प्रतिस्थापन के बिना n1 ... से यादृच्छिक सूचकांक खोजेंs

c← करने के लिए आवंटित c(के लिए ग andidate)

+/ उन्हें योग

s= से तुलना s

: अगर बराबर है

c उम्मीदवार वापस करें

⋄ अन्य

∇⍵ तर्क पर फिर से आना

— एडम
स्रोत

क्या तुमने मेरी और H.PWiz की 18 बाइट्स देखीं ?

— ngn

@ नहीं, स्पष्ट रूप से नहीं, लेकिन मैंने जाँच की कि पोस्ट करने से पहले कोई एपीएल समाधान पोस्ट नहीं किया गया था। आप में से किसी ने भी ऐसा क्यों नहीं किया

— एडमंड एमवी

ठीक है, एक बार जब मैंने इसे गोल्फ किया और ऑर्चर्ड को दिखाया, तो शायद ही कोई प्रोत्साहन पोस्ट किया गया हो :)

— ngn 25'18 on

@ आप के लिए, नहीं, लेकिन मेरे लिए वहाँ है।

— Adám

1

निश्चित रूप से, और मुझे लगता है कि आप यहाँ apl को लोकप्रिय बनाने के लिए बहुत अच्छा काम कर रहे हैं। मैं सिर्फ यह सुनिश्चित कर रहा था कि आपको पता है कि छोटे समाधान मिल गए हैं और संभवतः उनमें से एक (या एक भिन्नता) की व्याख्या करना बेहतर है

— ngn

2

एपीएल (डायलॉग क्लासिक) , 18 बाइट्स

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

इसे ऑनलाइन आज़माएं!

का उपयोग करता है ⎕io←1

⍳ संख्या उत्पन्न करता है 1 2 ... n

(... )⍣(... )जब तक दाएं रिटर्न सही न हो, तब तक फंक्शन को बाईं ओर लगाते रहें

≢ लंबाई, यानी n

≢?≢×≢n1 और ^{2 के} बीच बेतरतीब ढंग से अलग पूर्णांक चुनेंn

+.-∘≢ प्रत्येक संख्या और योग से लंबाई घटाना

0= यदि योग 0 है, तो लूप करना बंद करें, अन्यथा फिर से प्रयास करें

— NGN
स्रोत

1

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

— ग्यूसेप
स्रोत

मैं आर में यह कोशिश नहीं करेंगे - यादृच्छिक अक्षर लगभग कभी भी एक वैध कार्यक्रम का उत्पादन नहीं करते हैं।

— एनएमसी

@ngm hahaha मुझे लगता है कि एक स्पष्टीकरण क्रम में है।

— Giuseppe

1

जाप, 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

— झबरा
स्रोत

ओपी द्वारा की गई एक टिप्पणी के अनुसार, आउटपुट में तत्वों का क्रम अप्रासंगिक है इसलिए àठीक होना चाहिए।

— कामिल दकरी

धन्यवाद, @KamilDrakari अपडेट किया गया।

— झबरा

1

जावा (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 तक भी नहीं जा सकता।

— ओलिवियर ग्रेजायर
स्रोत

आप गोल्फ 3 बदलकर बाइट्स कर सकते हैं if(r.size()==n&s==0)करने के लिए if(r.size()+s==n)।

— केविन क्रूज़सेन

@KevinCruijssen मैंने इसके बारे में भी सोचा है, लेकिन मैं नहीं कर सकता क्योंकि s -1 हो सकता है और n आकार हो सकता है () - 1.

— ओलिवियर ग्राईगोइरे

आह रुको, जब तक आप सेट में आइटम जोड़ना जारी रखते हैं s>0, तो आकार से बड़ा हो सकता है n। ठीक है, उस मामले में यह वास्तव में काम नहीं करता है। nएक निरंतर है, लेकिन दुर्भाग्य से दोनों sऔर r.size()चर कि दोनों नीचे या ऊपर हो सकता है 0और nक्रमशः।

— केविन क्रूज़सेन 11

1

बैच, 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 को अंतिम संख्या के रूप में चुनते हैं।

— नील
स्रोत

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शून्य के बराबर नहीं है या वर्तमान तत्व -1वर्तमान सरणी में नहीं है, घटाना 1; यदि सरणी का योग से कम है n^2और वर्तमान तत्व +1सरणी में नहीं है, तो 1तत्व में जोड़ें । यदि सरणी योग n^2लूप, आउटपुट सरणी को तोड़ने के बराबर है ।

— guest271314
स्रोत

1

637 बाइट्स z.join को एक चर में खींचकर, औरk++

— Veskah

@Veskah दो whileछोरों को शायद एकल फ़ंक्शन के शरीर में भी कम किया जा सकता है जो मापदंडों को स्वीकार करता है; और if..elseबयानों के लिए सशर्त ऑपरेटरों (टर्नरी) को स्थानापन्न कर सकता है ; कोड के अन्य भागों में जो कि संभावना से अधिक हो सकता है गोल्फ के लिए समायोजित किया जा सकता है; यानी, letबयानों को हटाना ।

— 271314

@Veskah 601 बाइट्स के लिए बिना टर्नरी को प्रतिस्थापित किएif..else

— Guest271314

1

अरे हाँ, आप सभी सेटों का उत्पादन कर रहे हैं, जबकि चुनौती एक यादृच्छिक वापस करने के लिए कहती है (अधिक विवरण के लिए ओपी टिप्पणियाँ देखें)

— Veskah

@Veskah ने चुनौती और उदाहरणों की गलत व्याख्या की होगी, या प्रश्न के इस भाग को हल करने पर बहुत ध्यान केंद्रित किया था " बोनस टास्क: क्या किसी दिए गए वैध क्रमांक की संख्या की गणना करने का कोई सूत्र है n?" । परीक्षण अगर एल्गोरिथ्म लगातार n^2फ़ंक्शन में एकल कॉल में उत्पन्न आउटपुट सरणियों के लिए अपेक्षित परिणाम देता है , और साथ ही इस प्रश्न की समानता पर विचार करते हुए एन-आयामी एन ^ एन सरणी एन से भरा हुआ है ।

— 271314

0

जाप , 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

— कामिल दकरी
स्रोत

0

रूबी , 46 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— जीबी
स्रोत

0

सी (जीसीसी) , 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 + (y + 1) + (y + 2) + . . .

$y+(y+1)+(y+2)+...$ x

\frac{k (k + 1)}{2} + k (y + 1) + y < x

$\frac{k(k+1)}{2}+k(y+1)+y<x$

फिर भी तर्क के पास 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 प्रयोग किया जाता है।

— LambdaBeta
स्रोत

मुझे अच्छा लगेगा अगर कोई मेरे गणित को निरंतरता के लिए जाँचे। मुझे यह भी आश्चर्य है कि क्या इस प्रकार का समाधान समान यादृच्छिक गति चुनौती को सरल बना सकता है। सूत्र उत्तर पर एक ऊपरी और निचले हिस्से को बांधता है, क्या उस श्रेणी में एक समान यादृच्छिक संख्या समान यादृच्छिक परिणाम देती है? मैं नहीं देखता कि क्यों नहीं - लेकिन मैंने कुछ समय में बहुत अधिक दहनशीलता नहीं की है।

— लाम्बेबेटा

p(y),x-=y++)while(rand()&&(i-n)*((~n+i)/2+~y)+y<x)y++;){while(rand()&&(n-i)*(n-i+1)/2+(n-i)*(y+1)+y<x)y++;p(y);x-=y++;}

— सीवनकेट

@ceilingcat मुझे आपके द्वारा खोजे गए इन छोटे सुधारों से प्यार है। मैं हमेशा समग्र एल्गोरिथ्म पर इतना ध्यान केंद्रित करता हूं जिसे मैं कार्यान्वयन के लिए अनुकूलित करना भूल जाता हूं (मैं मूल रूप से एक बार गैर-गोल्फ स्रोत पर काम करता हूं, जो काम करता है - इसलिए मुझे बहुत बचत याद आती है)

— लैम्ब्डाटाटा

अरे, यह सिर्फ तुम नहीं है जो उन वाक्यविन्यास-गोल्फ है। मुझे इस तरह के बहुत सारे C / C ++ उत्तरों में थोड़ा सुधार मिला है (आपके अलावा नहीं, @ceilingcat आमतौर पर उन लोगों को छीन लेता है)।

— Zacharý

हाँ, मैंने देखा है कि आप दो शायद सबसे सक्रिय सी / सी ++ पुटर हैं (क्या हम गोल्फ सादृश्य को पिछले कुछ स्ट्रोक के लिए डालने के लिए उपयोग कर सकते हैं? क्यों नहीं!)। यह मुझे हमेशा प्रभावित करता है कि आप इसे बेहतर बनाने के लिए गोल्फ कोड को अच्छी तरह समझ सकते हैं।

— लैंबडाटा

0

साफ , 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)))))

इसे ऑनलाइन आज़माएं!

— Οurous
स्रोत

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

इसे ऑनलाइन आज़माएं!

एल (5) के आसपास अधिकतम पुनरावृत्ति की गहराई को हिट करता है

— अरबो
स्रोत

0

कोटलिन , 32 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— snail_
स्रोत

1

इस योग

— बजे

0

गणितज्ञ 40 बाइट्स

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

— डेविड जी स्टॉर्क
स्रोत

1

सबसे पहले यह n ^ 2 है, 2 ^ n नहीं। दूसरे, आपका कार्यक्रम एक समारोह होना चाहिए और एक गोल्फ भी होना चाहिए। यह कोशिश करें RandomChoice@IntegerPartitions[#^2,{#}]&

— J42161217

1

इसके अलावा परिणाम होना चाहिए (अनियंत्रित, अद्वितीय) लेकिन यह फ़ंक्शन दोनों में विफल रहता है

— J42161217

0

वोल्फ्राम लैंग्वेज (मैथेमेटिका) , 49 बाइट्स

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

इसे ऑनलाइन आज़माएं!

@ J42161217 द्वारा गोल्फ संस्करण।

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 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$

p a r t (n, k) = p a r t (n - 1, k - 1) + p a r t (n - k, k)

$part(n,k) = part(n-1,k-1) + part(n-k,k)$

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

p a r t (\frac{n^{2} + n}{2}, n)

$part(\frac{n^2+n}{2}, n)$

जो है, गणितज्ञ में:

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

इसे ऑनलाइन आज़माएं!

— bubbler
स्रोत

यह कोड गोल्फ है .. 49 बाइट्स(While[Tr[s=RandomSample[Range[#^2],#]]!=#^2];s)&

— J42161217

मनमाना यादृच्छिकता

उदाहरण

Brachylog (v2), 15 बाइट्स (यादृच्छिक) या 13 बाइट्स (सभी संभावनाएं)

बिना सोचे समझे

व्याख्या

सभी संभावनाएं

व्याख्या

बोनस कार्य

05AB1E , 11 बाइट्स

पायथन (2 या 3), 85 बाइट्स

आर , 68, 75 48 बाइट्स (यादृच्छिक) और 70 बाइट्स (निर्धारक)

जेली , 9 बाइट्स

जावा 10, 250 242 222 बाइट्स

पर्ल 6 , 41 बाइट्स

पायथ, 13 12 बाइट्स

पायथन 3 , 136 134 127 121 114 बाइट्स

एपीएल (Dyalog यूनिकोड) , 20 बाइट्स SBCS

एपीएल (डायलॉग क्लासिक) , 18 बाइट्स

MATL , 18 13 बाइट्स

जाप, 12 बाइट्स

जावा (JDK) , 127 बाइट्स

बैच, 182 145 बाइट्स

जावास्क्रिप्ट, 647 291 261 260 259 251 239 बाइट्स

जाप , 20 बाइट्स

रूबी , 46 बाइट्स

सी (जीसीसी) , 128 125 बाइट्स

कैसे?

कोड

साफ , 172 बाइट्स

पायथन (2 या 3), 84 बाइट्स

कोटलिन , 32 बाइट्स

गणितज्ञ 40 बाइट्स

वोल्फ्राम लैंग्वेज (मैथेमेटिका) , 49 बाइट्स

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 62 बाइट्स

यह काम किस प्रकार करता है

बोनस टास्क का जवाब

एपीएल (Dyalog यूनिकोड) , 20 बाइट्स ^SBCS