बिशप के खिलाफ मजबूत पासवर्ड

13

पासवर्ड बिशप अच्छाई के साथ भ्रमित होने की नहीं !

एक स्ट्रिंग, उत्तर (सत्य / मिथ्या या दो सुसंगत मूल्यों) को देखते हुए यदि यह एक पासवर्ड बनाता है जो बिशप के खिलाफ मजबूत है ।

एक पासवर्ड बिशप के खिलाफ मजबूत है अगर यह एक स्ट्रिंग है जिसमें अक्षर (इन a-h) और अंक ( 1-8जैसे) शामिल हैं, ताकि प्रत्येक वर्ण की व्याख्या शतरंज के पटल पर एक वर्ग के रूप में की जा सके, और यदि आप अपने वर्ग नाम पर एक सफेद प्यादा रखते हैं पासवर्ड में, फिर एक सफेद बिशप के लिए यात्रा करने का कोई तरीका नहीं है, किसी भी संख्या में लगातार चालें, पहली में किसी भी वर्ग से ( 1) पंक्ति से किसी भी वर्ग में अंतिम ( 8) पंक्ति में।

उदाहरण

बिशप के खिलाफ मजबूत पासवर्ड

  • a1b1c1d1e1f1g1h1
  • a8b8c8d8e8f8g8h8
  • a1b2c3d4d5f5f4g3g4h2b5
  • h4g4f4e4c4b4a4c3e3
  • a1b1c1d1e1f1g1a8b8c8d8e8f8g8
  • b4b5d4d5f4f5g3h5

उदाहरण के लिए, a1b1c1d1e1f1g1a8b8c8d8e8f8g8स्थिति fooसे b4b5d4d5f4f5g3h5मेल खाती है और स्थिति से मेल खाती हैfoo

बिशप के खिलाफ पासवर्ड कमजोर

  • a4c4e4g4g5d6f6e3d2b2 (अच्छी तरह से गठित लेकिन मजबूत नहीं - इस उदाहरण के लिए धन्यवाद जो किंग!)
  • b1c1d1e1f1g1h1a8b8c8d8e8f8g8 (अच्छी तरह से गठित लेकिन मजबूत नहीं)
  • h4g4f4e4c4b4a4c3 (अच्छी तरह से गठित लेकिन मजबूत नहीं)
  • d4 (अच्छी तरह से गठित लेकिन मजबूत नहीं)
  • b4b5d4d5f4f5g2h5 (अच्छी तरह से गठित लेकिन मजबूत नहीं)
  • correct horse battery staple (बीमार का गठन)
  • 1a1b1c1d1e1f1g8a8b8c8d8e8f8g (बीमार का गठन)
  • a (बीमार का गठन)
  • aa (बीमार का गठन)
code-golf  string  decision-problem  path-finding  chess 
— Quuxplusone
स्रोत
1
बिशप किस रंग के वर्गों पर जाता है?
— को अज्ञानता का अवतार
2
आपका दूसरा अंतिम परीक्षण मामला आपकी कल्पना का खंडन करता है। आपको यह भी समझाने की आवश्यकता है कि " वर्णों के प्रत्येक जोड़े को एक शतरंज की बिसात पर एक वर्ग के रूप में कैसे समझा जा सकता है "।
— झबरा
1
a1b2c3d4d5f5f4f4g3g4h2b5 बिशप के खिलाफ मजबूत नहीं है, क्योंकि एक बिशप h5 के लिए मिल सकता है, तो d1 पर जाएं
— अज्ञानता का अवतार
2
@TRITICIMAGVS, Ourous: मैंने स्पष्ट किया है कि प्यादे और बिशप दोनों सफेद हैं, इसलिए न तो दूसरे को पकड़ने (या भूमि पर जाने, या आगे बढ़ने, या कूदने) की अनुमति है।
— क्क्सप्लसोन
1
इसके अलावा, क्या आप सत्य परीक्षण मामलों में से एक के लिए एक उदाहरण जोड़ सकते हैं। क्योंकि मैं समझता हूं कि पासवर्ड के वर्ग सफेद मोहरे से भरे होते हैं, लेकिन मुझे समझ नहीं आता कि सफेद बिशप को कहां रखा गया है। और अगर किसी भी जगह ठीक है, कारण है कि यह प्रत्येक पंक्ति के यात्रा नहीं कर सकते 1के माध्यम से 8पहला परीक्षण मामले में? यह प्रत्येक स्तंभ की यात्रा नहीं कर सकता, क्योंकि aस्तंभ पूरी तरह से प्यादों से भरा है, लेकिन यह बिना किसी समस्या के प्रत्येक पंक्ति की यात्रा कर सकता है, क्या यह नहीं हो सकता है? मुझे लग रहा है कि मुझे कुछ याद आ रहा है ..: S
— केविन क्रूज़सेन

