বেজেড / ম্যাচ 3 গেমটিতে কোনও পদক্ষেপ বিদ্যমান কিনা তা নির্ধারণ করুন

Question

পটভূমি

বেজেওয়েলড এবং অনুরূপ গেমগুলিতে, খেলোয়াড়কে পর পর একই রঙের তিনটি মেলানোর জন্য 8x8 রত্নের একটি গ্রিডে দুটি সংলগ্ন রত্ন (কোন তির্যক নয়) অদলবদল করতে হবে। রত্নগুলি আনুভূমিকভাবে বা উল্লম্বভাবে মিলতে পারে। গেমপ্লে অব্যাহত থাকে যতক্ষণ না কোনও পদক্ষেপ বিদ্যমান না থাকে যা ফলস্বরূপ একের পর এক তিনটি তৈরি করা যায়, যার শেষে গেমটি শেষ হয়।

কার্য

লক্ষ্যটি এমন একটি প্রোগ্রাম লিখতে হয় যা নির্ধারণ করে যে বেজেওয়েডের কোনও খেলা এখনও শেষ হয়নি কিনা। অন্য কথায়, এটি কোনও সম্ভাব্য পদক্ষেপ যা সারিবদ্ধভাবে কমপক্ষে তিনটি করে তোলে তা পরীক্ষা করে দেখতে হবে। এক সারিতে আরও তিনটি রত্ন থাকতে পারে এবং এটি এখনও একটি বৈধ পদক্ষেপ।

ইনপুট

আপনার প্রোগ্রামটি অবশ্যই স্ট্যান্ডার্ড ইনপুটটির মাধ্যমে একটি বেজেওয়েড গ্রিডের 8x8 উপস্থাপনা গ্রহণ করতে হবে। সাতটি রত্ন বর্ণের প্রত্যেকটিই 1 থেকে 7 পর্যন্ত একটি অঙ্ক দ্বারা উপস্থাপিত হবে Each প্রতিটি লাইনে একটি সারি থাকবে এবং 8 টি সংখ্যার সমন্বিত প্রতিটি 8 টি লাইন ইনপুট হবে। উদাহরণ দেখুন। আপনি ধরে নিতে পারেন যে ইনপুটটি সর্বদা এই ফর্ম্যাটটি অনুসরণ করবে এবং এরই মধ্যে পরপর তিনটি থাকবে না।

আউটপুট

প্রোগ্রাম তারপর আউটপুট (মানক আউটপুটে) আবশ্যক yesবা noথাকুক বা না থাকুক অন্তত একটি বৈধ পদক্ষেপ উপর নির্ভর করে যে একটি সারিতে বা তিনটি রত্ন স্থাপিত হবে বিদ্যমান। আপনার প্রোগ্রামের অবশ্যই একটি yesবা একক উদাহরণ ছাড়া অন্য কিছু আউটপুট করা উচিত নয় no।

বিধি

আপনার প্রোগ্রামে কোনও বাহ্যিক ফাইল বা সংস্থান, কমান্ড-লাইন আর্গুমেন্ট বা কোনও নির্দিষ্ট ফাইলের নাম ব্যবহার করা উচিত নয়। তার উত্স কোডটিতে বাইটের ন্যূনতম সংখ্যা সহ প্রোগ্রামটি।

উদাহরণ

ইনপুট:

12314131
13224145
54762673
61716653
61341144
23453774
27645426
75575656

আউটপুট: yes

ইনপুট:

35261546
76421754
15743271
62135642
35617653
64565476
54427254
15635465

আউটপুট: no

অতিরিক্ত পরীক্ষার মামলার জন্য এমটি 0 এর উত্তর নীচে দেখুন ।

Comments

এটি কি কেবল সারি, বা কলামগুলিও।

— TheDoctor

@ ডক্টর কলামও। আমি যখন "পর পর তিনটি" বাক্যাংশটি ব্যবহার করি তখন এর অর্থ হ'ল এগুলি অবশ্যই একটি অনুভূমিক বা উল্লম্ব দিকটিতে রেখাযুক্ত থাকতে হবে।

— বিডিআর

@ বিডিআর 9 আপনি এটি সম্পাদনা করতে চাইতে পারেন

— জন ডিভোরাক

@ জনডভোরাক হয়ে গেছে

— বিডিআর

একসাথে 4+ টি অনুমোদিত হলে এডিট করতেও পারে।

— জাস্টিন 5

Answer 1

আসল সমাধান: জাভাস্ক্রিপ্ট - 261 255 228 227 179 153 অক্ষর

/(\d)(\1(\d|.{6}|.{9})|(\d|.{6}|.{9})\1|.{7}\1(.|.{9})|(.|.{9})\1.{7}|(.{7,9}|.{17})\1.{8}|.{8}\1(.{7,9}|.{17}))\1/.test(s.replace(/\n/g,'A'))?'yes':'no'

