Twoim zadaniem jest napisanie dwóch programów. Program A nie może drukować niczego na wszystkich wejściach, z wyjątkiem sytuacji, gdy wprowadzony jest program B , w którym to przypadku powinien wydrukować 1. Program B musi drukować 1na wszystkich wejściach, z wyjątkiem sytuacji, gdy wprowadzony jest program A , w którym to przypadku nie powinien nic drukować.

Punktacja:

• +1 za każdą postać z obu programów.
• Najniższy wynik wygrywa.

GTB , 25

Wykonane z kalkulatora TI-84

Program A

`_@_eq;"$w;&

Program B

`_@_eq;"$#w;&

Wyjaśnienie

`_ Wpisz ciąg

@_eq;"Sprawdź, czy jest on równy kodowi źródłowemu ( #jest automatycznie usuwany wraz z małymi literami)

$w;&Jeśli tak, wyświetl 1 (w przeciwnym razie nic) [ Bponieważ $#w;&- jeśli nie, wyświetl 1 (w przeciwnym razie nic)]

Bash - 32 znaki

Skrypt A - 16 znaków

cmp -s b&&echo 1

Skrypt B - 16 znaków

cmp -s a||echo 1

Stosowanie

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

Ruby, 54

ZA

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

b

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

przykłady:

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)

Ponieważ nie zabroniłeś tego ...

Zapisz programy jako AiB odpowiednio odpowiednio.

Program A (30):

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

Program B (32):

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

Jak to działa (program B, A jest podobny):

• 1!:1[3: przeczytaj standardowe
• 1!:1<'A': przeczytaj plik A
• -:: sprawdź, czy są równe
• -.: zaneguj wynik
• #~: sam powiel wynik (więc 1daje jeden 1i 0daje zero 0s, tzn. nic)
• echo: wynik
• exit: exit (interpreter J nie kończy domyślnie po osiągnięciu końca pliku)

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

Haskell - BEZ źródła ładowania - 478 644 znaków

Zakłada się, że getContents ZAWSZE kończy się nową linią, więc upuszcza końcową postać bez sprawdzania, ponieważ nie mam ochoty jej uciekać

ZA

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

Działa jak standardowy quine, ale zamienia - na *, aby uzyskać inny program (unikając znaków gdzie indziej).

Następujące testy są drukowane zgodnie z oczekiwaniami (zamieniając main = interact $ na a = ib =)

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

Plik A (dosłownie nazwany po prostu a):

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

Plik B (dosłownie nazwany po prostu b):

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

Ruby, 166 znaków, brak źródła czytania

ZA:

(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

Upewnij się, że twój edytor tekstu nie oszczędza z końcowym znakiem nowej linii.

Zastosowanie (przykład):

 $ 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

Każdy program konstruuje źródło drugiego programu za pomocą HEREdoc i przekształca ciąg znaków, a następnie porównuje wynik z danymi wejściowymi.

Haskell - 138

Niezbyt dobra odpowiedź, ale chciałem, aby oba programy korzystały z tego samego źródła. Można zapisać niektóre znaki, zmieniając nazwę pliku, ale to nie sprawi, że będzie to zwycięskie rozwiązanie, więc nie sądzę, żeby było warto.

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

Skompiluj to źródło zarówno jako, jak Ai 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 znaki

Skrypt |(znany również jako Skrypt A) - 80 znaków

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

Skrypt &(znany również jako Skrypt B) - 62 znaki

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

Stosowanie

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

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

Opis

Skrypt B odczytuje zawartość skryptu A i analizuje go po zamianie nazw plików i andoperatora na or.

Nazwałam pliki &i |tak mogę wykonać pojedynczy zastąpić w skrypcie B.

Python 3-102 znaków

Wyświetla 1, jeśli dane wejściowe są takie same jak program 2, w przeciwnym razie nic:

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

Wyświetla 1, jeśli dane wejściowe nie są takie same jak program 1, w przeciwnym razie nic:

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

bash / grep - 59 znaków

51 znaków, jeśli policzymy tylko rzeczywisty ciąg programu.

$ 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 znaków)

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

produkuje:

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

Meta komentarz: R targi stosunkowo słabo kodują, ponieważ nie ma skrótu do function...