समय में बायनिंग

Question

इस चुनौती में एक सरणी के तत्वों को समय के डिब्बे में रखना है। इनपुट घटनाओं के समय का प्रतिनिधित्व करने वाले सकारात्मक पूर्णांकों का एक गैर-घटता हुआ सरणी होगा, और एक पूर्णांक जो प्रत्येक बिन के आकार का प्रतिनिधित्व करता है। एक उदाहरण से शुरू करते हैं। हम इनपुट ऐरे Aऔर आउटपुट ऐरे को कहते हैं O।

`A = [1,1,1,2,7,10]` and `bin_size = 2`.

`O = [4,0,0,1,1]`.

क्यों ? एक साथ bin_size = 2, हम निम्नलिखित अंतराल होगा: (0,2], (2,4], (4,6], (6,8], (8,10], जहां चार वस्तुओं (1,1,1,2)पहले अंतराल के भीतर कर रहे हैं (0,2], दूसरे और तीसरे के अंतराल में कोई नहीं, एक 7अंतराल में (6,8], और एक 10अंतराल में (8,10]।

आपके कोड को लंबाई से bin_sizeशुरू होने वाले हर अंतराल पर विचार करना चाहिए 0और गिनना चाहिए कि Aप्रत्येक में कितने नंबर हैं। आपको हमेशा एक अंतराल के दाहिने हाथ के अंत को एक बिन में शामिल करना चाहिए ताकि ऊपर के उदाहरण 2में गिनती में शामिल हो 4। आपका कोड इनपुट और आउटपुट की लंबाई के योग में रैखिक समय में चलना चाहिए।

और ज्यादा उदाहरण:

`A = [1,2,7,12,15]`  and `bin_size = 5`.

`O = [2, 1, 2]`.

`A = [1,2,7,12,15]`  and `bin_size = 3`.

`O = [2,0,1,1,1]`.

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

Comments

अनुगामी के साथ आउटपुट 0की अनुमति है? इसलिए वापसी [2,0,1,1,1,0]करने के बजाय [2,0,1,1,1]?

— केविन क्रूज़सेन

कोई अनुगामी शून्य नहीं।

उन स्थितियों के बारे में जहां अधिकतम सरणी मूल्य एक से अधिक नहीं है bin_size, क्या हमें वास्तव में इन्हें संभालना चाहिए? ऐसा लगता है कि अधिकांश उत्तर देते हैं, लेकिन यदि ऐसा है, तो भ्रम को रोकने के लिए इस परिदृश्य के लिए एक परीक्षण मामला जोड़ना अच्छा होगा।

— किरिल एल।

@KirillL। हां उन्हें भी संभाला जाना चाहिए।

@GPS 0 एक सकारात्मक पूर्णांक नहीं है। यह कोई दुर्घटना नहीं है :)

Answer 1

आर , 48 बाइट्स

function(n,s)table(cut(n,0:ceiling(max(n)/s)*s))

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

एक बार फिर, tableऔर बिनिंग के लिए एक चाल के लिए cutटिंग factor। उदाहरण के लिए, अंतराल अंतराल में, vectorजहां नाम हैं, आउटपुट ।names(0,5]

संपादित करें: जब sविभाजित नहीं होता है तो पहले वाले संस्करण पर वापस लौटें n।

Comments

मैं वास्तव में आर नहीं करता हूं, लेकिन टीआईओ पर यह भाग के format you [most likely do not] find convenientबिना आउटपुट के लिए प्रकट होता है table।

— मेरा सर्वनाम

@ कोई भी ऐसा क्यों है। cutवेक्टर को अंतराल द्वारा दिए गए स्तरों के साथ कारकों में विभाजित करता है, और tableइसके इनपुट में प्रत्येक अद्वितीय मूल्य की घटनाओं को गिनता है।

— Giuseppe

