গ্র্যাভিটি গাই কি এটি তৈরি করতে পারে?

Question

মাধ্যাকর্ষণ গাই একটি গেম যেখানে একমাত্র ব্যবহারকারী ইনপুটটি একটি একক কী যা মাধ্যাকর্ষণটির দিকটি পিছলে fl একটি এএসসিআইআই আর্ট স্তর দেওয়া হয়েছে, গ্র্যাভিটি গাইয়ের শেষে পৌঁছানো সম্ভব কিনা তা নির্ধারণ করুন।

---

বিধি

• মাধ্যাকর্ষণ প্রাথমিক দিক নিচে ।
• ইনপুটটির প্রথম কলামে সর্বদা কেবল একটিই থাকবে # যা গ্রাভিটি গাই শীর্ষে শুরু হয় ।
• প্রতিটি পুনরাবৃত্তি, তিনি সরাসরি তার ডানদিকে অক্ষর সরানো ।
• যদি তার পথ অবরুদ্ধ থাকে এবং সে একটিতে চলে যায় #তবে প্লেয়ার হেরে যায় ।
• সরানোর পরে, প্লেয়ারটি মহাকর্ষটিকে নিচ থেকে উপরে বা উপরে পর্যন্ত স্যুইচ করতে পারে।
• গ্র্যাভিটি গাই তার পরের দিকে# (মহাকর্ষের বর্তমান দিকে) পড়ে যায়।
• যদি পড়তে না# হয় এবং সে গ্রিড থেকে পড়ে তবে প্লেয়ার হেরে যায় ।
• যদি গ্র্যাভিটি গাই ইনপুট গ্রিডের ডান দিক থেকে সরে যায় তবে প্লেয়ার জিতবে ।

উদাহরণ

এটি যদি ইনপুট গ্রিড হত:

  ### 

#  # #
 ###  

মাধ্যাকর্ষণ গাই শুরু হবে xএবং প্রতিটি পুনরাবৃত্তির পরে এই পজিশনে থাকবে। ^= মাধ্যাকর্ষণটিকে উপরে vস্যুইচ করুন এবং = মাধ্যাকর্ষণটিকে নীচে স্যুইচ করুন।

v                        ^                               v
-------------------------------------------------------------
  ###   |    ###   |    ###   |    ###   |    ###   |    ### 
x       |          |    x     |     x    |      x   |        
#  #    |  #x #    |  #  #    |  #  #    |  #  #    |  #  # x
 ### #  |   ### #  |   ### #  |   ### #  |   ### #  |   ### #

আপনি দেখতে পাচ্ছেন, এই সময়ে মহাকর্ষ পরিবর্তন করে গ্র্যাভিটি গাই প্রান্তে পৌঁছেছে, সুতরাং এই ইনপুটটি সত্যবাদী মান ফিরে আসবে।

বিশেষ উল্লেখ

• ইনপুট গ্রিড যে কোনও উপযুক্ত "গ্রিড" ফর্ম্যাটে থাকতে পারে (একাধিক স্ট্রিং স্পেস সহ প্যাডযুক্ত, রেখার স্ট্রিংগুলির অ্যারে, অক্ষরের অ্যারে ইত্যাদি)।
• যদি প্লেয়ারের পক্ষে স্তরটি জয় করা সম্ভব হয় তবে একটি truthyমান আউটপুট করুন । যদি না falseyহয় তবে একটি মান আউটপুট করুন ।
• গ্রিডের প্রস্থ এবং উচ্চতা 50সর্বাধিক অক্ষর হবে ।
• এটি কোড-গল্ফ , বাইটের মধ্যে সংক্ষিপ্ততম কোডটি জয় পেতে পারে!

পরীক্ষার মামলা

(প্রতিটি কেস পৃথক করে আলাদা করে ----------রাখলে, কোনও ফাঁকা রেখাও ফাঁকা জায়গায় প্যাড করা উচিত)

সত্য

 #########   ########      ######     ######    
          #  #       #    #      #   #      #   
