मैं पहेली के अलावा स्लाइड कर सकते हैं?


38

एक प्रोग्राम या फ़ंक्शन लिखें जो पाठ के एक आयताकार ग्रिड में लेता है जहां हर सेल या तो एक Aया एक है B। सभी Aकोशिकाएं एक सरलता से जुड़ी आकृति का निर्माण करेंगी, अर्थात वे सभी बिना किसी छिद्र के साथ जुड़े होंगे (तिरछे पड़ोसी अक्षर जुड़े हुए नहीं हैं)। इसी तरह, सभी Bकोशिकाएं एक और बस-जुड़ा हुआ आकार बनाएंगी। ग्रिड में हमेशा कम से कम एक Aऔर कम से कम एक होगा B

कल्पना कीजिए कि ग्रिड वास्तव में पतले प्लास्टिक के दो ब्लॉक-आकार के टुकड़े हैं, जिन्हें Aऔर Bभागों द्वारा दर्शाया गया है । यदि इसे एक मेज पर सपाट रखा जाता है, तो क्या मेज पर पूरी तरह से सपाट रखने के दौरान दो टुकड़े अलग हो सकते हैं?

यदि दो और आकृतियों को इस तरह अलग किया जा सकता है , तो प्रिंट करें या एक सत्य मान लौटाएं । यदि नहीं, तो झूठा मूल्य प्रिंट या वापस करें ।AB

उदाहरण के लिए, इनपुट

AAA
ABB
AAA

यह सत्य है क्योंकि यह BBखंड दाईं ओर खिसक सकता है, इसे A's: से अलग करना

AAA
A    BB
AAA

हालाँकि, इनपुट

AAAA
ABBA
ABAA

गलत है, क्योंकि उन्हें ओवरलैप किए बिना अलग Aऔर Bभागों को स्लाइड करने का कोई तरीका नहीं है।

बाइट्स में सबसे छोटा कोड जीतता है। यदि वांछित है, तो आप और के स्थान पर किसी भी दो डिस्टिक्ट प्रिंट करने योग्य ASCII वर्ण का उपयोग कर सकते हैं ।AB

ट्रुथ उदाहरण (खाली लाइनों द्वारा अलग)

BBB
BAA
BBB

BA

A
B

AB
AB

AAA
BBB

AAAAB
ABBBB

ABBA
ABBA
AAAA

AAAAAABBBBBBBBB
AABBBBBBBBBBBBB
AAAAAAAAAABBBBB
AABBBBBBBBBBBBB
AAAAAAAAAAAAAAB

AAAAAAAAAAAA
ABABABABABAB
BBBBBBBBBBBB

BAAAAABB
BBAAABBB
BBBABBBB
BBBABBBB
BBBABBBB
BBBBBBBB
BBBBBBBB

AAA
BAA
AAA

झूठा उदाहरण

BBBB
BAAB
BABB

BBBB
BAAB
AABB

BBBBBBB
BBBBBAB
AAAAAAB
BBBBBBB

BAAA
BABA
BBBA
AABA
AAAA

AAAAAAA
ABBBBBA
AAAAABA
BBBBBBA

BAAAAABB
BBAAABBB
BBBABBBB
BBBABBBB
BBBAABBB
BBBBBBBB
BBBBBBBB

AAA
ABA
BBA
ABA
AAA

जवाबों:


9

घोंघे, १४

