भूस्खलन की भविष्यवाणी करें

Question

भूस्खलन

इस चुनौती में, आपका काम बड़े पैमाने पर भूस्खलन से होने वाले नुकसान की भविष्यवाणी करना है। हम इसके लिए निम्नलिखित सरलीकृत दो आयामी मॉडल का उपयोग करते हैं, एक प्रारंभिक ऊंचाई h >= 0 और एक महत्वपूर्ण गुणांक द्वारा पैरामीटरित c > 0। आप ऊंचाई की एक चट्टान से शुरू करते हैं h, और यह माना जाता है कि इलाके पूरी तरह से बाईं ओर और इसके दाईं ओर असीम रूप से सपाट हैं। के लिए h = 6, इस तरह स्थिति दिखता है:

##########
##########
##########
##########
##########
##########
-----------------------

-अचल आधार हैं, और #अस्थिर मिट्टी हैं। यदि दो पड़ोसी स्तंभों के बीच की ऊंचाई का अंतर अधिक है c, तो एक भूस्खलन होता है: cबाएं स्तंभ से मिट्टी की शीर्ष इकाइयां cदाएं पर अगले कॉलम में गिरती हैं , प्रत्येक के लिए एक। चित्र में सबसे दाहिना गैर-खाली कॉलम अस्थिर है c = 2, इसलिए भूस्खलन शुरू हो गया है:

#########
#########
##########
##########
##########
############
-----------------------

स्तंभ अभी भी अस्थिर है, जो एक दूसरे भूस्खलन का कारण बनता है:

#########
#########
#########
#########
############
############
-----------------------

अब, इसके बाईं ओर का स्तंभ अस्थिर हो गया है, इसलिए वहां एक नया भूस्खलन शुरू हो गया है:

########
########
#########
###########
############
############
-----------------------

इसके बाद, चट्टान फिर से स्थिर है। इस मॉडल के बारे में अच्छी बात यह है कि जिस क्रम में भूस्खलन की प्रक्रिया होती है, उससे कोई फर्क नहीं पड़ता: अंतिम परिणाम समान है।

काम

आपके प्रोग्राम को पूर्णांक पैरामीटर दिए गए हैं hऔर cइनपुट के रूप में (ऑर्डर से कोई फर्क नहीं पड़ता है, लेकिन आपको इसे अपने उत्तर पर निर्दिष्ट करना होगा), और यह कुल स्तंभों की संख्या को आउटपुट करना चाहिए जो भूस्खलन को प्रभावित करता है। इसका मतलब परिणामी स्थिर चट्टान में स्तंभों की संख्या है जिनकी ऊँचाई कड़ाई से 0और के बीच है h। उपरोक्त उदाहरण में, सही आउटपुट है 4।

आप एक पूर्ण कार्यक्रम या एक फ़ंक्शन लिख सकते हैं। सबसे कम बाइट गिनती जीतता है, और मानक खामियों को रोक दिया जाता है।

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

ये प्रारूप में दिए गए हैं h c -> output।

0  2  -> 0
2  3  -> 0
6  2  -> 4
6  6  -> 0
10 1  -> 10
15 1  -> 14
15 2  -> 11
15 3  -> 6
40 5  -> 16
80 5  -> 28
80 10 -> 17

Answer 1

सीजेएम, 62 57 बाइट्स

जहां तक ​​मैं देख सकता हूं, यह एडिट्स के उत्तर से समाधान को लागू करने के लिए पूरी तरह से अलग दृष्टिकोण है।

q~:C;:HaH)*H){(:I\_@>2<:-C>{I0a*C~)+C1a*+]z1fb_,}I?}h-H-,

इनपुट के रूप में जाता है h c

उदाहरण:

80 5

आउटपुट:

28

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

कोड के आकार को कम करने के लिए उपयोग किए जाने वाले कुछ ट्रिक्स के साथ तर्क यहाँ बहुत आगे है।

