Trong toán học, một dấu chấm than !thường có nghĩa là giai thừa và nó xuất hiện sau khi lập luận.

Trong lập trình, một dấu chấm than !thường có nghĩa là phủ định và nó xuất hiện trước đối số.

Đối với thử thách này, chúng tôi sẽ chỉ áp dụng các hoạt động này cho không và một.

Factorial
0! = 1
1! = 1

Negation
!0 = 1
!1 = 0

Lấy một chuỗi từ 0 trở lên !, theo sau 0hoặc 1, theo sau là 0 hoặc nhiều hơn !( /!*[01]!*/).
Ví dụ, đầu vào có thể !!!0!!!!hay !!!1hay !0!!hay 0!hay 1.

Những !cái trước 0hoặc 1là phủ định và cái !sau là giai thừa.

Yếu tố có độ ưu tiên cao hơn phủ định vì vậy giai thừa luôn được áp dụng đầu tiên.
Ví dụ, !!!0!!!!thực sự có nghĩa là !!!(0!!!!), hoặc tốt hơn chưa !(!(!((((0!)!)!)!))).

Xuất ra ứng dụng kết quả của tất cả các giai thừa và phủ định. Đầu ra sẽ luôn luôn là 0hoặc 1.

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

0 -> 0
1 -> 1
0! -> 1
1! -> 1
!0 -> 1
!1 -> 0
!0! -> 0
!1! -> 0
0!! -> 1
1!! -> 1
!!0 -> 0
!!1 -> 1
!0!! -> 0
!!!1 -> 0
!!!0!!!! -> 0
!!!1!!!! -> 0

Mã ngắn nhất tính bằng byte thắng.

Toán học, 25 17 byte

Input[]/.!x_:>1-x

Đưa đầu vào từ một dấu nhắc người dùng. Giả sử môi trường máy tính xách tay của Mathicala để in ngầm. Để làm cho nó thành một tập lệnh dòng lệnh, hãy bọc nó Print[...]hoặc để làm cho nó thành một hàm không có đối số (sau đó lấy đầu vào từ dấu nhắc), nối thêm &.

Mathematica có cả hai toán tử cần thiết (với quyền ưu tiên bắt buộc), vì vậy chúng ta chỉ có thể "đánh giá" đầu vào (được thực hiện tự động bởi Input[]), nhưng toán tử phủ định logic không hoạt động trên các số nguyên (vì vậy nó sẽ không được đánh giá). Nếu có một !xkết quả trái, chúng tôi thay thế nó bằng 1-x.

Một vài sự thật thú vị về việc đánh giá:

1. Mathematica thực sự cũng có toán tử nhân đôi !!, tính toán n*(n-2)*(n-4)*..., nhưng được áp dụng cho 0hoặc 1nó vẫn cho 1, vì vậy nó không 0!!!!!thực sự được phân tích cú pháp như ((0!!)!!)!.
2. Mặc dù Mathicala rời khỏi !0và không được !1đánh giá, nhưng nó biết rằng đó !là tự nghịch đảo, vì vậy nó sẽ tự động hủy bỏ tất cả các cặp dẫn đầu !. Sau khi ToExpressionchúng tôi luôn trái với một trong những 0, 1, !0, !1.

[Bash] + Tiện ích Unix, 21 17 byte

sed s/.!!*$/1/|bc

Điều này phải được lưu trong một tập tin và chạy như một chương trình. Nếu bạn cố gắng nhập lệnh trực tiếp từ dòng lệnh, nó sẽ không hoạt động vì !! được mở rộng do thay thế lịch sử được bật trong chế độ tương tác của bash. (Ngoài ra, bạn có thể tắt thay thế lịch sử bằng set +H.)

Trường hợp thử nghiệm chạy:

for x in 0 1 '0!' '1!' '!0' '!1' '!0!' '!1!' '0!!' '1!!' '!!0' '!!1' '!0!!' '!!!1' '!!!0!!!!' '!!!1!!!!'; do ./excl <<<"$x"; done