o(t\B+~)+!(t\B

यदि पहेली को अलग किया जा सकता है, तो यह इनपुट के क्षेत्र को प्रिंट करता है। अन्यथा, यह प्रिंट करता है 0।

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

         ,, the program will print the number of starting cells matching this pattern
o        ,, pick a cardinal direction
(
    t    ,, teleport to any cell on the grid
    \B+  ,, match "B" 1 or more times, moving in the direction set by 'o'.
         ,, when a cell is matched, it gets slimed and can't be matched again.
    ~    ,, match an out-of-bounds cell
)+       ,, do parenthesized instructions 1 or more times
!(       ,, the following must not match:
    t\B  ,, teleport to some cell and match 'B'

4
"यह थोड़ा धीमा है .." । यकीन नहीं होता कि आपको घोंघे नामक भाषा से क्या उम्मीद है ...
बैसब्रांड कंबरव्वाबबूब

4
@ बस्स अब, घावों में नमक रगड़ने का कोई कारण नहीं।
Trasiva

21

CJam, 33 32 20 19 17 बाइट्स

@ Sp3000 और @ मार्टिनबटनर से बड़े पैमाने पर समर्थन के साथ संशोधित संस्करण:

qN/_z]{:e`z,3<}/|

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

योगदान

  • @ Sp3000 ने मेरे मूल एल्गोरिथ्म के लिए एक महत्वपूर्ण सरलीकरण का सुझाव दिया।
  • @ मार्टिनबटनर ने संशोधित दृष्टिकोण के लिए अपने पागल गोल्फिंग कौशल को लागू किया, जिसके परिणामस्वरूप निश्चित रूप से कम कोड की तुलना में मैं सरलीकरण पर विचार करने के बाद भी आ गया था।

एल्गोरिथम और सबूत

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

मैं एक ही अक्षर के अधिकतम अनुक्रम के लिए "खिंचाव" शब्द का उपयोग करूँगा। उदाहरण के लिए, निम्नलिखित पंक्तियों में क्रमशः 1, 2 और 3 स्ट्रेच हैं:

AAAAAAAA
BBBAAAAA
AABBBAAA

मैं एक पंक्ति / पहेली के लिए "इंटरलॉक्ड" शब्द का उपयोग करूंगा जो अलग नहीं हो सकता।

मुख्य अवलोकन यह है कि पहेली अलग-अलग स्लाइड कर सकती है यदि और केवल यदि सभी पंक्तियों में अधिकतम 2 खंड हैं । या उलट, यह इंटरलॉक किया जाता है अगर और केवल अगर 2 से अधिक हिस्सों के साथ कोई पंक्ति है

निम्नलिखित एक सख्त गणितीय प्रमाण के रूप में योग्य नहीं हो सकता है, लेकिन मेरा मानना ​​है कि यह एक ठोस व्याख्या के लिए बनाता है कि ऐसा क्यों होना चाहिए।

यह देखना आसान है कि पहेली इंटरलॉक की गई है यदि इसमें 2 से अधिक हिस्सों की पंक्तियाँ हैं। 3 स्ट्रेच वाली पंक्ति को देखते हुए:

BBBAAB

यह स्पष्ट है कि यह पहेली को अलग-अलग फिसलने से रोकता है क्योंकि Aस्ट्रेच के बीच खिंचाव बंद Bहै। इसका मतलब है कि पंक्ति इंटरलॉक की गई है, जो बदले में पूरी पहेली को इंटरलॉक कर देती है।

प्रमाण की विपरीत दिशा स्पष्ट नहीं है। हमें यह दिखाने की ज़रूरत है कि कोई इंटरलॉक की गई पहेलियाँ नहीं हैं जहाँ सभी पंक्तियों में केवल 1 या 2 स्ट्रेच हों। कुछ टिप्पणियों के साथ शुरू:

  • केवल 1 स्ट्रेच वाली पंक्तियाँ इंटरलॉक होने वाली पहेली में योगदान नहीं करती हैं, क्योंकि वे बिना किसी टकराव के किसी भी दिशा में स्लाइड कर सकती हैं।
  • यदि 2 स्ट्रेच वाली सभी पंक्तियों का क्रम समान है Aऔर B, पहेली स्पष्ट रूप से इंटरलॉक नहीं की गई है। इस मामले में, सभी Aकोशिकाएं सभी कोशिकाओं से बची रहती हैं B, या इसके विपरीत, और दो टुकड़ों को अलग करने पर कोई टकराव नहीं होता है।

एकमात्र मुश्किल मामला पहेली होगा जहां हमारे पास अलग-अलग क्रम के 2 हिस्सों के साथ पंक्तियाँ हैं। मैं यह दिखाने जा रहा हूं कि दी गई विशिष्टताओं के तहत ऐसी पहेलियाँ मौजूद नहीं हैं । यह दिखाने के लिए, आइए एक आंशिक पहेली को देखें जिसमें यह विन्यास है, जहां .वाइल्डकार्ड हैं:

.......
AAABBBB
.......
BBAAAAA
.......

अब, विनिर्देश का कहना है कि दोनों Aऔर Bसेल सभी वैध पहेली में बस जुड़े हुए हैं। बनाने के Aऊपर आंशिक पहेली में जुड़े कोशिकाओं, हम दो विकल्प हैं:

  1. हम Bउदाहरण के लिए, एक के चारों ओर लूप करते हैं :

    ..AAAAAA
    AAABBBBA
    .......A
    BBAAAAAA
    ........
    

    ऐसा करने के लिए, हम अनपेक्षित रूप से एक पंक्ति को 3 खंडों तक बढ़ाते हैं, इसलिए यह हमें कभी भी एक मान्य पहेली नहीं देगा जहां सभी पंक्तियों में अधिकतम 2 खंड हैं।

  2. हम उन्हें एक सीधे रास्ते पर जोड़ते हैं:

    .......
    AAABBBB
    ..A....
    BBAAAAA
    .......
    

    Aकोशिकाओं अब बस जुड़े हुए हैं, और अभी भी अधिक से अधिक 2 हिस्सों के साथ कोई भी पंक्ति रहे हैं। हालांकि, Bकोशिकाओं को भी बस जुड़ा होना चाहिए। सीधा रास्ता अब जुड़ा हुआ Aकोशिकाओं द्वारा अवरुद्ध है , और कोशिकाओं को जोड़ने का एकमात्र तरीका Bकोशिकाओं में से एक के चारों ओर लूप Aहै। यह केस 1 पर वापस जाता है, जहां हम 3 स्ट्रेच की पंक्तियों को बनाए बिना ऐसा नहीं कर सकते।

स्ट्रेच को गिनने के लिए, कार्यान्वयन CJam RLE ऑपरेटर का उपयोग करता है।

संहिता की व्याख्या

qN/     Get input and split at newlines.
_z      Make a transposed copy.
]       Wrap the original and transposed puzzle in an array so that we can
        loop over the two.
{       Start of loop over original and transposed puzzle.
  :e`     Apply RLE to all rows.
  z,      Transpose the matrix with the RLE rows, and take the element count of the
          result. Or in other words, take the column count. This will be the length
          of the longest row after RLE.
  3<      Check the length for less than 3.
}/      End of loop over original and transposed puzzle.
|       Or the results of the two.

9

जावास्क्रिप्ट (ईएस 6), 108 107 98 91 82 बाइट्स

a=>!(T=[],R=/AB+A|BA+B/).test([...a].map((c,i)=>T[i%-~a.search`
`]+=c))|!R.test(a)

लाइव डेमो । फ़ायरफ़ॉक्स में परीक्षण किया गया। इनपुट को न्यूलाइन-सीमांकित स्ट्रिंग के रूप में लेता है।

संपादन:

  • 1 बाइट \nको शाब्दिक न्यूलाइन में बदलकर सहेजा गया ।
  • एक सरणी में परिवर्तित करने के बजाय सीधे मल्टी-लाइन स्ट्रिंग पर RegExp परीक्षण करके 9 बाइट्स सहेजे गए।
  • विभाजित स्ट्रिंग को स्थानांतरित करने के लिए सरणी समझ का उपयोग करके एक और 9 बाइट्स को हटा दिया! में gसमारोह और रेगुलर एक्सप्रेशन सीधे सरणी पर बजाय कॉलिंग का उपयोग करके find
  • एक और 9 बाइट्स को बचाकर अंकगणितीय अनुक्रम जारी रखा। स्थानान्तरण लेने से पहले न्यूलाइन द्वारा सरणी को विभाजित करने के बजाय सूचकांक पर एक मापांक किया।

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

पुराना वर्जन:

a=>(T=[],a.split`
`.map(s=>s.split``.map((c,i)=>T[i]+=c)),!T.find(g=s=>/AB+A|BA+B/.test(s)))|!g(a)
  1. इनपुट लें aऔर इसे न्यूलाइन द्वारा स्ट्रिंग्स की एक सरणी में विभाजित करें।
  2. इसमें ट्रांसफ़ॉर्म करें aऔर स्टोर करें T। उपयोग mapके प्रत्येक तत्व पर पुनरावृति करने a, एक चरित्र सरणी में स्ट्रिंग विभाजित है, और प्रयोग mapसंलग्न करने के लिए फिर से iकरने के लिए लाइन में वें चरित्र iका वीं लाइन T। चूँकि प्रत्येक तत्व Tअसंगठित है, इसलिए यह कुछ ऐसा दिखाई "undefinedAAABBA"देगा, लेकिन यह कोई मायने नहीं रखेगा।
  3. एक RegExp आधारित परीक्षण फ़ंक्शन बनाएँ gजो पैटर्न से मेल खाता है /AB+A|BA+B/। यदि यह मेल खाता है, तो टुकड़े दिए गए दिशा में बंद हैं क्योंकि तब Bदो या दो से अधिक As या इसके विपरीत सैंडविच का सेट होता है ।
  4. gब्लॉक के सभी तत्वों का परीक्षण करने के लिए परीक्षण फ़ंक्शन का उपयोग करें aऔर इसका Tउपयोग करके एक मैच के लिए स्थानांतरित करें find। यदि दोनों मेल खाते हैं, तो टुकड़े दोनों दिशाओं में बंद हैं, इसलिए एक मिथ्या मूल्य का उत्पादन करें, अन्यथा एक सत्य।

5

जावास्क्रिप्ट (ईएस 6), 118

slidey=
// code
a=>!a.match(R=/AB+A|BA+B/)||!(a=a.split`
`.map(b=>b.split``))[0].map((_,c)=>a.map(d=>d[c])).some(e=>e.join``.match(R))

// IO
var S =document.getElementById('S');
S.onkeyup = _=> document.getElementById('P').innerText = slidey(S.value);

document.getElementById('P').innerText = slidey(S.value);
<textarea id='S'>BAAAAABB
BBAAABBB
BBBABBBB
BBBABBBB
BBBABBBB
BBBBBBBB
BBBBBBBB</textarea>
<p id='P'></p>

स्पष्टीकरण:

a=> !/* check string horizontally */ || !/* check string vertically by transposing it and
                                            running the same horizontal check */

a=> !a.match(R=/AB+A|BA+B/) || !/* ... */
// check for lines containing something like BAAAAAB or ABBBBBBBA
// this is the only way something can get blocked horizontally
// eg AAAAAAA
//    AAABAAA <<< note the B in the middle of As here
//    AAABBBB <<< blocked from being pulled out horizontally
//    AAAAAAA

a=> /* ... */ ||!( a = a.split('\n').map(b=> b.split('')) ) // split a into 2D array
    [0].map((_,c)=>a.map(d=>d[c])) // transpose it
    .some(e=>e.join``.match(R)) // run the check again using `some` to go line by line
                                // which is shorter than .join().match() outside

a=> !/* returns null if no horizontal obstacles and an array if there are */
    || !/* same thing */
// negate both to cast to a boolean (false if obstacles, true if not)
// an input can only be unslidable if both directions are blocked
// so (no obstacles vertically? || no obstacles horizontally?) gives the answer

सत्यानाश! मुझे इससे हराएं।
intrepidcoder

5

जावास्क्रिप्ट (ईएस 6) 72 74

2 बाइट्स संपादित करें thx @NotthatCharles को सहेजा गया

मेरी सहज समझ है कि अगर कोई एक टुकड़ा कदम के एक हिस्से को स्लाइड कर सकता है, तो यह मुफ़्त है। वर्तमान परीक्षण के मामले इसकी पुष्टि करते हैं।

इसलिए मैं प्रत्येक दिशा में सिर्फ एक चरण की जांच करता हूं।

उपयोग किए गए वर्ण:
A और B जैसे किसी भी 2 मुद्रण योग्य वर्णों का उपयोग करने के लिए 1 और 0 2 बाइट्स अधिक

एक EcmaScript 6 अनुरूप ब्राउज़र में नीचे स्निपेट का परीक्षण करना (प्रसार ऑपरेटर का समर्थन करना - IE फ़ायरफ़ॉक्स)

f=s=>[w=~s.search`
`,-w,-1,1].some(o=>![...s].some((x,p)=>x+s[p+o]==10))

// 4 bytes more- for any symbol, not just 1 and 0 (for instance A and B):
g=s=>[w=~s.search`
`,-w,-1,1].some(o=>![...s].some((x,p)=>x+s[p+o]=='AB'))

//TEST
console.log=x=>O.innerHTML+=x+'\n'

testOk = [
 '111\n100\n111',
 '10',
 '0\n1',
 '01\n01',
 '000\n111',
 '00001\n01111',
 '0110\n0110\n0000',
 '000000111111111\n001111111111111\n000000000011111\n001111111111111\n000000000000001',
 '000000000000\n010101010101\n111111111111',
 '10000011\n11000111\n11101111\n11101111\n11101111\n11111111\n11111111',
 '000\n100\n000'
]

testKo = [
 '1111\n1001\n1011',
 '1111\n1001\n0011',
 '1111111\n1111101\n0000001\n1111111',
 '1000\n1010\n1110\n0010\n0000',
 '0000000\n0111110\n0000010\n1111110',
 '10000011\n11000111\n11101111\n11101111\n11100111\n11111111\n11111111',
 '000\n010\n110\n010\n000'
]

console.log('Expecting true')
testOk.forEach(t=>console.log(t+'\n'+f(t)+'\n'))
console.log('Expecting false')
testKo.forEach(t=>console.log(t+'\n'+f(t)+'\n'))
<pre id=O></pre>


खैर, यह सिर्फ प्रतिभा है। फिर से एक समर्थक द्वारा पीटा गया। :-)
२१

