ব্যাটব্লক থিয়েটার ধাঁধা সমাধান করুন

Question

গেম ব্যাটলক থিয়েটারে মাঝে মধ্যে একটি ধাঁধা থাকে যা লাইটস আউট এর একটি সাধারণ সংস্করণ । আপনি তিনটি সংলগ্ন ব্লক পেয়েছেন, যার প্রতিটি বারের সাথে সমেত 1 এবং 4 এর মধ্যে একটি স্তর নির্দেশ করে:

|
||||
||

আপনি যদি কোনও ব্লক স্পর্শ করেন, তবে সেই ব্লকটির সাথে সাথে যে কোনও সংলগ্ন ব্লকও এর স্তরটিকে বাড়িয়ে তুলবে (4 থেকে 1 এ পিছনে মোড়ানো)। ধাঁধাটি সমাধান করা হয় যখন তিনটি ব্লক একই স্তর দেখায় (কোন স্তরের বিষয়টি বিবেচনা করে না)। যেহেতু, আপনি ব্লকগুলিতে যে অর্ডারটি স্পর্শ করছেন তাতে কিছু আসে যায় না, আমরা প্রতিটি ব্লককে কতবার স্পর্শ করা হয় তার দ্বারা সমাধানটি বোঝাই। উপরের ইনপুটটির সর্বোত্তম সমাধানটি হ'ল 201:

|    --> || --> |||     |||
||||     |      ||      |||
||       ||     ||  --> |||

গেমটি খুব সহজেই কয়েকটি সংখ্যক ব্লককে সাধারণীকরণ করে, যদিও কয়েকটি সংখ্যার জন্য, সমস্ত কনফিগারেশনগুলি সমাধানযোগ্য হয় না।

চ্যালেঞ্জ

ব্লক স্তরের ক্রম দেওয়া, ধাঁধাটি সমাধান করার জন্য প্রতিটি ব্লকের কতবার স্পর্শ করা দরকার তা ফিরে আসুন। যেমন উপরের উদাহরণটি দেওয়া হবে 142এবং 201ফলস্বরূপ ফলন করতে পারে yield যদি কোনও সমাধান না হয়, আপনার পছন্দসই কিছু সামঞ্জস্যপূর্ণ আউটপুট ফিরিয়ে দিন , যা সমস্ত সম্ভাব্য সমাধানগুলি থেকে পৃথক, যেমন -1বা খালি স্ট্রিং।

আপনি কোনও ফাংশন বা প্রোগ্রাম লিখতে পারেন, কোনও সুবিধাজনক তালিকা বা স্ট্রিং বিন্যাসে STDIN, কমান্ড-লাইন আর্গুমেন্ট বা ফাংশন আর্গুমেন্টের মাধ্যমে ইনপুট নিতে পারেন এবং একইভাবে কোনও রিটার্ন মান বা STDOUT এ মুদ্রণের মাধ্যমে আউটপুট নিতে পারেন।

আপনার কোডটি একটি যুক্তিসঙ্গত মেশিনে এক মিনিটের মধ্যে সমস্ত পরীক্ষার ক্ষেত্রে সঠিক ফলাফলগুলি ফিরিয়ে আনতে হবে। (এটি সম্পূর্ণ কঠোর সীমা নয়, সুতরাং আপনার সমাধানটি যদি এক মিনিট দশ সেকেন্ড সময় নেয় তবে তা ঠিক আছে, তবে এটি যদি 3 মিনিট সময় নেয় তবে তা হয় না A একটি ভাল অ্যালগরিদম এগুলি সহজেই সেকেন্ডে সমাধান করবে will)

এটি কোড গল্ফ, তাই সংক্ষিপ্ত উত্তরটি (বাইটে) জেতে।

উদাহরণ

সমাধানগুলি অনন্য নয়, তাই আপনি বিভিন্ন ফলাফল পেতে পারেন।

Input                          Output

