নির্দেশ প্রদান

15

চ্যালেঞ্জ

আপনি কোনও বন্ধুর কাছে একটি মানচিত্র দিয়েছেন যা দেখতে দেখতে এটির মতো দেখাচ্ছে:

      |
      /
     |
     /
    |
    \
     |
     \
      D

একটি সাধারণ মানচিত্র যা শীর্ষে শুরু হয় এবং নীচে শেষ হয়। দুঃখের বিষয়, আপনার বন্ধু এটি পায় না। আপনি মানচিত্রটি ডিকোড করতে পারেন যাতে তিনি এটি পড়তে পারেন?

ইনপুট

ইনপুট গঠিত অক্ষরের একটি স্ট্রিং |, /, \, D, ^, Y, (স্থান) , এবং নতুন লাইন।

  • | একই কলামে থাকতে বলে।
  • \ কলামে ডান এবং নীচে 1 এ যেতে বলে।
  • / কলামে বাম দিকে এবং নীচে 1 এ যেতে বলে।
  • D গন্তব্য চিহ্নিত করে।
    • ^ (যদি উপস্থিত থাকে) পথে বিভক্ত হওয়ার কথা বলে।
    • Y(যদি উপস্থিত থাকে) আবার পথের পুনরায় যোগদানের কথা বলে। এটির মতো চিকিত্সা করুন |।

ইনপুটটি এমনভাবে সাজানো হবে যাতে এটি এক ধরণের পথ তৈরি করে:

   |
   |
   \
    |
    ^
   / \
  /   |
 D    |

দুটি পথের মধ্যে সর্বদা একটি স্থান থাকবে এবং সমস্ত পাথ হয় পুনরায় যোগদান করবে বা ইনপুটটির শেষ লাইনে পৌঁছাবে। প্রতি ম্যাপে কেবল একটি বিভাজন থাকবে। ইনপুট মানচিত্রের দৈর্ঘ্যের কোনও সীমা নেই। দু'বারের বেশি পথ আর কখনও হবে না।

আউটপুট

আউটপুট দিকের একটি স্ট্রিং হওয়া উচিত।

  • " এল " আপনার বন্ধুকে এল ইফিট সরানো এবং 1 ধাপ এগিয়ে যেতে বলা উচিত ।
  • " আর " আপনার বন্ধুকে আর ight সরানো এবং 1 ধাপ এগিয়ে যেতে বলা উচিত ।
  • " এফ " আপনার বন্ধুকে 1 ধাপ এগিয়ে যেতে বলা উচিত।

ইনপুট উদাহরণ মানচিত্রের জন্য, আউটপুট নিম্নলিখিত হবে:

F F L F R R R

নোট করুন যে আপনার বন্ধুটি মানচিত্রের শীর্ষে শুরু হচ্ছে এবং মানচিত্রটির নীচে মুখোমুখি। তাঁর দৃষ্টিকোণ থেকে দিকনির্দেশ দিন। "^" এর উদাহরণস্বরূপ, আপনার প্রোগ্রাম অবশ্যই গন্তব্য (ডি) দিকে যাওয়ার পথ বেছে নিতে সক্ষম হবে। যদি দুটি পাথ পুনরায় সমন্বিত হয়, তবে আপনার প্রোগ্রামটিকে অনুসরণ করার জন্য অবশ্যই সোজাতম পথ (সর্বাধিক |গুলি সহ একটি) বেছে নিতে হবে। দিকগুলি অবশ্যই স্পেস দিয়ে আলাদা করতে হবে এবং ডি তে শেষ হতে হবে ।

উদাহরণ

ইনপুট

      |
      |
      \
       \
        ^
       / |
      |  |
      \  |
       \ \
        \ \
         \ /
          Y
          D

আউটপুট

F F L L L F F F L L R F

যেহেতু বাম দিকের পাথটিতে কেবল ১ টি রয়েছে |, তাই আমরা 3 টি থাকা ডানদিকের পথটি ব্যবহার করি।

ইনপুট

\
 |
 /
|
\
 |
 /
D

আউটপুট

L F R F L F R

ইনপুট

    /
   \
    /
   \
    ^
   \ \
    D \

আউটপুট

R L R L R L

