ল্যান্ডস্লাইড পূর্বাভাস

Question

ধ্বস

এই চ্যালেঞ্জে আপনার কাজটি হ'ল একটি বিশাল ভূমিধসের কারণে যে পরিমাণ ক্ষয়ক্ষতি হয়েছে তার পূর্বাভাস দেওয়া। আমরা এটির জন্য নীচের সরলিকৃত দ্বি-মাত্রিক মডেলটি ব্যবহার করি, একটি প্রাথমিক উচ্চতা h >= 0 এবং একটি সমালোচক সহগ দ্বারা পরামিতি c > 0। আপনি উচ্চতার খিঁচুনি দিয়ে শুরু করুন h, এবং ধারণা করা হয় যে এই অঞ্চলটি বাম এবং এর ডানদিকে সম্পূর্ণ সীমিত flat কারণ 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পার্থক্যের চেয়ে কম বা সমান have
• অ্যারে থেকে যে কোনও 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

সিজেম - 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 টি স্পেসে রূপান্তরিত করে this এই প্রোগ্রামের 7 এবং 8 টি লাইনের প্রতিটি ইনডেন্টেশনের একটিমাত্র ট্যাব [অর্থাৎ একটি বাইট রয়েছে])

hপ্রথমে স্ট্ডিনে ইনপুট নেয় । উদাহরণ স্বরূপ:

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

এই প্রোগ্রামটি অনেক উন্নতির মধ্য দিয়ে গেছে। আরও কয়েকটি বড় সম্পাদনার ব্যাখ্যা দেওয়ার জন্য আমি এই উত্তরটি সম্পাদনা করছিলাম তবে এটি এক ধরণের দীর্ঘতর হয়ে উঠছিল। আপনি যদি কৌতূহলী হন তবে সম্পাদনার ইতিহাসটি পরীক্ষা করতে পারেন।

ব্যাখ্যা

প্রথম, hএবং cস্ট্ডিন থেকে পড়া হয়। পাইথন 2- input()তে সমান eval(raw_input()), যার জন্য আমি সংখ্যাগুলি পৃথক করে কমা চাইছি। input()ইনটসকে টুপল দেয়, কোনও রূপান্তর প্রয়োজন হয় না required

এরপরে, পূর্ণসংখ্যার একটি তালিকা তৈরি করা হয়। এটি 2*hদীর্ঘ। প্রথমার্ধটি হয় hএবং দ্বিতীয়ার্ধটি হয় ০। আমার hবামে অসীম ও ডানদিকে 0s অনুকরণ করার পক্ষে এটি যথেষ্ট তা প্রমাণ করার কোনও যুক্তি নেই। আমি কেবল এটিকে হোঁচট খেয়েছি এবং এটি সমস্ত পরীক্ষার ক্ষেত্রে কাজ করে, তাই যদি কেউ ইনপুট পেতে পারে তবে এটি কাজ করে না আমি আনন্দের সাথে এটি পরিবর্তন করব। যাইহোক, এই তালিকাটি বলা হয় l, তবে এর অন্য একটি অনুলিপি বলা হয় b।

bএর মান আসলে কোনও বিষয় নয়, এটি যে সত্য তা সত্য। একটি খালি খালি তালিকা সত্য এবং একমাত্র উপায় bএখানে খালি হতে পারে যদি h0 হয়, সেক্ষেত্রে সঠিক উত্তরটি এখনও মুদ্রিত রয়েছে। অন্য যে কোনও ক্ষেত্রে, bআমরা while b:লুপটি প্রবেশ করানোর বিষয়টি নিশ্চিত করতে সত্যবাদী হতে হবে । যাইহোক, bলুপটিতে প্রথম যেটি ঘটে তা হ'ল একটি ভুয়া মান setting লুপের প্রতিটি পুনরাবৃত্তি চলাকালীন bঅবশ্যই একটি সত্য সত্যে ফিরে যেতে হবে বা লুপটি শেষ হবে।

বাকি লুপটি আসল সিমুলেশন। এটি খুব নিষ্পাপ, মূলত সমস্যা বর্ণনার একটি কোড অনুবাদ হ'ল। কোন উপাদান যদি lবেশী cএটা নিম্নলিখিত এক তার চেয়ে অনেক বেশী, এটি দ্বারা বিয়োগ করা হয় cএবং পরবর্তী cউপাদানের 1 তাদের যোগ করেছেন। (এখানে ব্যবহৃত বিটওয়াইজ যাদুটি লেখার কেবল একটি ছোট্ট উপায়, i+1+jউপায় দ্বারা)) এই রূপান্তরগুলি bতৈরি করার সময় , সেট করা হয়েছে The প্রথমবার কোনও রূপান্তর করা bহবে না , 0 থাকবে এবং লুপটি সমাপ্ত হবে।

যে কোনও সত্য প্রকাশটি মূল্যায়ন করে True, এবং আপনি যখন Trueএটিতে গণিত করার চেষ্টা করেন তখন এটি 1 টি মূল্যায়ন করে The একই ক্ষেত্রে সত্য False0 এবং 0 প্রোগ্রামটির সর্বশেষ লাইনটি অভিব্যক্তির lমতো প্রতিটি উপাদান ব্যবহার করে এবং ফলাফলটির যোগফল দেয় ms এটি 0 টির চেয়ে বেশি কলামের সংখ্যা পেয়েছে তবে মূল ক্লিফের উচ্চতার চেয়ে কম যা প্রশ্নটি জিজ্ঞাসা করে value এটি মুদ্রিত এবং প্রোগ্রামটি প্রস্থান করে।eh>e>0

Comments

c-=cসমান নয় কি c=0?

— জাগারব

...কি দারুন. আমার পিছনে দেখার জন্য ধন্যবাদ, আমি যে ধরা উচিত ছিল, হা

— আন্ডারগ্রাউন্ডোরিওরাইল

i+1+jহিসাবে লেখা যেতে পারেi-~j

— Sp3000

@ Sp3000 আমি বিটওয়াইজ ম্যাজিক সম্পর্কে পুরোপুরি ভুলে গেছি! ধন্যবাদ: ডি

— আন্ডারগ্রাউন্ডোমোনাইল

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আউটপুট আর পরিবর্তন না হওয়া পর্যন্ত বারবার প্রয়োগ করুন । প্রভাবিত উপাদানগুলি গণনা করুন।

পাওয়া "আউটপুট পর্যন্ত প্রযোজ্য পরিবর্তন করে না" ফাংশন (যেমন until=<<((==)=<<)কোণে) Stackoverflow ।

Comments

আপনি fইনফিক্স ( h#c=...) হিসাবে সংজ্ঞায়িত করে এবং whereধারাটি একই লাইনে সরিয়ে কয়েকটি বাইট সংরক্ষণ করতে পারেন । এছাড়াও, এখনও ব্যবহার করার জন্য কয়েকটি বন্ধনী রয়েছে $, যদিও আমি নিশ্চিত না কতজন ...

— জাগারব

@ জগারব: ইঙ্গিতগুলির জন্য ধন্যবাদ এর সাথে প্রতিস্থাপন ()করা $আমার জন্য ট্রেইল এবং ত্রুটি।

— নিমি

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;}

আমি অবশ্যই নতুন ভাষা সন্ধান করব;)

আমি এই সিজেম জিনিসটি পরীক্ষা করব ...

উন্নত:

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);নির্ভুলতা, গতিবেগকে প্রভাবিত না করেই শর্তটি হারাতে পারে।

— পিটার টেলর

@ পিটার টেইলর ধন্যবাদ!

— মাইক এম