1                              0
11                             00
12                             No solution
142                            201
434                            101
222                            000
4113                           0230
32444                          No solution
23432                          10301
421232                         212301
3442223221221422412334         0330130000130202221111
22231244334432131322442        No solution
111111111111111111111222       000000000000000000000030
111111111111111111111234       100100100100100100100133
412224131444114441432434       113013201011001101012133

যতদূর আমি জানি, প্রতিটি ইনপুটটির জন্য ঠিক 4 টি সমাধান রয়েছে যেখানে ব্লকের সংখ্যা 0 মড 3, বা 1 মড 3 এবং সেখানে 0 বা 16 সমাধান রয়েছে যেখানে এটি 2 মোড 3।

Comments

আপনার কি সর্বোত্তম সমাধান আউটপুট করতে হবে?

— xnor

@ এক্সনর না, আপনি না

— মার্টিন এন্ডার

আমাদের কি ঠিক একটি সমাধান মুদ্রণ করতে হবে বা আমরা সেগুলিও মুদ্রণ করতে পারি?

— জাকুব

@ জাকুব ঠিক একটি দয়া করে। আমার সকলের / সর্বোত্তম সমাধানের জন্য একটি বোনাস যুক্ত করা উচিত ছিল, তবে আমি তাড়াতাড়ি যথেষ্ট মনে করিনি, সুতরাং এটি কোনও (এক) সমাধান।

— মার্টিন এন্ডার

Answer 1

পাইথন 2, 115 বাইট

n=input()
for F in range(4):
 t=[F];b=0;exec"x=(-n[b]-sum(t[-2:]))%4;t+=x,;b+=1;"*len(n)
 if x<1:print t[:-1];break

মার্টিনের সাথে সমস্যাটি আলোচনার সময় আমি যে প্রোগ্রামটি লিখেছিলাম এটির গল্ফ সংস্করণ।

ইনপুটটি STDIN এর মাধ্যমে একটি তালিকা। আউটপুট হল এমন একটি তালিকা যা সলিউশন পাওয়া গেলে পাওয়া শেষ সমাধানের প্রতিনিধিত্ব করে, বা শূন্য না থাকলে। উদাহরণ স্বরূপ:

>>>
[1, 4, 2]
[2, 1, 1]
>>>
[1, 2]
0
>>>
map(int,"3442223221221422412334")
[2, 3, 3, 2, 1, 3, 2, 0, 0, 2, 1, 3, 2, 2, 0, 0, 2, 2, 3, 1, 1, 3]

---

পাইথ, 32 29 বাইট

V4J]NVQaJ%_+s>J_2@QN4)I!eJPJB

বাধ্যতামূলক বন্দর। 3 জ্যাকেট 3 জ্যাকেট সংরক্ষণের জন্য ধন্যবাদ

ইনপুট পদ্ধতি উপরের মতো একই, এটি অনলাইনে চেষ্টা করুন ।

---

ব্যাখ্যা (দীর্ঘ এবং লজিক পূর্ণ!)

প্রথম, দুটি প্রাথমিক পর্যবেক্ষণ:

• পর্যবেক্ষণ 1: আপনি যে আদেশগুলিতে ব্লকগুলি স্পর্শ করছেন তা বিবেচ্য নয়

• পর্যবেক্ষণ 2: আপনি যদি কোনও ব্লকটি 4 বার স্পর্শ করেন তবে এটি একবার স্পর্শ করার সমতুল্য

অন্য কথায়, যদি কোনও সমাধান হয় তবে এমন একটি সমাধান রয়েছে যেখানে স্পর্শের সংখ্যা 0 এবং 3 এর মধ্যে অন্তর্ভুক্ত।

মডুলো 4 যেহেতু খুব সুন্দর, তাই ব্লকগুলির সাথে এটিও করা হোক। এই ব্যাখ্যার বাকী অংশের জন্য, ব্লক স্তর 0 ব্লক স্তর 4 এর সমান।

এখন বোঝাতে দিন a[k]ব্লক বর্তমান স্তর হতে kএবং x[k]আমরা ব্লক স্পর্শ যতবার হতে kএকটি সমাধান হবে। এছাড়াও nব্লকের মোট সংখ্যা হতে দিন । @ জাকুবে উল্লেখ করেছেন যে, একটি সমাধান অবশ্যই সন্তুষ্ট করবে:

  a[0]   + x[0] + x[1]