অন্যান্য বিস্তারিত

  • এটি কোড গল্ফ, সুতরাং আগামী বুধবার, 19 ই আগস্টের মধ্যে সংক্ষিপ্ত কোড সহ ব্যক্তিটি জিতে যায়।
  • গঠনমূলক প্রতিক্রিয়া স্বাগত এবং ব্যাপকভাবে প্রশংসা।
  • আংশিকভাবে লুকানো ট্রেজারে একটি মানচিত্র দ্বারা অনুপ্রাণিত
  • আরও সৃজনশীল কিছুতে শিরোনামটি নির্দ্বিধায় পরিবর্তন করুন।
  • আমি যদি ভুল করে ফেলেছি তবে সেগুলি সংশোধন করুন।
  • এবং অবশ্যই, মজা আছে।

ধন্যবাদ!

কিছুটা দেরি হতে পারে, তবে জাভাস্ক্রিপ্টে উইন্ডোজ কোডিং হ'ল UndefinedFunction! যারা প্রবেশ করেছে তাদের সবাইকে ধন্যবাদ। অন্য কোনও এন্ট্রি গ্রহণ করা হবে না।

code-golf 
— The_Basset_Hound
সূত্র
এটি এখনও বন্ধ মনে হচ্ছে। প্রথম উদাহরণটি শেষ হয় L L, যা আমি মনে করি L L L। উদাহরণ সহ Yএখনও একটি 1শেষে আছে এবং অন্যান্য ত্রুটি আছে বলে মনে হয়। আমি মানচিত্রটি F F R R R F F F R R L Fএমনভাবে পড়েছি যেন আমি নিয়মগুলি সঠিকভাবে বুঝতে পারি।
— মার্টিন ইন্ডার
@ মার্টিনব্যাটনার আপনার ডি-তে শেষ হওয়ার কথা, আপনার কেবল 2 এলএস প্রয়োজন হবে। 3 এল ডি যেতে হবে ডি
— দ্য_ব্যাসেট_আউন্ড
2
শেষ লাইনে পৌঁছানোর আগে কোনও পথ কি কখনও কোনও শেষ প্রান্তে পৌঁছতে পারে? বা সমস্ত পাথ ইনপুটটির শেষ লাইনে পৌঁছে যাবে?
— জ্রিখ
@BassetHound এক করা উচিত হবে না Lজন্য ^এবং দুই Lদুই জন্য /? এবং আপনি উদাহরণের Fশেষে আরও দুটি যুক্ত করলেন কেন Y?
— মার্টিন ইন্ডার
পছন্দ করুন
— দ্য_বাসেট_হাউন্ড

উত্তর:

5

জাভাস্ক্রিপ্ট (ES6), 261 248 252 248 212 বাইট

যেহেতু শুধুমাত্র একটি বিভাজন সমর্থন করতে হবে:

s=>(s=s.replace(/ /g,o="",d=0).split(`
`)).map((v,j)=>{if(v=="^")for(v="/\\";(w=s[++j])&&(x=w[1]);d=x=="D"?1:w[0]=="D"?0:x>"{"?d+1:w[0]>"{"?d-1:d);o+=(p=v[d>0?1:0]||v[0])<"0"?"R ":p<"E"?"":p=="\\"?"L ":"F "})?o:o


তবে, 240 বাইট এবং আমরা একাধিক বিভাজনগুলি মোকাবেলা করতে পারি:

s=>(s=s.replace(/ /g,o="").split(`
`)).map((v,j)=>{if(!v[1])t=d=0
else if(!t){for(t=1;(w=s[++j])&&(x=w[1]);d=x=="D"?1:w[0]=="D"?0:x>"{"?d+1:w[0]>"{"?d-1:d);o+=d>0?"L ":"R "}o+=(p=v[d>0?1:0])<"0"?"R ":p<"E"||p=="^"?"":p=="\\"?"L ":"F "})?o:o


উভয় প্রোগ্রাম বেনামী ফাংশন সংজ্ঞায়িত।

ব্যবহার করতে, ফাংশন (গুলি) যুক্ত করে একটি নাম দিন f= কোডের আগে ।

পরে, তাদের সাথে কল করা যেতে পারে

