আপনার কাজটি হ'ল স্কোর বনাম কোড আকারের ক্ষেত্রে ভারসাম্যহীন একটি টেট্রিস কৌশল প্রয়োগ করা।
গেমের এই সংস্করণে টেট্রোমিনোসগুলি ঘোরানো হয় এবং উপরের থেকে 20 টি সারি এবং 10 কলামের গ্রিডে ফেলে দেওয়া হয়। পড়ার সময় এগুলি আড়াআড়িভাবে ঘোরানো বা সরানো যায় না। যথারীতি, যখন একটি গ্রিডের নীচে পৌঁছায় বা আরও নিচের দিকে গতি ইতিমধ্যে দখলকৃত স্কোয়ারের সাথে সংঘর্ষ ঘটায় তখন একটি টুকরো টুকরো টুকরো টুকরো হয়ে যায়।
nঅনুভূমিক রেখা সম্পূর্ণরূপে পূর্ণ হয়ে গেলে এগুলি একই সাথে ভেঙে যায়, গ্রিডটি nশীর্ষে খালি লাইন দিয়ে পুনরায় পূরণ করা হয় এবং স্কোর 2 এন -1 পয়েন্ট দ্বারা বৃদ্ধি পায় । জন্য n= 1,2,3,4 যথাক্রমে 1,3,7,15 পয়েন্ট যে। লাইনগুলি অদৃশ্য হওয়ার পরে, কিছু ব্লক বাতাসে ভাসমান থাকতে পারে (কোনও " মাধ্যাকর্ষণ চেইন প্রতিক্রিয়া নেই ")।
যখন পছন্দসইভাবে বর্তমান টুকরো উপস্থিত হওয়ার জন্য কোনও ঘর উপলব্ধ নেই, গ্রিডটি সাফ হয়ে যায়, বর্তমান অংশটি উপেক্ষা করা হয় এবং পরবর্তী অংশটি বর্তমান হিসাবে উপস্থিত থাকে as এর জন্য কোনও জরিমানা নেই।
আপনার টুকরো টাইপের একটি স্ট্রিমটি পড়া উচিত এবং সেগুলি কীভাবে আবর্তিত করা যায় এবং কোথায় সেগুলি ফেলে রাখা উচিত decide পরবর্তী টুকরোটির জন্য সন্ধানের জন্য অনুমতি দেওয়া (কেবলমাত্র একটি) অনুমোদিত: আপনি i+1প্রতিক্রিয়া জানানোর আগে টুকরোটি দেখতে পারেন i, তবে আপনাকে iদেখার আগে অবশ্যই তার ভাগ্য স্থির করে নেওয়া উচিত i+2। ইনপুটটির শেষ অংশের বাইরে আর কোনও চেহারা-পাওয়া যায় না।
টেট্রোমিনো ধরণের এবং তাদের ঘূর্ণনগুলি নিম্নলিখিত টেবিল অনুযায়ী এনকোড করা হয়:
type 0 1 2 3 4 5 6
O I Z J L S T
┌────┬────┬────┬────┬────┬────┬────┐
rotation 0 │## │# │## │ # │# │ ## │### │
│## │# │ ## │ # │# │## │ # │
│ │# │ │## │## │ │ │
│ │# │ │ │ │ │ │
├────┼────┼────┼────┼────┼────┼────┤
1 │## │####│ # │### │ # │# │# │
│## │ │## │ # │### │## │## │
│ │ │# │ │ │ # │# │
│ │ │ │ │ │ │ │
├────┼────┼────┼────┼────┼────┼────┤
2 │## │# │## │## │## │ ## │ # │
│## │# │ ## │# │ # │## │### │
│ │# │ │# │ # │ │ │
│ │# │ │ │ │ │ │
├────┼────┼────┼────┼────┼────┼────┤
3 │## │####│ # │# │### │# │ # │
│## │ │## │### │# │## │## │
│ │ │# │ │ │ # │ # │
│ │ │ │ │ │ │ │
└────┴────┴────┴────┴────┴────┴────┘
ইনপুট বাইনারি - বাইটগুলির একটি ক্রম যার বাকী OIZJLSTঅংশগুলি যখন 7 দ্বারা বিভাজিত হয় তখন তাকে টেট্রোমিনোস হিসাবে ব্যাখ্যা করা উচিত । এগুলি প্রায় একই সম্ভাবনার সাথে ঘটবে (256 7 এর গুণক না হওয়ার কারণে প্রথম কয়েক প্রকারটি সামান্য বেশি প্রদর্শিত হতে পারে তবে তা তুচ্ছ নয়)। ইনপুট স্টিডিন থেকে বা "i" নামক কোনও ফাইল হতে পারে বা আর্গুমেন্ট হিসাবে পাস হতে পারে। আপনি সামনের দিকে সীমাবদ্ধতা মেনে চলার বিষয়টি নিশ্চিত করে আপনি একসাথে সমস্ত ইনপুট পড়তে পারেন।
আউটপুটটিও বাইনারি - ইনপুট হিসাবে একই দৈর্ঘ্যের বাইটের ক্রম। এটি স্টডআউট বা "ও" নামের একটি ফাইল বা কোনও ফাংশন থেকে ফলাফল হতে পারে। প্রতিটি বাইট এনকোড r*16 + x, যেখানে rপছন্দসই ঘূর্ণন এবং xএটি কলামের 0-ভিত্তিক সূচক যেখানে ঘোরানো টেট্রোমিনোটির বামতম বর্গক্ষেত্রটি যেতে হবে। এগুলি rএবং xঅবশ্যই বৈধ হতে হবে, 0 ≤ r ≤ 3এবং 0 ≤ x ≤ 10-w, wসম্পর্কিত টুকরাটির প্রস্থ কোথায় ।
আপনার প্রোগ্রামটি অবশ্যই ডিটারমিনিস্টিক হতে হবে - একই ইনপুট দেওয়া হলে, এটি ঠিক একই আউটপুট উত্পাদন করতে হবে। PRNG ব্যবহার করা ঠিক যতক্ষণ না এটি কনস্ট-বীজযুক্ত।
মোট স্কোর হ'ল গেম বিয়োগ থেকে আপনার কোডের আকারের বাইটগুলি থেকে প্রাপ্ত স্কোর। দয়া করে নীচের ফাইলটি (সিউডো-র্যান্ডম শোরগোলের 64kiB) ইনপুট হিসাবে ব্যবহার করুন: https://gist.github.com/ngn/857bf2c99bfafc649b8eaa1e489e75e4/raw/880f29bd790638aa17f51229c105e726bce60235/ii
নিম্নলিখিত পাইথন 2 / পাইথন 3 স্ক্রিপ্টটি বর্তমান ডিরেক্টরি থেকে "আই" এবং "ও" ফাইলগুলি পড়ে, গেমটি পুনরায় প্রদর্শন করে এবং স্কোরটি মুদ্রণ করে (দয়া করে স্কোর থেকে আপনার কোডের আকারটি বিয়োগ করতে ভুলবেন না):
a = [0] * 23 # grid (1square=1bit, 1row=1int, LSB is left, 3 empty rows on top)
# O I Z J L S T tetrominoes
t = [[[3,3],[1,1,1,1],[3,6], [2,2,3],[1,1,3],[6,3], [7,2] ],
[[3,3],[15], [2,3,1],[7,4], [4,7], [1,3,2],[1,3,1]],
[[3,3],[1,1,1,1],[3,6], [3,1,1],[3,2,2],[6,3], [2,7] ],
[[3,3],[15], [2,3,1],[1,7], [7,1], [1,3,2],[2,3,2]]]
tw = [[2,1,3,2,2,3,3],[2,4,2,3,3,2,2],[2,1,3,2,2,3,3],[2,4,2,3,3,2,2]] # widths
th = [[2,4,2,3,3,2,2],[2,1,3,2,2,3,3],[2,4,2,3,3,2,2],[2,1,3,2,2,3,3]] # heights
score = 0
for p, rx in zip(bytearray(open('i', 'rb').read()),
bytearray(open('o', 'rb').read())):
p %= 7; r = rx >> 4; x = rx & 15 # p:piece type, r:rotation, x:offset
b = [u << x for u in t[r][p]] # as a bit-matrix (list of ints)
bw = tw[r][p]; bh = th[r][p] # width and height
y = 0 # drop it
while y <= 23 - bh and all((a[y + i] & b[i]) == 0 for i in range(bh)):
y += 1
y -= 1
if y < 3: # no room?
a = [0] * len(a) # clear the grid and carry on
else:
for i in range(bh): # add the piece to the grid
a[y + i] |= b[i]
n = 0
for i in reversed(range(bh)): # collapse full lines
if a[y + i] == (1 << 10) - 1:
n += 1; del a[y + i]; a = [0] + a
score += (1 << n) - 1
print(score)
নীচেরগুলি আরও দ্রুত সি প্রোগ্রাম করে তবে এটি কেবল লিনাক্সে কাজ করার গ্যারান্টিযুক্ত:
#include<stdio.h>
#include<fcntl.h>
#include<sys/mman.h>
#include<sys/stat.h>
#define F(i,n,b...)for(i=0;i<n;i++){b;}
typedef int I;typedef char C;
I a[23],t[]={
51,4369,99,802,785,54,39,51,15,306,71,116,561,305,
51,4369,99,275,547,54,114,51,15,306,113,23,561,562};
C*th="2423322213223324233222132233";
I main(){
struct stat h;stat("i",&h);I i,j,k,l=h.st_size,z=0;
C*mi=mmap(0,l,1,1,open("i",0,0),0),*mo=mmap(0,l,1,1,open("o",0,0),0);
F(k,l,
I p=(mi[k]&255)%7,r=3&mo[k]>>4,q=r*7+p,x=mo[k]&15,y=0,h=th[q]-'0',b[4];
F(i,h,b[i]=(t[q]>>(4*i)&15)<<x)
while(y<=23-h){I u=0;F(i,h,u|=a[y+i]&b[i])if(u)break;y++;}
if(--y<3){F(i,23,a[i]=0)continue;}
F(i,h,a[y+i]|=b[i])
I n=0;F(i,23,n+=a[i]==1023)
if(n){j=23;F(i,20,a[j]=a[22-i];j-=a[j]!=1023)F(i,j,a[i]=0);z+=(1<<n)-1;})
printf("%d\n",z);return 0;}
সর্বোচ্চ স্কোর জয়। স্ট্যান্ডার্ড লুফোলগুলি নিষিদ্ধ।