पृष्ठभूमि

बेज्वेल्ड और इसी तरह के खेलों में, खिलाड़ी को एक पंक्ति में एक ही रंग के तीन मैच करने के लिए रत्नों के 8x8 ग्रिड में किसी भी दो आसन्न रत्न (कोई विकर्ण) को स्वैप नहीं करना चाहिए। रत्नों का मिलान क्षैतिज या लंबवत रूप से किया जा सकता है। गेमप्ले तब तक जारी रहता है जब तक कि कोई चाल मौजूद नहीं होती है जिसके परिणामस्वरूप एक पंक्ति में तीन हो सकते हैं, जिस बिंदु पर खेल खत्म हो गया है।

कार्य

लक्ष्य एक कार्यक्रम लिखना है जो यह निर्धारित करता है कि बेज्वेल्ड का खेल अभी खत्म नहीं हुआ है। दूसरे शब्दों में, यह देखना होगा कि क्या एक संभावित कदम है जो एक पंक्ति में कम से कम तीन बनाता है। एक पंक्ति में तीन से अधिक रत्न हो सकते हैं और यह अभी भी एक वैध कदम है।

इनपुट

आपके प्रोग्राम को मानक इनपुट के माध्यम से स्वीकार करना होगा एक बेज्वेड ग्रिड का 8x8 प्रतिनिधित्व। सात मणि रंग के प्रत्येक 1 से 7 प्रत्येक पंक्ति के लिए एक अंकों द्वारा प्रतिनिधित्व किया जाएगा एक पंक्ति है, और 8 लाइनों, 8 अंकों के प्रत्येक मिलकर में शामिल होंगे, इनपुट होगा। उदाहरण देखें। आप मान सकते हैं कि इनपुट हमेशा इस प्रारूप का पालन करेगा, और इसमें पहले से ही एक पंक्ति में तीन नहीं होंगे।

उत्पादन

कार्यक्रम तो निर्गम (मानक आउटपुट में) चाहिए yesया noया नहीं, कम से कम एक वैध कदम पर निर्भर करता है कि एक पंक्ति में तीन या अधिक जवाहरात में परिणाम होगा मौजूद है। आपके प्रोग्राम को yesया तो या तो एकल उदाहरण के अलावा कुछ भी आउटपुट नहीं करना चाहिए no।

नियम

आपके प्रोग्राम को किसी भी बाहरी फाइल या संसाधनों, कमांड-लाइन तर्कों का उपयोग नहीं करना चाहिए, या किसी निश्चित फ़ाइल नाम की आवश्यकता नहीं होनी चाहिए। इसके स्रोत कोड जीत में बाइट्स की कम से कम संख्या के साथ कार्यक्रम।

उदाहरण

इनपुट:

आउटपुट: yes

इनपुट:

आउटपुट: no

अतिरिक्त परीक्षण मामलों के लिए MT0 का उत्तर नीचे देखें ।

code-golf game grid

— bdr9
स्रोत

क्या यह सिर्फ पंक्तियाँ हैं, या कॉलम भी हैं।

— TheDoctor

@ TheDoctor कॉलम भी। जब मैं "एक पंक्ति में तीन" वाक्यांश का उपयोग करता हूं तो मेरा मतलब है कि उन्हें क्षैतिज या ऊर्ध्वाधर दिशा में पंक्तिबद्ध होना चाहिए।

— bdr9

@ bdr9 आप इसे संपादित करना चाहते हैं

— जॉन ड्वोरक

@ जैनध्वक ने किया।

— bdr9

अगर 4+ में एक पंक्ति की अनुमति है, तो इसे संपादित करना चाह सकते हैं।

— जस्टिन

12

मूल समाधान: जावास्क्रिप्ट - 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'

यह मानते हुए कि परीक्षण करने के लिए स्ट्रिंग चर में है s(यह एक समारोह बनाने के लिए fतो जोड़ने f=s=>के लिए एक संकेत से इनपुट लेने के लिए तो जगह ले, कोड या की शुरुआत करने के लिए अन्यथा, sसाथ prompt())।

आउटपुट कंसोल के लिए है।

3 ^rd समाधान: जावास्क्रिप्ट (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 ले लिया ^nd समाधान, नीचे, (जो कुछ विन्यास में पात्रों के लिए जाँच करने के लिए नियमित अभिव्यक्ति का उपयोग करता है) और यह फिर से काम सिर्फ नियमित अभिव्यक्ति का उपयोग किए बिना एक ही विन्यास में समान पात्रों के लिए स्ट्रिंग की जाँच करने के।

बेस -36 स्ट्रिंग "2313ab1b8a2a78188h9haj9j8iaiir9r"ऑफ़सेट के जोड़े को जाँचने के लिए देता है - यानी जोड़ी23 में जाँच का परिणाम होता है कि अगर मैं ^वें चरित्र (i + 2) ^वें चरित्र और (i + 3) ^वें चरित्र (नियमित अभिव्यक्ति के बराबर ) के समान है (.).\1\1- कुछ अतिरिक्त जांच के साथ यह सुनिश्चित करें कि असमान चरित्र एक नई पंक्ति नहीं है)।