0
1
1
1
1
0
0
0
1
1
0
1
0
0
0
0

Võng mạc , 20 15 14 byte

Cảm ơn Leo vì đã tiết kiệm 1 byte.

0!
1
!!

^1|!0

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

Giải trình

0!
1

Biến 0!thành 1. Chúng tôi không quan tâm đến bất kỳ dấu vết nào khác !, số kết quả giống như chúng tôi đã áp dụng tất cả các yếu tố.

!!

Hủy bỏ các cặp phủ định. Điều này cũng có thể hủy bỏ một số giai thừa, nhưng điều đó không liên quan.

^1|!0

Đếm số lượng trận đấu của regex này, hoặc là 1hoặc 0cho kết quả mong muốn.

Grime , 14 12 9 byte

e`\0!~\!_

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

Giải trình

Điều này khớp với đầu vào so với một mẫu, in 1cho khớp và 0không khớp.

e`\0!~\!_
e`         Match entire input against this pattern:
    !      not
  \0       a sole 0
     ~     xor
      \!   exclamation mark
        _  followed by this pattern matched recursively.

Ý tưởng là thế này. Nếu đầu vào bắt đầu bằng một chữ số, thì phần đệ quy \!_luôn luôn thất bại và \0!thành công trừ khi chúng ta có một chữ số duy nhất 0. Xor của họ thành công trừ khi đầu vào là một 0. Nếu đầu vào bắt đầu bằng a !, thì \0!luôn thành công và \!_thành công nếu khớp đệ quy thành công. Xor của họ thành công chính xác khi trận đấu đệ quy thất bại, do đó phủ nhận nó.

Brainfuck, 85 72 (84) byte

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

để trả về số, hoặc

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

cho văn bản ASCII. > cũng có thể được thêm tiền tố để tránh gói bộ nhớ.

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

Loops over the input.
On 1, ends.
On "!", toggles bool a stored as 0 or 255.
On "0", toggles if there is no trailing bit, then ends.

Memory labels  | BOOL | INPUT | FLAG |

,                   first input 
[                     # loop on INPUT
  >-[-----<->]<++     subtract 49 == "1"

  [                     # case not "1"
    >++++[-<++++>]      add 16 since 49 take 16 == "!"

    +                   set FLAG
    <                   move to INPUT
    [                     # case "0"
      [+],                clear and new INPUT
      [                     # case "0!"
        [-]>-<              clear INPUT and FLAG
      ]
    ]
  ]

  >                   move to FLAG
  [                     # case "!" or "0" without tail
    <<+[-->]>[<]        not the BOOL
    ,                   take new input
    >-                  clear FLAG
  ]
  <                   move to INPUT
]

+.                    return 0 or 1

Hoặc để trả lời văn bản, thay thế dòng cuối cùng bằng

-[-----<+>]<--.       add 49 for "0" or "1" conversion and return

Brainfuck - đường đến nhiều byte (232 byte)

Rõ ràng ngôn ngữ sai cho chiến thắng trong mã golf. Chủ yếu tôi nhận thấy thiếu bất cứ ai sử dụng esolang này. Có một trình thông dịch bf phiên dịch trực tuyến tốt hoặc bạn thực sự có thể xem những gì chương trình sử dụng trình hiển thị bf này .

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

Python, -44- 42 byte

Đã lưu 2 byte nhờ Zgarb!

lambda x:(x[-1]=='0')^len(x.rstrip('!'))%2

Từng bước một:

1. x[-1]!='0'
   nếu xkết thúc bằng 1hoặc !⇔ xkhông kết thúc bằng 0, phần giai thừa phải có giá trị 1, phần khác0
2. ^len(x.rstrip('!'))%2
   khai thác tài sản của xor như là một "điều kiện không". Điều kiện trong trường hợp này là nếu độ dài của !s ban đầu là số lẻ. Tuy nhiên, .rstripkhông xóa số khỏi chuỗi để độ dài được tính bằng 1, do đó điều kiện được đảo ngược
3. Giá trị bù 1 trong bước 2 được sửa bằng cách thay đổi !=sang ==bước 1. Zgarb đề xuất sử dụng toán tử so sánh khác biệt thay vì áp dụng đảo ngược khác, tiết kiệm 2 byte.

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

JavaScript (ES6), 43 41 29 byte

s=>+eval(s.replace(/.!+$/,1))

Phương thức phi regex ( 41 31 byte)

Dưới đây là cách tiếp cận ban đầu của tôi. Nó thú vị hơn một chút, nhưng lâu hơn đáng kể vẫn lâu hơn một chút ngay cả sau khi tối ưu hóa đáng kể bởi Neil (đã lưu 10 byte) .

f=([c,...s])=>1/c?c|s>'':1-f(s)

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

let f =

s=>+eval(s.replace(/.!+$/,1))

;[
  "0", "1", "0!", "1!", "!0", "!1", "!0!", "!1!", "0!!",
  "1!!", "!!0", "!!1", "!0!!", "!!!1", "!!!0!!!!", "!!!1!!!!"
].map(
  s => console.log(s, '=>', f(s))
)

Thạch , 5 byte

VeMḂ$

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

Hàm monadic mong đợi một chuỗi. Đầu vào với hàng đầu! s1 được in thành STDOUT trên đường đi, do đó, liên kết TIO tôi đưa ra là một khai thác thử nghiệm in các cặp đầu vào-đầu ra bên dưới dòng đầu ra đầu tiên.

Làm sao?

VeMḂ$ - Monadic link: string
V     - eval the string
          - the implicit input of 0 causes !...! to evaluate to 1 (which gets printed),
          - the result is the evaluation of the rest: "0"=0; "0!"=1; "1"=1; "1!"=1; ...
 e    - exists in?
    $ - last two links as a monad:
  M   -     Maximal indexes - the "0" and "1" characters are greater than "!",
                            - so this results in a list of one item [i] where
                            - i is the 1-based index of the 0 or 1 character.
   Ḃ  -     %2 (vectorises) - [i%2], so a 0 if we need to logically negate and a 1 if not
                            - hence we check equality with e rather than inequality.

05AB1E , 9 byte

Mã số:

.V¹'!ÜgG_

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến! hoặc là Xác minh tất cả các trường hợp thử nghiệm!

Giải trình:

.V         # Evaluate the input as 05AB1E code. This computes the factorial part.
   '!Ü     # Remove trailing exclamation marks..
  ¹        # ..from the first input
      g    # Get the length of the resulting string
       G   # Do the following length - 1 times:
        _  #   Negate the number

Võng mạc , 13 byte

Một cách tiếp cận hơi kỳ lạ, nhưng nó ngắn và nó hoạt động.

0$
!1
!!

^\d

Với hai dòng đầu tiên, chúng tôi thay thế một kết thúc 0bằng!1 : với sự thay thế này, bây giờ chúng tôi biết rằng một phần của chuỗi của chúng tôi từ chữ số trở đi bằng 1.

Hai dòng tiếp theo, loại bỏ các cặp ! : phủ định kép sẽ tự xóa và chúng ta đã tính đến giai thừa với bước trước đó.

Dòng cuối cùng, khớp một chữ số ở đầu chuỗi và trả về số lượng khớp: nếu tất cả các phủ định đã được loại bỏ, chúng tôi sẽ tìm thấy một kết quả khớp (và như chúng tôi đã nói trước khi chúng tôi biết số này bằng 1), nếu vẫn còn một phủ định này sẽ không phù hợp.

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

Ruby, 12 + 1 = 39 24 15 13 byte

Sử dụng -ncờ. Cảm ơn @GB cho -9 byte!

p~/!*$|0$/%2

Perl , 20 byte

19 byte mã + -pcờ.

s/\d!+/1/;$_=0+eval

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

Trả về phủ định của Perl undefhoặc 1, vì vậy tôi sử dụng 0+để đánh số kết quả 0+undeftrả về 0. Bên cạnh đó, không có nhiều điều để nói về mã.

C, 68 62 61 53 byte

c;e(char*a){for(c=1;*a<34;a++)c^=1;c=a[1]?c:*a&1^!c;}

Bóp thêm một vài byte với một số lạm dụng

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

Perl 6 , 32 28 23 byte

{m/(\!)*(1|0.)*/.sum%2}

Làm thế nào nó hoạt động

{                     }  # A lambda.
{m/            /      }  # Match the lambda argument against the regex:
   (\!)*                 #   Zero or more `!`.
                         #     (First capture will be an array with one element per negation).
        (1|0.)*          #   A `1`, or a `0` and another character, zero or more times.
                         #     (Second capture will be a one-element array if the factorial
                         #     part evaluates to 1, and an empty array otherwise.)
                .sum     # Add the lengths of the two captures,
                    %2   # and return that sum modulo 2.

Haskell , 39 byte

f('!':b)="10"!!read[f b]
f[a]=a
f _='1'

Xác định hàm f, lấy một chuỗi và trả về một ký tự. Hãy thử trực tuyến!

Giải trình

Có ba trường hợp: đầu vào bắt đầu bằng !, đầu vào có độ dài 1 và mọi thứ khác.

f('!':b)=    -- If input has head '!' and tail b,
 "10"!!      -- we index into the string "10"
  read[f b]  -- using f b converted to int. This essentially inverts f b.
f[a]=        -- If input has only one character, we know it's a digit,
 a           -- so we can just return it.
f _=         -- In all other cases, we know the input is a digit followed by !s,
 '1'         -- so we can return '1'.

Befunge, 24 byte

~"!"-:#v_$1+
*+2%!.@>0~`

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