= a[1]   + x[0] + x[1] + x[2]
= a[2]          + x[1] + x[2] + x[3]
= a[3]                 + x[2] + x[3] + x[4]
...
= a[n-1]                                     ...  + x[n-2] + x[n-1] + x[n]
= a[n]                                       ...           + x[n-1] + x[n]
= C

Cচূড়ান্ত স্তরটি যেখানে সমস্ত ব্লক শেষ হয়, 0 থেকে 3 এর মধ্যে অন্তর্ভুক্ত থাকে (মনে রাখবেন আমরা স্তর 4 স্তরকে 0 হিসাবে বিবেচনা করছি) এবং উপরের সমস্ত সমীকরণগুলি সত্যই একত্রিত করা মডেল 4।

এখন মজার অংশটি এখানে:

• পর্যবেক্ষণ 3 : যদি কোনও সমাধান বিদ্যমান থাকে তবে যে কোনও চূড়ান্ত ব্লক স্তরের জন্য একটি সমাধান বিদ্যমান 0 <= C <= 3।

ব্লকগুলির মডুলো ৩ এর ভিত্তিতে তিনটি কেস রয়েছে যার প্রতিটিটির ব্যাখ্যা একই রকম - যে কোনও ব্লকের জন্য, সেখানে একটি ব্লকের একটি উপসেট উপস্থিত রয়েছে যা আপনি যদি তাদের প্রত্যেককে একবার স্পর্শ করেন তবে সমস্ত ব্লকের স্তর বৃদ্ধি করে ঠিক 1।

0 mod 3 (touch every third block starting from the second):
    .X. / .X. / .X.

1 mod 3 (touch every third block starting from the first):
    X. / .X. / .X. / .X

2 mod 3 (touch every third block starting from either the first or second):
    X. / .X. / .X. / .X.
    .X. / .X. / .X. / .X

এটি ব্যাখ্যা করে যে কেন 0 mod 3এবং এর জন্য 4 সমাধান রয়েছে 1 mod 3এবং সাধারণত 16 টি সমাধান 2 mod 3। আপনার যদি ইতিমধ্যে একটি সমাধান থাকে তবে উপরের মতো ব্লকগুলি স্পর্শ করা অন্য একটি সমাধান দেয় যা উচ্চতর ব্লক স্তরে শেষ হয় (চারপাশে মোড়ানো)।

তাহলে এর অর্থ কি? আমরা Cচাই যে কোনও চূড়ান্ত ব্লক স্তর বেছে নিতে পারি! আসুন বাছাই করুন C = 0, কারণ এটি বাইটগুলিতে সঞ্চয় করে।

এখন আমাদের সমীকরণগুলি হয়ে:

0 = a[0] + x[0] + x[1]
0 = a[1] + x[0] + x[1] + x[2]
0 = a[2] + x[1] + x[2] + x[3]
0 = a[3] + x[2] + x[3] + x[4]
...
0 = a[n-1] + x[n-2] + x[n-1] + x[n]
0 = a[n] + x[n-1] + x[n]

এবং পুনর্বিন্যাস:

x[1] = -a[0] - x[0]
x[2] = -a[1] - x[0] - x[1]
x[3] = -a[2] - x[1] - x[2]
x[4] = -a[3] - x[2] - x[3]
...
x[n] = a[n-1] - x[n-2] - x[n-1]
x[n] = a[n] - x[n-1]

সুতরাং আমরা যা দেখতে পাচ্ছি তা হ'ল, যদি আমাদের থাকে তবে আমরা একে x[0]অপরের সন্ধানের জন্য শেষ ব্যতীত সমস্ত সমীকরণ ব্যবহার করতে পারি x[k]। শেষ সমীকরণটি একটি অতিরিক্ত শর্ত যা আমাদের অবশ্যই চেক করা উচিত।

এটি আমাদের একটি অ্যালগরিদম দেয়:

