数学是事实。编程不是


175

在数学中,感叹号!通常表示阶乘,并且在论点之后出现。

在编程中,感叹号!通常表示取反,它位于参数之前。

对于这一挑战,我们仅将这些运算应用于零和一。

Factorial
0! = 1
1! = 1

Negation
!0 = 1
!1 = 0

取一个零或多个字符串!,然后是01,然后是零个或多个字符串!/!*[01]!*/)。
例如,输入可以是!!!0!!!!!!!1!0!!0!1

!的之前的0或者1是否定和!年代后的阶乘。

阶乘的优先级比否定的优先级高,因此总是优先应用阶乘。
例如,!!!0!!!!确实意味着!!!(0!!!!),或者更好!(!(!((((0!)!)!)!)))

输出所有阶乘和否定的结果应用。输出将始终为01

测试用例

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

以字节为单位的最短代码获胜。


18
但是0!= 1 !,那么处理多个阶乘有什么意义呢?
boboquack

30
@boboquack因为这是挑战。
加尔文的业余爱好

11
<?='1'; ...在PHP中纠正75%的时间。
阿斯卢姆,

10
我在这里可能是错误的,但是在简单地将其删除并替换为1之后,不能将任何带阶乘的数设为数字吗?像0 !!!! = 1!= 0 !!!!!!!! = 1 !!!= 1!= 0!= 1等
Albert Renshaw

2
@AlbertRenshaw是的。
加尔文的业余爱好

Answers:


43

Mathematica,25个 17字节

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

从用户提示输入。假定Mathematica的笔记本环境用于隐式打印。要使其成为命令行脚本,请将其包装Print[...]或使其成为无参数函数(然后从提示符处获取输入),然后追加&

Mathematica具有两个必需的运算符(具有必需的优先级),因此我们可以“评估”输入(由自动完成Input[]),但是逻辑否定运算符不适用于整数(因此它将保持未赋值的状态)。如果结果中有!x剩余,我们将其替换为1-x

有关评估的两个有趣事实:

  1. Mathematica实际上具有双阶乘运算符!!,该双因子运算符可以计算n*(n-2)*(n-4)*...但仍应用于01仍然给出1,因此,0!!!!!将其实际解析为没关系((0!!)!!)!
  2. 即使Mathematica离开!0!1没有!被评估,它也知道这是自反的,因此它将自动取消所有对的领先!。之后,ToExpression我们总是留下的一个01!0!1

3
从什么时候开始默认允许REPL代码段?
LegionMammal978

2
@ LegionMammal978显然是自2015年12月以来,但我一直对此遗忘。公平地说,它不是一个“片段”,因为它不假定输入已经存储在内存中的某个位置。假设笔记本环境与使用隐式输出的语言没有太大不同。
Martin Ender

只是好奇,可以提供一个元链接吗?(试图找到有压力的信息,这是SE Q&A格式的又一个问题……)
LegionMammal978'2

@ LegionMammal978已经在答案中了。
马丁·恩德

