एक डिब्बे को डिब्बे में रखें

Question

इस सरल चुनौती में आपको Lगैर-नकारात्मक पूर्णांक का एक इनपुट सरणी और b0 से अधिक डिब्बे की संख्या दी जाती है, लेकिन लंबाई से अधिक नहीं L। आपके कोड को एक नया सरणी वापस करना होगा, Mजिसकी लंबाई है bऔर जिसने सरणी को बायन किया है L। यह उदाहरणों के साथ सबसे आसान समझाया गया है।

L = [1,0,5,1]और b = 2लौटता है M = [1,6]।

L = [0,3,7,2,5,1]और b = 3लौटता है M = [3,9,6]।

अब तक, इतना सरल। हालांकि इस सवाल में bजरूरी नहीं कि विभाजन हो len(L)। इस मामले में अंतिम बिन को बनाने के लिए कम संख्या होगी।

संभवत: अंतिम को छोड़कर प्रत्येक बिन में कुल संख्या में समान संख्या होनी चाहिए। अंतिम बिन में अन्य डिब्बे की तुलना में अधिक संख्या में योगदान नहीं होना चाहिए। अंतिम बिन में उतने ही अंक होने चाहिए जितने अन्य नियमों के अधीन हो सके।

L = [0,3,7,2,5,1]और b = 4लौटता है M = [3,9,6,0]। M = [10,8,0,0]एक स्वीकार्य आउटपुट नहीं है क्योंकि तीसरे बिन में संख्याओं का नाम नहीं है जो इसे करने के लिए योगदान कर रहा है 1और 2।

L = [0,3,7,2,5]और b = 2लौटता है M = [10,7]। M = [3, 14]एक स्वीकार्य आउटपुट नहीं है क्योंकि अंतिम बिन में इसमें 3योगदान करने वाले तत्व होंगे लेकिन पहला केवल है 2।

L = [1,1,1,1,1,1,1]और b = 3लौटता है M = [3,3,1]।

अंतिम नियम के रूप में, आपका कोड रैखिक समय में चलना चाहिए।

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

---

यह पता चला है कि कुछ इनपुट हैं जिन्हें हल नहीं किया जा सकता है। उदाहरण के लिए [1,1,1,1,1]और b=4। आपका कोड उन इनपुट के लिए जो कुछ भी पसंद करता है उसे आउटपुट कर सकता है।

Comments

मुझे लगता है कि कुछ और परीक्षण मामले अच्छे होंगे।

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

your code must run in linear time- मैं किसी भी एल्गोरिथ्म जो यह स्वाभाविक रूप से काफी अजीब पालन नहीं करता है मिलेगा

— ऊरीएल

@ यूरेल कितनी अजीब कोड-गोल्फ उत्तर हो सकता है इसकी कोई सीमा नहीं है :)

@Lembik हालांकि किस तरह से इस तरह के संभावित अजीब तरीकों को एक कोड-गोल्फ चुनौती के लिए फायदेमंद नहीं है?

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

@JonathanFrech यह ओपी की प्राथमिकताओं के लिए नीचे है :)

Answer 1

एपीएल (डायलॉग) , 19 बाइट्स

{+/⍺(⌈⍺÷⍨≢⍵)⍴⍵,⍺⍴0}

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

हम संलग्न ख के बराबर भागों में यह देगी से पहले सरणी के लिए शून्य ⌈⍺÷⍨≢⍵( ⌈ एल की ÷ ख ⌉ लंबाई ) उन्हें संक्षेप और, के रूप में में दिखाया गया ,⍺⍴0, खाली स्थानों में से किसी भी राशि के बाद से से बड़ा (जो मूल सरणी का हिस्सा नहीं हैं) ख - 1 अन्य चंक्स से कम से कम b - 1 तत्वों से भरा होगा , जो अंतिम समूह के संतुलन बिंदु को अधिकतम बनाता है b - 1 से है, बाकी से 1 अंतर। हम b> b - 1 का उपयोग करते हैं क्योंकि यह कोड गोल्फ है।

उदाहरण के लिए, 15 तत्वों के साथ एल और बी = 3 समूहीकृत नहीं किया जाएगा

x x x x x x
x x x x x x
x x x 0 0 0

बल्कि इसके बजाय (ध्यान दें कि कैसे सबसे सही 2 है x s "सबसे बाईं ओर शून्य" भरता है)

x x x x x
x x x x x
x x x x x

जबकि एक 16 तत्व सरणी 2 ( 3 - 1 ) रिक्त स्थानों से भरा होगा , जैसे

