_{Thử thách này được lấy cảm hứng từ Toán học là sự thật. Lập trình thì không .}

Ký hiệu toán học cho một giai thừa, hoặc thực tế là một dấu chấm than !. Dấu chấm than cũng là một biểu tượng phổ biến cho notnhiều ngôn ngữ lập trình.

Thử thách:

Lấy một chuỗi, chứa các chữ số và các ký tự: + !làm đầu vào và đầu ra như sau:

Tất cả mọi thứ ở phía trước dấu chấm than nên được đánh giá là biểu thức toán học, vì vậy 2+2sẽ là như vậy 4.

Tất cả mọi thứ sau một dấu chấm than duy nhất nên được thêm vào như phụ kiện cho bất cứ thứ gì ở phía trước nó, vì vậy: 2+2!5nên cho 45, bởi vì 2+2=4, và 5là một phụ kiện. 2+2!5+5nên cho 410.

Vì !cũng có nghĩa là not, bất cứ thứ gì không phải là phụ kiện sau khi thực tế không nên được thêm vào. Vì vậy, 2+2!!5nên cho 4, vì 5không phải là một phụ kiện. Bây giờ, not(not(true))==true, vì vậy 2+2!!!5nên cung cấp 45. 2+2!!5!5+5nên cho : 410, bởi vì 2+2=4, sau đó là một giai thừa và !5!5+5. Đầu tiên 5không phải là một sự thật, mà 5+5là sau một dấu chấm than khác, và do đó là một sự thật, một lần nữa.

Làm rõ:

• Các dấu chấm than sẽ không liền kề với một +bên.
• Sẽ không dẫn đầu +về số lượng (nó 5, không phải +5).
• Bạn có thể tùy ý bao gồm một số 0 đứng đầu nếu đó là kết quả của biểu thức ở phía trước đầu tiên !. Cả hai 4và 04được chấp nhận đầu ra cho đầu vào:0+0!4

Tóm tắt điều hành: đánh giá từng khoản tiền (coi !như dấu phân cách). Sau đó loại bỏ tất cả các số xuất hiện sau một số chẵn !(tính từ đầu chuỗi). Sau đó loại bỏ tất cả !.

Các trường hợp thử nghiệm:

!
   <- 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

Đây là môn đánh gôn để mã ngắn nhất tính theo byte (theo từng ngôn ngữ) sẽ thắng! Giải thích được khuyến khích mạnh mẽ!

Võng mạc , 35 31 29 byte

Đã lưu 4 byte bằng cách lấy một số cảm hứng từ ETHproductions .

Cảm ơn Leo đã lưu thêm 2 byte.

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

!\d*!?

Hãy thử trực tuyến!

JavaScript (ES6), 58 56 byte

Lưu hai byte nhờ Martin Ender .

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>

Có thể được cải thiện bằng cách nào đó ...

Thạch , 16 byte

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

Hãy thử trực tuyến!

Giải trình

Quan sát chính ở đây là chúng ta có thể chạy các bước "không theo thứ tự"; thay vì đánh giá các khoản tiền sau đó bỏ qua những khoản tiền chúng tôi không thích, chúng tôi có thể bỏ qua các khoản tiền ở vị trí không hợp lệ, sau đó đánh giá phần còn lại.

ṣ”!µḢ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

Đánh giá một tổng số "10+10"sẽ đánh giá nó thành một số, ví dụ 20, sau đó đánh giá lại nó thành một chuỗi , "20". Lặp lại quá trình đó không có hiệu lực bổ sung (đó là idempotent). Do đó, chúng tôi đánh giá hiệu quả mọi yếu tố của chuỗi, ngoại trừ chuỗi null, vẫn không được đánh giá vì nó có độ dài bằng không.

Thạch , 18 byte

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

Hãy thử trực tuyến!

Làm sao?

ṣ”!µḊ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 byte

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

Hãy thử trực tuyến! (Bộ kiểm tra được phân tách theo dòng.)

Ruby , 58 56 + 1 = 59 57 byte

Sử dụng -pcờ. -2 byte từ Tutman .

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

Hãy thử trực tuyến! (Một dòng mã bổ sung đã được thêm vào để nó sẽ lấy tất cả các dòng đầu vào và in đầu ra thành các dòng khác nhau.)

Hàng loạt, 192 184 byte

@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

Phải xử lý các chuỗi trống là bất tiện.

Pip , 18 byte

Tôi nghĩ rằng đây là thời gian ngắn nhất ... mặc dù tôi đã nói rằng khoảng ba lần lặp lại trước đây.

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

Lấy đầu vào làm đối số dòng lệnh. Hãy thử trực tuyến!

Giải trình

                    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 byte

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

Có lẽ có một số chỗ để cải thiện nhưng hiện tại nó là thứ tốt nhất tôi có thể nghĩ ra.