आज रात कार्ड गेम की रात है! आप डीलर हैं और आपका काम खिलाड़ियों को कार्ड देने का कार्यक्रम लिखना है।

कार्ड की एक सरणी और खिलाड़ियों की संख्या को देखते हुए, आपको प्रत्येक खिलाड़ी के लिए कार्ड के सरणी को एक हाथ में विभाजित करने की आवश्यकता है।

नियम

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

यदि n==1, आपको Aकेवल एक तत्व के रूप में सरणी का एक सरणी वापस करना होगा
अगर nकी लंबाई से अधिक है A, तो आप हर हाथ और एक खाली हाथ वापस जाने के लिए की आवश्यकता होगी। यदि n = 4और array A = [1,2,3], आप वापस आ जाएगी [[1],[2],[3]]या [[1],[2],[3],[]]। आप खाली हाथ को खाली, अपरिभाषित या अशक्त के साथ संभालने के लिए स्वतंत्र हैं।
सरणी में संख्या के बजाय किसी भी प्रकार हो सकता है।
आपको व्यवहार करते समय सरणी के क्रम को नहीं बदलना चाहिए। उदाहरण के लिए if n = 2और A= [1,2,3], इसके बजाय कोई भी परिणाम [[1,3],[2]]अमान्य होगा।

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

n   A               Output

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

डेमो कार्यक्रम

def deal(cards, n):
	i = 0
	players = [[] for _ in range(n)]
	for card in cards:
		players[i % n].append(card)
		i += 1
	return players

hands = deal([1,2,3,4,5,6], 2)

print(hands)

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

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

Cha giang द्वारा सरणी से विखंडू बनाएँ से प्रेरित

code-golf array-manipulation

— aloisdg codidact.com पर जा रहा है
स्रोत

1

आपको हर हाथ को वापस करने की आवश्यकता होगी और एक खाली हाथ पिछले परीक्षण मामले के पहले परिणाम की संभावना का खंडन करता है।

— आदम

6

भविष्य में मैं सैंडबॉक्स का उपयोग करने की सलाह दूंगा और समस्याओं को कम करने के लिए अपने प्रश्न को मुख्य पोस्ट करने से पहले सामुदायिक प्रतिक्रिया

— जो किंग

2

@ जॉकिंग मैं पूरी तरह से सहमत हूँ। मुझे नहीं लगा कि मेरे पास ऐसा करने के लिए बहुत कुछ होगा। यह पहले बीटा पर तैनात किए बिना उत्पादों को धकेलने जैसा है। सहायता के लिए धनयवाद।

— aloisdg

1

@aloisdg मैं आपके सुझाए गए वैकल्पिक नियम को पार्स नहीं कर सकता। यदि यह विचार जैसा है कि लोग अक्सर एक सर्कल से निपटते हैं, तो सभी खिलाड़ी जो ज्यादातर कार्ड के साथ समाप्त होते हैं, शुरुआत में होते हैं, और अंत में रहने वाले खिलाड़ियों को कोई कार्ड नहीं मिल सकता है।

— आदम

2

क्या होगा यदि इनपुट सरणी में ए 0?

— झबरा

12

05AB1E , 3 1 बाइट

अदनान के लिए धन्यवाद 2 बाइट्स बचाए

ι

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

ι  # uninterleave

वास्तव में चुनौती क्या माँगता है

— Emigna
स्रोत

5

मुझे लगता है कि यह भी काम करना चाहिए:ι

— अदनान

@ अदनान: हाँ धन्यवाद :) केवल अंतर खाली सूची के लिए है n=7, लेकिन यह एक स्वीकार्य आउटपुट प्रारूप है। मुझे पूरी तरह से याद है कि बिल्ट-इन: /

— Emigna

तो इसके लिए एक अंतर्निहित भाषा है! : D

— aloisdg codidact.com

9

आर , 46 25 बाइट्स

function(A,n)split(A,1:n)

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

