ගණිතයේ දී විශ්මය දනවන ලකුණ !බොහෝ විට සාධකීය වන අතර එය තර්කයෙන් පසුව පැමිණේ.

ක්‍රමලේඛනයේ දී විශ්මය දනවන ලකුණ !බොහෝ විට ප්‍රතික්ෂේප කිරීමක් අදහස් කරන අතර එය තර්කයට පෙර පැමිණේ.

මෙම අභියෝගය සඳහා අපි මෙම මෙහෙයුම් බිංදුවට සහ එකකට පමණක් යොදන්නෙමු.

Factorial
0! = 1
1! = 1

Negation
!0 = 1
!1 = 0

බිංදුවක් හෝ ඊට වැඩි ගණනක් !ගෙන යන්න, ඉන්පසු 0හෝ 1පසුව ශුන්‍ය හෝ වැඩි ගණනක් !( /!*[01]!*/) ගන්න.
උදාහරණයක් ලෙස, ආදාන විය හැකි !!!0!!!!හෝ !!!1හෝ !0!!හෝ 0!හෝ 1.

මෙම !'පෙර s 0හෝ 1negations වන අතර !ඒක පසු factorials වේ.

සාධකය නිෂේධනයට වඩා ඉහළ ප්‍රමුඛතාවයක් ඇති බැවින් සාධක සෑම විටම පළමුව අදාළ වේ.
උදාහරණයක් ලෙස, !!!0!!!!සැබවින්ම අදහස් කරන්නේ !!!(0!!!!), හෝ වඩා හොඳ තවමත් !(!(!((((0!)!)!)!))).

සියලු සාධක සහ ප්‍රතික්ෂේප කිරීම්වල ප්‍රති application ලයක් ලෙස යෙදුම ප්‍රතිදානය කරන්න. ප්‍රතිදානය සැමවිටම 0හෝ 1වේ.

පරීක්ෂණ අවස්ථා

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

බයිට් වල කෙටිම කේතය ජය ගනී.

ගණිතය, බයිට් 25 17

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

පරිශීලක විමසුමෙන් ආදානය ලබා ගනී. ව්‍යාජ මුද්‍රණය සඳහා ගණිතයේ සටහන් පොත් පරිසරය උපකල්පනය කරයි. එය විධාන රේඛා ස්ක්‍රිප්ටයක් බවට පත් කිරීම සඳහා, එය ඔතා Print[...]හෝ එය තර්ක රහිත ශ්‍රිතයක් බවට පත් කිරීම සඳහා (පසුව විමසුමෙන් ආදානය ලබා ගනී), එකතු කරන්න &.

ගණිතයට අවශ්‍ය ක්‍රියාකරුවන් දෙදෙනාම ඇත (අවශ්‍ය ප්‍රමුඛතාවය සහිතව), එබැවින් අපට ආදානය “ඉවාල්” කළ හැකිය (එය ස්වයංක්‍රීයව සිදු වේ Input[]), නමුත් තාර්කික නිෂේධන ක්‍රියාකරු පූර්ණ සංඛ්‍යා මත ක්‍රියා නොකරයි (එබැවින් එය තක්සේරු නොකෙරේ). ප්‍රති !xresult ලයෙහි වම්පස තිබේ නම්, අපි එය ප්‍රතිස්ථාපනය කරමු 1-x.

ඇගයීම පිළිබඳ විනෝදජනක කරුණු කිහිපයක්:

1. Mathematica ඇත්තටම ද ද්විත්ව ක්රමාරෝපිත සන්නිවේදන සේවා !!, වන ගණනය n*(n-2)*(n-4)*..., නමුත් යෙදිය 0හෝ 1එය තවමත් ලබා දෙන 1ඒ ප්රශ්නයක් නොවේ නම්, 0!!!!!ඇත්තටම ලෙස විග්රහ කරනු ඇත ((0!!)!!)!.
2. ගණිතමය පිටව !0ගොස් !1තක්සේරු නොකළද, එය !ස්වයං ප්‍රතිලෝම බව එය දනී , එබැවින් එය ප්‍රමුඛ පෙළේ සියලුම යුගල ස්වයංක්‍රීයව අවලංගු !කරයි. පසු ToExpressionඅපි කරන්නේ හැම විටම එක් ඉතිරි 0, 1, !0, !1.

