您的任务是编写两个程序。程序A不得在所有输入上打印任何内容，除非输入了程序B，否则应打印1。程序B必须1在所有输入上打印出来，但输入程序A时除外，在这种情况下，它不应打印任何内容。

得分：

• +1对于两个程序中的每个字符。
• 最低分获胜。

GTB，25

从TI-84计算器执行

程序 A

`_@_eq;"$w;&

程序 B

`_@_eq;"$#w;&

说明

`_ 输入一个字符串

@_eq;"检查它是否等于源代码（#会自动与小写字母一起剥离）

$w;&如果是这样，显示1（否则没有）为B它的$#w;&-如果不是，显示1（否则无）]

重击-32个字符

脚本A-16个字符

cmp -s b&&echo 1

脚本B-16个字符

cmp -s a||echo 1

用法

$> echo "foo" | ./a
$> cat b | ./a
1
$> echo "foo" ./b
foo ./b
$> cat a | ./b

Ruby，54岁

一种

$><<1if$<.read==IO.read(?B)

乙

$><<1if$<.read!=IO.read(?A)

例子：

bash-3.2$ ruby A < A
bash-3.2$ ruby A < B
1bash-3.2$ ruby B < A
bash-3.2$ ruby B < B
1bash-3.2$ 

J（62）

既然你没有禁止...

将程序分别存储为A和B。

计划A（30）：

exit echo#~(1!:1<'B')-:1!:1[3

程式B（32）：

exit echo#~-.(1!:1<'A')-:1!:1[3

工作原理（程序B，A相似）：

• 1!:1[3：读标准输入
• 1!:1<'A'：读取文件 A
• -:：看看它们是否相等
• -.：否定结果
• #~：自己复制结果（因此，1结果为1 1，0结果为0 0s，即为空）
• echo：输出
• exit：退出（J解释器到达文件末尾时默认不退出）

$ jconsole A <B
1个
$ jconsole A <foo
$ jconsole B <A
$ jconsole B <foo
1个
$

Haskell-无需加载源-478644个字符

假设getContents总是以换行符结尾，因此不检查就删除了最后一个字符，因为我不想转义它

一种

main=interact$($'1').replicate.(1-).fromEnum.(/=map r(d++shows d[toEnum 10]))where r n|n=='-'='*'|n=='*'='-'|True=n;d="main=interact$($'1').replicate.(1-).fromEnum.(/=map r(d++shows d[toEnum 10]))where r n|n=='-'='*'|n=='*'='-'|True=n;d="

乙

main=interact$($'1').replicate.(1*).fromEnum.(/=map r(d++shows d[toEnum 10]))where r n|n=='*'='-'|n=='-'='*'|True=n;d="main=interact$($'1').replicate.(1*).fromEnum.(/=map r(d++shows d[toEnum 10]))where r n|n=='*'='-'|n=='-'='*'|True=n;d="

它的工作方式类似于标准的quine，但将-换成*以获取其他程序（避免在其他地方使用这些字符）。

以下测试按预期方式打印（用a =和b =替换main = interact $）

main=do
  putStrLn "START"
  putStrLn$a "FOO"
  putStrLn$a "main=interact$($'1').replicate.(1*).fromEnum.(/=map r(d++shows d[toEnum 10]))where r n|n=='*'='-'|n=='-'='*'|True=n;d=\"main=interact$($'1').replicate.(1*).fromEnum.(/=map r(d++shows d[toEnum 10]))where r n|n=='*'='-'|n=='-'='*'|True=n;d=\"\n"
  putStrLn$b "FOO"
  putStrLn$b "main=interact$($'1').replicate.(1-).fromEnum.(/=map r(d++shows d[toEnum 10]))where r n|n=='-'='*'|n=='*'='-'|True=n;d=\"main=interact$($'1').replicate.(1-).fromEnum.(/=map r(d++shows d[toEnum 10]))where r n|n=='-'='*'|n=='*'='-'|True=n;d=\"\n"
  putStrLn "END"

--

START

1
1

END

Python 2.7-82

文件A（简称为a）：

if raw_input()==open('b').read():print 1

文件B（简称为b）：

if raw_input()!=open('a').read():print 1

Ruby，166个字符，无阅读源

A：

(gets(p)==<<2.tr('&|','|&')*2+'2')&&p(1)
(gets(p)==<<2.tr('&|','|&')*2+'2')&&p(1)
2

B：

(gets(p)==<<2.tr('|&','&|')*2+'2')||p(1)
(gets(p)==<<2.tr('|&','&|')*2+'2')||p(1)
2

确保您的文本编辑器不保存尾随换行符。

用法（示例）：

 $ ruby know_a.rb know_b.rb 
1
 $ ruby know_a.rb know_a.rb 
 $ ruby know_b.rb know_a.rb 
 $ ruby know_b.rb know_b.rb 
1

每个程序使用HEREdoc和字符串转换构造另一个程序的源，然后将结果与输入进行比较。

哈斯克尔-138

这不是一个很好的答案，但是希望使两个程序使用相同的源。通过重命名文件可以节省一些字符，但这并不能使它成为一个成功的解决方案，因此我认为这样做不值得。

import System.Environment
import Control.Monad
main=do{i<-getContents;p<-getProgName;f<-readFile "ab.hs";when((f==i)/=(p=="B"))(print 1)}

将此源编译为A和B。

测试：

% ghc -o A ab.hs
[1 of 1] Compiling Main             ( ab.hs, ab.o )
Linking A ...
% cp A B
% ./A < ab.hs
1
% ./B < ab.hs
% ./A < ab.hi
% ./B < ab.hi
1

Node.js-142个字符

脚本|（也称为脚本A）-80个字符

f=require('fs').readFileSync;f('/dev/stdin','hex')==f('&','hex')&&console.log(1)

脚本&（也称为脚本B）-62个字符

eval(require('fs').readFileSync('|','utf8').replace(/&/g,'|'))

用法

# \| is Script A
# \& is Script B

$> echo "foo" | node \| 
$> cat \& | node \| 
1
$> echo "foo" | node \& 
1
$> cat \| | node \&

描述

脚本B读取脚本A的内容，并将文件名和and运算符交换为，然后对其进行评估or。

我命名了文件&，|因此可以在脚本B中执行一次替换。

Python 3-102个字符

如果输入的内容与程序2相同，则显示1，否则显示：

if input()==open('a.py').read():print('1')

如果输入与程序1不同，则输出1。否则：

if input()==open('a.py').read():print('1')

bash / grep — 59个字符

如果仅计算实际程序字符串，则为51个字符。

$ a='grep -cx "$b" | grep -x 1'
$ b='grep -vcx "$a" | grep -x 1'
$ echo 'foo' | eval $a
$ echo $b | eval $a
1
$ echo 'foo' | eval $b
1
$ echo $a | eval $b

R（62个字符）

i=identical
A=function(x)if(i(x,B))1
B=function(x)if(!i(x,A))1

产生：

> A(123)
> A(A)
> A(B)
[1] 1
> B(123)
[1] 1
> B(A)
> B(B)
[1] 1

元评论：R代码在代码高尔夫方面相对较差，因为没有捷径可function...