एक सरणी से विखंडू बनाएँ

21

आपका कार्य एक प्रोग्राम लिखना है, जिसने एक सरणी और एक संख्या दी है, आपको सरणी को आकार में बदलकर संख्याओं में विभाजित करना होगा।

नियम

आपके कार्यक्रम को एक सरणी मिलेगी A, साथ ही एक सकारात्मक पूर्णांक भी मिलेगा n। सरणी को लंबाई के टुकड़ों में विभाजित किया जाना चाहिए n, अगर स्ट्रिंग की लंबाई nकिसी भी बचे हुए से विभाज्य नहीं है , तो अंत में इसे अपना हिस्सा माना जाना चाहिए।

  • यदि nसरणी की लंबाई से अधिक है A, तो आपको सरणी वापस करने की आवश्यकता होगी A, उदाहरण के लिए: यदि n = 4और array A = [1,2,3], आपको वापस लौटना चाहिए[1,2,3]

  • सरणी में संख्या के बजाय किसी भी प्रकार हो सकता है।

  • आपको किसी भी वस्तु के क्रम (या दिशा) को बाएं से दाएं नहीं बदलना चाहिए। उदाहरण के लिए if n = 2और A= [1,2,3]। इसके बजाय कोई भी परिणाम [[1,2],[3]]अमान्य होगा।

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

n   A               Output

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

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

code-golf  array-manipulation 
— चौ जियांग
स्रोत
4
यदि हमें लौटने की आवश्यकता nसे अधिक है तो क्या आप सुनिश्चित हैं कि आपका मतलब नहीं है ? AA[A]
— आदम
9
@ आँचियांग मुझे अभी भी लगता है कि बहुत बड़े nको लौटना चाहिए [A], जैसे [[1,2,3]]। क्या होगा अगर nवास्तव में की लंबाई है A?
— आदम
4
@ आचुआनयांग एडम सही इमो है। वापसी मूल्य सुसंगत होना चाहिए।
— जोना
1
@chaugiang n कभी 1 बराबर हो सकता है ?
— DJMcMayhem
4
एक जोरदार टाइप की गई भाषा में, इसके Aबजाय वापस लौटना असंभव है [A] , जो बहुत सी भाषाओं को बाहर कर देगा।
— dfeuer

जवाबों:

9

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

के रूप में इनपुट लेता है (n)(array)।

n=>g=a=>a+a&&[a.splice(0,n),...g(a)]

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

टिप्पणी की गई

n =>                  // n = chunk size
  g = a =>            // g = recursive function taking the array a[]
    a + a             // if a[] is empty, stop recursion and return an empty string
    &&                // otherwise, return an array made of:
    [ a.splice(0, n), //   the next chunk
      ...g(a)         //   followed by the result of a recursive call
    ]                 //   (the last call leads to ...'', which adds nothing)
— Arnauld
स्रोत
अब यह एक साफ और स्वच्छ समाधान है, और मैंने पुनरावर्ती गुमनाम कार्यों के बारे में भी सीखा!
— जो व्यक्ति
9

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

⊢⊂⍨(⍴⊢)⍴1↑⍨⊣

मूल रूप से सभी गोल्फिंग (और मूल रूप से वर्तमान में मेरे पास मौजूद सभी APL ज्ञान के लिए _ _>) करने के लिए Adám का बड़ा धन्यवाद ।

व्याख्या

 ⊂⍨           Partitioned enclose (commuted, i.e. left and right switched) - for each ⍵ in left, ⍺ in right, if ⍺ = 0, create a new sub-array, push ⍵ to latest sub-array
⊢             Right argument of entire expression
       ⍴      Reshape - Change size of right into dimensions specified by left
   (⍴ )       Shape of (here, there is only one dimension - length)
     ⊢        Right argument of entire expression
         ↑⍨   Take (commuted) - takes ⍺ elements from left where ⍺ is right. Extra elements (zeroes here) are automatically added
        1     1
           ⊣  Left argument of entire expression

