उपसर्ग संकेतन उपसर्ग संकेतन

Question

अस्वीकरण: नहीं, यह एक स्ट्रिंग को उलटने के लिए एक मजाक चुनौती नहीं है।

कार्य

समर्थन करने के लिए केवल एक ऑपरेशन है: घटाव ( -)।

आपके पास भी समर्थन के लिए केवल दो परमाणु हैं: शून्य ( 0) और एक ( 1)।

यहाँ, उपसर्ग संकेतन उपसर्ग संकेतन -ABके बराबर है AB-, जहाँ Aऔर Bअभिव्यक्ति हैं।

आपका कार्य (पुनरावर्ती) एक अभिव्यक्ति को उपसर्ग संकेतन में बदलकर उसके उपसर्ग संकेतन में समतुल्य कर देता है।

परिभाषाएं

उपसर्ग संकेतन में एक अभिव्यक्ति निम्नलिखित व्याकरण द्वारा उत्पन्न होती है:

S > -SS
S > 0
S > 1

पोस्टफ़िक्स अंकन में एक अभिव्यक्ति निम्नलिखित व्याकरण द्वारा उत्पन्न होती है:

S > SS-
S > 0
S > 1

उदाहरण

Prefix notation:  --01-0-01
Parentheses:      -(-01)(-0(-01))
Convert:          (01-)(0(01-)-)-
Postfix notation: 01-001---

नियम और स्वतंत्रता

• जब तक यह संगत है आप ऑपरेशन और परमाणुओं का नाम बदल सकते हैं।
• इनपुट प्रारूप आउटपुट प्रारूप के अनुरूप होना चाहिए (इस तथ्य के अलावा कि इनपुट उपसर्ग संकेतन में है और आउटपुट उपसर्ग संकेतन में है)।

परीक्षण का मामला

Input       Output
1           1
0           0
-01         01-
-10         10-
--01-0-01   01-001---

दादा को क्रेडिट का परीक्षण ।

Comments

क्या आप कुछ और परीक्षण मामलों को जोड़ सकते हैं, कृपया?

— झबरा

@ पता है कि आप किस तरह के टेस्टकेस चाहेंगे?

— लीक नून

@LeakyNun क्या पुनरावृत्तियों के रूप में इनपुट और आउटपुट लेना ठीक है, जैसा कि मैंने अपने उत्तर के नवीनतम संस्करण में किया है?

— L3viathan

@ L3viathan मुझे ऐसा लगता है ...

— लीक नून

Answer 1

ब्रेनफक , 32 बाइट्स

,[[->++++<<+>]>[[-]<<[.[-]<]]>,]

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

मैंने @ऑपरेशन के रूप में उपयोग किया , क्योंकि इसका कोड पॉइंट (64) सुविधाजनक है। U3 * 85 + 1 = 256 = 0 का उपयोग करके समान बाइट गिनती के साथ भी संभव है।

व्याख्या

टेप का उपयोग स्टैक के रूप में किया जाता है। मुख्य लूप के प्रत्येक पुनरावृत्ति में, डेटा पॉइंटर स्टैक के शीर्ष पर दो कोशिकाओं को शुरू करता है।

,[                Take input and start main loop
  [->++++<<+>]    Push input, and compute 4*input
  >[              If 4*input is nonzero (and thus input is not @):
    [-]<<           Zero out this cell and move to top of stack
    [.[-]<]         Pop from stack and output until \0 is reached
  ]
  >,              Move pointer into the correct position.  If input was @, the earlier > pushed \0 onto the stack.
]

Answer 2

रेटिना , 37 30 29 बाइट्स

M!`-*.
+m`^-(.*)¶(\d.*)
$1$2-

इसे ऑनलाइन आज़माएं! 7 बाइट्स को यह महसूस करते हुए सहेजा गया कि शब्द हमेशा एक अंक से शुरू होते हैं, इसलिए मुझे मैच को -किसी भी अंतिम तक सीमित नहीं करना पड़ता है (पहले यह केवल दो शर्तों का पालन करने की गारंटी थी)। -अपनी लाइन में एस न लगाकर 1 बाइट को बचाया । उदाहरण के लिए, -01वह बन जाता है -0¶1जिसे बाद में बदल दिया जाता है 01-। अब, अगर मेरे पास है --010यानी --0¶1¶0तब मैं भीतरी बदलना चाहते -0¶1करने के लिए 01-इतना है कि मैं जगह ले सकता है -01-¶0के साथ 01-0-, लेकिन यह वास्तव में बात नहीं करता है, जिनमें से दो -रों मैं निकालें, तो मैं पंक्ति के आरंभ में एक को निकालने के रूप में, के लिए परीक्षण करना आसान है।

Comments

मुझे लगता है कि यह आपका कुछ है :)

— लियो

@ लियो सामान्य रूप से काम नहीं करता है, जैसे -0-0-00बनना चाहिए 0000---।

— नील

