Hai il compito di scrivere due programmi. Il programma A non deve stampare nulla su tutti gli ingressi tranne quando è inserito il programma B , nel qual caso dovrebbe stampare 1. Il programma B deve essere stampato 1su tutti gli ingressi tranne quando è inserito il programma A , nel qual caso non dovrebbe stampare nulla.

punteggio:

• +1 per ogni personaggio di entrambi i programmi.
• Il punteggio più basso vince.

GTB , 25

Eseguito da una calcolatrice TI-84

Programma A

`_@_eq;"$w;&

Programma B

`_@_eq;"$#w;&

Spiegazione

`_ Inserisci una stringa

@_eq;"Controlla se è uguale al codice sorgente ( #viene automaticamente rimosso insieme alle lettere minuscole)

$w;&In tal caso, visualizzare 1 (altrimenti niente) [perché Bè $#w;&- in caso contrario, visualizzare 1 (altrimenti niente)]

Bash - 32 caratteri

Script A - 16 caratteri

cmp -s b&&echo 1

Script B - 16 caratteri

cmp -s a||echo 1

uso

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

Ruby, 54

UN

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

B

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

esempi:

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)

Dal momento che non l'hai proibito ...

Memorizza i programmi come Ae Brispettivamente.

Programma A (30):

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

Programma B (32):

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

Come funziona (il programma B, A è simile):

• 1!:1[3: leggi stdin
• 1!:1<'A': leggi il file A
• -:: vedi se sono uguali
• -.: annulla il risultato
• #~: replicare il risultato da solo (quindi, 1risulta in uno 1e 0risulta in zero 0s, cioè niente)
• echo: produzione
• exit: exit (l'interprete J non esce di default quando raggiunge la fine del file)

$ jconsole A <B
1
$ jconsole A <pippo
$ jconsole B <A
$ jconsole B <pippo
1
$

Haskell - SENZA fonte di caricamento - 478 644 caratteri

Questo presuppone che getContents finisca SEMPRE con una nuova riga e quindi abbandoni il personaggio finale senza controllarlo perché non ho voglia di sfuggirlo

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

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

Funziona come un normale quine, ma scambiando - per * per ottenere l'altro programma (evitando quei caratteri altrove).

Il seguente test viene stampato come previsto (sostituendo main = interact $ con a = e 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

File A (letteralmente chiamato solo a):

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

File B (letteralmente chiamato solo b):

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

Rubino, 166 caratteri, nessuna fonte di lettura

UN:

(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

Assicurati che il tuo editor di testo non salvi con una nuova riga finale.

Utilizzo (esempio):

 $ 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

Ogni programma costruisce l'origine dell'altro programma usando un HEREdoc e trasforma le stringhe, quindi confronta il risultato con l'input.

Haskell - 138

Non è proprio una buona risposta, ma voleva che entrambi i programmi utilizzassero la stessa fonte. Potrebbe salvare alcuni caratteri rinominando il file, ma non renderà questa soluzione vincente, quindi non credo ne 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)}

Compila questa fonte come entrambi Ae B.

Test:

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

Script |(altrimenti noto come Script A) - 80 caratteri

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

Script &(altrimenti noto come Script B) - 62 caratteri

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 \&

Descrizione

Lo script B legge il contenuto dello script A e lo elimina dopo aver scambiato i nomi dei file e l' andoperatore in un or.

Ho chiamato i file &e |quindi posso eseguire una singola sostituzione nello script B.

Python 3 - 102 caratteri

Stampa 1 se l'ingresso è uguale al programma 2, altrimenti nulla:

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

Stampa 1 se l'ingresso non è uguale al programma 1, altrimenti nulla:

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

bash / grep - 59 caratteri

51 caratteri se contiamo solo la stringa di programma effettiva.

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

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 commento: R fa fiere relativamente cattive sul code golf in quanto non esiste un collegamento a function...