অফিসে পালানোর: আপনার পথের পরিকল্পনা!


32

এটি চূড়ান্ত স্প্রিন্ট ... এবং আপনার অর্ধেক দল অসুস্থ। আপনি দেরী করে কাজ করছেন, কেবল দিনের জন্য শেষ প্রতিশ্রুতিবদ্ধ করছেন, অপেক্ষায় রয়েছেন ... লাইট বন্ধ হয়ে গেছে কেন? সুরক্ষা লোকটি আমার চারপাশে আসা মনে পড়ে না ... ওরে না! আমি আমার চাবি বাড়িতে রেখেছি!

পরিস্থিতির ভয়াবহতা ডুবে যাওয়ার সাথে সাথে আপনি সিদ্ধান্ত নিলেন যে আপনি পালাতে চলেছেন

কার্যের সংক্ষিপ্তসার

আপনার পালানোর জন্য, আপনার একটি পরিকল্পনা প্রয়োজন! তবে, আপনি জানেন যে কোনও পরিকল্পনা ব্যর্থ হওয়ার সম্ভাবনা রয়েছে এবং বিভিন্ন পরিকল্পনার জন্য বিভিন্ন পরিমাণের প্রচেষ্টা প্রয়োজন।

ক্ষুধার্ত, ক্লান্ত এবং ইঞ্জিনিয়ার হওয়ার কারণে, জটিলতার হাত থেকে বাঁচার সর্বোত্তম উপায় নির্ধারণের জন্য আপনি একটি সংক্ষিপ্ত প্রোগ্রাম লেখার সিদ্ধান্ত নিয়েছেন, সাফল্যের সম্ভাবনার উদ্বেগ এবং এটির প্রয়োজনীয় প্রচেষ্টাগুলির উদ্বেগকে ভারসাম্যপূর্ণ করে।

আপনি ভবনের একটি মানচিত্র তৈরি করুন:

#######################
#                =    #
!                =    !    <-- window
#          !     =    #        (freedom!)
#################=    #
#    #           =    #
#    #           =    #
#    #           =    #
# o  !   # #  !  =    #
##|  !  ## #  !  =    #
#######################

  ^  ^           ^
  me my door     ludicrously high shelves
     (locked)    (climbable)

অফিস থেকে বাঁচতে আপনাকে মানচিত্র থেকে নিজেকে সরিয়ে নিতে হবে। এখানে আপনি দেখতে পেয়েছেন যে 2 টি উইন্ডোজ ( !) রয়েছে, যে কোনও একটি আপনাকে স্বাধীনতার দিকে নিয়ে যাবে, তবে এর মধ্যে একটি মাত্র অ্যাক্সেসযোগ্য। মানচিত্রের গণ্ডির বাইরে আপনার পা রয়েছে বলে আমরা 'মানচিত্রের বাইরে' সংজ্ঞায়িত করি

কোষের প্রকারগুলি

  - empty, you can be here (i.e. the escapee can consume this cell)
# - solid (your desk, your in-tray), you can't be here, but you can stand on it
! - destructible, (co-worker's desk, door, window), you can't be here until you smash it first (turning it into an empty cell)
= - climbable, (fire ladder, filing cabinet, etc.), you can be here

মূলত পলায়নকারীদের দ্বারা গৃহীত ঘরগুলি খালি থাকতে নেওয়া হয়।

ক্রিয়া বিশেষ উল্লেখ

আপনার ডিসপোজেবলে আপনার বেশ কয়েকটি সম্ভাব্য ক্রিয়া রয়েছে। এগুলি কয়েকটি পূর্ণসংখ্যার সাফল্যের সম্ভাবনার সাথে সাধারণ রাষ্ট্রীয় রূপান্তর দ্বারা সংজ্ঞায়িত হয়। উদাহরণস্বরূপ, হাঁটার জন্য, আপনি পালানো একটি কক্ষকে সরান, যা আমরা এই রূপান্তরটির সাথে প্রতিনিধিত্ব করি:

ধাপ

1 স্টপ, 100%, আয়না

 o.            o
 |.   -->      |
 #            #

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

"আয়না" অর্থ এই ক্রিয়াটির দুটি রূপ রয়েছে। "ডান" ক্রিয়াটি দেখানো হয়েছে, "বাম" ক্রিয়াটি একটি সঠিক আয়না, উদাহরণস্বরূপ:

.o
.|
 # 

এর আয়না (বাম) রূপ

o.
|.
# 

ডান ক্রিয়াটিকে "ডান" বলা হয় (উদাঃ "ধাপে ডান") বাম ক্রিয়াটিকে "বাম" বলা হয় (যেমন "পদক্ষেপ বাম")

এই চিত্রগুলিতে, পালানো দেখানো হয়

o
|

যখন দাঁড়িয়ে (2 ইউনিট লম্বা) এবং

%

ক্রচিংয়ের সময় (1 ইউনিট লম্বা) দৃ or় বা ধ্বংসাত্মক হতে হবে এমন ঘরগুলি হ্যাশ দ্বারা চিহ্নিত করা হয় #,। দৃ solid় বা ধ্বংসাত্মক হতে হবে না এমন কক্ষগুলি একটি বিন্দু দ্বারা নির্দেশিত .। ধ্বংসাত্মক হতে হবে এমন কক্ষগুলি একটি ঠুং শব্দ দ্বারা নির্দেশিত !। একটি সদ্য নির্মিত খালি স্থান একটি আন্ডারস্কোর দ্বারা দেখানো হয়েছে _xএকটি রেফারেন্স পয়েন্ট যা চলন্ত না (এটি বিদ্যমান নেই, সেই ঘরটি কী হবে সে সম্পর্কে কোনও বাধা নেই) একটি স্থানের মতো ) )।

দ্রষ্টব্য: আপনি যখন মেঝেতে আঘাত করবেন তখন আমরা দ্রুত হ্রাসের বিষয়টি উপেক্ষা করি এবং হ্যাঁ, এই গেমটিতে আপনি পুরোপুরি সিঁড়ির উপরে ঝাঁপিয়ে পড়তে পারেন)

ধাপ

1 স্টপ, 100%, আয়না

 o.         o
 |.  -->    |
x#        x#

চড়তে চলা

1 স্টপ, 100%, আয়না

 =         =
 o.  -->    o
 |.         |
x=        x= 

অদলবদল

3 স্টপ, 100%, আয়না

 %.         %