जवाबों:

4

रूबी, 115 182 163 बाइट्स

->s{z=('00'..'99').map{|x|x=~/[09]/||s[(x[1].ord+48).chr+x[0]]};(11..18).map &g=->x{z[x]||[x-11,x-9,x+z[x]=9,x+11].map(&g)};s=~/^([a-h][1-8])*$/&&(z[81,9]-[9])[8]}

इसे ऑनलाइन आज़माएं!

1मजबूत और nilकमजोर के लिए रिटर्न । (+67 बाइट्स "बैकट्रैकिंग" को ध्यान में रखने के लिए था।)

->s{
 z=                             # this is the board
 ('00'..'99').map{|x|           # coordinates are described as y*10 + x
  x=~/[09]/||                   # truthy if out of bounds...
  s[(x[1].ord+48).chr+x[0]]     # ...or impassable
 }                              # now only the passable squares are falsey
 (11..18).map                   # for each x position at y=1,
  &g=->x{                       # call helper function on that square
   z[x]||                       # if the square is passable (i.e. falsey),
    [x-11,x-9,x+z[x]=9,x+11]    # mark it impassable by setting to 9 (truthy)
     .map(&g)                   # call helper recursively for each neighbor
  }
 s=~/^([a-h][1-8])*$/           # make sure the input was valid,
 &&(z[81,9]-[9])[8]             # and check that the last row was never reached
}

कुछ तरकीबें जिनका इस्तेमाल किया गया था:

  • संख्यात्मक श्रेणी के बजाय 0..99, हम स्ट्रिंग रेंज का उपयोग करते हैं '00'..'99'ताकि संख्या स्वचालित रूप से 2 अंकों के लिए बाएं-गद्देदार हो और स्ट्रिंग हो । यह सीमा से बहुत कम जाँच करता है - रेगेक्स के साथ मेल खाता है /[09]/।

  • सहायक समारोह के अंदर, नए निर्देशांक की सूची निर्माण, जबकि [x-11, x-9, x+9, x+11], हम एक साथ आवंटित z[x]करने 9की प्रक्रिया है, जो एक truthy मूल्य होता है में (वर्ग का दौरा किया अंकन)।

  • अंतिम पंक्ति में, हम जाँचना चाहते हैं कि सरणी z[81,9]में नहीं है 9। हम 9( z[81,9]-[9]) के सभी उदाहरणों को हटाकर ऐसा करते हैं , फिर परिणामी सरणी के 9 वें तत्व के लिए पूछ रहे हैं ( [8])। चूंकि हम जानते हैं कि सरणी में मूल रूप से 9 तत्व थे, यदि कोई हटा दिया गया था, तो हम प्राप्त करेंगे nil, जबकि यदि वे सभी बने रहे, तो हमें सरणी का अंतिम तत्व मिलेगा (जो हमेशा होता है 1)।

— Doorknob
स्रोत
2

पायथन 2 , 330 318 313 309 370 बाइट्स