[Bash] + යුනික්ස් උපයෝගිතා, බයිට් 21 17

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

මෙය ගොනුවක සුරකින අතර වැඩසටහනක් ලෙස ක්‍රියාත්මක විය යුතුය. ඔබ විධාන රේඛාවෙන් කෙලින්ම විධානය ඇතුල් කිරීමට උත්සාහ කළහොත් එය ක්‍රියා නොකරනු ඇත !! ඉතිහාසය ආදේශ කිරීම බාෂ්ගේ අන්තර්ක්‍රියාකාරී ප්‍රකාරයේදී සක්‍රීය කිරීම හේතුවෙන් පුළුල් වේ. (විකල්පයක් ලෙස, ඔබට ඉතිහාසය ආදේශ කිරීම අක්‍රිය කළ set +Hහැකිය.)

පරීක්ෂණ නඩුව ක්‍රියාත්මක වේ:

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

රෙටිනා , 20 15 14 බයිට්

බයිට් 1 ක් ඉතිරි කිරීම ගැන ලියෝට ස්තූතියි.

0!
1
!!

^1|!0

එය මාර්ගගතව උත්සාහ කරන්න!

පැහැදිලි කිරීම

0!
1

0!බවට හැරෙන්න 1. වෙනත් කිසිදු ලුහුබැඳීම් ගැන අපි තැකීමක් නොකරන්නෙමු !, එහි ප්‍රති number ලයක් ලෙස ලැබෙන අංකය අප සියලු සාධක භාවිතා කළ ආකාරයටම වේ.

!!

නිෂේධන යුගල අවලංගු කරන්න. මෙය සමහර සාධක අවලංගු කළ හැකි නමුත් එය අදාල නොවේ.

^1|!0

අපේක්ෂිත ප්‍රති .ලය ලබා දෙන 1හෝ 0ලබා දෙන මෙම රීජෙක්ස් හි තරඟ ගණන ගණන් කරන්න .

ග්‍රීම් , බයිට් 14 12 9