splitएस Aद्वारा परिभाषित समूहों में 1:n, रीसाइक्लिंग 1:nजब तक यह साथ लंबाई से मेल खाता है A।

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

7

पर्ल 6 , 33 24 बाइट्स

->\b{*.classify:{$++%b}}

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

बेनामी करी कोड जो एक नंबर लेता है और जो भी लैम्बडा लेता है वह एक सूची लेता है और सूचियों की सूची लौटाता है। यह दूसरा विकल्प लेता है जब सूचियों की लंबाई से बड़ी संख्या दी जाती है, जैसे f(4)([1,2,3])रिटर्न[[1],[2],[3]]

स्पष्टीकरण:

->\b{                  }  # Anonymous code block that takes a number
     *                    # And returns a Whatever lambda
      .classify           # That groups by
               :{$++%b}   # The index modulo the number

— मजाक कर रहा है
स्रोत

7

वोल्फ्राम भाषा (गणितज्ञ) , 28 बाइट्स

(s=#;GatherBy[#2,#~Mod~s&])&

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

— J42161217
स्रोत

बहुत चतुराई से किया!

— ग्रेग मार्टिन

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

— 19

6

जाप, 2 बाइट्स

सरणी को पहले इनपुट के रूप में लेता है।

óV

कोशिश करो

— झबरा
स्रोत

5

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

कोड:

lambda x,n:[x[i::n]for i in range(n)]

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

— अदनान
स्रोत

5

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

sZ

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

4 बाइट बचाने के लिए @JonathanAllan को धन्यवाद

— निक केनेडी
स्रोत

करता है sZकाम नहीं?

— जोनाथन एलन

@JonathanAllan हाँ, किसी भी तरह याद किया। क्या आप अलग उत्तर के रूप में पोस्ट करना चाहते हैं या मैं अपना संपादन करूंगा?

— निक केनेडी

आपका स्वागत करने के लिए स्वागत नहीं है :)

— योनातन एलन

4

जे , 13 , 11 , 10 , 9 बाइट्स

(|#\)</.]

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

कैसे (पिछले स्पष्टीकरण, मौलिक रूप से समान)

] </.~ (| #\)
  </.~          NB. box results of grouping
]               NB. the right arg by...
         |      NB. the remainders of dividing...
       [        NB. the left arg into...
           #\   NB. the length of each prefix of...
              ] NB. the right arg,
                NB. aka, the integers 1 thru
                NB. the length of the right arg

— जोनाह
स्रोत

3

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

ＩＥθ✂ηιＬηθ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। ऑर्डर में इनपुट लेता है [n, A]और प्रत्येक मूल्य को अपनी लाइन पर और प्रत्येक हाथ को पिछले से डबल-स्पेस दिया जाता है। स्पष्टीकरण:

  θ         First input `n`
 Ｅ          Map over implicit range
    η       Second input `A`
   ✂        Sliced
     ι      Starting at current index
      Ｌη    Ending at length of `A`
        θ   Taking every `n`th element
Ｉ           Cast to string
            Implicitly print

— नील
स्रोत

एक स्लाइस को "स्लाइस" का प्रतीक बनाने के लिए +1!

— जोनाह

2

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

import Data.Lists
(transpose.).chunksOf

नोट: Data.Listsतृतीय-पक्ष लाइब्रेरी सूचियों से है , जो स्टैकेज पर नहीं है और इसलिए हुगले पर दिखाई नहीं देगी।

— dfeuer
स्रोत

Data.Listsलगता नहीं है। मुझे लगता है कि आप मतलब था Data.List, लेकिन यह शामिल नहीं है chunksOf।

— जोसेफ सेबल-मोनिका

chunksOfकेवल हस्ताक्षर के साथ प्रकट होता है Int -> Text -> [Text]। 1

— पोस्ट रॉक गार्फ हंटर

@JosephSible, यह listsपैकेज में है।

— डेफ्यूअर

