(लगभग) आप की तरह किसी भी संख्या के साथ एक समीकरण को हल करें

Question

पात्रों की एक स्ट्रिंग को देखते हुए +=-जहां कम से कम एक है =, सभी प्रतीकों के बीच और शुरुआत और अंत में सकारात्मक पूर्णांक डालें जैसे कि गणित समीकरण संतुष्ट हैं।

उदाहरण के लिए, इनपुट दिया गया

+-=-=

आपको इस तरह से एफ के माध्यम से सकारात्मक पूर्णांक ए डालने की आवश्यकता है

A+B-C=D-E=F

ऐसी है कि समीकरण सभी संतुष्ट, यानी कर रहे हैं A + B - Cऔर D - Eऔर Fसभी एक ही संख्या में हैं।

ऐसा करने के कई संभावित तरीके हैं, जब तक समीकरण काम करते हैं, सकारात्मक पूर्णांक के किसी भी सेट का उपयोग किया जा सकता है। यहां प्रत्येक पंक्ति इनपुट के लिए एक संभावित वैध आउटपुट है +-=-=:

2+3-4=6-5=1
1+1-1=2-1=1
4+2-4=4-2=2
100+1-10=182-91=91
89+231-77=1024-781=243

ध्यान दें कि भावों का मान धनात्मक पूर्णांक होना आवश्यक नहीं है जैसे कि सम्मिलित संख्याएँ हैं। उदाहरण के लिए, दिए गए इनपुट -=-आउटपुट 1-10=8-17(-9 तक) और 10-1=17-8(9 के बराबर) दोनों समान रूप से मान्य हैं। बेशक कुछ इनपुटों के लिए जैसे कि =एक नकारात्मक होना असंभव है क्योंकि अभिव्यक्ति केवल सकारात्मक संख्याएं 5=5डाली जा सकती हैं।

ध्यान दें कि शून्य एक सकारात्मक पूर्णांक नहीं है।

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

आप उन्हें सीधे स्ट्रिंग में सम्मिलित करने के बजाय एक सूची के रूप में संख्याओं का उत्पादन कर सकते हैं। यदि आप स्ट्रिंग को आउटपुट करते हैं तो प्रतीकों और संख्याओं को अलग करने वाले स्थान हो सकते हैं। तो, इनपुट के लिए +-=-=, आउटपुट

2, 3, 4, 6, 5, 1

या

2 + 3 - 4 = 6 - 5 = 1

आउटपुट के बराबर है

2+3-4=6-5=1

परीक्षण के मामलों

Input | One Possible Output
= | 1=1
== | 2=2=2
+= | 1+3=4
=+ | 2=1+1
-= | 30-10=20
=- | 1=2-1
=-= | 3=7-4=3
=+= | 2=1+1=2
=== | 100=100=100=100
+=- | 3+2=7-2
-=+ | 7-2=3+2
+=+ | 3+3=3+3
-=- | 1-10=8-17
--= | 60-1-1=58
++= | 60+1+1=62
-+= | 60-9+1=52
+-= | 60+9-1=68
+-=-= | 2+3-4=6-5=1
--=-- | 2-1-1=2-1-1
==-== | 47=47=50-3=47=47
=++=+-=-+=--= | 3=1+1+1=3+1-1=1-1+3=5-1-1=3
+--++-=-+-+- | 35+10-16-29+20+107-1000=5-4+3-2+1-876
====== | 8=8=8=8=8=8=8

Comments

सम्बंधित।

— मार्टिन एंडर

क्या हम सूत्र की लंबाई पर किसी ऊपरी सीमा को मान सकते हैं?

— xnor

@xnor आप मान सकते हैं कि इनपुट 2 ^ 16 वर्णों से कम है यदि यह मदद करता है।

— केल्विन के शौक

Answer 1

रेटिना , 58 बाइट्स

[-+]
$&1
\B((\+1)|(-1))*
$._$*1$#3$*1$#2$*_$&
+`1_

1+
$.&

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

एक ही बाइट गिनती में वैकल्पिक समाधान:

((\+)|(-))*
$._$*1$#3$*1$#2$*_$&
+`1_

([+-])1*
$+1
1+
$.&

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

व्याख्या