import numpy as n
b=n.ones([8,8])
q=r=1
s=input()
l=len(s)
def g(x,y=0,p=0):
    if b[y,x]and p<32:
        if y<7:
            if x<7:
                g(x+1,y+1,p+1)
                if y:g(x+1,y-1,p+1)
            if x:
                g(x-1,y+1,p+1)
                if y:g(x-1,y-1,p+1)
        else:global q;q=0
for i in range(l/2):
    x=ord(s[2*i])-97;y=ord(s[2*i+1])-49
    if y>8or y<0 or l%2or x>8or x<0:r=0
    if r:b[7-y,x]=0
map(g,range(8))
print q&r

इसे ऑनलाइन आज़माएं!

ऑनलाइन व्यावहारिक संस्करण की कोशिश करो! (मूल पूरी तरह से जांच करने के लिए 4 ^ 32 ऑपरेशन ले सकता है, मैं सुझाव देता हूं कि यह एक ही - बाइट्स की एक ही संख्या का उपयोग करके)

सुपर शॉर्ट सॉल्यूशन नहीं - मैं यह पता नहीं लगा सका कि जी का लैंबडा फंक्शन वर्जन जी से कम है।

-4 बाइट्स क्वक्सप्लोन के लिए धन्यवाद

+61 बाइट्स के पीछे का हिसाब चुकता करना (जो जो किंग को बताने के लिए धन्यवाद और गोल्फ के लिए टिप्स)

— एलेक
स्रोत
अच्छा लगा। q=r=1से छोटा होगा q=1 r=1, है ना? और से if r:छोटा है if r>0:।
— Quuxplusone
2

अजगर 2 , 490 476 474

def f(p):
 a=[set(ord(c)-33 for c in s)for s in"* )+ *, +- ,. -/ .0 / \"2 !#13 \"$24 #%35 $&46 %'57 &(68 '7 *: )+9; *,:< +-;= ,.<> -/=? .0>@ /? 2B 13AC 24BD 35CE 46DF 57EG 68FH 7G :J 9;IK :<JL ;=KM <>LN =?MO >@NP ?O BR ACQS BDRT CESU DFTV EGUW FHVX GW JZ IKY[ JLZ\\ KM[] LN\\^ MO]_ NP^` O_ R QS RT SU TV UW VX W".split()];x=set((ord(p[i+1])-49)*8+ord(p[i])-97 for i in range(0,len(p),2))
 r=set(range(8))-x
 for i in range(99):r=set().union(*[a[c]for c in r])-x
 return all(c<56 for c in r)

इसे ऑनलाइन आज़माएं!

यह "बाढ़-भरण" द्वारा काम करता है। पहले हम एक सूची बनाते हैं aकि कौन से वर्ग आसन्न हैं, अन्य वर्ग, बिशपवाइज़। फिर हम xबहिष्करण का एक सेट बनाते हैं (पासवर्ड के आधार पर)। फिर हम rपहुंच योग्य वर्गों के एक सेट को आरंभीकृत करते हैं , जो कि केवल पहली पंक्ति के रूप में शुरू होता है (किसी भी प्रकार का ऋण), और वहाँ से बार-बार "बाढ़", 99 बार, जो कि पर्याप्त से अधिक होना चाहिए। अंत में, हम यह देखने के लिए परीक्षण करते हैं कि पिछली पंक्ति में कोई भी वर्ग हमारे पहुंच योग्य सेट में समाप्त हो गया है या नहीं। यदि हां, तो हमारे पास एक कमजोर पासवर्ड है! यदि नहीं, तो हमारे पास एक मजबूत पासवर्ड है।

नुकसान, शायद अयोग्य (मैं यहां सामान्य नियम नहीं जानता): यदि पासवर्ड बीमार है (जैसे "सही हॉर्स बैटरी स्टेपल"), तो हम लौटने के बजाय एक अपवाद फेंक देते हैं False। लेकिन हम हमेशा वापसी करते हैं Trueयदि पासवर्ड मजबूत है!

