यदि N आइटम को N > M के साथ M बॉक्स में रखा जाता है , तो कम से कम एक बॉक्स में एक से अधिक आइटम होने चाहिए।

कई लोगों के लिए, इस सिद्धांत की अन्य गणितीय गणनाओं की तुलना में एक विशेष स्थिति है। जैसा कि EW Dijkstra ने लिखा है ,

यह किसी रहस्य से घिरा हुआ है। इसका उपयोग करने वाले सबूतों को अक्सर कुछ विशेष, कुछ विशेष रूप से सरल के रूप में माना जाता है।

चुनौती

इस चुनौती का उद्देश्य ASCII कला अभ्यावेदन का उपयोग करके कबूतर सिद्धांत को स्पष्ट करना है। विशेष रूप से:

गैर-नकारात्मक और सकारात्मक के साथ इनपुट N(आइटमों की संख्या) और M(बक्से की संख्या ) के रूप में लें । से छोटा हो सकता है (भले ही उस मामले में सिद्धांत लागू नहीं होता है)।NMNM
बक्से के लिए आइटम के संभावित असाइनमेंट में से एक को बेतरतीब ढंग से चुनें। प्रत्येक असाइनमेंट में उठाया जाने वाला गैर-शून्य संभावना होना चाहिए।
निम्नानुसार असाइनमेंट का ASCII कला प्रतिनिधित्व प्रस्तुत करें:
- वहाँ Mएक बॉक्स के लिए प्रत्येक लाइनों, कर रहे हैं ।
- प्रत्येक पंक्ति एक गैर-व्हाट्सएप चरित्र से शुरू होती है, जैसे कि |।
- उस चरित्र का अनुसरण करना एक अन्य गैर-व्हाट्सएप चरित्र है, जैसे कि #, उस बॉक्स में जितनी बार आइटम हैं, उतने बार-बार दोहराया जाना।

उदाहरण के लिए विचार करें N = 8, M = 5। बक्से के लिए आइटम के चयनित असाइनमेंट है, तो 4, 1, 0, 3, 0, प्रतिनिधित्व है

|####
|#
|
|###
|

एक ही कार्यक्रम का एक अलग रन (एक अलग असाइनमेंट के परिणामस्वरूप) दे सकता है

|#
|##
|#
|#
|###

प्रतिनिधित्व के संबंध में कुछ लचीलापन है; निचे देखो।

विशिष्ट नियम

कोड को सैद्धांतिक रूप से Nऔर के किसी भी मूल्य के लिए चलना चाहिए M। व्यवहार में इसे मेमोरी साइज़ या डेटा टाइप सीमाओं द्वारा प्रतिबंधित किया जा सकता है।

चूंकि आउटपुट का अवलोकन यह निर्धारित करने के लिए पर्याप्त नहीं है कि सभी असाइनमेंट में गैर-शून्य संभावना है , प्रत्येक सबमिशन को यह स्पष्ट करना चाहिए कि कोड कैसे प्राप्त करता है, यदि स्पष्ट नहीं है।

निम्नलिखित प्रतिनिधित्व विविधताओं की अनुमति है:

विभिन्न, गैर-व्हाट्सएप पात्रों की किसी भी जोड़ी को चुना जा सकता है। वे पूरे कार्यक्रम के अनुरूप होना चाहिए।
प्रतिनिधित्व के 90-डिग्री घुमाव स्वीकार्य हैं। फिर से, चुनाव सुसंगत होना चाहिए।
अनुगामी या अग्रणी व्हाट्सएप की अनुमति है।

एक अलग प्रतिनिधित्व प्रारूप के साथ, के लिए एक उदाहरण के रूप N = 15, M = 6कार्यक्रम के दो फांसी के परिणाम हो सकता है

VVVVVV
@@@@@@
@@ @@@
 @  @@
    @

या

VVVVV
@@@ @
@@@ @
@ @ @
@ @ @
@

इसी तरह, N = 5, M = 7, देना प्रतिनिधित्व की एक और भिन्नता का उपयोग कर सकता है,

  *
* * * *
UUUUUUU

या

 *** **
UUUUUUU

या

   *
*  *
*  * 
UUUUUUU

ध्यान दें कि इस मामले में सिद्धांत कैसे लागू नहीं होता है, क्योंकि N< M।

सामान्य नियम

प्रोग्राम या फ़ंक्शंस की अनुमति है, किसी भी प्रोग्रामिंग भाषा में । मानक खामियों को मना किया जाता है।

इनपुट किसी भी उचित माध्यम से लिया जा सकता है ; और किसी भी प्रारूप के साथ, जैसे कि दो संख्याओं की एक सरणी या दो अलग तार।