###    #   # #    #   #  #       #  #        #  
  #    ##  # #    ##  # #     # #  #      ##    
  #    #   # #    #   # #    #     #     #######
  #       #  #       #  #     ###  #          # 
  #    ##    #    ##     #       #  #         # 
  #    #          #              #        #   # 
  #    ####################################   # 
  #                                           # 
  ############################################# 

----------


###

----------

   #####

####    

----------

 #####
 # # #

# # # 
 #####

----------

   ############   

######      ######

   ############   

----------

  ###   ###  
     # #     
####  #  ####
    #   #    
     # #     
      #      

----------

    ######  
   #        
 ##         
     #######
###     #   
   #    #   
    #####   


----------

    #####   
   #    #   
 ##     #   
     #######
###         
   #        
    ######  

----------

  ### 

#  # #
 ###  

----------

  ###  ###

###     ##
   #    # 
    ##### 

----------

  #        
     #   # 
       #   
#   #     #
        #  
   #       
      #    
 #         

----------

    ##### ####   
   #     #    #  
  #   # #  ##  # 
             #  #
#####  ####   #  
               # 
     #########   

----------

 ########################### 
 #   #   #   #     #   #   # 
 # # # #   #   # #   #   # # 
 # # # ######### ########### 
 # # # #  #       #     #  # 
   # # # ## ##### ### #      
## #   #    #          ## ###
 # ##### #### ###########  # 
 # #     #  #     #     ## # 
 # # #####  ### # # # # #  # 
 #              #   # #   ## 
 ########################### 

মিথ্যা

 ###
   #
####

----------


### ###

----------

    #   
 ### ###

#### ###
    #   

----------

  ###     ###  
     # # #     
####  # #  ####
    #     #    
     #   #     
      # #      
       #       

----------

  ####### 
  #     # 
 ## ##### 

### ######
  #     # 
  ####### 

----------

 ########################### 
 #   #   #   #  #  #   #   # 
 # # # #   #   # #   #   # # 
 # # # ######### ########### 
 # # # #  #       #     #  # 
   # # # ## ##### ### #      
## #   #    #          ## ###
 # ##### #### ###########  # 
 # #     #  #     #     ## # 
 # # #####  ### # # # # #  # 
 #              #   # #   ## 
 ########################### 

Comments

আমরা কলামার ফর্ম্যাটে গ্রিড অনুমোদিত?

— নীল

@ নীল আপনার অর্থ পরিবহন / ঘোরানো অ্যারে? আমি না বলতে যাচ্ছি, যেহেতু এটি ইনপুটটি পরিবর্তন করছে। তবে আপনার ভাষার যদি কোনও বিশেষ columnধরণের থাকে তবে এটি অনুমান করা ঠিক হবে।

— ব্যবহারকারী 81655

#প্রথম কলামে প্রথম সারিতে থাকা কি সম্ভব ?

— ফেয়ারসাম

@ ফেয়ারসাম না, গ্রিডটি গ্র্যাভিটি গাইয়ের জন্য "দাঁড়ানোর" জন্য স্থান অন্তর্ভুক্ত করতে পারে

— ব্যবহারকারী81655

লজ্জা; স্থানান্তর আমার বাইট গণনা 20% বৃদ্ধি করে।

— নীল

Answer 1

শামুক , 15 বাইট

অনলাইনে চেষ্টা করে দেখুন?

^
\ n\ ,=\#r}+~

0 ^এমন একটি বিকল্প যা প্যাটার্নটির উপরের বাম দিকে শুরু করতে হবে।

1. \ ​: ম্যাচ স্পেস

2. n: যে কোনও দিকে 90 ডিগ্রি ঘুরিয়ে দিন

3. \ ,​: স্পেস শূন্য বা আরও বেশি বার মিলবে

4. =\##আমাদের সামনে একটি আছে দেখুন

5. r: ডানদিকে দিক নির্ধারণ করুন

6. }+: পূর্ববর্তী সমস্ত এক বা একাধিকবার করুন

7. ~ গ্রিডের বাইরে থাকা একটি ঘরের সাথে মেলে

Comments

এটি বেশিরভাগ সত্য পরীক্ষার ক্ষেত্রে 0 দেয়