माइनस 16 बाइट्स जो किंग के लिए धन्यवाद। हम aएक ही स्थान पर इसका उपयोग करते हैं, और कुछ गणित को निरंतर गुना करते हैं।

def f(p):
 x=set(ord(p[i])-489+8*ord(p[i+1])for i in range(0,len(p),2));r=set(range(8))-x
 for i in[1]*99:r=set().union(*[[set(ord(k)-33for k in s)for s in"* )+ *, +- ,. -/ .0 / \"2 !#13 \"$24 #%35 $&46 %'57 &(68 '7 *: )+9; *,:< +-;= ,.<> -/=? .0>@ /? 2B 13AC 24BD 35CE 46DF 57EG 68FH 7G :J 9;IK :<JL ;=KM <>LN =?MO >@NP ?O BR ACQS BDRT CESU DFTV EGUW FHVX GW JZ IKY[ JLZ\\ KM[] LN\\^ MO]_ NP^` O_ R QS RT SU TV UW VX W".split()][c]for c in r])-x
 return all(c<56for c in r)
— Quuxplusone
स्रोत
@JoKing धन्यवाद! अभी भी दो व्हाट्सएप से पहले व्हाट्सएप है forकि मैं नहीं देख सकता कि कैसे हटाऊं। मैंने पाया की जगह है कि range(99)के साथ repr(f)नहीं बल्कि tio.run के दुभाषिया पर अपने स्थानीय मशीन पर काम करता है ... लेकिन तब मैंने पाया कि [1]*99वैसे भी कम था! ताकि 4 और बाइट्स बच जाएं।
— क्क्सप्लसोन
दो forएस से पहले व्हॉट्सएप कि मैं नहीं देख सकता कि कैसे हटाऊं - ओह! जाहिर तौर पर अजगर 33forदो टोकन मानते हैं (जबकि for33एक टोकन होगा)। आज मैंने सीखा। माइनस 2 और बाइट्स, फिर।
— क्क्सप्लसोन
1

क्लीन , 285 बाइट्स

import StdEnv,Data.List
$_[_]=1<0
$a[x,y:l]=case[[u,v]\\u<-[0..7],v<-[0..7]|u==toInt x-97&&v==toInt y-49]of[p]= $[p:a]l;_=1<0
$a _=all(\[_,y]=y<7)(iter 64(nub o\e=e++[k\\[u,v]<-e,p<-[-1,1],q<-[-1,1],k<-[[abs(u+p),abs(v+q)]]|all((<>)k)a&&all((>)8)k])(difference[[e,0]\\e<-[0..7]]a))


$[]

इसे ऑनलाइन आज़माएं!

$[]है $ :: [[Int]] [Char] -> Boolपहला तर्क के साथ की रचना की, दे रही है \ [Char] -> Bool।

फ़ंक्शन एक समय में स्ट्रिंग दो वर्णों का उपभोग करके काम करता है, यदि कोई अमान्य प्रारूप देखता है तो स्ट्रिंग तुरंत अमान्य स्वरूप में है। एक बार स्ट्रिंग संसाधित हो जाने के बाद, यह बोर्ड के एक तरफ प्रत्येक खाली वर्ग पर एक बिशप को रखता है और उन्हें हर तरह से 64 बार संभव स्थानांतरित करता है और जाँचता है कि क्या कोई अंतिम स्थिति लक्ष्य पंक्ति में है।

— Οurous
स्रोत
गलत तरीके से वापसी के Trueलिए लगता है a1b1c1d1e1f1g1? ऐसा नहीं है कि मैं कुछ भी समझता हूं कि यह कैसे काम करता है। :)
— क्क्सप्लसोन
2
@Quuxplusone मैं एक मस्तिष्क गोज़ और सोचा सफेद बिशप केवल सफेद वर्गों का इस्तेमाल किया था। मैंने एक स्पष्टीकरण भी जोड़ा है।
— 21
1

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 339 316 358 353 345 बाइट्स

