ইন্টারলকিং বন্ধনী

Question

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

মুদ্রণ করুন বা থেকে একটি পূর্ণসংখ্যা আসতে 0করার 6যে -এর মানে কিভাবে চার বন্ধনী ধরনের ছয় সম্ভব পেয়ারিং অনেক interlocked করা হয়। যদি অন্য ধরণের বন্ধনীগুলির মধ্যে এক ধরণের এক বন্ধনী উপস্থিত হয় তবে ব্রাকেট প্রকারের জোড়গুলি আন্তঃসংযোগযুক্ত বলে বিবেচিত হয়। সুতরাং ([)]এবং [(])interlocked হয় কিন্তু ()[], [](), ([]), এবং [()]হয় না।

বাইটের মধ্যে সংক্ষিপ্ততম কোডটি জয়ী।

ইনপুট / আউটপুট উদাহরণ

()[]{}<> : 0
([{<>}]) : 0
<>{[]}() : 0
{<>([])} : 0
<(>)[{}] : 1
<[({)}]> : 1
[{<}]>() : 2
{<>([}]) : 2
<{(>})[] : 3
[(]<){>} : 3
<([>{)}] : 4
(<{[>})] : 4
(<[{)>}] : 5
<{[(>})] : 5
[{<(]}>) : 6
(<{[)>}] : 6

Answer 1

সিজেম, 18

l7~f&_f{\/~;&}s,2/

কিছু গল্ফিং আইডিয়া জন্য ধন্যবাদ isaacg :)
এটি অনলাইনে চেষ্টা করুন বা সমস্ত উদাহরণ ব্যবহার করে দেখুন

ব্যাখ্যা:

l         read a line of input
7~f&      clear the lowest 3 bits of each character
           the goal is to convert brackets of the same type to the same char
_         duplicate the resulting string, let's call it S
f{…}      for each character in S, and S (the char and S are pushed every time)
  \       swap the character with S
  /       split S around that character, resulting in 3 pieces:
           before, between, after
  ~       dump the pieces on the stack
  ;       pop the last piece
  &       intersect the first 2 pieces
          after the loop, we have an array of strings
          containing the chars interlocking to the left with each char of S
s         join all the string into one string
,         get the string length
2/        divide by 2, because S has duplicated characters

Comments

ওহ, সুতরাং আপনি সেই লোক যিনি সিজেএম তৈরি করেছেন ?? আমি যে সমস্ত উত্তর হারিয়েছি সেগুলির জন্য আপনি আমাকে thatণী, যা সিজেএম উত্তরগুলি দ্বারা পরাজিত হয়েছিল! ;)

— kirbyfan64sos

@ কিরবিফ্যান64 ভাল, আপনি যদি জিততে চান তবে আপনি এটি আরও ভালভাবে শিখতে শুরু করেছিলেন :)

— অ্যাডিটসু

7~f&? আমি এই উত্তরটি ইতিমধ্যে পছন্দ করেছি এবং আমি এটির বাকীটিও পড়িনি।

— ডেনিস

Answer 2

পাইথন 2, 163 বাইট

def f(b,e='([{<)]}>',q=range(4)):
 b=[b[b.index(e[j])+1:b.index(e[j+4])]for j in q]
 print sum(sum(abs(b[k].count(e[j])-b[k].count(e[j+4]))for j in q)for k in q)/2

এটি প্রতিটি জোড়া ম্যাচের বন্ধনীগুলির মধ্যে স্টাফটি দেখায় এবং উপস্থিত বাম বা ডান বন্ধনীগুলির সংখ্যা গণনা করে। এই দুটি দ্বারা বিভক্ত এর যোগফল হয়।

আমি নিশ্চিত এটি আমার চেয়ে আরও ভাল গল্ফাররা আরও অনেক বেশি গল্ফ করতে পারে।

Comments

ঠিক আছে, এটা ঘটেছে। ক্যালভিন একটি উত্তর পোস্ট করেছেন। শেষ সময় আমাদের উপর।

— অ্যালেক্স এ।

Answer 3

জিএনইউ সেড -r, 147

এই মেটা-উত্তর অনুসারে আউটপুট অচেনা ।

y/([{</)]}>/
s/.*/\t& & & & /
:b
y/)]}>/]}>)/
s/\S*>(\S*)>\S* /\1\t/
t
s/\S* //
:
s/(\t\S*)(\S)(\S*)\2(\S*\t)/\1\3\4/
t
s/\S *$/&/
tb
s/\s//g
s/../1/g

দ্রষ্টব্য: সঠিক স্কোর পেতে \tপ্রকৃত tabঅক্ষরগুলি দিয়ে প্রতিস্থাপন করুন । যাইহোক, প্রোগ্রামটি জিএনইউ সেডের সাথে কোনওভাবেই কাজ করবে।

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