Assuming যে পরীক্ষা স্ট্রিং পরিবর্তনশীল হয় s(এটা একটি ফাংশন করতে fতারপর যোগ f=s=>একটি প্রম্পট থেকে ইনপুট নিতে তারপর প্রতিস্থাপন, কোড বা শুরুতে অন্যথায়, sসঙ্গে prompt())।

আউটপুট কনসোল হয়।

3 ^য় সমাধান: জাভাস্ক্রিপ্ট (ECMAScript 6) - 178 টি অক্ষর

p=x=>parseInt(x,36);for(t="2313ab1b8a2a78188h9haj9j8iaiir9r",i=v=0;s[i];i++)for(j=0;t[j];v|=s[i]==s[i+a]&s[i]==s[i+b]&i%9<8&(b>3|(i+b-a)%9<8))a=p(t[j++]),b=p(t[j++]);v?'yes':'no'

আমি নীচে 2 ^তম সমাধানটি নিয়েছি (যা নির্দিষ্ট কনফিগারেশনে অক্ষরগুলি পরীক্ষা করার জন্য নিয়মিত এক্সপ্রেশন ব্যবহার করে) এবং নিয়মিত এক্সপ্রেশন না ব্যবহার করে একই কনফিগারেশনে অভিন্ন অক্ষরের জন্য স্ট্রিংটি পরীক্ষা করতে পুনরায় কাজ করেছি।

বেস-36 string স্ট্রিং "2313ab1b8a2a78188h9haj9j8iaiir9r"জোড় অফসেটগুলি যাচাই করতে দেয় - উদাহরণস্বরূপ, জোড় যাচাইয়ের 23ফলাফল দেয় যদি আমি ^তম অক্ষর (i + 2) ^তম অক্ষর এবং (i + 3) ^তম অক্ষর (নিয়মিত প্রকাশের সমতুল্য ) (.).\1\1- অ-অভিন্ন চরিত্রটি কোনও নতুন লাইন নয় তা নিশ্চিত করার জন্য কিছু অতিরিক্ত চেক সহ)।

2 ^তম সমাধান: জাভাস্ক্রিপ্ট (ECMAScript 6) - 204 অক্ষর

p=x=>parseInt(x,18);g=a=>a?a>1?"(.|\\n){"+a+"}":".":"";f=(x,a,b)=>RegExp("(.)"+g(a)+"\\1"+g(b)+"\\1").test(x);for(t="10907160789879h8",i=v=0;t[i];v|=f(s,x,y)||f(s,y,x))x=p(t[i++]),y=p(t[i++]);v?'yes':'no'

বেস -18 স্ট্রিং থেকে নেওয়া বিভিন্ন সংখ্যক মান ব্যবহার করে একাধিক নিয়মিত অভিব্যক্তি (আরও তথ্যের জন্য নীচে দেখুন) তৈরি করে 10907160789879h8এবং ORসমস্ত পরীক্ষার পরীক্ষা নেয় । এটিকে আরও কমাতে আপনি নোট করতে পারেন যে নিয়মিত প্রকাশগুলি জোড়ায় আসে যেখানে একজনের অপরটির "বিপরীত" হয় (নিয়মিত এক্সপ্রেশনগুলিকে 3-ইন-সারি জন্য অনুভূমিকভাবে এবং উলম্বভাবে ওপি হিসাবে বলা হয় যে তারা কখনই উপস্থিত থাকবে না - আপনি যদি সেই পরীক্ষাগুলি 0088বেস -18 স্ট্রিং- এ সংযোজন করতে চান তবে।

ব্যাখ্যা

বৈধ পদক্ষেপের সমস্ত সম্ভাব্য কনফিগারেশনগুলিকে কভার করে নিয়মিত 16 টি অভিব্যক্তি দিয়ে শুরু করুন:

REs=[
    /(\d)\1\1/,                 // 3-in-a-row horizontally
    /(\d).\1\1/,                // 3-in-a-row horizontally after left-most shifts right
    /(\d)\1.\1/,                // 3-in-a-row horizontally after right-most shifts left
    /(\d)(?:.|\n){9}\1\1/,  // 3-in-a-row horizontally after left-most shifts down
    /(\d)(?:.|\n){7}\1.\1/, // 3-in-a-row horizontally after middle shifts down
    /(\d)(?:.|\n){6}\1\1/,  // 3-in-a-row horizontally after right-most shifts down
    /(\d)\1(?:.|\n){6}\1/,  // 3-in-a-row horizontally after left-most shifts up
    /(\d).\1(?:.|\n){7}\1/, // 3-in-a-row horizontally after middle shifts up
    /(\d)\1(?:.|\n){9}\1/,  // 3-in-a-row horizontally after right-most shifts up
    /(\d)(?:.|\n){7,9}\1(?:.|\n){8}\1/, // 3-in-a-row vertically (with optional top shifting left or right)
    /(\d)(?:.|\n){7}\1(?:.|\n){9}\1/,   // 3-in-a-row vertically after middle shifts right
    /(\d)(?:.|\n){9}\1(?:.|\n){7}\1/,   // 3-in-a-row vertically after middle shifts left
    /(\d)(?:.|\n){8}\1(?:.|\n){7}\1/,   // 3-in-a-row vertically after bottom shifts right
    /(\d)(?:.|\n){8}\1(?:.|\n){9}\1/,   // 3-in-a-row vertically after bottom shifts left
    /(\d)(?:.|\n){17}\1(?:.|\n){8}\1/,  // 3-in-a-row vertically after top shifts down
    /(\d)(?:.|\n){8}\1(?:.|\n){17}\1/,  // 3-in-a-row vertically after bottom shifts up
];

( দ্রষ্টব্য: 3-ইন-এ-সারি আনুভূমিকভাবে (0 ^ম ) এবং উল্লম্বভাবে (9 ^ম অংশ ) অপ্রাসঙ্গিক কারণ ওপি বলেছে যে এইগুলির সাথে মেলে ইনপুটগুলি কখনই উপস্থিত হবে না ))

