जादू दर्पण पागलपन

Question

परिचय

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

इनपुट

आपका इनपुट वर्णों से युक्त एक तार है .#|, जो खाली जगह, वस्तुओं और जादू के दर्पण का प्रतिनिधित्व करता है। इनपुट में हमेशा कम से कम एक जादू दर्पण होगा।

उत्पादन

आपका आउटपुट एक और स्ट्रिंग होगा जहां प्रत्येक जादू दर्पण ने ऊपर दिए गए नियमों के अनुसार प्रत्येक आइटम की नकल की हो सकती है। आप मान सकते हैं कि उस जगह पर हमेशा एक खाली जगह होगी जहां एक डुप्लिकेट आइटम दिखाई देता है (इसलिए वे सीमा से बाहर नहीं जाएंगे)।

उदाहरण

इनपुट स्ट्रिंग पर विचार करें

.#.|.....|......#
 A B     C      D

जहां हमने स्पष्टता के लिए कुछ पदों को चिह्नित किया है। दर्पण Bआइटम को डुप्लिकेट करता है A, जो इसके दाईं ओर समाप्त होता है:

.#.|.#...|......#
 A B     C      D

दर्पण Cतब नए आइटम की नकल करता है:

.#.|.#...|...#..#
 A B     C      D

दर्पण Cआइटम को डुप्लिकेट नहीं कर सकता A, क्योंकि दर्पण Bरास्ते में है। यह आइटम को डुप्लिकेट भी नहीं कर सकता है D, क्योंकि दर्पण Bदूसरी तरफ है। इसी तरह, दर्पण Bआइटम को डुप्लिकेट नहीं कर सकता है Dया उसके बगल में डुप्लिकेट नहीं कर सकता है, क्योंकि दर्पण Cरास्ते में है, इसलिए यह सही आउटपुट है।

एक अन्य उदाहरण के लिए, इनपुट पर विचार करें

.##..#...|#..##...|..##....#.
 AB  C   DE  FG   H  IJ    K

मिरर Dनकल कर सकते हैं Aऔर Bसही करने के लिए, और Eऔर Gके लिए छोड़ दिया। Cऔर Fपहले से ही एक दूसरे के डुप्लिकेट हैं। तार बन जाता है

.##.##..#|#..##.##|..##....#.
 AB  C   DE  FG   H  IJ    K

मिरर Hनकल कर सकते हैं E, Fऔर के डुप्लिकेट Aऔर Bकरने का अधिकार है, और Iबाईं ओर। Gऔर Jपहले से ही एक दूसरे के डुप्लिकेट हैं, और दर्पण Dके रास्ते में है K। अब हमारे पास है

.##.##..#|#..#####|#####..##.
 AB  C   DE  FG   H  IJ    K

अंत में, दर्पण बाईं ओर के Dडुप्लिकेट की नकल कर सकता है I। हम साथ समाप्त करते हैं

.#####..#|#..#####|#####..##.
 AB  C   DE  FG   H  IJ    K

नियम और स्कोरिंग

आप एक पूर्ण कार्यक्रम या एक फ़ंक्शन लिख सकते हैं। सबसे कम बाइट गिनती जीतती है। सबमिशन जो रेगेक्स इंजन का उपयोग नहीं करते हैं, जो उन लोगों से अलग से प्रतिस्पर्धा करते हैं, और उन्हें (कोई रेगेक्स) चिह्नित नहीं किया जा सकता है ।

परीक्षण के मामलों

"|" -> "|"
"..|.." -> "..|.."
".#.|..." -> ".#.|.#."
"..#|.#." -> ".##|##."
".#..|....|.." -> ".#..|..#.|.#"
".|..|.#....." -> "#|#.|.#....."
"...|.#...|....#" -> ".##|##...|...##"
"......#|......." -> "......#|#......"
".#.|.....|......#" -> ".#.|.#...|...#..#"
".......|...#.##|...." -> "##.#...|...#.##|##.#"
"...#..||.......#..#...#" -> "...#..||.......#..#...#"
".##|.#....||#||......#|.#" -> ".##|##....||#||.....##|##"
".##..#...|#..##...|..##....#." -> ".#####..#|#..#####|#####..##."
".#|...||...|#...|..##...|#...." -> ".#|#..||.##|##..|..##..#|#..##"
"....#.|...#.|..|.|.....|..#......" -> "..#.#.|.#.#.|.#|#|#.#..|..#.#...."
"..|....|.....#.|.....|...|.#.|..|.|...#......" -> ".#|#...|...#.#.|.#.#.|.#.|.#.|.#|#|#..#......"