आप सही हैं, क्षमा करें। मेरे पास एक और विचार है, लेकिन यह काफी हद तक अलग है, इसलिए मैं इसे एक नए उत्तर के रूप में पोस्ट करूंगा

— लियो

@ अब मैंने अपना कुछ पाया है ...

— नील

@ मेरे नवीनतम गोल्फ के साथ हम बंधे हैं!

— नील

Answer 3

हास्केल , 62 59 बाइट्स

f(x:r)|x>'-'=([x],r)|(a,(b,c))<-f<$>f r=(a++b++"-",c)
fst.f

इसे ऑनलाइन आज़माएं! उपयोग: fst.f $ "--01-0-01"। 0और 1मनमाने चरित्र हो सकते हैं जो चरित्र से बड़े हैं -।

संपादित करें: -3 बाइट्स जर्ब के लिए धन्यवाद!

फ़ंक्शन fपुनरावर्ती रूप से एक अभिव्यक्ति को पार्स करता है और पोस्टफ़िक्स अंकन और बाकी स्ट्रिंग में इस अभिव्यक्ति का एक टपल देता है, सरल व्याकरण का अनुसरण करता है जिसमें से वैध उपसर्ग-अभिव्यक्ति का निर्माण किया जा सकता है:

<exp> ::= - <exp> <exp> | 0 | 1

यदि aइनपुट स्ट्रिंग का पहला वर्ण इससे बड़ा है -, तो हम एक परमाणु अभिव्यक्ति पर हैं और एक स्ट्रिंग का टपल चरित्र aऔर शेष इनपुट स्ट्रिंग के साथ लौटाते हैं ।

यदि हम पाते हैं -, दो भावों को पार्स किया जाना चाहिए। यह द्वारा प्राप्त किया जा सकता (a,x)<-f rपहली अभिव्यक्ति पाने के लिए aऔर उसके बाद बाकी स्ट्रिंग पार्स xफिर (b,c)<-f xदूसरी अभिव्यक्ति पाने के लिए bऔर अंतिम बाकी स्ट्रिंग c। (a,(b,c))<-f<$>f rवास्तव में ऐसा इसलिए होता है क्योंकि <$>ट्यूपल्स पर एक फ़ंक्शन होता है जो कि तीन बाइट्स से छोटा होने के दौरान एक ट्यूपल का दूसरा तत्व है (a,x)<-f r,(b,c)<-f x। दोनों अभिव्यक्तियों और बाकी स्ट्रिंग को प्राप्त करने के बाद, अभिव्यक्तियों को संक्षिप्त किया जाता है और एक "-" जोड़ा जाता है (a++b++"-",c):।

Comments

आप मामलों को मिलाकर 3 बाइट्स बचा सकते हैं:f(x:r)|x>'-'=([x],r)|(a,(b,c))<-f<$>f r=(a++b++"-",c)

— ज़गारब

@Zgarb धन्यवाद! किसी कारण के लिए मैंने केवल f(x:r)|x<'0',(a,(b,c))<-f<$>f r=(a++b++"-",c)|1<3=([x],r)तब विचार किया जब मैंने दोनों मामलों के साथ एक संस्करण की तलाश की, जो अब बाइट है।

— लैकोनी

Answer 4

हास्केल, 54 बाइट्स

v f""=""
v f(a:s)=last(v.v:[id|a>'-'])((a:).f)s
h=v h

फ़ंक्शन vएक स्ट्रिंग और एक फ़ंक्शन लेता है, प्रारंभिक उप-अभिव्यक्ति को फिर से व्यवस्थित करता है, फिर फ़ंक्शन को स्ट्रिंग के शेष तक लागू करता है जब तक कि सब कुछ पुनर्व्यवस्थित नहीं किया गया हो। कॉल स्टैक और फ़ंक्शन तर्क एक साथ रखते हैं कि किस अभिव्यक्ति को पार्स किया जा रहा है। फ़ंक्शन hचुनौती का जवाब देता है, और केवल vअपने आप को एक डमी पहले तर्क के रूप में कहा जाता है।

Comments

वाह! (१) यह सिर्फ ५३ है, आपको अंतिम न्यूलाइन गिनने की आवश्यकता नहीं है। (२) पहली पंक्ति को छोटा किया जा सकता है v f l=lयदि आप इसे दूसरे स्थान पर ले जाते हैं।

— अर्जन जोहान्सन

मुझे नहीं लगता कि आपको एक से अधिक संपूर्ण अभिव्यक्ति को पार्स करने की आवश्यकता है, इसलिए आप अनाम फ़ंक्शन का उपयोग करके एक बाइट बचा सकते हैं v id।

— अर्जन जोहान्सन

वास्तव में पहली पंक्ति को वैध इनपुट पर कभी नहीं बुलाया जाता है, इसलिए आप इसे हटा सकते हैं।

— अर्जन जोहान्सन

गार्ड में बंटवारा lastएक बाइट से चाल को हरा देता है ।

— अर्जन जोहान्सन

