पूर्णांक L, और पूर्णांक की एक सूची को देखते हुए N, आउटपुट समान लेनगेट्स के सब्लिस्ट Lमें Nविभाजित होता है।

गैर-विभाज्य लंबाई

यदि Nकी लंबाई को विभाजित नहीं करता है L, तो यह संभव नहीं है कि सभी उपविदों की लंबाई समान हो।

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

इसका मतलब यह है कि Lपिछले एक को छोड़कर सभी उपविभाग लंबाई के होने चाहिए length(L) // N, जहां //फ्लोर्ड डिवीजन (जैसे 3//2 = 1) है।

कुछ िनयम

L खाली हो सकता है।
N >= 1।
आप किसी भी अंतर्निहित का उपयोग कर सकते हैं।
आप STDINफ़ंक्शन तर्क, या कुछ समान के माध्यम से इनपुट ले सकते हैं ।
आप आउटपुट को प्रिंट कर सकते हैं STDOUT, इसे किसी फ़ंक्शन या किसी समान से वापस कर सकते हैं।
जब तक आप अपनी भाषा में सूचियों और पूर्णांकों का सबसे प्राकृतिक प्रतिनिधित्व करते हैं, तब तक आप सूचियों और पूर्णांक के लिए किसी भी प्रारूप को चुन सकते हैं।

परीक्षण के मामलों

Input:  [1,2,3,4], 2
Output: [[1,2],[3,4]]

Input:  [-1,-2,3,4,-5], 2
Output: [[-1,-2],[3,4,-5]]

Input:  [1,2,3,4], 1
Output: [[1,2,3,4]]

Input:  [4,8,15,16,23,42], 5
Output: [[4],[8],[15],[16],[23,42]]

Input:  [4,8,15,16,23,42], 7
Output: [[],[],[],[],[],[],[4,8,15,16,23,42]]

Input:  [2,3,5,7,11,13,17,19,23], 3
Output: [[2,3,5],[7,11,13],[17,19,23]]

Input:  [], 3
Output: [[],[],[]]

Input:  [1,2,3,4,5,6,7,8], 3
Output: [[1,2],[3,4],[5,6,7,8]]

स्कोरिंग

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

code-golf array-manipulation

— Fatalize
स्रोत

अजगर, 11 10 बाइट्स

1 बाइट @FryAmTheEggman को धन्यवाद ।

cJEt*R/lJQ

परीक्षण सूट।

उल्टे क्रम में इनपुट लेता है।

नमूना इनपुट:

5
[1,2,3,4,5,6,7]

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

[[1], [2], [3], [4], [5, 6, 7]]

व्याख्या

cJEt*R/lJQ     Main function, first input:Q, second input:E.
cJEt*R/lJQQ    Implicit arguments.

c              The function c is special.
               It can chop arrays.
               If the second argument is a list of integers,
               then it chops the first array at the indices
               specified by the second array.

 JE            The first argument is the second input, stored
               to the variable J.

   t*R/lJQQ    This is the second argument.
      /lJQ     Yield length of J, integer-divided by Q.
    *R    Q    Multiply it to the following respectively:
                   [0,1,2,3,...,Q-1]
   t           Then throw away the first element.
               For example, if Q=3 and E=[1,2,3,4,5,6,7,8],
               we would now have [3,6].

— लीक नन
स्रोत

4

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

(a,n,l=a.length/n|0)=>[...Array(n)].map(_=>--n?a.splice(0,l):a)

— नील
स्रोत

2

पायथन, 76 73 बाइट्स