@ SriotchilismO'Zaic, बहुत सी चीजें हुगली में दिखाई नहीं देती हैं। यह splitपैकेज में है और पैकेज द्वारा फिर से निर्यात किया जाता है lists। chunksOfसूची, पाठ, अनुक्रम और शायद अन्य चीजों के लिए संस्करण हैं।

— डेफ्यूअर

2

कोटलिन , 53 51 49 बाइट्स

{a,n->(0..n-1).map{a.slice(it..a.size-1 step n)}}

पुराने, गलत समाधान ने केवल सरणी लंबाई के विभाजकों के लिए काम किया। मुझे यकीन है कि यह नीचे गोल्फ हो सकता है।

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

— एडम
स्रोत

अमान्य

— केवल

nसूची की लंबाई का भाजक नहीं होने पर काम नहीं करता है

— जो किंग

मैं देखता हूं, धन्यवाद। इसे अब ठीक कर रहे हैं

— एडम

मेरा मानना है कि यह @ ASCII- केवल

— एडम

1

ऐसा लगता है कि आप अतिरिक्त जोड़ी ओ.टी. परेंस को निकाल सकते हैं

— ASCII-only

2

जावास्क्रिप्ट (Node.js) , 51 बाइट्स

A=>n=>A.map((x,i)=>e[i%=n]=[...e[i]||[],x],e=[])&&e

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

जावास्क्रिप्ट (Node.js) , 53 बाइट्स

A=>n=>g=(i=n)=>i?[...g(--i),A.filter(_=>i--%n==0)]:[]

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

— l4m2
स्रोत

1

एपीएल + विन 26 या 31 बाइट्स

यदि अलग-अलग हाथों को 2 डी मैट्रिक्स के कॉलम के रूप में दर्शाया जा सकता है तो 26 बाइट यदि सरणी का एक सरणी है तो 5 बाइट जोड़ें।

(l,n)⍴((l←⌈(⍴a)÷n)×n←⎕)↑a←⎕

इसे ऑनलाइन आज़माएं! Dyalog क्लासिक की हमारी विरासत

या

⊂[1](l,n)⍴((l←⌈(⍴a)÷n)×n←⎕)↑a←⎕

इसे ऑनलाइन आज़माएं! दरियाल क्लासिक के सौजन्य से

स्पष्टीकरण:

कार्ड के सरणी के लिए a ← संकेत

((l ÷ ⌈ (⍴a) × n) × n ⎕ ↑) पूर्णांक के लिए ← ←, हाथों से शून्य तक पैड के साथ पैड

(l, n) each प्रत्येक हाथ का प्रतिनिधित्व करने वाले प्रत्येक कॉलम के साथ 2D मैट्रिक्स बनाएँ

⊂ [1] यदि आवश्यक हो तो नेस्टेड वेक्टर में परिवर्तित करें - सरणियों के एपीएल सरणी

— ग्राहम
स्रोत

1

TSQL, 44 बाइट्स

-- @       : table containing the input 
-- column c: value of the card, 
-- column a: position on the card in the deck
-- @n      : number of players

DECLARE @ table(a int identity(0,1), c varchar(9))
DECLARE @n int = 4

INSERT @ values('1a'),('2c'),('3e'),('4g'),('5i'),('6k')

SELECT string_agg(c,',')FROM @ GROUP BY a%@n

कोशिश करके देखो

— t-clausen.dk
स्रोत

1

हर बार जब मैं इस वेबसाइट पर होता हूं तो मुझे कुछ नया दिखाई देता है और "वाह यह प्रभावशाली है, लेकिन क्यों?"

— माइंडस्वाइप

@MindSwipe मैंने स्टैकऑवरफ्लो पर बहुत सारे सवालों के जवाब दिए हैं, लेकिन उनमें से कई सवाल एक जैसे या लगभग एक जैसे हैं - ऐसा भी लगता है कि मैं मुफ्त में काम कर रहा हूं। कोड-गोल्फ प्रश्न हर बार अलग होते हैं और मैं इसका अधिक आनंद लेता हूं क्योंकि मुझे उन विधियों का उपयोग करना पड़ता है जो मुझे शायद ही कभी मिलती हैं।

