मानों की सूची में एक संख्या को यथासंभव समान वितरित करें जिनकी राशि उस संख्या के बराबर है

15

संभवतः एक साधारण कोड-गोल्फ चुनौती। 2 सकारात्मक पूर्णांकों को देखते हुए mऔर n, उन nमूल्यों की एक सूची बनाएं जो सकारात्मक पूर्णांक हैं जिनकी राशि संख्या के बराबर है m। या तो आउटपुट में सभी मान समान मूल्य हैं या अंतर ठीक 1 है।

उदाहरण

उदाहरण के लिए

  • m=6और n=3बन जाएगा2, 2, 2
  • m=7और n=3बन जाएगा 2, 2, 3या 2, 3, 2या 3, 2, 2
  • m=7और n=2बन जाएगा 3, 4या4, 3
  • m=7और n=1बन जाएगा7
  • m=7और n=8एक त्रुटि उत्पन्न करेगा क्योंकि 8 सकारात्मक पूर्णांकों का योग 7 नहीं हो सकता है।
  • m=10और n=4बन जाएगा 3, 3, 2, 2या किसी भी अन्य क्रमपरिवर्तन

नियम

  • इनपुट और आउटपुट दोनों ही सकारात्मक पूर्णांक के बारे में हैं।
  • या तो आउटपुट में सभी मान समान मूल्य हैं या अंतर ठीक 1 है।
  • सूची में मूल्यों का क्रम महत्वपूर्ण नहीं है।
  • सूची में मानों का योग बराबर है m।
  • जब यह हल नहीं होता है, तो एक त्रुटि या एक गलत मान उत्पन्न करें (उदाहरण के लिए m = 7 और n = 8 के मामले में)।
  • अन्य नियमों के परिणामस्वरूप m=8और (नहीं ) के n=3किसी भी क्रमपरिवर्तन को उत्पन्न करेगा3, 3, 22, 2, 4

विजेता

यह कोड-गोल्फ है, इसलिए सबसे छोटा वैध उत्तर - बाइट्स में मापा जाता है - जीतता है।

code-golf  number 
— क्रिस्टियान वेस्टरबेक
स्रोत
मैं मान रहा हूं कि शून्य सकारात्मक नहीं है?
— द लीथेलकोडर
वास्तव में यह है: en.wikipedia.org/wiki/Integer#Order-theoretic_properties
— क्रिस्टियान वेस्टरबेक
1
@ मैं कोई गणितज्ञ नहीं हूं, लेकिन मैंने जो पढ़ा है, वह आमतौर पर संदर्भ पर निर्भर करता है। कुछ कहते हैं कि यह अहस्ताक्षरित है, कुछ सकारात्मक और नकारात्मक दोनों, कुछ सकारात्मक आदि
— TheLethalCoder
1
@ TheLethalCoder इस बीच, जावा (और सामान्य रूप से फ्लोटिंग पॉइंट) में, float a = -0f, b = 0f; System.out.println(a == b); System.out.println(a + "," + b);... उत्पादन trueऔर -0.0,0.0। देखें, सकारात्मक 0 और नकारात्मक 0 स्पष्ट रूप से दो अलग-अलग संख्या हैं ... कार्यान्वयन ऐसा कहता है!
— सुकराती फीनिक्स
1
— q

जवाबों:

2

गैया , 4 बाइट्स

…÷l¦

इसके लिए लगभग एक बिल्ट-इन है ...

व्याख्या

…     Get the range [0 .. m-1].
 ÷    Split into n roughly even length chunks. Throws an error if the number of chunks if 
       more than the list's length.
  l¦  Get the length of each chunk.
— बिजनेस कैट
स्रोत
मुझे लगा कि 05AB1E के साथ एक 4 बाइट समाधान भी था। अब जब यह चला गया है, तो मेरे लिए यह तय करना आसान हो गया है। बधाई और धन्यवाद!
— क्रिस्टियान वेस्टरबेक
5

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

#>#2&&Last@IntegerPartitions@##1&

इनपुट

[६३, ११]

उत्पादन

{6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5}

जब यह सॉल्व नहीं होता है तो आउटपुट गलत हो जाता है