ইনপুটটির বিপরীতে তাদের প্রত্যেকটির পরীক্ষা করা নির্ধারণ করবে যে সেই কনফিগারেশনের কোনও বৈধ পদক্ষেপ পাওয়া যাবে কিনা।

যাইহোক, নিয়মিত প্রকাশগুলি এই 6 টি প্রদানের জন্য একত্রিত হতে পারে:

/(\d)(?:.|(?:.|\n){9}|(?:.|\n){6})?\1\1/            // Tests 0,1,3,5
/(\d)\1(?:.|(?:.|\n){9}|(?:.|\n){6})?\1/            // Tests 0,2,6,8
/(\d)(?:.|\n){7}\1(?:.|(?:.|\n){9})\1/              // Tests 4,10
/(\d)(?:.|(?:.|\n){9})\1(?:.|\n){7}\1/              // Tests 7,11
/(\d)(?:(?:.|\n){7,9}|(?:.|\n){17})\1(?:.|\n){8}\1/ // Tests 9,14
/(\d)(?:.|\n){8}\1(?:(?:.|\n){7,9}|(?:.|\n){17})\1/ // Tests 9a,12,13,15

এরপরে এগুলি একক নিয়মিত অভিব্যক্তিতে সংযুক্ত করা যায়:

/(\d)(?:.|(?:.|\n){9}|(?:.|\n){6})?\1\1|(\d)\2(?:.|(?:.|\n){9}|(?:.|\n){6})?\2|(\d)(?:.|\n){7}\3(?:.|(?:.|\n){9})\3|(\d)(?:.|(?:.|\n){9})\4(?:.|\n){7}\4|(\d)(?:(?:.|\n){7,9}|(?:.|\n){17})\5(?:.|\n){8}\5|(\d)(?:.|\n){8}\6(?:(?:.|\n){7,9}|(?:.|\n){17})\6/

যা শুধু ইনপুট বিরুদ্ধে পরীক্ষা করা প্রয়োজন।

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

কিছু টেস্ট কেস যা অন্যান্য লোকেরা দরকারী খুঁজে পেতে পারে (কেবলমাত্র 1-7 সংখ্যা ব্যবহারের ইনপুট বিন্যাসের সাথে সম্মতি দেয় না তবে এটি সহজেই সংশোধন করা হয় এবং এটি কেবল একটি 8x4 গ্রিড - যেহেতু সমস্ত বৈধ ইনপুটগুলির পরীক্ষার জন্য এটি ন্যূনতম )।

ইনপুট স্ট্রিং থেকে কোনও মানচিত্রের ফর্ম্যাটে এটির উপরে 16 টি নিয়মিত এক্সপ্রেশন মেলে matches