alert(f(
`   |
   |
   \\
    |
    ^
   / \\
  /   |
 D    |`
))


ব্যাখ্যা

(পুরানো তবে এখনও একই ধারণা। একাধিক বিভক্ত সমাধানের জন্য)

s=>
    //Remove all spaces from the input
    (s=s.replace(/ /g,o="",
                 //Define function c, to convert symbols to directions
                 c=p=>p<"0"?"R ":p<"E"||p=="^"?"":p=="\\"?"L ":"F "
    //Split input into an array by newlines
    ).split(`
`))
    //for each string v in the input array, at index j:
    .map((v,j)=>{
        //if v is only one character long:
        if(!v[1]){
            t=1     //assign t to 1 (true) - we need to test if multiple paths
            d=0     //assign d to 0 - reset the counter for determining shortest path
        }
        //if v is two characters long, and we have not tested which path is shorter yet:
        else if(t){
            for(    t=0;    //assign t to 0 - we will have tested which path is longer

                    //for each string left in the input, while the input still has two characters:
                    (w=s[++j]) && w[1];
                    //assign d to determine which direction to go. This will be conveyed by if d>0
                    d=
                        w[1]=="D"?1:    //if the dest. is only on one side, choose that side.
                        w[0]=="D"?0:
                        w[1]=="|"?d+1:  //otherwise add/subtract from d (like a tug of war) to determine which side has more "|"
                        w[0]=="|"?d-1:
                        d
               );
            o+=d>0?"L ":"R "    //append to the output which direction was taken
        }

        o+=c(v[d>0?1:0])    //append to the output the characters from the correct path in any case, determined by d calculated above 
                            //(or defaulting to 0, if path is not split, in which case the only character is appended)

    }) ? o : o  //coerce the result, which will evaluate to an array of the input, to the output (o) and implicitly return


মন্তব্য

  • ইনপুটটিতে থাকা সমস্ত ব্যাকস্ল্যাশ ( \) এড়িয়ে চলেছে\\ , যাতে জাভাস্ক্রিপ্ট তাদের সনাক্ত করতে পারে।

  • উভয় আউটপুট একটি পিছনে স্থান রয়েছে।

— jrich
সূত্র
এটি ড্যাং, ভেবেছিলাম আমার সব ঠিক আছে।
— দ্য_বাসেট_আউন্ড
9

পিএইচপি, 634 631 607 396 382 381 347 338 330 337 324 বাইট

আমার প্রথম গল্ফ তাই নম্র হতে। কোনও টিপস প্রশংসা করা হয়।

<?php
foreach(str_split(strtr(fgets(STDIN),[' '=>'']))as $i){if($i!=D){$z=$i=='^';$x=$i==Y;$s=!$z&&!$x?($i=='/'?R:($i=='|'?F:($i=='\\'?L:$s))):$s;$a.=$z?R:($x?F:(($c==1||!$c)?$s:''));$b.=$z?L:($x?F:(($c==2||!$c)?$s:''));$c=$z?1:($x?0:($c==1?2:($c==2?1:$c)));}else{echo(substr_count($a,F)<substr_count($b,F)&&$c==0||$c==2)?$b:$a;}}

সংক্ষিপ্ত বিবরণ: ইনপুটটির
কেবল একটি পাথ থাকলে আমার একটি গুন আছে। যখন পথটি বিভক্ত হয় তখন বাম পথের জন্য গণনা 1 এবং সঠিক পথের জন্য 2 হয়। উভয় পাথ (বা শুধুমাত্র একটি) সংজ্ঞায়িত করার পরে আমি পরীক্ষা করেছি যে কোন পথে আরও "এফ এর" রয়েছে।

অবরুদ্ধ সংস্করণ: 