— J42161217
स्रोत
5

MATL , 7 बाइट्स

:gie!Xs

जब वहाँ कोई समाधान नहीं है उत्पादन जो है कम से कम एक शून्य से युक्त एक सरणी, है falsy Matl में।

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

व्याख्या

आदानों पर विचार करें m = 10और n = 4।

:      % Implicitly input m. Push [1 2 ... m]
       % STACK: [1 2 3 4 5 6 7 8 9 10]
g      % Logical: convert nonzeros to 1
       % STACK: [1 1 1 1 1 1 1 1 1 1]
i      % Input n
       % STACK: [1 1 1 1 1 1 1 1 1 1], 4
e      % Reshape into matrix with n rows, padding with zeros
       % STACK: [1 1 1;
                 1 1 1;
                 1 1 0;
                 1 1 0]
!      % Transpose
       % STACK: [1 1 1 1;
                 1 1 1 1;
                 1 1 0 0]
Xs     % Sum of each column. Implicitly display
       % STACK: [3 3 2 2]
— लुइस मेंडो
स्रोत
4

NDD लगाने के बाद चारकोल , 15 बाइट 1 को

¿÷ＮＮＩＥＩη÷⁺ＩθιＩη

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

अगर कोई समाधान नहीं है तो कुछ भी नहीं। से लिंक करेंवर्बोज़ संस्करण ।

1 एनडीडी = नील-प्रेरित विकास।

मेरा पिछला जवाब:

चारकोल , 32 27 24 20 बाइट्स

ＮμＮν¿÷μνＩＥν⁺÷μν‹ι﹪μν

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

अगर कोई समाधान नहीं है तो कुछ भी नहीं। वर्बोज़ संस्करण से लिंक करें ।

निस्संदेह, मैं इसे नील की मदद के बिना नहीं पा सकता था।

— चार्ली
स्रोत
Castऑपरेटर को हटाना किसी कारण से काम करता है, लेकिन यह एक आदर्श एल्गोरिथ्म नहीं है ... मेरे पास 16-बाइट समाधान है।
— नील
@ नील चैलेंज स्वीकार किया!
— चार्ली
मुझे पूर्वनिर्धारित चर पसंद है, लेकिन अब यह जानना कि Castसूचियों पर काम करता है मैं नीचे 11 बाइट्स के लिए हूं ...
— नील
@ नील और मैं अभी भी उपयोग करने में असमर्थ हूं Map, पृथ्वी पर यह कैसे काम करता है ??
— चार्ली
Mapforउसी लूप वेरिएबल का उपयोग करने के लिए, नीचे के अभिव्यक्ति संस्करण की तरह है । इसलिए आपके उदाहरण में, हर बार किसी अभिव्यक्ति को किसी सूची में धकेलने के बजाय, Mapस्वचालित रूप से उन्हें एकत्र करता है और परिणामों की सूची का मूल्यांकन करता है।
— नील
3

आर , 33 बाइट्स

function(m,n)diff(trunc(0:n*m/n))

लुइस मेंडो के ऑक्टेव उत्तर का एक बंदरगाह । बहुत दुख की बात है कि यह मेरे पिछले उत्तर की तुलना में लगभग 50% कम है।

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

पिछला उत्तर, 63 बाइट्स:

function(m,n,o=rep(m%/%n,n),d=m-sum(o))o+c(rep(0,n-d),rep(1,d))

एक अनाम फ़ंक्शन जो दो (अनिवार्य) तर्कों mऔर n, दो वैकल्पिक लोगों को लेता है जो गोल्फिंग उद्देश्यों के लिए हैं। बढ़ते हुए क्रम में एक वेक्टर लौटाता है। विफलता के लिए, पहला मूल्य होगा 0, जो आर में गलत है, क्योंकि ifकेवल वेक्टर के पहले मूल्य (एक चेतावनी के साथ) का उपयोग करता है।

यह अनिवार्य रूप से निम्नलिखित फ़ंक्शन के बराबर है:

function(m,n){o=rep(m%/%n,n)
d=m-sum(o)
o+c(rep(0,n-d),rep(1,d))}

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