Tests={
    "12345678\n34567812\n56781234\n78123456": -1, // No Match
    "12345678\n34969912\n56781234\n78123456": 1,    // 3-in-a-row horizontally after left-most shifts right 
    "12345678\n34567812\n59989234\n78123456": 2,    // 3-in-a-row horizontally after right-most shifts left
    "12345978\n34567899\n56781234\n78123456": 3,    // 3-in-a-row horizontally after left-most shifts down
    "12345978\n34569892\n56781234\n78123456": 4,    // 3-in-a-row horizontally after middle shifts down
    "12345678\n34967812\n99781234\n78123456": 5,    // 3-in-a-row horizontally after right-most shifts down
    "12399678\n34967812\n56781234\n78123456": 6,    // 3-in-a-row horizontally after left-most shifts up
    "12345678\n34597912\n56789234\n78123456": 7,    // 3-in-a-row horizontally after middle shifts up
    "12345998\n34567819\n56781234\n78123456": 8,    // 3-in-a-row horizontally after right-most shifts up
    "12945678\n34597812\n56791234\n78123456": 9,    // 3-in-a-row vertically after top shifts right
    "12349678\n34597812\n56791234\n78123456": 9,    // 3-in-a-row vertically after top shifts left
    "12345978\n34569812\n56781934\n78123456": 10,   // 3-in-a-row vertically after middle shifts right
    "92345678\n39567812\n96781234\n78123456": 11,   // 3-in-a-row vertically after middle shifts left
    "12945678\n34967812\n59781234\n78123456": 12,   // 3-in-a-row vertically after bottom shifts right
    "12349678\n34569812\n56781934\n78123456": 13,   // 3-in-a-row vertically after bottom shifts left
    "12395678\n34567812\n56791234\n78193456": 14,   // 3-in-a-row vertically after top shifts down
    "12345698\n34567892\n56781234\n78123496": 15,   // 3-in-a-row vertically after bottom shifts up
    "12345678\n34567899\n96781234\n78123456": -1,   // No match - Matches (.)\1.\1 but not 3 in a row
    "12345679\n99567812\n56781234\n78123456": -1,   // No match - Matches (.).\1\1 but not 3 in a row
};

সম্পাদনা 1

\dএর সাথে এস প্রতিস্থাপন করুন .- 6 টি অক্ষর সংরক্ষণ করে।

সম্পাদনা 2

অতিরিক্ত নন-ক্যাপচারিং গ্রুপগুলি এবং অপসারণ ব্যাক রেফারেন্সগুলি ( এম-বেটনার দ্বারা প্রস্তাবিত ) এর (?:.|\n)সাথে প্রতিস্থাপন করুন [\s\S]এবং হ্যাঁ / কোনও আউটপুট যুক্ত করা হবে।

সম্পাদনা 3

• বেস -18 স্ট্রিং থেকে স্বতন্ত্র নিয়মিত এক্সপ্রেশনগুলি তৈরি করতে ECMAScript 6 সমাধান যুক্ত করা হয়েছে।
• অনুভূমিকভাবে 3-ইন-এ-সারিটির জন্য পরীক্ষাগুলি সরানো হয়েছে ( এম-বাটনার দ্বারা প্রস্তাবিত )।

সম্পাদনা 4

আরও একটি (সংক্ষিপ্ত) সমাধান এবং আরও দুটি মিল নেই টেস্টের কেস।

সম্পাদনা করুন 5

• সংখ্যাসূচক অক্ষর ( ভাদিমআর দ্বারা প্রস্তাবিত ) দিয়ে নিউলাইনগুলি প্রতিস্থাপন করে সংক্ষিপ্ত মূল সমাধানটি ।

সম্পাদনা 6

• নিয়মিত অভিব্যক্তির বিটগুলিকে একত্রিত করে (মূলত ভাদিমআর দ্বারা প্রস্তাবিত ) সংক্ষিপ্ত মূল সমাধান ।

Comments

চমৎকার সমাধান! আমি ভাবিনি যে রেজেক্স কাজ করতে পারে। ?'yes':'no'ন্যায্যতার জন্য দয়া করে আপনার অক্ষর গণনায় অন্তর্ভুক্ত করুন , কারণ এটি প্রয়োজনীয়তার মধ্যে রয়েছে এবং অন্য প্রত্যেকে এটি ব্যবহার করছে।

— বিডিআর

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

— বিডিআর

দাঁড়ান।

— রেজেক্সের

এইচ-মিমি, .নিউলাইন সহ কোনও চরিত্রের সাথে মেলে জেএসে কোনও সংশোধক নেই ? পার্লের সাথে, সম্মিলিত রেজিএক্সপেক্সটি কেবল 129 বাইট স্ট্রিং (যা অলস হয়ে আমি রেজিএক্সএক্স :: এসেম্বল দিয়ে সংকলিত ), সুতরাং পুরো পার্ল প্রোগ্রামটি প্রায় 150 বাইট।

— ব্যবহারকারী 2846289

ধন্যবাদ @VadimR কিন্তু আপনি এমনকি প্রতিস্থাপন যেতে পারেন .{8}|.{9}সঙ্গে .{8,9}এবং .{7}|.{8}সঙ্গে.{7,8}

— MT0

Answer 2

পাইথন 383

পাইথনের একমাত্র * লাইন!

a=[list(l)for l in raw_input().split('\n')];z=any;e=enumerate;c=lambda b:z(all(p==b[y+v][x+u]for(u,v)in o)for y,r in e(b[:-2])for x,p in e(r[:-2])for o in [[(0,1),(0,2)],[(1,0),(2,0)]]);print z(c([[q if(i,j)==(m,n)else a[m][n]if(i,j)==(y+1,x+1)else p for j,p in e(r)]for i,r in e(a)])for y,t in e(a[1:-1])for x,q in e(t[1:-1])for n,m in((x+u,y+v)for u,v in[(1,0),(1,2),(0,1),(2,1)]))

