กำหนดสตริงของตัวละคร+=-ที่มีอย่างน้อยหนึ่งตัว=ให้ใส่จำนวนเต็มบวกระหว่างสัญลักษณ์ทั้งหมดและที่จุดเริ่มต้นและจุดสิ้นสุดเช่นสมการคณิตศาสตร์

ตัวอย่างเช่นกำหนดอินพุต

+-=-=

คุณต้องใส่จำนวนเต็มบวก A ถึง F เช่นนี้

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(evals ถึง -9) และ10-1=17-8(evals ถึง 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

เรติน่า 58 ไบต์

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

1+
$.&

ลองออนไลน์!

โซลูชันทางเลือกที่นับไบต์เดียวกัน:

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

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

ลองออนไลน์!

คำอธิบาย

แนวคิดพื้นฐานคือการเปิดทั้งหมด +และ-s เข้าไปในที่เรียบง่าย+1และ-1การดำเนินงานและจากนั้นก็ต้องเพิ่มจำนวนมากพอที่จะทำให้ทุกการทำงานของสมการ ในการสร้างสมการให้ตรงกันเราสามารถเติมจำนวนเดียวกันให้กับแต่ละตัวแล้วลดลงทีละหนึ่งสำหรับแต่ละตัว+1และเพิ่มมันทีละตัวสำหรับแต่ละ-1หลัง เนื่องจากเราจะทำงานกับตัวเลขที่ยังไม่ทราบได้การจับอย่างเดียวคือหมายเลขแรกต้องมีขนาดใหญ่พอที่เราจะสามารถลดได้ 1 ครั้ง

[-+]
$&1

เราเริ่มต้นด้วยการใส่1หลังจากที่แต่ละหรือ-+

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

การ\Bตรวจสอบให้แน่ใจว่าการจับคู่เหล่านี้เป็นจุดเริ่มต้นของอินพุตหรือระหว่าง a =และ a +หรือ-คือตำแหน่งทั้งหมดที่เราต้องการแทรกจำนวนนำหน้าของการแสดงออก ((\+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_จากสตริงซ้ำ ๆใช้การยกเลิกที่จำเป็นจาก+1s

1+
$.&

ในที่สุดให้แทนที่สตริงทั้งหมดของ 1 s ด้วยความยาวเพื่อแปลงจาก unary เป็นทศนิยม

Python 2 , 76 ไบต์

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

ลองออนไลน์!

Python 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 ไบต์จากประวัติการแก้ไข

JavaScript (ES6), 92 82 ไบต์

เล่นกอล์ฟขนาด 8 ไบต์ด้วยเคล็ดลับจาก @xnor

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>

เคล็ดลับที่นี่คือการแทรก a 1after ทุกครั้ง+หรือ-จากนั้นเติมตัวเลขที่ทำให้นิพจน์เท่ากับความยาวของแต่ละนิพจน์ วิธีนี้เราสามารถรับประกันได้ว่าจำนวนจะเป็นบวกเสมอ เนื่องจากมีอย่างน้อย 1 =ในสตริงจำนวน+s จึงไม่สามารถเข้าถึงความยาวของสตริงได้ดังนั้นส่วนที่เหลือจึงเป็นอย่างน้อย1เสมอ คุณสามารถตรวจสอบสิ่งนี้ได้ด้วยการพิมพ์จำนวน+s โดยพลการในตัวอย่างข้างต้น

Python 2 , 120 119 bytes

^{-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ในทุกตำแหน่งเพื่อตรวจสอบค่าสูงสุดจากนั้นเพิ่มเป็นออฟเซ็ตในทุกสมการ งานนี้เพราะคุณไม่สามารถเพิ่มจำนวนลบเพื่อให้ผลต่ำสุดที่จะได้รับจากปริมาณของในสมการที่มีเพียง++

อารัมภบท GNU, 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และเรายังรวมถึงการยืนยันว่าEมากกว่า 0 (เนื่องจากคำถามต้องใช้ตัวเลขบวก) ฟังก์ชั่นนี้มีความละเอียดมากกว่าที่ฉันต้องการเล็กน้อยเช่นฉันต้องเขียนการ[E|R]จับคู่รูปแบบ / ยกเลิกการจับคู่สองครั้งเนื่องจากรายการมีความสัมพันธ์ที่ถูกต้อง แต่การเพิ่มและการลบนั้นสัมพันธ์กันทางซ้าย น่าเศร้าที่เราต้องใช้ลิสต์จริงแทนที่จะประดิษฐ์ลิสต์ประเภทซ้ายของเราเองออกจากเซลล์ข้อเสียเพื่อที่fd_labelingจะทำงาน

qคล้ายกับแต่ยังรวมถึงx =มันเป็นเพียงการโทรxและตัวเองซ้ำ บังเอิญมันเป็นสาธิตที่ชัดเจนของวิธีการทำงานของรายการที่แตกต่างกันแสดงให้เห็นว่าคุณสามารถเชื่อมสองรายการที่แตกต่างกันL,Tและเป็นรายการที่แตกต่างกันเพียงครั้งเดียวT,R L,Rแนวคิดพื้นฐานคือรายการความแตกต่างเป็นฟังก์ชันบางส่วนที่รับอาร์กิวเมนต์Rและส่งคืนค่าLที่เป็นRในรายการที่ได้รวมไว้ ดังนั้นโดยการระบุข้อโต้แย้งของรายการที่แตกต่างหนึ่งรายการและค่าส่งคืนของอีกรายการหนึ่งเราสามารถเขียนฟังก์ชันและทำการเชื่อมโยงรายการต่างๆ

ในที่สุดsซึ่งเป็น funciton ที่จริงแก้งานในคำถามเป็นฟังก์ชั่น wrapper ที่เรียกว่า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] ? 

ในทั้งสองกรณี?ที่จุดสิ้นสุดของเอาต์พุตหมายความว่าอาจมีมากกว่าหนึ่งโซลูชัน (แน่นอนในกรณีนี้เรารู้ว่ามีจำนวนมากมากกว่าหนึ่งวิธีการแก้ปัญหา!)

Mathematica, 116 ไบต์

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

ฟังก์ชัน Pure รับสตริงเป็นอินพุตและส่งคืนรายการจำนวนเต็มบวก กลยุทธ์พื้นฐาน: เราเพิ่มเพียงแค่ 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รวมเข้าด้วยกันเพื่อสร้างผลลัพธ์

ทับทิม, 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

Ungolfed ในโปรแกรมทดสอบ

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

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"

• !$cเป็นจริงในการทำซ้ำครั้งแรกนำไปใช้1สำหรับการจัดทำดัชนีสตริง; "="[1]มันว่างเปล่า.
  หลังจากนั้น$cมีการตั้งค่าและ!$cเท็จโยนไป0และ"="[0]เป็นตัวละครตัวแรก
• ค่าสูงสุดสำหรับคำใด ๆ ที่ต้องไม่เกินจำนวนของ pluses +1;
  ดังนั้นเราจึงปลอดภัยอย่างแน่นอนกับความยาวของอินพุต เงื่อนไขทั้งหมดจะประเมินว่า
• chunk_split($s,$n,$i)แทรก$iหลังจากทุก$nอักขระตัวของ$s- และท้ายที่สุด
  เพื่อป้องกันไม่ให้แง่ว่างหันไปมีข้อผิดพลาดจะถูกบังคับโดยการตั้งค่าความยาวอันที่จะ10

Röda , 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 ("="). */
}