— বাসড্রপ কম্বারবুবউবউব

@ বাস আপনি কি ফাঁকা ফাঁকা ফাঁকা লাইনে প্যাড করেছেন?

— মার্টিন এন্ডার

@ মার্টিনবাটনার আমি কিছু ইনপুট সরাসরি অনুলিপি করেছিলাম, এটি করে সত্যই কিছু স্থান সরিয়ে নিয়েছে। এটি স্পেস যুক্ত করার পরে সত্যই কাজ করে

— বাসড্রপ কম্বারবুবউবউব

যেহেতু কেউ এখনও এটি বলেনি: এটি দুর্দান্ত!

— DLosc

Answer 2

পার্ল, 93 89 81 77 76 75 74 বাইট

জন্য +2 অন্তর্ভুক্ত -0p

এসটিডিআইএন-এ ইনপুট প্যাটার্ন (সমস্ত লাইন স্পেস একই দৈর্ঘ্যে প্যাডযুক্ত) দিয়ে চালান:

gravity.pl < gravity.txt

gravity.pl:

#!/usr/bin/perl -0p
/
/;$n=".{@-}";s/#$n\K( $n)*\b |(^|w)([w ]$n)*\K $n#/w|$&/es&&redo;$_=m;w

এই ফাইল ভিত্তিক সংস্করণটির চূড়ান্ত নিউলাইন দরকার, তাই এটি সত্যই 75 বাইট। তবে কমান্ডলাইন ভিত্তিক সংস্করণে সেই অতিরিক্ত নতুন লাইনের দরকার নেই সুতরাং এটি 74 বাইট হিসাবে গণ্য:

perl -0pe '/
/;$n=".{@-}";s/#$n\K( $n)*\b |(^|w)([w ]$n)*\K $n#/w|$&/es&&redo;$_=m;w' < gravity.txt

ব্যাখ্যা:

এটি wপ্রতিটি পজিশনে মাধ্যাকর্ষণ লোকটি পৌঁছাতে পারে এমন একটি দিয়ে একটি স্ট্রিং তৈরি করবে । সুতরাং দ্বিতীয় থেকে শেষ সত্যের উদাহরণটি এটি তৈরি করবে:

     #########   
    ##### ####   
   #wwwww#wwww#  
  #w  # #w ##ww# 
wwwww wwwwwww#ww#
#####  ####  w#ww
     wwwwwwwwww# 
     #########   

সুতরাং মহাকর্ষের লোকটি এটি তৈরি করতে পারে যদি কেবলমাত্র wসর্বশেষ কলামে থাকে। স্ট্রিংটি wপ্রতিটি রাউন্ডে একটি করে পৌঁছনযোগ্য স্থান প্রতিস্থাপন করে নির্মিত হবে ।

প্রতিটি প্রতিস্থাপন ফর্ম হতে হবে

s/prefix \K space postfix/ w | $& /e

যা দাবি করবে যে স্থানটি উপসর্গের আগে এবং পোস্টফিক্সের পরে রয়েছে তবে wপ্রচুর উন্নত গোষ্ঠীকরণের প্রয়োজন ছাড়াই কেবল স্থানটি প্রতিস্থাপন করবে ।

অনুমান করুন $nএকটি রেজেক্স রয়েছে যা বাম এবং ডান দিক একে অপরের নীচে ঠিক পর্যাপ্তভাবে অগ্রসর হবে। তারপরে প্রাসঙ্গিক রেজিক্সগুলি হ'ল:

/^( $n)*\K $n#/       From the first position drop down as long as you
                      encounter spaces until you encounter a #. 
                      This puts gravity guy on his starting platform

/#$n\K( $n)*\b /      A space immediately below a # and if you (optionally)
                      go down further from there (as as the descent is
                      over spaces) you get to a space that follows a word
                      boundary. The only way to get a word boundary is if 
                      there is a w in front of that space. This selects the
                      position gravity guy ends up on if starting from that
                      w and gravity is up