* আচ্ছা, সেমিকোলন সহ, তবে এটি পাইথনটিতে এখনও অপ্রয়োজনীয় (পাইথনের এক-লাইন মজাদার! )

Comments

বোধগম্য বোধগম্যতার জন্য উত্সাহিত :)

— আলেকজান্দার-ব্রেট

Answer 3

নোড.জেএস - নিষ্পাপ সমাধান - 905 বাইট

ঠিক আছে, এখনও কোন উত্তর নেই তাই আমি নোড.জেএসসে একটি সত্যই নিষ্পাপ সমাধান পোস্ট করব

এটি প্রতিটি সম্ভাব্য পদক্ষেপের মধ্য দিয়ে যায় এবং ফলস্বরূপ বোর্ডটি পরপর 3 টি আছে কিনা তা পরীক্ষা করে।

গল্ফড (গুগল ক্লোজার সংকলক সহ) (সেখানে কিছু হ্যাকি স্টাফের মতো! 0 এবং! 1; আমি এটিও নিশ্চিত নই যে এটি আমার এক্সওআর সোয়াপ দিয়ে কী করেছে)

Array.prototype.a=function(){for(var f=[],d=0;d<this.length;d++)f[d]=this[d].a?this[d].a():this[d];return f};for(var a=[],b=0;8>b;b++)a[b]=[];for(b=2;b<process.argv.length;b++)for(var c=process.argv[b].split(""),e=0;e<c.length;e++)a[b-2][e]=parseInt(c[e],10);function h(){for(var d=l,f=0;f<d.length-2;f++)for(var g=0;g<d[f].length-2;g++){var k=d[f][g];if(k==d[f+1][g]&&k==d[f+2][g]||k==d[f][g+1]&&k==d[f][g+2])return!0}return!1}function m(){console.log("yes");process.exit()}for(b=0;b<a.length;b++)for(e=0;e<a[b].length;e++){var l=a.a();0!=b&&(l[b-1][e]^=l[b][e],l[b][e]^=l[b-1][e],l[b-1][e]^=l[b][e],h()&&m(),l=a.a());b!=a.length-1&&(l[b+1][e]^=l[b][e],l[b][e]^=l[b+1][e],l[b+1][e]^=l[b][e],h()&&m(),l=a.a());0!=e&&(l[b][e-1]^=l[b][e],l[b][e]^=l[b][e-1],l[b][e-1]^=l[b][e],h()&&m(),l=a.a());e!=a[b].length-1&&(l[b][e+1]^=l[b][e],l[b][e]^=l[b][e+1],l[b][e+1]^=l[b][e],h()&&m(),l=a.a())}console.log("no");

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

প্রাক-গল্ফ মানব পাঠযোগ্য সংস্করণ

// set it up
Array.prototype.clone = function() {
    var arr = [];
    for( var i = 0; i < this.length; i++ ) {
        if( this[i].clone ) {
             arr[i] = this[i].clone();
        } else {
             arr[i] = this[i];
        }
    }
};
var board=[];
for(var i=0;i<8;i++)board[i]=[];
for(var i=2;i<process.argv.length;i++){
    var row=process.argv[i].split("");
    for(var j=0;j<row.length;j++)board[i-2][j]=parseInt(row[j], 10);
}
// function to test
function testBoard(arr){
    for(var i=0;i<arr.length-2;i++){
        for(var j=0;j<arr[i].length-2;j++){
            var val=arr[i][j];
            if(val==arr[i+1][j] && val==arr[i+2][j])return true;
            if(val==arr[i][j+1] && val==arr[i][j+2])return true;
        }
    }
    return false;
}
// functions to exit
function yay(){console.log("yes");process.exit();}
function nay(){console.log("no");}
// super slow naive solution time
for(var i=0;i<board.length;i++){
    for(var j=0;j<board[i].length;j++){
        var newboard=board.clone();
        if(i!=0){
            newboard[i-1][j]=newboard[i-1][j]^newboard[i][j];// whoa, it's a
            newboard[i][j]=newboard[i-1][j]^newboard[i][j];  // cool algorithm
            newboard[i-1][j]=newboard[i-1][j]^newboard[i][j];// at least this 
                                                             // isn't all naive
            if(testBoard(newboard))yay();
            newboard=board.clone();
        }
        if(i!=board.length-1){
            newboard[i+1][j]=newboard[i+1][j]^newboard[i][j];
            newboard[i][j]=newboard[i+1][j]^newboard[i][j];
            newboard[i+1][j]=newboard[i+1][j]^newboard[i][j];
            if(testBoard(newboard))yay();
            newboard=board.clone();
        }
        if(j!=0){
            newboard[i][j-1]=newboard[i][j-1]^newboard[i][j];
            newboard[i][j]=newboard[i][j-1]^newboard[i][j];
            newboard[i][j-1]=newboard[i][j-1]^newboard[i][j];
            if(testBoard(newboard))yay();
            newboard=board.clone();
        }
        if(j!=board[i].length-1){
            newboard[i][j+1]=newboard[i][j+1]^newboard[i][j];
            newboard[i][j]=newboard[i][j+1]^newboard[i][j];
            newboard[i][j+1]=newboard[i][j+1]^newboard[i][j];
            if(testBoard(newboard))yay();
            newboard=board.clone();
        }
    }
}
nay();