मूल विचार सभी +एस और -एस को सरल +1और -1संचालन में बदलना और फिर एक पर्याप्त बड़ी संख्या को तैयार करना है जो सभी समान कार्य करता है। समीकरणों का मिलान करने के लिए, हम उनमें से प्रत्येक के लिए समान संख्या को पूर्व निर्धारित कर सकते हैं, और फिर इसे प्रत्येक के लिए एक घटा सकते हैं +1और इसके -1बाद प्रत्येक के लिए इसे बढ़ा सकते हैं। चूंकि हम एकात्मक संख्याओं के साथ काम कर रहे हैं, एकमात्र पकड़ यह है कि पहली संख्या को पर्याप्त बड़ा होना चाहिए ताकि हम इसे 1 बार कम कर सकें।

[-+]
$&1

हम एक के 1बाद एक -या सम्मिलित करके शुरू करते हैं +।

\B((\+1)|(-1))*
$._$*1$#3$*1$#2$*_$&

यह \Bसुनिश्चित करता है कि ये मैच या तो इनपुट की शुरुआत में हैं, या =एक +या एक के बीच में हैं -, यानी वे सभी पद जहाँ हम एक अभिव्यक्ति की अग्रणी संख्या सम्मिलित करना चाहते हैं। ((\+1)|(-1))*हिस्सा तो बस की संख्या की गणना +1और -1समूहों में रों 2और 3क्रमशः। अब चलो प्रतिस्थापन स्ट्रिंग को तोड़ते हैं:

$._$*1   # For each character in the current string, insert a 1. This is
         # an offset which is the same for each expression and is guaranteed
         # to be large enough that all subsequent +1s can be cancelled.
$#3$*1   # For each -1, insert a 1.
$#2$*_   # For each +1, insert a _.
$&       # Re-insert the string of +1s and -1s.