• জন্য সমস্ত মান চেষ্টা করুন x[0]
• অন্যান্য সমস্ত কাজ করার জন্য উপরের সমীকরণগুলি ব্যবহার করুন x[k]
• শেষ শর্তটি সন্তুষ্ট কিনা তা পরীক্ষা করে দেখুন। যদি তা হয় তবে সমাধানটি সংরক্ষণ করুন।

এটি উপরের সমাধান দেয়।

তাহলে কেন আমরা মাঝে মাঝে সমাধান পাই না 2 mod 3? আসুন এই দুটি নিদর্শন আবার একবার দেখুন:

X. / .X. / .X. / .X.
.X. / .X. / .X. / .X

এখন সেই অবস্থানগুলিতে সমীকরণগুলি বিবেচনা করুন, প্রথমটির জন্য:

0 = a[0] + x[0] + x[1]
0 = a[3] + x[2] + x[3] + x[4]
0 = a[6] + x[5] + x[6] + x[7]
0 = a[9] + x[8] + x[9] + x[10]

এগুলি যুক্ত করুন:

0 = (a[0] + a[3] + a[6] + a[9]) + (x[0] + x[1] + ... + x[9] + x[10])

দ্বিতীয়টির জন্য:

0 = a[1] + x[0] + x[1] + x[2]
0 = a[4] + x[3] + x[4] + x[5]
0 = a[7] + x[6] + x[7] + x[8]
0 = a[10] + x[9] + x[10]

এগুলি আবার যুক্ত করুন:

0 = (a[1] + a[4] + a[7] + a[10]) + (x[0] + x[1] + ... + x[9] + x[10])

সুতরাং (a[1] + a[4] + a[7] + a[10])এবং যদি (a[0] + a[3] + a[6] + a[9])সমান না হয়, তবে আমাদের কোনও সমাধান নেই। তবে যদি সেগুলি সমান হয়, তবে আমরা 16 টি সমাধান পাই। এটি n = 11ক্ষেত্রে ছিল, তবে অবশ্যই এটি যে কোনও সংখ্যায় সাধারণীকরণ করে 2 mod 3- দ্বিতীয় থেকে শুরু করে প্রতি তৃতীয় উপাদানটির যোগফল নিয়ে যান এবং প্রথম থেকে শুরু হওয়া প্রতিটি তৃতীয় উপাদানের যোগফলের সাথে তুলনা করুন।

এখন অবশেষে, x[0]সম্ভাবনার সমস্ত চেষ্টা করার পরিবর্তে কী থাকতে হবে তা নির্ধারণ করা সম্ভব? সর্বোপরি, যেহেতু আমরা আমাদের টার্গেট স্তরটি C0-তে সীমাবদ্ধ করেছি , কেবলমাত্র একটিই আছে x[0]যা ক্ষেত্রে 0 mod 3বা 1 mod 3ক্ষেত্রে সমাধান দেয় 4 solutions / 4 final levels = 1 solution for a specific final level।

উত্তরটি হল হ্যাঁ! আমরা এটির জন্য এটি করতে পারি 0 mod 3:

 .X..X
.X..X.

যা অনুবাদ করে:

0 = a[2] + x[1] + x[2] + x[3]   -> 0 = (a[2] + a[5]) + (x[1] + ... + x[5])
0 = a[5] + x[4] + x[5]          /


0 = a[1] + x[0] + x[1] + x[2]   -> 0 = (a[1] + a[4]) + (x[0] + x[1] + ... + x[5])
0 = a[4] + x[3] + x[4] + x[5]   /

বিয়োগ দেয়:

x[1] = (a[2] + a[5]) - (a[1] + a[4])

একইভাবে 1 mod 3আমরা এই প্যাটার্নটি করতে পারি:

 .X..X.
X..X..X

যা দেয়:

x[0] = (a[2] + a[5]) - (a[0] + a[3] + a[6])

এগুলি অবশ্যই সূচকগুলি 3 বৃদ্ধি করে বাড়িয়ে তোলে।