क्रियान्वयन

तर्क 2, 1 2 3 4 5 6 7। ध्यान दें कि एपीएल सरणियाँ फार्म के हैं a b c, वैकल्पिक आसपास के कोष्ठकों के साथ।

           ⊣  2
        1     1
         ↑⍨   1↑2 = 1 0
     ⊢        1 2 3 4 5 6 7
   (⍴ )       ⍴1 2 3 4 5 6 7 = 7
       ⍴      7⍴1 0 = 1 0 1 0 1 0 1
⊢             1 2 3 4 5 6 7
 ⊂⍨           1 0 1 0 1 0 1⊂1 2 3 4 5 6 7 = (1 2)(3 4)(5 6)(7)

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

— ASCII-केवल
स्रोत
7
आपके पहले एपीएल जवाब पर बधाई। और अच्छी तरह से समझाया भी! यहाँ, एक APL पाई है: 🥧
— Adám
9

पायथन 3 , 61 बाइट्स

lambda A,n:[A,[A[x:x+n]for x in range(0,len(A),n)]][n<len(A)]

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

N> = len (A) के लिए वैध उत्पादन के लिए हेनरी टी के मौजूदा पायथन 3 समाधान को संशोधित करता है ।
टिप्पणी विशेषाधिकारों की कमी के कारण अपने स्वयं के उत्तर के रूप में पोस्टिंग।

— मोनिका को बहाल करो
स्रोत
7

प्रोलोग (एसडब्ल्यूआई) , 90 84 61 बाइट्स

कोड:

[]*_*[].
L*N*[P|R]:-length(P,N),append(P,T,L),T*N*R;P=L,R=[].

इनपुट प्रारूप थोड़ा अजीब हो सकता है, लेकिन यह है:

A * n * Result.

उदाहरण के लिए, इनपुट के लिए: 

n = 2
 A = [1, 2, 3, 4, 5, 6]

आपको उपयोग करने की आवश्यकता होगी [1, 2, 3, 4, 5, 6] * 2 * Result.।

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


Ungolfed संस्करण:

divide([], _, []).
divide(List, N, [Prefix | Result]) :-
    length(Prefix, N), append(Prefix, Remaining, List), divide(Remaining, N, Result) 
  ; Prefix = List, Result = [].

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

— अदनान
स्रोत
6

PHP, 15 बाइट्स

$f=array_chunk;

PHP की आवश्यकता है 7. के साथ कॉल करें $f(ARRAY, N)।

— टाइटस
स्रोत
6
मुझे नहीं लगता कि आपको एक बिलिन को दूसरा नाम देना आवश्यक है, इसलिए यह सिर्फ 11 स्कोर है, है ना?
— नील
@ नील मैंने सोचा था कि एक निषिद्ध ढोंगी हो सकता है ; लेकिन आप सही हो सकते हैं।
— टाइटस
6

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

{*.batch($_)}

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

batchअंतर्निहित फ़ंक्शन को लपेटकर करी फ़ंक्शन ।

— nwellnhof
स्रोत
क्या उन्होंने उस बग को ठीक किया जहां आपके पास ;जो भी कोड था उसके बाद?
— जो किंग
2
@JoKing नहीं। आपको केवल तभी पास करने की आवश्यकता होगी ;जब आप या उसके साथ तर्क पारित $^aकर रहे हों@_ ।
— nwellnhof
5

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

i,j=input()
while j:print j[:i];j=j[i:]

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

मानता है कि प्रति पंक्ति 1 हिस्सा स्वीकार्य आउटपुट है।

— ElPedro
स्रोत
4
36 बाइट्स एक पुनरावर्ती लैम्ब्डा फ़ंक्शन के रूप में
— ओव्स
@ नोव्स - यदि आप चाहें तो बहुत अच्छा और आपके जवाब के रूप में पोस्ट करने के लिए बहुत अलग हैं।
— ElPedro
5

ब्रेनफक, 71 बाइट्स