e`\0!~\!_

එය මාර්ගගතව උත්සාහ කරන්න!

පැහැදිලි කිරීම

මෙය රටාවකට ආදානය සමඟ 1ගැලපේ, ගැලපීම සඳහා මුද්‍රණය කිරීම හා 0නොගැලපීම.

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

අදහස මෙයයි. ආදානය අංකයකින් ආරම්භ වන්නේ නම්, පුනරාවර්තන කොටස \!_සැමවිටම අසමත් වන අතර \0!අපට තනි එකක් නොමැති නම් එය සාර්ථක වේ 0. ආදානය තනි එකක් නොවේ නම් ඔවුන්ගේ xor සාර්ථක වේ 0. ආදානය a සමඟ ආරම්භ වන්නේ නම් !, \0!සෑම විටම සාර්ථක වන \!_අතර පුනරාවර්තන තරගය සාර්ථක වුවහොත් එය සාර්ථක වේ. පුනරාවර්තන තරගය අසමත් වූ විට ඔවුන්ගේ xor හරියටම සාර්ථක වේ.

බ්‍රේන්ෆක්, බයිට් 85 72 (84)

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

සංඛ්‍යාත්මකව ආපසු යාමට, හෝ

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

ASCII පෙළ සඳහා. > මතක එතීම වළක්වා ගැනීම සඳහා ද උපසර්ග ගත කළ හැකිය.

එය මාර්ගගතව උත්සාහ කරන්න!

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

හෝ පෙළ ප්‍රතිචාර සඳහා, අවසාන පේළිය ආදේශ කරන්න

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

බ්‍රේන්ෆක් - බොහෝ බයිට් වලට යන මාර්ගය (බයිට් 232)

කේත ගොල්ෆ් වලින් ජයග්‍රහණය කිරීම සඳහා වැරදි භාෂාව පැහැදිලිවම. ප්රධාන වශයෙන් මම දුටුවේ මෙම esolang භාවිතා කරන කිසිවෙකු නොමැති වීමයි. හොඳ ඔන්ලයින් පරිවර්තක bf අතුරුමුහුණතක් ඇත, නැතහොත් මෙම bf දෘශ්‍යකරණය භාවිතා කරමින් වැඩසටහන කරන්නේ කුමක්දැයි ඔබට සැබවින්ම නැරඹිය හැකිය .

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

පයිතන්, -44- 42 බයිට්

Zgarb ට ස්තූතියි බයිට් 2 ක් ඉතිරි කළා!

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

පියවරෙන් පියවර:

1. x[-1]!='0'
   නම් xඅන්ත සමග 1හෝ !⇔ xසමග අවසන් නොවේ 0, එම ක්රමාරෝපිත කොටසක් වටිනාකමක් තිබිය යුතුය 1, වෙන0
2. ^len(x.rstrip('!'))%2
   xor ගේ දේපල “කොන්දේසි සහිත නොවේ” ලෙස සූරාකන්න. මෙම නඩුවේ තත්වය වන්නේ ආරම්භක !s හි දිග අමුතු නම්. කෙසේ වෙතත්, .rstripනූලෙන් අංකය ඉවත් නොකරන්න , එවිට ගණනය කළ දිග 1 කින් කපා හරිනු ලැබේ, එබැවින් තත්වය ප්‍රතිලෝම වේ
3. පියවර 2 හි 1 වන ඕෆ්සෙට් එක පියවර 1 ට වෙනස් කිරීමෙන් නිවැරදි කරනු !=ලැබේ ==. Zgarb යෝජනා කළේ වෙනත් ප්‍රතිලෝමයක් යෙදීම වෙනුවට බයිට් 2 ක් ඉතිරි කර ගැනීම වෙනුවට වෙනස සංසන්දනය කිරීමේ ක්‍රියාකරුවෙකු භාවිතා කිරීමයි.

එය මාර්ගගතව උත්සාහ කරන්න!

ජාවාස්ක්‍රිප්ට් (ඊඑස් 6), බයිට් 43 41 29

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

රීජෙක්ස් නොවන ක්‍රමය ( බයිට් 41 31)

පහත දැක්වෙන්නේ මගේ ආරම්භක ප්‍රවේශයයි. එය තරමක් රසවත් ය, නමුත් නීල් විසින් සැලකිය යුතු ප්‍රශස්තිකරණයකින් පසුව වුවද සැලකිය යුතු ලෙස දිගු වේ (බයිට් 10 ක් ඉතිරි කර ඇත) .

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

පරීක්ෂණ අවස්ථා

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

රෙටිනා , බයිට් 13 යි

තරමක් අමුතු ප්‍රවේශයක්, නමුත් එය කෙටි වන අතර එය ක්‍රියාත්මක වේ.

0$
!1
!!

^\d

පළමු පේළි දෙකක් අප විසින් අවසන් වෙනුවට 0සමග !1: මෙම ආදේශන සහිත අපි දැන් ඉලක්කම් අපේ සංගීත පැත්තෙන් සිට 1 ට සමාන බව මම දන්නවා.

ඊළඟ පේළි දෙක, යුගල ඉවත් කරන්න !: ද්විත්ව නිෂේධනය මකා දමයි, තවද අපි දැනටමත් පෙර පියවර සමඟ සාධකීය ගණනය කර ඇත.

අන්තිම පේළියේ, නූල ආරම්භයේ දී ඉලක්කම් ගලපන්න සහ තරඟ ගණන ආපසු එවන්න: ප්‍රතික්ෂේප කිරීම් සියල්ල ඉවත් කර ඇත්නම් අපි තරඟයක් සොයා ගනිමු (සහ අපි දැන ගැනීමට පෙර පැවසූ පරිදි මෙය 1 ට සමාන වේ), තවමත් තිබේ නම් ප්‍රතික්ෂේප කිරීමක් මෙය නොගැලපේ.

එය මාර්ගගතව උත්සාහ කරන්න!

ජෙලි , බයිට් 5 යි

VeMḂ$

එය මාර්ගගතව උත්සාහ කරන්න!

නූලක් අපේක්ෂා කරන මොනාඩික් ශ්‍රිතය. ප්රමුඛ පෙලේ යෙදවුම් !හේතුව එයම 1ඒ නිසා මම දෙන Tio ලින්ක් නිමැවුම් පළමු පෙළ යටින් ආදාන-ප්රතිදාන යුගල මුද්රණය කරයි බව පරීක්ෂණ පටි වේ STDOUT කිරීමට, මඟ මුද්රණය කළ යුතුය.

කොහොමද?

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 යි

කේතය:

.V¹'!ÜgG_

භාවිතා කරයි , කොප-1252 කේතන.එය මාර්ගගතව උත්සාහ කරන්න! හෝ සියලුම පරීක්ෂණ අවස්ථා සත්‍යාපනය කරන්න!

පැහැදිලි කිරීම:

.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

රූබි, 12 + 1 = 39 24 15 13 බයිට්

-nධජය භාවිතා කරයි . -9 බයිට් සඳහා @GB ට ස්තූතියි !

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

පර්ල් , බයිට් 20 යි

කේත + -pධජයේ බයිට් 19 ක් .

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

එය මාර්ගගතව උත්සාහ කරන්න!

පර්ල්ගේ ප්‍රතික්ෂේප කිරීම් ප්‍රතිලාභ undefහෝ 1, එබැවින් 0+ප්‍රති result ල 0+undefප්‍රතිලාභ සංඛ්‍යා කිරීමට මම භාවිතා කරමි 0. ඒ හැර, කේතය ගැන වැඩි යමක් කීමට නැත.

සී, 68 62 61 53 බයිට්

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

යම් අපයෝජනයකින් තවත් බයිට් කිහිපයක් මිරිකා

එය මාර්ගගතව උත්සාහ කරන්න!

පර්ල් 6 , 32 28 23 බයිට්

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

එය ක්‍රියාත්මක වන ආකාරය

{                     }  # 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.

හස්කල් , බයිට් 39 යි

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

ශ්‍රිතයක් අර්ථ දක්වයි f, එය නූලක් ගෙන අක්ෂරයක් ලබා දෙයි. එය මාර්ගගතව උත්සාහ කරන්න!

පැහැදිලි කිරීම

අවස්ථා තුනක් තිබේ: ආදානය ආරම්භ වන්නේ !, ආදානයේ දිග 1 සහ අනෙක් සියල්ල.

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'.

බෙෆන්ජ්, බයිට් 24 යි

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

එය මාර්ගගතව උත්සාහ කරන්න!

මෙය ආරම්භ වන්නේ !stdin වෙතින් කියවන අක්ෂර ගණන ගණනය කිරීමෙනි . එසේ නොවන පළමු අක්‍ෂරය !එකක් 0හෝ වේ 1, නමුත් පරීක්ෂා කිරීමේ ක්‍රියාවලියේදී! පසුව අපි තවත් එක් චරිතයක් කියවීමට එය 15 ක් හෝ 16 හෝ කරමින්, අප 33 ශේෂයෙන් අඩු කර ඇත, බව එක්කෝ වනු ඇත! හෝ EOF, සහ එය 0 ට වඩා අඩු නම් සංසන්දනය කරන්න (එනම් ඊඕඑෆ්).

එම දත්ත ලක්ෂ්‍ය තුන සැලකිල්ලට ගනිමින් - විශ්මය ජනක ගණන ( ඇ ), එම ඉලක්කම් අගය, ( ඈ ), සහ අවසානයේ-of-ගොනුව තත්ත්වය ( ඊ ) - අපි පහත සඳහන් පරිදි ප්රතිඵල ගණනය කළ හැක:

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

ගොනුවේ අවසානය අනුව ඉලක්කම් අගය ගුණ කිරීම යනු ඉලක්කම් a ට පසුව නම් එය ශුන්‍ය බවට පරිවර්තනය වනු ඇති !අතර එමඟින් එය සමාන මොඩියුලෝ 2 අගයක් ලබා දෙයි 1(මතක තබා ගන්න 16 බවට පරිවර්තනය කර ඇත). නමුත් මොඩියුලෝ 2 යෙදීමට පෙර, අපි ආරම්භක විශ්මය දනවන අගය එකතු කරන්නෙමු, එමඟින් මොඩියුලෝ 2 ප්‍රති result ලය ඒවායේ !උපසර්ග මෙන් බොහෝ වාරයක් effectively ලදායී ලෙස ටොගල් කරයි . අවසාන වශයෙන් අපි නෑ ප්රතිඵල සඳහා අපගේ පාදක වටිනාකම් සිට 0හා 1අපට අවශ්ය දේ ප්රතිවිරුද්ධ වේ.

කේතය වඩාත් විස්තරාත්මකව බැලීම:

~                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.

හස්කල් , බයිට් 27 යි

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

එය මාර්ගගතව උත්සාහ කරන්න!

එක් එක් ප්‍රමුඛයා !ප්‍රකාශනයේ ඉතිරි කොටස සඳහා ප්‍රතිදානය සම්පූර්ණ කරයි 1-. අපි අංකයකට පහර දෙන තුරු අපි දිගටම පෙරළෙනවා. ඉතිරි කොටස සාධාරණ "0"නම්, ප්‍රති result ලය 0 වේ. එසේ නොමැති නම්, එය a 1හෝ ඊට පසුව එකක් හෝ වැඩි ගණනක් අනුගමනය කරයි !, එබැවින් ප්‍රති result ලය 1 වේ.

රූබි, 22 21 20 බයිට්

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

පැහැදිලි කිරීම:

• පළමු අවස්ථාව, මට '!' අවසානයේ, ඒවා ඉවත් කරන්න, දිග මොඩියුලෝ 2 ලබා ගන්න.
• දෙවන අවස්ථාව, නැත '!', අවසාන අක්‍ෂරය ශුන්‍ය නම් එය ඉවත් කරන්න, දිග මොඩියුලෝ 2 ලබා ගන්න
• අවසාන අක්‍ෂරය 1 නම්, පළමු නඩුව වෙත ආපසු යන්න

(බයිට් -1 සොරකම් කිරීම al අගය තීන්තයේ අදහස)

ජෙලි , බයිට් 8 යි

œr”!LḂ=V

එය මාර්ගගතව උත්සාහ කරන්න!

මෙය ශ්‍රිතයකි එක් තර්කයක් ගෙන එහි ප්‍රතිලාභ අගය හරහා ආපසු එන (මොනාඩික් සබැඳිය). (එය බොහෝ විට අතුරු ආබාධයක් ලෙස සම්මත නිමැවුමට කුණු ලියයි, නමුත් අපි ඒ ගැන තැකීමක් නොකරමු.)

පැහැදිලි කිරීම

œ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

පළමුවෙන්ම, ආදානය සෑම විටම යම් ගණනකින් සමන්විත වන අතර !, පසුව ඉලක්කම් වලින් පසුව තවත් බොහෝ දේ !, අපි පසුපස මකා !දමා දිග ගතහොත් , අපි එක් ප්ලස් එකකින් සහ !වැඩසටහනේ ප්‍රමුඛ සංඛ්‍යාවෙන් අවසන් වන බව සලකන්න . මෙහි සමානාත්මතාවය ගත් විට ඔත්තේ සංඛ්‍යාවක් තිබුනේ නම් 0 ක් !හෝ ඊටත් වඩා සංඛ්‍යාවක් තිබේ නම් 1 නැවත පැමිණේ !. 0 සමඟ සංසන්දනය කිරීම "නොවන" ශ්‍රිතයක් වන අතර 1 සමඟ සංසන්දනය කිරීම අනන්‍යතා ශ්‍රිතය වේ; මේ අනුව œr”!LḂ=treat ලදායී ලෙස “ප්‍රමුඛ පෙළේ සංග්‍රහය” ක්‍රියාත්මක කරයි! , ප්‍රශ්නයේ කොටසක් වන “ක්‍රියාකරුවන් නොවන ලෙස .

දෙවන භාගය සඳහා, සාධක සාධක හැසිරවීම !ජෙලි හි සාධකීය මෙහෙයුමකි, එබැවින් වැඩසටහනට ප්‍රමුඛතාවයක් නොමැති නම් !, අපට සරල eval( V) සමඟ ගැටළුව කෙලින්ම විසඳා ගත හැකිය . වැඩසටහනට ප්‍රමුඛතාවයක් තිබේ නම් !, ඒවා 0 හි සාධකය (සමහර විට කිහිප වතාවක්) ගෙන, 1 හි ප්‍රතිලාභ අගය නිපදවන අතර එය සම්මත නිමැවුමට මුද්‍රණය කර ඉලක්කම් දුටු විට ඉවතලනු ලැබේ; මේ අනුව, ප්‍රශ්නයට මා ඉදිරිපත් කළ ශ්‍රිතයේ ප්‍රතිලාභ වටිනාකමට ඒවා කිසිදු බලපෑමක් නොකරයි.

පයිතන්, බයිට් 38 යි

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

TryItOnline!

නම් නොකරන ලද ශ්‍රිතයක් ආදාන නූලක් sගෙන පූර්ණ සංඛ්‍යාවක් ආපසු ලබා දීම 0හෝ 1.

s[1::2] යනු ආදාන නූලක පෙත්තක් වන අතර එය දර්ශක 1 හි ආරම්භ වන අතර පියවර දෙකේ විශාලත්වය ඇත:
'Like this' -> 'ieti'

s[::2] සමාන නමුත් 0 හි පෙරනිමි දර්ශකයෙන් ආරම්භ වේ:
'Like this' -> 'Lk hs'

පරීක්ෂණය (s[1::2]>s[::2])මගින් 0 පදනම් කරගත් දර්ශකය '0'හෝ '1'අමුතුද යන්න පරීක්ෂා කරයි, එනම් අපට අනුපූරක වීමට අවශ්‍ය නම්.
මෙය ක්‍රියාත්මක වන්නේ හිස් නූල් අනුපිළිවෙල හිස් නූලට වඩා විශාල හිස් නොවන නූල් සමඟ ශබ්දකෝෂ විද්‍යාත්මකව පරීක්ෂා කර ඇති නිසා සහ ASCII ඇණවුම සමඟ ය '1'>'0'>'!'. මෙය සරල ඒවාට වඩා කෙටි බයිට් එකකි s.index(max(s))%2.

මෙම ord(s[-1])%2අවසන් අක්ෂරය නො වේ නම්, දකින්න චෙක්පත් '0'(වලංගු ආදානය සඳහා), සහ පූර්ණ සංඛ්යාවක් ප්රතිඵල (එම දිග ඇති ෙහයින්ද (s[-1]!='0')වූ වීජ බවත් නැවත).
මෙය ක්‍රියාත්මක වන්නේ ආදානයේ අවසාන අක්‍ෂරය පිළිවෙලින් 0, 1 සහ 1 මොඩියුලෝ 2 වන ASCII කේත ලකුණු 48, 49 සහ 33 පිළිවෙලින් s[-1]a '0', '1'හෝ '!'වේ.

මෙම ^එවිට එක් ආදාන, හරි එක පටන් යනු පූර්ණ සංඛ්යාවකි නැවත, ඉහත අගයන් දෙකක් මත bitwise සුවිශේෂී හෝ මෙහෙයුම් සිදු කරන අතර, යනු පූර්ණ සංඛ්යාවකි. වම්පස සත්‍ය නම් දකුණේ අනුපූරකය ආපසු දෙනු ලැබේ, වම් අසත්‍ය නම් අවශ්‍ය පරිදි දකුණ ආපසු ලබා දෙනු ලැබේ.

ජාවා 7, 105 82 81 බයිට්

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;}

එය මාර්ගගතව උත්සාහ කරන්න!

පැරණි රීජෙක්ස්-ඊෂ් විසඳුම

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

සී ජෑම් , බයිට් 12 11

r_W='0=!\~;

එය මාර්ගගතව උත්සාහ කරන්න! පරීක්ෂණ කට්ටලය ( 1එක් එක් නිවැරදි පරීක්ෂණ අවස්ථාව සඳහා a මුද්‍රණය කරයි ).

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.

හස්කල් , බයිට් 67 65

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

එය මාර්ගගතව උත්සාහ කරන්න! භාවිතය:f "!!!0!!!!"

ඉනිමීට ස්තූතියි බයිට් දෙකක් ඉතිරි කළේය.

බ්‍රේන්ෆක්, බයිට් 115 යි

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

එය මාර්ගගතව උත්සාහ කරන්න!

Ungolfed:

% 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
]

කණ්ඩායම, බයිට් 62 යි

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

STDIN මත ආදානය ගනී. කණ්ඩායම !මෙම අභියෝගය සඳහා ප්‍රමුඛයන් නිවැරදිව වටහාගෙන ඇත , නමුත් පසුපසින් !සිටින අය සමඟ කටයුතු කළ යුතුය, එය පියවර තුනක් ගනී:

• වෙත වෙනස් 0!කරන්න1
• යුගල මකන්න !!(මෙය !!ඉලක්කම් වලට පෙර s සඳහාද ආරක්ෂිතයි )
• ඉතිරිව ඇති ඕනෑම ලුහුබැඳීමක් මකන්න ! (මේ වන විට විය හැක්කේ a ට පසුව පමණි 1)

sed, 36 33 31 බයිට්

පිරිසිදු sed, bc / shell utils නොමැත. GNU sed <4.3; BSD සහ GNU 4.3+ මත බයිට් 33 ක්.

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

ඔබ හුරුපුරුදු නම් කෙලින්ම ඉදිරියට යන්න sed ; නැති අය වෙනුවෙන් අදහස් දැක්වූයේ:

# 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

පරීක්ෂණය:

% 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 බයිට්

සටහන: IBM-850 කේතන ක්‍රමය භාවිතා කරයි

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

මේ ආකාරයට දුවන්න:

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

පැහැදිලි කිරීම

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.

කරකැවිල්ල

• IBM-850 කේතන ක්‍රමයෙන් බයිට් 3 ක් ඉතිරි කර ඇත
• රීජෙක්ස් තරමක් වෙනස් කිරීමෙන් බයිට් එකක් ඉතිරි කර ඇත
• බයිට් 17 ක් සුරකින ලදි, දිගු ක්‍රියාකාරී නම් නොමැතිව නව අනුවාදය සහ ආපසු
• භාවිතයෙන් බයිට් 2 ක් ඉතිරි කර ඇත -R(එමඟින් $argnලබා ගත හැකිය)

IBM / නෙළුම් සටහන් සූත්‍රය - බයිට් 77 යි

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

සටහන් ෆෝමියුලා සඳහා TIO නොමැත, එබැවින් සියලු පරීක්ෂණ අවස්ථා වල තිර රුවක් පහත දැක්වේ:

එය ක්‍රියාත්මක වන ආකාරය

@Eval() ප්‍රකාශනයක් ලෙස නූලක් ඇගයීමට ලක් කරයි

පළමුවෙන්ම අපි පරීක්ෂා කරන්නේ ක්ෂේත්‍රයේ ආදාන පෙළ (ආදානය) aඅඩංගු ද 1නැතිනම් 0සියලු අක්ෂර වම් පසින් ගෙන යන අතර එය !අක්ෂර මාලාවක් වනු ඇත . අපි කීයක් ගණන් ගන්නේ නැහැ.@Eval()ඒ ගැන බලා ගනීවි.

ඊළඟට අපි බලමු !නූල් අවසානයේ a තිබේදැයි බලන්න . අපි නූලට එකතු 1කරන්නේ නම් !( 0!සහ 1!දෙකම 1 වේ - !අවසානයේ අක්ෂර කීයක් තිබේද යන්න ගැටළුවක් නොවේ ) එසේ නොමැති නම් අපි අන්තිම අක්‍ෂරය නොවෙනස්ව එකතු කරන්නෙමු, මන්ද එය a නොවන අතර !එය a1 හෝ a0 .

අප සතුව දැන් ප්‍රමුඛ ප්‍රතිලෝමයන් ඇතුළත් වන අතර සාධකීය අක්‍ෂර තිබේද යන්න නිර්වචනය කර ඇති සංඛ්‍යාවක් ඇත, එබැවින් අපට මෙය පෝෂණය කර @Eval()ඉහත ප්‍රති results ල ලබා ගත හැකිය.

බීන් , බයිට් 24 යි

හෙක්ස්ඩම්ප්:

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

සමාන ජාවාස්ක්‍රිප්ට්:

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

ඔබේ ඇඟිලි මතට නැගීම ගැන කණගාටුයි, ආර්නෝල්ඩ් .

පැහැදිලි කිරීම:

දී නව DOS string ලෙස ආදාන පළමු මාර්ගය ගනී a, සහ එකක් හෝ ඊට වැඩි මගින් ඕනෑම ඉලක්කම් විස්ථාපනය !සමග 1ඉතිරි විය හැකි නිසා බව, eval'JavaScript විසින් ඈ.

නිරූපණය හෝ පරීක්ෂණ කට්ටලය උත්සාහ කරන්න