— t-clausen.dk

1

मैथॉल्फ , 9 बाइट्स

\ô_í\%q╞;

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

व्याख्या

\           swap top elements (pops both input onto stack)
 ô          start block of length 6
  _         duplicate TOS (will duplicate the list)
   í        get total number of iterations of for loop (the other input)
    \       swap top elements
     %      modulo (picks every n:th item of the list
      q     print without newline
       ╞    discard from left of string/array (makes the next player pick cards starting with the next in the deck)
        ;   discard TOS (removes some junk in the end)

— maxb
स्रोत

1

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

A->n->{var o="";for(int h=0,i;h<n;o+="\n")for(i=h++;i<A.length;i+=n)o+=" "+A[i];return o;}

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

लैम्बडा के लिए धन्यवाद ओलिवियर ग्रेजायर और पुनरावृति करते हुए बेहतर वेतन वृद्धि।

— डैनियल Widdis
स्रोत

और यहां, मैंने इसे 90 बाइट्स के लिए नीचे गिरा दिया ।

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

@ OlivierGrégoire धन्यवाद! यह थोड़ा नया था और लंबोदर बिट पर काम कर रहा था लेकिन संघर्ष कर रहा था।

— डैनियल विदिस

1

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

def s a,n;a.each_with_index.inject(([[]]*n).map(&:dup)){|b,(c,d)|b[d%n]<<c;b};end

यह ऑनलाइन की कोशिश करो

— Avilyn
स्रोत

1

क्या आप संभवतः सत्यापन में आसानी के लिए एक ऑनलाइन परीक्षण वातावरण के लिए एक लिंक जोड़ सकते हैं?

— जोनाथन फ्रीच

@JonathanFrech वहाँ तुम जाओ।

— १०:३४ पर एवलिन

PPCG में आपका स्वागत है! लंबाई के लिए आप बहुत सारे अनुकूलन कर सकते हैं; उदाहरण के लिए, each_with_indexएक वृद्धिशील काउंटर की तुलना में बहुत महंगा है,map{[]} मूल रूप से आपकी map(&:dup)चाल, अनाम प्रोक, आदि के समान काम करता है जो आपके कोड को 59 बाइट्स तक कम कर सकता है। इसे ऑनलाइन आज़माएं! इसके अलावा बाहर की जाँच रूबी सुझावों पेज

— मूल्य इंक

1

पीएचपी ,85 83 82 बाइट्स

function($a,$n){while($x<$n)$c[]=array_column(array_chunk($a,$n),+$x++);return$c;}

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

यह सबसे छोटी प्रविष्टि नहीं होगी, लेकिन मुझे लगा कि PHP अरेंज फंक्शन बिल्ट-इन का उपयोग करके इसे करने में मज़ा आएगा। परिणाम: लंबा।

उत्पादन

1   [1,2,3,4,5,6]   [[1,2,3,4,5,6]]
2   [1,2,3,4,5,6]   [[1,3,5],[2,4,6]]
3   [1,2,3,4,5,6]   [[1,4],[2,5],[3,6]]
4   [1,2,3,4,5,6]   [[1,5],[2,6],[3],[4]]
7   [1,2,3,4,5,6]   [[1],[2],[3],[4],[5],[6],[]]
5   ["9C","QD","2S","4H","6D","AS","9D","TH","5C"]  [["9C","AS"],["QD","9D"],["2S","TH"],["4H","5C"],["6D"]]

— 640KB
स्रोत

1

बस FYI करें, print_flatआप के बजाय बस json_encode सैंडबॉक्स कर सकते हैं - वास्तव में उत्तर को किसी भी रूप में नहीं बदलेंगे, बस सोचा था कि मैं इसका उल्लेख करूंगा, चीयर्स!

— ArtisticPhoenix

@ArtisticPhoenix अच्छी तरह से, बिल्कुल! (फेसपालम) धन्यवाद! :)