lambda L,N:list(map(lambda x,r=len(L)//N:L[x*r:][:r+(x>N-2)*N],range(N)))

मूल रूप से एक अनाम फ़ंक्शन जो कार्य करता है। बच गए बाइट्स के लिए LeakyNun को धन्यवाद!

— Lause
स्रोत

1

इसके अलावा, PPCG में आपका स्वागत है!

— लीक नून

@LeakyNun नन यह 73 है मुझे वास्तव में लगता है। इसके अलावा यह ज्यादातर मेरी गलती है क्योंकि मैं संपादन करते समय ज्यादा ध्यान नहीं दे रहा था। काम पर कोडगुल्फिंग के जोखिम: पी

— लूज

@ लीक - पहले बिंदु पर - यह काम नहीं करता है। नियमित आइटम के लिए मूल रूप से अभिव्यक्ति [: r] है और अंतिम आइटम के लिए [: r + N], जो कि शेष सभी तत्वों को पकड़ने वाला है। दूसरा बिंदु - मैंने कोशिश की लेकिन मुझे पता है कि मुझे असाइन करने वाले सभी तरीके मेरे कोड से अधिक लंबे हैं।

— जू

यह होगा, लेकिन r * (x> N-2) के मामले में यह [: 0] है, [:] नहीं।

— रोकें

खैर, यहाँ

— लीक नून

2

आम लिस्प, 114 बाइट्स

(defun f(l n &optional(p(floor(length l)n))(i 1))(if(= i n)(list l)(cons(subseq l 0 p)(f(subseq l p)n p(+ i 1)))))

Ungolfed:

(defun f (l n &optional (p (floor (length l) n)) (i 1))
  (if (= i n) (list l)
              (cons (subseq l 0 p)
                    (f (subseq l p) n p (+ i 1))))
  )

उदाहरण कॉल:

(format t "~A~C~C" (f (read) (read)) #\return #\newline)

यहाँ यह कोशिश करो!

मूल रूप से:

यदि हम अंतिम समूह में कटौती कर रहे हैं, तो प्रारंभिक सूची में से जो भी बचा है उसे वापस करें।
अन्यथा p = |L| / Nतत्वों को सूची से बाहर निकालें और शेष पर पुनरावर्ती कॉल के परिणाम में शामिल हों। iस्टॉप कंडीशन के लिए उपयोग किया जाने वाला एक पुनरावृत्ति काउंटर है।

मैंने पहली बार चुनौती को गलत समझा था, यह सोचकर कि कार्यक्रम को समूहों के Nबजाय तत्वों के समूहों का निर्माण करना चाहिए N। वैसे भी, यह संस्करण अतिरिक्त 10 बाइट्स के लिए काम करता है। लिसप इस बार नहीं जीतेंगे लेकिन मैं वास्तव में इस मौके को नहीं चूक सकता: ')

— जॉन डब्ल्यूएच स्मिथ
स्रोत

2

हास्केल, 69 67 बाइट्स

a%b=a#b where l#1=[l];l#n|(h,t)<-splitAt(div(length a)b)l=h:t#(n-1)

प्रयोग उदाहरण: [1,2,3,4] % 3-> [[1],[2],[3,4]]।

@ Xnor के उत्तर के समान एक सरल पुनरावर्ती दृष्टिकोण ।

संपादित करें: @Will Ness ने 2 बाइट्स बचाए। धन्यवाद!

— nimi
स्रोत

h:t#(n-1)भी काम करता है।

— विल नेस

1

PowerShell v2 +, 125 बाइट्स

param($l,$n)if($p=[math]::Floor(($c=$l.count)/$n)){1..$n|%{$l[(($_-1)*$p)..((($_*$p-1),$c)[!($_-$n)])]}}else{(,''*($n-1))+$l}

बहुत लंबा लगता है, लेकिन मैं स्लाइसिंग को खुशी से काम करने का एक तरीका नहीं बता सकता हूं यदि आउटपुट में खाली सरणियां हैं, तो मुझे उन मामलों को संभालने के लिए इनकैप्सुलेटिंग if/ की आवश्यकता है else। इसके अतिरिक्त, चूंकि .ToString()कंसोल आउटपुट के माध्यम से सरणियों के लिए पॉवरशेल का डिफ़ॉल्ट थोड़ा अजीब लग सकता है, आप -join','कंसोल पर न्यूलाइन-अलग होने के बजाय एरे को अलग-थलग दिखाने के लिए एक पर सौदा कर सकते हैं । मैंने किया है कि आउटपुट को और अधिक स्पष्ट करने के लिए नीचे दिए गए उदाहरणों में, लेकिन आप ऐसा नहीं करना चाहेंगे कि यदि आप आउटपुट को किसी अन्य कमांड के पिकअप के लिए छोड़ रहे हैं।

व्याख्या

param($l,$n)क्रमशः विभाजन की सूची और संख्या के लिए इनपुट लेता है। हम फिर एक if/ elseबयान दर्ज करते हैं। यदि प्रत्येक विभाजन का आकार, $pगैर-शून्य है ( रास्ते में $cआने .countके लिए सहायक की स्थापना ), तो हम अंदर हैं if।

अंदर ifहै, हम से पाश 1के $nसाथ |%{...}, और प्रत्येक पुनरावृत्ति हम एक बहुत जटिल दिखने सरणी टुकड़ा कर रहे हैं $l[(($_-1)*$p)..((($_*$p-1),$c)[!($_-$n)])]। पहला पैरेन्स हमारा स्टार्ट इंडेक्स है, जो इस बात पर आधारित है कि हम किस पार्टीशन पर हैं और हमारा विभाजन साइज कितना बड़ा है। हम ..अपने अंत इंडेक्स के साथ, जो एक छद्म-टर्नरी से बनता है । यहां, हम या तो $c(सरणी के शाब्दिक अंत), या हमारे विभाजन की लंबाई के बीच चयन कर रहे हैं , इस आधार पर कि हम अंतिम चंक में हैं $_-$nया नहीं।

अन्यथा, हम अंदर हैं else। हम ,''*अनुरोध के मुकाबले कम से कम एक विभाजन के बराबर अल्पविराम ऑपरेटर के साथ एक खाली सरणी का निर्माण करते हैं , और फिर अंतिम तत्व के रूप में इनपुट सरणी पर काम करते हैं।

उदाहरण

यहाँ मैं ,ऊपर बताए गए अनुसार अलग-अलग न्यूलाइन्स और अलग-अलग तत्वों के साथ विभाजन दिखा रहा हूँ ।

PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 (1,2,3,4) 2
1,2
3,4

PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 (-1,-2,3,4,-5) 2
-1,-2
3,4,-5

PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 (1,2,3,4) 1
1,2,3,4

PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 (4,8,15,16,23,42) 5
4
8
15
16
23,42

PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 (4,8,15,16,23,42) 7






4,8,15,16,23,42

PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 (2,3,5,7,11,13,17,19,23) 3
2,3,5
7,11,13
17,19,23

PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 $null 3



PS C:\Tools\Scripts\golfing>

— AdmBorkBork
स्रोत

1

एफ #, 100 98 बाइट्स

fun n l->
let a=List.length l/n
List.init n (fun i->if i<n-1 then l.[a*i..a*i+a-1] else l.[a*i..])

यदि कोई तत्व या शेष सभी तत्वों को चुनना है, तो एक क्लॉज के साथ F # सूची स्लाइसिंग का उपयोग करना ।

— hlo
स्रोत

1

प्रोलॉग, 100 99 बाइट्स।

n(A,B):-length(B,A).
p(L,K,G):-n(K,G),append(A,[_],G),n(N,L),M is N//K,maplist(n(M),A),append(G,L).

जैसे कॉल करें

? - पी ([1,2,3,4,5,6,7], 3, एक्स)।
एक्स = [[१, २], [३, ४], [५, ६,।]] ।

— विल नेस
स्रोत

0

PHP, 109 बाइट्स

<?for($n=(count($a=$_GET[0]))/($d=$_GET[1])^0;$i<$d;)$r[]=array_slice($a,$i*$n,++$i==$d?NULL:$n);print_r($r);

सभी टेस्टकेस

— जार्ग हुल्सरमन
स्रोत

N-chotomize एक सूची

गैर-विभाज्य लंबाई

कुछ िनयम

परीक्षण के मामलों

स्कोरिंग

अजगर, 11 10 बाइट्स

व्याख्या

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

पायथन, 76 73 बाइट्स

आम लिस्प, 114 बाइट्स

हास्केल, 69 67 बाइट्स

PowerShell v2 +, 125 बाइट्स

व्याख्या

उदाहरण

एफ #, 100 98 बाइट्स

प्रोलॉग, 100 99 बाइट्स।

PHP, 109 बाइट्स