/w([w ]$n)*\K $n#/    A w followed by a space (or w) and if you go down from
                      there as long as it is over spaces (or w) you finally
                      end up on a space directly above a #. This handles the
                      gravity down case. The test uses "space or w" instead
                      of just space to handle this case:

                       #
                      ww
                      #x  
                       #

                      Position x is currently a space and must be replaced by a
                      w but the gravity up regex has already put a w directly
                      after the w gravity guy takes off from. So for gravity
                      down we must handle w as if it is still a space. This
                      is not needed for gravity up because regex always matches
                      starting at the earliest possible character, so 
                      gravity up matches before gravity down

প্রোগ্রামটি সহজ উপায়ের বাইরে:

#!/usr/bin/perl -0p   Slurp all of STDIN into $_, at the end print $_

/\n/                  Match the first newline (needed to measure the row
                      length)
$n=".{@-}"            $n effectively becomes rowlength-1 times ".". This
                      will be the regex that goes one step down a column

s/#$n\K( $n)*\b |(^|w)([w ]$n)*\K $n#/w|$&/es

                     This is the 3 regexes shown above combined. The s 
                     modifier is needed so the . in $n also matches newline

    &&redo           Keep looping as long as w's keep getting added

$_=m;w\n;            Check if the last column contains a w: He made it!
                     The \n; at the end is not written. These 2 bytes sneakily
                     come from the -p option for the ; and the -e option
                     for the \n

Answer 3

জাভাস্ক্রিপ্ট (ES6), 174 বাইট

a=>[...a[0]].map((_,i)=>[...t].map(x=>s[x]<'#'&&g(s.indexOf('#',x),-1)&&g(s.lastIndexOf('#',x),1),s=a.map(s=>s[i]),t=new Set),t=new Set([0]),g=(i,d)=>i<0||t.add(i+d))&&t.size

স্ট্রিংগুলির একটি অনুভূমিক অ্যারে নেয় এবং প্রস্থানস্থানগুলির সংখ্যা প্রদান করে। অ্যারে স্থানান্তর করতে আমার 29 বাইট খরচ হয়। Ungolfed:

function gravity(array) {
    var set = new Set;
    set.add(0); // starting point
    for (var i = 0; i < array[0].length; i++) {
        var s = array.map(s => s[i]); // transpose array
        var old = set;
        set = new Set;
        for (var x of old) {
            if (s[x] == '#') continue; // hit wall
            var j = s.indexOf('#', x); // try downward gravity
            if (j >= 0) set.add(j - 1);
            j = s.lastIndexOf('#', x); // try upward gravity
            if (j >= 0) set.add(j + 1);
        }
    }
    return set.size;
}

Answer 4

পিপ , 85 68 62 59 + 1 = 60 বাইট

স্টিডিনের -rসমস্ত লাইন পড়তে পতাকা ব্যবহার করে ।

