_{ความท้าทายนี้ได้รับแรงบันดาลใจจากวิชาคณิตศาสตร์เป็นความจริง การเขียนโปรแกรมไม่ได้}

สัญกรณ์คณิตศาสตร์สำหรับปัจจัยหรือความเป็นจริง!เป็นเครื่องหมายอัศเจรีย์ เครื่องหมายอัศเจรีย์ยังเป็นสัญลักษณ์ทั่วไปสำหรับnotภาษาการเขียนโปรแกรมจำนวนมาก

ท้าทาย:

ใช้สตริงที่มีตัวเลขและตัวอักษร: + !เป็นอินพุตและเอาต์พุตต่อไปนี้:

ทุกสิ่งที่อยู่ข้างหน้าเครื่องหมายอัศเจรีย์ควรได้รับการประเมินว่าเป็นนิพจน์ทางคณิตศาสตร์ดังนั้น2+2ควรเป็น4จะ

ทุกอย่างหลังจากเครื่องหมายอัศเจรีย์ควรจะผนวกเข้ากับอุปกรณ์เสริมที่อยู่ข้างหน้ามันดังนั้น: 2+2!5ควรให้45เพราะ2+2=4และ5เป็นอุปกรณ์เสริม ควรให้2+2!5+5410

ตั้งแต่!ยังหมายถึงnotอะไรที่ไม่ได้เป็นอุปกรณ์เสริมหลังจากที่ความจริงควรจะไม่ได้ถูกผนวก ดังนั้น2+2!!5ควรให้4เนื่องจาก5ไม่ใช่อุปกรณ์เสริม ตอนนี้not(not(true))==trueจึงควรให้2+2!!!5 ควรให้: เพราะแล้วตามด้วยปัจจัยและ คนแรกไม่ใช่ความจริง แต่เป็นเครื่องหมายอัศเจรีย์อีกอันหนึ่งดังนั้นจึงเป็นเรื่องจริงอีกครั้ง452+2!!5!5+54102+2=4!5!5+555+5

ชี้แจง:

• เครื่องหมายอัศเจรีย์จะไม่ติดกับ a +กับด้านใดด้านหนึ่ง
• จะไม่นำ+ตัวเลข (มัน5ไม่ใช่+5)
• !คุณอาจเลือกที่จะรวมศูนย์นำถ้าว่าเป็นผลมาจากการแสดงออกในด้านหน้าของครั้งแรก ทั้ง4และ04เป็นที่ยอมรับเอาต์พุตสำหรับอินพุต:0+0!4

บทสรุปผู้บริหาร:ประเมินผลรวมแต่ละรายการ (ถือว่า!เป็นตัวคั่น) จากนั้นทิ้งหมายเลขทั้งหมดที่ปรากฏหลังจำนวนคู่!(นับจากจุดเริ่มต้นของสตริง) จากนั้นลบทั้งหมด!แล้วเอาทั้งหมด

กรณีทดสอบ:

!
   <- Empty string

5
5

12!
12

!87
87

!!5
   <- Empty string

5+5!2+2
104

5+5!!2+2
10

1!2!3!4!5!6!7!8!9
12468

10+10!!2+2!!3+3!4+4
208

2!!3!5
25

2!!3!5!7
25

10!!!!!!!5
105

นี่คือโค้ดกอล์ฟดังนั้นโค้ดที่สั้นที่สุดเป็นไบต์ (ในแต่ละภาษา) ชนะ! คำอธิบายได้รับการสนับสนุนอย่างยิ่ง!

จอประสาทตา35 31 29 29 ไบต์

บันทึก 4 ไบต์โดยรับแรงบันดาลใจจาก ETHproductions ETHproductions

ขอขอบคุณลีโอสำหรับการบันทึกอีก 2 ไบต์