+`1_

बार-बार 1_स्ट्रिंग से ड्रॉप , +1एस से आवश्यक रद्दीकरण को लागू करना ।

1+
$.&

अंत में, एस के सभी तारों को 1उनकी लंबाई के साथ बदलकर यूनिरी से दशमलव में परिवर्तित करें।

Answer 2

पायथन 2 , 76 बाइट्स

lambda e:sum([[len(e+s)-2*s.count('+')]+[1]*len(s)for s in e.split('=')],[])

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

Comments

क्या आप एक स्पष्टीकरण जोड़ सकते हैं?

— केल्विन के शौक

@ हेलकाहोम्बा विचार काफी सरल है: पहले इनपुट के प्रत्येक भाग को समान संकेतों द्वारा विभाजित करें। प्रत्येक चंक की पहली संख्या चुनें eqtn_len + plus_signs + minus_signs - 2 * plus_signs = eqtn_len + minus_signs - plus_signs। तब से चंक में अन्य सभी संख्याएं हैं, चंक के लिए कुल काम करता है eqtn_len + minus_signs - plus_signs - minus_signs + plus_signs = eqtn_len। समीकरण की लंबाई सकारात्मक होनी चाहिए, इसलिए सब कुछ काम करता है।

— FryAmTheEggman

Answer 3

पायथन 2, 199 179 178 172 162 158 156 152 151 बाइट्स

रास्ता बहुत लंबा है, लेकिन समाधान बनाना आसान था।

from itertools import*
i=input()
k='%s'
s=k+k.join(i)+k
for p in product(*[range(1,65537)]*-~len(i)):
    if eval((s%p).replace('=','==')):print s%p;break

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

यह हर संभावना की कोशिश करेगा जब तक कि यह एक समाधान नहीं ढूंढता। कार्यक्रम बेहद धीमा है। यह हर पुनरावृत्ति को स्ट्रिंग प्रतिस्थापन भी करता है। "172" के संपादन ने इसे काफी धीमा बना दिया , क्योंकि एक छोटी सी सीमा के साथ शुरू होने के बजाय यह अधिकतम पर शुरू होता है। उदाहरण के लिए, इनपुट -=या =+समाधान तक पहुंचने से पहले 2 ** 32 प्रयास करने होंगे।

प्रोग्राम को गति देने के लिए, संपादित इतिहास से 178 बाइट वाले संस्करण का उपयोग करें।

Comments

क्या rangepython2 तुरंत एक सूची के रूप में पूरी रेंज नहीं बनाता है? IIRC आप xrangeइसके बजाय का उपयोग करके इसे गति प्रदान कर सकते हैं , जैसा कि मुझे लगता है कि यह आलसी-लोडिंग संस्करण है (Python3 डिफ़ॉल्ट के रूप में आलसी का उपयोग करता है range)

— Deloth

@ डेलियोथ जो एक अन्य बाइट का उपयोग करता है, हालांकि। बाइट निकालने का लक्ष्य है । इसके अलावा, यह वास्तव में बहुत अधिक गति प्रदान नहीं करेगा, क्योंकि मंदी का अधिकांश हिस्सा पुनरावृत्तियों की संख्या से है, न कि सूची के निर्माण से, जो केवल एक बार होता है। मैं भागा print range(1,65537)और यह 0.034 सेकेंड में पूरा हुआ।

— mbomb007

ठीक है, निश्चित रूप से- "यह अधिक समान कार्यप्रणाली के साथ इसे गति दे सकता है," इसके बारे में इतनी देर लगने की चिंता है। मेमोरी थ्रैशिंग महत्वपूर्ण मंदी का कारण बन सकता है। इसके अलावा, आप सेटिंग न करके कुछ बाइट्स (शायद केवल 1) काट सकते हैं l=..., लेकिन उस अधिकार को इसमें डाल सकते हैं product(range(...),repeat=len(s)+1)। यदि आपको कोष्ठक की आवश्यकता है तो यह केवल एक बाइट (\ n)

— 22

@ डेलियॉथ को भले ही मुझे आसपास परिंदों की आवश्यकता थी len(s)+1, मैं -~len(s)इसके बजाय उपयोग कर सकता था, जिसके लिए परिजनों की आवश्यकता नहीं होगी।

— mbomb007

ठीक है। मैं हमेशा बिटवाइज ऑपरेशंस और ट्रिक्स के बारे में भूल जाता हूं- होना चाहिए कि फ्रंटएंड जावास्क्रिप्ट पर काम कर रहा टोल मेरी पायथन विशेषज्ञता पर ले रहा है!

— रात्रि

Answer 4

जावास्क्रिप्ट (ईएस 6), 92 82 बाइट्स

@Xnor से एक ट्रिक के साथ 8 बाइट्स गिए

let f =
x=>x.split`=`.map(q=>(x+q).length-2*~-q.split`+`.length+[...q,''].join(1)).join`=`

<input oninput="if(/^[+=-]+$/.test(value))O.innerHTML=f(value)" value="="><br>
<pre id=O>1=1</pre>

चाल यहाँ एक डालने के लिए है 1हर के बाद +या -तो प्रत्येक अभिव्यक्ति करने के लिए संख्या है कि अभिव्यक्ति इनपुट की लंबाई के बराबर पहले जोड़ें। इस तरह हम गारंटी दे सकते हैं कि संख्या हमेशा सकारात्मक है; चूंकि =स्ट्रिंग में हमेशा कम से कम 1 होता है, इसलिए +s की संख्या कभी भी स्ट्रिंग की लंबाई तक नहीं पहुंच सकती है, इसलिए शेष हमेशा कम से कम होता है 1। आप इसे +ऊपर के स्निपेट में मनमाने ढंग से टाइप करके सत्यापित कर सकते हैं ।

Answer 5

पायथन 2 , 120 119 बाइट्स

^{-1 बाइट mbomb007 के लिए धन्यवाद}

a=['1'+(n and('1'.join(n)+'1'))for n in input().split('=')]
print'='.join(`max(map(eval,a))-eval(c)+1`+c[1:]for c in a)

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें

पहले मैं 1हर स्थिति में सम्मिलित करता हूं , उच्चतम मूल्य की जांच करने के लिए, फिर इसे हर समीकरण पर ऑफसेट के रूप में जोड़ता हूं । यह कार्य क्योंकि आप ऋणात्मक संख्याओं को जोड़ नहीं सकते हैं, इसलिए न्यूनतम परिणाम +केवल उस समीकरण की राशि द्वारा दिया जाता है जो केवल है +।

Comments

आप एक दो रिक्त स्थान निकाल सकते हैं।

— mbomb007

Answer 6

जीएनयू प्रोलॉग, 156 बाइट्स

x(L,R,V)-->{E#>0},({L=[E|R],E=V};x(L,[E|R],X),("+",{V#=X+E};"-",{V#=X-E})).
q(L,R,V)-->x(L,T,V),({T=R};"=",q(T,R,V)).
s(Q,L):-q(L,[],_,Q,[]),fd_labeling(L).

व्याख्या

हमें हल करने के लिए समीकरणों का एक गुच्छा मिला है, इसलिए एक वास्तविक समीकरण सॉल्वर का उपयोग क्यों न करें?

xमूल रूप से फॉर्म के समीकरणों के लिए एक समीकरण मूल्यांकनकर्ता है +-+; समीकरण के अलावा, इसमें दो अतिरिक्त तर्क हैं (एक अंतर सूची L,Rजिसमें समीकरण के मान शामिल हैं, और एक मूल्य Vजो समीकरण का मूल्यांकन करता है)। Prolog में हमेशा की तरह, यह किसी भी तरह दौर इस्तेमाल किया जा सकता है (जैसे आप निर्दिष्ट कर सकते Vहैं और एक मिल L,R, निर्दिष्ट L,Rऔर एक मिल V, दोनों को निर्दिष्ट और सत्यापित करें कि मूल्य सही है, या न निर्दिष्ट जिसमें मामले उचित की कमी दोनों पर रखा जाएगा Vऔर L,R)। "वर्तमान तत्व" का L,Rनाम दिया गया है E, और हम एक जोर भी शामिल करते हैंE0 से अधिक है (क्योंकि प्रश्न में सकारात्मक संख्याओं के उपयोग की आवश्यकता है)। यह फ़ंक्शन मेरे द्वारा पसंद किए जाने की तुलना में थोड़ा अधिक क्रियात्मक है, उदाहरण के लिए, मुझे [E|R]दो बार पैटर्न मैच / बेमिसाल लिखना था , इस तथ्य के कारण कि सूचियां सही-सहयोगी हैं लेकिन जोड़ और घटाव बाएं-सहयोगी हैं। अफसोस की बात है, हमें काम करने के लिए, अपने स्वयं के बाएं-साहचर्य सूची प्रकार की कोशिकाओं से बाहर का आविष्कार करने के बजाय, एक वास्तविक सूची का उपयोग करने की आवश्यकता है fd_labeling।

qके समान है x, लेकिन इसमें भी शामिल है =। यह मूल रूप से सिर्फ कॉल करता है x, और स्वयं पुनरावर्ती होता है। संयोग से, यह बहुत स्पष्ट प्रदर्शन है कि अंतर सूचियां कैसे काम करती हैं, यह दिखाते हुए कि आप दो अंतर सूचियों L,Tऔर T,Rएक अंतर सूची में बदल सकते हैं L,R। मूल विचार यह है कि एक अंतर सूची एक आंशिक कार्य है जो एक तर्क लेती है Rऔर एक मान लौटाती है Lजो Rउस सूची के साथ होती है जो इसके लिए पहले से तैयार है। इस प्रकार, एक अंतर सूची के तर्क और दूसरे के वापसी मूल्य की पहचान करके, हम फ़ंक्शन की रचना कर सकते हैं, और इस प्रकार सूची को संक्षिप्त कर सकते हैं।

अंत में s, जो कि कवक है जो वास्तव में प्रश्न में कार्य को हल करता है, एक आवरण फ़ंक्शन है जो qतर्कों के साथ कहता है। हम अंतर सूची को []उसके तर्क के रूप में आपूर्ति करके एक नियमित सूची में परिवर्तित करते हैं , और fd_labelingहमारे द्वारा निर्मित समीकरण का हल खोजने के लिए उपयोग करते हैं। (डिफ़ॉल्ट रूप से, यह मानों को 1 पर सेट करना पसंद करता है यदि उन्हें किसी और चीज़ पर सेट करने का कोई कारण नहीं है। हालांकि, इसे कॉन्फ़िगर किया जा सकता है, value_method(random)उदाहरण के लिए, हर जगह 1s डालने से अधिक "दिलचस्प" समाधान देता है, और अभी भी बहुत तेज़ है। )

नमूना उत्पादन

लिखित कार्यक्रम के साथ:

| ?- s("=++=+-=-+=--=", V).

V = [3,1,1,1,3,1,1,3,1,1,5,1,1,3] ?

अगर मैं प्रोग्राम को जोड़ने के लिए थोड़ी देर करता हूं value_method(random), तो परिणाम बदलता है, लेकिन कुछ इस तरह दिखता है:

| ?- s("=++=+-=-+=--=", V).

V = [68,6,12,50,85,114,131,45,3,26,71,1,2,68] ? 

दोनों मामलों में, ?आउटपुट के अंत में इसका मतलब है कि एक से अधिक समाधान हो सकते हैं। (बेशक, इस मामले में, हम जानते हैं कि एक बात यह है कि वहाँ बहुत से अधिक समाधान!)

Answer 7

गणितज्ञ, ११६ बाइट्स

Join@@(Prepend[#^2,1-Min[Tr/@c]+Tr@#]&/@(c=Characters@StringSplit["0"<>#<>"0","="]/."+"->-1/."-"->1/."0"->Nothing))&

शुद्ध कार्य इनपुट के रूप में एक स्ट्रिंग ले रहा है और सकारात्मक पूर्णांकों की सूची लौटा रहा है। मूल रणनीति: हम केवल 1 को जोड़ते हैं और 1 घटाते हैं, और हम सब कुछ समान बनाने के लिए प्रत्येक अभिव्यक्ति में प्रारंभिक संख्याएँ चुनते हैं।

c=Characters@StringSplit[#,"="]/."+"->-1/."-"->1हर बराबर चिह्न पर इनपुट स्ट्रिंग को विभाजित करेगा, फिर प्रत्येक +को -1प्रत्येक और प्रत्येक के -द्वारा प्रतिस्थापित करेगा 1। हालाँकि, यदि शुरुआत या अंत में एक समान चिह्न है, तो इसे अनदेखा कर दिया जाएगा। इसलिए हम कृत्रिम रूप से प्रत्येक सिरे पर एक नया वर्ण जोड़ते हैं ( "0"<>#<>"0") और स्ट्रिंग-विभाजन पूरा होने ( /."0"->Nothing) के बाद इसे दूर कर देते हैं ।

प्रत्येक सबलिस्ट का कुल अब एक पूर्णांक के बराबर होता है जिसे हम प्रत्येक अभिव्यक्ति के बराबर बनाने के लिए +s और -s के सामने रख सकते हैं । 1-Min[Tr/@c]सबसे छोटा पूर्णांक है जिसे हम सभी को कुल मिलाकर सकारात्मक बना सकते हैं। इसलिए Prepend[#^2,1-Min[Tr/@c]+Tr@#]&प्रत्येक सबलिस्ट ( ^2अपनी सभी प्रविष्टियों को चालू करता है 1) लेता है और इस छोटे से मुआवजे वाले पूर्णांक द्वारा स्थानांतरित किए गए कुल को प्रीपेन्ड करता है। परिणामी सूचियों Joinको उत्पादन के लिए एक साथ संपादित किया जाता है।

Answer 8

रूबी, 76

->s{(?1+s.gsub(/./){|a|a+?1}).split(?=).map{|e|e[0]="#{5**8-eval(e)}";e}*?=}

5**8गोल्फिंग कारणों से भावों का लक्ष्य मान शून्य से 1 पर तय किया गया है! मूल रूप से मैं s.size+1माइनस 1 का उपयोग कर रहा था ।

परीक्षण कार्यक्रम में अपराजित

f=->s{(?1+s.gsub(/./){|a|a+?1}).           #add a 1 at the beginning and after every symbol
       split(?=).                          #split into an array of expressions at = signs
       map{|e|                             #for each expression string
         e[0]="#{5**8-eval(e)}";e          #change the first number to 5**8-eval(e)
       }*?=                                #and rejoin the strings
}


puts f["="] 
puts f["=="] 
puts f["+="] 
puts f["=+"]
puts f["-="]
puts f["=-"]
puts f["=-="]
puts f["=+="]
puts f["==="]
puts f["+=-"]
puts f["-=+"]
puts f["+=+"]
puts f["-=-"]
puts f["--="]
puts f["++="]
puts f["-+="]
puts f["+-="]
puts f["+-=-="]
puts f["--=--"]
puts f["==-=="]
puts f["=++=+-=-+=--="]
puts f["+--++-=-+-+-"]
puts f["======"]

उत्पादन

390624=390624
390624=390624=390624
390623+1=390624
390624=390623+1
390625-1=390624
390624=390625-1
390624=390625-1=390624
390624=390623+1=390624
390624=390624=390624=390624
390623+1=390625-1
390625-1=390623+1
390623+1=390623+1
390625-1=390625-1
390626-1-1=390624
390622+1+1=390624
390624-1+1=390624
390624+1-1=390624
390624+1-1=390625-1=390624
390626-1-1=390626-1-1
390624=390624=390625-1=390624=390624
390624=390622+1+1=390624+1-1=390624-1+1=390626-1-1=390624
390624+1-1-1+1+1-1=390625-1+1-1+1-1
390624=390624=390624=390624=390624=390624=390624

Answer 9

PHP, 207 204 197 114 बाइट्स

प्रत्यक्ष दृष्टिकोण: बहुत छोटा और तेज

foreach(explode("=",$argn)as$t)echo"="[!$c],strlen($argn)+($c=count_chars($t))[45]-$c[43],@chunk_split($t,!!$t,1);

इसे ऑनलाइन चलाएं echo '<input>' | php -nR '<code>'या परीक्षण करें ।

टूट - फूट

foreach(explode("=",$argn)as$t) // loop through terms
    echo                            // print ...
        "="[!$c],                       // 1. "=" if not first term
        strlen($argn)                   // 2. maximum number
            +($c=count_chars($t))[45]   //    + number of "-"
            -$c[43],                    //    - number of "+"
        @chunk_split($t,!!$t,1);        // 3. each operator followed by "1"

• !$c1स्ट्रिंग अनुक्रमित करने के लिए डाली गई पहली पुनरावृत्ति में सच है ; "="[1]खाली है।
  उसके बाद, $cसेट किया गया और !$cगलत है, कास्ट किया गया 0और "="[0]पहला चरित्र है।
• किसी भी शब्द के लिए अधिकतम मूल्य pluses +1 की संख्या से अधिक नहीं होना चाहिए;
  इसलिए हम निश्चित रूप से इनपुट की लंबाई के साथ सुरक्षित हैं। सभी शर्तें उसी का मूल्यांकन करेंगी।
• chunk_split($s,$n,$i)$iके हर $nअक्षर के बाद सम्मिलित करता है $s- और अंत में।
  रिक्त शर्तों को चालू करने से रोकने के लिए 1, एक त्रुटि को चंक की लंबाई निर्धारित करके मजबूर किया जाता है 0।

Answer 10

रोड़ा , 112 110 109 बाइट्स

f x{[(`:$x:`/"=")()|{|p|p~=":",""a=p;a~=`\+`,""b=p;b~="-","";["=",#x-#b+#a];{(p/"")|{|o|[o,"1"*#o]}_}}_][1:]}

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

स्प्लिट फंक्शन काम नहीं करता था जैसा कि मैंने इस कार्यक्रम के साथ किया था। उदाहरण के लिए, split("", sep="")कुछ नहीं के बजाय एक खाली स्ट्रिंग लौटाता है। यह कैसे तार्किक है? इसके कारण यह कार्यक्रम लगभग 20 बाइट्स की तुलना में बड़ा है, यदि विभाजित शब्दार्थ आदर्श थे तो यह क्या हो सकता है।

इस उत्तर का विचार यह है कि हम जानते हैं कि इनपुट स्ट्रिंग की लंबाई समीकरण के मान से अधिक या बराबर होनी चाहिए, इसलिए हम समीकरण के मान को स्ट्रिंग की लंबाई के रूप में परिभाषित करते हैं। समीकरण के हर भाग के लिए, हम सोचते हैं कि प्रत्येक ऑपरेटर को घटाया +1या -1घटाया और उन्हें समीकरण के मूल्य में जोड़ा जाए।

Ungolfed:

function f(x) {
    /* Adds ":"s around the string to prevent "=" being split wrong. */
    [split(`:$x:`, sep="=") | for p do
        p ~= ":", ""          /* Removes colons. */
        a := p; b := p        /* Initializes a and b to be p. */
        a ~= "\\+", ""        /* The lengths of a and are now equal to the */
        b ~= "-", ""          /* numbers of "-" and "+" characters in x. */
        push("=", #x-#b+#a)   /* Prints "=" and the value of the equation */
                              /* minus number of "+"s plus number of "-"s. */
        split(p, sep="") | for o do /* For each operator: */
            push(o)                 /* Prints the operator. */
            push(1) if [o != ""]    /* Prints 1 unless the operator is "". */
        done
    done][1:] /* Removes the first character of the output ("="). */
}