FcZg{YlFxiIc@xQsyPB(Jc@<x@?`# *$`)+1PB(c@>x@?'#)+x-1i:UQy}i

এটি অনলাইন চেষ্টা করুন!

সংক্ষিপ্ত বর্ণনা

কৌশলটি মূলত একটি প্রস্থের প্রথম অনুসন্ধান। আমরা ইনপুট এবং লাইনগুলি (কলামগুলি) এর উপরে লুপটি স্থানান্তর করি, প্লেয়ারটি কলামে যে y- পজিশনে পৌঁছাতে পারে তার একটি তালিকা রেখে। খেলোয়াড় জিততে পারলে সর্বশেষ কলামের পরে আউটপুট হ'ল খালি তালিকা বা প্লেয়ার হেরে গেলে একটি খালি তালিকা (যা কেবল একটি ট্রেলিং নিউলাইন হিসাবে প্রিন্ট করে)।

সম্পূর্ণ ব্যাখ্যা

বিল্ট-ইন এই প্রোগ্রাম ব্যবহার করা ভেরিয়েবল: i == 0, l == [], s == " "।

-rপতাকা ইনপুট লাইনের মধ্যে একটি তালিকা রাখে g। FcZg{...}জিপ gএবং প্রতিটি কলামে লুপ c। (অ্যানারি Z, যখন পুনরাবৃত্তিযোগ্য তালিকার জন্য প্রয়োগ করা হয়, পাইথনের মতো কাজ করে, ঝরঝরে করে zip(*g)2 ডি অ্যারে স্থানান্তর করে)) দ্রষ্টব্য যে cতালিকাটি থাকবে, স্ট্রিং নয়।

কলামের লুপের অভ্যন্তরে, আমরা আনকিং yকরে খালি তালিকায় পুনরায় সেট Yকরি l। Fxiলুপ উপর i। পরবর্তী পুনরাবৃত্তিতে, iপ্লেয়ারটি পূর্ববর্তী কলামে পৌঁছাতে সক্ষম y- স্থানাঙ্কের একটি তালিকা হবে। প্রথমবারের মাধ্যমে, আমরা ঠিক 0(উপরের বাম কোণে) দিয়ে শুরু করতে চাই । ভেরিয়েবলটি 0কোনও তালিকা হিসাবে নয়, কোনও স্কেলারে প্রাক-প্রাক্কলিত হয় [0], তবে পাইপ এটির উপর দিয়ে পুনরাবৃত্তি করে either

শেষ কলামে প্রতিটি বৈধ পজিশনের জন্য, Ic@xQsবর্তমান কলামে সেই অবস্থানের কোনও স্থান আছে কিনা তা পরীক্ষা করে দেখুন। যদি তা না হয় তবে প্লেয়ারটি কেবল একটি প্রাচীরের মধ্যে চলে গেল এবং আমরা পরবর্তী সম্ভাবনার চেষ্টা করে যাচ্ছি। যদি তা হয়, তবে আমরা খেলোয়াড় মহাকর্ষের প্রতিটি দিকনির্দেশের জন্য এই কলামে পজিশনগুলি পজিশনের অবস্থানগুলি সন্ধান করতে চাই yএবং Push Back অপারেটরটি ব্যবহার করে তাদের তালিকায় যুক্ত করব ।

মাধ্যাকর্ষণ উপরে উঠছে (বাম দিকে, ট্রান্সপোজড সংস্করণে):

(Jc@<x@?`# *$`)+1
  c@<x             Slice everything left of x in the column
 J                 Join into a string so we can do a regex search on it
      @?`# *$`     Find index of the last # in this string
(             )+1  The player's index is the space below/to the right of this #

মাধ্যাকর্ষণ নীচে নেমে যাচ্ছে (ডানদিকে, ট্রান্সপোজড সংস্করণে):

(c@>x@?'#)+x-1
 c@>x              Slice everything right of x in the column
     @?'#          Find index of the first # in this list (no need to join into string)
(        )+x       Translate to index number in entire column
            -1     The player's index is the space above/to the left of this #

প্লেয়ারটি যদি কোনও নির্দিষ্ট দিক থেকে গ্রিড থেকে পড়ে যায় তবে সংশ্লিষ্ট @?ক্রিয়াকলাপটি খুঁজে পাবে না #এবং শূন্য করবে। এটি কোনও বৈধ সূচক নয় এবং পরবর্তী পুনরাবৃত্তিতে কিছু সতর্কতা উত্পন্ন করবে - যা -wপতাকা ব্যতীত দৃশ্যমান নয় । আমাদের উদ্দেশ্যে, এই মামলাগুলি মূলত বিবেচনা থেকে বাদ দেওয়া হয়।

অভ্যন্তরীণ লুপের পরে, আমরা যে অবস্থানগুলি তৈরি করেছি i:UQyতার তালিকা গ্রহণ করে y, সদৃশগুলি মুছে ফেলা এবং এটিকে নির্ধারিত করে i। (সদৃশগুলি অপসারণ করা প্রয়োজনীয় কারণ অন্যথায় তালিকার বেলুনগুলি তাত্ক্ষণিকভাবে।) আমরা তারপরে পরবর্তী কলামে যাই go যখন আমরা সমস্ত কলামগুলি iঘুরে দেখি , যদি সেখানে কোনও বৈধ পথ ছিল, তবে পজিশনের (সত্যবাদী) একটি অসাধারণ তালিকা হবে; যদি তা না হয় তবে এটি খালি তালিকা (মিথ্যা) হবে।