2 ^nd समाधान: जावास्क्रिप्ट (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
];

( नोट: क्षैतिज रूप से (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 से ऊपर नियमित अभिव्यक्ति के कौन से मेल खाते हैं।

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]और अतिरिक्त गैर-कैप्चरिंग समूहों को हटा दिया और वापस संदर्भ (जैसा कि m-buettner द्वारा सुझाया गया है ) और हां / नहीं आउटपुट में जोड़ा गया।

संपादित करें 3

एक बेस -18 स्ट्रिंग से अलग-अलग नियमित एक्सप्रेशन बनाने के लिए ECMAScript 6 समाधान जोड़ा गया।
क्षैतिज रूप से ( m-buettner द्वारा सुझाए गए ) 3-in-a-row के परीक्षण हटा दिए गए ।

संपादित करें ४

एक और (छोटा) समाधान और दो और गैर-मिलान परीक्षण मामले जोड़े।

संपादित करें ५

गैर-संख्यात्मक चरित्र के साथ नई कहानियों को प्रतिस्थापित करके मूल समाधान। (जैसा कि वादिम द्वारा सुझाया गया है )।

संपादित करें ६

नियमित अभिव्यक्ति के बिट्स के संयोजन द्वारा छोटा मूल समाधान (जैसा कि वादिम द्वारा सुझाया गया है )।

— MT0
स्रोत

1

अच्छा समाधान! मुझे नहीं लगता था कि regex काम कर सकता है। कृपया ?'yes':'no'निष्पक्षता के लिए अपनी वर्ण गणना में शामिल करें , क्योंकि यह आवश्यकताओं में है और बाकी सभी इसका उपयोग कर रहे हैं।

— bdr9

अतिरिक्त परीक्षण मामलों के लिए धन्यवाद, मैं अपने जवाब के लिए लिंक जोड़ी ताकि अन्य लोग उन्हें देख सकें।

— bdr9

वाह। Regex के लिए +1

— DankMemes

एच मिमी, के लिए जे एस में कोई संशोधक .न्यू लाइन सहित किसी भी चरित्र से मेल करने के? पर्ल के साथ, संयुक्त regexp मात्र 129 बाइट्स स्ट्रिंग (जो, आलसी जा रहा है, मैं के साथ संकलित है Regexp :: इकट्ठा ,) तो पूरे पर्ल कार्यक्रम 150 बाइट्स के बारे में है।

— user2846289

1

धन्यवाद @VadimR लेकिन आप भी आगे की जगह जा सकते हैं .{8}|.{9}के साथ .{8,9}और .{7}|.{8}साथ.{7,8}

— MT0

3

अजगर 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)]))

* ठीक है, अर्धविराम से, लेकिन अभी भी अजगर में गैर तुच्छ है कि (अजगर एक-लाइनर्स हैं मज़ा! )

— KSab
स्रोत

3

समझ से बाहर comprehensions :) के लिए upvoted

— सिकंदर-ब्रेट

2

Node.js - अनुभवहीन समाधान - 905 बाइट्स

ठीक है, कोई जवाब अभी तक तो मैं Node.js में एक बहुत भोली समाधान पोस्ट करेंगे

यह हर संभव कदम के माध्यम से चला जाता है और फिर परिणामी बोर्ड का परीक्षण करती है, अगर वहाँ एक पंक्ति में 3 है देखने के लिए।

गोल्फ (गूगल क्लोजर कंपाइलर के साथ) (कुछ हैक करने योग्य सामान जैसे वहाँ! 0 और! 1; मुझे यकीन भी नहीं है कि यह मेरे XOR स्वैप के साथ क्या हुआ)

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();

— DankMemes
स्रोत

हाह मैं वास्तव में 10 मिनट से पहली पोस्ट को याद किया। हालांकि मुझे यह पसंद है ...

— DankMemes

आह, ठीक वही विधि जिसका मैंने उपयोग किया (भोली लेकिन छोटी संहिता!)। +1 मेरे से बहुत अधिक वर्णनात्मक होने के लिए

— केएसएबी

मुझे आश्चर्य है कि वहाँ एक और अधिक कुशल एल्गोरिथ्म है कि अगर ...

— DankMemes

2

पर्ल, 114 96 95 93 92 87 86 85 बाइट्स

के लिए + शामिल -a0p

STDIN पर इनपुट के साथ चलाएँ:

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

इस चक्र के साथ एक ही दिशा क्षैतिज regex समाधान को जोड़ती है

स्पष्टीकरण:

इस समाधान मैं बार-बार बारी बारी से और निम्न 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"किसी भी चरित्र" (के विपरीत है .इस नई पंक्ति शामिल हैं)। सिवाय इसके कि \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)

