কোড গল্ফ: টেট্রিস বাজানো


83

অধিকার:

নিম্নলিখিত tetrominoes এবং খালি খেলার ক্ষেত্র বিবেচনা করুন:

                                            0123456789
    আইওজেডএলএসজে []
                                           []
    # ## ## ### # ## # []
    # ## ## # # ## # []
    # ## ## []
    # []
                                           [===========]

খেলার মাঠের মাত্রা স্থির। শীর্ষে সংখ্যাগুলি কলাম নম্বরটি নির্দেশ করতে এখানে কেবল (ইনপুটটিও দেখুন)।

ইনপুট:

। আপনাকে একটি নির্দিষ্ট প্লেয়িং ফিল্ড দেওয়া হয়েছে (উপরের ভিত্তিতে) যা ইতিমধ্যে টেট্রোমিনোস (এটি একটি পৃথক ফাইলে বা স্ট্ডিনের মাধ্যমে সরবরাহ করা যেতে পারে) দিয়ে আংশিকভাবে পূরণ করা যেতে পারে।

নমুনা ইনপুট:

[]
[]
[]
[]
[# # #]
[## #######]
[===========]

। আপনাকে একটি স্ট্রিং দেওয়া হবে যা বর্ণনা করে (স্পেস দ্বারা বিচ্ছিন্ন) কোন কলামে কোন টেট্রোমিনো sertোকাতে হবে (এবং ড্রপ ডাউন করবে)। টেট্রোমিনোগুলি ঘোরানোর দরকার নেই। স্টিন থেকে ইনপুট পড়া যায়।

নমুনা ইনপুট:

T2 Z6 I0 T7

আপনি ধরে নিতে পারেন ইনপুটটি 'সুগঠিত' (বা এটি যখন না হয় তখনই সংজ্ঞায়িত আচরণ তৈরি করে)।

আউটপুট

ফলাফলের ক্ষেত্রটি রেন্ডার করুন ('পূর্ণ' লাইনগুলি অবশ্যই অদৃশ্য হয়ে যাবে) এবং স্কোর কাউন্ট মুদ্রণ করুন (প্রতিটি নিচে লাইন 10 পয়েন্টের হয়ে থাকে)।

উপরে নমুনা ইনপুট উপর ভিত্তি করে নমুনা আউটপুট:

[]
[]
[]
[# ###]
[# ###]
[##### ####]
[===========]
10

বিজয়ী:

সংক্ষিপ্ত সমাধান (কোড অক্ষর গণনা দ্বারা)। ব্যবহারের উদাহরণগুলি দুর্দান্ত। মজা গল্ফিং আছে!

সম্পাদনা : +500উত্তরদাতারা ইতিমধ্যে করা সুন্দর প্রচেষ্টা (এবং সম্ভবত এই প্রশ্নের কয়েকটি নতুন সমাধান) এর দিকে আরও কিছু মনোযোগ আকর্ষণ করার জন্য খ্যাতির পরিমাণ বাড়িয়েছে ...


4
@ হোম: মেটা.স্ট্যাকওভারফ্লো ডট কম পরীক্ষা করুন - কোড গল্ফকে সাধারণত অনুমোদিত হয় (সম্প্রদায়ের উইকি আকারে)
ক্রিস্টোফিড

18
@ মাউস: এটিই ভোটদান বন্ধ করার জন্য। প্রশ্নটিকে পতাকাঙ্কিত করে এখানে মডারেটরদের টেনে নিয়ে যাওয়া সম্ভবত আপনাকে সেই জনপ্রিয় করে তুলবে না, সময় এবং বার বার সম্প্রদায়টি (অনিচ্ছায়) কোড গল্ফকে থাকতে দিয়েছে (কোড-গল্ফ ট্যাগ এবং মেটা আলোচনা দেখুন; এটি নতুন কিছু নয়) ।
মার্ক পিটারস

8
@ মাউস: অফ-টপিক! = স্প্যাম। এমনকি যদি আপনি বন্ধ করতে ভোট দিতে না পারেন, তবে সেই স্প্যামের পতাকাটি বাদ দেওয়া হয়েছিল।
BoltClock

4
আমি একটি এপিএল জকের জন্য অপেক্ষা করছি! আমি বাজি দেব সে এটি 3.5 টি প্রতীকগুলিতে করতে পারে
n8wrl

4
মাত্রাগুলি স্থির হওয়ার কথা, তবে নমুনা ইনপুট এবং ফাঁকা ক্ষেত্রের আলাদা উচ্চতা রয়েছে। উচ্চতা কত হতে হবে?
নবব

উত্তর:


27

গল্ফস্ক্রিপ্ট - 181 টি অক্ষর

নিউলাইনগুলি প্রয়োজন হয় না। আউটপুটটি স্ট্যান্ডার্ড আউটপুটে রয়েছে যদিও স্ট্যান্ডারটিতে কিছু ত্রুটি রয়েছে।
\10প্রোগ্রামটির 181 টি অক্ষর হওয়ার জন্য সংশ্লিষ্ট ASCII অক্ষর দ্বারা প্রতিস্থাপন করা উচিত।

{):X!-{2B{" #"=}%X" ":f*+-1%}%:P;:>.{\!:F;>P{\(@{3&\(@.2$&F|:F;|}%\+}%\+F![f]P+:P
;}do;{"= "&},.,7^.R+:R;[>0="#"/f*]*\+}0"R@1(XBc_""~\10"{base}:B/3/~4*"nIOZTLSJR "
";:"*~;n%)n*~ 10R*+n*

নমুনা I / O:

$ cat inp
[          ]
[          ]
[          ]
[          ]
[ #    #  #]
[ ## ######]
[==========]
T2 Z6 I0 T7
$ cat inp|golfscript tetris.gs 2>/dev/null
[          ]
[          ]
[          ]
[#      ###]
[#     ### ]
[##### ####]
[==========]
10

টেট্রোমিনো সংক্ষেপণ:
টুকরো তিনটি বেস 8 অঙ্ক হিসাবে সংরক্ষণ করা হয়। এটি একটি সাধারণ বাইনারি উপস্থাপনা, উদাহরণস্বরূপ T=[7,2,0], S=[6,3,0], J=[2,2,3]। সংক্ষেপে টুকরাটির [1]জন্য ব্যবহৃত হয় I, তবে এটি স্পষ্টতই [1,1,1,1]পরে সেট করা হয় (যেমন কোডটিতে 4*)। এই সমস্ত অ্যারে একক অ্যারেতে সংমিশ্রিত হয়, যা একটি পূর্ণসংখ্যায় রূপান্তরিত হয় এবং তারপরে একটি স্ট্রিং (প্রিন্টযোগ্য অক্ষর, দৈর্ঘ্য এবং utf8 এর মুখোমুখি না হওয়া কমানোর জন্য বেস 126)। এই স্ট্রিং খুবই সংক্ষিপ্ত: "R@1(XBc_"

ডিকম্প্রেশন তখন সোজা। আমরা প্রথমে একটি বেস 126 রূপান্তর করি তারপরে একটি বেস 8 রূপান্তর ( "~\10"{base}/অর্থাত্ "~\10"প্রতিটি উপাদানটির জন্য পুনরাবৃত্তি এবং একটি বেস রূপান্তর করি)। ফলস্বরূপ অ্যারে 3 টি গ্রুপে বিভক্ত হয়, এর জন্য অ্যারেটি Iস্থির হয় ( 3/~4*)। তারপরে আমরা প্রতিটি উপাদানকে বেস 2 তে রূপান্তর করি এবং (শূন্যগুলি অপসারণের পরে) প্রতিটি বাইনারি সংখ্যাকে স্ট্রিংয়ের সেই সূচকের চরিত্রের সাথে প্রতিস্থাপন করি " #"( 2base{" #"=}%...-1%- নোট করুন যে আমাদের অ্যারেটি বিপরীত করা উচিত অন্যথায় পরিবর্তে 2হয়ে যাবে )।"# "" #"

বোর্ড / টুকরো বিন্যাস, টুকরোগুলি ফেলে দেওয়া
বোর্ডটি কেবল প্রতিটি লাইনের জন্য একটি স্ট্রিংয়ের অ্যারে। প্রাথমিকভাবে এটির কোনও কাজ করা হয় না, তাই আমরা n/(ইনপুট দিয়ে এটি তৈরি করতে পারি । টুকরাগুলি তার এক্স অবস্থানের জন্য বামে শূন্যস্থানযুক্ত প্যাডযুক্ত স্ট্রিংগুলির অ্যারেও রয়েছে, তবে স্থান ফাঁকা ছাড়াই। টুকরোগুলি অ্যারেতে প্রিপেন্ড করে ফেলে দেওয়া হয় এবং ক্রমাগত কোনও সংঘর্ষ রয়েছে কিনা তা পরীক্ষা করে নেওয়া হয়।

টুকরো টুকরো টুকরো সমস্ত অক্ষরের মধ্যে পুনরাবৃত্তি, এবং বোর্ডে একই অবস্থানের চরিত্রের সাথে তুলনা করে সংঘাত পরীক্ষা করা হয়। আমরা #+ =এবং #+ #কে সংঘর্ষ হিসাবে বিবেচনা করতে চাই , সুতরাং আমরা ((পিসচার এবং 3) এবং বোর্ডচার) ননজারো কিনা তা পরীক্ষা করি। এই পুনরাবৃত্তিটি করার সময়, আমরা ((টুকচারার এবং 3) | বোর্ডচারার) সহ বোর্ডটিও আপডেট করি (যা একটি জোড় #+ , + #, + + এর জন্য মানটি সঠিকভাবে সেট করে [। টুকরোটিকে অন্য সারিতে নামানোর পরে যদি সংঘর্ষ হয় তবে আমরা এই আপডেট হওয়া বোর্ডটি ব্যবহার করি।

ভরাট সারিগুলি সরিয়ে ফেলা বেশ সহজ। আমরা সমস্ত সারি অপসারণ করি যার জন্য "= "&মিথ্যা প্রত্যাবর্তন হয়। একটি ভরাট সারিতে না থাকবে =বা , সুতরাং সংযোগটি একটি ফাঁকা স্ট্রিং হবে, যা মিথ্যা সমান। তারপরে আমরা মুছে ফেলা সারিগুলির সংখ্যা গণনা করি, স্কোরটিতে গণনা যুক্ত করুন এবং এটির অনেকগুলি প্রিপেন্ড করুন "[ ... ]"। আমরা গ্রিডের প্রথম সারিটি নিয়ে এবং প্রতিস্থাপনের #মাধ্যমে এটিকে নিখুঁতভাবে উত্পন্ন করি

বোনাস
যেহেতু বোর্ডটি টুকরো টুকরো টুকরো পড়ার মতো দেখতে প্রতিটি অবস্থান দেখতে কেমন হবে তা গণনা করি, তাই আমরা এগুলি মুছে ফেলার পরিবর্তে স্ট্যাকের উপর রাখতে পারি! মোট তিনটি অক্ষরের জন্য আমরা এই সমস্ত পজিশন আউটপুট করতে পারি (বা বোর্ডের একক ব্যবধান থাকলে আমাদের দুটি অক্ষর)।

{):X!-{2B{" #"=}%X" ":f*+-1%}%:P;:>.{>[f]P+:P(!:F;{\(@{3&\(@.2$&F|:F;|}%\+}%\+F!}
do;{"= "&},.,7^.R+:R;[>0="#"/f*]*\+}0"R@1(XBc_""~\10"{base}:B/3/~4*"nIOZTLSJR "
";:"*~;n%)n*~ ]{n*n.}/10R*

এখানে কিছু চরম কোড-গল্ফিং চলছে (আমি ভাবিনি যে এটি 200 টিরও কম অক্ষরে করা যেতে পারে)। চমৎকার কাজ!
ক্রিস্টোফিড

8
বিস্ময়কর। আমি যদি গল্ফস্ক্রিপ্ট বুঝতে পারি অপেক্ষা কর ... না আমি করি না।
পি বাবা

26

পার্ল, 586 523 483 472 427 407 404 386 387 356 353 অক্ষর

(সংজ্ঞায়িত-বা //অপারেটরের জন্য পার্লের দরকার 5.10 )।

স্টিন থেকে সমস্ত ইনপুট নেয়। এখনও কিছু গুরুতর গল্ফিং প্রয়োজন।
নোট করুন যে ^ প্রশ্ন ASCII 17 (DC1 / XON) প্রতিনিধিত্ব করে, ^ C ASCII 3 এবং ^ @ ASCII 0 (NUL) উপস্থাপন করে।

while(<>){push@A,[split//]if/]/;while(/\w/g){for$i(0..6){for($f=0,$j=4;$j--;){$c=0;map{if($_){$i--,$f=$j=3,redo if$A[$k=$i+$j][$C=$c+$'+1]ne$";$A[$k][$C]="#"if$f}$c++}split//,unpack"b*",chr vec"3^@'^@c^@^Q^C6^@\"^C^Q^Q",index(OTZLSJI,$&)*4+$j,4;$s+=10,@A[0..$k]=@A[$k,0..$k-1],map{s/#/ /}@{$A[0]},$i++if 9<grep/#/,@{$A[$k]}}last if$f}}}print+(map@$_,@A),$s//0,$/

মন্তব্য করা সংস্করণ:

while(<>){
    # store the playfield as an AoA of chars
    push@A,[split//]if/]/;
    # while we're getting pieces
    while(/\w/g){
            # for each line of playfield
            for$i(0..6){
                    # for each line of current piece
                    for($f=0,$j=4;$j--;){
                            # for each column of current piece
                            $c=0;
                            map{
                                    if($_){
                                            # if there's a collision, restart loop over piece lines
                                            # with a mark set and playfield line decremented
                                            $i--,$f=$j=3,redo if$A[$k=$i+$j][$C=$c+$'+1]ne$";
                                            # if we already found a collision, draw piece
                                            $A[$k][$C]="#"if$f
                                    }
                                    $c++
                            # pieces are stored as a bit vector, 16 bits (4x4) per piece,
                            # expand into array of 1's and 0's
                            }split//,unpack"b*",chr vec"3^@'^@c^@^Q^C6^@\"^C^Q^Q",index(OTZLSJI,$&)*4+$j,4;
                            # if this playfield line is full, remove it. Done by array slicing
                            # and substituting all "#"'s in line 0 with " "'s
                            $s+=10,@A[0..$k]=@A[$k,0..$k-1],map{s/#/ /}@{$A[0]},$i++if 9<grep/#/,@{$A[$k]}
                    }
                    # if we found a collision, stop iterating over the playfield and get next piece from input
                    last if$f
            }
    }
}
# print everything
print+(map@$_,@A),$s//0,$/

সম্পাদনা 1: কিছু গুরুতর গল্ফিং, আউটপুট বাগ ঠিক করুন।
সম্পাদনা 2: কিছু অন্তর্নিহিত, (ড্রাম রোল ...) 3 টি চর, মিস গল্ফিংয়ের নেট সেভিংয়ের জন্য একটিতে দুটি লুপ একত্রিত।
3 সম্পাদনা করুন: কিছু সাধারণ সবেশন এক্সপ্রেশন, কিছুটা ধ্রুবক সংশ্লেষ এবং একটি রেজেক্স টিক করে।
4 সম্পাদনা করুন: প্যাক বিট ভেক্টর, মিস্ক গল্ফিংয়ে টেট্রোমিনোসের প্রতিনিধিত্ব পরিবর্তন করা হয়েছে।
5 সম্পাদনা করুন: টেট্রোমিনো চিঠি থেকে অ্যারে সূচকগুলিতে আরও সরাসরি অনুবাদ, প্রিন্টযোগ্য অক্ষরগুলি, মিস্ক গল্ফিং ব্যবহার করুন।
সম্পাদনা 6: ফিক্সড বাগ পরিষ্কারের শীর্ষ লাইন, আর 3-এ প্রবর্তিত (সম্পাদনা 2), নকিলন দ্বারা চিহ্নিত। আরও মুদ্রণযোগ্য অক্ষর ব্যবহার করুন।
7 সম্পাদনা করুন: vecটেট্রোমিনো ডেটা পাওয়ার জন্য ব্যবহার করুন। প্লেফিল্ডের নির্দিষ্ট মাত্রা রয়েছে সেটির সুবিধা নিন। ifবিবৃতি =>ifসংশোধক, সম্পাদনা 2 এর লুপগুলি মার্জ করা বন্ধ করা শুরু করে। //0-স্কোর ক্ষেত্রে ব্যবহার করুন ।
সম্পাদনা 8: আর একটি বাগ ঠিক করা, আর 6-এ প্রবর্তিত (5 সম্পাদনা করুন), নকিলন দ্বারা চিহ্নিত।
9 সম্পাদনা করুন: লাইনগুলি সাফ করার সময় নতুন রেফারেন্স তৈরি করবেন না, কেবল অ্যারে স্লাইসিংয়ের মাধ্যমে রেফারেন্সগুলি চারপাশে সরান। দু'জনকে mapএকটিতে মার্জ করুন । স্মার্ট রিজেক্স। "দক্ষতা সহকারে" for। মিস গল্ফিংস
10 সম্পাদনা করুন: ইনলাইনড টেট্রোমিনো অ্যারে, মন্তব্য করা সংস্করণ যুক্ত।


খুব সুন্দরভাবে কাজ করা (এবং ইতিমধ্যে এই অ-তুচ্ছ সমস্যার জন্য একটি সুন্দর চরিত্র গণনায়)। একটি ছোট অদ্ভুততা হ'ল আমার পার্ল (ডারউইন-থ্রেড-মাল্টি-২ লেভেলের জন্য নির্মিত পার্ল, ভি 5.10.0) ফলাফলটি দু'বার মুদ্রণ করেছে বলে মনে হচ্ছে (ইনপুট পাইপড ইন)।
ক্রিস্টোফিড

@ ক্রিস্টোফিড: নকল আউটপুট স্থির করেছিলাম, আমি আমার মূল লুপের ভিতরে মুদ্রণ করছিলাম, তবে কেবল প্লেফিল্ড ছাড়াই লাইনের জন্য। আপনার সম্ভবত একটি নতুন লাইন খুব বেশি ছিল :)
ninjalj

অজগরকে মারতে আরও চারটি চর !!
ভিভিন পালিথ 18

4
আমি এখনও পার্ল ছেড়ে দেওয়া হয়নি! xD (যদিও আমি অন্য কিছু সমাধান খুব দেখতে এখন দ্বারা চাই ..)
অকর্মা

@ নকিলন: ভাল ধরা! আপনার সেখানে একটি দুর্দান্ত পরীক্ষার মামলা রয়েছে।
নিনজালজ

24

রুবি - 427 408 398 369 359

t=[*$<]
o=0
u=->f{f.transpose}
a=u[t.reverse.join.scan /#{'( |#)'*10}/]
t.pop.split.map{|w|m=(g='I4O22Z0121T01201L31S1201J13'[/#{w[0]}\d+/].scan(/0?\d/).zip a.drop w[1].to_i).map{|r,b|(b.rindex ?#or-1)-r.size+1}.max
g.map{|r,b|b.fill ?#,m+r.size,r.to_i}
v=u[a]
v.reject!{|i|i-[?#]==[]&&(o+=10;v)<<[' ']*10}
a=u[v]}
puts u[a].reverse.map{|i|?[+i*''+?]},t[-1],o

খুব সুন্দর সমাধান! আপনি কীভাবে টেরোমিনোস ফর্মগুলি এনকোড করেছেন ঠিক তা দেখতে হবে (এইভাবে খুব কমপ্যাক্ট দেখাচ্ছে)।
ক্রিস্টোফিড

4
আমি এই কোডটির একটি বিস্তৃত ব্যাখ্যা দেখতে সত্যিই পছন্দ করব। দেখে মনে হচ্ছে এতো অসুস্থ… এর চারপাশে আমার মাথা উঠতে পারে না।
নীলস রিডিম্যান

4
@ নীল রিডেমেন, আমি এখনই একটি ব্যাখ্যা লিখছি, তবে এখনই এটি পোস্ট করার কথা ভাবছি, বা বিজয়ীর ঘোষণার পরে) যাইহোক একবার আমি সমস্ত প্রশ্ন পোস্ট করব এবং উত্তর দেব, কারণ এটি মূল ধারণা সহ একটি সম্প্রদায় উইকি রয়েছে)
নাকিলন

ডেবিয়ানের রুবি ১.৯.২.দেব (২০১০-০7-৩০) এ এটি পেস্ট.আর.আর /?6 এপি 1 এ আপনার পরীক্ষার কেসটির জন্য ব্যর্থ হয়? তবুও , এটি সর্বদা প্লেফিল্ডটিকে দশ লাইনে প্রসারিত করে?
নিনজালজ

@ নিনজালজ, রুবি 1.9.2p0 (2010-08-18) [i386-mingw32] paste.org.ru/?1qnjhj দেখতে ভাল লাগছে । 10 এর প্রস্থটি একটি টেট্রিস স্ট্যান্ডার্ড, আমি মনে করি।
নাকিলন

17

বাশ শেল স্ক্রিপ্ট ( 301 304 টি অক্ষর)


আপডেট: শীর্ষ সারিতে প্রসারিত টুকরা জড়িত একটি বাগ ঠিক করা। এছাড়াও, আউটপুটটি এখন স্ট্যান্ডার্ড আউটে প্রেরণ করা হয়েছে, এবং বোনাস হিসাবে, গেমটি চালিয়ে যাওয়ার জন্য আবার স্ক্রিপ্টটি চালানো সম্ভব (এই ক্ষেত্রে আপনাকে অবশ্যই মোট স্কোর যোগ করতে হবে)।

এটিতে ছাপানো অক্ষর অন্তর্ভুক্ত রয়েছে, তাই আমি একটি হেক্স্স ডাম্প সরবরাহ করেছি। এটি সংরক্ষণ করুন tetris.txt:

0000000: 7461 696c 202d 3120 245f 7c7a 6361 743e  tail -1 $_|zcat>
0000010: 753b 2e20 750a 1f8b 0800 35b0 b34c 0203  u;. u.....5..L..
0000020: 5590 516b 8330 10c7 dff3 296e 4c88 ae64  U.Qk.0....)nL..d
0000030: a863 0c4a f57d 63b0 07f7 b452 88d1 b4da  .c.J.}c....R....
0000040: 1a5d 5369 91a6 df7d 899a d05d 5e72 bfbb  .]Si...}...]^r..
0000050: fbff 2fe1 45d5 0196 7cff 6cce f272 7c10  ../.E...|.l..r|.
0000060: 387d 477c c4b1 e695 855f 77d0 b29f 99bd  8}G|....._w.....
0000070: 98c6 c8d2 ef99 8eaa b1a5 9f33 6d8c 40ec  ...........3m.@.
0000080: 6433 8bc7 eeca b57f a06d 27a1 4765 07e6  d3.......m'.Ge..
0000090: 3240 dd02 3df1 2344 f04a 0d1d c748 0bde  2@..=.#D.J...H..
00000a0: 75b8 ed0f 9eef 7bd7 7e19 dd16 5110 34aa  u.....{.~...Q.4.
00000b0: c87b 2060 48a8 993a d7c0 d210 ed24 ff85  .{ `H..:.....$..
00000c0: c405 8834 548a 499e 1fd0 1a68 2f81 1425  ...4T.I....h/..%
00000d0: e047 bc62 ea52 e884 42f2 0f0b 8b37 764c  .G.b.R..B....7vL
00000e0: 17f9 544a 5bbd 54cb 9171 6e53 3679 91b3  ..TJ[.T..qnS6y..
00000f0: 2eba c07a 0981 f4a6 d922 89c2 279f 1ab5  ...z....."..'...
0000100: 0656 c028 7177 4183 2040 033f 015e 838b  .V.(qwA. @.?.^..
0000110: 0d56 15cf 4b20 6ff3 d384 eaf3 bad1 b9b6  .V..K o.........
0000120: 72be 6cfa 4b2f fb03 45fc cd51 d601 0000  r.l.K/..E..Q....

তারপরে, bash কমান্ড প্রম্পটে অগ্রাধিকার হিসাবে ইনস্টল করার elvisপরিবর্তে :vimvi

$ xxd -r tetris.txt tetris.sh
$ chmod +x tetris.sh
$ cat << EOF > b
> [          ]
> [          ]
> [          ]
> [          ]
> [ #    #  #]
> [ ## ######]
> [==========]
> EOF
$ ./tetris.sh T2 Z6 I0 T7 2>/dev/null
-- removed stuff that is not in standard out --
[          ]
[          ]
[          ]
[#      ###]
[#     ### ]
[##### ####]
[==========]
10

কিভাবে এটা কাজ করে

কোড নিজেই এক্সট্রাক্ট করে কীভাবে এক্সিকিউটেবল প্রোগ্রামগুলি gzexeস্ক্রিপ্টটি ব্যবহার করে সংকুচিত করে । টেট্রোমিনো টুকরোগুলি vi সম্পাদক কমান্ডের ক্রম হিসাবে উপস্থাপিত হয়। চরিত্র গণনা সংঘর্ষগুলি সনাক্ত করতে ব্যবহৃত হয় এবং স্কোর গণনা করতে লাইন গণনা ব্যবহৃত হয়।

আনজিপড কোড:

echo 'rej.j.j.:wq!m'>I
echo '2rejh.:wq!m'>O
echo '2rej.:wq!m'>Z
echo '3rejh1.:wq!m'>T
echo 'rej.j2.:wq!m'>L
echo 'l2rej2h.:wq!m'>S
echo 'lrej.jh2.:wq!m'>J
for t
do for y in `seq 1 5`
do echo -n ${y}jk$((${t:1}+1))l|cat - ${t:0:1}|vi b>0
grep ========== m>0||break
[ `tr -cd '#'<b|wc -c` = `tr -cd '#'<m|wc -c` ]||break
tr e '#'<m>n
done
cat n>b
grep -v '##########' b>m
$((S+=10*(`wc -l < b`-`wc -l < m`)))
yes '[          ]'|head -7|cat - m|tail -7>b
done
cat b
echo $S

গল্ফ করার আগে আসল কোড:

#!/bin/bash

mkpieces() {
    pieces=('r@j.j.j.' '2r@jh.' '2r@j.' '3r@jh1.' 'r@j.j2.' 'l2r@j2h.' 'lr@j.jh2.')
    letters=(I O Z T L S J)

    for j in `seq 0 9`; do
        for i in `seq 0 6`; do
            echo "jk$(($j+1))l${pieces[$i]}:wq! temp" > ${letters[$i]}$j
        done
    done
}

counthashes() {
    tr -cd '#' < $1 | wc -c
}

droppiece() {
    for y in `seq 1 5`; do
        echo -n $y | cat - $1 | vi board > /dev/null
        egrep '={10}' temp > /dev/null || break
        [ `counthashes board` -eq `counthashes temp` ] || break
        tr @ "#" < temp > newboard
    done
    cp newboard board
}

removelines() {
    egrep -v '#{10}' board > temp
    SCORE=$(($SCORE + 10 * (`wc -l < board` - `wc -l < temp`)))
    yes '[          ]' | head -7 | cat - temp | tail -7 > board
}

SCORE=0
mkpieces
for piece; do
    droppiece $piece
    removelines
done
cat board
echo $SCORE

4
একটি বাশ ফাইল, ডিকম্প্রেসিং এবং চলমান vi .. এমন ঘৃণার বৈধতা সম্পর্কে নিশ্চিত নয় .. তবে এটি সবচেয়ে চিত্তাকর্ষক, +1। স্যার আপনাকে কুডোস
মাইকেল অ্যান্ডারসন

হাস্যকরভাবে শেষ করতে দীর্ঘ সময় নেয় এবং তারপরে পরীক্ষার কেসের জন্য ভুল আউটপুট উত্পন্ন করে "T2 Z6 I0 T7 T2 Z6 T2 I5 I1 I4 T8 O1 T1 T3 T3 Z0 I9 I6 O7 T3 I2 O0 J8 L6 O7 I4 J8 S6 O1 I0 O4 "(উদাহরণ হিসাবে ইনপুট হিসাবে একই বোর্ড)। তদ্ব্যতীত, পাইপ দেওয়ার সময় হাজার হাজার আবর্জনা লাইন স্ট্যাডআউটে যাবে এবং বোর্ডের ফলাফল সম্ভবত পরিবর্তে সেখানে যাওয়া উচিত।
নবাব

এটি অনেক দ্রুত হবে যদি এলভিসকে ভিআইএম এর পরিবর্তে ভিআইএম ইনস্টল করা হত।
স্ট্যান্ড

4
@ ন্যাব: আমি কেবলমাত্র তিনটি অক্ষরের ব্যয়ে এই সমস্ত সমস্যা সমাধান করেছি।
প্লিজ স্ট্যান্ড

কি দারুন. এটি বাশের কিছু চমত্কার চিত্তাকর্ষক আপত্তি।
পি বাবা

13

পাইথন: 504 519 অক্ষর

(পাইথন 3 সমাধান) বর্তমানে উপরে প্রদর্শিত হিসাবে বিন্যাসে ইনপুট সেট করতে হবে (ইনপুট কোড গণনা করা হয় না)। আমি পরে ফাইল বা স্টিডিন থেকে পড়তে প্রসারিত করব। এখন একটি প্রম্পট দিয়ে কাজ করে, কেবল ইনপুটটি আটকে দিন (মোট 8 টি লাইন)।

R=range
f,p=[input()[1:11]for i in R(7)],p
for(a,b)in input().split():
 t=[' '*int(b)+r+' '*9for r in{'I':'#,#,#,#','O':'##,##','Z':'##, ##','T':'###, # ','L':'#,#,##','S':' ##,##','J':' #, #,##'}[a].split(',')]
 for r in R(6-len(t),0,-1):
  for i in R(len(t)):
   if any(a==b=='#'for(a,b)in zip(t[i],f[r+i])):break
  else:
   for i in R(0,len(t)):
    f[r+i]=''.join(a if b!='#'else b for(a,b)in zip(t[i],f[r+i]))
    if f[r+i]=='#'*10:del f[r+i];f[0:0]=[' '*10];p+=10
   break
print('\n'.join('['+r+']'for r in f[:7]),p,sep='\n')

নিশ্চিত না যে আমি সেখানে আরও অনেক কিছু সঞ্চয় করতে পারি কিনা। বিটফিল্ডে রূপান্তর থেকে প্রচুর অক্ষর হারিয়ে গেছে, তবে এটি স্ট্রিংয়ের সাথে কাজ করার চেয়ে অনেক বেশি অক্ষর সংরক্ষণ করে। এছাড়াও আমি নিশ্চিত না যে আমি সেখানে আরও সাদা জায়গা সরিয়ে ফেলতে পারি কিনা তবে আমি পরে এটি চেষ্টা করব।
এটিকে আরও বেশি হ্রাস করতে সক্ষম হবে না; বিটফিল্ড-ভিত্তিক সমাধান পাওয়ার পরে, আমি আবার স্ট্রিংগুলিতে স্থানান্তরিত হয়েছি, কারণ আমি এটি আরও সংকোচনের জন্য একটি উপায় খুঁজে পেয়েছি (বিটফিল্ডে 8 টি অক্ষর সংরক্ষণ করেছেন!)। তবে প্রদত্ত যে আমি অন্তর্ভুক্ত করতে ভুলে গিয়েছি Lএবং ভিতরে থাকা পয়েন্টগুলির সাথে একটি ত্রুটি ছিল, আমার চরিত্রের গণনাটি দীর্ঘশ্বাস ছেড়ে চলেছে ... সম্ভবত আমি এটিকে আরও কিছুটা সংকোচনের জন্য পরে কিছু পেয়েছি, তবে আমি মনে করি আমি শেষের কাছে এসেছি। মূল এবং মন্তব্য করা কোডের জন্য নীচে দেখুন:

মূল সংস্করণ:

field = [ input()[1:11] for i in range(7) ] + [ 0, input() ]
# harcoded tetrominoes
tetrominoes = {'I':('#','#','#','#'),'O':('##','##'),'Z':('##',' ##'),'T':('###',' # '),'L':('#','#','##'),'S':(' ##','##'),'J':(' #',' #','##')}
for ( f, c ) in field[8].split():
    # shift tetromino to the correct column
    tetromino = [ ' ' * int(c) + r + ' ' * 9 for r in tetrominoes[f] ]

    # find the correct row to insert
    for r in range( 6 - len( tetromino ), 0, -1 ):
        for i in range( len( tetromino ) ):
            if any( a == b == '#' for (a,b) in zip( tetromino[i], field[r+i] ) ):
                # skip the row if some pieces overlap
                break
        else:
            # didn't break, insert the tetromino
            for i in range( 0, len( tetromino ) ):
                # merge the tetromino with the field
                field[r+i] = ''.join( a if b != '#' else b for (a,b) in zip( tetromino[i], field[r+i] ) )

                # check for completely filled rows
                if field[r+i] == '#' * 10:
                    # remove current row
                    del field[r+i]
                    # add new row
                    field[0:0] = [' '*10]
                    field[7] += 10
            # we found the row, so abort here
            break
# print it in the requested format
print( '\n'.join( '[' + r + ']' for r in field[:7] ) )
# and add the points = 10 * the number of redundant lines at the end
print( str( field[7] ) )

আমি এটি সঠিক মনে করি না। এখানে কোনও নিয়ম নেই যে কেবল নীচের লাইনটি অদৃশ্য হয়ে যেতে পারে, তবে আপনার মন্তব্যের দ্বারা বিচার করে আপনি কেবল সেই লাইনটি পরীক্ষা করেন।
মাইকেল ম্যাডসেন

দয়া করে কোনও কাজের মতো আপনার ইনপুটটি তৈরি করুন। মানে, ফাইল বা এসটিডিআইএন থেকে ইনপুট।
নাকিলন

6
পাইথন কোডটি কীভাবে এখনও মোটামুটি পঠনযোগ্য তা আপনি পছন্দ করেন না?
EMP

@ অ্যাভজেনি, কেবল পার্ল বা
মালবোলজের

ঠিক আছে, আমি অন্যান্য কোড গল্ফ উত্তরগুলির তুলনায় "পাঠযোগ্য" বলতে চাইছিলাম!
EMP

13

রুবি ১.৯, 357 355 353 339 330 310 309 অক্ষর

d=0
e=[*$<]
e.pop.split.map{|f|f="L\003\003\007J\005\005\007O\007\007Z\007\013S\013\007I\003\003\003\003T\017\005"[/#{f[j=0]}(\W*)/,1].bytes.map{|z|?\0+?\0*f[1].hex+z.to_s(2).tr("01"," #")[1,9]}
k,f,i=i,[p]+f,e.zip(f).map{|l,m|l.bytes.zip(m.to_s.bytes).map{|n,o|j|=n&3&q=o||0;(n|q).chr}*""}until j>0
e=[]
e+=k.reject{|r|r.sum==544&&e<<r.tr(?#,?\s)&&d+=10}}
puts e,d

নোট করুন যে \000পালানো (তৃতীয় লাইনের নাল বাইট সহ) তাদের প্রকৃত অ-ছাপানো সমতুল্য দিয়ে প্রতিস্থাপন করা উচিত।

নমুনা ইনপুট:

[          ]
[          ]
[          ]
[          ]
[ #    #  #]
[ ## ######]
[==========]
T2 Z6 I0 T7

ব্যবহার:

ruby1.9 tetris.rb < input

বা

ruby1.9 tetris.rb input

টেট্রোমিনোস ফেলে দেওয়ার এবং অন্য গ্লাসকে অ্যারেতে রাখার আরও একটি উপায়, এমনকি সীমানা থাকাও ... চমৎকার। এখন আপনি রুবি / পার্ল নেতা হবেন। পিএস: আমি জানতাম না ?\s
নাকিলন

12

সি, 727 [...] 596 581 556 517 496 471 461 457 চার্স

এটি আমার প্রথম কোড গল্ফ, আমি মনে করি চরিত্রের সংখ্যাটি অনেক কমতে পারে, অভিজ্ঞ গল্ফাররা আমাকে কিছু ইঙ্গিত দিতে পারলে ভাল হবে।

বর্তমান সংস্করণটি বিভিন্ন মাত্রা সহ প্লেফিল্ডগুলিও পরিচালনা করতে পারে। ইনপুটটিতে ডস / উইন্ডোজ এবং ইউনিক্স ফর্ম্যাট উভয় ক্ষেত্রে লাইনব্রেক থাকতে পারে।

কোডটি অপ্টিমাইজেশনের আগে বেশ সোজা ছিল, টেট্রোমিনোগুলি 4 টি পূর্ণসংখ্যায় সংরক্ষণ করা হয় যা একটি (7 * 3) x4 বিট অ্যারে হিসাবে ব্যাখ্যা করা হয়, প্লেফিল্ডটি যেমন হয় তেমন সংরক্ষণ করা হয়, টাইলস বাদ দেওয়া হয় এবং প্রতিটিের পরে সম্পূর্ণ লাইনগুলি সরানো হয় টাইল ড্রপ।

কীভাবে অক্ষরগুলি গণনা করা যায় তা সম্পর্কে আমি নিশ্চিত ছিলাম না, তাই আমি কোডের ফাইলসাইজটি সমস্ত অযৌক্তিক লাইনব্র্যাকগুলি সরিয়ে দিয়ে ব্যবহার করেছি।

সম্পাদনা 596 => 581: কিটসিউনওয়াইএমজিকে ধন্যবাদ, %lsপরামর্শ ব্যতীত সমস্ত কিছুই নিখুঁতভাবে কাজ করেছে, অতিরিক্তভাবে, আমি লক্ষ্য করেছি এর putchপরিবর্তে putcharব্যবহার করা যেতে পারে ( getchকোনওভাবে কাজ করে না) এবং সমস্ত বন্ধনী সরিয়ে ফেলেছে #define G

সম্পাদনা 581 => 556: বাকী forএবং নেস্টেড Fলুপগুলির সাথে সন্তুষ্ট ছিল না , তাই কিছু লুপগুলি পরিবর্তন করা এবং লুপগুলি অপসারণ করা ছিল, বেশ বিভ্রান্তিকর তবে অবশ্যই এটি মূল্যবান।

556 সম্পাদনা করুন => 517: অবশেষে aএকটি আন্ত অ্যারে করার উপায় খুঁজে পেয়েছে । কিছু N;মিশে গেছে c, আর breakনেই।

সম্পাদনা 496 => 471: প্লেফিল্ডের প্রস্থ এবং উচ্চতা এখন ঠিক করা হয়েছে।

সম্পাদনা 471 => 461: গৌণ পরিবর্তনগুলি, কোনও স্ট্যান্ডার্ড ফাংশন না putcharহিসাবে আবার ব্যবহৃত হয় putch

সম্পাদনা: বাগফিক্স, টাইল ড্রপ হওয়ার পরে সম্পূর্ণ লাইনগুলি অপসারণের আগে সরিয়ে ফেলা হয়েছিল , সুতরাং সম্পূর্ণ লাইনগুলি শেষে ছেড়ে যেতে পারে। ফিক্স অক্ষরের সংখ্যা পরিবর্তন করে না।

#define N (c=getchar())
#define G T[j%4]&1<<t*3+j/4
#define X j%4*w+x+j/4
#define F(x,m) for(x=0;x<m;x++)
#define W while
T[]={916561,992849,217,1},C[99],c,i,j,s,t,x,A,a[99],w=13;
main(){F(j,7)C["IJLSTZO"[j]]=j;
F(j,91)a[j]=N;
W(N>w){t=C[c];x=N-86;
W(c){F(j,12)if(G&&X>1?a[X]-32:0)c=0;
F(j,12)if(G&&X>w&&!c)a[X-w]=35;x+=w;}N;
F(i,6){A=0;t=i*w;F(x,w)A|=(a[t+x]==32);
if(!A){s++;F(j,t)a[t+w-j]=a[t-j];
x=1;W(a[x]-93)a[x++]=32;}}}
F(i,91)putchar(a[i]);printf("%i0",s);}

4
আপনি forহিসাবে সংজ্ঞায়িত করতে পারবেন না #define F(x,m) for(x=0;x++<m;)? এটি সি # তে কাজ করে ...: পি
ব্রুনোএলএম

@ ব্রুনোএলএম: ধন্যবাদ, তবে এটি কার্যকর হবে না, পরিবর্তনের পরিবর্তে ফে F(x,3){printf("%i",x}প্রিন্টগুলি । এতে পরিবর্তিত হতে পারে তবে এটি কিছুই সংরক্ষণ করে না :)12012for(x=-1;x++<m;)
schnaader

4
আপনি যদি কোডটি সঠিকভাবে লিখেছেন, আপনি যদি সি হিসাবে সংকলন করেন তবে আপনাকে stdio.h অন্তর্ভুক্ত করতে হবে না (যদি না আমি কিছু মিস করি?) কয়েকটি চর সংরক্ষণ করুন :)

4
আপনি আপনার এন এর সংজ্ঞায়িত প্রতিস্থাপন করতে পারেন (c=getchar())এবং 6 টি অক্ষর সংরক্ষণ করে সমস্ত সি = এন লাইন মুছে ফেলতে পারেন। আমি যদি এগুলি সম্পর্কে ভুল না করি তবে আপনি 585
নামা

4
কমপক্ষে C89 এর জন্য ভেরিয়েবলের জন্যও int-এ ডিফল্ট টাইপ করুন।
নিনজালজ

8

পাইথন 2.6+ - 334 322 316 টি অক্ষর

397 368 366 অক্ষর সঙ্কুচিত

#coding:l1
exec'xÚEPMO!½ï¯ i,P*Ýlš%ì­‰=‰Ö–*†­þz©‰:‡—Lò¾fÜ”bžAù,MVi™.ÐlǃwÁ„eQL&•uÏÔ‹¿1O6ǘ.€LSLÓ’¼›î”3òšL¸tŠv[ѵl»h;ÁºŽñÝ0Àë»Ç‡ÛûH.ª€¼âBNjr}¹„V5¾3Dë@¼¡•gO. ¾ô6 çÊsÃЮürÃ1&›ßVˆ­ùZ`Ü€ÿžcx±ˆ‹sCàŽ êüRô{U¯ZÕDüE+³ŽFA÷{CjùYö„÷¦¯Î[0þøõ…(Îd®_›â»E#–Y%’›”ëýÒ·X‹d¼.ß9‡kD'.decode('zip')

একক নতুন লাইনের প্রয়োজন, এবং আমি এটিকে একটি চরিত্র হিসাবে গণনা করেছি।

ব্রাউজার কোড পৃষ্ঠা মুম্বো জাম্বো এই কোডটির একটি সফল অনুলিপি-আটকাতে বাধা দিতে পারে, তাই আপনি এই কোড থেকে বিকল্পটি ফাইলটি তৈরি করতে পারেন:

s = """
23 63 6F 64 69 6E 67 3A 6C 31 0A 65 78 65 63 27 78 DA 45 50 4D 4F 03 21
10 BD EF AF 20 69 2C 50 2A 02 DD 6C 9A 25 EC AD 07 8D 89 07 3D 89 1C D6
96 2A 86 05 02 1B AD FE 7A A9 89 3A 87 97 4C F2 BE 66 DC 94 62 9E 41 F9
2C 4D 56 15 69 99 0F 2E D0 6C C7 83 77 C1 16 84 65 51 4C 26 95 75 CF 8D
1C 15 D4 8B BF 31 4F 01 36 C7 98 81 07 2E 80 4C 53 4C 08 D3 92 BC 9B 11
EE 1B 10 94 0B 33 F2 9A 1B 4C B8 74 8A 9D 76 5B D1 B5 6C BB 13 9D 68 3B
C1 BA 8E F1 DD 30 C0 EB BB C7 87 DB FB 1B 48 8F 2E 1C AA 80 19 BC E2 42
4E 6A 72 01 7D B9 84 56 35 BE 33 44 8F 06 EB 40 BC A1 95 67 4F 08 2E 20
BE F4 36 A0 E7 CA 73 C3 D0 AE FC 72 C3 31 26 9B DF 56 88 AD F9 5A 60 DC
80 FF 9E 63 78 B1 88 8B 73 43 E0 8E A0 EA FC 52 F4 7B 55 8D AF 5A 19 D5
44 FC 45 2B B3 8E 46 9D 41 F7 7B 43 6A 12 F9 59 F6 84 F7 A6 01 1F AF CE
5B 30 FE F8 F5 85 28 CE 64 AE 5F 9B E2 BB 45 23 96 59 25 92 9B 94 EB FD
10 D2 B7 58 8B 64 BC 2E DF 39 87 6B 44 27 2E 64 65 63 6F 64 65 28 27 7A
69 70 27 29
"""

with open('golftris.py', 'wb') as f:
    f.write(''.join(chr(int(i, 16)) for i in s.split()))

পরীক্ষামূলক

ইন্ট্রিটিস

[]
[]
[]
[]
[# # #]
[## #######]
[===========]
টি 2 জেড 6 আই0 টি 7

নিউলাইনগুলি অবশ্যই ইউনিক্স-স্টাইলের (কেবল লাইনফিড)। শেষ লাইনে একটি চলন্ত নিউলাইন optionচ্ছিক।

পরীক্ষা করার জন্য:

> পাইথন golftris.py <ইন্ট্রিস
[]
[]
[]
[# ###]
[# ###]
[##### ####]
[===========]
10

এই কোডটি মূল কোডটি আনজিপ করে এবং এটি দিয়ে কার্যকর করে exec। এই সংক্রামিত কোডটির ওজন হ'ল 366 টি অক্ষর এবং এর মতো দেখতে:

import sys
r=sys.stdin.readlines();s=0;p=r[:1];a='[##########]\n'
for l in r.pop().split():
 n=int(l[1])+1;i=0xE826408E26246206601E>>'IOZTLSJ'.find(l[0])*12;m=min(zip(*r[:6]+[a])[n+l].index('#')-len(bin(i>>4*l&31))+3for l in(0,1,2))
 for l in range(12):
  if i>>l&2:c=n+l/4;o=m+l%4;r[o]=r[o][:c]+'#'+r[o][c+1:]
 while a in r:s+=10;r.remove(a);r=p+r
print''.join(r),s

নিউলাইনগুলি প্রয়োজনীয় এবং এগুলির প্রতিটি চরিত্র।

এই কোডটি পড়ার চেষ্টা করবেন না। চলক নামগুলি আক্ষরিকভাবে সর্বোচ্চ সংকোচনের সন্ধানে এলোমেলোভাবে বেছে নেওয়া হয় (বিভিন্ন ভেরিয়েবলের নাম সহ, আমি কমপ্রেসনের পরে 342 টির মতো অক্ষর দেখেছি)। আরও একটি বোধগম্য সংস্করণ নিম্নলিখিত:

import sys

board = sys.stdin.readlines()
score = 0
blank = board[:1] # notice that I rely on the first line being blank
full  = '[##########]\n'

for piece in board.pop().split():
    column = int(piece[1]) + 1 # "+ 1" to skip the '[' at the start of the line

    # explanation of these three lines after the code
    bits = 0xE826408E26246206601E >> 'IOZTLSJ'.find(piece[0]) * 12
    drop = min(zip(*board[:6]+[full])[column + x].index('#') -
               len(bin(bits >> 4 * x & 31)) + 3 for x in (0, 1, 2))

    for i in range(12):
        if bits >> i & 2: # if the current cell should be a '#'
            x = column + i / 4
            y = drop + i % 4
            board[y] = board[y][:x] + '#' + board[y][x + 1:]

    while full in board:      # if there is a full line,
        score += 10           # score it,
        board.remove(full)    # remove it,
        board = blank + board # and replace it with a blank line at top
        
print ''.join(board), score

কর্কসটি তিনটি ক্রিপ্টিক লাইনে রয়েছে আমি বলেছি আমি ব্যাখ্যা করব।

টেট্রোমিনোসের আকারটি সেখানে হেক্সাডেসিমাল সংখ্যায় এনকোড করা হয়েছে। প্রতিটি তেট্রোনিমো কোষের একটি 3x4 গ্রিড অধিগ্রহণ হিসাবে বিবেচনা করা হয়, যেখানে প্রতিটি ঘর হয় ফাঁকা (একটি স্থান) বা পূর্ণ (একটি সংখ্যা চিহ্ন) is তারপরে প্রতিটি টুকরা 3 টি হেক্সাডেসিমাল ডিজিট সহ এনকোড করা হয়, প্রতিটি ডিজিট 4-সেল কলামকে বর্ণনা করে। সর্বনিম্ন উল্লেখযোগ্য অঙ্কগুলি বাম-সর্বাধিক কলামগুলিকে বর্ণনা করে এবং প্রতিটি ডিজিটের সর্বনিম্ন উল্লেখযোগ্য বিট প্রতিটি কলামের শীর্ষ সর্বাধিক ঘরকে বর্ণনা করে। যদি কিছুটা 0 হয়, তবে সেই ঘরটি ফাঁকা, অন্যথায় এটি '#'। উদাহরণস্বরূপ, আই টেট্রোনিমোটি 00Fবাম-সর্বাধিক কলামে চারটি সংখ্যার চিহ্নকে এনকোড করতে সর্বনিম্ন-তাত্পর্যপূর্ণ অঙ্কের চারটি বিট সেট হিসাবে এনকোড করা হয়েছে, এবং টি হয়131উপরের বিটটি বাম এবং ডানদিকে এবং শীর্ষ দুটি বিট মাঝখানে সেট করে in

পুরো হেক্সাডেসিমাল সংখ্যাটি তখন একটি বিটকে বামে স্থানান্তরিত করে (দুটি দ্বারা গুণিত)। এটি আমাদের নীচের অংশটিকে কিছুটা উপেক্ষা করার অনুমতি দেবে। আমি কেন এক মিনিটে ব্যাখ্যা করব।

সুতরাং ইনপুট থেকে বর্তমান টুকরোটি দেওয়া, আমরা এই হেক্সাডেসিমাল সংখ্যায় সূচকটি পাই যেখানে এটির আকৃতি বর্ণনাকারী 12 টি বিট শুরু হয়, তারপরে নীচে স্থানান্তরিত করুন যাতে bitsভেরিয়েবলের 1-1 (বিট 0 এড়িয়ে যাওয়া) বিট বর্তমান টুকরাটি বর্ণনা করে।

থেকে নিয়োগ dropনির্ধারণ করে কিভাবে গ্রিড উপর থেকে অনেক সারি টুকরা অন্যান্য টুকরা টুকরা উপর অবতরণ আগে আসবে। প্রথম লাইনটি খেলার ক্ষেত্রের প্রতিটি কলামের শীর্ষে কতগুলি খালি ঘর রয়েছে তা সন্ধান করে, যখন দ্বিতীয়টি টুকরোটির প্রতিটি কলামের মধ্যে সর্বনিম্ন দখলকৃত সেলটি আবিষ্কার করে। zipফাংশন যেখানে প্রতিটি tuple নিয়ে গঠিত tuples একটি তালিকা ফেরৎ এন ইনপুট তালিকার প্রতিটি আইটেম থেকে কক্ষ। সুতরাং, নমুনা ইনপুট বোর্ড ব্যবহার করে, zip(board[:6] + [full])ফিরে আসবে:

[
 ('[', '[', '[', '[', '[', '[', '['),
 (' ', ' ', ' ', ' ', ' ', ' ', '#'),
 (' ', ' ', ' ', ' ', '#', '#', '#'),
 (' ', ' ', ' ', ' ', ' ', '#', '#'),
 (' ', ' ', ' ', ' ', ' ', ' ', '#'),
 (' ', ' ', ' ', ' ', ' ', '#', '#'),
 (' ', ' ', ' ', ' ', ' ', '#', '#'),
 (' ', ' ', ' ', ' ', '#', '#', '#'),
 (' ', ' ', ' ', ' ', ' ', '#', '#'),
 (' ', ' ', ' ', ' ', ' ', '#', '#'),
 (' ', ' ', ' ', ' ', '#', '#', '#'),
 (']', ']', ']', ']', ']', ']', ']')
]

আমরা যথাযথ কলামের সাথে সম্পর্কিত এই তালিকাটি থেকে টুপল নির্বাচন করি এবং কলামের প্রথমটির সূচি খুঁজে '#'পাই। এ কারণেই কল করার আগে আমরা একটি "পূর্ণ" সারি সংযুক্ত করেছি zip, যাতে indexকলামটি অন্যথায় ফাঁকা থাকলে এর বুদ্ধিমান রিটার্ন (কোনও ব্যতিক্রম ছোঁড়ার পরিবর্তে) আসবে।

তারপরে '#'টুকরোটির প্রতিটি কলামের সর্বনিম্ন সন্ধান করার জন্য , আমরা সেই কলামটি বর্ণনা করে এমন চারটি বিট স্থানান্তরিত এবং মুখোশ করি, তারপরে সেই binফাংশনটি সেগুলি এবং শূন্যের একটি স্ট্রিংয়ে পরিণত করতে ব্যবহার করি । binফাংশন শুধুমাত্র উল্লেখযোগ্য বিট ফেরৎ, তাই আমরা শুধুমাত্র এই স্ট্রিং এর দৈর্ঘ্য নিরূপণ প্রয়োজন সর্বনিম্ন দখলকৃত সেল (সবচেয়ে গুরুত্বপূর্ণ সেট বিট) খুঁজে। binফাংশন এছাড়াও prepends '0b', তাই আমরা যে বিয়োগ করতে হবে। আমরা কমপক্ষে উল্লেখযোগ্য বিটটিকেও উপেক্ষা করি। এ কারণেই হেক্সাডেসিমাল সংখ্যাটি কিছুটা বামে স্থানান্তরিত হয়। এটি খালি কলামগুলির জন্য অ্যাকাউন্টে রয়েছে, যার স্ট্রিং উপস্থাপনাগুলি কেবল শীর্ষ কক্ষ পূর্ণ (যেমন টি টুকরা) সহ কলামের সমান দৈর্ঘ্যযুক্ত হবে ।

উদাহরণস্বরূপ, এর কলাম আমি tetromino, যেমন আগে উল্লেখিত হয় F, 0এবং 0bin(0xF)হয় '0b1111'। উপেক্ষা করার পরে '0b', আমাদের দৈর্ঘ্য 4, যা সঠিক। কিন্তু bin(0x0)হয় 0b0'0b'এটিকে উপেক্ষা করার পরে , আমাদের এখনও '1 এর দৈর্ঘ্য রয়েছে যা ভুল। এটির জন্য অ্যাকাউন্ট হিসাবে, আমরা শেষ পর্যন্ত একটি অতিরিক্ত বিট যুক্ত করেছি, যাতে আমরা এই তুচ্ছ বিটকে উপেক্ষা করতে পারি। অতএব, কোডটিতে শুরুর দিকে +3নেওয়া অতিরিক্ত দৈর্ঘ্য '0b'এবং শেষে তুচ্ছ-বিস্তারের জন্য অ্যাকাউন্ট রয়েছে ।

এগুলি সমস্ত তিনটি কলামের জন্য জেনারেটর এক্সপ্রেশন ( (0,1,2)) এর মধ্যে ঘটে এবং আমরা তিনটি কলামের minযে কোনওটিতে স্পর্শ করার আগে টুকরোটি সর্বাধিক সারি সরাতে পারে তা সন্ধান করতে ফলাফলটি গ্রহণ করি ।

বাকিটি কোডটি পড়ে বোঝা খুব সহজ হওয়া উচিত, তবে forএই নিয়োগগুলি অনুসরণ করে লুপটি বোর্ডে টুকরো যোগ করে। এর পরে, whileলুপটি সম্পূর্ণ সারিগুলি সরিয়ে দেয়, তাদের শীর্ষে ফাঁকা সারি দিয়ে প্রতিস্থাপন করে এবং স্কোরটি দীর্ঘায়িত করে। শেষে, বোর্ড এবং স্কোর আউটপুট প্রিন্ট করা হয়।


6

পাইথন, 298 অক্ষর

এখন পর্যন্ত সমস্ত অ- সাহসী ভাষা সমাধানকে বিট করে (পার্ল, রুবি, সি, বাশ ...)


... এবং এমনকি কোড-জিপিং চিকানারি ব্যবহার করে না।

import os
r=os.read
b='[%11c\n'%']'*99+r(0,91)
for k,v in r(0,99).split():
    t=map(ord,' -:G!.:; -:; !-.!"-. !". !./')['IJLOSTZ'.find(k)*4:][:4];v=int(v)-31
    while'!'>max(b[v+j+13]for j in t):v+=13
    for j in t:b=b[:v+j]+'#'+b[v+j+1:]
    b=b.replace('[##########]\n','')
print b[-91:],1060-10*len(b)/13

পরীক্ষার উদাহরণে

[          ]
[          ]
[          ]
[          ]
[ #    #  #]
[ ## ######]
[==========]
T2 Z6 I0 T7

এটা আউটপুট

[          ]
[          ]
[          ]
[#      ###]
[#     ### ]
[##### ####]
[==========]
10

পুনশ্চ. নাকিলনের দ্বারা +5 ব্যয়ে একটি বাগ ঠিক করা


এটি কিছু চমত্কার চিত্তাকর্ষক কোড। এটি ঠিক করার জন্য আরও 14 টি অক্ষর লাগবে ( আইডিয়োনা / আইজেইওয়াইবি ), যদি না এর চেয়ে আরও ভাল উপায় থাকে তবে এখনও তবুও, এটি গল্ফস্ক্রিপ্ট এবং বাশ ব্যতীত সমস্ত কিছুকে পরাজিত করে। এটি অবশ্যই একটি চতুর সমাধান।
পি বাবা

হ্যাঁ, একেবারে খুব সূক্ষ্ম সমাধান!
ক্রিস্টোফিড

@ নকিলন: ধন্যবাদ, স্পষ্টতই সেটিকে মিস করেছি। নির্ধারিত @ ব্যয় 293-> 298
নাস বানভ

@ পি বাবা, ধন্যবাদ - আমাকে "সমস্ত অ-সাহসী" বলার ক্ষেত্রে সত্যবাদী রাখার জন্য আমি বাশ ও টুলচেনের আওতায় আনার একটি উপায় খুঁজে পেয়েছি :)
নাস বানভ

@ ন্যাব: কোডটি ছোট রাখার জন্য এটি কিছু সীমাবদ্ধতার কথা মাথায় রেখে লেখা হয়েছিল। 33 টি টেট্রোমিনিস সর্বাধিক এবং 99 লাইনের ড্রপ সর্বাধিক কিছু। সহজেই +3 দামের জন্য বাড়ানো যেতে পারে। বা কম-স্বল্প মূল্যের জন্য :), সীমাবদ্ধতাগুলি পুরোপুরি তোলা যায়। বিটিডাব্লু, পরীক্ষার সেটটি কীভাবে এই স্পষ্টটি স্পষ্ট করে জানাতে পারে তার একটি দুর্দান্ত উদাহরণ (আমি মন্তব্যে ক্রিস্টোফারডি কী
বগিং করছি

5

গল্ফস্ক্রিপ্ট 260 অক্ষর

আমি নিশ্চিত এটির উন্নতি হতে পারে, আমি গল্ফস্ক্রিপ্টে এক ধরণের নতুন।

[39 26.2/0:$14{.(}:?~1?15?1?14 2??27?13.!14?2?27?14 1]4/:t;n/)\n*:|;' '/-1%.,:c;~{)18+:&;'XIOZTLSJX'\%~;,1-t\={{.&+.90>{;.}*|\=32=!{&13-:&;}*}%}6*{&+}/|{\.@<'#'+\)|>+}4*{'['\10*']'++}:
;n/0\~n+:|;0\{.'#'
={;)}{n+|+:|;}if\.}do;' '
n+\.@*|+\$+:$;.,1-<:|;}c*|n?$*

লাইনের সমাপ্তি প্রাসঙ্গিক (শেষে একটি হওয়া উচিত নয়)। যাইহোক, আমি যে কয়েকটি পরীক্ষার মামলা ব্যবহার করেছি তা এখানে:

> বিড়াল init.txt 
[]
[]
[]
[]
[# # #]
[## #######]
[===========]
টি 2 জেড 6 আই0 টি 7> বিড়াল init.txt | রুবি golfscript.rb tetris.gsc
[]
[]
[]
[# ###]
[# ###]
[##### ####]
[===========]
10

> বিড়াল init.txt
[]
[]
[]
[]
[# # #]
[## #####]
[===========]
I0 O7 Z1 S4> বিড়াল init.txt | রুবি golfscript.rb tetris.gsc
[]
[]
[]
[#]
[### ####]
[### #####]
[===========]
10

> বিড়াল init.txt
[]
[]
[]
[## ###]
[# #]
[## #######]
[===========]
T7 I0 I3> বিড়াল init.txt | রুবি golfscript.rb tetris.gsc
[]
[]
[]
[]
[# #]
[## # # #]
[===========]
20

নোট করুন যে ইনপুট ফাইলে লাইনের শেষ নেই, লাইনের একটি প্রান্তটি স্ক্রিপ্টটিকে যেমন ভাঙবে।


4
/ আমি গল্ফস্ক্রিপ্টকে সত্যিকারের প্রতিযোগিতার ভাষা হিসাবে বিবেচনা করি না ... এটি কেবল একটি লাইব্রেরি যা সরাসরি গল্ফ কার্যগুলিতে রূপায়িত হয় ... এই গ্রন্থাগারের আকারটি গল্ফস্ক্রিপ্ট কোডের আকারে যুক্ত হতে পারে ...
নাকিলন

4
@ নাকিলন - আপনি কাঁচা মেশিনের ভাষায় লিখিত না এমন কিছু সম্পর্কে অনুরূপ কিছু বলতে পারবেন না? :) পাইথন ইন্টারপ্রেটারটি কেবল একটি গ্রন্থাগার, এটি আপনার প্রবেশের আকারকে যুক্ত করে। </
sarcasm

4
@ নকিলন: এটাই কেবল দোভাষী। এটি অন্য যে কোনও ভাষায় লেখা যেতে পারে; আপনি কি এখনও বলবেন যে গল্ফস্ক্রিপ্ট একটি আসল ভাষা নয়?
মাইকেল ফৌকারাকিস

4
@ ন্যাব: ধন্যবাদ, আমি অনুভব করেছি যে আমি কিছু কৌশল মিস করেছি ... খারাপ লাগবে না, আমি আমার কোডটি বোঝারও বিরক্ত করিনি :)।
কোডরাজ

4
@ মিশেল ফৌকারাকিস, আমি এক মিনিটে এই কাজটি একটি চরে সমাধান করতে নিজের দোভাষী লিখতে পারি, তবে কী?
নাকিলন

4

ও'ক্যামেল 809 782 চার্স

open String let w=length let c s=let x=ref 0in iter(fun k->if k='#'then incr x)s;!x open List let(@),g,s,p,q=nth,ref[],ref 0,(0,1),(0,2)let l=length let u=Printf.printf let rec o x i j=let a=map(fun s->copy s)!g in if snd(fold_left(fun(r,k)(p,l)->let z=c(a@r)in blit(make l '#')0(a@r)(i+p)l;if c(a@r)=z+l then r+1,k else r,false)(j-l x+1,true)x)then g:=a else o x i(j-1)and f x=let s=read_line()in if s.[1]='='then g:=rev x else f(sub s 1 10::x)let z=f [];read_line();;for i=0to w z/3 do o(assoc z.[i*3]['I',[p;p;p;p];'O',[q;q];'Z',[q;1,2];'T',[0,3;1,1];'L',[p;p;q];'S',[1,2;q];'J',[1,1;1,1;q]])(Char.code z.[i*3+1]-48)(l!g-1);let h=l!g in g:=filter(fun s->c s<>w s)!g;for i=1to h-(l!g)do incr s;g:=make 10' '::!g done;done;iter(fun r->u"[%s]\n"r)!g;u"[==========]\n";u"%d\n"(!s*10)

4

সাধারণ লিস্প 667 657 645 চার্স

কোড গল্ফে আমার প্রথম প্রচেষ্টা, তাই সম্ভবত অনেকগুলি কৌশল রয়েছে যা আমি এখনও জানি না। কিছু অবশিষ্ট "পঠনযোগ্যতা" রাখতে আমি সেখানে কিছু নিউলাইন রেখেছি (আমি নিউলাইনগুলিকে 2 বাইট হিসাবে গণনা করেছি, সুতরাং 6 অপ্রয়োজনীয় নিউলাইনগুলি সরিয়ে 12 আরও চরিত্র অর্জন করেছে)।

ইনপুটটিতে প্রথমে আকারগুলি পরে ক্ষেত্রটি রাখুন।

(let(b(s 0)m(e'(0 1 2 3 4 5 6 7 8 9)))
(labels((o(p i)(mapcar(lambda(j)(+ i j))p))(w(p r)(o p(* 13 r)))(f(i)(find i b))
(a(&aux(i(position(read-char)"IOZTLSJ")))(when i(push(o(nth i'((0 13 26 39)(0 1 13 14)(0 1 14 15)(0 1 2 14)(0 13 26 27)(1 2 13 14)(1 14 26 27)))(read))m)(a))))
(a)(dotimes(i 90)(if(find(read-char)"#=")(push i b)))(dolist(p(reverse m))
(setf b`(,@b,@(w p(1-(position-if(lambda(i)(some #'f(w p i)))e)))))
(dotimes(i 6)(when(every #'f(w e i))(setf s(1+ s)b(mapcar(lambda(k)(+(if(>(* 13 i)k)13(if(<=(* 13(1+ i))k)0 78))k))b)))))
(dotimes(i 6)(format t"[~{~:[ ~;#~]~}]
"(mapcar #'f(w e i))))(format t"[==========]
~a0"s)))

পরীক্ষামূলক

T2 Z6 I0 T7
[          ]
[          ]
[          ]
[          ]
[ #    #  #]
[ ## ######]
[==========]
[          ]
[          ]
[          ]
[#      ###]
[#     ### ]
[##### ####]
[==========]
10
NIL

খুব ছোট নয়, তবে কদর্যতার জন্য +1! আমি কল্পনা করেছিলাম যে অক্ষরগুলির স্যুপটি দেখতে প্রথম দেখতে যদি এটি বন্ধনী নিয়ে আসে।
পি বাবা

@ পি বাবা: ধন্যবাদ হ্যাঁ, সম্ভবত এটি দেখতে কেমন হবে :)।
lpetru

2

রুবি 505 479 474 442 439 426 অক্ষর

একটি প্রথম প্রচেষ্টা। আয়রণরবি দিয়ে এটি করেছেন। আমি নিশ্চিত যে এটি উন্নত করা যেতে পারে, তবে আমার সত্যিই আজ কিছু কাজ করা উচিত!

p,q,r,s=(0..9),(0..2),(0..6),0
t=[*$<]
f=p.map{|a|g=0;r.map{|b|g+=2**b if t[6-b][a+1]==?#};g}
t.pop.split.map{|x|w,y=[15,51,306,562,23,561,113]["IOZTLSJ"=~/#{x[0]}/],x[1].to_i
l=q.map{|d|r.inject{|b,c|f[d+y]&(w>>(d*4)&15-c+1)>0?c:b}}.max
q.map{|b|f[b+y]|=w>>(b*4)&15-l}
r.map{i=f.inject{|a,b|a&b};f.map!{|a|b=i^(i-1);a=((a&~b)>>1)+(a&(b>>1))};s+=i>0?10:0}}
p.map{|a|r.map{|b|t[6-b][a+1]=f[a]&2**b>0??#:' '}}
puts t,s

পরীক্ষামূলক

cat test.txt | ruby tetris.rb
[          ]
[          ]
[          ]
[          ]
[#      ###]
[#     ### ]
[##### ####]
[==========]
10

সাধারণ রুবি ব্যবহার করে এখন সম্পাদনা করুন । দেয়ালের আউটপুট পেয়েছি ..


আরও একজন রুবিস্ট, সুন্দর! তবে ইটের চারপাশে একটি গ্লাস তৈরি করুন।
নাকিলন

1

রুবির আরেকজন, 573 546 টি অক্ষর

: **

Z={I:?#*4,J:'#,###',L:'###,#',O:'##,##',S:'#,##, #',Z:' #,##,#',T:' #,##, #'}
t=[*$<]
R=->s{s.reverse}
T=->m{m.transpose}
a = T[R[t].join.scan /.#{'(\D)'*10}.$/]
t.pop.split.each{|z|
t,o=Z[z[0].to_sym].split(',').map{|x|x.split //},z[1].to_i
r=0..t.size-1
y=r.map{|u|1+a[o+u].rindex(?#).to_i-t[u].count(' ')}.max
(0..3).each{|i|r.each{|j|t[j][i]==?#&&a[o+j][y+i]=t[j][i]}}}
s=0
a.each{|x|s=a.max_by(&:size).size;x[s-=1]||=' 'while s>0}
a=R[T[a].reject{|x|x*''=~/[#]{10}/&&s+=10}.map{|x|?[+x*''+?]}[0..6]]
puts (0..8-a.size).map{?[+' '*10+?]},a,s

পরীক্ষামূলক:

cat test.txt | ruby 3858384_tetris.rb
[          ]
[          ]
[          ]
[          ]
[#      ###]
[#     ### ]
[##### ####]
[==========]
10

সঙ্গে ফিক্সডa.each{|x|s=a.max_by(&:size).size;x[s-=1]||=' 'while s>0}
glebm
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.