Điều này bắt đầu bằng cách đếm số lượng !ký tự được đọc từ stdin. Ký tự đầu tiên không phải !là một 0hoặc 1, nhưng trong quá trình thử nghiệm, !chúng tôi sẽ trừ 33, biến nó thành 15 hoặc 16. Sau đó chúng tôi đọc thêm một ký tự, đó sẽ là một ký tự! hoặc EOF, và so sánh nếu đó nhỏ hơn 0 (tức là EOF).

Lấy ba điểm dữ liệu đó - số dấu chấm than ( c ), giá trị chữ số, ( d ) và điều kiện cuối tập tin ( e ) - chúng ta có thể tính kết quả như sau:

!((c + d*e) % 2)

Nhân giá trị chữ số với điều kiện cuối tập tin có nghĩa là nó sẽ được chuyển đổi thành 0 nếu chữ số được theo sau bởi a !, do đó cung cấp cho nó giá trị modulo 2 tương tự như một 1(ghi nhớ đã được chuyển đổi thành 16). Nhưng trước khi áp dụng modulo 2, chúng tôi thêm số dấu chấm than ban đầu, điều này có hiệu quả làm thay đổi kết quả modulo 2 nhiều lần như !tiền tố của chúng. Và cuối cùng chúng tôi không phải là kết quả vì các giá trị cơ bản của chúng tôi cho 0và 1trái ngược với những gì chúng tôi cần.