-23 बाइट्स @Doorknob को धन्यवाद।

+42 बाइट्स बैकट्रैकिंग के लिए लेखांकन।

p[m_]:=StringPartition[#,m]&;l=Range@8;f[n_]:=Check[w=(8#2+#1-8)&@@@({LetterNumber@#,FromDigits@#2}&@@@(p@1/@p[UpTo@2]@n));g=Graph[Sort/@UndirectedEdge@@@Position[Outer[EuclideanDistance@##&,#,#,1],N@Sqrt@2]&@GraphEmbedding@GridGraph@{8,8}//Union]~VertexDelete~w;c:=#~Complement~w&;m=0;Do[m+=Length@FindPath[g,i,j],{i,c@l},{j,c[l+56]}];m==0,0>1]

इसे ऑनलाइन आज़माएं!

मैंने इसमें से अधिकांश को पीछे की ओर जाने के लिए फिर से लिखा है, मुझे लगता है कि ग्राफ को परिभाषित करने का एक आसान तरीका हो सकता है g, गणितज्ञ के पास GraphData[{"bishop",{8,8}}]जो सभी चालों का ग्राफ है जो एक बिशप एक शतरंजबोर्ड ( बिशप ग्राफ ) पर बना सकता है , लेकिन इस ग्राफ में कनेक्शन शामिल हैं निकटतम विकर्ण पड़ोसी की तुलना में। अगर किसी को यह करने का एक छोटा तरीका पता है तो मुझे बताएं। ग्राफ निर्माण का श्रेय इस गणितज्ञ उत्तर को जाता है ।

Trueमजबूत पासवर्ड के लिए रिटर्न , Falseकमजोर / बीमार पासवर्ड के लिए। ध्यान दें कि अधिकांश बीमार पासवर्डों के लिए यह त्रुटि संदेशों का एक समूह उत्पन्न करेगा और फिर वापस आ जाएगा False। यदि यह नियमों के साथ लाइन में नहीं है तो वे बदलते द्वारा दबा दिया जा सकता है f[n_]:=...के लिए f[n_]:=Quiet@...6 बाइट्स की लागत।

Ungolfed:

p[m_] := StringPartition[#, m] &;

f[n_] :=
 Check[
  w = (8 #2 + #1 - 
       8) & @@@ ({LetterNumber@#, FromDigits@#2} & @@@ (p@1 /@ 
        p[UpTo@2]@n));
  r = GridGraph[{8, 8}];
  g = Graph[Sort /@ UndirectedEdge @@@
             Position[Outer[EuclideanDistance@## &, #, #, 1],N@Sqrt@2] &@
              GraphEmbedding@r // Union]~VertexDelete~w;
  s = Complement[{1,2,3,4,5,6,7,8},w];
  e = Complement[{57,58,59,60,61,62,63,64},w];
  m = 0;
  Do[m += Length@FindPath[g, i, j], {i, s}, {j, e}];
  If[m == 0,True,False]
  , False]

टूट - फूट:

p[m_]:=StringPartition[#,m]&

एक स्ट्रिंग तर्क लेता है और इसे प्रत्येक लंबाई के तार की सूची में विभाजित करता है m।

Check[...,False]

Falseयदि कोई त्रुटि संदेश उत्पन्न होता है, तो लौटाता है , जिससे हम अ-निर्मित तारों को पकड़ते हैं (यानी मान लें कि वे अच्छी तरह से निर्मित हैं, अनिवार्य रूप से लाइन के नीचे एक त्रुटि पैदा कर रहे हैं)।

(8*#2 + #1 - 8) & @@@ ({LetterNumber@#, FromDigits@#2} & @@@ (p@1 /@ 
        p[UpTo@2]@n));

प्यादा पदों की स्ट्रिंग लेता है और इसे इस तरह विभाजित करता है कि "a2h5b"बन जाता है {{"a","2"},{"h","5"},{"b"}}, फिर LetterNumberपत्र को एक संख्या में (और a -> 1,) में FromDigitsबदल देगा और अंक को पूर्णांक में बदल देगा। यदि स्ट्रिंग अच्छी तरह से नहीं बनाई गई है, तो यह चरण एक त्रुटि पैदा करेगा जो कि Checkवापस पकड़ा जाएगा False। इन दो नंबरों को तब बोर्ड पर एक वर्ग के अनुरूप एक पूर्णांक में बदल दिया जाता है।

r = GridGraph[{8, 8}];
g = Graph[
     Sort /@ UndirectedEdge @@@ 
          Position[Outer[EuclideanDistance@## &, #, #, 1], 
           N@Sqrt@2] &@GraphEmbedding@r // Union]~VertexDelete~w;

हटाए गए मोहरे पदों के साथ सभी निकटतम-पड़ोसी विकर्ण किनारों के ग्राफ का निर्माण करता है। 

s = Complement[{1,2,3,4,5,6,7,8},w];
e = Complement[{57,58,59,60,61,62,63,64},w];

ये क्रमशः अव्यवस्थित शुरुआत और समाप्ति की सूची हैं

m=0
Do[m += Length@FindPath[g, i, j], {i, s}, {j, e}];
If[m == 0,True,False]

प्रत्येक जोड़ी के लिए शुरुआती और अंत की छोरों पर छोरों, FindPathउनके बीच के रास्तों की एक सूची होगी। यदि उनके बीच कोई रास्ता नहीं है, तो यह एक खाली सूची होगी, इसलिए Length@रिटर्न 0। यदि रास्ते बिल्कुल नहीं हैं, तो mशून्य होगा, और हम लौटते हैं True, अन्यथा वापस लौटते हैं False।

— काई
स्रोत
कुछ टिप्स: Trueऔर Falseहो सकता है 1>0और 0>1क्रमशः। p[1]@#&/@के बराबर है p@1/@। Sequence@@से बदला जा सकता है ##&@@। इसके बजाय {LetterNumber[#[[1]]],FromDigits[#[[2]]]}&/@, आप उपयोग कर सकते हैं {LetterNumber@#,FromDigits@#2}&@@@।
— दरवाज़े
@Doorknob धन्यवाद! कोड गोल्फिंग मुझे मैथमेटिका के बारे में हर तरह की नई बातें सिखा रहा है। मुझे अभी भी 100% समझ नहीं है p@1/@, लेकिन मैं सामान्य विचार देखता हूं। मुझे लगता है p@1 = StringPartition[#,1]&, यह मेरे लिए थोड़ा भ्रामक है, मुझे लगता है क्योंकि pदो तर्क दो अलग-अलग तरीके से लगते हैं, एक के रूप में m_और दूसरे के रूप में #...&, मुझे लगता है कि यह सिर्फ पूर्वता का मामला है। हालांकि यह समझ में आता है p@m = p[m]।
— काई
यह मेरे लिए भी है! वहाँ मुख्य परिवर्तन यह है कि किसी भी कार्य के लिए fजो एक ही तर्क लेता है, f@#&उसका व्यवहार वैसा ही है f- जैसा है, यहाँ fहै p[1]। (तब मैं बदल []अंकन करने के लिए @है, जो हमेशा पूर्वता को छोड़ कर एक है।)
— दरवाज़े
@JoKing जो कुटिल है, यह पहले से ज्यादा जटिल है, मैंने पीछे के आंदोलनों पर भी विचार किया है। धन्यवाद
— काई
@JoKing ने एक नया लेख लिखा है जिसमें बैकट्रैकिंग के बारे में बताया गया है।
— काई
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.