x#   -->  x# 

ক্লবার আপ

10 স্টপ, 95%, আয়না

 o.         %
 |#  -->    #
x#        x#

ড্রপ

0 স্টপ, 100%

 o         
 |  -->   o
x.       x|

ড্রপ (স্ট্যান্ড)

0 স্টপ, 100%

 %        o
x.  -->  x|

উপরে উঠুন

2 স্টপ, 100%

 =        o
 o  -->   |
x|       x

তোষামোদ করা

2 স্টপ, 100%

 o
 |  -->   %
x#       x#

থাকা

4 স্টপ, 100%

 .        o
 %  -->   |
x#       x#

শর্ট জাম্প

4 স্টপ, 95%, আয়না

 o..          o
 |..  -->     |
x#         x#

লম্বা লাফ

7 স্টিপ, 75%, আয়না

 o...           o
 |...  -->      |
x#          x#

উচ্চ লাফ

12 স্টপ, 90%, আয়না

 ..         o
 o.  -->    |
 |          
x#        x# 

এটি আপনার পিছনে রাখুন!

20 স্টপ, 80%, আয়না

 o!.         _o
 |!.  -->    _|
x#         x#

মুষ্ট্যাঘাত

8 স্টপ, 90%, আয়না

 o!        o_
 |   -->   |
x#        x#

পদাঘাত

8 স্টিপ, 85%, আয়না

 o         o
 |!  -->   |_
x#        x#

স্ট্যাম্প

8 টি স্টিপ, 90%

 o        o
 |  -->   |
x!       x_

পরিকল্পনা সমূহ

একটি পরিকল্পনা উপরে বর্ণিত ক্রিয়াগুলির ক্রম। উদাহরণ স্বরূপ:

Step Left
High Jump Left
Crouch
Shuffle Left
Shuffle Left
Stand
Long Jump Left
Put your back into it! Left
Step Left

ফোঁটা অন্তর্ভুক্তকরণ নোট করুন। ড্রপ করা ছাড়া আপনার কিছু করা বন্ধ করতে নিয়মগুলি সেট আপ করা উচিত, তবে আপনার এখনও এটি পরিকল্পনা করতে হবে!

যে কোনও পরিকল্পনার প্রয়োজনীয় প্রচেষ্টা থাকে যা প্রতিটি পদক্ষেপের জন্য প্রচেষ্টাগুলির যোগফল। একটি সাফল্যের সম্ভাবনাও রয়েছে, যা প্রতিটি ক্রিয়নের সাফল্যের সম্ভাবনার পণ্য। সাধারণ উদাহরণ:

Step Right:          1stp,  100%
Long Jump Right:     7stp,  75%
Step Right:          1stp,  100%
Stamp:               8stp,  90%
Drop:                0stp,  100%
Drop:                0stp,  100%
Drop:                0stp,  100%
Drop:                0stp,  100%
Step Left:           1stp,  100%
Step Left:           1stp,  100%
High Jump Left:      12stp, 90%

Effort = 1+7+1+8+1+1+12 = 31
Success Probability = 75%*90*90% = 60.75%

পৃষ্ঠার শীর্ষে মানচিত্রের জন্য একটি 'কাজের উদাহরণ' একটি সংক্ষেপ হিসাবে পাওয়া যাবে ।

ইনপুট

ইনপুটটি দুটি অংশে আসে, একটি পূর্ণসংখ্যা এবং একটি অ্যারে বা অক্ষরের স্ট্রিং।

পূর্ণসংখ্যা হ'ল সাফল্যের আপনার সর্বনিম্ন গ্রহণযোগ্য (শতাংশ) সম্ভাবনা। এটি শতাংশ হিসাবে ব্যাখ্যা করতে হবে, তাই 80 এর অর্থ আপনার পরিকল্পনা অবশ্যই 80% এর চেয়ে কম সম্ভাবনার সাথে সফল হবে।

একটি বৈধ মানচিত্র একটি আয়তক্ষেত্র যা স্থায়ী পলায়ন (1x2 এর সর্বনিম্ন আকার) এবং কোনও অনির্ধারিত চিহ্নগুলিকে অন্তর্ভুক্ত করে। সমস্ত সারি একই দৈর্ঘ্য হবে। আপনি ইনপুটটিকে 1-মাত্রিক ডিলিমিটেড স্ট্রিং হিসাবে গ্রহণ করতে পারেন (ডিলিমিটার অবশ্যই একটি একক ধারাবাহিক অক্ষর, বা একটি CRLF এবং LFCR জুড়ি হতে হবে), অনুরূপ 1-মাত্রিক অ্যারে বা 2-মাত্রিক অ্যারে হিসাবে। যদি আপনার নির্বাচিত ইনপুট ফর্ম্যাটটি কোনও উপায়ে মানচিত্রের প্রস্থ বা উচ্চতা নির্দেশ না করে তবে আপনি এগুলির জন্য অতিরিক্ত যুক্তি গ্রহণ করতে পারেন (আপনাকে অবশ্যই নিজের উত্তরে এটি বিবরণী করতে হবে)। আপনি কমান্ড লাইন আর্গুমেন্ট এবং মান ইনপুট মিশ্রিত করতে পারেন যদি এটি আপনার জন্য উপযুক্ত হয় (যেমন স্টিডিনের মানচিত্র, আরজিভি থেকে ন্যূনতম সাফল্যের সম্ভাবনা)। নীচে বৈধ এবং অবৈধ মানচিত্রের উদাহরণ রয়েছে।

বৈধ:

o
|

বৈধ:

  #     #
  !   o #
  !   | #
#########

অবৈধ (কোনও পলাতক নেই):

  #     #
  !     #
  !     #
#########

অবৈধ (পলাতক সর্বদা দাঁড়ানো শুরু করে):

  #     #
  !     #
  !   % #
#########

অবৈধ (অবৈধ প্রতীক):

  #     #
  !  ~  #
  !     #
#########

অবৈধ (আয়তক্ষেত্র / বিভিন্ন দৈর্ঘ্যের সারি নয়):

  #     #
  !   o #
  !   | # 
#########