• प्रत्येक तत्व के साथ लंबाई h + 1( सरणी के + 1लिए h = 0) लंबाई को प्राप्त करें hताकि वह चट्टान का प्रतिनिधित्व कर सके
• इस एरे के सही सबसे इंडेक्स से पुनरावृति शुरू करें
  • यदि वर्तमान सूचकांक के दो तत्व अलग-अलग हैं c
    • cवर्तमान सूचकांक तत्व से निकालें
    • वर्तमान सूचकांक से सरणी के 1अगले cतत्वों में जोड़ें
    • वर्तमान सूचकांक को इस नए सरणी की लंबाई के बराबर बनाएं
    • यह सुनिश्चित करता है कि हम पत्थरों को पहले मौजूदा सूचकांक के दाईं ओर स्थिर करें
  • वरना, वर्तमान सूचकांक को कम करें
• जब हम बाएं सबसे अधिक सूचकांक को मारते हैं, तो हम यह सुनिश्चित कर रहे हैं कि सभी आसन्न सूचकांक cअंतर से कम या बराबर हैं
• किसी भी 0या hमान को सरणी से निकालें और लंबाई प्राप्त करें।

कोड विस्तार

q~:C;:HaH)*H){(:I\_@>2<:-C>{I0a*C~)+C1a*+]z1fb_,}I?}h-H-,
q~:C;:HaH)*H)
q~:C;:H                  "Read the input, evaluate it, store height in H and coeff. in C";
       aH)*              "Wrap the height number in an array and repeat it H + 1 times";
           H)            "Put H+1 on stack, representing the current index of iteration";
{(:I\_@>2<:-C>{I0a*C~)+C1a*+]z1fb_,}I?}h
(:I\_@>2<:-C>
(:I                      "Decrement the current index and store it in I";
   \_                    "Swap to put array on top and make 1 copy";
     @>2<                "Get the two elements starting from Ith index";
         :-              "Get the difference. The best part of this approach is that";
                         "For the right most index, where there is only element, it";
                         "returns the element itself, which is the expected difference";
           C>            "Check if difference is greater than C";
{I0a*C~)+C1a*+]z1fb_,}   "This block will be executed when the difference is more than C";
 I0a*                    "Get an array of I length and all elements 0";
     C~)+                "Get -C value and append it to the above array";
         C1a*+           "Get C length array of 1s and concat with the above array";
              ]          "Wrap the two arrays, the cliff and the above one in an array";
               z1fb      "Transpose to get number pairs and add those pairs. For example";
                         "If we are at the right most index with H = 80 and C = 5,";
                         "The right section of the cliff looks like:";
                         "[ ... 80 80 80 80 80] and the array created in above step";
                         "looks like [ ... 0 0 0 0 -5 1 1 1 1 1]. After z, we have:";
                         "[ ... [80 0] [80 0] [80 0] [80 0] [80 -5] [1] [1] [1] [1] [1]]";
                         "After 1fb we get [ ... 80 80 80 80 75 1 1 1 1 1]";
                   _,    "Take a copy of the above resultant array and take its length";
I?                       "If difference was not greater than C, put I on stack";
                         "Now we either have the decremented index or new array length";
                         "on stack."
{ ... }h                 "This is a do while loop which makes sure that we iterate to";
                         "the left of the array. This loops runs till the top stack";
                         "element is 0 while not popping the top element";
        -H-,             "After the loop, we have the final cliff array and 0 on stack";
                         "Remove any 0 elements from the array, then remove any H";
                         "elements from the array and then take length to get the";
                         "number of columns which were modified";

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

Comments

फिर से

— फेन

@aditsu फिर से?

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

यह पहली बार नहीं है जब किसी ने मुझे सीजेएम में हराया है। और पहली बार ऐसा नहीं कर रहे हैं, हालांकि यह सुनिश्चित नहीं है कि क्या आपने कभी इसे सीधे प्रतिस्पर्धा में किया है।

— २१

हेह :) एल्गोरिथम के बारे में यह सब :)

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

Answer 2

CJam - 70