आउटपुट के साधन और प्रारूप भी लचीले हैं। उदाहरण के लिए, आउटपुट स्ट्रिंग्स की एक सूची या न्यूलाइन के साथ एक स्ट्रिंग हो सकता है; फ़ंक्शन आउटपुट तर्क के रूप में लौटाया गया या STDOUT में प्रदर्शित किया गया। बाद के मामले में सीमित प्रदर्शन चौड़ाई के कारण लाइन रैपिंग के बारे में चिंता करना आवश्यक नहीं है।

बाइट्स में सबसे छोटा कोड जीतता है।

— लुइस मेंडो
स्रोत

11

यह वास्तव में मुझे शीर्षक पाने के लिए अब तक ले गया ...

— मार्टिन एंडर

@MartinEnder क्या यह है कि "कबूतर सिद्धांत" में "कोड गोल्फ" की तुलना में अधिक वर्ण हैं, या कोई अन्य मजाक है?

— डोरुकायहन

5

@dorukayhan एक मानक ब्राउज़र में, प्रश्न शीर्षक से थोड़ा ऊपर पाठ को देखें ...

— लुइस मेंडो

2

जेली , ९ by बाइट्स

=þṗX¥S⁵*

यह एक डाइएडिक लिंक है जो एम को इसके बाएं और एन को अपने सही तर्क के रूप में लेता है। आउटपुट पूर्णांक का एक सरणी है, जहां 0 कबूतरों का प्रतिनिधित्व करता है और 1 छिद्रों का प्रतिनिधित्व करता है।

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

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

=þṗX¥S⁵*  Main link. Left argument: m. Right argument: n

    ¥     Combine the two links to the left into a dyadic chain and call it
          with arguments m and n.
  ṗ        Compute the n-th Cartesian power of [1, ..., m], i.e., generate all
           vectors of length n that consist of elements of [1, ..., m].
   X       Pseudo-randomly choose one of those vectors with a uniform distribution.
=þ        Equal table; for each k in [1, ..., m] and each vector to the right,
          compare the elements of the vector with k. Group the results by the
          vectors, yielding a 2D Boolean matrix.
     R    Range; map 1 to [1], 0 to [].
      S   Take the sum of all columns.
       ⁵* Raise 10 to the resulting powers.

— डेनिस
स्रोत

10

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