জন্য 2 mod 3, যেহেতু আমরা দুই সাব-সেট নির্বাচন যা প্রতি ব্লক আবরণ আছে, আমরা আসলে কোন বাছাই করতে পারেন x[0]। প্রকৃতপক্ষে, এটি সত্য x[0], x[1], x[3], x[4], x[6], x[7], ...(মূলত কোনও সূচকই সমান নয় 2 mod 3, কারণ সেগুলি কোনও উপসেট দ্বারা আচ্ছাদিত নয়)।

সুতরাং আমাদের কাছে x[0]সমস্ত সম্ভাবনার চেষ্টা করার পরিবর্তে বাছাইয়ের একটি উপায় রয়েছে ...

... তবে খারাপ খবরটি এটি বাইটগুলি (124 বাইট) সংরক্ষণ করে না:

def f(n):s=[];L=len(n);B=sum(n[~-L%3::3])-sum(n[-~L%3::3]);x=A=0;exec"s+=B%4,;A,B=B,-n[x]-A-B;x+=1;"*L*(L%3<2or B<1);print s

Comments

চালাক। ব্যবহার করে আপনি 1 গৃহস্থালির কাজ সংরক্ষণ করতে পারবেন Jপরিবর্তে H, এবং 2 অক্ষর যদি আপনি শেষ উপাদান পপ PJslicing পরিবর্তে। <J_1। V4J]NVQaJ%_+s>J_2@QN4)I!eJPJB

— জাকুবে

@ জাকুব আহ ধন্যবাদ আমি যখন পপ পড়ি তখন ভেবেছিলাম তালিকা থেকে অপসারণের সময় পাইথন পপ শেষ উপাদানটি ফিরে আসছিল। এখন আমি দেখছি যে ঘটনাটি নয়।

— Sp3000

Answer 2

পাইথ, 72 76 73 66 39 38 অক্ষর

Ph+f!eTmu+G%+&H@G_3-@QH@QhH4UtQd^UT2]Y

সম্পাদনা 4: উপলব্ধি, যে গণনা Q[N]-Q[N+1]+solution[-3]এবং Q[-2]-Q[-1]+solution[-3]অভিন্ন। অতএব আমি সমাধানটি 1 দ্বারা অবিচ্ছিন্ন করে সমাধানগুলি ফিল্টার করি, যেখানে শেষ এন্ট্রি 0 হয়। তারপরে আমি শেষ এন্ট্রিটি পপ করি। ভাগ্যক্রমে বিশেষ ক্ষেত্রে এই পদ্ধতির সাথে অতিরিক্ত চিকিত্সার প্রয়োজন হয় না। -27 চরিত্র

3 সম্পাদনা করুন: FryAmTheEggman: -7 অক্ষর থেকে কিছু গল্ফিং কৌশল প্রয়োগ করা

সম্পাদনা 2: ফিল্টার ব্যবহার, হ্রাস এবং মানচিত্র: -3 অক্ষর

সম্পাদনা 1: আমার প্রথম সংস্করণে আমি কোনও মুদ্রণ করি নি, যদি কোনও সমাধান না হয়। আমি মনে করি না এটি অনুমোদিত, সুতরাং +4 অক্ষর।

পূর্ণসংখ্যার একটি তালিকা ইনপুট হিসাবে প্রত্যাশা করে [1,4,2]এবং [2,0,1]যদি একটি থাকে তবে একটি বৈধ সমাধান আউটপুট দেয় , অন্যথায় একটি খালি তালিকা []।

ব্যাখ্যা:

দিন Q5 স্তরের তালিকা এবং হতে Yসমাধান তালিকা। নিম্নলিখিত সমীকরণগুলি ধরে রাখতে হবে:

  Q0 + Y0 + Y1 
= Q1 + Y0 + Y1 + Y2
= Q2      + Y1 + Y2 + Y3
= Q3           + Y2 + Y3 + Y4
= Q4                + Y3 + Y4

অতএব আমরা যদি কোনো একটি ব্যবহার Y0এবং Y1আমরা নিরূপণ করতে পারেন Y2, Y3এবং Y4নিম্নলিখিত পদ্ধতিতে।

