একটি এএসসিআইআই আর্টের সমাপ্তিগুলি গণনা করা

Question

আপনার এমন একটি প্রোগ্রাম বা ফাংশন লিখতে হবে যা কোনও এসিআইআইআই আর্টকে ইনপুট এবং আউটপুট হিসাবে উপস্থাপন করে বা ইনপুটটিতে শেষ পয়েন্টগুলির সংখ্যা প্রদান করে string

ইনপুটটিতে অক্ষরগুলি space - | +(যথাক্রমে 0, 2, 2 এবং 4 টি সমাপ্তি সহ) এবং লাইনব্র্যাকগুলি সমন্বিত থাকবে। উদাহরণ:

-|++-
  +

দুটি সংলগ্ন অক্ষর সংযুক্ত এবং অতএব নিম্নলিখিত ক্ষেত্রে প্রতিটি 1 টি শেষ পয়েন্ট হারাবে:

--  -+  +- |  |  +  +  ++
           |  +  |  +

প্রথম উদাহরণ আছে

2+2+2+2+1+
    3        = 12

এন্ড পয়েন্ট।

ইনপুট

• ইনপুট অক্ষর স্থান, এর মধ্যে রয়েছে একটি স্ট্রিং হতে হবে -, |, +এবং সম্পর্কে newline।
• ইনপুট দৈর্ঘ্য 0 দৈর্ঘ্য হতে পারে এবং উপরের বর্ণনার সাথে মিলে যে কোনও ইনপুট বৈধ (রেজেক্স ইনপুটটিতে রয়েছে [ -+|\n]*)।
• ট্রেলিং নিউলাইন optionচ্ছিক।

আউটপুট

• একটি একক অ-নেতিবাচক পূর্ণসংখ্যা, শেষ পয়েন্টের সংখ্যা।

উদাহরণ

আউটপুটগুলি ইনপুটগুলির শেষ সারির পরে হয়।

+
4 

-|++-
  +
12 

+--+
|  |
+--+
8 

  |  |
  +--+-- |||
12 

--++
 |||--
10 

<empty input>
0 


|
|     
2 

--
++--
 ++
   --+
  +++ || 

 ----
30 

এটি কোড গল্ফ তাই সংক্ষিপ্ত এন্ট্রি জিতেছে।

Answer 1

শামুক , 29

A
\+|\-)lr!\-|(\+|\|)n!\|}!\+

আমি ,,একটি মন্তব্য সংস্করণ করার জন্য লাইন মন্তব্য যুক্ত করেছি ।

A                    ,, Count all accepting paths
        \+ | \- )    ,, Literal '+' or '-'        
        lr           ,, Set direction to left or right
        !\-          ,, Assert next char is not '-'
    |                ,, Or...
        ( \+ | \| )  ,, Literal '+' or '|'
        n            ,, Turn 90 degrees right or left (from initial direction right)
        !\|          ,, Assert next char is not '|'
}                    ,, Group everything previous
!\+                  ,, Assert next char is not '+'

Answer 2

জাভাস্ক্রিপ্ট (ES6), 168

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

ফায়ারফক্সে নীচে স্নিপেট চলমান পরীক্ষা করুন। (ক্রোম এখনও সমর্থন করে না ...)

f=s=>`
${s}
`.split`
`.map((r,y,s,v=c=>c>' '&c!='-',h=c=>c>' '&c<'|')=>[...r].map((c,x)=>t+=(v(c)?2-v(s[y-1][x])-v(s[y+1][x]):0)+(h(c)?2-h(r[x-1])-h(r[x+1]):0)),t=0)&&t

// Less golfed
u=s=>{
  s = ('\n' + s + '\n').split('\n'); // split in rows, adding a blank line at top and one at bottom
  t = 0; // init counter
  v = c => c>' ' & c!='-'; // function to check if a character has vertical end points
  h = c => c>' ' & c<'|'; // function to check if a character has horizontal end points
  s.forEach( (r,y) =>
    [...r].forEach( (c,x) => {
     if (v(c)) // if current character has vertical endpoints, check chars in previous and following row
        t += 2 - v(s[y-1][x]) - v(s[y+1][x]); 
     if (h(c))  // if current character has horizontal endpoints, check previous and following chars in row
        t += 2 - h(r[x-1]) - h(r[x+1]);
    })
  )  
  return t
}

//TEST
out=x=>O.innerHTML+=x+'\n'

;[
 [`+`,4]
,[`-|++-
  +`,12]
,[`+--+
|  |
+--+`,8]
,[`  |  |
  +--+-- |||`,12]
,[`--++
 |||--`,10]
,[``,0]
,[`
|
|`,2]
,[`
--
++--
 ++
   --+
  +++ || 

 ----`,30]
].forEach(t=>{ r=f(t[0]),k=t[1],out('Test '+(r==k?'OK':'Fail')+'\n'+t[0]+'\nResult:'+r+'\nCheck:'+k+'\n') })