纯ksh解决方案x=${x/[01]!*/1};echo $(($x))-不允许发布正确的答案:(
DarkHeart

28

[Bash] + Unix实用程序,21 17字节

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

必须将其保存在文件中并作为程序运行。如果您尝试直接从命令行输入命令,它将无法正常运行,因为!! 由于在bash的交互模式下启用了历史记录替换,因此扩展。(或者,您可以使用关闭历史记录替换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

旧版本有效,但旧版本无效
牛嘎嘎叫声

我使用了TIO链接
Cows quack'Feb

@KritixiLithos在Linux机器上尝试时,它工作正常。问题显然是TIO在模拟输入行的末尾需要换行。这是一个令人困惑的情况,所以我删除了TIO链接。如果要在此处尝试,请再次使用链接(但如果更改输入以对其进行测试,请确保在输入末尾添加换行符):tio.run/nexus/bash#@1@cmqJQrK @ nqKilom @ oX5OU / P @ /…
Mitchell Spector

2
但是,如果有人逃跑了mkdir -p 's/.!!'{bunch,of,different,directories}\$/1怎么办?然后,您将得到Pathname Expansion,Sed将尝试像读取文件一样读取目录,而不是读取标准输入,并且它将不会输出任何内容!:)
通配符

1
@Wildcard我完全同意。在生产脚本中,我总是在这种情况下使用引号。(在这种情况下,我实际上会在sed的参数两边加上双引号,而不仅仅是转义*。它比使用反斜杠更容易阅读,并且避免了丢失某些特殊字符的可能性。)
Mitchell Spector

22

视网膜20 15 14字节

感谢Leo节省了1个字节。

0!
1
!!

^1|!0

在线尝试!

说明

0!
1

0!1。我们不在乎其他尾随!s,得到的数字与应用所有阶乘相同。

!!

取消成对的否定。这也可能会取消某些阶乘,但这无关紧要。

^1|!0

计算此正则表达式的匹配数,该匹配数为1或,0并给出所需的结果。


相同字节数的替代解决方案:\d.+...
奶牛嘎嘎声

@KritixiLithos找到了一种完全避免这种情况的方法。
Martin Ender

您可以删除^之前的内容!0
Leo

17

污垢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。除非输入为single,否则它们的xor成功0。如果输入以开头!,则\0!始终成功,\!_如果递归匹配成功,则成功。当递归匹配失败时,它们的xor完全成功,从而取反。


16

Brainfuck,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

14

Brainfuck-通往许多字节(232字节)的方式

显然,赢得代码高尔夫的语言错误。主要是我注意到缺少使用此esolang的任何人。有一个不错的在线解释器bf插入器,或者您可以使用此bf可视化器实际观看程序的作用。

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

3
你这个疯子!
Almo

喜欢它,你能大肆宣传吗?XD
Stefan Nolde'Feb

信息:下面有太多简短的解决方案。
user202729 '18

14

Python,-44- 42字节

感谢Zgarb,节省了2个字节!

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

一步步:

  1. x[-1]!='0'
    如果x1!x不以结尾0,则阶乘部分必须具有值1,否则0
  2. ^len(x.rstrip('!'))%2
    利用xor的属性作为“有条件的不”。在这种情况下,条件是初始!s 的长度为奇数。但是,.rstrip不要从字符串中删除数字,因此计算出的长度会偏移1,因此条件会被反转
  3. 通过将步骤2中的更改!=为1,可以将步骤2中的偏移量校正为==1。Zgarb建议使用差值比较运算符而不是应用另一个反转,从而节省2个字节。

在线尝试!


输入失败!!0; 目前正在返回1
价值墨水

@ValueInk应该现在正在工作
busukxuan

1
lambda x:(x[-1]=='0')^len(x.rstrip('!'))%2避免额外的反转。
Zgarb

15
划掉44仍然是常规的44
Rɪᴋᴇʀ

3
我认为他说的是所使用字体中的划掉的44看起来并不划掉... :)划掉的部分与4s的水平部分重叠。
JeffC

13

JavaScript(ES6),43 41 29字节

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

非正则表达式方法(41 31个字节)

以下是我的初始方法。稍微有点有趣,但是即使经过Neil的重大优化(节省了10个字节),也明显更长 了一点,甚至更长了一点

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

测试用例


我只能保存从非正则表达式的方法10个字节,所以它仍然是太长:f=([c,...s])=>1/c?c|s>'':1-f(s)
尼尔

@Neil既然比起我的第一次尝试要好得多,所以我很乐意加入您的建议。
Arnauld

哈,我有相同的想法,但您打得更好。:)
Devsman '17

11

果冻,5 个字节

VeMḂ$

在线尝试!

Monadic函数需要一个字符串。带前导!s的输入会导致将a 1一直打印到STDOUT,因此我给出的TIO链接是一个测试工具,用于在输出的第一行下方打印输入-输出对。

怎么样?

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.

10

05AB1E,9个字节

码:

.V¹'!ÜgG_

使用CP-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

10

视网膜,13字节

一种有点怪异的方法,但是它很短并且有效。

0$
!1
!!

^\d

在前两行中,我们0!1:替换结尾:现在,我们知道从数字开始的字符串部分等于1。

接下来的两行,删除对!:双重否定会擦除自身,并且我们已经在上一步中考虑了阶乘。

最后一行,在字符串的开头匹配一个数字并返回匹配数:如果所有的否定都被消除,我们将找到一个匹配项(就像我们之前所说的那样,它等于1),如果还有否定的否定。