Comments

হাহ আমি প্রথম পোস্টটি 10 ​​মিনিটের মধ্যে মিস করেছি। আমি যদিও এটিকে পছন্দ করি ...

— ড্যাঙ্কমেস

আহ, হুবহু একই পদ্ধতি আমি ব্যবহার করেছি (নিষ্পাপ তবে ছোট কোড!)। আমার চেয়ে অনেক বেশি বর্ণনামূলক হওয়ার জন্য +1

— কেএসব

আমি আরও আশ্চর্য হয়েছি যদি আরও দক্ষ অ্যালগরিদম থাকে ...

— ড্যাঙ্কমিমেস

Answer 4

পার্ল, 114 96 95 93 92 87 86 85 বাইট

+ এর জন্য অন্তর্ভুক্ত -a0p

এসটিডিআইএন ইনপুট দিয়ে চালান:

bejeweled.pl
12314131
13224145
54762673
61716653
61341144
23453774
27645426
75575656
^D

bejeweled.pl:

#!/usr/bin/perl -a0p
$i/s%.%chop$F[$i++&7]%eg>3|/(.)((.|\H{6}|\H{9})\1|\H{7}\1.)\1/||redo;$_=$1?yes:n.o

এটি আবর্তনের সাথে একক দিকের অনুভূমিক রেজেক্স সমাধানকে একত্রিত করে

ব্যাখ্যা:

এই সমাধানে আমি বারবার ঘোরান এবং নিম্নলিখিত 4 টি পরীক্ষা করব:

/(.).\1\1/,      // 3-in-a-row horizontally after left-most shifts right
/(.)\C{9}\1\1/,  // 3-in-a-row horizontally after left-most shifts down
/(.)\C{7}\1.\1/, // 3-in-a-row horizontally after middle shifts down
/(.)\C{6}\1\1/,  // 3-in-a-row horizontally after right-most shifts down

\C"যে কোনও চরিত্র" ( .এটিতে লাইন অন্তর্ভুক্ত নয় ) Where \Cএটি বাদ দেওয়া এবং সতর্কতার দিকে পরিচালিত করা ব্যতীত আমি এর \Hপরিবর্তে (অনুভূমিক স্থান) ব্যবহার করি যা সমস্ত অঙ্ক এবং নিউলাইন ক্যাপচার করার জন্য যথেষ্ট ভাল।

4 আবর্তনের পরে এটি প্রয়োজনীয় 16 টি পরীক্ষা করবে

-p                            Read lines from STDIN, print $_ at the end
-0                            No line ending => slurp ALL of STDIN
-a                            Split $_ into @F. Since there are no spaces
                              on the rows this means each element of @F is
                              1 row

    s%.%chop$F[$i++&7]%eg     Replace each row by the removed last column
                              This is therefore a left rotation. Very short
                              but at the cost of using @F. To make sure that
                              @F gets refilled from $_ each time I won't be
                              able to use while, until, eval or do$0 for the
                              loops but have to use redo. That costs a few
                              bytes but less than having to do my own split
$i/                      >3   The previous regex replacement always
                              returns 64 and each time through the loop $i is
                              increased by 64. So if this division reaches
                              4 all rotations have been done

/(.)((.|\H{6}|\H{9})\1|\H{7}\1.)\1/ This is the 4 regexes mentioned above
  ||redo                      Stop the loop if the regex matches or we
                              rotated 4 times
$_=$1?yes:n.o                If the regex matched $1 will be one of the
                              color digits (which cannot be 0) and this will
                              assign "yes" to $_. If the regex didn't match
                              in 4 times $1 will get its value from the last
                              succesful regex in scope which will be the one
                              from the rotation, but that one doesn't have
                              any () so $1 will be unset. So in case there
                              is no move $_ will be set to "no" (which needs
                              to be constructed because "no" is a keyword)

Answer 5

পাইথন 3, 314 বি

import itertools as T,copy
r=[]
K=range(8)
J=[list(input())for w in K]
P=T.product
f=lambda A:["yes"for b in[A[m][n:]for m,n in P(K,K[:6])]if b[0]==b[1]==b[2]]
for i,j,x in P(K,K,[0,1]):
 t=j+1-x
 if i+x<8and t<8:B=copy.deepcopy(J);B[i][j],B[i+x][t]=B[i+x][t],B[i][j];r+=f(B)+f(list(zip(*B)))