Comments

क्या हम इनपुट और / या आउटपुट के रूप में वर्णों की एक सरणी ले सकते हैं?

— कॉनर ओ'ब्रायन

@ ConorO'Brien नहीं, जब तक कि आपकी भाषा में स्ट्रिंग का प्राकृतिक प्रतिनिधित्व नहीं है।

— जर्बर्ग

Answer 1

रेटिना , 50 बाइट्स

+`([#.])(([#.])*\|(?>(?<-3>[#.])*))(?!\1)[#.]
#$2#

इसे ऑनलाइन आज़माएं! (पहली पंक्ति एक लाइनफ़ीड-पृथक परीक्षण सूट को सक्षम करती है।)

मुझे लगता है कि यह (कोई रेगेक्स) प्रस्तुत करने के विपरीत है।

व्याख्या

यह केवल एक रेगेक्स प्रतिस्थापन है, जिसे बार-बार लागू किया जाता है ( +जब तक कि स्ट्रिंग बदलना बंद न हो जाए। मैं यह सुनिश्चित करने के लिए बैलेंसिंग समूहों का उपयोग कर रहा हूं कि दो मिरर किए गए पोज़िशन दिए गए मिरर से एक ही दूरी पर हैं (बैकरेफ्रेंस ऐसा नहीं करेंगे, क्योंकि दोनों पक्षों पर सटीक स्ट्रिंग |भिन्न हो सकती हैं)।

([#.])            # Match and capture a non-mirror cell.
(                 # This will match and capture everything up to its corresponding
                  # cell so that we can write it back in the substitution.
  ([#.])*         #   Match zero or more non-mirror cells and push each one onto
                  #   group 3. This counts the distance from our first match to
                  #   the mirror.
  \|              #   Match the mirror.
  (?>             #   Atomic group to prevent backtracking.
    (?<-3>[#.])*  #     Match non-mirror while popping from group 3.
  )               #   There are three reasons why the previous repetition
                  #   might stop:
                  #   - Group 3 was exhausted. That's good, the next position
                  #     corresponds to the first character we matched.
                  #   - We've reached the end of the string. That's fine,
                  #     the last part of the regex will cause the match to fail.
                  #   - We've hit another mirror. That's also fine, because
                  #     the last part of the regex will still fail.
)
(?!\1)            # Make sure that the next character isn't the same as the first
                  # one. We're looking for .|# or #|., not for #|# or .|.
[#.]              # Match the last non-mirror character.

इसे बदल दिया जाता है, #$2#जिसके साथ मैच के पहले और अंतिम दोनों अक्षरों को बदल दिया जाता है #।

Answer 2

पर्ल, 49 बाइट्स

इसके लिए @Martin एंडर को पूरा श्रेय, जिन्होंने इस रेगेक्स 15 बाइट्स का सुझाव दिया है, जो मेरी तुलना में कम है।

कोड + -plझंडे के 47 बाइट्स

s/([.#])(\||[^|](?2)[^|])(?!\1)[^|]/#$2#/&&redo

इसे चलाने के लिए:

perl -plE 's/([.#])(\||[^|](?2)[^|])(?!\1)[^|]/#$2#/&&redo' <<< ".##..#...|#..##...|..##....#."

पहले ( ([.#])) और अंतिम ( (?!\1)[^|]) भाग रेटिना के उत्तर के समान हैं (वहां पर स्पष्टीकरण देखें)।
मध्य भाग ( (\||[^|](?2)[^|])) (?2)एक दर्पण ( \|) या ( |) दो नहीं-दर्पण-वर्णों ( [^|]) को एक ही पैटर्न से अलग करने के लिए perl recursion ( ) का उपयोग करता है (?2)।

---

मेरा पुराना (और बदसूरत) संस्करण: s/([.#])(([^|]*)\|(??{$3=~s%.%[^|]%gr}))(?!\1)[^|]/#$2#/&&redo

Answer 3

हास्केल (रेगेक्स नहीं), 117 बाइट्स

r=reverse
s=span(<'|')
m=zipWith min
g a|(b,l:c)<-s a,(d,e)<-s c=b++l:g(m(r b++[l,l..])d++e)|0<1=a
f x=m(g x)$r.g.r$x

Answer 4

PHP, 123 117 100 बाइट्स

for($t=$argv[1];$t!=$s;)$t=preg_replace("%([.#])(\||[.#](?2)[.#])(?!\g1)[.#]%","#$2#",$s=$t);echo$t;

कार्यक्रम कमांड लाइन तर्क लेता है, @Martin एंडर / दादा से लिया गया रेक्स। साथ चलाना -r।

Comments

@ ज़र्ब तय, धन्यवाद

— टाइटस

Answer 5

सी, 176 बाइट्स

void t(char*a){int x=0;for(int i=0;a[i];i++)if(a[i]=='|'){for(int j=x;a[j]&&j<=i*2-x;j++){if((a[j]==35)&&(a[2*i-j]==46)){a[2*i-j]=35;i=-1;}if((i-j)&&(a[j]=='|'))break;}x=i+1;}}

Ungolfed

void t(char*a)
{
    int x=0;
    for(int i=0;a[i];i++)
        if(a[i]=='|')
        {
            for(int j=x;a[j]&&j<=i*2-x;j++)
            {
                if((a[j]=='#')&&(a[2*i-j]=='.'))
                {
                    a[2*i-j]='#';
                    i=-1;
                    break;
                }
                if((i!=j)&&(a[j]=='|'))
                    break;
            }
            x=i+1;
        }
}

Comments

मुझे लगता है कि आप को बदल कर एक जोड़ी बाइट्स बचा सकता है '#'और '.'साथ 35और 46क्रमशः।

— कृत्रिम

यह कोड गोल्फ हो सकता है..एक बहुत।

— मुकुल कुमार

धन्यवाद ArtNull, कि 3 बचे बचाया। '|' 124 है, इसलिए इससे कुछ भी नहीं बचता (लेकिन शायद मुझे इसे बदलना चाहिए, इसलिए यह सुसंगत होगा; अभी तक निश्चित नहीं है)। और @ मकुल, मैं वास्तव में यह नहीं देखता कि बिना तर्क के परिवर्तन को कैसे बदला जाए।

— ईयाल लेव

जांचें कि क्या यह कोड ठीक चलता है x,i,j;void t(char*a){while(a[i]++)if(a[i]=='|'){for(j=x;a[j++]&&j<=i*2-x;j++){if((a[j]==35)&&(a[2*i-j]==46)){a[2*i-j]=35;i=-1;break;}if((i-j)&&(a[j]=='|'))break;}x=i+1;}}- 170 बाइट्स

— मुकुल कुमार

1more बाइट की जगह (i =! J) के साथ (ij) और यदि आप c ++ के साथ छड़ी करने जा रहे हैं तो कम से कम एक जगह पर सभी int को परिभाषित करें ...

— मुकुल कुमार

Answer 6

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

s=>s.replace(/#/g,(c,i)=>(g(i,-1),g(i,1)),g=(i,d,j=h(i,d))=>j-h(j=j+j-i,-d)|s[j]!='.'||(s=s.slice(0,j)+'#'+s.slice(j+1),g(j,d)),h=(i,d)=>s[i+=d]=='|'?i:s[i]?h(i,d):-1)&&s

Ungolfed:

function mirror(s) {
    for (var i = 0; i < s.length; i++) {
        // Reflect each # in both directions
        if (s[i] == '#') s = reflect(reflect(s, i, true), i, false);
    }
    return s;
}
function reflect(s, i, d) {
    // Find a mirror
    var j = d ? s.indexOf('|', i) : s.lastIndexOf('|', i);
    if (j < 0) return s;
    // Check that the destination is empty
    var k = j + (j - i);
    if (s[k] != '.') return s;
    // Check for an intervening mirror
    var l = d ? s.lastIndexOf('|', k) : s.indexOf('|', k);
    if (l != j) return s;
    // Magically duplicate the #
    s = s.slice(0, k) + '#' + s.slice(k + 1);
    // Recursively apply to the new #
    return reflect(s, k, d);
}