@someone आह, मैं देखता हूं, मैंने आपकी टिप्पणी को गलत समझा। नहीं, मुझे लगता है कि यह मान्य नहीं होगा क्योंकि हमें प्रत्येक बिन की गिनती की आवश्यकता है।

— ग्यूसेप

पूरी तरह से परीक्षण नहीं है, लेकिन मुझे लगता है कि आप reaplacing बाइट्स एक जोड़े को बचा सकता है 0:ceiling(max(n)/s)*sके साथ seq(0,max(n)+s-1,s)। यह प्रश्न में दो नमूनों के लिए कम से कम काम करता है।

— ग्रेगर थॉमस

@Gregor हम्म अगर काम करता 1:max(n/s+1)*s-sहै तो एक और सुधार है क्योंकि दोनों बराबर हैं

— Giuseppe

Answer 2

ऑक्टेव , 36 बाइट्स

@(A,b)histc(A,1:b:A(end)+b)(1:end-1)

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

ईस्टर अंडे का शिकार करना और अलाव बनाना। जब मेरे पास समय होगा तो मैं एक स्पष्टीकरण जोड़ूंगा।

Answer 3

पर्ल 5 -a -i , 32 28 बाइट्स

-I विकल्प के बाद गिनती दें। प्रत्येक इनपुट तत्व को STDIN पर एक अलग लाइन पर दें

$G[~-$_/$^I]--}{say-$_ for@G

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

Comments

यह प्रभावशाली है।

Answer 4

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

I,s=input()
B=[0]*(~-I[-1]/s+1)
for i in I:B[~-i/s]+=1
print B

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

Comments

सबसे पहले: अच्छा जवाब, मैं पहले से ही इसे 1-एड कर चुका हूं (और जावा में एक पोर्ट बनाया है, क्योंकि यह मेरे द्वारा की गई तुलना में काफी कम है)। ट्रेलिंग जीरो को हालांकि अनुमति नहीं दी जाती है (बस ओपी से पूछा जाता है), इसलिए इसके बजाय I[-1]/s+1होना चाहिए ~-I[-1]/s+1।

— केविन क्रूज़सेन

@KevinCruijssen नोटिस के लिए धन्यवाद!

— मृत पोसुम

Answer 5

05AB1E , 18 बाइट्स

θs/Å0¹vDyI/î<©è>®ǝ

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

Comments

मैं 05AB1E को अच्छी तरह से नहीं जानता, लेकिन यह A.count अधिकतम (ए) कहलाता है , इसलिए चलाने का समय लेन (ए) + लेन (ओ) में रैखिक नहीं है । क्या यह सही है या मुझे कुछ गलत हुआ है?

— डेनिस

@ डेनिस की गिनती होगी O(max(A)*max(A))... तो यह ए के अधिकतम पर द्विघात है ... ओपी ने निर्दिष्ट किया कि इसे ... के संदर्भ में रैखिक होना चाहिए ... वास्तव में क्या है?

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn आपका कोड नवीनतम संशोधन के अनुसार इनपुट और आउटपुट की लंबाई के योग में रैखिक समय में चलना चाहिए ।

— डेनिस

@ डेनिस जो मनमाना लगता है।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn मेरे विचार से इस प्रश्न के लिए रैखिक समय की एकमात्र समझदार परिभाषा है।

Answer 6

एपीएल + विन, 23 बाइट्स

बिन के स्क्रीन इनपुट के लिए संकेत तो पूर्णांक के वेक्टर:

+⌿<\v∘.≤b×⍳⌈⌈/(v←⎕)÷b←⎕    

स्पष्टीकरण:

⎕ Prompt for input

⌈⌈/(v←⎕)÷b←⎕ divide the integers by bin size, take maximum and round up for number of bins

b×⍳ take number of bins from previous step and create a vector of bin upper boundaries

v∘.≤ apply outer product to generate boolean matrix where elements of vector ≤ boundaries

<\ switch off all 1's after first 1 in each row to filter multiple bin allocations

+⌿ sum columns for the result

Answer 7

सी ++ (जीसीसी) , 90 83 बाइट्स

auto f(auto i,int s){typeof i j;for(auto v:i)--v/=s,j.resize(v+1),j[v]++;return j;}

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

Answer 8

जावा 8, 75 बाइट्स

a->b->{var r=new int[~-a[a.length-1]/b+1];for(int i:a)r[~-i/b]++;return r;}

पोर्ट ऑफ @ डेडपॉसियम के पायथन 2 उत्तर , इसलिए उसके उत्तर को सुनिश्चित करें!

स्पष्टीकरण:

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

a->b->{          // Method with integer-array and integer parameters and no return-type
  var r=new int[~-a[a.length-1]/b+1];
                 //  Result integer-array of size `((last_item-1)/bin_length)+1`
  for(int i:a)   //  Loop over the input-array
    r[~-i/b]++;  //   Increase the value at index `(i+1)/bin_length` by 1
  return r;}     //  Return the result-array

Answer 9

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

->a,b{(b...a[-1]+b).step(b).map{|i|a.count{|n|n<=i&&n>i-b}}}

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

Answer 10

जावास्क्रिप्ट (ईएस 6), 60 बाइट्स / ओ (लेन (ए) + अधिकतम (ए) / एन)

सहेजे गए 5 बाइट्स @Neil का धन्यवाद

करी सिंटैक्स में इनपुट लेता है (a)(n)।

a=>n=>[...a.map(x=>o[x=~-x/n|0]=-~o[x],o=[])&&o].map(n=>~~n)

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

या सिर्फ 43 बाइट्स / O (len (a)) यदि खाली तत्वों की अनुमति है।

Comments

[...o].map(n=>n|0)कम बाइट्स में दूसरे समाधान से पहला आउटपुट मिलता है।

— नील

@ नहीं मुझे यकीन नहीं है कि मैं इतना दृढ़ क्यों कुछ के लिए चला गया। : - /

— अरनुलद

Answer 11

हास्केल , 63 75 70 बाइट्स

l!n=l#[n,2*n..]
[]#_=[]
l#(b:i)|h<-length$takeWhile(<=b)l=h:drop h l#i

वूप्स, यह छोटा एक रैखिक नहीं है, लेकिन द्विघात है;

l!n=l#[n,2*n..]
[]#_=[]
l#(b:i)=sum[1|a<-l,a<=b]:[a|a<-l,a>b]#i

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

Answer 12

पायथ, 23 22 बाइट्स

Jm/tdeQhQK*]ZheJhXRK1J