r+=["no"]
print(r[0])

8, 5 লাইনে 6 এবং 8 লাইনটি 9 ইচ্ছামত বড় ইনপুট আকারগুলি পরিচালনা করতে পরিবর্তন করুন; প্রতিটি মান কী তাও বিবেচনা করে না, তাই আপনি এটি খাওয়াতে পারেন:

absdefgh
sdkljahs
lsdfjasd
fjdhsdas
dkjhfasd
sdfhaskd
sdkfhkas
weriuwqe

এবং এটি ফিরে আসবে yes।

টীকা

import itertools as T,copy 
            # itertools.product is going to save us lots of for loops
r=[]        # result
K=range(8)  # we can use range(8) everywhere, so this saves more than the usual R=range
J=[list(input())for w in K] 
            # input handling: keep everything as a length-1 string to avoid map(int,input())
P=T.product
f=lambda A:["yes"for b in[A[m][n:]for m,n in P(K,K[:6])]if b[0]==b[1]==b[2]] 
            # check the condition horiontally only. K[:6] is the same as range(5)
            # A[m][n:n+3] would be neater, but not actually needed
for i,j,x in P(K,K,[0,1]): 
            # <3 itertools.product! 3 for-loops without it.
            # NB we're only going right and downwards
 t=j+1-x
 if i+x<8and t<8: 
            # don't want out-of-bounds errors at the edges
  B=copy.deepcopy(J) 
            # preserve the reference array
  B[i][j],B[i+x][t]=B[i+x][t],B[i][j] 
            # do the switch
  r+=f(B)+f(list(zip(*B))) 
            # do the test. you could end up with lots of 'yes's in r.
            # zip(*B) takes the transpose, so that f checks the columns too
r+=["no"]   # happens to ensure that r is nonempty
print(r[0]) # only prints no if r was empty before the last line

Answer 6

জিএনইউ সেড 255 + 2 = 257 বি

আমি ভেবেছিলাম এটি অজগরটির মতো ভাল হবে না তবে এটি এখন: - / আমি আজ ইন্টারনেটের অ্যাক্সেস ছাড়াই থাকি তাই এটিকে সমাধান করার ক্ষেত্রে আমি নিজেকে দখল করলাম :)। -র পতাকা সহ ডাকার প্রয়োজন, অর্থাত্ sed -rf command.sed < inputআমি আমার স্কোরটিতে 2 টি যুক্ত করেছি।

:a
$!N
s/\n/ /g
ta
:b
/^((\w)(\w\2\2|\2\w\2|\w\2\w* \w\2|\2\w* \w\w\2|\w* (\2\w* \w* \2|\w* \2\w* \2|\w\2\2|\w\2\w* \2|\2\w* \w\2|\w\2\w* \w\2))|\w((\w)(\w* \6\w\6|\6\w* \6|\w* (\6\w \w\6|\w\6\w* \6|\6\w* \6))|\w(\w)\w* \9\9))/c\yes
s/\w(\w*)/\1/g
tb
c\no

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

1. স্পেস-বিভাজিত অক্ষরের একক লাইনে গ্রিডটি পড়ুন
2. প্রথম কলামে কোনও মিল আছে কিনা তা জানতে মাদারলোড রেজেক্স ব্যবহার করুন * - যদি হ্যাঁ, তবে 'হ্যাঁ' এর জন্য পুরো লাইনটি অদলবদল করুন (প্রোগ্রামটি শেষ করে)
3. প্রতিটি কলাম থেকে প্রথম অক্ষরটি স্ট্রিপ করুন এবং আমরা যদি করি তবে 2
4. যদি আমরা না করি (লাইনটি খালি) পুরো লাইনটি 'না' দিয়ে প্রতিস্থাপন করুন

Answer 7

রুবি, 201 বাইট

আমি এই দুর্দান্ত চ্যালেঞ্জের কোনও সমাধান দেখতে না পেয়ে হতাশ হয়েছি যে একটি রেইজেক্স বা ব্রুট ফোর্স ব্যবহার করে না (যদিও সেগুলি দুর্দান্ত) তবে আমি একটি লিখেছিলাম। এটি STDIN এ ইনপুট নেয়।

মূল বিটওয়াইজ গাণিতিক অ্যালগরিদমটি গেম ডেভলপমেন্ট স্ট্যাক এক্সচেঞ্জের দুর্দান্ত উত্তরটি থেকে প্রাপ্ত হয়েছে @ লিন্ডারের মাধ্যমে।