<?php
$input = fgets(STDIN);
$inputArray = str_split($input);
foreach ($inputArray as $currentChar) {
    if ($currentChar != 'D') {
        if ($i == '^') {
            $firstPath .= 'R';
            $secondPath .= 'L';
            $count = 1;
        } elseif ($i == 'Y') {
            $secondPath .= 'F';
            $firstPath .= 'F';
            $count = 0;
        } else {
            if ($i == ' ') {
                continue;
            }
            if ($i == '/') {
                $direction = 'R';
            } else {
                if ($i == '|') {
                    $direction = 'F';
                } else {
                    if ($i == '\\') {
                        $direction = 'L';
                    } else {
                        $direction = '';
                    }
                }
            }
            if ($count == 1) {
                $firstPath .= $direction;
                $count = 2;
            } elseif ($count == 2) {
                $secondPath .= $direction;
                $count = 1;
            }
            if (!$count) {
                $firstPath .= $direction;
                $secondPath .= $direction;
            }
        }
    } else {
        echo (substr_count($firstPath, 'F') < substr_count($secondPath, 'F')) || $count == 2 ? $secondPath : $firstPath;
    }
};


লগ:
কমহামেহাকে ধন্যবাদ 36 বাইট সংরক্ষণ করা।
যুক্তিটি কিছুটা পরিবর্তন করে অনেকগুলি বাইট সংরক্ষণ করেছেন।
অক্ষরেখায় ধন্যবাদ 42 বাইট সংরক্ষণ করা হয়েছে।
টেরিনারি অপারেটরগুলির সাথে স্ট্যাটমেন্ট যদি প্রতিস্থাপিত হয়।

— jrenk
সূত্র
3
সাইটে স্বাগতম!
— isaacg
2
$a=$b='';পরিবর্তে আপনি চেষ্টা করতে পারেন - $a='';$b='';প্রায় 3 বাইট সংরক্ষণ করে।
— কামেহেহেহা
1
এছাড়াও, মত সংমিশ্রণ $a=$a.'L ';হ্রাস করা যেতে পারে $a.='L '। আপনি এটি বেশ কয়েকটি জায়গায় করেছেন বলে মনে হয়। এটি প্রায় 6 বাইট সংরক্ষণ করবে :)
— কামাহেমেহা
1
আমি পিএইচপি খুব ভাল জানি না, তবে আমি বিশ্বাস করি যে আপনি আপনার ভবিষ্যদ্বাণীতে ( foreach($e as$i)) হিসাবে "স্থান" পরে স্থানটি ফেলে দিতে পারেন ; আমি এটি পরীক্ষা করেছি এবং এটি ঠিকঠাকভাবে কাজ করে বলে মনে হচ্ছে।
— প্রোগ্রামফক্স
1
এক দম্পতি আরো টিপসের কয়েক বাইট সংরক্ষণ করতে, যেমন @ProgramFox সম্পর্কে উল্লিখিত asমধ্যে foreachমধ্যে শূণ্যস্থান echoএবং পরিবর্তনশীল নাম যাতে আপনি আছে মুছে ফেলা হতে পারে echo$b। এছাড়াও, সমতা পরীক্ষা দুয়েক খুব খাটো হতে পারে, $c==0হতে পারে !$cএবং সেই বিষয়টিই কিনা তা, আপনি ইনিশিয়ালাইজ করতে $cকরতে ''সঙ্গে $aএবং $b!
— ডম হেস্টিংস
3

পিএইচপি, 281 বাইট

$b=0;$p=['|'=>'$a[$b].="F ";$f[$b]++;','/'=>'$a[$b].="R ";','\\'=>'$a[$b].="L ";','^'=>'$d.=$a[0];$n=2;$a=["R ","L "];$f=[];$b=1;','Y'=>'$d.=$a[$f[0]<$f[$n=1]]."F ";$a=[];','D'=>'$d.=$a[$b];exit(rtrim($d));'];foreach(str_split($argv[$n=1])as$c){if($x=$p[$c]){eval($x);$b=++$b%$n;}}

এটি দুটি গল্ফিং পুনরাবৃত্তির ফলাফল। অবরুদ্ধ সংস্করণটি হ'ল:

$a=$f=[];       // these assignments are not required (they were suppresed in v2)
$n=1;           // this assignment can be squeezed into $argv[$n=1]
$b=0;           // if this assignment is suppressed $b becomes '' and breaks the logic
$code = [
    '|' => '$a[$b].="F ";$f[$b]++;',
    '/' => '$a[$b].="R ";',
    '\\'=> '$a[$b].="L ";',
    '^' => '$d.=$a[0];$n=2;$a=["R ","L "];$f=[];$b=1;',
    'Y' => '$d.=$a[$f[0]<$f[$n=1]]."F ";$a=[];',
    'D' => '$d.=$a[$b];echo(rtrim($d));',
];
foreach (str_split($argv[1]) as $char) {
    // ignore input characters not in the keys of $code
    if ($x = $code[$char]) {
        eval($x);
        $b = ++ $b % $n;   // cycles between 0 and 1 ($n == 2) or stays 0 ($n == 1)
    }
}

