Tienes la tarea de escribir dos programas. El programa A no debe imprimir nada en todas las entradas, excepto cuando se ingresa el programa B , en cuyo caso debe imprimir 1. El programa B debe imprimir 1en todas las entradas, excepto cuando se ingresa el programa A , en cuyo caso no debe imprimir nada.

Puntuación:

• +1 para cada personaje de ambos programas.
• La puntuación más baja gana.

GTB , 25

Ejecutado desde una calculadora TI-84

Programa A

`_@_eq;"$w;&

Programa B

`_@_eq;"$#w;&

Explicación

`_ Ingrese una cadena

@_eq;"Compruebe si es igual al código fuente ( #se elimina automáticamente junto con letras minúsculas)

$w;&Si es así, muestre 1 (de lo contrario, nada) [porque Bes, $#w;&si no, muestre 1 (de lo contrario, nada)]

Bash - 32 caracteres

Guión A - 16 caracteres

cmp -s b&&echo 1

Guión B - 16 caracteres

cmp -s a||echo 1

Uso

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

Rubí, 54

UN

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

si

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

ejemplos:

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)

Como no prohibiste esto ...

Almacene los programas como Ay Brespectivamente.

Programa A (30):

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

Programa B (32):

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

Cómo funciona (el programa B, A es similar):

• 1!:1[3: leer stdin
• 1!:1<'A': leer archivo A
• -:: ver si son iguales
• -.: negar el resultado
• #~: replica el resultado por sí mismo (por lo tanto, 1da como resultado uno 1y 0da como resultado cero 0s, es decir, nada)
• echo: salida
• exit: salir (el intérprete J no sale por defecto cuando llega al final del archivo)

$ jconsola A <B
1
$ jconsole A <foo
$ jconsola B <A
$ jconsole B <foo
1
PS

Haskell - SIN fuente de carga - 478 644 caracteres

Esto supone que getContents SIEMPRE termina con una nueva línea y, por lo tanto, suelta el carácter final sin verificarlo porque no tengo ganas de escapar.

UN

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

si

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 un quine estándar, pero intercambiando * por * para obtener el otro programa (evitando esos caracteres en otra parte).

La siguiente prueba se imprime como se esperaba (reemplazando main = interact $ con a = y b =)

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

Archivo A (literalmente llamado solo a):

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

Archivo B (literalmente llamado solo b):

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

Ruby, 166 caracteres, sin fuente de lectura

UN:

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

SI:

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

Asegúrese de que su editor de texto no se guarde con una nueva línea final.

Uso (ejemplo):

 $ 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 construye la fuente del otro programa usando un HEREdoc y transforma cadenas, luego compara el resultado con la entrada.

Haskell - 138

Realmente no es una buena respuesta, pero quería que ambos programas usaran la misma fuente. Podría guardar algunos caracteres cambiando el nombre del archivo, pero no va a hacer de esta una solución ganadora, así que no creo que valga la 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 fuente como ambos Ay B.

Prueba:

% 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 |(también conocido como Script A) - 80 caracteres

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

Script &(también conocido 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 \&

Descripción

El guión B lee el contenido del guión A y lo evalúa después de intercambiar los nombres de archivo y el andoperador a un or.

Puse un nombre a los archivos &y |así puedo realizar un solo reemplazo en el Script B.

Python 3 - 102 caracteres

Imprime 1 si la entrada es la misma que la del programa 2; de lo contrario, nada:

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

Imprime 1 si la entrada no es la misma que la del programa 1; de lo contrario, nada:

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

bash / grep - 59 caracteres

51 caracteres si solo contamos la cadena real del programa.

$ 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

produce:

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

Meta comentario: R es relativamente malo en el golf de código ya que no hay un atajo para function...