আপনার ইনপুটটি বৈধ বলে ধরে নিতে পারেন (আপনার প্রোগ্রামটি যদি অবৈধ ইনপুট দেওয়া হয় তবে আমি তা করি না care

আউটপুট

আউটপুট হ'ল পাঠ্য (ASCII)। স্ট্রিং হিসাবে ফিরে আসতে পারে, বা স্ট্যান্ডার্ড আউটপুটে মুদ্রিত হতে পারে। পরিকল্পনাটি অবশ্যই একটি এলএফ, সিআরএলএফ, বা এলএফসিআর দ্বারা সীমিত করা উচিত। একইভাবে, প্রয়োজনীয় প্রচেষ্টার পরে আর একটি এলএফ, সিআরএলএফ বা এলএফসিআর থাকতে হবে। একটি পিছনের লাইনের বিরতি isচ্ছিক।

আপনার প্রয়োজনীয় প্রচেষ্টাটির সাথে একটি অনুকূল পরিকল্পনা অবশ্যই আউটপুট করতে হবে, বা "কোনও আশা নেই!" যদি এরকম কোনও পরিকল্পনা না থাকে। সাফল্যের সম্ভাব্যতার আউটপুট দেওয়ার দরকার নেই। এই পাঠ্যক্রমে লম্বা বিরতি থাকতে পারে বা নাও থাকতে পারে।

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

বিন্যাস:

Required Effort: <effort>
<plan>

উদাহরণস্বরূপ, ইনপুট জন্য

50
  #     #
  !   o #
  !   | #
#########

একটি উপযুক্ত আউটপুট হবে:

Required Effort: 23
Step Left
Step Left
Step Left
Kick Left
Punch Left
Step Left
Step Left
Step Left
Step Left

এখানে সাফল্যের সম্ভাবনা 76.5% .5

একই মানচিত্রের জন্য, তবে ৮০% সাফল্যের ন্যূনতম সম্ভাবনার জন্য আপনাকে "নিজের পিঠে এটি" রাখতে হবে, যার জন্য আরও প্রচেষ্টা প্রয়োজন তবে সাফল্যের সম্ভাবনার মানদণ্ড পূরণ করতে হবে। সাফল্যের ন্যূনতম সম্ভাবনা যদি ৮০% এর বেশি হয় তবে আপনাকে কিছুটা কঠিন চিন্তা করতে হবে (হয় পাঞ্চ বা দরজার অংশে লাথি মেরে লাফিয়ে বেরিয়ে আসা)। সাফল্যের নূন্যতম সম্ভাবনা যদি 100% হত, আপনাকে "কোনও আশা নেই!" ছাপাতে হবে!

উদাহরণ

এটা সম্ভব যে ইনপুটটির জন্য একাধিক বৈধ পরিকল্পনা রয়েছে, আপনার আউটপুটটি হুবহু হওয়া দরকার নেই, তবে এটির অবশ্যই সঠিক প্রচেষ্টা থাকতে হবে এবং একটি বৈধ পরিকল্পনা হতে হবে। আপনার সমাধানগুলি পরীক্ষা করতে আপনি যাচাইকারীটি ব্যবহার করতে পারেন (নীচে দেখুন)

ইনপুট:

100
o
|

আউটপুট:

Required Effort: 0
Drop

ইনপুট:

5
# =      #
# =      !
# = !  ! !
# =#######
# =      #
# =   o  #
# = ! |  #
##########

আউটপুট:

Required Effort: 57
Step Left
Kick Left
Step Left
Step Left
Step Left
Climb Up
Climb Up
Climb Up
Climb Up
Climb off Right
High Jump Right
Long Jump Right
Step Right
Drop
Kick Right
Crouch
Shuffle Right
Shuffle Right

ইনপুট:

60
#########
# ! #   #
! ! ! o #
! # ! | #
#########

আউটপুট:

Required Effort: 58
Step Left
Kick Left
Crouch
Shuffle Left
Shuffle Left
Stand
Punch Left
Clamber Up Left
Shuffle Left
Drop (Stand)
Kick Left
Crouch
Shuffle Left
Shuffle Left

একই মানচিত্রে, তবে ৮০% এর জন্য আউটপুটটি হওয়া উচিত:

There is no hope!

একই মানচিত্রের জন্য, তবে 50% এর জন্য প্রয়োজনীয় প্রচেষ্টাটি ভিন্ন পরিকল্পনার সাথে 56 হয়ে যায়)

ইনপুট:

50
#######################
#          #     =    #
!          #     =    !
#          #     =    #
######  #####!## =### #
#=   ##       #  =    #
#=#############  =    #
#=               =    #
#= o             =    #
#!!|             =    #
#######################

আউটপুট:

Required Effort: 121
Step Right
Step Right
Step Right
Step Right
Step Right
Step Right
Step Right
Step Right
Step Right
Step Right
Step Right
Step Right
Step Right
Step Right
Climb Up
Climb Up
Climb Up
Climb Up
Climb Up
Climb Up
Climb off Right
Long Jump Left
Step Left
Step Left
Stamp
Drop
Drop
Crouch
Shuffle Left
Shuffle Left
Shuffle Left
Shuffle Left
Shuffle Left
Shuffle Left
Stand
Clamber Up Left
Stand
Clamber Up Left
Stand
Step Left
Step Left
Step Left
Step Left
Punch Left
Clamber Up Left
Shuffle Left

ইনপুট:

66
######
#  ###
#o ! !
#| ! !
### ##
######

আউটপুট:

Required Effort: 37
Step Right
Put your back into it! Right
Kick Right
Crouch
Shuffle Right
Shuffle Right

ইনপুট:

এটিকে এমন অনেকগুলি অনুমান যাচাই করার জন্য ডিজাইন করা হয়েছে যার ফলে কেউ এর শিকার হতে পারে এবং ফলস্বরূপ কিছুটা অদ্ভুত দেখাচ্ছে

30
###################
# ## # # #   #  = #
! ## #   #   #  = #
#      #   #    = #
##  ############= #
# ## #         #= #
# =  #         #= #
! =  #         #= #
# =  #         #= #
#o=  !          ==#
#|=  !           =#
#!= # ==########==#
#   #    !   !!  =#
#   #    !!  !  = #
#   # !!!!#########
#   # #           #
#   # #           #
###################

সাফল্যের সীমাবদ্ধতার সম্ভাবনা 30 এর সাথে আউটপুট:

Required Effort: 199
Long Jump Right
Put your back into it! Right
<snip>

সাফল্যের সীমাবদ্ধতার সুযোগের সাথে আউটপুট 32:

Required Effort: 200
Long Jump Right
Punch Right
<snip>