— ग्यूसेप
स्रोत
pryr::f(diff(trunc(0:n*m/n)))काम करता है और कम है!
— JAD
2

जेली , 7 6 बाइट्स

:ȧœsL€

इसे ऑनलाइन आज़माएं! झूठा के लिए कुछ भी नहीं आउटपुट।

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

:ȧœsL€    Main link. Arguments: m (integer), n (integer)
:         Integer division. Yields 0 if m < n; a positive integer otherwise.
 ȧ        Logical AND. Yields 0 if m < n; m otherwise.
  œs      Split into n roughly equal groups. Since the left argument is an integer,
          this implicitly converts it to [1..m] (or [] for 0) before splitting.
    L€    Length of €ach. If the inputs were 7 and 3, the previous result would be
          [[1,2,3],[4,5],[6,7]], so this would give [3,2,2].
— ETHproductions
स्रोत
2

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

:Prompt M,N
:N(M≥N
:int(Ans⁻¹randIntNoRep(M,M+N-1

रिटर्न ईआरआर: त्रुटि पर 0 से विभाजित करें

— ओकी
स्रोत
2

ऑक्टेव , 24 बाइट्स

@(m,n)diff(fix(0:m/n:m))

कोड एक अनाम फ़ंक्शन को परिभाषित करता है। आउटपुट एक संख्यात्मक सरणी (पंक्ति वेक्टर) है। जब कोई है इस सरणी कम से कम एक शून्य है, जो होता है falsy सप्टक में।

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

व्याख्या

0:m/n:mकी एक सरणी का उत्पादन n+1से मूल्यों 0को mकदम के साथ m/n। fixप्रत्येक प्रवेश की ओर गोल 0, और diffलगातार अंतर की गणना करता है।

उदाहरण के लिए, यहाँ के लिए सभी मध्यवर्ती परिणाम हैं m = 7, n = 3:

>> 0:m/n:m
ans =
         0    2.3333    4.6667    7.0000

>> fix(0:m/n:m)
ans =
     0     2     4     7

>> diff(fix(0:m/n:m))
ans =
     2     2     3
— लुइस मेंडो
स्रोत
शून्य युक्त एक सरणी मिथ्या है। यह एक खिंचाव की तरह लगता है, लेकिन मैं ऑक्टेव को भी नहीं जानता। जावास्क्रिप्ट से अपने coercions के साथ आ रहा है, मैं कहूंगा कि नरक क्यों नहीं। मुझ से +1।
— क्रिश्चियन वेस्टेरबेक
@ChristiaanWesterbeek धन्यवाद! यह अजीब लगता है अगर आप अन्य भाषाओं से आते हैं, लेकिन यह कैसे MATLAB / ऑक्टेव में है
— लुइस मेंडू
2

हास्केल , 93 89 88 87 86 71 बाइट्स

m!n|n<=m=e$m:(0<$[2..n])
e(a:b:x)|b<a=e$a-1:e(b+1:x)
e(a:x)=a:e x
e x=x

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

व्याख्या

यहाँ मुख्य कार्य है e। eएक सूची लेगा और अनिवार्य रूप से बाएं से दाएं एक रोलिंग पिन चलाएगा। जबकि सूची में एक तत्व है जो अपने पड़ोसी से दाएं से बड़ा है और हम इसे दाईं ओर से स्थानांतरित करेंगे।

अब हमें बस इतना करना है कि इस फंक्शन को एक पर्याप्त रूप से लॉप्सर्ड सूची में फीड करें और इसे जादू करने की अनुमति दें। हम जो सूची चुनेंगे, mउसके बाद n-1शून्य होगा। चूंकि यह बनाना आसान है।

आखिरी चीज जो हमें करने की ज़रूरत है वह यह सुनिश्चित करना है कि त्रुटि मामले को संभाला जाए। इसके लिए हम केवल एक Non-exhaustive patterns in functionएरर को तब तक फेंकते हैं जब तक कि यह त्रुटि न हो m>n।

— पोस्ट रॉक गार्फ हंटर
स्रोत
मुझे लगता है कि आप error[]इसके बजाय गैर-निकास पैटर्न के साथ असफल होने से छुटकारा पा सकते हैं m!n|m>n=e$m:replicate(n-1)0:।
— लकोनी
से भी (0<$[1..n-1])छोटा है replicate(n-1)0।
— लकोनी
2

सी # (.NET कोर) , 86 82 71 बाइट्स

using System.Linq;a=>b=>new int[b].Select((x,i)=>(i<a%b?1:0/(a/b))+a/b)

अमान्य इनपुट के लिए एक त्रुटि फेंकता है।

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

-4 बाइट्स TheLethalCoder के लिए धन्यवाद

-11 बाइट्स ओलीवियरग्रेगायर के लिए धन्यवाद

— LiefdeWen
स्रोत
1
यह इस समय केवल एक कोड स्निपेट है; आपको बस इसे एक अनाम फ़ंक्शन या a=>b=>शुरुआत में लपेटने की आवश्यकता है ।
— द लीथेलकोडर
@TheLethalCoder हम्म आप निश्चित हैं? using System.Collections.Genericअगर मैं वापस लौटता हूं तो क्या मुझे जोड़ने की जरूरत नहीं है IEnumerable<int>?
— LiefdeWen
मुझे वैसे भी गलत मिला क्योंकि आप एक सरणी लौटा रहे हैं (मैं टर्नरी के पहले भाग को गलत बताता हूं)। लेकिन केवल अगर वह आपके कोड में दिखाता है और जैसा IEnumerable<int>कि फ़ंक्शन परिभाषा में होता है, आपको इसे शामिल करने की आवश्यकता नहीं होगी using।
— TheLethalCoder
नहीं, कोड के बिना आपका टिप अभी भी अच्छा है ।ToArray () अभी भी संकलित है।
— लाईफ़डेवेन जूथ
1
@ OlivierGrégoire आप सही हैं, क्षमा करें और धन्यवाद।
— LiefdeWen
2

हास्केल, 48 बाइट्स

m#n|m>=n=iterate(\(a:b)->b++[a+1])(0<$[1..n])!!m

nशून्य की सूची के साथ शुरू करें । बार- mबार दोहराएं : पहला तत्व लें, एक जोड़ें और इसे सूची के अंत में रखें।

यदि एक पैटर्न मैच त्रुटि के साथ विफल रहता है n < m।

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

— nimi
स्रोत
1

ब्रिंगोल्फ , 30 बाइट्स

.M>.M/v.mR>[.]$_v%!?[R1+>v]|R=

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

रिवर्स ऑर्डर में इनपुट लेता है ( nपहला इनपुट है, mदूसरा है)

mद्वारा विभाजित n, परिणाम nसमय को डुप्लिकेट करता है, फिर एक m % nबार के माध्यम से और वेतन वृद्धि करता है

— Skidsdev
स्रोत
1

बैच, 71 बाइट्स

@if %1 geq %2 for /l %%i in (1,1,%2)do @cmd/cset/an=(%1+%%i-1)/%2&echo(

cmd/cset/aकिसी विभाजक का उत्पादन नहीं करता है, इसलिए मुझे उपयोग करना पड़ता है echo(( (मुद्रण से बचा जाता है ECHO is on.)।

— नील
स्रोत
1

PHP> = 7.1, 62 बाइट्स

for([,$s,$n]=$argv;$n;)$s-=$r[]=$s/$n--^0;$r[0]?print_r($r):0;

PHP सैंडबॉक्स ऑनलाइन

— जार्ग हुल्सरमन
स्रोत
सैंडबॉक्स में अपने लिंक पर क्लिक किया, एक्सक्यूट कोड पर क्लिक किया और मुझे एक पार्स त्रुटि मिली।
— क्रिश्चियन वेस्टरबेक
@ChristiaanWesterbeek PHP 7.0.3 में सैंडबॉक्स डिफॉल्ट करता है।
— नील
1
अन्य भाषाओं जैसे कि ऑक्टेव और MATL में एक सरणी में एक शून्य को झूठा माना जाता है, लेकिन मैं इसे php के मामले में नहीं मानता हूं। मुझे लगता है कि कार्यक्रम में लिखे गए भाषा के नियमों के भीतर आउटपुट को झूठा होना पड़ता है।
— क्रिश्चियन वेस्टेरबेक
1
@ChristiaanWesterbeek निश्चित
— Jörg Hülsermann
1

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

lambda m,n:(m%n*[m/n+1]+[m/n or _]*n)[:n]

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

NameError जब असंभव हो।

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

lambda m,n:[c/n for c in range(m,m+n,m>=n)]

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

ValueError जब असंभव हो।

— XNOR
स्रोत
NameErrorत्रुटि के माध्यम से बाहर निकलने के लिए उपयोग करने के बारे में कभी नहीं सोचा है
— फेलिप नार्दी बतिस्ता
1

जावास्क्रिप्ट (ईएस 6), 57 56 53 41 बाइट्स

m=>n=>m>=n&&[...Array(n)].map(_=>m++/n|0)

उत्तर में अब मूल्य बनाने का स्मार्ट तरीका शामिल है। धन्यवाद @ नील

प्रयोग

f=m=>n=>m>=n&&[...Array(n)].map(_=>m++/n|0)

f(6)(3) // [2, 2, 2]
f(7)(3) // [3, 2, 2]
f(7)(2) // [4, 3]
f(7)(1) // [7]
f(7)(8) // false
f(8)(3) // [3, 3, 2]

इतिहास

पहले मेरा

(m,n)=>m>=n&&Array(n).fill(~~(m/n)).map((v,i)=>v+(i<m%n))

(m,n)=>m>=n&&Array(n).fill().map((v,i)=>~~(m/n)+(i<m%n))

फिर प्रसार ऑपरेटर जोड़ा और @Arnauld द्वारा इत्तला दे दी सिंटेक्स

m=>n=>m>=n&&[...Array(n)].map((v,i)=>~~(m/n)+(i<m%n))
— क्रिस्टियान वेस्टरबेक
स्रोत
1
_=>m++/n|0बाइट्स का एक गुच्छा बचाता है।
— नील
0

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

KE?>KQ0lMcK*d

इसे ऑनलाइन आज़माएं! 0त्रुटि पर आउटपुट ।

धोखा, 6 बाइट्स

lMcE*d

इसे ऑनलाइन आज़माएं! सरणी में 0त्रुटि होती है। अफसोस की बात है कि यह अजगर में गलत नहीं है ।

व्याख्या

KE?>KQ0lMcK*dQ    # Implicit input Q for m
KE                # Store n in K
           *d     # Generate a string of length Q containing only spaces
         cK       # Chop this string in K pieces of equal sizes, initial piece longer if necessary
       lM         # For each string, compute the length. Here we already have our result. However if the array contain a zero, we must output a falsy value
  ?>KQ            # If K > Q...
      0           # Then display zero, otherwise display the array
— जिम
स्रोत
0

सीजाम , 13 12 बाइट्स

{_2$>/,/z:,}

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

यह एक गुमनाम ब्लॉक है जो इनपुट के रूप में लेता है n m स्टैक पर । यह एक अच्छा जवाब होता, लेकिन त्रुटि से निपटने की आवश्यकता ने इसे पूरी तरह से मार दिया।

जब इसे हल करना संभव नहीं है तो एक विभाजन-दर-शून्य के साथ त्रुटियां।

व्याख्या

{   e# Stack:                | 3 10
 _  e# Duplicate:            | 3 10 10
 2$ e# Copy from back:       | 3 10 10 3
 >  e# Greater than:         | 3 10 1 (true)
 /  e# Divide:               | 3 10
    e# This will cause an error on invalid input.
 ,  e# Range:                | 3 [0 1 2 3 4 5 6 7 8 9]
 /  e# Split on nth element: | [[0 1 2] [3 4 5] [6 7 8] [9]]
 z  e# Transpose array:      | [[0 3 4 9] [1 4 7] [2 5 8]]
 :, e# Length of each:       | [4 3 3]
}

यदि त्रुटि से निपटने की आवश्यकता को हटा दिया जाता है, तो इसे 7 बाइट्स तक छोटा किया जा सकता है, जो कि 40% से अधिक की कमी है:

{,/z:,}
— फल तोड़ना
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.