Answer 4

পার্ল, 77 বাইট

76 কোড + 1 স্যুইচ

perl -pe 'y/)]}>/([{</;for$x(/./g){$h{$x="\\$x"}++&&s!$x(.*)$x!$z+=length$1,$1!e}$_=$z'

STDIN থেকে ইনপুট নেয় এবং প্রতিটি ইনপুটটির জন্য প্রোগ্রামটি অবশ্যই নতুন করে শুরু করা উচিত।

ব্যাখ্যা

1. সমস্ত বন্ধ বন্ধনীগুলি তাদের উন্মুক্ত অংশগুলির ( y/.../.../) দিয়ে প্রতিস্থাপন করুন ।
2. তারপরে, ইনপুট স্ট্রিং ( for$x...) এর প্রতিটি অক্ষরের জন্য, ( $h{$x}++) অক্ষরের জন্য একটি পাল্টা বাড়ান ।
3. যদি আমরা এই চরিত্রটি দ্বিতীয়বার দেখতে পাই তবে দুটি ঘটনাগুলির মধ্যে দূরত্বটি পান (length $1 ) এর এবং এই চরিত্রের উভয় ঘটনাটি স্ট্রিং থেকে সরান। উদাহরণস্বরূপ, যদি স্ট্রিংটি ছিল ([{([{<<তবে দুটি অক্ষর [এবং {দুটি (s এর মধ্যে রয়েছে। (গুলি প্রক্রিয়া করার পরে , স্ট্রিংটি হয়ে যায় [{[{<<এবং আমরা $zইন্টারলকিং বন্ধনীগুলির মোট সংখ্যায় ( ) যোগ করি ।
4. ফলাফল থেকে নেওয়া হয় $z( $_=$z)

Answer 5

পাইথ, 20 বাইট

JmC/CdTzlsm@FPcsJd{J

পরীক্ষা স্যুট

JmC/CdTz: প্রথমত, এটি প্রতিটি প্রতীক জুটিকে প্রতিটি ইনপুট অক্ষরকে তার অক্ষর কোড ( Cd) দ্বারা 10 ( / T) দ্বারা বিভক্ত করে একটি একক অক্ষরে রূপান্তর করে , যা প্রতিটি জোড়ের জন্য সমান তবে সমস্ত জোড়ের মধ্যে পৃথক। ফলাফলটি পরে প্রকাশের উদ্দেশ্যে উদ্দেশ্যে একটি চরিত্রে ফিরে রূপান্তরিত হয় (C ) । অক্ষরের ফলাফলের তালিকাতে সংরক্ষণ করা হয় J।

lsm@FPcsJd{J: এখন, আমরা J( {J) এর মধ্যে অনন্য অক্ষরগুলির উপরে ম্যাপ করি । আমরা Jবর্তমান চরিত্রটিকে ডিলিমেটার ( csJd) হিসাবে ব্যবহার করে সংযুক্ত করে স্ট্রিংটি কেটে শুরু করি । একটি জোড়া বন্ধনী বর্তমান জুটিকে ওভারল্যাপ করে যদি এটি দ্বিতীয় গ্রুপে হয় এবং তা হয় প্রথম বা তৃতীয় গ্রুপে। দ্বিগুণ গণনা এড়াতে, আমরা কেবল প্রথম এবং দ্বিতীয় গ্রুপ কেস গণনা করব। সুতরাং, আমরা তৃতীয় গোষ্ঠী ( P) সরিয়ে ফেলব এবং অবশিষ্ট গোষ্ঠীগুলির ছেদটি ( @F) নিলাম । অবশেষে, আমরা ওভারল্যাপের অক্ষরগুলি ( s) কনটেটেট করি এবং পুনরায় ফলাফলের দৈর্ঘ্য ( ) মুদ্রণ করি l।

Answer 6

পাইথন 3, 107

t=0
s=""
for x in input():s+=chr(ord(x)&~7)
for x in s:a=s.split(x);t+=len(set(a[0])&set(a[1]))
print(t//2)

আলগাভাবে আমার সিজেএম সমাধানের উপর ভিত্তি করে।

Answer 7

রেটিনা , 128 108 64 62 55 বাইট

(T`)]>}`([<{
(\D)(.*)\1(.*)
\n$2\n$3
(?=(\D).*\n.*\1)
1
\n
<empty>

যেখানে <empty>একটি খালি ট্রেলিং লাইন উপস্থাপন করে। গণনা উদ্দেশ্যে, প্রতিটি লাইন পৃথক ফাইলে রাখুন, এবং \nপ্রকৃত লাইনফিড অক্ষরগুলির সাথে প্রতিস্থাপন করুন । সুবিধার জন্য, আপনি -sএকটি একক ফাইলের পতাকা সহ এই সমতুল্য কোডটি ব্যবহার করতে পারেন :

(T`)]>}`([<{
(\D)(.*)\1(.*)
#$2#$3
(?=(\D)[^#]*#[^#]*\1)
1
#
<empty>

আউটপুট একরকম ।

ব্যাখ্যা

প্রথমটি (রেটিনাকে বলে যে কোনও কোডটি কোনও স্ট্রিং পরিবর্তন করা বন্ধ না করা পর্যন্ত পুরো কোডটি একটি লুপে চালিত করে। এই ক্ষেত্রে, এটি সর্বদা চার বার পুনরাবৃত্তি হবে, প্রতিটি বন্ধনী টাইপের জন্য একবার।

T`)]>}`([<{

এটি কেবল প্রতিটি ক্লোজিং বন্ধনীটিকে সংশ্লিষ্ট প্রারম্ভিক বন্ধনীতে রূপান্তরিত করে, যাতে আমরা পরে বন্ধনীকরণের সাথে সামঞ্জস্য করা বন্ধনীগুলির সাথে মেলাতে পারি। (এই পর্যায়টি প্রথম পুনরাবৃত্তির পরে কোনও অনিঃপ্রকাশে পরিণত হয় It's এটি কেবলমাত্র লুপের মধ্যে অন্তর্ভুক্ত রয়েছে, কারণ Tইতিমধ্যে একটি ব্যাকটিক প্রয়োজন, সুতরাং (দুটি বাইটের পরিবর্তে ব্যয় যোগ করা ।)

(\D)(.*)\1(.*)
\n$2\n$3

এটি নিউলাইনগুলি সহ বাম-জুটির বন্ধনীকে প্রতিস্থাপন করে। আমরা গণনার জন্য লুপে পরে যুক্ত করা \Dএসগুলি থেকে বন্ধনীগুলি পৃথক করতে ব্যবহার 1করি। (.*)শেষ নিশ্চিত করে যে শুধুমাত্র এক জোড়া প্রতিস্থাপিত হয় এ (কারণ মিল ওভারল্যাপ করতে পারেন)।

(?=(\D).*\n.*\1)
1

পুরো রেজেক্স এক চেহারাতে আছে, সুতরাং এটি একটি অবস্থানের সাথে মেলে । আরও সুনির্দিষ্টভাবে এটি প্রতিটি জোড়া বন্ধনীগুলির জন্য একটি অবস্থানের সাথে মেলে যা অন্য বন্ধনী দ্বারা পৃথক করা হয়েছে যা আমরা সবে নতুন লাইনে পরিণত করেছি। একজন 1এইসব অবস্থান প্রতিটি ঢোকানো হয়। আমরা কেবল 1সেখানেই ছেড়ে দিতে পারি, কারণ তারা অন্যান্য রেগেক্সগুলির কোনওটিকে প্রভাবিত করে না (কারণ এটি \Dনিশ্চিত করে যে আমরা তাদের সাথে দুর্ঘটনাক্রমে মেলে না)।

\n
<empty>

শেষ অবধি, আমরা নিউলাইনগুলি সরিয়ে ফেলি (যেমন বর্তমান ধরণের বন্ধনীগুলির জন্য স্থানধারক) - এর অর্থ হ'ল আমরা বাকী সমস্যাটি কেবলমাত্র 3 ধরণের বন্ধনীর সাথে দৈর্ঘ্যের 6 স্ট্রিংয়ে হ্রাস করেছি, তবে অন্যথায় এটি ঠিক একইরকম কাজ করে।

শেষে, কেবলমাত্র 1আমরা সন্নিবেশ করানো বামগুলি থাকবে এবং তাদের পরিমাণ ইন্টারলকিং বন্ধনীর সংখ্যার সাথে সামঞ্জস্য করে।

Answer 8

জাভাস্ক্রিপ্ট (ES7), 121 117 বাইট

x=>(a=b=0,[for(c of x)for(d of'1234')(e=c.charCodeAt()/26|0)==d?a^=1<<d:b^=(a>>d&1)<<d*4+e],f=y=>y&&y%2+f(y>>1))(b)/2

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

কিভাবে এটা কাজ করে

আমরা প্রথমে ভেরিয়েবল সেট aএবং bকরতে 0। aএকটি 4-বিট বাইনারি অ্যারে যা বন্ধন জোড়া বর্তমানে আমরা ভিতরে রয়েছি এবংb এটি একটি 16-বিট বাইনারি অ্যারে যার বন্ধনী জোড়া এক সাথে যুক্ত linked

এর পরে, প্রতিটি অক্ষর মাধ্যমে আমরা লুপ cমধ্যে x, এবং প্রতিটি গৃহস্থালির কাজ dমধ্যে '0123'। প্রথমে আমরা নির্ধারণ করি কী ধরণের বন্ধনী cরয়েছে e=c.charCodeAt()/26-1|0। প্রতিটি বন্ধনী ধরণের দশমিক চর কোডগুলি নিম্নরূপ:

() => 40,41
<> => 60,62
[] => 91,93
{} => 123,125

26 কে ভাগ করে 1 টি বিয়োগ করে এবং মেঝে দিয়ে আমরা যথাক্রমে 0, 1, 2 এবং 3 এ ম্যাপ করি।

পরবর্তী আমরা পরীক্ষা করে দেখি যে এই সংখ্যাটি বর্তমান মানের সমান কিনা d। যদি এটি হয় তবে আমরা হয় dবন্ধনী প্রকারটি প্রবেশ করানো বা প্রস্থান করছি , সুতরাং আমরা dএর aসাথে বিটটি ফ্লিপ করব a^=1<<d। যদি তা না, কিন্তু আমরা হয় ভিতরে dতম বন্ধনী টাইপ, আমরা টুসকি প্রয়োজন eম বিট dএর ম 4-বিট অধ্যায় b। এটি এভাবে করা হয়:

b^=(a>>d&1)<<d*4+e

(a>>d&1)dমধ্যে বিট ফিরে a। আমরা যদি dবন্ধনী ধরণের ভিতরে থাকি তবে এটি 1 প্রদান করে; অন্যথায়, এটি 0. ফিরে আসে, এর পরে, আমরা d*4+eবিট দ্বারা এই বাম স্থানান্তরিত করব , এবং bফলস্বরূপ XOR । আমরা যদি dবন্ধনী প্রকারের ভিতরে থাকি তবে এই এক্সওআর এর d*4+eবিট b; অন্যথায়, এটি কিছুই করে না।

সমস্ত লুপিংয়ের শেষে, bপছন্দসই রিটার্ন মানের দ্বিগুণ সমান 1-বিট সংযুক্ত থাকবে। তবে আমাদের এখনও এটি নির্ধারণ করতে হবে যে এটি কতগুলি বিট। সাব-ফাংশনটি এখানে fআসে:

f=y=>y&&y%2+f(y>>1)

যদি y0, এই কেবল ফেরৎ 0. অন্যথায়, এটি শেষ বিট লাগে yসঙ্গে y%2, তারপর সব কিন্তু শেষ প্রান্তে চলমান ফলাফলের যোগ yফাংশন মাধ্যমে আবার। উদাহরণ স্বরূপ:

f(y)         => y && y%2 + f(y>>1)
f(0b1001101) =>       1  + f(0b100110) = 4
f(0b100110)  =>       0  + f(0b10011)  = 3
f(0b10011)   =>       1  + f(0b1001)   = 3
f(0b1001)    =>       1  + f(0b100)    = 2
f(0b100)     =>       0  + f(0b10)     = 1
f(0b10)      =>       0  + f(0b1)      = 1
f(0b1)       =>       1  + f(0b0)      = 1
f(0b0)       => 0                      = 0

আমরা bএই ফাংশনটি দিয়ে চলি এবং ফলাফলটিকে 2 দ্বারা ভাগ করি এবং আমাদের উত্তর আছে।

Answer 9

ওরাকল এসকিউএল 11.2, 206 বাইট

WITH v AS(SELECT b,MIN(p)i,MAX(p)a FROM(SELECT SUBSTR(TRANSLATE(:1,'])>}','[(<{'),LEVEL,1)b,LEVEL p FROM DUAL CONNECT BY LEVEL<9)GROUP BY b)SELECT COUNT(*)FROM v x,v y WHERE x.i<y.i AND x.a<y.a AND y.i<x.a;

আন-গল্ফড:

WITH v AS( -- Compute min and max pos for each bracket type
           SELECT b,MIN(p)i,MAX(p)a 
           FROM   ( -- replace ending brackets by opening brakets and split the string  
                    SELECT SUBSTR(TRANSLATE(:1,'])>}','[(<{'),LEVEL,1)b,LEVEL p 
                    FROM DUAL 
                    CONNECT BY LEVEL<9
                  )
           GROUP BY b
         )
SELECT COUNT(*)
FROM   v x,v y
WHERE  x.i<y.i AND x.a<y.a AND y.i<x.a -- Apply restrictions for interlocking brackets