Y2 = (Q0 - Q1     ) mod 4
Y3 = (Q1 - Q2 + Y0) mod 4
Y4 = (Q2 - Q3 + Y1) mod 4

সমস্ত স্তরের তুলনায় সর্বশেষটি সমান হয় (কারণ আমরা সমীকরণটি ব্যবহার করি নি = Q4 + Y3 + Y4। পরীক্ষা করার জন্য, এই শেষটিটি যদি অন্যান্য স্তরেরও সমান হয়, তবে আমরা খালি পরীক্ষা করতে পারি (Q3 - Q4 + Y2) mod 4 == 0। লক্ষ্য করুন, বাম অংশটি মান হবে Y5.আমি যদি সমাধানটির the ষ্ঠ অংশ গণনা করি তবে আমি তা শূন্য কিনা তা খালি পরীক্ষা করতে পারি।

আমার পদ্ধতির মধ্যে আমি সহজভাবে সমস্ত সম্ভাব্য শুরুগুলি ( [0,0], থেকে [3,3]), এবং দৈর্ঘ্য (ইনপুট) -1 আরও বেশি এন্ট্রি গণনা করি এবং শূন্যের সাথে শেষ হওয়া সমস্ত সমাধান ফিল্টার করি।

mu+G%+&H@G_3-@QH@QhH4UtQd^UT2   generates all possible solutions

এটি মূলত নিম্নলিখিত:

G = start value           //one of "^UT2", [0,0], [0,1], ..., [9,9]
                          //up to [3,3] would be enough but cost 1 char more
for H in range(len(Q)-1): //"UtQ"
   G+=[(H and G[-3])+(Q(H)-Q(H+1))%4] //"+G%+&H@G_3-@QH@QhH4"
   //H and G[-3] is 0, when H is empty, else G[-3]

তারপরে আমি বৈধদের জন্য এই সম্ভাব্য সমাধানগুলি ফিল্টার করি:

f!eT //only use solutions, which end in 0

সমাধানের তালিকায় আমি একটি খালি তালিকা সংযোজন করি, যাতে এতে কমপক্ষে একটি আইটেম থাকে

 +....]Y

এবং প্রথম সমাধানটি নিন h, শেষ উপাদানটি পপ করুন pএবং এটি মুদ্রণ করুন

 Ph

লক্ষ্য করুন, এটির জন্যও কাজ করে, যদি কেবল একটি ব্লক থাকে। আমার পদ্ধতির মধ্যে আমি প্রারম্ভিক অবস্থান পেয়েছি [0,0] এবং এটি প্রসারিত করে না। যেহেতু শেষ এন্ট্রি 0, এটি সমাধান [0] মুদ্রণ করে।

দ্বিতীয় বিশেষ কেস (2 ব্লক) সর্বোপরি বিশেষ নয়। নিশ্চিত নয়, কেন আমি আগে জিনিসগুলিকে বেশি জটিল করেছিলাম।

Comments

আমি মনে করি কোনও কিছুই মুদ্রণ কোনও সমাধানের জন্য ঠিক নেই যদি আপনি কেবল কিছু না মুদ্রণ করেন তবে এটিই এমন হয়। নিশ্চিত করার জন্য @ মার্টিনব্যাটনারকে পেতে হবে

— Sp3000

?**lQ]0qhQeQ<lQ3h+f!%-+ePQ@T_3eQ4mu+G]%+&H@G_3-@QH@QhH4UttQd^UT2]Y66 বাইট হয়। পারফরম্যান্সটি কিছুটা আঘাত পেয়েছিল তবে এটি এখনও আমার জন্য <1 এস মধ্যে সবচেয়ে বড় টেস্ট কেস চালায়। আপনি কিছু গল্ফের ব্যাখ্যা চাইলে আমাকে পিং করুন; এই মন্তব্যে পর্যাপ্ত জায়গা নেই;) আশা করি আপনি

— পাইথটি