s[p+o]=='0'थोड़ा लंबा लगता है। क्या इसे 1-s[p+o]कम से कम या इसके साथ बदला जा सकता है s[p+o]==0?
ETHproductions

@ETHproductions हाँ, यह लंबा है, यह कुछ और सोच के लायक है। इसे '\ n' (खड़ी सीमा, 0 में धर्मान्तरित) और अपरिभाषित (ऊपरी और निचली सीमा के लिए, NaN में धर्मान्तरित) के लिए असत्य देना चाहिए
edc65

=='A'द्वारा प्रतिस्थापित किया जा सकता है <'B'। उसी के लिए=='B'
चार्ल्स

इसके अलावा, क्या आप ऐसा नहीं कर सकते x+s[p+o]=='AB'?
नहीं कि चार्ल्स

3

गणितज्ञ 100 69 बाइट्स

एक बड़े पैमाने पर 31 बाइट्स बचाए जाने के लिए, @ मॉर्टिन बटनर को धन्यवाद,

g=Max[Length/@Split/@#]<3&;g[c=Characters@StringSplit@#]||g@Thread@c&

वर्णों के एक मैट्रिक्स के रूप में इनपुट को प्रारूपित करता है; यह मैट्रिक्स का एक संक्रमण भी बनाता है। यदि या तो मैट्रिक्स या इसके ट्रांसपोज़ में प्रति पंक्ति 2 से अधिक रन नहीं हैं तो पहेली स्लाइड कर सकते हैं।

{a,a,b,b,b} पत्रों के 2 रन है।

{a,a,b,a,a} पत्रों के 3 रन है।

{a,a,b,a,a,a,b,b,b,b,b,b,b,b} अक्षरों के 4 रन हैं।


2

दिल्लोग एपीएल, 22 बाइट्स

(∨/{∧/2>+/2≠/⍵}¨)⊂∘⍉,⊂

इसे यहाँ आज़माएँ। यह एक फ़ंक्शन है जो वर्णों के 2 डी सरणी में लेता है, और 1स्लाइडिंग इंस्टेंस के लिए और 0गैर-स्लाइडिंग वाले के लिए लौटता है। एल्गोरिथ्म अधिकांश अन्य उत्तरों के समान है: मैट्रिक्स की जांच करें और इसके ट्रांसपोज़ के लिए कि किसी भी पंक्ति में विभिन्न अक्षरों के एक से अधिक आसन्न जोड़े नहीं हैं। 4x3 इनपुट मैट्रिक्स के लिए

AAAA
ABBB
AAAB

समारोह के रूप में लागू किया जा सकता है

f ← (∨/{∧/2>+/2≠/⍵}¨)⊂∘⍉,⊂
f 4 3 ⍴ 'AAAAABBBAAAB'

जिसके परिणामस्वरूप 1

व्याख्या

⊂∘⍉,⊂   The matrix and its transpose.
{...}¨   For each of them:
  2≠/⍵   On each row, replace each adjacent pair with 1 if they differ, with 0 otherwise
  2>+/    Take the sum on each row and check that it's less than 2
  ∧/     AND over all rows
∨/      OR over the resulting two values

1

जावास्क्रिप्ट (ईएस 6), 94 बाइट्स

x=>!(y=/AB+A|BA+B/).test(x)|(z=[],x.split`
`.map(b=>b.split``.map((c,i)=>z[i]+=c)),!y.test(z))

एक ही आकार वैकल्पिक विधि:

x=>(t=s=>!/AB+A|BA+B/.test(s),z=[],x.split`
`.map(b=>b.split``.map((c,i)=>z[i]+=c)),t(x)|t(z))

यह 1एक सत्य इनपुट के लिए और मिथ्या के लिए लौटता है 0। इससे पहले कि मैं कोई अन्य उत्तर पोस्ट किया गया था, मैंने इस पर काम शुरू कर दिया। मैंने मूल रूप से ES7 की सरणी समझ का उपयोग करने की कोशिश की, लेकिन यह इस विधि की तुलना में लगभग 10 चार्ट अधिक लंबा था।

कोशिश करके देखो:

a=x=>!(y=/AB+A|BA+B/).test(x)|(z=[],x.split`
`.map(b=>b.split``.map((c,i)=>z[i]+=c)),!y.test(z))

P.onclick=_=>Q.innerHTML='Result: '+a(O.value)
<textarea id=O cols="20" rows="8">AAAAAABBBBBBBBB
AABBBBBBBBBBBBB
AAAAAAAAAABBBBB
AABBBBBBBBBBBBB
AAAAAAAAAAAAAAB</textarea>
<button id=P>Test</button>
<p id=Q>Result: </p>

सुझावों का स्वागत है!


B.split`` के बजाय [... b] का उपयोग करके 3 बाइट्स बचाता है, लेकिन केवल कुछ ब्राउज़रों में काम करता है।
इंट्रेपिडोडर
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.