इसे यहाँ आज़माएँ

Jm/tdeQhQK*]ZheJhXRK1J
Jm/tdeQhQ                 Find the bin for each time and save them as J.
         K*]ZheJ          Create empty bins.
                 XRK1J    Increment the bins for each time within them.
                h         Take the first (because mapping returned copies).

Answer 13

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

संपादित करें: iamnotmaynard द्वारा -3 बाइट्स।

->a,b{(0..~-a.max/b).map{|i|a.count{|x|~-x/b==i}}}

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

Comments

यह तब काम नहीं करता है जब a.maxकोई बहु नहीं है b(जैसे f[[1,1,1,2,7,10],3]=> [4, 0, 1]लेकिन देना चाहिए [4, 0, 2])। मैंने उसी दृष्टिकोण की कोशिश की थी।

— मोनिका को फिर से स्थापित करें - notmaynard

(या यों कहें [4, 0, 1, 1])

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

ठीक है, यह एक फ्लोट अधिकतम रेंज मान पर स्विच करके ठीक करने योग्य है, लेकिन मैं ओपी को कार्य विवरण में इसे स्पष्ट करने के लिए भी कहूंगा।

— किरिल एल।

50 बाइट्स

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

अच्छा, और भी बेहतर, धन्यवाद।

— किरिल एल।

Answer 14

यह पहेली मूल रूप से काउंट-सॉर्ट है। हम पहले इनपुट के माध्यम से जाने बिना आउटपुट की लंबाई नहीं जानते।

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