q~:C;:H0]H*$W%{[__W<\1>]z{~-}%{C>}#):I{I(_2$=C-tC,{I+_2$=)t}/}0?}h-H-,

इसे http://cjam.aditsu.net/ पर आज़माएं

स्पष्टीकरण:

q~                    read and evaluate the input
:C;                   store the 2nd number in C and remove
:H                    store the first number in H
0]H*                  make an array [H 0] and repeat it H times
$W%                   sort and reverse, obtaining [(H H's) (H 0's)] (initial cliff)
{                     loop...
    [__W<\1>]         make an array with the cliff without the first column
                      and the cliff without the last column
    z{~-}%            subtract the 2 arrays to get the height differences
    {C>}#             find the index of the first height diff. greater than C
    ):I               increment and store in I
    {                 if the value is non-zero (i.e. landslide occurring)
        I(_2$=C-t     subtract C from the corresponding column height
        C,            make an array [0 1 ... C-1]
        {             for each of those numbers
            I+        add I, obtaining a column index where some soil falls
            _2$=)t    increment the column height
        }/            end loop
    }0?               else break outer loop; end if
}h                    ...while the condition is true
-H-                   remove all 0 and H from the final stable cliff
,                     count the remaining columns

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

Answer 3

अजगर, 200 190 174

h,c=input();q=[h]*h+[0]*h
try:
 while 1:
    d=[b-a for a,b in zip(q[1:],q)];g=max(d);a=d.index(g)
    for i in range(c):q[a+1+i]+=1/(g>c);q[a]-=1
except:print sum(h>i>0for i in q)

विस्तारित संस्करण:

h, c = input()
# Initialize the heights
q = [h]*h + [0]*h
try:
    while 1:
        # Difference between the heights
        d = [b-a for a,b in zip(q[1:],q)]
        # It may error here, when h == 0, but thats okay
        g = max(d)
        a = d.index(g)
        for i in range(c):
            # This is the termination condition, when g <= c
            q[a+1+i] += 1 / (g>c)
            # Save the newline; also move this line to after termination
            q[a] -= 1
except:
    # Count all heights that have changed
    print sum(h > i > 0 for i in q)

संपादित करें: कुछ अनुकूलन के बाद, मैंने ब्रेक के माध्यम से अजीब लूप समाप्ति को समाप्त कर दिया (1 बाइट बचाता है)। लूप आधारित स्लाइस से स्लाइड को भी बदल दिया।

Comments

अच्छा! आप sum2 बाइट्स के लिए चौकोर कोष्ठकों को अंदर छोड़ सकते हैं । इसके अलावा, आमतौर पर पायथन में एक पूर्ण कार्यक्रम को परिभाषित करना बेहतर होता है, जिसके साथ इनपुट लेना h,c=input()और अंत में परिणाम को प्रिंट करना।

— ज़र्गब

मैंने इस समाधान पर ध्यान नहीं दिया और अपने थोड़े से खराब एक डी को पोस्ट किया: ओह ठीक है, प्रतियोगिता अच्छी है। शायद मैं देखूं कि क्या मैं खदान से कुछ बाइट्स निकाल सकता हूं। वैसे, अपनी तुलनाओं को अपने में समेटने से sumआप बच सकते हैं:sum(h>i>0for i in q) :।

— भूमिगत

