एक "मैच -3" खेल में सबसे अच्छा तत्काल कदम खोजें

आज आपकी चुनौती इस तरह से इनपुट लेने की है:

fbcfbee
ffcabbe
debceec
bccabbe
edcfbcd
daeaafc
eebcbeb

और आउटपुट खेल की तरह Bejeweled एक में सबसे अच्छा संभव कदम है कि तीन या अधिक पत्र से मेल खाएगा, यह (ध्यान दें राजधानी की तरह Bऔर C):

fbcfbee
ffcabbe
deBCeec
bccabbe
edcfbcd
daeaafc
eebcbeb

पूर्ण विनिर्देशों:

इनपुट प्रत्येक निचले अक्षरों nकी पंक्तियाँ nहोंगी (जहाँ nकोई भी संख्या हो सकती है)।
आउटपुट एक सर्वश्रेष्ठ कदम होगा जो आप मैच -3 गेम में बना सकते हैं, दो अक्षरों के साथ जिसे आप कैपिटल स्वैप करना चाहते हैं।
मैचों में निम्नलिखित प्राथमिकता होनी चाहिए (इन उदाहरणों में, .एक वर्ग को इंगित करता है जो कोई फर्क नहीं पड़ता):
1. पांच में एक पंक्ति
```
xxYxx
..X..
```
2. टूटी हुई पांच-एक पंक्ति
```
X..
Yxx
x..
x..
```
  या
```
.X.
xYx
.x.
.x.
```
3. चार में एक पंक्ति
```
xYxx
.X..
```
4. तीन-में-एक-पंक्ति
```
xYx
.X.
```
आपको सर्वोच्च प्राथमिकता का मिलान ढूंढना होगा और उसका आउटपुट देना होगा।
यदि एक ही प्राथमिकता के कई मैच हैं, तो आप उनमें से किसी एक को आउटपुट कर सकते हैं।
हमेशा कम से कम एक मैच होगा (यदि कोई मैच नहीं है, या आप चाहते हैं कि कुछ भी करें तो आपका कार्यक्रम टूट सकता है)।
I / O किसी भी उचित प्रारूप में हो सकता है (स्टडिन / आउट, रीडिंग एंड राइटिंग फाइल्स, फंक्शन आर्ग्युमेंट्स / रिटर्न वैल्यूज़, डायलॉग बॉक्स इत्यादि) लेकिन हार्डकोड (जैसे नहीं x="[insert input here]")।
यह कोड-गोल्फ है इसलिए बाइट्स जीत में सबसे छोटा कोड है। यदि आप किसी कारण से किसी नेटवर्क एक्सेस का उपयोग करते हैं, तो आपके स्कोर के विरुद्ध नेटवर्क गणना से डाउनलोड किए गए सभी बाइट्स।

code-golf game

— Doorknob
स्रोत

+1, लेकिन मैं शीर्षक का विरोध करता हूं; एक बेहतर कदम हो सकता है। उदाहरण के लिए, एक जो दो पत्नियां बनाता है, या एक जो अधिक सामान बनाने के लिए एक बूंद का कारण बनता है।

— जस्टिन

क्या टूटी हुई पांच-पंक्तियां भी कवर करती हैं ..x.\nxxYX\n..x.?

— पीटर टेलर

@Peter हाँ, यह करता है।

— दरवाज़े

पंक्ति पैटर्न में 2 टूटे हुए 5 हैं: एल पैटर्न और टी पैटर्न। क्या आपको दोनों का मिलान आवश्यक है?

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

@nhahtdh हां, मैं इसे स्पष्ट करने के लिए संपादन करूंगा।

— दरवाज़े

पायथन 3.4, 772

(रिक्त स्थान के बजाय इंडेंटेशन के लिए टैब का उपयोग करना।)

import sys,itertools as I
B=[]
for l in sys.stdin:
    l=l.rstrip()
    B.append(list(l))
Z=len(B[0])
F=T=None
R=range
N=min
X=max
P=I.product
S=0
def C(I,J,K,L):
    global F,T,S
    if K<0 or K>=Z or L<0 or L>=Z: return
    B[I][J],B[K][L]=B[K][L],B[I][J]
    h=v=1
    m=B[K][L]
    for i in R(K+1,N(Z,K+5)):
        if B[i][L]!=m:break
        v+=1
    for i in R(K-1,X(0,K-5),-1):
        if B[i][L]!=m:break
        v+=1
    for j in R(L+1,N(Z,L+5)):
        if B[K][j]!=m:break
        h+=1
    for j in R(L-1,X(0,L-5),-1):
        if B[K][j]!=m:break
        h+=1
    c=X(h,v)*2
    if N(h,v)>=3:c+=N(h,v)
    if c>S:S=c;F=I,J;T=K,L
    B[I][J],B[K][L]=B[K][L],B[I][J]
for i,j in P(reversed(R(Z)),R(Z)):
    for d,e in (1,0),(0,-1),(0,1),(-1,0):
        C(i,j,i+d,j+e)
for i,j in P(R(Z),R(Z)):
    c=B[i][j]
    if (i,j)in(F,T):c=c.upper()
    print(c,end=('',"\n")[j==Z-1])

— ऑस्टिन हेस्टिंग्स
स्रोत

इसके बजाय [c for c in l], आप बस कर सकते हैं list(l)।

— दरवाज़े

उपयोग (i, j) इन (F, T) दो तुलना के बजाय - 778

— ऑस्टिन हेस्टिंग्स

एफ = (आई, जे) -> एफ = आई, जे। डीग्लोडाइज़ 2 आर / ओ जिम - 770

— ऑस्टिन हेस्टिंग्स

फिक्स्ड बग: टूटा -5 को सच -5 को हरा नहीं करना चाहिए।

— ऑस्टिन हेस्टिंग्स 18