বিনে একটি অ্যারে রাখুন

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। আপনার কোডগুলি in ইনপুটগুলির জন্য যা পছন্দ করে তা আউটপুট করতে পারে।

Comments

আমি মনে করি আরও কয়েকটি পরীক্ষার কেস সুন্দর হবে।

— জোনাথন ফ্রেচ

your code must run in linear time- আমি এমন কোনও অ্যালগরিদম খুঁজে পেতে পারি যিনি এটিকে প্রাকৃতিকভাবে বেশ অদ্ভুতভাবে অনুসরণ করেন না

— ইউরিয়েল

@ ইউরাইল কীভাবে অদ্ভুত কোড-গল্ফ উত্তর হতে পারে তার কোনও সীমা নেই :)

@ ল্যাম্বিক যদিও কোনও উপায়ে এই জাতীয় সম্ভাব্য অদ্ভুত পদ্ধতিকে কোনও কোড-গল্ফ চ্যালেঞ্জের পক্ষে উপকারী বলে অস্বীকার করছেন ?

— জোনাথন ফ্রেচ ২৩:০7

@

Answer 1

এপিএল (ডায়ালগ) , 19 বাইট

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

এটি অনলাইন চেষ্টা করুন!

আমরা যোগ খ সমান অংশের সেটিকে আকৃতিগত আগে অ্যারেতে শূন্য ⌈⍺÷⍨≢⍵( ⌈ এল ÷ খ ⌉ দৈর্ঘ্য ) তাদের summing এবং, ফোটানো ,⍺⍴0, ফাঁকা দাগ যে কোন পরিমাণ যেহেতু চেয়ে বড় (যা মূল অ্যারের অংশ নয়) খ - 1 অন্যান্য খণ্ড থেকে কমপক্ষে খ - 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

তবে বরং (নোট করুন কীভাবে বাম xদিকের জিরোতে 2 টি "পূরণ করে")

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

খুব সুন্দর এবং দ্রুত! আর

@ ললেবিক আমি ভাগ্যবান যে আমি আপনার মাঝে "এই চ্যালেঞ্জ হিসাবে পোস্ট করব" বলে টিএনবিতে পপ করতে পেরেছিলাম এবং আপনি আসলে এটি পোস্ট করছেন।

— জিউসেপ্পে

ওহ দেখুন "দৈর্ঘ্য [<-" আমাদের প্রিয় বন্ধু "[<-" এর মতোই ফিরে আসবে। কম পাঠযোগ্যতার জন্য কোনও বাইটস সংরক্ষণ করা হয়নি:function(L,b)colSums(matrix("length<-"(L,ceiling(length(L)/b)*b),,b),T)

— Vlo

@ ভ্লো no bytes saved for less readabilityসম্ভবত আর গল্ফিংয়ের মূলমন্ত্র ... যদিও আমি মনে করি sum(L|1)এটি একটি বাইট যা থেকে রক্ষা পেয়েছে length(L)!

— জিউসেপে

Answer 4

এমএটিএল , 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 বাইট

@ কিরিল এলকে একটি বাইট সংরক্ষণ করে

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

এটি অনলাইন চেষ্টা করুন!

Comments

ভাল, আপনি প্রতিস্থাপন [0]*bকরে একটি বাইট সংরক্ষণ করতে পারেন1..b

— কিরিল এল

@KirillL। ধন্যবাদ। এমনকি আমার সাথে ঘটেনি।

— মনিকা পুনরায় ইনস্টল করুন - notmaynard

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।

— নয়েলহহফ

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 বাইট গল্ফ করার জন্য অলিভিয়ার গ্রাগোয়ারকে ধন্যবাদ।

অবরুদ্ধ সংস্করণ:

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 বাইট

— অলিভিয়ার গ্রাগোয়ার

@ অলিভিয়ারগ্রোওয়ের ধন্যবাদ!

— ওবালান্স

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

আপনার কিছু ফলাফলের দৈর্ঘ্য ভুল।

@ ল্যাম্বিক এটি ঠিক করেছেন।

— Okx

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 বাইট এটি অ-প্রতিযোগিতামূলক টেস্ট করে Test

{@^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সেই দৈর্ঘ্যের বিভাগগুলিতে বিভক্ত করুন , তারপরে প্রতিটি বিভাগের যোগফল তৈরি করুন এবং পৃথক লাইনে অন্তর্ভুক্ত ফলাফলের জন্য স্ট্রিংয়ে কাস্ট করুন string

Answer 12

জাভাস্ক্রিপ্ট (নোড.জেএস) , 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

পিএইচপি, 88 বাইট

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

বেনামী ফাংশন, অ্যারে এবং পূর্ণসংখ্যার লাগে, অ্যারে প্রদান করে

শুধুমাত্র golfing সম্ভাব্য এই ছিল প্রতিস্থাপন করা হয়েছিল ceil(count($a)/$b))সঙ্গে (count($a)-1)/$b+1এবং কাটছাঁট (count($a)-1)সঙ্গে ~-count($a)। ফলস্বরূপ ভাসমানটি স্পষ্টভাবে array_chunkকলটিতে পূর্ণসংখ্যায় কাস্ট করা হয় ।

এটি অনলাইনে চেষ্টা করুন ।