पिरामिडों में गिनती

Question

आपको एक प्रोग्राम या फ़ंक्शन लिखना चाहिए जो इनपुट और आउटपुट के रूप में अलग-अलग पूर्णांकों की एक सूची प्राप्त करता है या निम्न उल्टा संख्या पिरामिड में इनपुट नंबर की घटनाओं की संख्या देता है।

मूल सूची हर कदम में हम आसन्न संख्या की प्रत्येक जोड़ी के अधिक से अधिक मूल्यों (जैसे के साथ एक नया बना से शुरू 5 1 2 6हो जाता है 5 2 6)। सूची में केवल एक नंबर होने पर हम रुक जाते हैं।

के लिए पूर्ण पिरामिड 5 1 2 6है

5 1 2 6
 5 2 6 
  5 6  
   6   

परिणामस्वरूप होने वाली संख्याएँ 3 1 2 4( 5 1 2 6क्रमशः के लिए) हैं।

इनपुट

• बिना पुनरावृत्ति वाले एक या अधिक पूर्णांकों की सूची। (उदा 1 5 1 6। अमान्य है)

उत्पादन

• सकारात्मक पूर्णांक की एक सूची। iसूची में सबसे वें तत्व की घटनाओं की संख्या है iपिरामिड में वें इनपुट संख्या।

उदाहरण

इनपुट => आउटपुट

-5 => 1

8 4 => 2 1

5 9 7 => 1 4 1

1 2 3 9 8 6 7 => 1 2 3 16 3 1 2

6 4 2 1 3 5 => 6 4 2 1 3 5

5 2 9 1 6 0 => 2 1 12 1 4 1

120 5 -60 9 12 1 3 0 1200 => 8 2 1 3 16 1 4 1 9

68 61 92 58 19 84 75 71 46 69 25 56 78 10 89 => 2 1 39 2 1 27 6 5 1 6 1 2 14 1 12

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

बोनस पहेली: क्या आप O(n*log n)समय में समस्या को हल कर सकते हैं ?

Comments

एक फ़ंक्शन सबमिशन के लिए, क्या मुझे उन्हें STDOUT में प्रिंट करना होगा या बस उन्हें आउटपुट करना होगा?

— ऑप्टिमाइज़र

Answer 1

पायथ, 19 17 बाइट्स

m/smmeSb.:QhkUQdQ

की जाँच करें ऑनलाइन प्रदर्शन या पूर्ण टेस्ट सुइट (पहले 4 बाइट उदाहरण पर पुनरावृति)।

यह एक भोले दृष्टिकोण की तुलना में थोड़ा अधिक चतुर है। त्रिभुज की प्रत्येक संख्या को एक जुड़े उपसमूह के अधिकतम मूल्य के रूप में दर्शाया जा सकता है Q। पहली पंक्ति में यह लंबाई 1 के सबसेट का उपयोग करता है, त्रिकोण की दूसरी रेखा लंबाई 2, ... के सबसेट का उपयोग करती है।

व्याख्या

m/smmeSb.:QhkUQdQ    implicit: Q = input()
   m         UQ         map each k in [0, 1, 2, ..., len(Q)-1] to:
        .:Qhk              all subsets of Q of length (k + 1)
    meSb                   mapped to their maximum
  s                     join these lists together
m               Q    map each d of Q to:
 /             d        its count in the computed list

यह थोड़ा सा कल्पना करने के लिए। m.:QhdUQऔर इनपुट [5, 1, 2, 6]मुझे सभी संभव सबसेट देता है:

[[[5], [1], [2], [6]], [[5, 1], [1, 2], [2, 6]], [[5, 1, 2], [1, 2, 6]], [[5, 1, 2, 6]]]

और mmeSk.:QhdUQमुझे उनकी प्रत्येक अधिकतमता देता है (जो पिरामिड में पंक्तियों से बिल्कुल मेल खाती है):

[[5, 1, 2, 6], [5, 2, 6], [5, 6], [6]]

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

|u&aYGmeSd.:G2QQm/sYdQ

यह सिर्फ सरल है "आपको जो बताया गया है वह करें" दृष्टिकोण।

की जाँच करें ऑनलाइन प्रदर्शन या एक पूरा टेस्ट सुइट (पहले 4 बाइट उदाहरण पर पुनरावृति)।