— 640KB

1

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

#2[[i;;;;#]]~Table~{i,#}&

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

— attinat
स्रोत

O_o स्पष्टीकरण pls

— केवल

@ ASCII- ;; ;;केवल एक टुकड़ा है, लगभग अजगर के बराबर : :; यह हर के स्लाइस हो जाता है

n

$n$ वें तत्व के लिए ऑफसेट 1 ... n

— एटिनैट

अरे हाँ, भूल गया कि यह योग्य ;;नहीं था ;। यह देख रहा था कि "wth is i ; ; ; ; #"

— केवल

0

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

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

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

— aloisdg codidact.com पर जा रहा है
स्रोत

@JoKing [1,2,3], 4को आउटपुट देना चाहिए [[1],[2],[3]]। आप 4 खिलाड़ियों को 3 कार्ड दे रहे हैं। मैं मुख्य प्रश्न को अपडेट करूंगा।

— aloisdg

1

यह आमतौर पर आपकी अपनी चुनौतियों का तुरंत समाधान करने के लिए हतोत्साहित किया जाता है।

— शैगी

1

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

— aloisdg

@ जो राजा तुम सही हो! मैंने एक टाइपो बनाया: /

— aloisdg

0

सी (जीसीसी), 5 बाइट्स

संकलक ध्वज -Df=(पुनः अग्रणी स्थान) विनिर्देश पूरा करता है। f(n_cards,n_hands,card_ptr)हाथों की सूची के लिए एक सूचक का मूल्यांकन करता है।

व्याख्या

C में, सूचियों की सूचियों को एक एकल interleaved सरणी के रूप में लागू करना आम बात है, जब सूचियों की संख्या स्थिर रहती है लेकिन सभी सूचियों को बढ़ाया जा सकता है। उदाहरण के लिए, कार्ड से निपटने के इस मामले में, अधिक कार्ड के लिए प्रत्येक हाथ को हाथ से जोड़ा जाना अधिक आम है, इसलिए एक सूची के रूप में हाथों की सूची को लागू करना उचित होगा। संयोगवश, "डेक" एक ऐसी सूची है, और इस प्रकार हम पैरामीटर को अनमॉडिफाइड लौटाते हैं।

यह चुनौती शायद सैंडबॉक्स हो गई होगी।

मुझे लगता है कि हम सभी सैंडबॉक्स के लिए सहमत हैं

— aloisdg

0

पर्ल ५ `-la` , 66 56 बाइट्स

$,=<>;map{push@$_,shift@F}1..$,while@F;say"@$_"for 1..$,

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

— Xcali
स्रोत

खिलाड़ियों के लिए कार्ड डील करें

नियम

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

डेमो कार्यक्रम

05AB1E , 3 1 बाइट

आर , 46 25 बाइट्स

पर्ल 6 , 33 24 बाइट्स

स्पष्टीकरण:

वोल्फ्राम भाषा (गणितज्ञ) , 28 बाइट्स

जाप, 2 बाइट्स

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

कोड:

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

जे , 13 , 11 , 10 , 9 बाइट्स

कैसे (पिछले स्पष्टीकरण, मौलिक रूप से समान)

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

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

कोटलिन , 53 51 49 बाइट्स

जावास्क्रिप्ट (Node.js) , 51 बाइट्स

जावास्क्रिप्ट (Node.js) , 53 बाइट्स

एपीएल + विन 26 या 31 बाइट्स

TSQL, 44 बाइट्स

मैथॉल्फ , 9 बाइट्स

व्याख्या

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

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

पीएचपी ,85 83 82 बाइट्स

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

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

सी (जीसीसी), 5 बाइट्स

व्याख्या

पर्ल ५ -la , 66 56 बाइट्स

पर्ल ५ `-la` , 66 56 बाइट्स