1% সাফল্যের সীমাবদ্ধতার সম্ভাবনা সহ শীর্ষে মানচিত্রটি ব্যবহার করে, আপনার 116 (সাফল্যের সম্ভাবনা ~ 32%) হওয়া দরকার, এটি আমার পরীক্ষার প্রোগ্রামে চালাতে প্রায় 20 সেকেন্ড সময় নিয়েছিল)।

বিজয় মানদণ্ড

এটি কোড-গল্ফ, সংক্ষিপ্ততম কোড জিততে পারে।

যোগ্য হওয়ার জন্য, আপনার ফাংশন বা প্রোগ্রামটি অবশ্যই কার্যকর হতে হবে এবং উপরের প্রতিটি টেস্টকেসগুলিকে একটি যুক্তিসঙ্গত মেশিনে 30 মিনিটের অধীনে সমাধান করতে সক্ষম হতে হবে। আমার সলভার তাদের প্রত্যেককে 30 সেকেন্ডের নীচে করে। যদি পরীক্ষা স্ক্রিপ্ট (নীচে) 30 মিনিটের অধীনে চলে, আপনি অবশ্যই ভাল good

সমাধানকারী, যাচাইকারী, টেস্ট স্ক্রিপ্ট এবং টেস্ট কেসগুলির উদাহরণ (সমাধান সহ)

সমাধানকারী এবং সমাধান যাচাইকারীর জন্য সি # কোড এখানে একটি সংক্ষিপ্তসার হিসাবে উপলব্ধ । সংক্ষেপেও রয়েছেfile.txt , যা উপরে বর্ণিত ক্রিয়াগুলির একটি মেশিন পঠনযোগ্য (পর্যাপ্ত) ফর্ম এবং প্রোগ্রামটি চালানোর জন্য প্রয়োজনীয়। ফাইল এবং স্পেকের মধ্যে কোনও তাত্পর্য ইচ্ছাকৃত নয়।

গিস্টটিতে বেশ কয়েকটি পরীক্ষার কেসও রয়েছে (উপরের সমস্ত উদাহরণ সহ) এবং তাদের বিরুদ্ধে স্বয়ংক্রিয়ভাবে জমা দেওয়ার জন্য পাওয়ারশেল স্ক্রিপ্ট রয়েছে। যদি স্ক্রিপ্টটি আপনাকে বলে যে একটি নির্দিষ্ট পরীক্ষা ব্যর্থ হয়েছে, আপনি OfficeEscapeSolver.exe testcase<n>.txt outputFromYourProgram.txtআরও বিশদ দেখতে দৌড়াতে পারেন । এই পরীক্ষাগুলির ক্ষেত্রে উদাহরণগুলির সমাধানগুলি অন্য গিস্টে রয়েছে

সমস্ত কোড একটি সম্পূর্ণ জগাখিচুড়ি (যদিও নিরপেক্ষ), তবে আপনার কাছ থেকে দূরে পথভ্রষ্ট হওয়া উচিত নয় static void Main(...) আউটপুট পরিমাণ পরিবর্তন করার আপনাকে (এই তথ্যটি ব্যবহারে নির্দ্বিধায় বোধ করুন, আমি এটি আপনার সুবিধার জন্য সরবরাহ করেছি!)।

একটি পরীক্ষা-কেস পাস করার অর্থ এই নয় যে আপনার আউটপুটটি বেশ ভাল গঠন করেছে, কারণ স্ক্রিপ্ট এবং যাচাইকারী খুব উদার। আপনার জমাটি কার্যকর হওয়ার জন্য আপনার আউটপুট অবশ্যই উপরের স্পেসিফিকেশনের সাথে মেলে।

আপনি যদি মনে করেন আপনি সলভার বা টেস্টস্ক্রিপ্টের সাথে একটি বাগ খুঁজে পেয়েছেন তবে এতে একটি ত্রুটি file.txt , তবে দয়া করে এই পোস্টে মন্তব্য করুন বা অন্যথায় আমাকে এসই চ্যাটে পিং করছেন; আমি সম্ভবত যোগাযোগের অন্য কোনও প্রচেষ্টা লক্ষ্য করব না।

আমি বাশ বা ব্যাচে পরীক্ষার স্ক্রিপ্ট সরবরাহ করব না, কারণ আমি সেগুলি জানি না, তবে আমি একটি অনুবাদ অন্তর্ভুক্ত করে খুশি এবং লোকেরা চাইলে একটি সি # সংস্করণ লিখব।

পোস্ট এম্বেল

প্রশ্ন আছে? দেরি করবেন না, আজ তাদের জিজ্ঞাসা করুন!

এই কাজটি বোঝার দরকার , গুরুতর গল্ফারদের দাঁত ডুবিয়ে দেওয়ার জন্য কিছু দেওয়া।

ইনপুট / আউটপুট সম্পর্কে তার প্রতিক্রিয়া জানাতে আমার আইস 2323 কে ধন্যবাদ।

লোকেরা যদি আরও বেশি চায় (এই পোস্টটি আর বেশি না হয়ে চায়) বা তাদের নিজস্ব কিছু সরবরাহ করতে চাই তবে আমি টুকরো টুকরো টুকরো টুকরোটি সরবরাহ করতে পারি।


2
দুর্দান্ত চ্যালেঞ্জ! আমি সময় পেলে অবশ্যই একটি শট দেব। :)
আর কাপ

আপনি জানেন, পতনের (বা নীচে দ্রুত ক্ষয় হওয়া) বিপদগুলি ড্রপ ট্রানজিশনের 95% বা তার বেশি সম্ভাবনা দিয়ে মডেল করা যেতে পারে। ;) দুর্দান্ত চ্যালেঞ্জ!
মার্টিন এন্ডার

আপনি একটি আকাশ আলো বা টানেল যদিও পালাতে পারেন? অর্থাৎ উপরে এবং না মাঠের নীচে? বা কেবল বাম বা ডান?
মুগি

@ মোগি আপনি সত্যিই পারেন! আপনার পা যতক্ষণ নিখরচায় থাকে ততক্ষণ আপনি মুক্ত হন (উদাহরণস্বরূপ, 1x2 টেস্টকেস দেখুন, যেখানে সমাধানটি কেবল একবার ড্রপ হয়)। সিলিংয়ের বাইরে যাওয়ার জন্য আমি টুকরো টুকরো টুকরো টুকরো যোগ করব।
ভিজুয়ালমেলন