在线尝试!


1
最终数字是否一定总是1?在这种情况下,您可以使用1而不是\d

1
@ ais523否,因为第一部分只会替换结尾的0,所以例如输入0!将保持不变,直到最后一行
Leo

1
真正可爱的解决方案,不错的工作!:)
Martin Ender

10

Ruby,12 + 1 = 39 24 15 13个字节

使用-n标志。感谢@GB -9个字节!

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

由于仅检查长度,因此可以删除结尾的零,而不必先检查“!0”,然后再检查一个零。
GB

@GB是个好主意!但是,通过修改我的正则表达式以查找行尾0 或行尾,我发现了一个更短的解决方案
Value Ink

然后,您可以仅检查尾随的“!” 或零或行尾:p〜/!+ $ | 0 $ | $ /%2仅14个字节。
GB

然后“ 0 $ | $”可以变成“ 0?$”以保存另一个字节。
GB

1
更好而又!*$短了两个!
价值墨水

9

Perl,20个字节

19个字节的代码+ -p标志。

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

在线尝试!

Perl的否定返回undefor 1,所以我用0+数字对0+undef返回的结果进行量化0。除此之外,关于代码没有太多要说的。


2
刚写了这个。+1。
primo

@primo很高兴看到我一次不在你后面20个字节!谢谢:)
达达

9

C,68 62 61 53字节

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

挤出了一些字节,但有些滥用

在线尝试!


1
我认为您可以int从函数中删除,也可以将更*a==33改为*a<34
牛嘎嘎声

las *a%2*a-48

谢谢你的提示。我还可以通过删除返回值周围的括号并为其分配字符来消除其他字符。
Ahemone

我很确定for(;*a<34;a++)可以将其缩短为for(;*a++<34;)节省1个字节
Albert Renshaw

不幸的是,由于条件语句将始终执行,因此将指针推得太远,无法进行返回取消引用。
Ahemone

6

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

6

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

从String切换为Integer作为返回类型:f('!':b)=[1,0]!!f b;f"0"=0;f _=1
nimi

6

Befunge,24个字节

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

在线尝试!

首先计算!从stdin读取的字符数。不是a的第一个字符!将是a 01,但是在测试过程中!我们将减去33,使其成为15或16。然后再读取一个字符,该字符将是a !或EOF,并且比较是否小于0(即EOF)。

取三个数据点-感叹号(c),数字值(d)和文件结束条件(e)-我们可以计算出以下结果:

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

将数字值乘以文件结尾条件意味着,如果数字后面跟有a !,则它将转换为零,从而赋予它与a相同的模2值1(记住已转换为16)。但是在应用模2之前,我们添加了初始感叹号,它可以有效地切换模2结果的!前缀次数。最后,由于和的基线值与我们需要的相反,因此我们没有得到结果。01

详细查看代码:

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

6

Haskell,27个字节

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

在线尝试!

每个前导!对表达式的其余部分的输出进行补充,如1-。我们一直在翻转,直到达到数字为止。如果剩余数为just "0",结果为0。否则为a 1或后跟一个或多个!,因此结果为1。


5

Ruby,22 21 20字节

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

说明:

  • 第一种情况,我得到一些“!” 最后,将其删除,将长度取模2。
  • 第二种情况,没有'!',如果最后一个字符为零,则将其删除,将长度取模2
  • 如果最后一个字符为1,则返回第一种情况

(-1字节窃取@Value Ink的想法)


太棒了,我看了10分钟的拼图,但时间不多,然后就忘了。现在,它又在活跃的问题中再次发现它,并很高兴看到这样一个不错的方法。
akostadinov

4

果冻,8字节

œr”!LḂ=V

在线尝试!

这是一个函数(monadic链接),它接受一个参数并通过其返回值返回。(它通常还会将垃圾内容写入标准输出,但我们对此并不在意。)

说明

œ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

首先,请注意,由于输入始终由一定数量的组成!,后跟一个数字,然后是more !,因此,如果删除尾随!并取长度,则最终将加一个加!程序中前导的数字。如果奇数个数为奇数!,则取此奇偶校验将返回0;如果偶数个数为奇数,则返回1 !。与0比较是“非”函数,而与1比较是恒等函数。因此œr”!LḂ=有效地实现了问题的“ !非运算符领先”。