+<list><int>এর একই প্রভাব রয়েছে +<list>]<int>, তাই আপনি প্রথমটি মুছে ফেলতে পারেন ]। এছাড়াও, খুব সুন্দর সমাধান।

— ইসাকাক

@ আইসাকের ক্ষেত্রেও কি একই সত্য ~? দেখে মনে হচ্ছে না যে আমি চেষ্টা করেছি

— Sp3000

@ Sp3000 ~সাথে প্রতিস্থাপন করুন a- ~<list>]<int>এর সমতুল্য a<list><int>। ~হয় +=, যখন aহয়.append()

— isaacg

Answer 3

রুবি, 320 313 অক্ষর

m=gets.chop.chars.map{|x|x.to_i-1}
a=m.map{0}
t=->n{m[n]+=1
m[n-1]+=1if n>0
m[n+1]+=1if n<m.size-1
m.map!{|x|x%4}
a[n]=(a[n]+1)%4}
t[0]until m[0]==1
(2...m.size).map{|n|t[n]until m[n-1]==1}
r=0
while m.uniq.size>1&&m[-1]!=1
(0...m.size).each_with_index{|n,i|([1,3,0][i%3]).times{t[n]}}
(r+=1)>5&&exit
end
$><<a*''

অবশ্যই আরও গল্ফ করা যেতে পারে। অবিশ্বাস্য ধাঁধা জন্য আউটপুট কিছুই।

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

#!/usr/bin/ruby

nums = gets.chomp.chars.map {|x| x.to_i-1 }
touches = nums.map {0}

# our goal: make all the numbers 1
# utility function
touch = ->n {
    nums[n] += 1
    nums[n-1] += 1 if n > 0
    nums[n+1] += 1 if n < (nums.length-1)
    nums.map! {|x| x % 4 }
    touches[n] = (touches[n] + 1) % 4
}

# first, start with the very first number
touch[0] until nums[0] == 1

# then, go from index 2 to the end to make the previous index right
(2...nums.length).each {|n|
    touch[n] until nums[n-1] == 1
}

iters = 0
if nums.uniq.length != 1
    # I have no idea why this works
    while nums[-1] != 1
        (0...nums.length).each_with_index {|n, i|
            ([1, 3, 0][i % 3]).times { touch[n] }
        }
        if (iters += 1) > 5
            puts -1
            exit
        end
    end
end

puts touches * ''

ঠিক আছে, এই মজা ছিল। উদাহরণগুলির মধ্যে একটিতে প্রদর্শিত হিসাবে {n}উপরের সংখ্যাটিতে এন "টাচ" এসকে উপস্থাপন করে এখানে বেসিক অ্যালগরিদম রয়েছে n:

we want each number to be a 1
first make the first number a 1
3442223221221422412334
2}
1242223221221422412334
 {3} now keep "touch"ing until the number to the left is a 1
1131223221221422412334
  {2}
1113423221221422412334
   {2}
1111243221221422412334
... (repeat this procedure)
1111111111111111111110

আমি এখানে কিছুটা স্টাম্পড হয়েছি। আমি কীভাবে 111...1110একই সংখ্যার একটি সিরিজে রূপান্তর করতে পারি ? সুতরাং আমি আমার সমাধান এবং সঠিক সমাধানটির সাথে তুলনা করেছি (দ্রষ্টব্য: "স্পর্শ" গণনাগুলি তাদের হওয়া উচিতের চেয়ে বড় কারণ ইনপুটটি 1-সূচিযুক্ত, এবং আউটপুট 0-সূচকযুক্ত):

3033233103233301320210
0330130000130202221111

আমি লক্ষ্য করেছি যে প্রতিটি সংখ্যা সঠিক নম্বর থেকে এক দূরে ছিল mod 4, সুতরাং আমি সেগুলিকে +এস, -এস এবং =এস দ্বারা চিহ্নিত করেছি :

3033233103233301320210 original program output
+-=+-=+-=+-=+-=+-=+-=+ amount to modify by (+1, -1, or 0 (=))
4334534404534602621511 result (the correct answer)

0330130000130202221111 (the original solution, digits equal to result mod 4)