व्याख्या

meSd.:G2[(G[0], G[1]), (G[1], G[2]), ...]अधिकतम तत्व के प्रत्येक जोड़े को मैप करता है ।

Yएक खाली सूची है, इसलिए इस पर aYGनिर्भर Gकरता है Y।

u...QQबार-बार ये दो कार्य ( len(Q)समय) लागू होते हैं G = Qऔर Gप्रत्येक रन के बाद अपडेट होते हैं।

m/sYdQचपटा Yसूची के प्रत्येक तत्व को चपटा सूची में उनकी गिनती के लिए मैप करता है ।

Comments

आपका 17 बाइट संस्करण उसी एल्गोरिथ्म का उपयोग करता है जैसा मेरा है, मुझे लगता है कि अब बहुत भोला है: पी

— ऑप्टिमाइज़र

Answer 2

पायथन, 81

def f(L):
 if L:i=L.index(max(L));L=f(L[:i])+[~i*(i-len(L))]+f(L[i+1:])
 return L

एक विभाजन और जीत समाधान। अधिकतम तत्व Mपिरामिड के नीचे के सभी रास्ते को बंद कर देता है, इसे M's और दो उप-पिरामिडों की एक आयत में विभाजित करता है ।

* * * M * *
 * * M M *
  * M M M
   M M M
    M M
     M

तो, कुल परिणाम बाएं सबलिस्ट के लिए आउटपुट है, इसके बाद आयत के क्षेत्र के बाद, दाएं सबलिस्ट के लिए आउटपुट के बाद।

इनपुट चर Lका पुन: उपयोग करके संग्रहित किया जाता है ताकि खाली सूची को खाली सूची में मैप किया जा सके।

समाधान में निर्माण पायथन में कृमि हैं। हो सकता है कि पैटर्न-मिलान वाली कुछ भाषा निम्नलिखित छद्मकोड को लागू कर सकती है?

def f(L):
 [] -> []
 A+[max(L)]+B -> f(A)+[(len(A)+1)*(len(B)+1)]+f(B)

Comments

मैं मैथेमेटिका के पैटर्न के मिलान के साथ एक बाइट कम कर सकता हूं, लेकिन यह मौजूदा मैथमेटिका प्रस्तुत करने से भी पीछे नहीं f@{}=##&@@{};f@{a___,l_,b___}/;l>a~Max~b:={f@{a},Length@{a,0}Length@{b,0},f@{b}}

— हटता

Answer 3

CJam, 23 22 बाइट्स

अभी भी गोल्फ विकल्पों की तलाश में है।

{]_,{)W$ew::e>~}%fe=~}

यह एक CJam फ़ंक्शन (सॉर्ट) है। यह स्टैक पर इनपुट संख्याओं की अपेक्षा करता है और स्टैक पर संबंधित आउटपुट गणनाओं को भी लौटाता है। एक उदाहरण:

5 1 2 6 {]_,{)W$ew::e>~}%fe=~}~

पत्ते

3 1 2 4

ढेर पर।

बहुत यकीन है कि यह अंदर नहीं है O(n log n) समय ।

कोड विस्तार :

]_                     e# Wrap the input numbers on stack in an array and take a copy
  ,{          }%       e# Take length of the copy and run the loop from 0 to length - 1
    )W$                e# Increment the iterating index and copy the parsed input array
       ew              e# Get overlapping slices of iterating index + 1 size
         ::e>          e# Get maximum from each slice
             ~         e# Unwrap so that there can be finally only 1 level array
                fe=    e# For each of the original array, get the occurrence in this
                       e# final array created by the { ... }%
                   ~   e# Unwrap the count array and leave it on stack

आइए एक उदाहरण देखें कि यह कैसे काम करता है 5 1 2 6

दूसरी पंक्ति में, 5 1 2 6बन जाता है 5 2 6क्योंकि क्रमशः 5, 2 and 6अधिकतम [5 1], [1 2] and [2 6]हैं। तीसरी पंक्ति में, यह क्रमशः हो जाता है 5 6क्योंकि 5 and 6अधिकतम होते [5 2] and [2 6]हैं। इसे [5 1 2] and [1 2 6]क्रमशः अधिकतम के रूप में भी लिखा जा सकता है । इसी तरह अंतिम पंक्ति के लिए, 6अधिकतम है[5 1 2 6] ।