s=$<.read
$><<(?1..?9).any?{|n|a=[0]*19
s.scan(n){i=$`.size
a[i/9+1]+=2**(i%9)
a[i%9+10]+=2**(i/9)}
a.each_cons(3).any?{|x,y,z|q=y&y<<1
l=q<<1
q>>=2
y&(l<<1|q>>1)|(q|l|(y&y<<2)>>1)&(x|z)>0}}?"yes":"no"

রুবি ল্যাম্বদা, 181 বাইট

এখানে এটা একটি ল্যামডা যে একটি স্ট্রিং এবং আয় লাগে হিসাবে trueবা false:

->s{(?1..?9).any?{|n|a=[0]*19
s.scan(n){i=$`.size
a[i/9+1]+=2**(i%9)
a[i%9+10]+=2**(i/9)}
a.each_cons(3).any?{|x,y,z|q=y&y<<1
l=q<<1
q>>=2
y&(l<<1|q>>1)|(q|l|(y&y<<2)>>1)&(x|z)>0}}}

এটি repl.it এ দেখুন: https://repl.it/ColJ/2

অবহেলিত ও ব্যাখ্যা

->s{
  (?1..?9).any? {|n|
    a = [0] * 19

    s.scan(n) {
      i = $`.size
      a[i/9+1] += 2**(i%9)
      a[i%9+10] += 2**(i/9)
    }

    a.each_cons(3).any? {|x,y,z|
      q = y & y << 1
      l = q << 1
      q >>= 2
      y & (l << 1 | q >> 1) |
        (q | l | (y & y << 2) >> 1) &
        (x | z) > 0
    }
  }
}

কোডটি "1" থেকে "9" এর অঙ্কগুলিতে পুনরাবৃত্তি করে প্রতিটি পুনরাবৃত্তির দুটি পৃথক পদক্ষেপ রয়েছে:

প্রথম পদক্ষেপটি হ'ল বোর্ড রূপান্তরকরণ, যা আপনি s.scan(n)অবারিত কোডগুলিতে ব্লকটিতে দেখতে পাবেন । এটি বোর্ডকে 8 টি পূর্ণসংখ্যার অ্যারে রূপান্তরিত করে, প্রতিটি সারিটির জন্য একটি করে, বাইনারি স্ট্রিংয়ে 1 টি এবং অন্যান্য সকলকে 0 এর মান হিসাবে ম্যাচিং ডিজিটগুলি আচরণ করে। উদাহরণস্বরূপ, সারিটি ধরুন 12231123। প্রথম পুনরাবৃত্তিতে, এটি বাইনারি স্ট্রিং হয়ে যাবে 10001100(সমস্ত 1s — er হয়ে যাবে, থাকুন — 1s এবং অন্যান্য সমস্ত অঙ্ক 0 সেটে পরিণত হবে), যা দশমিক সংখ্যা 140 the দ্বিতীয় বারবারে একই সারিতে পরিণত হয় 01100010(সমস্ত 2s 2s হয়ে যায় এবং অন্যান্য সমস্ত অঙ্ক 0 এর দশকে হয়) বা দশমিক 98 হয়।

এটি একই সাথে দ্বিতীয় রূপান্তর সম্পাদন করে যা প্রথমটির মতো তবে বোর্ডটি 90 ডিগ্রি ঘোরানো সাথে। এটি আমাদের উল্লম্বগুলি হিসাবে অনুভূমিক মিলগুলি তৈরি করার জন্য একই যুক্তি ব্যবহার করতে দেয়। সরলতার জন্য, এটি দুটি বোর্ডকে একক দীর্ঘ একটিতে শুরুতে শূন্য দিয়ে মাঝখানে (দুটি বোর্ড পৃথক করতে) এবং প্যাডিংয়ের শেষে শেষ করে aten

দ্বিতীয় ধাপটি সম্ভাব্য মিলগুলি অনুসন্ধান করছে যা আপনি each_cons(3).any?ব্লকটিতে দেখতে পাচ্ছেন । রূপান্তরকৃত সারিগুলি (যা এখন 8-বিট পূর্ণসংখ্যা হয়) বিটওয়াইথ গাণিতিক ব্যবহার করে তিনটি সারি ( x , y , z ) এর (ওভারল্যাপিং) গোষ্ঠীতে চেক করা হয় । প্রতিটি গ্রুপ দেখতে যদি কোনো মিল সারিতে তৈরি করা যেতে পারে পরীক্ষা করা হয় Y , হয় সারিতে এক টুকরা নাড়াচাড়া দ্বারা Y বা মধ্যে একটি টুকরা নাড়াচাড়া দ্বারা Y থেকে এক্স বা z- র । যেহেতু মূল এবং ঘোরানো বোর্ডের সারি উভয়ের আগে এবং পরে একটি শূন্য রয়েছে, সুতরাং আমরা বোর্ডের প্রথম বা শেষ সারিতে আছি কিনা তা পরীক্ষা করে দেখার দরকার নেই।

কোনও মিল খুঁজে পাওয়া যায় নি, এটি পরবর্তী পুনরাবৃত্তি অবিরত।