Vous êtes chargé d'écrire deux programmes. Le programme A ne doit rien imprimer sur toutes les entrées, sauf lorsque le programme B est entré, auquel cas il doit imprimer 1. Le programme B doit imprimer 1sur toutes les entrées, sauf lorsque le programme A est entré, auquel cas il ne doit rien imprimer.

Notation:

• +1 Pour chaque personnage des deux programmes.
• Le score le plus bas l'emporte.

GTB , 25

Exécuté à partir d'une calculatrice TI-84

Programme A

`_@_eq;"$w;&

Programme B

`_@_eq;"$#w;&

Explication

`_ Entrez une chaîne

@_eq;"Vérifiez s'il est égal au code source ( #est automatiquement supprimé avec les lettres minuscules)

$w;&Si oui, affichez 1 (sinon rien) [car Bc'est $#w;&- sinon, affichez 1 (sinon rien)]

Bash - 32 caractères

Script A - 16 caractères

cmp -s b&&echo 1

Script B - 16 caractères

cmp -s a||echo 1

Usage

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

Rubis, 54

UNE

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

B

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

exemples:

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)

Puisque vous ne l'avez pas interdit ...

Stockez les programmes comme Aet Brespectivement.

Programme A (30):

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

Programme B (32):

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

Comment cela fonctionne (le programme B, A est similaire):

• 1!:1[3: lire stdin
• 1!:1<'A': lire le fichier A
• -:: voir s'ils sont égaux
• -.: annuler le résultat
• #~: réplique le résultat par lui-même (donc, 1résulte en un 1et 0résulte en zéro 0s, c'est-à-dire rien)
• echo: production
• exit: exit (l'interpréteur J ne quitte pas par défaut lorsqu'il atteint la fin du fichier)

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

Haskell - SANS source de chargement - 478 644 caractères

Cela suppose que getContents se termine TOUJOURS par une nouvelle ligne et supprime donc le caractère final sans vérification car je n'ai pas envie de lui échapper

UNE

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

Cela fonctionne comme un quine standard, mais en échangeant - pour * pour obtenir l'autre programme (en évitant ces caractères ailleurs).

Le test suivant s'imprime comme prévu (en remplaçant main = interact $ par a = et 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

Fichier A (littéralement nommé juste a):

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

Fichier B (littéralement nommé juste b):

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

Ruby, 166 caractères, pas de source de lecture

UNE:

(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

Assurez-vous que votre éditeur de texte n'enregistre pas avec une nouvelle ligne de fin.

Utilisation (exemple):

 $ 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

Chaque programme construit la source de l'autre programme à l'aide d'un HEREdoc et de transformations de chaîne, puis compare le résultat à l'entrée.

Haskell - 138

Pas vraiment une bonne réponse, mais je voulais que les deux programmes utilisent la même source. Pourrait enregistrer certains caractères en renommant le fichier, mais cela ne va pas en faire une solution gagnante, donc je ne pense pas que cela en vaille la peine.

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

Compilez cette source en tant que Aet B.

Tester:

% 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 caractères

Script |(autrement appelé Script A) - 80 caractères

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

Script &(également appelé Script B) - 62 caractères

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

Usage

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

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

La description

Le script B lit le contenu du script A et l'évalue après avoir échangé les noms de fichier et l' andopérateur vers un or.

J'ai nommé les fichiers &et |je peux donc effectuer un seul remplacement dans le script B.

Python 3 - 102 caractères

Imprime 1 si l'entrée est identique au programme 2, sinon rien:

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

Imprime 1 si l'entrée n'est pas identique au programme 1, sinon rien:

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

bash / grep - 59 caractères

51 caractères si l'on ne compte que la chaîne de programme réelle.

$ 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 caractères)

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

produit:

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

Meta comment: R est relativement mauvais sur le golf de code car il n'y a pas de raccourci vers function...