Print/@(10^RandomSample@RandomChoice[IntegerPartitions[+##,{#}]-1])&

एक अनाम फ़ंक्शन जो दो पूर्णांक तर्क लेता है, बॉक्स की संख्या, उसके बाद आइटम की संख्या।

यह पहले N+Mबिल्कुल Mसकारात्मक भागों में सभी संभावित विभाजन की गणना करता है , और 1बाद में प्रत्येक विभाजन से घटाता है। यह हमें गैर-नकारात्मक भागों (जो अन्यथा उत्पन्न नहीं करेगा) Nमें सभी संभव विभाजन देता है । फिर एक यादृच्छिक विभाजन चुनें और इसे फेरबदल करें। यह शून्य के साथ सभी संभव आदेशित विभाजन की गारंटी देता है। अंत में, विभाजन के प्रत्येक बिन को संबंधित पावर (जैसे कि प्रत्येक पंक्ति शून्य के साथ हो जाती है ) को 10 बढ़ाकर आउटपुट लाइन में बदल दें । एक उदाहरण आउटपुट जैसा दिख सकता है:MIntegerPartitions1000...k

— मार्टिन एंडर
स्रोत

मेरा मानना है कि PadRightकरने के लिए पैड नहीं होगा Mशून्य अगर N< M।

— लेजिओनमाला 978

1

@ LegionMammal978 धन्यवाद, एक ही बाइट गिनती में इसे ठीक करने में कामयाब रहे।

— मार्टिन एंडर

... मैं ईमानदारी से प्रभावित हूँ। मैं इसी तरह का समाधान करने वाला था, लेकिन PadRightगैर-सूचीबद्धता से यह बहुत लंबा हो जाएगा।

— लेजियम मैमल 978

@ LegionMammal978 बचने का एक और तरीका PadRightहोगा IntegerPartitions[#,{#2},0~Range~#]।

— मार्टिन एंडर

1

कोई बाइटेल्टिन नहीं? मुझे आश्चर्य है ...: डी लेकिन अच्छा जवाब। मुझे केवल यह पता लगाने की आवश्यकता है कि यह पहले कैसे काम करता है: पी

— हाइपरएनुट्रीनो

9

पायथन 2, 77 86 बाइट्स

from random import*
n,m=input()
exec'c=randint(0,n);n-=c;print 10**c;'*~-m
print 10**n

[0, n] में एक संख्या उत्पन्न करता है, कई वस्तुओं को प्रिंट करता है और इसे n से प्रतिस्थापित करता है। यह इस बार करता है।

यह बहुत संभव नहीं बनाता है कुछ भी इसे अंतिम बॉक्स में बनाता है, लेकिन सवाल केवल यह पूछा गया कि हर आउटपुट संभव है , समान रूप से संभव नहीं है ।

— orlp
स्रोत

7

बैच, 164 बाइट्स

@for /l %%i in (1,1,%1)do @set h%%i=1
@for /l %%j in (1,1,%2)do @call set/ab=%%random%%%%%%%1+1&call set/ah%%b%%*=10
@for /l %%i in (1,1,%1)do @call echo %%h%%i%%

मुझे लगता है कि लगातार 7 %संकेत एक नया व्यक्तिगत सर्वश्रेष्ठ हो सकता है! नोट: यह विषम उत्पादन करता है इसे कभी भी एक ही बॉक्स में 9 से अधिक आइटम असाइन करना चाहिए; यदि यह समस्या है, तो 180 बाइट्स के लिए:

@for /l %%i in (1,1,%1)do @set h%%i=1
@for /l %%j in (1,1,%2)do @call set/ab=%%random%%%%%%%1+1&call call set h%%b%%=%%%%h%%b%%%%%%0
@for /l %%i in (1,1,%1)do @call echo %%h%%i%%

हाँ, यह %दूसरी पंक्ति पर कुल मिलाकर 28 एस है।

— नील
स्रोत

5

सी, 102 बाइट्स

n,m;main(x){srand(time(0));for(scanf("%d %d",&n,&m);m--;n-=x)printf("|%0*s\n",x=m?rand()%(n+1):n,"");}

स्टड पर इनपुट लेता है, जैसे:

echo "5 4" | ./pigeonhole

समान संभावना वाले प्रत्येक आउटपुट को उत्पन्न नहीं करेगा, लेकिन सभी संभव संयोजनों को उत्पन्न करने में सक्षम है।

टूट - फूट:

n,m;
main(x){
    srand(time(0));             // Seed random number generator
    for(scanf("%d %d",&n,&m);   // Parse input values into n and m
        m--;                    // Loop through each bucket (count down)
        n-=x)                   // Subtract number assigned to bucket from total
        printf(                 // Output a formatted string using padding
            "|%0*s\n",          // (turns out %0s will actually zero-pad a string!)
            x=m?rand()%(n+1):n, // Calculate a number of items for this bucket
            "");
}

जीसीसी के अपरिभाषित व्यवहार से निपटने पर निर्भर करता है %0s- आम तौर पर %0एक पूर्णांक या फ्लोट को शून्य-पैड करेगा, लेकिन यह केवल पैड कर सकता है (कभी भी छोटा नहीं), इसलिए रिक्त को प्रिंट करना संभव नहीं है। लेकिन स्ट्रिंग्स के लिए व्यवहार को परिभाषित नहीं किया गया है, और जीसीसी ने इसे शून्य-पैड बनाने का फैसला किया, इसलिए यह शून्य-पैड शून्य स्ट्रिंग को शून्य या अधिक लिखने में सक्षम होने के लिए 0।

— डेव
स्रोत

2

चूंकि फ़ंक्शंस की अनुमति है, आप a(b,c){...}इसके बजाय mainऔर का उपयोग करके कुछ वर्णों को काट सकते हैं scanf।

— केविन

3

पायथन 2, 102 99 97 90 बाइट्स

m-1बार, एक यादृच्छिक राशि चुना है xके बीच 0और n, समावेशी और एन से घटा दें। फिर एक प्रिंट 1और '0'*x।

अंत में, प्रिंट करें 1और बाकी के 0एस। सभी समान अवसरों पर नहीं, लेकिन सभी कॉन्फ़िगरेशन संभव हैं।

from random import*
n,m=input()
exec'x=randrange(n+1);n-=x;print 10**x;'*(m-1)
print 10**n

(टूटे हुए पायथन उत्तर से पुन: उपयोग किया गया कोड।)

— L3viathan
स्रोत

मुझे लगता है कि यह जवाब मेरे जवाब पर एक सुझाव होना चाहिए था क्योंकि यह सचमुच एक छोटे बग फिक्स के साथ एक ही जवाब है।

— orlp

1

@orlp यदि आप इस उत्तर के इतिहास को देखें, तो यह नवीनतम संस्करण में बन गया। अगर मैंने इसे शुरू में ऐसा बनाया होता, तो मैं इसे टिप्पणी के रूप में पोस्ट करता।

— L3viathan

आह फिर यह ठीक है, जिस तरह से यह देखा (और आपने 'पुन: उपयोग किए गए कोड' लिखा) ने इसे अलग तरह से देखा है। माफ़ कीजिये।

— orlp

@orlp कोई समस्या नहीं है। तुम्हारा अब काम कर रहा है और मेरा किसी भी रास्ते से छोटा है, मैं इस उत्तर को भी हटा सकता हूं यदि आपको लगता है कि यह आपके बहुत करीब है, तो मुझे कोई आपत्ति नहीं है, मैं केवल यह स्पष्ट करना चाहता था कि मैंने आपके उत्तर को कॉपी-पेस्ट नहीं किया था।

— L3viathan

3

हास्केल, 114 94 बाइट्स

import System.Random
n#m=map(10^).take m.until((==n).sum.take m)tail.randomRs(0,m)<$>newStdGen

थोड़ी-बहुत बल-शक्ति का दृष्टिकोण: यादृच्छिक संख्याओं की एक अनंत सूची तैयार करता है, सूची की शुरुआत के n संख्याओं को लेता है, उन्हें समेटता है, और जाँचता है कि क्या वे m के बराबर हैं। यदि नहीं, तो पहले तत्व को सूची से हटा दें और दोहराएं।

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

नोट: आयात के बिना 73 बाइट्स

संपादित करें: 10 ^ ट्रिक के साथ कुछ बाइट्स सहेजे गए ( ऑनलाइन नया संस्करण आज़माएं! )

— सामान्य प्रदर्शन का नाम
स्रोत

2

REXX, 74 बाइट्स

arg n m
m=m-1
o.=@
do n
  a=random(m)
  o.a=o.a||#
  end
do a=0 to m
  say o.a
  end

आउटपुट (8 5):

@#
@###
@
@#
@###

आउटपुट (8 5):

@#
@#
@
@####
@##

— idrougge
स्रोत

2

सी, 175 138 बाइट्स

37 बाइट बचाने के लिए @Dave का धन्यवाद!

i;f(n,m){char**l=calloc(m,8);for(i=0;i<m;)l[i]=calloc(n+1,1),*l[i++]=124;for(i=n+1;--i;)*strchr(l[rand()%m],0)=35;for(;i<m;)puts(l[i++]);}

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

— Steadybox
स्रोत

1

नमस्ते, कुछ चीजें जो आपको इसे कम करने में मदद कर सकती हैं: callocआपको 0-इनिशियलाइज्ड मेमोरी (सभी 0s खुद को सेट करने की कोई आवश्यकता नहीं) देगी, strchrएक स्ट्रिंग के अंत का पता लगा सकती है, अल्पविराम श्रृंखला संचालन की आवश्यकता को पूरा कर सकती है {}, और इसकी आवश्यकता से बच सकती है x[0] == *x। बाहर भी देखो; mallocयदि आप सभी आइटम एक ही बॉक्स में हैं, तो आप पर्याप्त मेमोरी नहीं ले सकते हैं ।

— डेव

2

एएचके, 66 बाइट्स

2-=1
Loop,%2%{
Random,r,0,%1%
Send,|{# %r%}`n
1-=r
}
Send,|{# %1%}

मैंने उसी प्रिंसिपल का अनुसरण किया, जिसे orlp ने 0 से N तक यादृच्छिक संख्याओं का उपयोग किया और फिर इसे N से घटाया। दुर्भाग्य से, मैं सेंड फंक्शन के काम करने के तरीके के कारण 10 ^ r का उपयोग करके बाइट्स को नहीं बचा सका। काश और अलैक। यहाँ n = 8, m = 5 के लिए कुछ आउटपुट दिए गए हैं:

|##     |#####    |##       |##     |#      |##   
|##     |#        |#####    |       |###    |#    
|#      |##       |         |###    |###    |     
|###    |         |         |       |#      |     
|       |         |#        |###    |       |#####

— इंजीनियर टोस्ट
स्रोत

2

सीजेएम, 30 31 21 बाइट्स

:B1a*:C\{CBmrAt.*}*N*

n mस्टैक पर इनपुट दो नंबर है । 1कॉलम चरित्र के 0लिए और दोहराया चरित्र के लिए उपयोग करता है ।

स्पष्टीकरण:

:B          e# Store m in B (without deleting it from the stack)
1a          e# Push 1 and wrap it in an array: [1]
*           e# Repeat the array m times
:C          e# Store this array in C (without deleting)
\{          e# Do n times:
  CBmrAt    e#   Create an array of 1s with a random element replaced with 10.
  .*        e#   Vectorized multiplication: multiply the respective elements in the arrays.
            e#   Effectively, we multiply a random value in the array by 10 (and add a 0 to the end).
}*          e# End loop.
N*          e# Join with newlines.

— फल तोड़ना
स्रोत

1

रोड़ा , 79 बाइट्स

f n,m{a=[0]*m
i=0{{n--
a[i%m]++}if randomBoolean
i++}while[n>0]
a|[`|`.."#"*_]}

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

यह शून्य की एक सरणी बनाता है और यादृच्छिक स्थानों पर उन्हें बढ़ाता है।

— fergusq
स्रोत

1

PHP, 100 बाइट्स

list($z,$m,$n)=$argv;$a=array_fill(0,$n,z);while($m>0){$a[rand(0,$n-1)].=a;$m--;}echo join("\n",$a);

टूट - फूट :

list($z,$m,$n)=$argv;     // assigns the input vars to $m and $n
$a=array_fill(0,$n,z);    // creates an array $a of $n elements containing 'z'
while($m>0){              // randomly populate array $a
    $a[rand(0,$n-1)].=a;  //
    $m--;                 //
}                         //
echo join("\n",$a);       // output $a contents separated by a new line

के लिए आउटपुट m=7और n=5:

पहला निष्पादन:

za
zaa
za
za
zaa

दूसरा निष्पादन:

za
zaa
zaaa
z
za

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

— roberto06
स्रोत

आप [,$m,$n]=$argv;कुछ चरों को बचाने के लिए PHP 7.1 से उपयोग कर सकते हैं । आप \n1 बाइट को बचाने के लिए वास्तविक लाइन ब्रेक के साथ बदल सकते हैं । आप for(;$m-->0;)$a[rand(0,$n-1)].=a;ब्रेक, $mऔर एक अर्धविराम को बचाने के लिए उपयोग कर सकते हैं । [,$m,$n]=$argv;$a=array_fill(0,$n,z);for(;$m-->0;)$a[rand()%$n].=a;echo join("\n",$a);85 बाइट

— क्रिस्टोफ़

यह गोल्फ [,$m,$n]=$argv;for(;$m--;)${rand()%$n}.=a;for(;$n--;)echo"z${$n}\n";67 बाइट से भी नीचे है ।

— क्रिस्टोफ़

@ क्रिसटोफ़ मैंने [,$m,$n]=$argv;अन्य कोड-गोल्फ पर संकेतन देखा, लेकिन यह मेरे देव परिवेश में या eval.in पर काम करने में सक्षम नहीं था

— roberto06

इसे यहाँ आज़माएँ: sandbox.onlinephpfunctions.com/code/… ।

— क्रिस्टोफ़

1

अच्छा लगा। मुझे लगता है कि आप अपने स्निपेट को उत्तर के रूप में पोस्ट कर सकते हैं क्योंकि यह मेरी से काफी अलग है;)

— रोबर्टो06

1

जावास्क्रिप्ट, 105 बाइट्स

x=>y=>{s=[];for(;x>1;y-=t)s[--x]="|"+"#".repeat(t=Math.random()*(y+1)|0);s[0]="|"+"#".repeat(y);return s}

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

पंक्तियों को असाइन करने की विधि के कारण, यह नीचे की ओर अधिक जगह देगा, हालांकि एक छोटा मौका है कि शीर्ष को कुछ मिल जाएगा।

— fənɛtɪk
स्रोत

1

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

->(n,m){r=Array.new(m){?|};n.times{r[rand m]+=?#};r}

एक अनाम फ़ंक्शन बनाता है जो दो पूर्णांकों को तर्क के रूप में लेता है और स्ट्रिंग्स की एक सरणी देता है:

>> puts ->(n,m){r=Array.new(m){?|};n.times{r[rand m]+=?#};r}.call 7,5
|#
|#
|##
|##
|#

— मोनिका iamnotmaynard को बहाल करें
स्रोत

1

पायथन 2, 81 बाइट्स

from random import*
def f(n,m):l=['#']*m;exec('l[randrange(m)]+="o";'*n);return l

तार की सूची लौटाता है।

— TFeld
स्रोत

1

जावास्क्रिप्ट (ईएस 7), 75 बाइट्स

(N,M)=>{for(r='';M;M--,N-=x=~~(Math.random()*(N+1)),r+=10**x+`
`);return r}

मुझे लगा कि मैं केवल 10 विचारों की शक्तियों के साथ आने के लिए चतुर था, यह महसूस करने के लिए कि अधिकांश उत्तर पहले से ही उपयोग कर रहे थे।

— ValarDohaeris
स्रोत

1

AWK, 78 बाइट्स

{srand();for(;n++;)c[k]=c[k=int($2*rand())]"#"}END{for(;j<$2;)print"|"c[j++]}

2 तर्क लेता है, पहले मदों की संख्या, फिर बक्से की संख्या। यादृच्छिक संख्या जनरेटर बोने से शुरू होता है ताकि प्रत्येक रन अलग हो। तो बस एक सरणी में तार बनाता है, उदाहरण उपयोग:

awk '{srand();for(;n++;)c[k]=c[k=int($2*rand())]"#"}END{for(;j<$2;)print"|"c[j++]}' <<< "12 5"

Example output:
|##
|###
|##
|##
|###

— रॉबर्ट बेन्सन
स्रोत

1

MATLAB, 103 94 बाइट्स

function a(m,n)
d=@(p)disp(char([1,~(1:p)]+48));for i=1:m-1;p=randi([0,n]);d(p);n=n-p;end;d(n)

स्वरूपण के साथ

function a(m,n)
for i=1:m-1 
    d=@(p)disp(char([1,~(1:p)]+48));  % inline function for displaying
    p=randi([0,n]);              % picking a random number b/w 0 and n
    d(p);                        % '1' represents the box/pigeonhole, with '0's denoting entries
    n=n-p;
end
d(n);                            % writing the remaining entries/zeros

नमूना आउटपुट

>> a(4,7)
10
10000
10
10

प्रत्येक सरणी प्रविष्टि के बीच एक टैब के साथ प्रदर्शित होने के बाद से अनुगामी व्हॉट्सएप हैं, लेकिन यह चश्मा के अनुसार स्वीकार्य होना चाहिए।

यह मेरे लिए एक बहुत ही सरल कार्यान्वयन जैसा लगता है, इसलिए मुझे यकीन है कि इसमें सुधार किया जा सकता है।

सुझाव के लिए @Luis मेंडो को धन्यवाद।

— Krostd
स्रोत

अनाम बयान के रूप में प्रदर्शन स्टेटमेंट को परिभाषित करने वाले दो बाइट्स को दो बार लिखने से बचने के लिए आप काफी कुछ बचा सकते हैं:d=@(p)disp(char([1,~(1:p)]+48));for i=1:m-1;p=randi([0,n]);d(p);n=n-p;end;d(n)

— लुइस मेंडू

@LuisMendo सुझाव के लिए धन्यवाद, मैं अपडेट करूंगा। क्या मैं अपने वास्तविक कार्य को उसी तरह परिभाषित कर सकता हूं, जैसे। a = @ (m, n) ... क्योंकि इससे बाइट्स की संख्या भी कम हो जाएगी। MATLAB कोड-गोल्फ उत्तरों में लोग आमतौर पर "फ़ंक्शन नाम (args)" को कैसे हटाते हैं / छोटा करते हैं?

— Krostd

हाँ, आप उत्तर के रूप में भी एक एनोयमस फ़ंक्शन का उपयोग कर सकते हैं। आप भी छोड़ सकते हैं a=। इस मामले में आप सिद्धांत रूप में ऐसा नहीं कर सकते, क्योंकि अनाम कार्यों में लूप नहीं हो सकते। लेकिन आप सब कुछ डालने की चाल का उपयोग कर सकते हैं eval('...')। बीटीडब्लू, जिसे आमतौर पर मतलाब में बदसूरत और बुरा व्यवहार माना जाता है, लेकिन यहां हम भाषाओं का दुरुपयोग करना पसंद करते हैं :-)

— लुइस मेंडो

हम्म .. मैं आपके सुझाव के आधार पर अपडेट करूंगा और इसके बारे में कुछ और सोचूंगा और देखूंगा कि क्या मैं लूप से बच सकता हूं, हालांकि ऐसा लगता नहीं है। मैं एक तर्क के बारे में सोच सकता हूं जो ऐसा कर सकता है, लेकिन यह सुनिश्चित नहीं है कि इसे कैसे लागू किया जाए .. मैं एक संख्या 10 ^ n को परिभाषित करने के बारे में सोच रहा हूं, और मी संख्याएं ढूंढ रहा हूं जो 10 की सभी शक्तियां हैं, और फिर बस उन्हें प्रिंट करना है। यह बिल्कुल वैसा ही आउटपुट होगा जैसा अभी मेरे पास है:: D कोई सुझाव? एक और जवाब के रूप में इसे पोस्ट करने के लिए स्वतंत्र महसूस करें।

— Krostd

मेरा मतलब था एम फैक्टर (सिर्फ कोई संख्या नहीं)

— Krostd

1

ऑक्टेव , 62 54 बाइट्स

@(n,m)strcat(62,(sum(randi(m,1,n)==(1:m)',2)>=1:n)*42)

बेनामी फ़ंक्शन जो दो नंबर लेता है और >बॉक्स के लिए और *ऑब्जेक्ट्स के साथ वर्णों के 2 डी सरणी को आउटपुट करता है । सभी परिणाम समान रूप से होने की संभावना है।

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

— लुइस मेंडो
स्रोत

1

टीआई-बेसिक, 63 62 बाइट्स

Prompt N,M
For(A,1,M
N→B
If M-A
randInt(0,N→B
":→Str0
For(C,1,B
Ans+"X→Str0
End
Disp Ans
N-B→N
End

प्रत्येक असाइनमेंट में उठाया जाने वाला गैर-शून्य संभावना होना चाहिए।

इस मानदंड ने इस कार्यक्रम को लिखने में बहुत आसान बना दिया।

उदाहरण I / O:

prgmPIDGEON
N=?5
M=?2
:XXXX
:X

स्पष्टीकरण:

Prompt N,M     # 5 bytes, input number of items, number of boxes
For(A,1,M      # 7 bytes, for each box
N→B            # 4 bytes, on last box, make sure the sum is met by adding N items
If M-A         # 5 bytes, if not last box
randInt(0,N→B  # 8 bytes, add random number of items from 0 to N to box A
":→Str0        # 6 bytes, first character
For(C,1,B      # 7 bytes, add B items to the box
Ans+"X→Str0    # 8 bytes
End            # 2 bytes
Disp Ans       # 3 bytes, print this box
N-B→N          # 6 bytes, subtract the items used in this box
End            # 1 byte, move on to next box

— pizzapants184
स्रोत

1

MATLAB, 73 64 58 बाइट्स

# 3 अद्यतन

मुझे छंटाई की आवश्यकता है, ऐसा लगता है, क्योंकि मुझे नकारात्मक पूर्णांक मिलते हैं। मैंने अब के disp(sprintf(...))साथ प्रतिस्थापित किया fprintf(...), हालांकि, जवाब 58 बाइट्स रहता है।

@(m,n)fprintf('%i\n',10.^diff([0;sort(randi(n,m-1,1));n]))

# 2 अद्यतन:

मुझे एहसास हुआ कि मुझे सरणी को क्रमबद्ध करने की आवश्यकता नहीं है, और वास्तव में छंटनी वास्तव में सरणी में संख्याओं के औसत को कम करेगी। इसलिए मैंने उस sort(...)हिस्से को हटा दिया । ध्यान दें कि आउटपुट समान रहता है, इसलिए मैं "नमूना आउटपुट" अपडेट नहीं कर रहा हूं।

@(m,n)disp(sprintf('%i\n',10.^diff([0;randi(n,m-1,1);n])))

अंत में लुइस द्वारा ऑक्टेव उत्तर पर बंद करना! : डी

# 1 अद्यतन:

@(m,n)disp(sprintf('%i\n',10.^diff([0;sort(randi(n,m-1,1));n])))

स्ट्रिंग में कनवर्ट करने के बजाय, मैं सीधे संख्याओं को प्रदर्शित करता हूं। मैं 58 बाइट्स को कम कर सकता था, को हटाकर disp(...), लेकिन फिर मुझे ans =बस स्प्रिंटफ के साथ अतिरिक्त मिलता है , और यह नहीं पता कि क्या स्वीकार्य है।

प्रारंभिक कोड:

@(m,n)disp(strjust(num2str(10.^diff([0;sort(randi(n,m-1,1));n])),'left'))

लुइस के कुछ सुझावों के लिए धन्यवाद , मुझे अपने पिछले उत्तर में लूप से छुटकारा मिल गया । अब मैं सबसे पहले mयादृच्छिक संख्याओं को जोड़कर n( diff([0;sort(randi(n,m-1,1));n])) को खड़ा करता हूं , फिर उन्हें 10 के घातांक के रूप में उपयोग करता हूं, उन्हें एक स्ट्रिंग में परिवर्तित करता हूं, उन्हें बाएं-जस्टिफाई करता हूं और उन्हें प्रदर्शित करता हूं।

मैं तकनीकी रूप से एक और 6 बाइट्स को बचाने के लिए विवाद (...) से छुटकारा पा सकता था, लेकिन फिर एक "एन्स" मुद्रित हो जाता है जो ऐनक का उल्लंघन कर सकता है। वांछित अंत प्रारूप प्राप्त करने के लिए उन्हें स्ट्रिंग और बाएं-औचित्य में बदलने का एक तरीका भी हो सकता है, इसलिए मैं सुझावों के लिए खुला हूं।

नमूना उत्पादन:

>> a=@(m,n)disp(strjust(num2str(10.^diff([0;sort(randi(n,m-1,1));n])),'left'));
>> a(4,6)
1000
10  
100 
1

नोट : मैंने अपने फ़ंक्शन को सुझावों के आधार पर यहां एक अनाम फ़ंक्शन में बदल दिया है। नमूना आउटपुट में, मैंनेaउसे प्रदर्शित करने के लिएअसाइनकिया है। मुझे उम्मीद है कि यह चश्मे का उल्लंघन नहीं करता है, लेकिन अगर यह कृपया मुझे बताएं और मैं इसे बदल दूंगा।

— Krostd
स्रोत

मुझे बस एहसास हुआ कि शीर्ष उत्तर 10 ^ के समान तर्क का उपयोग करता है .. जो इसके लायक है, और अगर यह मायने रखता है, तो मैंने अपने उत्तर के संदर्भ के रूप में इसका उपयोग नहीं किया है .. (लेकिन खतरे में, किसी ने मुझे इसे हराया!) पी)

— क्रॉस्टड

यादृच्छिक उत्तर बनाने वाले के विचार के लिए भी इस उत्तर का श्रेय नोट करना चाहते थे , mजो कि मैं जोड़ देता nहूं, क्योंकि मैं उस हिस्से पर लंबे समय से अटका हुआ था .. (फिर भी मेरे उत्तरों में 2 से अधिक लिंक नहीं जोड़ सकता, इसलिए इसमें शामिल है एक टिप्पणी में)

— Krostd

1

स्टैक्ड , 29 बाइट्स

('|')\rep\[:randin'#'push@.]*

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

की एक सरणी का निर्माण करके व्यवहार करती Mयुक्त एकमात्र '|', तो जोड़ने '#'यादृच्छिक रूप से चुना सरणी के लिए Nबार।

— कोनोर ओ ब्रायन
स्रोत

अच्छा! और इसलिए सभी परिणाम समान रूप से होने की संभावना है, है ना?

— लुइस मेंडो

@LuisMendo यह होना चाहिए, क्योंकि randinफिशर-येट्स एल्गोरिथ्म का आंतरिक रूप से उपयोग करता है। (यह वही एल्गोरिथ्म है जो CJam उत्तर FWIW का उपयोग करता है)

— कॉनर ओ'ब्रायन

1

पायथन 2 , 80 95 89 88 बाइट्स

from random import*
n,m=input()
while m:x=randint(0,n);print'1'+'0'*[n,x][m>1];m-=1;n-=x

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

15 बाइट्स जोड़े गए: पिछला संपादन थोड़ा त्रुटिपूर्ण था, कुछ पीगों को छोड़ दिया गया था।
सहेजे गए 6 बाइट्स: [n, x] [m> 1] द्वारा प्रतिस्थापित किए जाने पर
सहेजे गए 1 बाइट: आयात *

— officialaimm
स्रोत

1

चारकोल , 19 बाइट्स

≔ＥＮ⟦⟧θＦＮ⊞‽θ#Ｅθ⁺|⪫ιω

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

  Ｎ                 Input `M`
 Ｅ                  Map over implicit range
   ⟦⟧               Empty array
≔    θ              Assign resulting nested array to `q`

       Ｎ            Input `N`
      Ｆ             Loop over implicit range
          θ         Nested array `q`
         ‽          Random element
           #        Literal string
        ⊞           Append to array

             θ      Nested array `q`
            Ｅ       Map over array
                 ι  Current element
                  ω Empty string
                ⪫   Join
               |    Literal string
              ⁺     Concatenate
                    Implicitly print on separate lines

— नील
स्रोत

कबूतर का सिद्धांत और कोड गोल्फ

चुनौती

विशिष्ट नियम

सामान्य नियम

जेली , ९ by बाइट्स

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

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

पायथन 2, 77 86 बाइट्स

बैच, 164 बाइट्स

सी, 102 बाइट्स

टूट - फूट:

पायथन 2, 102 99 97 90 बाइट्स

हास्केल, 114 94 बाइट्स

REXX, 74 बाइट्स

सी, 175 138 बाइट्स

एएचके, 66 बाइट्स

सीजेएम, 30 31 21 बाइट्स

रोड़ा , 79 बाइट्स

PHP, 100 बाइट्स

जावास्क्रिप्ट, 105 बाइट्स

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

पायथन 2, 81 बाइट्स

जावास्क्रिप्ट (ईएस 7), 75 बाइट्स

AWK, 78 बाइट्स

MATLAB, 103 94 बाइट्स

स्वरूपण के साथ

नमूना आउटपुट

ऑक्टेव , 62 54 बाइट्स

टीआई-बेसिक, 63 62 बाइट्स

MATLAB, 73 64 58 बाइट्स

# 3 अद्यतन

# 2 अद्यतन:

# 1 अद्यतन:

प्रारंभिक कोड:

नमूना उत्पादन:

स्टैक्ड , 29 बाइट्स

पायथन 2 , 80 95 89 88 बाइट्स

चारकोल , 19 बाइट्स