तो हम मूल रूप से लंबाई के स्लाइस से शुरू होने वाले उचित लंबाई के स्लाइस बनाते हैं 1, जो मूल रूप से मूल संख्या है, प्रत्येक एक सरणी में लिपटे हुए हैं, अंत में लंबाई का एक टुकड़ा हैN में अंतिम पंक्ति के लिए , जहांN इनपुट पूर्णांक की संख्या है।

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

Answer 4

गणितज्ञ, 72 बाइट्स

Last/@Tally[Join@@NestList[MapThread[Max,{Most@#,Rest@#}]&,#,Length@#]]&

Answer 5

पायथन, 81

lambda L:[sum(x==max(L[i:j])for j in range(len(L)+1)for i in range(j))for x in L]

पिरामिड की प्रत्येक प्रविष्टि अपने ऊपर वाले शंकु के ऊपर स्थित सबलिस्ट की अधिकतम होती है। इसलिए, हम इन सभी उपनलियों को उत्पन्न करते हैं, [i,j]जिनके साथ अंतराल होता है0 < i < j <= len(L) , , और गिनते हैं कि प्रत्येक तत्व अधिकतम कितने समय में प्रकट होता है।

सब-वेनेटल्स की गणना करने का एक छोटा तरीका संभवतः पात्रों को बचाएगा। जोड़े का एक एकल-सूचकांक पैरामीरिजेशन [i,j]एक प्रशंसनीय दृष्टिकोण होगा।

Answer 6

रंज , 56 + 1 = 57 बाइट्स

सीजेम वूडू के साथ ज्यादा प्रतिस्पर्धा नहीं, मुझे डर है। ऐसा लगता है कि मुझे एक बेहतर एल्गोरिथ्म की आवश्यकता है। -sस्पेस-सीमांकित आउटपुट प्राप्त करने के लिए ध्वज के साथ चलाएँ ।

l:gr:0*,#gg:0*g+1WrFir:{c:r@[a--a]c@($<l@c)}M1,#r++(gi)g

टिप्पणियों के साथ असंगठित:

l:g                              l = input from cmdline args
r:0*,#g                          r = current row as a list of indices into l
g:0*g+1                          Repurpose g to store the frequencies
Wr                               Loop until r becomes empty
 Fir:{c:r@[a--a]c@($<l@c)}M1,#r  Redefine r (see below) and loop over each i in it
  ++(gi)                         Increment g[i]
g                                Output g

rप्रत्येक समय के पुनर्परिवर्तन के रूप में निम्नानुसार काम करता है:

{c:r@[a--a]c@($<l@c)}M1,#r
{                   }M1,#r       Map this function to each a from 1 to len(r) - 1:
 c:r@[a--a]                      c is a two-item list containing r[a] and r[a-1]
                l@c              The values of l at the indices contained in c
              $<                 Fold/less-than: true iff l[c[0]] < l[c[1]]
           c@(     )             Return c[0] if the former is greater, c[1] otherwise

Answer 7

एपीएल (24)

{+/⍵∘.={⍵≡⍬:⍵⋄⍵,∇2⌈/⍵}⍵}

यह एक फ़ंक्शन है जो सूची लेता है, जैसे;

      {+/⍵∘.={⍵≡⍬:⍵⋄⍵,∇2⌈/⍵}⍵}68 61 92 58 19 84 75 71 46 69 25 56 78 10 89
2 1 39 2 1 27 6 5 1 6 1 2 14 1 12

स्पष्टीकरण:

• {...}⍵ : निम्नलिखित फ़ंक्शन को function पर लागू करें:
  • ⍵≡⍬:⍵: यदि empty खाली है, तो empty लौटें
  • 2⌈/⍵: अगली सूची तैयार करें
  • ⍵,∇: वापसी function, इस फ़ंक्शन को अगली सूची में लागू करने के परिणाम के बाद
• ⍵∘.=: फ़ंक्शन के परिणाम में प्रत्येक तत्व की तुलना प्रत्येक तत्व से करें
• +/: पंक्तियों को लिखें (in में तत्वों का प्रतिनिधित्व)

Answer 8

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

l=length
f x=[l[b|b<-concat$take(l x)$iterate(zipWith max=<<tail)x,a==b]|a<-x]

उपयोग: f [68,61,92,58,19,84,75,71,46,69,25,56,78,10,89]-> [2,1,39,2,1,27,6,5,1,6,1,2,14,1,12]।

यह काम किस प्रकार करता है

zipWith max=<<tail   -- apply 'max' on neighbor elements of a list
iterate (...) x      -- repeatedly apply the above max-thing on the
                     -- input list and build a list of the intermediate
                     -- results
take (l x) ...       -- take the first n elements of the above list
                     -- where n is the length of the input list
concat               -- concatenate into a single list. Now we have
                     -- all elements of the pyramid in a single list.
[ [b|b<-...,a==b] | a<-x]
                     -- for all elements 'a' of the input list make a 
                     -- list of 'b's from the pyramid-list where a==b.
 l                   -- take the length of each of these lists    

Answer 9

जावास्क्रिप्ट, 109 बाइट्स

मुझे लगता है कि मुझे इस बारे में जाने का एक दिलचस्प तरीका मिला, लेकिन मुझे एहसास होने के बाद कि कोड प्रतिस्पर्धा करने के लिए बहुत लंबा था। ओह ठीक है, इस पोस्टिंग वैसे भी किसी को आगे गोल्फ क्षमता देखता है।

f=s=>{t=[];for(i=-1;s.length>++i;){j=k=i;l=r=1;for(;s[--j]<s[i];l++);for(;s[++k]<s[i];r++);t[i]=l*r}return t}

मैं यहाँ निम्नलिखित सूत्र का उपयोग कर रहा हूँ:

I की घटनाएँ = (इसके बाएं से 1 तक छोटी संख्याओं की संख्या) * * (लगातार संख्याओं की संख्या जो कि मैं इसकी संख्या + 1 से छोटी है)

इस तरह किसी को वास्तव में पूरे पिरामिड या इसके सबसेट उत्पन्न करने की आवश्यकता नहीं है। (यही कारण है कि मैंने शुरू में सोचा था कि यह ओ (एन) में चलेगा, लेकिन कठिन भाग्य, हमें अभी भी आंतरिक छोरों की आवश्यकता है।)

Answer 10

MATLAB: (266 बी)

• कोड के सुधार में अधिक बाइट्स खर्च होते हैं, मैं संघर्ष करूंगा कि इसे बाद में कैसे कम किया जाए।

v=input('');h=numel(v);for i=1:h,f=(v(i)>v(1));l=(v(i)>v(h));for j=h-1:-1:i+1,l=(v(i)>v(j))*(1+l);end,if(i>1),l=l+(v(i)>v(i-1))*l;end;for j=2:i-1,f=(v(i)>v(j))*(1+f);end,if(i<h),f=f+(v(i)>v(i+1))*f;end;s=f+l+1;if(i<h&&i>1),s=s-((v(i)>v(i+1))*(v(i)>v(i-1)));end;s
end

इनपुट

एक सदिश रूप [abcd ...] का होना चाहिए

• उदाहरण:

  [२ ४ 3 ११ ३]

आउटपुट

पैटर्न घटनाएँ।

s =

 1


s =

 2


s =

 3


s =

 8


s =

 1

व्याख्या:

अगर [abcd] एक इनपुट है तो प्रोग्राम रिजल्ट की गणना करता है

g = (a> b) + (a> b) (a> c) + (a> b) (a> c) * (a> d) = (a> b) (1+ (a> c) ( 1+ (a> c)))

h = (b> a) + (b> c) + (b> a) (b> c) + (b> c) (b> d) + (b> a) (b> c) (b> d) ) = ... 'सरलीकृत'

i = (c> b) + (c> d) + (c> b) (c> d) + (c> b) (c> a) + (c> d) (c> b) (c> (c ) ) = ।।

j = (d> c) + (d> c) (d> b) + (d> c) (d> b) * (d> a) = ...

Answer 11

जे (49)

मुझे लगता है कि सुधार के लिए कुछ जगह है ...

[:+/~.="1 0[:;([:i.#)<@:(4 :'(}:>.}.)^:x y')"0 1]