এটি নিজেই গল্ফড এবং এটি নিম্নলিখিত গল্ফযুক্ত প্রোগ্রামের উন্নতি হিসাবে আবির্ভূত হয়েছে (৩১২ বাইট):

$b=0;foreach(str_split($argv[$n=1])as$c){if($c=='|'){$a[$b].='F ';$f[$b]++;}elseif($c=='/'){$a[$b].='R ';}elseif($c=='\\'){$a[$b].='L ';}elseif($c=='^'){$d.=$a[0];$n=2;$a=['R ','L '];$f=[];$b=1;}elseif($c==Y){$d.=$a[$f[0]<$f[$n=1]].'F ';$a=[];}elseif($c==D){$d.=$a[$b];exit(rtrim($d));}else continue;$b=++$b%$n;}

এটি মূলটির গল্ফযুক্ত সংস্করণ:

$map = $argv[1];

$dir = '';              // the already computed directions
$nb = 1;                // the number of branches
$branches = [ '' ];     // the branches (2 while between '^' and 'Y', 1 otherwise)
$nbF = [ 0, 0 ];        // the number of 'F's on the branches (used to select the branch)
$curr = 0;              // the current branch
foreach (str_split($map) as $char) {
    if ($char == '|') {             // go 'F'orward
        $branches[$curr] .= 'F ';       // put it to the current branch
        $nbF[$curr] ++;                 // count it for the current branch
    } elseif ($char == '/') {       // go 'R'ight
        $branches[$curr] .= 'R ';
    } elseif ($char == '\\') {      // go 'L'eft
        $branches[$curr] .= 'L ';
    } elseif ($char == '^') {       // fork; choose the path ('L' or 'R') that contains the most 'F'orward segments
        $dir .= $branches[0];           // flush the current path (it was stored as the first branch)
        $nb = 2;                        // start two branches
        $branches = [ 'R ', 'L ' ];     // put the correct directions on each branch
        $nbF = [ 0, 0 ];                // no 'F's on any branch yet
        $curr = 1;                      // need this to let it be 0 on the next loop
    } elseif ($char == 'Y') {       // join
        $dir .= $branches[$nbF[0] < $nbF[1]];   // flush; choose the branch having the most 'F's
        $dir .= 'F ';                           // treat it like a "|"
        $branches = [ '' ];                     // back to a single, empty branch
        $nb = 1;
    } elseif ($char == 'D') {       // finish
        $dir .= $branches[$curr];       // flush
        break;                          // and exit; could use 'return' but it's one byte longer; use exit() in the final program and save 5 bytes
    } else {
        continue;
    }
    $curr = ++ $curr % $nb;
}
echo rtrim($dir);

উদাহরণ কার্যকর:

$ php -d error_reporting=0 directions.php '
      |
      |
      \
       \
        ^
       / |
      |  |
      \  |
       \ \
        \ \
         \ /
          Y
          D
'; echo
F F L L L F F F L L R F
$

এটি একাধিক কাঁটাচামচও সঠিকভাবে পরিচালনা করে (যে কোনও সময় সর্বাধিক দুটি শাখা থাকার জন্য পরবর্তী কাঁটাচামড়ার আগে যোগদানের প্রয়োজন)। আমি একটি মন্তব্যে একাধিক কাঁটাচামচ সম্পর্কে জিজ্ঞাসা করেছি তবে উত্তরটি ("প্রয়োজন নেই") এলে কোডটি ইতিমধ্যে হয়ে গিয়েছিল।

পরীক্ষার স্যুট এবং আরও মন্তব্য সহ সম্পূর্ণ কোডটি গিথুবে পাওয়া যাবে ।

— axiac
সূত্র
বাহ ভাল কাজ! আমার এখনও বেশ কয়েকটি জিনিস শিখতে হবে!
— জেরেঙ্ক
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.