3
প্রশ্নে অনুগ্রহ যুক্ত হয়েছে। এটি উত্তরের দাবিদার একটি দুর্দান্ত প্রশ্ন।
প্রোগ্রামার

উত্তর:


3

পার্ল 5, 1425 1464 1481 1469 1485 1438 বাইট

এটাই ছিল মজার চ্যালেঞ্জ! এবং, মর্মাহতভাবে, দেখে মনে হচ্ছে আমার কাছে 1.5KB এর নিচে সামান্যতম কোড রয়েছে! :)

খুব নিশ্চিত যে অবশেষে আমি এই কাজটি পেয়েছি। ডিলিমিটারটি ব্যবহৃত হয় :এবং উপরে দুটি সারি এবং উভয় পাশে একটি কলামের অতিরিক্ত প্যাডিং রয়েছে । সুতরাং আপনার ইনপুট জন্য:

60
#########
# ! #   #
! ! ! o #
! # ! | #
#########

আমার প্রোগ্রামটি গ্রহণ করবে: (এনবি: অবশ্যই একটি কোলন অবশ্যই হবে, তবে শুরুতে নয়!)

60
#########:# ! #   #:! ! ! o #:! # ! | #:#########:

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

দুর্ভাগ্যক্রমে, কয়েকটা বাইট নেওয়ার জন্য বেশ দক্ষতার ব্যবসায়ের সুযোগ ছিল, তাই গল্ফ করা সংস্করণটি বরং ধীরে ধীরে;) পার্লকে মনে হয় বিশেষত এই যন্ত্রণাগুলি বেশ বেদনাদায়ক বলে মনে হয়েছে।

আরও অ্যাডিউ ছাড়া,