— टन हास्पेल
स्रोत

1

पायथन 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

— सिकंदर-ब्रेट
स्रोत

1

GNU sed 255 + 2 = 257B

मैंने सोचा कि यह अजगर के रूप में अच्छा नहीं होने वाला था, लेकिन अब यह है: - / मैं आज इंटरनेट का उपयोग किए बिना रहा हूं इसलिए मैंने इसे सीड में हल करने के साथ खुद पर कब्जा कर लिया :)। -R ध्वज के साथ कॉल करने की आवश्यकता है, 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

यह काम किस प्रकार करता है:

ग्रिड को अंतरिक्ष-पृथक वर्णों की एक पंक्ति में पढ़ें
पहले कॉलम * में एक मैच है या नहीं, यह पता करने के लिए मदरलोड रेगेक्स का उपयोग करें - यदि हाँ, तो 'हाँ' के लिए पूरी लाइन स्वैप करें (प्रोग्राम को समाप्त करें)
प्रत्येक कॉलम से पहला अक्षर स्ट्रिप करें और अगर हमने किया है तो गोटो 2
अगर हमने नहीं किया (लाइन खाली है) पूरी लाइन को 'नहीं' से बदलें

— सिकंदर-ब्रेट
स्रोत

1

रूबी, 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 पूर्णांक के एक सरणी में बदल देता है, प्रत्येक पंक्ति के लिए एक, 1s के रूप में और अन्य सभी को द्विआधारी स्ट्रिंग में 0 अंक के रूप में मिलान करके। उदाहरण के लिए, पंक्ति को लें 12231123। पहले पुनरावृत्ति में, यह बाइनरी स्ट्रिंग बन जाएगा 10001100(सभी 1s बन जाते हैं - एर, स्टे -1 और अन्य सभी अंक 0s बन जाते हैं), जो दशमलव संख्या 140 है। दूसरी पुनरावृत्ति में एक ही पंक्ति बन जाती है 01100010(सभी 2s 2s बन जाते हैं) अन्य सभी अंक 0s) या दशमलव 98 बन जाते हैं।

यह एक साथ एक दूसरा परिवर्तन करता है, जो कि पहले जैसा है लेकिन बोर्ड 90 डिग्री घुमाया गया है। इससे हम क्षैतिज मैचों को लंबवत बनाने के लिए उसी तर्क का उपयोग कर सकते हैं। सादगी के लिए, यह शुरुआत, मध्य (दोनों बोर्डों को अलग करने के लिए) के साथ दो बोर्डों को एक एकल में एक लंबे समय तक समेटता है, और पैडिंग के लिए समाप्त होता है।

दूसरा चरण संभावित मैचों की खोज कर रहा है, जिसे आप each_cons(3).any?ब्लॉक में देख सकते हैं । परिवर्तित पंक्तियों (जो अब 8-बिट पूर्णांक हैं) को तीन पंक्तियों ( x , y , z ) के समूहों में बिटवाइज़ अंकगणित का उपयोग करके जांचा जाता है । प्रत्येक समूह को यह देखने के लिए चेक किया जाता है कि क्या पंक्ति y में मैच बनाया जा सकता है , या तो पंक्ति y में एक टुकड़ा शिफ्ट करके या x या z से एक टुकड़ा y में स्थानांतरित करके । चूंकि दोनों मूल और घुमाए गए बोर्डों की पंक्तियों से पहले और बाद में एक शून्य "पंक्ति" है, हमें यह जांचने की ज़रूरत नहीं है कि क्या हम बोर्ड की पहली या अंतिम पंक्ति पर हैं।

यदि कोई मिलान नहीं मिला, तो यह अगले पुनरावृत्ति के लिए जारी है।

— जॉर्डन
स्रोत

निर्धारित एक कदम एक Bejeweled / मैच 3 खेल में मौजूद रहने पर

पृष्ठभूमि

कार्य

इनपुट

उत्पादन

नियम

उदाहरण

मूल समाधान: जावास्क्रिप्ट - 261 255 228 227 179 153 अक्षर

3 rd समाधान: जावास्क्रिप्ट (ECMAScript 6) - 178 वर्ण

2 nd समाधान: जावास्क्रिप्ट (ECMAScript 6) - 204 वर्ण

अजगर 383

Node.js - अनुभवहीन समाधान - 905 बाइट्स

पर्ल, 114 96 95 93 92 87 86 85 बाइट्स

स्पष्टीकरण:

पायथन 3, 314 बी

एनोटेशन

GNU sed 255 + 2 = 257B

रूबी, 201 बाइट्स

रूबी लैम्ब्डा, 181 बाइट्स

अपुष्ट और व्याख्या

3 ^rd समाधान: जावास्क्रिप्ट (ECMAScript 6) - 178 वर्ण

2 ^nd समाधान: जावास्क्रिप्ट (ECMAScript 6) - 204 वर्ण