x x x x x x
x x x x x x
x x x x 0 0

Answer 2

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

f=lambda l,n:n and[sum(l[:len(l)/n+1])]+f(l[len(l)/n+1:],n-1)or[]

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

Answer 3

आर , 75 71 70 63 बाइट्स

function(L,b)colSums(matrix(L[1:(ceiling(sum(L|1)/b)*b)],,b),T)

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

यह पैड तब तक Lहोता है NAजब तक लंबाई एक से अधिक नहीं हो जाती है b, फिर कॉलम को हटाने के Lसाथ एक मैट्रिक्स के रूप में bकॉलम के NAमानों को निकालता है।

स्टैक-आधारित भाषा के रूप में व्याख्या करना:

function(L,b){
      (ceiling(sum(L|1)/b*b)  # push the next multiple of b >= length(L), call it X
    1:..                      # push the range 1:X
  L[..]                       # use this as an index into L. This forces L
                              # to be padded to length X with NA for missing values
        matrix(..,,b)         # create a matrix with b columns, using L for values
                              # and proceeding down each column, so
                              # matrix(1:4,,2) would yield [[1,3],[2,4]]
colSums(.., na.rm = T)        # sum each column, removing NAs

Comments

बहुत अच्छा और जल्दी! R कोडर का उदय ...

@ लेम्बिक मैं भाग्यशाली था कि आपको टीएनबी के बीच में ही सही यह कहते हुए कि "मैं इसे एक चुनौती के रूप में पोस्ट करने जा रहा हूं" और आप वास्तव में इसे पोस्ट कर रहे हैं।

— ग्यूसेप

ओह देखो "लंबाई [<-" हमारे पसंदीदा दोस्त की तरह ही वापस आ जाएगी "[<-"। कम पठनीयता के लिए कोई बाइट्स नहीं बचा:function(L,b)colSums(matrix("length<-"(L,ceiling(length(L)/b)*b),,b),T)

— Vlo

@Lo no bytes saved for less readabilityशायद आर गोल्फिंग का आदर्श वाक्य है ... हालांकि मुझे लगता है कि sum(L|1)एक बाइट से बचा लिया गया है length(L)!

— ग्यूसेप

Answer 4

MATL , 6 बाइट्स

vi3$es

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

इनपुट पर विचार करें 4, [0,3,7,2,5,1]एक उदाहरण के रूप।

v       % Vertically concatenate stack contents. Gives the empty array, []
        % STACK: []
i       % Input b
        % STACK: [], 4
        % Implicitly input L at the bottom of the stack
        % STACK: [0,3,7,2,5,1], [], 4
3$e     % 3-input reshape. This reshapes L with [] rows and b columns, in
        % column-major order (down, then across). [] here means that the
        % number of rows is chosen as needed to give b columns. Padding
        % with trailing zeros is applied if needed
        % STACK: [0 7 5 0;
                  3 2 1 0]
s       % Sum of each column
        % STACK: [3 9 6 0]
        % Implicitly display

Comments

यह मेरे विचार में सबसे प्रभावशाली उत्तर है।

Answer 5

रूबी , 54 53 बाइट्स

@Kirill L को बाइट धन्यवाद दिया।

->l,b{s=1.0*l.size/b;(1..b).map{l.shift(s.ceil).sum}}

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

Comments

अच्छा, आप भी बदल कर एक बाइट बचा सकता [0]*bद्वारा1..b

— किरिल एल

@KirillL। धन्यवाद। मेरे साथ भी नहीं हुआ था।

— मोनिका को बहाल करना - 22

Answer 6

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

j,k,t,Q;f(A,l,b)int*A;{for(j=~0;b>++j;printf("%d,",t))for(t=k=0;(Q=!!(l%b)+l/b)>k;t+=Q<l?A[Q]:0)Q=k+++Q*j;}

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

Answer 7

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

l#0=[]
l#n|o<-length l`div`n+1=sum(take o l):(drop o l)#(n-1)

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

Comments

के लिए काम करने के लिए प्रतीत नहीं होता है [1, 2, 3, 4, 5, 6] # 3।

— nwellnhof

Answer 8

जावा 10, 96 89 86 बाइट्स

a->b->{int r[]=new int[b],i=0,n=a.length;for(;i<n;)r[i/((n+b-1)/b)]+=a[i++];return r;}

इसे यहाँ ऑनलाइन आज़माएँ ।

यहाँ लिखने का एक छोटा तरीका मिला i/(n/b+(n%b==0?0:1) : i/((n+b-1)/b)

3 बाइट गोल्फिंग के लिए ओलिवियर ग्रेजायर को धन्यवाद।

Ungolfed संस्करण:

input -> bins -> { // input is int[] (original array), bins is int (number of bins)
    int result[] = new int[bins], // resulting array, initialized with all 0
    i = 0, // for iterating over the original array
    n = a.length; // length of the original array
    for(; i < n ;) // iterate over the original array
        result[i / ((n + bins - 1) / bins)] += input[i++]; // add the element to the right bin; that's bin n/bins if bins divides n, floor(n/bins)+1 otherwise
    return result;
}

Comments

86 बाइट्स

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

@ OlivierGrégoire धन्यवाद!

— OOBalance

Answer 9

अमृत , 98 बाइट्स

fn l,b->Enum.map Enum.chunk(l++List.duplicate(0,b-1),round Float.ceil length(l)/b),&Enum.sum/1 end

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

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

Comments

आपके कुछ आउटपुट में गलत लंबाई है।

@ लिम्बिक ने इसे तय किया।

— 21x बजे ओकेक्स

Answer 10

पर्ल 6 ,  52 51  50 बाइट्स

52 बाइट्स: इसका परीक्षण करें

->\L,\b{L.rotor(:partial,ceiling L/b)[^b].map: &sum}

51 बाइट्स: इसका परीक्षण करें

{@^a.rotor(:partial,ceiling @a/$^b)[^$b].map: &sum}

50 बाइट्स: इसे आज़माएं

{map &sum,@^a.rotor(:partial,ceiling @a/$^b)[^$b]}

---

47 बाइट नॉन-कॉम्पिटिशन ने इसे टेस्ट किया

{@^a.rotor(:partial,ceiling @a/$^b)[^$b]».sum}

यह गैर-प्रतिस्पर्धात्मक है जैसा ».sumकि समानांतर में गणना करने की अनुमति है। तो यह रैखिक समय में हो भी सकता है और नहीं भी।

---

विस्तारित:

{  # bare block with two placeholder parameters ｢@a｣ and ｢$b｣

  map                   # for each sublist

    &sum,               # find the sum


    @^a                 # declare and use first parameter

    .rotor(             # break it into chunks

      :partial,         # include trailing values that would be too few otherwise

      ceiling @a / $^b # the number of elements per chunk

    )[ ^$b ]           # get the correct number of chunks if it would be too few

}

Answer 11

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

ＮθＡηＷ﹪Ｌηθ⊞η⁰Ｅ⪪η÷ＬηθＩΣι

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

Ｎθ

इनपुट b।

Ａη

इनपुट L।

Ｗ﹪Ｌηθ⊞η⁰

तब तक धक्का 0दें Lजब Lतक कि लंबाई विभाज्य न हो जाए b।

Ｅ⪪η÷ＬηθＩΣι

की Lलंबाई को bविभाजित करें और Lउस लंबाई के वर्गों में विभाजित करें , फिर प्रत्येक अनुभाग को अलग-अलग लाइनों पर अंतर्निहित आउटपुट के लिए स्ट्रिंग करें।

Answer 12

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

L=>b=>Array(b).fill().map((v,i)=>L.slice(s=i*b,s+b).reduce((x,y)=>x+y))

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

Answer 13

सी (क्लैंग) , 58 बाइट्स

i;f(*L,l,b,*m){b=l/b+!!(l%b);for(i=0;i<l;m[i++/b]+=L[i]);}

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

f()मापदंडों को निम्नानुसार लेता है:
Lइनपुट पॉइंटर के लिए पॉइंटर: इनपुट ऐरे की
lलंबाई
b: डिब्बे की संख्या
m : नए बफर को प्राप्त करने वाले बफर को सूचक

निम्नलिखित एक पुनः प्रवेशी संस्करण @ 60 बाइट्स है:

f(*L,l,b,*m){b=l/b+!!(l%b);for(int i=0;i<l;m[i++/b]+=L[i]);}

Answer 14

PHP, 88 बाइट्स

function($a,$b){return array_map(array_sum,array_chunk($a,~-count($a)/$b+1))+[$b-1=>0];}

अनाम फ़ंक्शन, सरणी और पूर्णांक लेता है, सरणी देता है

एकमात्र गोल्फ क्षमता जो इसके ceil(count($a)/$b))साथ बदल रही थी (count($a)-1)/$b+1और संक्षिप्त (count($a)-1)थी ~-count($a)। परिणामस्वरूप फ्लोट को array_chunkकॉल में पूर्णांक के लिए निहित किया जाता है ।

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