chop($P=<>,$_=<>);s/:/ : /g;$w++until/:.{$w}:/;$z=$"x$w;$_="(.{".$w--."})"for($c,$h,$i,$j);$_="$z:$z: $_$z";$n="[ =]";$d="([!#])";@s=split/,/,'Drop,Drop (Stand),Stepx,Climb offx,Shufflex,Clamber Upx,Put your back into it!x,Punchx,Kickx,Short Jumpx,Long Jumpx,High Jumpx,Crouch,Stand,Climb Up,Stamp';@c=split/,/,"o$c\\|$c$n/ \$1o\$2|,%$c$n/o\$1|,o$n$h\\|$n$h${d}/ o\$1 |\$2\$3,=${c}o$n$h\\|$n$h=/=\$1=o\$2=|\$3=,%$n$h$d/ %\$1\$2,o$n$h\\|${d}$h${d}/ %".'$1 $2$3$4,'."o!$n$i\\|!$n$i${d}/  o\$1  |\$2\$3,o!$h\\|$c$d/o \$1|\$2\$3,\\|!$h$d/| \$1\$2,o$n$n$i\\|$n$n$i${d}/  o\$1  |\$2\$3,o$n$n$n$j\\|$n$n$n$j${d}/   o\$1   |\$2\$3,$n$n${h}o$n$h\\|$c$d/ o".'$1 |$2 $3$4,'."o$c\\|$c${d}/ \$1%\$2\$3,$n$c%$c${d}/o\$1|\$2\$3,=${c}o$c\\|/o\$1|\$2=,\\|$c!/|\$1 ";eval"*$_=sub{\$Q=\"$s[$_]\";s/$c[$_]/}"for(0..15);sub M{$_=join":",map{join'',reverse split//}split/:/};push@M,[$_,0,100,$P];$B{$_}=100;@E=(0,0,1,1,3,10,20,8,8,4,7,12,2,4,2,8);@P=map{100-$_}(0,0,0,0,0,5,20,10,15,5,25,10,0,0,0,10);$z='$N=[$_,$G+0,$t,$t[3]*100,"$t[4]$Q\n"];$N->[4]=~s/x/';do{sub A{@N=@$N;if($N[2]/$N[3]>$B{$N[0]}){push@M,$N;$B{$N[0]}=$N[2]/$N[3]}};die"There is no hope!\n"if(!(@M=grep$G-$_->[1]<21,@M));$e=-1;while(++$e<@M){@t=@{$M[$e]};$m=$_=$t[0];die"Required Effort: $t[1]\n$t[4]"if(/([|%]:|:[|%])/||/[|%][^:]*$/||/^$c:[^:]*[%|]/);for$x(0..15){$_=$m;$t=$t[2]*$P[$x];if($G==$E[$x]+$t[1]and$t>=$t[3]*100){&$x;eval"$z Right/";A;$_=$m;M;&$x;M;eval"$z Left/";A;}}}}

স্যানিটির খাতিরে, এখানে নিউলাইন এবং কয়েকটি মন্তব্য সহ একই জিনিস:

chop($P=<>,$_=<>); #Take input
s/:/ : /g; #Pad columns on either side so escapee can leave that way
$w++until/:.{$w}:/; #Find width
$z=$"x$w;#Setup a blank line for use in padding later
$_="(.{".$w--."})"for($c,$h,$i,$j); #Set up some generic capturing regexes for reuse
$_="$z:$z: $_$z"; #Pad the top and bottom so the escapee can leave those ways
$n="[ =]"; #Regex for nonsolid block
$d="([!#])"; #Regex for solid block
@s=split/,/,'Drop,Drop (Stand),Stepx,Climb offx,Shufflex,Clamber Upx,Put your back into it!x,Punchx,Kickx,Short Jumpx,Long Jumpx,High Jumpx,Crouch,Stand,Climb Up,Stamp'; #Movement names
@c=split/,/,"o$c\\|$c$n/ \$1o\$2|,%$c$n/o\$1|,o$n$h\\|$n$h${d}/ o\$1 |\$2\$3,=${c}o$n$h\\|$n$h=/=\$1=o\$2=|\$3=,%$n$h$d/ %\$1\$2,o$n$h\\|${d}$h${d}/ %".'$1 $2$3$4,'."o!$n$i\\|!$n$i${d}/  o\$1  |\$2\$3,o!$h\\|$c$d/o \$1|\$2\$3,\\|!$h$d/| \$1\$2,o$n$n$i\\|$n$n$i${d}/  o\$1  |\$2\$3,o$n$n$n$j\\|$n$n$n$j${d}/   o\$1   |\$2\$3,$n$n${h}o$n$h\\|$c$d/ o".'$1 |$2 $3$4,'."o$c\\|$c${d}/ \$1%\$2\$3,$n$c%$c${d}/o\$1|\$2\$3,=${c}o$c\\|/o\$1|\$2=,\\|$c!/|\$1 ";#Movement regexes
eval"*$_=sub{\$Q=\"$s[$_]\";s/$c[$_]/}"for(0..15); #Setup methods to apply regexes. Name of these methods are 0,1,2,3, etc, so we can easily call them in a loop
sub M{$_=join":",map{join'',reverse split//}split/:/}; #Method to mirror the map. All the regexes are right-moving, so the mirror effects are achieved by M;&$x;M
push@M,[$_,0,100,$P]; #Array for initial map position. Encodes: [Map,Effort value,Probability value 1,Probability value 2,Movements(initially undef)]. Two integers are used for the probability to avoid floating point (although after enough steps they overflow and are automatically converted to f.p.)
$B{$_}=100; #Hash map to hold best probability of reaching a map. A new map is never added if it requires at least as much effort and doesn't give a better probability.
@E=(0,0,1,1,3,10,20,8,8,4,7,12,2,4,2,8); #Effort values
@P=map{100-$_}(0,0,0,0,0,5,20,10,15,5,25,10,0,0,0,10); #Probability values
$z='$N=[$_,$G+0,$t,$t[3]*100,"$t[4]$Q\n"];$N->[4]=~s/x/'; #Setup map values
do{ #Loop over all efforts. Do-while loop starts at undef, which is converted to zero automatically when used in a numeric context
    sub A{@N=@$N;if($N[2]/$N[3]>$B{$N[0]}){push@M,$N;$B{$N[0]}=$N[2]/$N[3]}}; #Method to add a map to list.
    die"There is no hope!\n"if(!(@M=grep$G-$_->[1]<21,@M)); #Pares away maps that no longer can produce new maps, and prints "There is no hope!" to stderr if there are no maps left.
    $e=-1;
    while(++$e<@M){ #Loop over all maps. Note that this loops over even maps that are created during the loop
        @t=@{$M[$e]}; #Dereference info about each map
        $m=$_=$t[0]; $Setup map variables
        die"Required Effort: $t[1]\n$t[4]"if(/([|%]:|:[|%])/||/[|%][^:]*$/||/^$c:[^:]*[%|]/); #Checks if escaped, and gives message if so.
        for$x(0..15){
            $_=$m; #Put map into $_
            $t=$t[2]*$P[$x]; #Probability calculation
            if($G==$E[$x]+$t[1]and$t>=$t[3]*100){ #If effort values are right and probability is over threshold
                &$x; #Run regex
                eval"$z Right/"; #Set up map info
                A; #Add map to list @M (only if probability works out right)
                $_=$m;
                M;&$x;M; #Same thing, but mirrored now (generates movement left)
                eval"$z Left/";
                A;
            }
        }
    }
}while(++$G)

আমি আরও কয়েকটি বাইট পেরিয়ে যাওয়ার জন্য ইতিমধ্যে কয়েকটি জায়গা দেখতে পাচ্ছি, তবে আমি আবারও সমস্ত পরীক্ষার মধ্য দিয়ে যেতে চাই না। পরবর্তীতে! :)

সম্পাদনা করুন: মেঝে দিয়ে পালানোর সময় আপনার আউটপুটটিকে আরও সঠিকভাবে ফিট করার জন্য নীচে কিছু প্যাডিং যুক্ত করা হয়েছে। কিছু ইভাল সরানো হয়েছে, তাই কোডটি এখন খুব দ্রুত চলতে পারে!

সম্পাদনা: মই এবং ড্রপগুলি ঠিকভাবে পরিচালনা করছিল না। এখনও মই ঠিক সঠিকভাবে পরিচালনা করে না ... এখনই এটি ঠিক করার চেষ্টা করা হচ্ছে।


অন্য কারও সাথে মজা করে খুশি! আমি আশঙ্কা করছি যে এটি বর্তমানে যেমন আছে তেমন আমি এটি গ্রহণ করতে পারছি না, কারণ আপনি অনুমান করতে পারবেন না যে ইনপুটটির সাথে সেই অতিরিক্ত সারি বা প্যাডিং শীর্ষে রয়েছে (তবে সরাসরি ser 1.5 কেবিতে, সরাসরি সন্নিবেশ করাতে আঘাত দেওয়া উচিত নয়) অনেক বেশি!). এই মেশিনে আমার কাছে পার্ল নেই, তবে আমি চেষ্টা করব এবং আজ এটির পরীক্ষা করার জন্য একটি উপায় খুঁজে পাব, তাই আমি এটি পরীক্ষা করতে পারি এবং বুদ্ধিমান সময় ফ্রেমে এটি চালাচ্ছি এবং রিপোর্ট করতে পারি!
ভিজুয়ালমেলন

1
@ ভিজুয়ালমেলন কোনও সমস্যা নেই, আমি ইনপুট পদ্ধতিটি পরিবর্তন করেছি এবং ম্যানুয়ালি প্যাডিং যুক্ত করেছি। এটি বৃহত্তর ধাঁধাগুলিতে ঝাঁকুনির ঝোঁক বহন করে না তবে এটি আপনার বেশিরভাগ পরীক্ষার ক্ষেত্রে উপযুক্ত সময়সীমার মধ্যে চলে।
ক্রিস

তবুও এটি পরীক্ষা করা হয়নি, তবে আমি নোট করেছি আপনি বলেছিলেন যে আপনি পাশ বা নীচে যাওয়ার সময় এটি সনাক্ত করতে একটি রেজেক্স ব্যবহার করেন তবে আপনি উপরের অংশ থেকেও পালাতে পারবেন ( টেস্টকেস 10 যা এই উদ্দেশ্যে যুক্ত করা হয়েছিল) ঠিক যদি আপনি মিস করেন তবে এটি
ভিজুয়ালমেলন

1
@ ভিজ্যুয়ালমেলন আহ, আমি ধরে নিয়েছিলাম যে ছাদ থেকে পালাতে পালানোকে ঘরের উপরে উঠতে হবে এবং তারপরে ছাদ থেকে পাশের দিকে হাঁটতে হবে। আমি এখন সম্পর্কিত বাক্যটি দেখতে পাচ্ছি see আমি এটি ঠিক করব :)
ক্রিস

2
আপনি একটি টিআইও লিঙ্ক যোগ করতে পারেন?
প্রোগ্রামার

3

সি #, 1814 1481 1395 বাইট

কী বোকা !! আমি এখন বরং এতে সত্যিই সন্তুষ্ট!

using C=System.Console;using System.Linq;class S{string M,N="";int x,y,E,c;decimal P=1;static void Main(){int W=0,H=0,x,i,j,k,X,Y,f,m,P=int.Parse(C.ReadLine());string l,M="",B,R="There is no hope!";for(;(l=C.ReadLine())!=null;H++,M+=l)W=l.Length;x=M.IndexOf("|");var D=new[]{new S{M=M,x=x%W,y=x/W}}.ToList();for(var N=D.ToDictionary(s=>R,s=>D);D.Count>0;D.Sort((z,w)=>z.E-w.E)){S s=D[f=0];D.Remove(s);var n=N[l=s.x+s.M+s.y+s.c]=N.ContainsKey(l)?N[l]:new S[0].ToList();if(n.All(o=>o.P<s.P|o.E>s.E)){n.Add(s);X=s.x;Y=s.y;if((X|Y|-X/W-Y/H)<0){R="Required Effort: "+s.E+s.N;break;}for(var A="0110d,Step,*** * #*,0110d,Climb off,=** * =*,3310d,Shuffle,***** #*,2:1/_,Clamber Up,*** *##*,0420_,Short Jump,****  *  #**,0730K,Long Jump,*****   *   #***,0<1/Z,High Jump,  * **#*,0D20P,Put your back into it!,****! *! #**,0800Z,Punch,***!**#*,0800U,Kick,*****!#*,0001d,Drop,*** ,1001d,Drop (Stand),*** ,2200d,Crouch,***#,1400d,Stand,* *#,020/d,Climb Up,=***,0800Z,Stamp,***!".Split(',');f<26;){l=A[k=f*3%48];B=A[++k]+(f>15?" Right":f>9?"":" Left");M=A[++k];m=f++/16*2-1;var Q=s.M.ToArray();var K=s.P*l[4]>=P&s.c==l[k=0]%2;for(j=Y-3;j++<=Y;)for(i=X;i!=X+m*M.Length/4;i+=m)if((K&="==  *!!##*!*=*|*| o*o ".Contains(""+((i|j)>=0&j<H&i<W?Q[x=j*W+i]:' ')+M[k]))&M[k++]==33)Q[x]=' ';if(K)D.Add(new S{M=new string(Q),N=s.N+"\n"+B,x=X+l[2]%48*m,y=Y+l[3]-48,c=l[0]/50,E=s.E+l[1]-48,P=s.P*l[4]/100});}}}C.Write(R);}}

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

সম্পূর্ণ প্রোগ্রাম, এসটিডিএন-এ ইনপুট নেয়, এসটিডিআউট-এ আউটপুট নেয়। অপরিহার্যভাবে আমার আসল সলভারটির পুনরায় লেখা, অনুকূল পথটি সন্ধান করার জন্য একটি সহজ এবং অকার্যকরভাবে প্রয়োগ করা বিএফএস ব্যবহার করে। এটি যুক্তিসঙ্গতভাবে দ্রুত, আমার অন্যান্য প্রয়োগের তুলনায় খুব ধীর হতে পারে না (আমি যদিও এটির সত্যিকার অর্থে সময় নিইনি), অবশ্যই সময়সীমার মধ্যে চলে। বেশিরভাগ ব্যয় হ'ল অ্যাকশন টেবিল, যা কমা পৃথক মান হিসাবে এনকোড থাকে যা নাম, 'ম্যাচ / স্ম্যাশ' মানচিত্র এবং প্রতিটি উপলব্ধ ক্রিয়াকলাপের অন্যান্য বৈশিষ্ট্য রেকর্ড করে।

এটি সাফল্যের ন্যূনতম সম্ভাবনা এবং মানচিত্র পাঠ করে শুরু হয়। তারপরে এটি পলাতককে সনাক্ত করে, তাকে মানচিত্র থেকে সরিয়ে দেয় এবং এই তথ্য সম্বলিত একটি 'অনুসন্ধানের রাজ্য' তৈরি করে। তারপরে, এটি বিএফএস সম্পাদন করে, যা সর্বনিম্ন পরিশ্রম (পরবর্তী সময়ে এটি সর্বোত্তম সমাধানটি সন্ধান করে) এর সাথে পরবর্তী প্রদত্ত রাষ্ট্রের দিকে বার বার তাকায়। নোডটি প্রসারিত করার আগে, এটি পূর্বের নোডগুলির সাথে একই মানচিত্র এবং পলায়নকারী অবস্থানের সাথে তার প্রচেষ্টা এবং সাফল্যের সম্ভাবনার তুলনা করে এবং ইতিমধ্যে যদি এই রাজ্যে আরও ভাল কোনও রাস্তা পাওয়া গিয়েছে তবে নিজেকে অস্বীকার করে। যদি এটি এ থেকে যায়, এটি নিজেকে 'দেখানো' টেবিলের সাথে যুক্ত করে যাতে এটি পরে রাষ্ট্রটিকে প্রত্যাখ্যান করতে পারে। এটি পারফরম্যান্সের জন্য সমস্ত, এবং এগুলি ছাড়াই ব্রাঞ্চিং ফ্যাক্টরটি বিশাল। তারপরে পালিয়ে যাওয়া মানচিত্রের বাইরে রয়েছে কিনা তা এটি পরীক্ষা করে। যদি তা হয় তবে তা জিতবে! এটি রাজ্যের পিছনে ট্র্যাক করে (প্রতিটি পূর্বের রাজ্য প্রতিটি রাজ্যের সাথে রেকর্ড করা হয়) এবং বিএফএস লুপ থেকে বের হওয়ার আগে পরিকল্পনাটি (বিপরীতে) তৈরি করে। অন্যথায়, এটি প্রতিটি ক্রিয়া প্রয়োগ করার চেষ্টা করে এবং এর সাথে প্রয়োগ করা যেতে পারে এমন কোনও যোগ করেdue এই সারিটি খোরাক করার আগে সারি, যাতে আমরা পরবর্তী পুনরাবৃত্তির সর্বনিম্ন প্রচেষ্টা রাষ্ট্র পাই state

ফর্ম্যাট এবং মন্তব্য কোড:

using C=System.Console;
using System.Linq;

// ascii
//   32
// ! 33
// = 61
// . 46
// * 42
// # 35
// | 124
// 0 48

class S // SearchState
{
    string M, // map
        N=""; // plan
    int x, // pos x
        y, // pos y
        E, // effort
        c; // crouching?
    decimal P=1; // chance (Probability)

    static void Main()
    {
        int W=0, // map width
            H=0, // map height
            x, // various temps
            i, // local x
            j, // local y
            k, // position in match/smash map
            X, // s.x
            Y, // s.y

            // action loop
            f, // T idx
            m, // A idx, action mirror (direction)

            P=int.Parse(C.ReadLine()); // probability of success constraint

        string l, // line, Act 'block' params, map hash, match pairs; all sorts!
            M="", // initial map
            B, // name of action
            R="There is no hope!"; // result string

        // read map
        for(;(l=C.ReadLine())!=null; // while there is input to read
            H++,M+=l) // increment height, and append to M
            W=l.Length; // record width

        // detect the escapee
        x=M.IndexOf("|");

        // create first state, and add it to Due list
        var D=new[]{new S{M=M,x=x%W,y=x/W}}.ToList();

        // 'seen' table, stores all the states we've been in which looked similar
        for(var N=D.ToDictionary(s=>R,s=>D); // these values are meaningless (and necessarily can't interfere), we just use it to save having to spec the type
            D.Count>0; // keep going until we run out of states to expand (-> no escape)
            D.Sort((z,w)=>z.E-w.E)) // enforce Breadth First Search
        {
            // get next State to expand, and remove it from Due
            S s=D[f=0];
            D.Remove(s);

            // retrieve or create seen list
            var n=N[l=s.x+s.M+s.y+s.c]= // store it, and cache it, l is 'hash', containing map and escapee state
                N.ContainsKey(l)? // already got a seen list for ths map?
                N[l]: // then use it!
                new S[0].ToList(); // otherwise create a new (empty) one

            // perf: only proceed if we havn't seen this map with better Effort and Chance yet
            if(n.All(o=>o.P<s.P|o.E>s.E))
            {
                // record that we have been seen
                n.Add(s);
                X=s.x;
                Y=s.y;

                if((X|Y|-X/W-Y/H)<0) // check if we our outside the bounds - this took 2.5hour to write. 1 byte.
                { // quit if both are positive or both are negative
                    // freedom
                    R="Required Effort: "+s.E+s.N;

                    // finished
                    break;
                }

                // [Crouch,Effort,dx,dy,Probability],Name,MatchSmash (first 10 are mirrors)
                // 0110d,Step,*** * #*,
                // 0110d,Climb off,=** * =*,
                // 3310d,Shuffle,***** #*,
                // 2:1/_,Clamber Up,*** *##*,
                // 0420_,Short Jump,****  *  #**,
                // 0730K,Long Jump,*****   *   #***,
                // 0<1/Z,High Jump,  * **#*,
                // 0D20P,Put your back into it!,****! *! #**,
                // 0800Z,Punch,***!**#*,
                // 0800U,Kick,*****!#*,
                // 0001d,Drop,*** ,
                // 1001d,Drop (Stand),*** ,
                // 2200d,Crouch,***#,
                // 1400d,Stand,* *#,
                // 020/d,Climb Up,=***,
                // 0800Z,Stamp,***!

                // attempt to expand this node with every action
                for(var A="0110d,Step,*** * #*,0110d,Climb off,=** * =*,3310d,Shuffle,***** #*,2:1/_,Clamber Up,*** *##*,0420_,Short Jump,****  *  #**,0730K,Long Jump,*****   *   #***,0<1/Z,High Jump,  * **#*,0D20P,Put your back into it!,****! *! #**,0800Z,Punch,***!**#*,0800U,Kick,*****!#*,0001d,Drop,*** ,1001d,Drop (Stand),*** ,2200d,Crouch,***#,1400d,Stand,* *#,020/d,Climb Up,=***,0800Z,Stamp,***!".Split(','); // Act string
                    f<26;) // read A into T // (cycle over first 10 twice, making them mirrors)  (very convieniently, 3*16==48=='0'==x!)
                {
                    // 'parse' next action
                    l=A[k=f*3%48]; // [Effort,Crouch,dx,dy,Probability]
                    B=A[++k]+(f>15?" Right":f>9?"":" Left"); // action name
                    M=A[++k]; // Match and Smash table (4x?, escapee at 0,2, #: solid, !: smashable (and is smashed), .: empty,  : don't care, =: climable)
                    //c=l[1]-48; // crouching transition (0: standing -> standing, 1: crouching -> standing, 2: standing -> crouching, 3: crouching -> crouching)
                    m=f++/16*2-1;

                    // this will be the new map
                    var Q=s.M.ToArray();

                    // K is whether we are allowed to apply this action
                    var K=s.P*l[4]>=P& // within chance limit
                        s.c==l[k=0]%2; // crouching matches

                    // compare the map to the Match/Smash map, to make sure we can apply this transform (and smash any ! we meet)
                    for(j=Y-3;j++<=Y;) // for the 4 rows
                        for(i=X;i!=X+m*M.Length/4;i+=m) // for each column (a.M has height 4, but variable width)
                            if((K&= // K still true?
                                "==  *!!##*!*=*|*| o*o ".Contains(""+ // check for an allowed pairing (cache pairing in M) (this includes the escapee, much cheaper to do this than remove him)
                                    ((i|j)>=0&j<H&i<W?Q[x=j*W+i]:' ') // we are within bounds and match, we are out of bounds (empty)
                                    +M[k])) // char from MatchSmash map
                                &M[k++]==33) // if it is destructible ('!' == 33)
                                Q[x]=' '; // then blank it out (x is necessarily set by the cell check)

                    if(K) // if K holds
                        D.Add(new S{M=new string(Q),N=s.N+"\n"+B, // assemble plan as we go (this will chew up memory, but none of the problems are big enough for it to matter)
                            x=X+l[2]%48*m,y=Y+l[3]-48,c=l[0]/50,E=s.E+l[1]-48,P=s.P*l[4]/100}); // add the resulting state to Due
                }
            }
        }

        C.Write(R);
    }
}

সুন্দর কাজ! এটি আমাকে অবিচ্ছিন্নভাবে
বিস্মিত করে তোলে

সি # পার্লকে মারধর করেছে?
ফল
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.