Você está encarregado de escrever dois programas. O programa A não deve imprimir nada em todas as entradas, exceto quando o programa B é inserido, caso em que deve ser impresso 1. O programa B deve imprimir 1em todas as entradas, exceto quando o programa A for inserido, caso em que não deverá imprimir nada.

Pontuação:

• +1 para cada personagem dos dois programas.
• Menor pontuação ganha.

GTB , 25

Executado a partir de uma calculadora TI-84

Programa A

`_@_eq;"$w;&

Programa B

`_@_eq;"$#w;&

Explicação

`_ Insira uma string

@_eq;"Verifique se é igual ao código-fonte ( #é automaticamente removido com letras minúsculas)

$w;&Nesse caso, exiba 1 (caso contrário, nada) [ Bpois é $#w;&- se não, exiba 1 (caso contrário, nada)]

Bash - 32 caracteres

Script A - 16 caracteres

cmp -s b&&echo 1

Script B - 16 caracteres

cmp -s a||echo 1

Uso

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

Ruby, 54

UMA

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

B

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

exemplos:

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)

Desde que você não proibiu isso ...

Armazene os programas como Ae Brespectivamente.

Programa A (30):

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

Programa B (32):

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

Como funciona (o Programa B, A é semelhante):

• 1!:1[3: leia stdin
• 1!:1<'A': ler arquivo A
• -:: veja se são iguais
• -.: negar o resultado
• #~: replica o resultado por si só (portanto, 1resulta em um 1e 0resulta em zero 0s, ou seja, nada)
• echo: resultado
• exit: exit (o intérprete J não sai por padrão quando chega ao final do arquivo)

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

Haskell - SEM fonte de carregamento - 478 644 caracteres

Isso pressupõe que getContents SEMPRE termina com uma nova linha e, portanto, elimina o caractere final sem verificar, porque não tenho vontade de escapar dele

UMA

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="

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="

Funciona como uma solução padrão, mas trocando - por * para obter o outro programa (evitando esses caracteres em outro lugar).

O teste a seguir é impresso conforme o esperado (substituindo main = interact $ por a = eb =)

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

Arquivo A (literalmente nomeado apenas a):

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

Arquivo B (literalmente nomeado apenas b):

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

Ruby, 166 caracteres, sem fonte de leitura

UMA:

(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

Verifique se o editor de texto não salva com uma nova linha à direita.

Uso (exemplo):

 $ 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

Cada programa constrói a fonte do outro programa usando um HEREdoc e transformações de string e depois compara o resultado com a entrada.

Haskell - 138

Não é realmente uma boa resposta, mas queria que os dois programas usassem a mesma fonte. Poderia salvar alguns caracteres renomeando o arquivo, mas isso não será uma solução vencedora, então não acho que valha a pena.

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

Compile esta fonte como ambos AeB .

Teste:

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

Script |(também conhecido como Script A) - 80 caracteres

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

Script &(também conhecido como Script B) - 62 caracteres

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

Uso

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

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

Descrição

O Script B lê o conteúdo do Script A e o avalia após trocar os nomes dos arquivos e o andoperador para umor .

Eu nomeei os arquivos &e, |assim, posso executar uma única substituição no Script B.

Python 3 - 102 caracteres

Imprime 1 se a entrada for igual ao programa 2, caso contrário nada:

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

Imprime 1 se a entrada não for igual ao programa 1, caso contrário, nada:

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

bash / grep - 59 caracteres

51 caracteres se contarmos apenas a string do programa real.

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

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

produz:

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

Meta comentário: R é relativamente ruim no código de golfe, pois não há atalho para function...