,[>+>+<<-]>>>,[<[>.,<-]>>>++++[<++++++++>-]<.[-]<<<[<+>>+<-]<[->+<]>>>]

डन्नो अगर यह मायने रखता है या नहीं ... इनपुट प्रारूप:

<character whose ascii is n>AAAAAAAAAAAAA
For example, in the input:
 1234567890123492034
n is 32 since the ASCII value of space is 32

हर बार nपात्रों के पास जाने के लिए इनपुट लेता है और एक स्थान पर रखता है

स्पष्टीकरण (कोई अल्पविराम नहीं है क्योंकि यह कार्यक्रम को तोड़ देगा):

, take n
[>+>+<<-] copy into next two cells (destroys original)
>>>, take first of A into next cell
[ while that input exists
<[>.,<-] if n is nonzero output take next of A subtract one from n
>>>++++[<++++++++>-]<.[-]< n is zero so put a space
<<[<+>>+<-] copy the old n into surrounding cells
<[->+<] move from first cell to second
>>>] take input, do again
— vityavv
स्रोत
2
71 अक्षरों के लिए रिक्त स्थान निकालें
— MilkyWay90
योग्य, मैंने सोचा कि मैंने उन सभी को हटा दिया, लेकिन मैंने उन पर ध्यान नहीं दिया, धन्यवाद!
— वतावव
कोशिकाओं को पुनर्गठित करने का प्रयास करें जैसे कि आपके द्वारा उपयोग की जाने वाली कोशिकाएँ अधिक सुलभ हैं (उदाहरण के लिए, यदि इनपुट सेल (जहाँ आप ,अधिक उपयोग करते हैं) का उपयोग अधिक किया जाता है तो इसे एक सेल लगाया जा सकता है जो कि इसे रखे जाने की तुलना में एक्सेस करने में आसान है अन्य कोशिकाओं में) या एक bruteforcer का उपयोग करें। मैं BF में गोल्फिंग में कुशल नहीं हूं, इसलिए ये सुझाव सहायक नहीं हो सकते हैं।
— मिल्कीवेय 90
अब तक मेरे पास n n n A spaceमेरा सेल सेटअप है, अगर आप बेहतर तरीके से सोच सकते हैं ...
— vityavv
A space n n n ...काम कर सकता है (या space A n n n...)?
— मिल्कीवेय 90
4

चारकोल , 1 बाइट

⪪

इसे ऑनलाइन आज़माएं! चारकोल का डिफ़ॉल्ट I / O स्ट्रिंग्स को छोड़कर किसी भी चीज़ का उपयोग करके प्रदर्शित करना मुश्किल बनाता है। यदि आप एक पूर्ण कार्यक्रम चाहते हैं जो संख्यात्मक सूचियों और आउटपुट स्वरूपित सूचियों को लेता है तो यह निम्नानुसार किया जा सकता है:

Ｅ⪪ＡＮ⪫ι,

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

  Ａ      Input array
 ⪪       Split into chunks of
   Ｎ     Input number
Ｅ       Map over chunks
     ι  Current chunk
    ⪫   Joined with
      , Literal `,`
        Implicitly print each chunk on its own line
— नील
स्रोत
4

सी # (विज़ुअल सी # इंटरएक्टिव कंपाइलर) , 78 77 43 बाइट्स

a=>b=>{int i=0;return a.GroupBy(_=>i++/b);}

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

मुझे लगता है कि हमें केवल लिखने में सक्षम होना चाहिए int i;क्योंकि 0 इंट का डिफ़ॉल्ट है। मैंने इसे त्रुटि से बचने के लिए दिया error CS0165: Use of unassigned local variable 'i':।

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

जे , 4 बाइट्स

<\~-

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

सरणी को बाएं आर्ग के रूप में ले जाता है और दायें आर्ग के रूप में चंक का आकार।