i,j;f(*A,l,b,*O){for(j=0;j<l;O[(A[j++]+b-1)/b-1]++);}

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

यह समाधान निम्नलिखित मापदंडों को लेता है: आउटपुट के लिए ए बिन_साइज़ स्टोरेज की
Aइनपुट सरणी
lलंबाई । ओ में पर्याप्त लंबाई और रिटर्न आउटपुट होना चाहिए ।
b
O

इस समाधान में एक बाधा है: यह आउटपुट सरणी O की लंबाई वापस नहीं करता है, और इसलिए कॉलर को यह नहीं पता है कि कितना प्रिंट करना है।

निम्नलिखित संस्करण उस बाधा पर काबू पाते हैं:

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

i,j,k;f(*A,l,b,*O,*m){for(k=j=0;j<l;O[i=(A[j++]+b-1)/b-1]++,k=k>i?k:i);*m=++k;}

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

यह एक अतिरिक्त पैरामीटर लेता है mऔर इसमें लंबाई लौटाता Oहै। यह मेरी लागत 26 बाइट्स है।

Answer 15

सी (जीसीसी) , 102 90 89 86 बाइट्स

#define P!printf("%d ",k)
i,j,k;f(s){for(i=s;~scanf("%d",&j);k++)for(;j>i;i+=s)k=P;P;}

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

12 बाइट्स को खत्म करने के लिए केविन क्रूज़सेन का धन्यवाद, और एक और 4 बाइट्स के लिए सीलिंगकैट!

Comments

90-बाइट्स के लिए लूप्स का उपयोग करके, हटाने intऔर बदलने के ==1लिए >0।

— केविन क्रूज़सेन

आपका स्वागत है। Btw, सिर्फ एक नोट, यह वर्तमान में अमान्य है (ठीक वैसे ही जैसे मेरा अब नष्ट किया गया जावा उत्तर था)। यह O(n)समय में चलाने के लिए आवश्यक है , इसलिए आपके पास कोई भी नेस्टेड-लूप नहीं हो सकता है .. (आपका सी ++ उत्तर ठीक लगता है, हालांकि, इसलिए मैंने + 1-एड किया है जो एक है। :))

— केविन क्रूज़सेन

यह अभी भी O (n) है। आंतरिक लूप हमेशा एक मूल्य प्रिंट करेगा, और हम केवल प्रिंट (अधिकतम मूल्य + 1) / कुल मानों को द्वि-आकार देते हैं।

— जी। स्लीपेन

हम्म, लेकिन O(n)इनपुट आइटम पर लूप करके पहले से ही बाहरी लूप नहीं है । यहां तक ​​कि अगर आंतरिक लूप केवल 2 बार लूप करेगा यह पहले से ही ऊपर है O(n)। या मैं कुछ गलत समझ रहा हूँ .. मैं मानता Oहूँ

— -टाइम्स

लेकिन आंतरिक लूप सभी इनपुट तत्वों पर पुनरावृत्ति नहीं करता है, यह केवल नवीनतम इनपुट तत्व के अनुरूप स्थिति में "पकड़ने" के लिए प्रिंट करने के लिए कई आउटपुट मानों पर निर्भर करता है। यदि इनपुट वेक्टर में बहुत सारे डुप्लिकेट या मान शामिल होते हैं जो बिन आकार से कम भिन्न होते हैं, तो आंतरिक लूप किसी भी पुनरावृत्तियों का प्रदर्शन नहीं करेगा। दूसरी ओर, यदि इनपुट वेक्टर बहुत विरल है, तो आंतरिक लूप अधिक पुनरावृत्तियों का प्रदर्शन करेगा, मुद्रण 0 के। तो सही होने के लिए, कोड ओ ((इनपुट तत्वों की संख्या) + (अंतिम तत्व / बिन आकार) समय में चलता है। यह अभी भी रैखिक है।

— जी। स्लिपेन