इंटरलॉकिंग ब्रैकेट

Question

एक प्रोग्राम या फ़ंक्शन लिखें जो आठ बाइट स्ट्रिंग ()[]{}<>में किसी भी तरह से व्यवस्थित वर्णों में से प्रत्येक में होता है जैसे कि चार संबंधित ब्रैकेट प्रकार मेल खाते हैं। उदाहरण के लिए, ]<([){}>अमान्य इनपुट है क्योंकि वर्ग कोष्ठक मेल नहीं खाते (हालांकि अन्य सभी करते हैं)।

किसी पूर्णांक को प्रिंट या वापस 0करना 6यह दर्शाता है कि चार ब्रैकेट प्रकारों के छह संभावित युग्मों में से कितने इंटरलॉक किए गए हैं। ब्रैकेट प्रकार जोड़े को इंटरलॉक किया गया माना जाता है यदि एक प्रकार का एक ब्रैकेट दूसरे प्रकार के ब्रैकेट के बीच होता है। तो ([)]और [(])इंटरलॉक कर रहे हैं लेकिन ()[], [](), ([]), और [()]नहीं कर रहे हैं।

बाइट्स में सबसे छोटा कोड जीतता है।

इनपुट / आउटपुट उदाहरण

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

Answer 1

CJam, 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

ओह, तो आप CJam बनाने वाले आदमी हैं ?? आपने मुझे जितने जवाब खो दिए, उन सभी के लिए मैं सीजेएम के जवाब से हार गया! ;)

— kirbyfan64sos

@ kirbyfan64sos अच्छी तरह से, यदि आप जीतना चाहते हैं तो आप इसे सीखना बेहतर शुरू करेंगे :)

— aditsu

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

GNU sed -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वर्णों के साथ बदलें । हालाँकि, प्रोग्राम GNU सेड के साथ किसी भी तरह से काम करेगा।

इसे ऑनलाइन आज़माएं ।

Answer 4

पर्ल, 77 बाइट्स

76 कोड + 1 स्विच

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

एसटीडीआईएन से इनपुट लेता है और प्रोग्राम को हर इनपुट के लिए नए सिरे से शुरू करना चाहिए।

व्याख्या

1. अपने खुले समकक्षों ( y/.../.../) के साथ सभी समापन कोष्ठक बदलें ।
2. फिर, इनपुट स्ट्रिंग ( for$x...) में प्रत्येक वर्ण के लिए, वर्ण के लिए एक काउंटर बढ़ाएँ ( $h{$x}++)।
3. यदि यह दूसरी बार है जब हम चरित्र को देख रहे हैं, तो दो आवृत्तियों ( length $1) के बीच की दूरी प्राप्त करें और स्ट्रिंग से इस वर्ण के दोनों आवृत्तियों को हटा दें। उदाहरण के लिए, यदि स्ट्रिंग थी ([{([{<<, तो दो अक्षर हैं [और {दोनों के बीच (। (एस संसाधित होने के बाद , स्ट्रिंग बन जाती है [{[{<<और हम $zइंटरलॉकिंग ब्रैकेट की कुल संख्या ( ) में 2 जोड़ देते हैं ।
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)

मेरे CJam समाधान पर आधारित है।

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`)]>}`([<{

यह बस प्रत्येक क्लोजिंग ब्रैकेट को संबंधित ओपनिंग ब्रैकेट में बदल देता है, जिससे हम बाद में एक साधारण बैकरेस्ट के साथ संबंधित ब्रैकेट्स का मिलान कर सकते हैं। (यह मंच पहले पुनरावृत्ति के बाद एक नो-ऑप बन जाता है। यह केवल लूप में शामिल है, क्योंकि Tपहले से ही एक बैकटिक की आवश्यकता है, इसलिए (दो बाइट्स के बजाय केवल एक ही लागत जोड़ना है ।)

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

यह नई सुर्खियों के साथ सबसे अधिक जोड़ी वाले कोष्ठक की जगह लेता है। हम \Dउस ब्रैकेट से अंतर करने के लिए उपयोग 1करते हैं, जिसे हम बाद में गिनती के लिए लूप में जोड़ते हैं। (.*)अंत सुनिश्चित होगा कि केवल एक जोड़ी बदल दिया जाता है पर (क्योंकि मैचों नहीं ओवरलैप कर सकते हैं)।

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

संपूर्ण रेगेक्स लुकहेड में है, इसलिए यह एक स्थिति से मेल खाता है । अधिक विशेष रूप से यह प्रत्येक जोड़ी कोष्ठक के लिए एक स्थिति से मेल खाता है जिसे अन्य कोष्ठकों द्वारा अलग किया गया है जिसे हम सिर्फ नई सुर्खियों में बदल गए हैं। 1इनमें से प्रत्येक स्थिति में A डाला गया है। हम सिर्फ 1एस को वहां छोड़ सकते हैं , क्योंकि वे किसी भी अन्य रेगेक्स को प्रभावित नहीं करते हैं (क्योंकि यह \Dसुनिश्चित करता है कि हम उन्हें दुर्घटना से मेल नहीं खाते)।

\n
<empty>

अंत में, हम newlines (यानी मौजूदा प्रकार के कोष्ठक के लिए प्लेसहोल्डर) को हटाते हैं - इसका मतलब है कि हमने शेष समस्या को 6 की एक स्ट्रिंग तक घटा दिया है जिसमें केवल 3 प्रकार के ब्रैकेट हैं, लेकिन अन्यथा यह बिल्कुल उसी तरह काम करता है।

अंत में, केवल 1हमारे द्वारा डाला गया शेष बचा रहेगा, और उनकी राशि इंटरलॉकिंग कोष्ठक की संख्या से बिल्कुल मेल खाती है।

Answer 8

जावास्क्रिप्ट (ईएस 7), 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। a4-बिट बाइनरी सरणी है, जो ब्रैकेट जोड़े हम वर्तमान में अंदर हैं, और b16-बिट बाइनरी सरणी है जिसमें ब्रैकेट जोड़े एक साथ जुड़े हुए हैं।

अगला, प्रत्येक चरित्र के माध्यम से हम पाश 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 , तो हमें वें 4-बिट अनुभाग eमें वें बिट को फ्लिप करना होगा । यह इस तरह किया जाता है:db

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

(a>>d&1)में dवें बिट लौटाता है a। यदि हम dवें ब्रैकेट प्रकार के अंदर हैं , तो यह 1 देता है; अन्यथा, यह 0. लौटाता है। अगला, हम इसे d*4+eबिट्स द्वारा छोड़ दिया है , और XOR bपरिणाम द्वारा। यदि हम dth ब्रैकेट प्रकार के अंदर हैं , तो यह XORs के 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

Oracle SQL 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