至于下半部分,处理阶乘!是Jelly中的阶乘操作,因此,如果程序没有前导!,我们可以使用简单的evalV)直接解决问题。如果程序确实有前导!,则将其解释为采用阶乘0(可能是多次),产生返回值1,该返回值将被打印到标准输出并在看到一个数字时被丢弃;因此,它们对我提交给问题的函数的返回值没有影响。


非常好,很好的解释。
ElPedro

4

Python,38个字节

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

TryItOnline!

带有输入字符串s并返回整数0或的未命名函数1

s[1::2] 是输入字符串的一部分,从索引1开始,步长为2:
'Like this' -> 'ieti'

s[::2] 相似,但从默认索引0开始:
'Like this' -> 'Lk hs'

该测试(s[1::2]>s[::2])检查'0'or的从0开始的索引'1'是否为奇数,即是否需要补码。
之所以可行,是因为按字典顺序检查字符串的顺序是使用大于空字符串的任何非空字符串,并使用ASCII顺序,因此'1'>'0'>'!'。这比简单的字节短一个字节s.index(max(s))%2

ord(s[-1])%2检查是否最后的字符不是一个'0'(对于有效的输入),并且导致一个整数(而相同的长度(s[-1]!='0')会返回一个布尔值)。
此操作,因为输入的最后一个字符,s[-1]将是一个'0''1''!'具有ASCII码分别指向48,49和33,它们是0,1和1模2。

^然后执行按位上上述两个值异或操作时,由于一个输入,正确的返回的整数,是整数。如果左侧为True,则返回右侧的补码;如果左侧为False,则根据需要返回右侧。


4

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

2
c^=1超级聪明。如果我见过,那将是一个未使用的运算符。
艾迪生·克朗普

3

CJam12 11字节

r_W='0=!\~;

在线尝试! 测试套件1为每个正确的测试用例打印一个)。

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.


3

Brainfuck,115个字节

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

在线尝试!

取消高尔夫:

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

2

批处理,62字节

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

在STDIN上输入。批处理实际上可以!正确理解此挑战的前导,但是!需要处理尾随的,这需要三个步骤:

  • 更改0!1
  • 删除对!!(这对于!!数字前的s 也是安全的)
  • 删除所有剩余的结尾!(目前只能在之后1

2

IBM /莲花笔记公式-77字节

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

Notes公式没有TIO,因此所有测试用例的屏幕截图如下所示:

所有测试用例

这个怎么运作

@Eval() 将字符串评估为表达式

首先,我们检查字段(输入)a中的输入字符串是否包含1或,0然后将所有字符都放在左边(即为字符串)!。我们不在乎有多少。@Eval()会照顾的。

接下来,我们来看!字符串的末尾是否有一个。如果我们1!字符串后追加(0!1!均为1- !末尾有多少个字符都没有关系),否则我们将最后一个字符原样追加,因为它不是a !,可以是a 1或a 0

现在,我们有一个包含前导倒置的字符串以及一个由是否存在阶乘字符定义的数字,因此我们可以将其提供给@Eval()上面并获得结果。


2

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
%

IIRC的某些(全部?)版本sed允许您使用空字符串作为标签名称。如果您可以在这里工作,则可以节省两个字节。实际上,我不确定是否还需要标签。除非我错过了某些内容,否则第一行是幂等的,因此您可以跳回到程序的开头,而不需要标签。

@ ais523我也这么认为,但显然它在BSD版本中不起作用。手册页上显示“如果未指定标签,则跳转到脚本的末尾”,即使在我尝试时它也无法正常工作。
凯文,

GNU sed确实允许标签只是一个标签:(更多是作为功能的错误),在这种情况下,tand和b!命令跳转到标签的位置。另外,与其他语言类似,sed代码必须至少适用于sed的一个版本,因此您无需创建也适用于BSD的代码。
seshoumara

2

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

1

Bean,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

等效的JavaScript:

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

对不起,脚踩到脚了,阿尔诺德

说明:

取输入作为无格式串的第一行中a,并替换任意数字,然后通过一个或多个!1,使其余的可以eval“由JavaScript天。

尝试演示测试套件

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.