এটি কিছুক্ষণ কাজ করেছিল, যতক্ষণ না আমি লক্ষ্য করেছি যে কখনও কখনও চূড়ান্ত ফলাফল হয় 111...11112বা 11...1113হয়! ভাগ্যক্রমে, বারবার .ন্দ্রজালিক সূত্র প্রয়োগ করা যা কোনও বুদ্ধিমান নয় তবে কাজগুলি এগুলি সাজিয়েও ফেলেছে।

তাই সেখানে যদি আপনি এটি আছে. এমন একটি প্রোগ্রাম যা বোধগম্যতা শুরু করে, তবে এটি আরও বেশি কুরুচিপূর্ণ হ্যাকনেসে যায়। কোড গল্ফ সমাধানের জন্য বেশ সাধারণ, আমি মনে করি। :)

Comments

আমি আপনার কোড শেষ মন্তব্যটি ভালবাসি :)। আপনি পরিবর্তন করে 2 অক্ষর সংরক্ষণ করতে পারবেন exit if (r+=1)>5করার (r+=1)>5&&exit। এছাড়াও (code)while condসিনট্যাক্সটি তার চেয়ে কম while cond \n code \n end।

— ক্রিশ্চিয়ান লুপাস্কু

Answer 4

পাইথন 2, 294,289,285,281 273 বাইট

n=input();l=len(n);s=[0]*l
for i in range(2,l):
 a=(n[i-2]-n[i-1])%4;s[i]+=a;n[i-1]+=a;n[i]+=a
 if i+1<l:n[i+1]+=a
 n=[a%4for a in n]
if l%3>1 and n!=[n[0]]*l:print"x"
else:
 for i in range(l%3,l-1,3):s[i]+=(n[l-1]-n[l-2])%4
 m=min(s);s=[(a-m)%4 for a in s];print s

ডেমো

আমি নিশ্চিত এটি আরও গল্ফ করা যেতে পারে ..

পরীক্ষার মামলার ফলাফলগুলি এখানে:

[1]
-> [0]

[1,1]
-> [0, 0]

[1,2]
-> x

[1,4,2]
-> [2, 0, 1]

[4,3,4]
-> [1, 0, 1]

[2,2,2]
-> [0, 0, 0]

[4,1,1,3]
-> [0, 2, 3, 0]

[3,2,4,4,4]
-> x

[2,3,4,3,2]
-> [0, 0, 3, 3, 1]

[4,2,1,2,3,2]
-> [2, 0, 2, 3, 3, 1]

[3,4,4,2,2,2,3,2,2,1,2,2,1,4,2,2,4,1,2,3,3,4]
-> [0, 3, 3, 0, 1, 3, 0, 0, 0, 0, 1, 3, 0, 2, 0, 2, 2, 2, 1, 1, 1, 1]

[2,2,2,3,1,2,4,4,3,3,4,4,3,2,1,3,1,3,2,2,4,4,2]
-> x

[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2]
-> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0]

[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,3,4]
-> [1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 3, 3]

[4,1,2,2,2,4,1,3,1,4,4,4,1,1,4,4,4,1,4,3,2,4,3,4]
-> [1, 0, 3, 0, 0, 3, 2, 3, 1, 0, 0, 1, 0, 3, 1, 1, 3, 1, 0, 0, 2, 1, 2, 3]

অ্যালগরিদম প্রথমে নিশ্চিত করে যে শেষ ব্লক ব্যতীত সমস্ত ব্লকের মান একই হয় (প্রথমটি ব্যতীত সমস্ত ব্লকের "স্পর্শ সংখ্যা" যুক্ত করে পুনরুক্তি করে)। তারপরে, যদি ব্লকের সংখ্যা এটির জন্য অনুমতি দেয় ( (num_of_blocks - 1) % 3 != 1), ফিরে যায় এবং নিশ্চিত হয়ে যায় যে বাকি ব্লকের মানগুলি শেষ ব্লকের সাথে মেলে। xকোনও সমাধান না হলে প্রিন্ট করুন ।