ম্যাজিক মিরর পাগলামি

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

আমরা কি ইনপুট এবং / অথবা আউটপুট হিসাবে অক্ষরের অ্যারে নিতে পারি?

— কনর ও'ব্রায়েন

@ কনরও ব্রায়ান না, যদি না এটি আপনার ভাষায় কোনও স্ট্রিংয়ের প্রাকৃতিক প্রতিনিধিত্ব না করে।

— Zgarb

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 বাইট

@ মার্টিন ইেন্ডারে সম্পূর্ণ ক্রেডিট এই একজনের জন্য যিনি এই আমার চেয়ে 15 বাইট কম খাটো করে বলেছিলেন।

কোড + -plপতাকা 47 বাইট

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

এটি চালানোর জন্য:

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

প্রথম ( ([.#])) এবং শেষ ( (?!\1)[^|]) অংশগুলি রেটিনা উত্তরের মতো (সেখানে ব্যাখ্যাটি দেখুন)।
মাঝের অংশটি ( (\||[^|](?2)[^|])) পার্ল রিকার্সন ( ) ব্যবহার করে (?2)মিরর ( \|) বা ( |) দুটি নয়-মিরর-অক্ষর ( [^|]) একেবারে একই প্যাটার্ন ( (?2)) দ্বারা পৃথক করে match

---

আমার পুরানো (এবং কুশলী) সংস্করণ: 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

পিএইচপি, 123 117 100 বাইট

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

প্রোগ্রামটি কমান্ড লাইন আর্গুমেন্ট গ্রহণ করে, @ মার্টিন ইন্ডার / দাদার কাছ থেকে নেওয়া রেজিজেস। সাথে চালাও -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

আমি মনে করি আপনি প্রতিস্থাপন করে এবং যথাক্রমে '#'এবং একটি জোড় বাইট সংরক্ষণ করতে পারেন । '.'3546

— artificialnull

এই কোডটি গল্ফ করা যেতে পারে ... প্রচুর।

— মুকুল কুমার

ধন্যবাদ কৃত্রিমনুল, এটি 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;}}

— মুকুল কুমার

1 মোর বাইট প্রতিস্থাপন (i! = J) (ij) এর সাথে এবং আপনি যদি সি ++ দিয়ে আটকে যাচ্ছেন তবে ন্যূনতম এক জায়গায় সমস্ত সংজ্ঞা সংজ্ঞায়িত করুন ...

— মুকুল কুমার

Answer 6

জাভাস্ক্রিপ্ট (ES6), 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);
}