Answer 5

पर्ल 5 , 57 बाइट्स

sub f{"@_"=~s/x((?0)|.)((?0)|.)/my$n=$2;f($1).f($n).x/re}

मैं xइसके बजाय ऑपरेटर के रूप में उपयोग करता हूं -(ट्राय इटऑनलाइन लिंक बोलो देखें)।

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

स्पष्टीकरण:
/x((?0)|.)((?0)|.)/ पुनरावर्ती रूप से एक पूर्ण अभिव्यक्ति से मेल खाता है: एक xशुरुआत में, फिर एक अभिव्यक्ति (?0)(यह एक पुनरावर्ती कॉल) या एक परमाणु ( .) है, इसके बाद एक और अभिव्यक्ति या परमाणु है।
फिर मुझे दूसरी अभिव्यक्ति / परमाणु ( my$n=$2;) को बचाने की आवश्यकता है क्योंकि अन्यथा पुनरावर्ती कॉल इसे ओवरराइड करेंगे।
फिर फ़ंक्शन को पहले अभिव्यक्ति ( f($1)), फिर दूसरे पर f($n), और xअंत में जोड़ा जाता है ( .x) पर पुनरावर्ती रूप से कहा जाता है ।

Answer 6

अजगर 3, 117 112 105 100 98 76 62 61 59 बाइट्स

def p(s):x=next(s);yield from[x]*(x>"-")or[*p(s),*p(s),"-"]

बदलाव का:

• जहां संभव हो वहां से हटाए गए लाइनब्रेक (-5 बाइट्स)
• एक पूर्ण कार्य के बदले लंबोदर (-7 बाइट्स, धन्यवाद @ दादा)
• कोई और नहीं (-5 बाइट्स, धन्यवाद @ लीक नन)
• पूर्व-विशाल गोल्फ (-2 बाइट्स, धन्यवाद @ लीके नन)
• इसके बजाय वैश्विक सूची में काम करें (-22 बाइट्स)
• वास्तव में, इसके बजाय (14 बाइट्स) पुनरावृत्तियों पर काम करते हैं
• बदलने !=के लिए >(-1 बाइट, @ovs 'सुझाव से नकल)
• आलसी मूल्यांकन प्रवंचना (-2 बाइट्स, धन्यवाद @ लव)

इसे इस तरह उपयोग करें:

>>> list(p(iter("--01-0-01")))
['0', '1', '-', '0', '0', '1', '-', '-', '-']

Comments

काम नहीं करता क्योंकि आप भूल गए थेreturn

— लीक नन

lambda x:p(x)[0]शायद आपके fकार्य को प्रतिस्थापित कर सकता है ।

— दादा

आपको जरूरत नहीं है else, मेथिंक की।

— लीक नून

क्या d="-"वास्तव में बाइट्स बचाने के लिए?

— लीक

def p(s):x=next(s);yield from[x]*(x>"-")or[*p(s),*p(s),"-"]59 बाइट्स के लिए

— ovs

Answer 7

अजगर, 20 बाइट्स

L+&-hbTsyM.-Btbytbhb

यह एक फ़ंक्शन बनाता है yजो पैरामीटर के रूप में एक स्ट्रिंग की अपेक्षा करता है।

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

स्पष्टीकरण:

फ़ंक्शन yपहले उपसर्ग अभिव्यक्ति को पार्स और अभिव्यक्ति में बदल देगा। इसलिए अगर इसे बुलाया जाता है तो यह y"10"केवल वापस आ जाएगा 1।

L+&-hbTsyM.-Btbytbhb
L                      define a function y(b), that returns:
   -hbT                   remove the chars "10" from the first char b
                          (T=10, and - will convert a number to a string)
  &                       if this gives the empty string (a falsy value)
 +                hb         then append b[0] to it and return it
                             (so this will parse a digit 0 or 1 from the string)
  &                       otherwise (the first char is a -)
               ytb           parse the first prefix expression from b[1:]
                             (recursive call)
          .-Btb              remove this parsed expression bifurcated from b[1:]
                             this gives a tuple [b[1:], b[1:] without first expr]
        yM                   parse and convert an expression from each one
       s                     join the results
 +                hb         and append the b[0] (the minus) to it and return

Answer 8

रेटिना , 34 31 29 बाइट्स

;
-;
¶
+`¶(.+);(.+)
$1$2-
;

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

;नोड्स को इंगित करने के लिए उपयोग किया जाता है, जो शुरू में एक ही संख्या से बना होता है और फिर कुछ भी हो जाता है जो पहले से ही पार्स हो चुका है। -इसलिए .+हम नए सिरे से सुर्ख़ियों में बने हैं ताकि हम किसी भी चीज़ को हड़प सकें, जो कि एक अनपैर्सड नहीं है -।

Answer 9

पर्ल 6 , 45 बाइट्स

my&f={S[x(<~~>)**2|)>.]=$0&&$0>>.&f.join~'x'}

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