\d+|\+
$*
1+
$.&
1`!

!\d*!?

ลองออนไลน์!

JavaScript (ES6), 58 56 ไบต์

ที่บันทึกไว้สองไบต์ขอบคุณที่มาร์ตินเอนเดอร์

let f =
x=>x.replace(/[^!]+/g,eval).replace(/!(\d*)!?\d*/g,"$1")

<input value="2+2!5+5" oninput="try{O.value=f(value)}catch(e){}"><br>
<input id=O value="410" disabled>

อาจได้รับการปรับปรุงอย่างใด ...

เยลลี่ขนาด 16 ไบต์

ṣ”!µḢW;m2$VṾ$L¡€

ลองออนไลน์!

คำอธิบาย

การสังเกตที่สำคัญที่นี่คือเราสามารถเรียกใช้ขั้นตอน "ผิดปกติ"; แทนที่จะประเมินผลรวมแล้วเพิกเฉยสิ่งที่เราไม่ชอบเราสามารถเพิกเฉยผลรวมในตำแหน่งที่ไม่ถูกต้องจากนั้นประเมินส่วนที่เหลือ

ṣ”!µḢW;m2$VṾ$L¡€
ṣ”!                Split input on '!'
   µ               Set as the new default for missing arguments
    Ḣ              Take the first element, removing it from the default
     W;  $         Cons with
       m2            every odd-numbered element of {the tail of the !-split input}
               €   For each remaining element
          VṾ$      Evaluate and de-evaluate it
             L¡      a number of times equal to its length

การประเมินผลรวมเหมือน"10+10"จะประเมินเป็นตัวเลขเช่น20นั้น "20"de-ประเมินเพื่อสตริง ทำซ้ำกระบวนการนั้นไม่มีผลกระทบเพิ่มเติม (เป็น idempotent) ดังนั้นเราจะประเมินทุกองค์ประกอบของสตริงอย่างมีประสิทธิภาพยกเว้นสตริงว่างซึ่งยังคงประเมินค่าไม่ได้เนื่องจากมีความยาวเป็นศูนย์

เยลลี่ขนาด 18 ไบต์

ṣ”!µḊm2;@ḢW$LÐfVṾ€

ลองออนไลน์!

อย่างไร?

ṣ”!µḊm2;@ḢW$LÐfVṾ€ - Main link: string
ṣ”!                - split on '!' characters
   µ               - monadic chain separation (call that x)      e.g. ['1+1','0+0','0+0','0+0','','1+0','','','']
    Ḋ              - dequeue x (all but the leftmost entry of x) e.g.       ['0+0','0+0','0+0','','1+0','','','']
     m2            - modulo 2 index into that result             e.g.       ['0+0',      '0+0',   '1+0',   '']
           $       - last two links as a monad
         Ḣ         -     head x (the leftmost entry of x)        e.g.  '1+1'
          W        -     wrap                                    e.g. ['1+1']
       ;@          - concatenate with reversed arguments         e.g. ['1+1','0+0',      '0+0',   '1+0',   '']
             Ðf    - filter keep:
            L      -     length (keep that have non-zero length) e.g. ['1+1','0+0',      '0+0',   '1+0']
               V   - eval as jelly code (vectorises)             e.g. [  2,    0,          0,       1]
                      Yes, addition is just + and decimal numbers are just strings of digits in Jelly believe it or not!
                Ṿ€ - uneval €ach (creates a string from each one)e.g. [ '2',  '0',        '0'     ,'1']
                      without the € it would uneval the list and hence yield commas too)
                   - implicit print (prints the resulting list [of characters and possibly
                      lists of characters] as if it were all one string.)

CJam , 20 ไบต์

r'!/{_{'+/1b}&}%(\2%

ลองออนไลน์! (ชุดทดสอบแยก Linefeed)

Ruby , 58 56 + 1 = 59 57 ไบต์

ใช้ -pธง -2 ไบต์จากTutleman

i=0;$_=' '+$_;gsub(/!?([^!]*)/){eval$1if(2>i+=1)||i%2<1}

ลองออนไลน์!(เพิ่มรหัสบรรทัดพิเศษเพื่อให้รับบรรทัดอินพุตทั้งหมดและพิมพ์เอาต์พุตในบรรทัดที่ต่างกัน)

แบตช์192 184 ไบต์

@echo off
set/ps=
call:c . "%s:!=" "%"
echo(%s%
exit/b
:c
set s=
if not %2=="" set/as=%2
:l
shift
shift
if "%1"=="" exit/b
if %1=="" goto l
set/at=%1
set s=%s%%t%
goto l

ต้องจัดการกับสตริงว่างไม่สะดวก

Pip , 18 ไบต์

ฉันคิดว่านี่เป็นเวลาที่สั้นที่สุดที่จะได้รับ ... แม้ว่าฉันจะบอกว่าประมาณสามครั้งแล้วก็เช่นกัน

{VaX++v%2+!v}Ma^'!

รับอินพุตเป็นอาร์กิวเมนต์บรรทัดคำสั่ง ลองออนไลน์!

คำอธิบาย

                    a is 1st cmdline arg; global variable v is -1 (implicit)
              a^'!  Split a on !
{           }M      Map this function to the resulting list (note that inside function,
                    a is the function arg):
    ++v              Increment v (so that v tracks the 0-based index of the current
                     element)
       %2            We want to keep the elements where v%2 is 1...
         +!v         ... and also v=0, where v%2 is 0, but adding !v makes it 1
  aX                 String-multiply the argument by the above quantity (turning elements
                     we don't want into empty string)
 V                   Eval it (eval'ing empty string gives nil, but that's okay because
                     nil doesn't output anything)
                    Autoprint the resulting list, concatenated together (implicit)

R, 95 ไบต์

function(x)for(e in strsplit(gsub('!([^!]*)![^!]*','\\1!',x),'!')[[1]])cat(eval(parse(text=e)))

อาจมีห้องพักสำหรับการปรับปรุง แต่ในขณะนี้มันเป็นสิ่งที่ดีที่สุดที่ฉันสามารถทำได้