<pre id=O></pre>

Comments

আমাকে যা করতে হবে তা হ'ল সারিগুলিতে বিভাজন করা, তারপরে উপরে একটি খালি সারি এবং নীচে একটি খালি সারি যুক্ত করুন। আপনার কোডটি মোটেও বিভক্ত হয় না। আপনি ["",...s.split("\n"),""]এটি আরও দীর্ঘ করতে পারবেন ETH প্রডাকশনগুলি

— edc65

আহ, ঠিক আছে, সে সম্পর্কে দুঃখিত।

— ETH প্রোডাকশনগুলি

Answer 3

পাইথন 2, 123

l=[]
i=p=t=0
for c in input():
 l+=0,;h=c in'-+';t+=h>p;p=h;v=c in'|+';t+=v>l[i];l[i]=v;i+=1
 if' '>c:l=l[:i];i=0
print t*2

এক-পাস পদ্ধতি। ইনপুট হিসাবে লাইন ব্রেকগুলির সাথে স্ট্রিং নেয় T

অনুভূমিকগুলির জন্য, ধারণাটি অনুভূমিক বিভাগগুলির সংখ্যা গণনা করা হবে, যার প্রত্যেকটির দুটি প্রান্ত রয়েছে। একটি বিভাগ যখনই শুরু হয় যখনই কোনও চরিত্র +-(বুলিয়ান h) এর একটি হয় তবে পূর্ববর্তীটি (বুলিয়ান p) নয়।

উল্লম্ব ক্ষেত্রে, আমরা ট্রান্সপোজড ইনপুটটিতে একই কাজ করতে চাই, রানের দিকে তাকিয়ে +|। দুর্ভাগ্যক্রমে, পাইথনের ট্রান্সপোসিংটি সত্যই জটিল। এর map(None,*s.split('\n'))সাথে শূন্যস্থান পূরণ করার মতো কিছু দরকার Noneযা এগুলি মোকাবেলা করার জন্য নিজেরাই।

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

Answer 4

সিজেম, 66 62 61 বাইট

q_N/_z,S*f.e|zN*"-|++"2$fe=1b"|-"{'++:R:a@+2ew{aR2m*&},,-}/2*

সিজেএম ইন্টারপ্রেটারে এটি অনলাইনে চেষ্টা করুন ।

ধারণা

আমরা নিম্নলিখিত পয়েন্টগুলি নিম্নরূপে গণনা করতে পারি:

1. ইনপুটটিতে -s, |s এবং +s এর সংখ্যা গণনা করুন।
2. শেষটিকে 2 দ্বারা গুণান এবং ফলাফলগুলি যুক্ত করুন।
3. সারিতে --s, -+s, +-s এবং ++s এর সংখ্যা গণনা করুন ।
4. এর সংখ্যা গণনা করুন ||। কলামগুলিতে |+s, +|গুলি এবং ++গুলি।
5. ফলাফলটি 3 থেকে 4 এবং 4 থেকে ফলাফল বিয়োগ করুন।
6. ফলাফলকে 5 দ্বারা 2 দ্বারা গুণান।

কোড

q        e# Read all input from STDIN.
_N/      e# Push a copy and split it at linefeeds.
_z,      e# Count the number of rows of the transposed array.
         e# This pushes the length of the longest row.
S*       e# Push a string of that many spaces.
f.e|     e# Perform vectorized logical OR with the rows.
         e# This pads all rows to the same length.
zN*      e# Transpose and join, separating by linefeeds.
"-|++"   e# Push that string.
2$       e# Copy the original input.
fe=      e# Count the occurrences of '-', '|', '+' and '+' in the input.
1b       e# Add the results.
"|-"{    e# For '|' and '-':
  '++    e#   Concatenate the char with '+'.
  :R     e#   Save the resulting string in R.
  :a     e#   Convert it into an array of singleton strings.
  @      e#   Rotate one of the two bottom-most strings on top of the stack.
         e#   This gets the transposed input for '|' and the original input for '-'.
  +      e#   Concatenate both arrays.
         e#   This pads the input with nonsense to a length of at least 2.
  2ew    e#   Push a overlapping slices of length 2.
  {      e#   Filter the slices; for each:
    a    e#     Wrap it in an array.
    R2m* e#     Push the second Cartesian power of R.
         e#     For '|', this pushes ["||" "|+" "+|" "++"].
    &    e#     Intersect.
  },     e#   If the intersection was non-empty, keep the slice.
  ,      e#   Count the kept slices.
  -      e#   Subtract the amount from the integer on the stack.
}/       e#
2*       e# Multiply the result by 2.