@undergroundmonorail मैंने बहुत कोशिश की, लेकिन मुझे डर है कि आपका दृष्टिकोण बस श्रेष्ठ है :(! c=0एक बाइट बचाता है (मैं आपके उत्तर पर टिप्पणी नहीं कर सकता)

— फिलिप्पुस

Answer 4

पायथन 2 - 194 158 बाइट्स

h,c=input()
b=l=[h]*h+[0]*h
while b:
 b=0
 for i in range(len(l)-1):
  if l[i]-l[i+1]>c:
    for j in range(c):l[i-~j]+=1
    l[i]-=c;b=1
print sum(h>e>0for e in l)

(ध्यान दें कि एसई का मार्कडाउन दुभाषिया शाब्दिक टैब को 4 स्थानों में परिवर्तित करता है। इस कार्यक्रम की पंक्तियों 7 और 8 में एक ही टैब [यानी एक बाइट] प्रत्येक इंडेंटेशन का है।)

स्टड पर इनपुट लेता है, hपहले। उदाहरण के लिए:

$ ./landslide.py <<< '6, 2'
4

यह कार्यक्रम काफी सुधारों के माध्यम से किया गया है। मैं इस उत्तर को कुछ और प्रमुख संपादनों को समझाने के लिए संपादित कर रहा था, लेकिन यह लंबे समय से हो रहा था। यदि आप उत्सुक हैं तो आप संपादन इतिहास की जांच कर सकते हैं।

व्याख्या

सबसे पहले, hऔर cस्टडिन से पढ़े जाते हैं। पायथन 2 में, इसके input()बराबर है eval(raw_input()), यही वजह है कि मैं संख्याओं को अलग करने के लिए अल्पविराम के लिए कहता हूं। input()रिटर्न की एक तुतलों देता है, कोई रूपांतरण की आवश्यकता है।

इसके बाद, पूर्णांकों की एक सूची बनाई जाती है। यह 2*hलंबा है। पहली छमाही हैं hऔर दूसरी छमाही 0. हैं। मेरे पास यह दिखाने के लिए कोई तर्क नहीं है कि यह अनंत hएस को बाईं ओर और 0 को दाईं ओर अनुकरण करने के लिए पर्याप्त है । मैं बस इसमें फंस गया और यह सभी परीक्षण मामलों के लिए काम करता है, इसलिए यदि कोई व्यक्ति इनपुट पा सकता है तो वह मेरे लिए काम नहीं करता है, मुझे खुशी होगी कि वह इसे बदल देगा। वैसे भी, इस सूची को कहा जाता है l, लेकिन इसकी एक और प्रतिलिपि कहा जाता है b।

bमूल्य वास्तव में मायने नहीं रखता है, यह सब मायने रखता है कि यह सच्चाई है। एक गैर-रिक्त सूची सत्य और एकमात्र तरीका हैb खाली हो सकता है यदि h0 है, तो उस स्थिति में सही उत्तर अभी भी मुद्रित है। किसी भी अन्य मामले में, bयह सुनिश्चित करने के लिए सच्चाई है कि हम while b:लूप में प्रवेश करते हैं । हालांकि, पहली चीज जो लूप में होती है bवह 0 पर सेट होती है, एक फाल्सी वैल्यू। लूप के प्रत्येक पुनरावृत्ति के दौरान bविशेष रूप से एक सत्य एक पर वापस सेट किया जाना चाहिए या लूप समाप्त हो जाएगा।

शेष लूप वास्तविक सिमुलेशन है। यह बहुत भोला है, अनिवार्य रूप से सिर्फ समस्या के वर्णन का एक कोड अनुवाद है। यदि किसी भी तत्व का अनुसरण करने वाले से lअधिक से cअधिक है, तो इसे घटाया जाता हैc और अगले cतत्वों में 1 जोड़ा जाता है। (यहाँ प्रयुक्त बिटवाइज़ मैजिक i+1+j, लिखने का एक छोटा तरीका है । इन परिवर्तनों को बनाते समय, 1 bपर सेट किया जाता है। पहली बार कोई परिवर्तन नहीं किया जाता है, b0 रहेगा और लूप समाप्त हो जाता है।

करने के लिए किसी भी सच्ची अभिव्यक्ति मूल्यांकन करता है True, और जब आप पर गणित करने की कोशिश Trueयह 1. एक ही का सच है पर मूल्यांकन करता है Falseऔर 0. कार्यक्रम की अंतिम पंक्ति के प्रत्येक तत्व का उपयोग करता है lके रूप में eअभिव्यक्ति में h>e>0और रकम परिणाम। इससे स्तंभों की संख्या 0 से अधिक हो जाती है, लेकिन मूल चट्टान की ऊंचाई से कम होती है, जो कि वह प्रश्न है जिसके लिए प्रश्न पूछता है। यह मुद्रित है और कार्यक्रम से बाहर निकलता है।

Comments

के c-=cबराबर नहीं है c=0?

— 19

...वाह। मेरी पीठ देखने के लिए धन्यवाद, मुझे यह पकड़ना चाहिए था, हाहा

— भूमिगत

i+1+jके रूप में लिखा जा सकता हैi-~j

— Sp3000

@ Sp3000 मैं बिटवाइज़ मैजिक के बारे में पूरी तरह भूल गया! साभार: D

— अंडरग्राउंडोरेल

Answer 5

हास्केल, 163 156 151 बाइट्स

h#c=sum[1|e<-(until=<<((==)=<<))s$r h++r 0,e`mod`h/=0]where r=replicate$h+1;s w@(x:y:z)|x==0=w|x>c+y=x-c:map(+1)(take c(y:z))++drop c(y:z)|1<2=x:s(y:z)

उपयोग: h#cउदाहरण के लिए, 6#2जो आउटपुट 4।

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

Stackoverflowuntil=<<((==)=<<) में "(जब तक आउटपुट नहीं बदलता है" फंक्शन (यानी ) लागू होता है ।

Comments

आप finfix ( h#c=...) के रूप में परिभाषित करके और whereएक ही पंक्ति में क्लॉज को स्थानांतरित करके बाइट्स के एक जोड़े को बचा सकते हैं । इसके अलावा, वहाँ अभी भी कुछ कोष्ठक का उपयोग करने के लिए शेड कर रहे हैं $, हालांकि मुझे यकीन नहीं है कि कितने ...

— Zgarb

@Zbb: संकेत के लिए धन्यवाद। मेरे ()साथ $पगडंडी बदलना और त्रुटि है।

— निमि

Answer 6

गणितज्ञ, 108 104 100 97 95

f=Max@#-Min@#&[0Range@#2//.{x___,k:##..&[a_,{#}],a_,y___}:>Sort@{x,##&@@({k}-1),a+#,y}/.{}->0]&

उपयोग:

f[c, h]

उदाहरण:

f[5, 80]

28

Answer 7

सी # 303 295

यह काम करता हैं!

लेकिन यह एक है ...।

int q(int n,int c){var s=Enumerable.Repeat(n,n).ToList();s.Add(0);var d=new HashSet<int>();var g=true;while(g){g=false;for(int i=s.Count-1;i>0;i--){int z=i;int y=i-1;if((s[y]-s[z])>c){s[y]-=c;d.Add(y);g=true;for(int j=1;j<=c;j++){s[y+j]++;d.Add(y+j);if(s[s.Count-1]>0)s.Add(0);}break;}}}return d.Count;}

मुझे नई भाषा मिलनी चाहिए)

मैं इस CJam बात की जाँच करेंगे ...

बेहतर:

int q(int n,int c){var s=Enumerable.Repeat(n,n).ToList();s.Add(0);var d=new HashSet<int>();var g=1>0;while(g){g=1<0;for(int i=s.Count-1;i>0;i--){int z=i,y=i-1;if((s[y]-s[z])>c){s[y]-=c;d.Add(y);g=1>0;for(int j=1;j<=c;j++){s[y+j]++;d.Add(y+j);if(s[s.Count-1]>0)s.Add(0);}break;}}}return d.Count;}

Comments

आप अभी भी इसे थोड़ा अनुकूलित कर सकते हैं। int z=i;int y=i-1;हो सकता है int z=i,y=i-1;। forछोरों उनके सूचकांकों के साथ चीजों को जटिल नहीं है, इसलिए जैसे for(int i=s.Count-1;i>0;i--)हो सकता है for(int i=s.Count;--i>0;)। 1<0लिखने का एक छोटा तरीका है false। मुझे संदेह है कि if(s[s.Count-1]>0)s.Add(0);शुद्धता को प्रभावित किए बिना स्थिति खो सकती है, बस गति।

— पीटर टेलर

@ अभिनेता टेलर। धन्यवाद!

— माइक