Nhìn vào mã chi tiết hơn:

~                Read a character from stdin.
 "!"-            Subtract 33 (ASCII for '!').
     :  _        Make a duplicate and check if zero (i.e. is it a '!').
         $1+     If so, drop the duplicate, increment a counter, and repeat.
       v         Otherwise move to the second line, leaving the digit value on the stack.
       >0~`      Read one more character and check if less than 0 (i.e. EOF).
*                Multiple by the digit value, making it zero if not followed by EOF.
 +               Add to the exclamation count.
  2%             Modulo 2 the result.
    !            Then not that value.
     .@          And finally write to stdout and exit.

Haskell , 27 byte

f('!':b)=1-f b
f"0"=0
f _=1

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

Mỗi đầu dẫn !bổ sung đầu ra cho phần còn lại của biểu thức, được thực hiện như 1-. Chúng tôi tiếp tục lật cho đến khi chúng tôi đạt được một chữ số. Nếu phần còn lại chỉ là "0", kết quả là 0. Nếu không, đó là một 1hoặc được theo sau bởi một hoặc nhiều !, vì vậy kết quả là 1.

Ruby, 22 21 20 byte

->s{(s=~/!*$|0$/)%2}

Giải trình:

• Trường hợp đầu tiên, tôi đã nhận được một số '!' cuối cùng, loại bỏ chúng, lấy chiều dài modulo 2.
• Trường hợp thứ hai, không '!', Nếu ký tự cuối bằng 0 thì xóa nó, lấy độ dài modulo 2
• Nếu ký tự cuối cùng là 1, quay lại trường hợp đầu tiên

(Ý tưởng ăn cắp -1 byte @Value Ink)

Thạch , 8 byte

œr”!LḂ=V

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

Đây là một hàm (liên kết đơn âm) nhận một đối số và trả về thông qua giá trị trả về của nó. (Nó cũng thường ghi rác vào đầu ra tiêu chuẩn như một tác dụng phụ, nhưng chúng tôi không quan tâm đến điều đó.)

Giải trình

œr”!LḂ=V
œr”!      Take {the input}, with all trailing ! deleted
    L     Take the length of this
     Ḃ    Take the parity of that length
      =   Return 0 if unequal, 1 if equal to:
       V    the value of {the input} when eval'ed as a niladic Jelly program

Đầu tiên, lưu ý rằng đầu vào luôn bao gồm một số số !, theo sau là một chữ số, theo sau là nhiều hơn !, nếu chúng ta xóa dấu !và lấy độ dài, chúng ta sẽ kết thúc với một số cộng với số lượng dẫn đầu !trong chương trình. Lấy tính chẵn lẻ của giá trị này sẽ trả về 0 nếu có số lẻ !hoặc 1 nếu có số chẵn! . So sánh với 0 là hàm "không", trong khi so sánh với 1 là hàm nhận dạng; do đó œr”!LḂ=thực hiện một cách hiệu quả phần "đối xử hàng đầu !với tư cách là toán tử KHÔNG" của câu hỏi.

Đối với nửa sau, xử lý các yếu tố, !là một hoạt động giai thừa trong Jelly, vì vậy nếu chương trình không có dẫn đầu !, chúng ta có thể giải quyết vấn đề trực tiếp bằng một cách đơn giản eval( V). Nếu chương trình không có lãnh đạo !, những người sẽ được hiểu là lấy thừa của 0 (có thể nhiều lần), tạo ra một giá trị trả về là 1, mà sẽ được in vào đầu ra tiêu chuẩn và loại bỏ một lần một chữ số được xem; do đó, chúng không có tác động đến giá trị trả về của hàm mà tôi gửi cho câu hỏi.

Python, 38 byte

lambda s:(s[1::2]>s[::2])^ord(s[-1])%2

Dùng thử trực tuyến!

Hàm không tên lấy chuỗi đầu vào svà trả về số nguyên 0hoặc 1.

s[1::2] là một lát của chuỗi đầu vào bắt đầu từ chỉ mục 1 và có kích thước bước là hai:
'Like this' -> 'ieti'

s[::2] tương tự nhưng bắt đầu ở chỉ số mặc định là 0:
'Like this' -> 'Lk hs'

Kiểm (s[1::2]>s[::2])tra kiểm tra nếu chỉ số dựa trên 0 của '0'hoặc '1'là số lẻ, tức là nếu chúng ta cần bổ sung.
Điều này hoạt động vì thứ tự của chuỗi được kiểm tra theo từ vựng với bất kỳ chuỗi không trống nào lớn hơn chuỗi trống và với thứ tự ASCII, vì vậy '1'>'0'>'!'. Đây là một byte ngắn hơn đơn giản hơns.index(max(s))%2 .

Các ord(s[-1])%2kiểm tra xem nếu ký tự cuối cùng không phải là một '0'(đối với đầu vào hợp lệ), và kết quả là một số nguyên (trong khi cùng độ dài (s[-1]!='0')sẽ trả về một boolean).
Điều này hoạt động vì ký tự cuối cùng của đầu vào s[-1], sẽ là một '0','1' hoặc '!'có mã ASCII lần lượt là 48, 49 và 33, là 0, 1 và 1 modulo 2.

Sau ^đó thực hiện độc quyền bitwise hoặc hoạt động trên hai giá trị trên, trả về một số nguyên vì một đầu vào, một bên phải, là một số nguyên. Nếu bên trái là True, phần bù bên phải được trả về, nếu bên trái là Sai thì phần bên phải được trả về, theo yêu cầu.

Java 7, 105 82 81 byte

int a(char[]a){int b=0,c=0;for(;a[b++]<34;c^=1);return(b<a.length?1:a[b-1]&1)^c;}

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

Giải pháp regex-ish cũ

int a(String a){a=a.replace("0!","1").replaceAll("1.*","1");int b=a.length()-1;return b%2^a.charAt(b)&1;}

CJam , 12 11 byte

r_W='0=!\~;

Hãy thử trực tuyến! Bộ kiểm tra (in một 1cho mỗi trường hợp kiểm tra chính xác).

r      e# Read input.
_W='0= e# Duplicate and check whether the string ends in '0'. This is the
       e# only case in which the factorial part results in 0.
!      e# Negate this to get the actual result of the factorial part.
\      e# Swap with the input.
~      e# Evalute the input as CJam code. The leading `!` will apply the logical
       e# negations to the factorial result. The 0 or 1 will then push a junk value
       e# which is potentially negated a few times as well, by the factorials.
;      e# Discard the junk value.

Haskell , 67 65 byte

f s|foldr(\_->not)(last s`elem`"1!")$fst.span(<'0')$s="1"|1<3="0"

Hãy thử trực tuyến! Sử dụng:f "!!!0!!!!"

Đã lưu hai byte nhờ @nimi.

Brainfuck, 115 byte

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

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

Ung dung:

% 0: inverter count
% 1: result
% 2: if/else flag; tmpspace in inner loop 0

>1,[
    ->2++++[<-------->-]<1 subtract 33 (!)
    [ 
        % we've reached the number
        ---------------
        % now it's either 0 or 1

        % check next char; If it's not 0 then it's '!'
        % 0! = 1! = 1!...! so we only need to determine if at least one ! exists
        >2,
                [<[-]+>-]<1

        % apply inversions
        <0
        [->1
            % invert cell 1 once each iteration
                       % cell 1 is 0 or 1
            -          % cell 1 is 255 or 1
            [>+<+]     % cell 1 is 0; cell 2 is 1 iff cell 1 should be 1
            >2[-<+>]<1 % cell 1 is 1 or 0
        <0]

        % print result
        >1>++++++[-<++++++++>]<1.

        >>2+< % tape={0 r 0 1}
    ]
    >2-[ % we haven't seen the number yet
        <<0+>1,>2 % add to inverter count
        [-]
    ]<1
]

Mẻ, 62 byte

@set/ps=
@set s=%s:0!=1%
@set s=%s:!!=%
@cmd/cset/a%s:1!=1%

Đưa đầu vào vào STDIN. Batch thực sự hiểu !chính xác hàng đầu cho thử thách này, nhưng các dấu vết !cần phải được xử lý, phải mất ba bước:

• Thay đổi 0!thành1
• Xóa các cặp !!(điều này an toàn cho!! s trước cả chữ số)
• Xóa mọi dấu vết còn lại !(mà bây giờ chỉ có thể là sau một 1)

Công thức ghi chú IBM / Lotus - 77 byte

@Eval(@Left(a;@If(@Like(a;"%1%");"1";"0"))+@If(@Ends(a;"!");"1";@Right(a;1)))

Không có TIO cho Ghi chú Công thức nên ảnh chụp màn hình của tất cả các trường hợp thử nghiệm được hiển thị bên dưới:

Làm thế nào nó hoạt động

@Eval() đánh giá một chuỗi như một biểu thức

Trước tiên, chúng tôi kiểm tra xem chuỗi đầu vào trong trường (đầu vào) acó chứa 1hoặc 0và đưa tất cả các ký tự sang bên trái của bất kỳ chuỗi nào sẽ là một chuỗi các !ký tự. Chúng tôi không quan tâm có bao nhiêu.@Eval()sẽ chăm sóc điều đó.

Tiếp theo chúng ta xem liệu có một !phần cuối của chuỗi không. Nếu có chúng ta nối 1vào !chuỗi ( 0!và 1!cả 1 - không quan trọng có bao nhiêu !ký tự ở cuối) nếu không chúng ta nối thêm ký tự cuối cùng vì nó không phải là một !và có thể là a 1hoặc a 0.

Bây giờ chúng ta có một chuỗi chứa các nghịch đảo hàng đầu cộng với một số được xác định bởi liệu có bất kỳ ký tự giai thừa nào để chúng ta có thể cung cấp chuỗi này cho @Eval()và nhận kết quả ở trên không.

sed, 36 33 31 byte

Sed tinh khiết, không có bc / vỏ utils. Hoạt động trên GNU sed <4.3; 33 byte trên BSD và GNU 4.3+.

s/.!!*$/1/
:
s/!0/1/
s/!1/0/
t

Đủ đơn giản nếu bạn quen thuộc sed; bình luận cho những người không:

# Since 0! == 1! == 1 and factorial has precedence, just collapse any trailing "!" 
s/.!!*$/1/
# Define an anonymous label
:
# Invert 0 if needed
s/!0/1/
# Invert 1 if needed
s/!1/0/
# If a change was made, go back to the anonymous label.
t

Kiểm tra:

% cat 109248.sed
s/.!!*$/1/
:l
s/!0/1/
s/!1/0/
tl
% wc -c 109248.sed
      33 109248.sed
% cat cases
0
1
0!
1!
!0
!1
!0!
!1!
0!!
1!!
!!0
!!1
!0!!
!!!1
!!!0!!!!
!!!1!!!!
% sed -f 109248.sed cases
0
1
1
1
1
0
0
0
1
1
0
1
0
0
0
0
% gsed -f 109248.sed cases
0
1
1
1
1
0
0
0
1
1
0
1
0
0
0
0
%

PHP 7.1, 58 55 54 37 35 byte

Lưu ý: sử dụng mã hóa IBM-850

echo!!$argn[-1]^strspn($argn,~Ì)%2;

Chạy như thế này:

echo '!!!0!!!!' | php -nR 'echo!!$argn[-1]^strspn($argn,~Ì)%2;';echo
> 0

Giải trình

echo
  strspn($a=$argv[1],~Ì) # Count the number of leading exclamation marks.
  % 2                    # Make 0 (even) or 1 (odd).
  ^ !!$a[-1];            # Negate with factorial part (truthy value of the 
                         # last char):
                         # - "0" is considered falsy.
                         # - "1" or "!" is considered truthy.

Tinh chỉnh

• Đã lưu 3 byte bằng cách sử dụng mã hóa IBM-850
• Đã lưu một byte bằng cách thay đổi regex một chút
• Đã lưu 17 byte, phiên bản mới không có tên hàm dài và trả về
• Đã lưu 2 byte bằng cách sử dụng -R( $argncó sẵn)

Bean , 24 byte

Hexdump:

00000000 26 4a c1 53 a0 17 53 d0 80 a0 5d 20 80 0a a1 80  &JÁS .SÐ. ] ..¡.
00000010 81 00 25 3a ae a1 ab 24                          ..%:®¡«$
00000018

JavaScript tương đương:

+eval(a.replace(/.!+$/,1))

Xin lỗi vì đã dẫm lên ngón chân của bạn, Arnauld .

Giải trình:

Đưa dòng đầu vào đầu tiên dưới dạng chuỗi không được định dạng vào avà thay thế bất kỳ chữ số nào theo sau bởi một hoặc nhiều !bằng 1, để phần còn lại có thể được evalJavaScript bằng JavaScript.

Hãy thử bản demo hoặc bộ thử nghiệm