एक नकारात्मक तर्क के साथ एक डाईएडिक हुक और इन्फिक्स क्रियाविशेषण का उपयोग करता है , जो कि परिभाषा के अनुसार हम चाहते हैं।

नोट: रिटर्न प्रकार को बॉक्सिंग किया जाना चाहिए क्योंकि J केवल समान आकार की वस्तुओं की तालिका की अनुमति देता है।

— जोनाह
स्रोत
3

PHP , 45 बाइट्स

function f($a,$b){return array_chunk($a,$b);}

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

— लुइस फेलिप डी जीसस मुनोज
स्रोत
3
क्या सिर्फ array_chunkएक मान्य उत्तर होगा?
— अरनुलद
@Arnauld मुझे नहीं पता। इससे पहले कि मैं काम में इसका इस्तेमाल करते हुए php में कभी गोल्फ नहीं दिया।
— लुइस फेलिप डी जीसस मुनोज
मुझे 100% यकीन नहीं है, लेकिन हम एक स्ट्रिंग के लिए अघोषित चर के निहित रूपांतरण का दुरुपयोग कर सकते हैं और ऐसा कुछ कर सकते हैं ।
— अरनुलद
(इरेटम: मेरा मतलब अपरिभाषित स्थिरांक है )
— अरनौलड
3

जावा 10, 106 80 बाइट्स

L->n->{for(int l=L.size(),i=0;i<l;)System.out.print(L.subList(i,(i+=n)<l?i:l));}

विखंडन के बिना विखंडू को मुद्रित करता है।

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

106 बाइट्स:

L->n->{var r=new java.util.Stack();for(int l=L.size(),i=0;i<l;)r.add(L.subList(i,(i+=n)<l?i:l));return r;}

वास्तव में सूची की एक सूची देता है।

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

स्पष्टीकरण:

L->n->{                       // Method with List and integer parameters and List return-type
  var r=new java.util.Stack();//  Create an empty List
  for(int l=L.size(),         //  Determine the size of the input-List
      i=0;i<l;)               //  Loop `i` in the range [0, size):
    r.add(                    //   Add to the result-List:
      L.subList(i,            //    A sublist of the input-list in the range from `i`
        Math.min(i+=n,l)));   //    to the minimum of: `i` + input-integer or the size
                              //    (and increase `i` by the input-integer at the same)
  return r;}                  //  Return the List of Lists of integers as result
— केविन क्रूज़सेन
स्रोत
3

क्लोजर, 14 बाइट्स

#(partition %)

मुझे लगता है कि बनाया

— nihilazo
स्रोत
स्वागत है। फ़ंक्शन को दो तर्क लेने चाहिए: विभाजन का हिस्सा और चंक की लंबाई। यदि विभाजन का उपयोग करते समय अंतिम हिस्सा "पूर्ण" नहीं है तो भी क्या होता है?
— निकोनिरह
3

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

import Data.Lists
chunksOf

यहां एक और दिलचस्प संस्करण है, बस कुछ और बाइट्स के लिए (प्रत्येक समाधान में पांच बाइट्स के लिए निम्मी के लिए धन्यवाद):

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

n![]=[]
n!x=take n x:n!drop n x

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

— dfeuer
स्रोत
मुझे लगता है कि आप कर सकते हैं
— aloisdg
1
n!x=take n x:n!drop n x। Data.Listsभी प्रदान करता है chunksOf।
— nimi
3

जेली , 1 बाइट

s

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

हालांकि प्रिंटर बनाता है कि यह एकल-तत्व विभाजन की सूची में लिपटे हुए नहीं हैं, वे वास्तव में हैं।

— Ven
स्रोत
1
यह रात एक बेहतर आउटपुट देती है जैसा कि दिखाती है कि एकल तत्व सरणियाँ वास्तव में सरणियाँ हैं।
— निक केनेडी
Er, डाउनवोट है क्योंकि मैंने @Nick कैनेडी का लिंक नहीं जोड़ा है?
— वेन
निश्चित रूप से मुझ से नहीं
— निक केनेडी
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.