[Question]
  [
# Problem
Create a function that can determine whether or not an arbitrary DNA string is a Watson-Crick palindrome. The function will take a DNA string and output a true value if the string is a Watson-Crick palindrome and a false value if it is not. (True and False can also be represented as 1 and 0, respectively.)
The DNA string may either be in all uppercase or all lowercase depending on your preference.
Also, the DNA string will not be empty.
# Explanation
A DNA string is a Watson-Crick palindrome when the complement of its reverse is equal to itself.
Given a DNA string, first reverse it, and then complement each character according to the DNA bases (A ↔ T and C ↔ G). If the original string is equal to the complemented-reverse string, it is a Watson-Crick palindrome.
For more, see this [question](https://codegolf.stackexchange.com/questions/42184/longest-reverse-palindromic-dna-substring). It is a different challenge where you must find the longest substring of a DNA string where that substring is a Watson-Crick palindrome.
# Goal
This is code-golf and the shortest code wins.
# Test Cases
The format is `<input> = <output>`.
```
ATCGCGAT = true
AGT = false
GTGACGTCAC = true
GCAGTGA = false
GCGC = true
AACTGCGTTTAC = false
ACTG = false
```
  
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), ~~10~~ 7 bytes
### Code:
```
Â'š×Â‡Q
```
### Explanation:
To check if a string is a palindrome, we just need to check the input with the input, with `at` swapped and `cg` swapped and then reverse it. So that is what we are going to do. We push the input and the input reversed using `Â` (bifurcate). Now comes a tricky part. `'š×` is the compressed version for `creating`. If we reverse it, you can see why it's in the code:
```
CreATinG
|  ||  |
GniTAerC
```
This will be used to transliterate the reversed input. Transliteration is done with `‡`. After that, we just check if the input and the transliterated input are e`Q`ual and print that value. So this is how the stack looks like for input `actg` :
```
Â          # ["actg", "gtca"]
 'š×       # ["actg", "gtca", "creating"]
    Â      # ["actg", "gtca", "creating", "gnitaerc"]
     ‡     # ["actg", "cagt"]
      Q    # [0]
```
Which can also be seen with the debug flag ([Try it here](http://05ab1e.tryitonline.net/#code=w4InxaHDl8OC4oChUQ&input=Z3RnYWNndGNhYw&args=LWQ)).
Uses **CP-1252** encoding. [Try it online!](http://05ab1e.tryitonline.net/#code=w4InxaHDl8OC4oChUQ&input=Z3RnYWNndGNhYw).
[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly), 9 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
O%8µ+U5ḍP
```
[Try it online!](http://jelly.tryitonline.net/#code=TyU4wrUrVTXhuI1Q&input=&args=QVRDR0NHQVQ) or [verify all test cases](http://jelly.tryitonline.net/#code=TyU4wrUrVTXhuI1QCsOH4oKs&input=&args=J0FUQ0dDR0FUJywgJ0FHVCcsICdHVEdBQ0dUQ0FDJywgJ0dDQUdUR0EnLCAnR0NHQycsICdBQUNUR0NHVFRUQUMnLCAnQUNURyc).
### How it works
```
O%8µ+U5ḍP  Main link. Argument: S (string)
O          Compute the code points of all characters.
 %8        Compute the residues of division by 8.
           This maps 'ACGT' to [1, 3, 7, 4].
   µ       Begin a new, monadic link. Argument: A (array of residues)
    +U     Add A and A reversed.
      5ḍ   Test the sums for divisibility by 5.
           Of the sums of all pairs of integers in [1, 3, 7, 4], only 1 + 4 = 5
           and 3 + 7 = 10 are divisible by 5, thus identifying the proper pairings.
        P  Take the product of the resulting Booleans.
```
[Answer]
# Python 2, 56 45 44 bytes
```
lambda s:s==s[::-1].translate("_T_GA__C"*32)
```
[Answer]
# Perl, 27 bytes
Includes +2 for `-lp`
Give input on STDIN, prints 1 or nothing:
```
dnapalin.pl <<< ATCGCGAT
```
`dnapalin.pl`:
```
#!/usr/bin/perl -lp
$_=y/ATCG/TAGC/r=~reverse
```
Replace `$_=` by `$_+=` to get `0` instead of empty for the false case
[Answer]
## [Retina](https://github.com/mbuettner/retina), ~~34~~ 33 bytes
```
$
;$_
T`ACGT`Ro`;.+
+`(.);\1
;
^;
```
[Try it online!](http://retina.tryitonline.net/#code=JShHYAokCjskXwpUYEFDR1RgUm9gOy4rCitgKC4pO1wxCjsKXjs&input=R0NHQwpBVENHQ0dBVApHVEdBQ0dUQ0FDCkFHVApHQ0FHVEdBCkFDVEcKQUFDVEdDR1RUVEFD) (Slightly modified to run all test cases at once.)
### Explanation
```
$
;$_
```
Duplicate the input by matching the end of the string and inserting a `;` followed by the entire input.
```
T`ACGT`Ro`;.+
```
Match only the second half of the input with `;.+` and perform the substitution of pairs with a transliteration. As for the target set `Ro`: `o` references the *other* set, that is `o` is replaced with `ACGT`. But `R` reverses this set, so the two sets are actually:
```
ACGT
TGCA
```
If the input is a DNA palindrome, we will now have the input followed by its reverse (separated by `;`).
```
+`(.);\1
;
```
Repeatedly (`+`) remove a pair of identical characters around the `;`. This will either continue until only the `;` is left or until the two characters around the `;` are no longer identical, which would mean that the strings aren't the reverse of each other.
```
^;
```
Check whether the first character is `;` and print `0` or `1` accordingly.
[Answer]
# Pyth - 10 bytes
```
qQ_XQ"ACGT
```
[Try it online here](http://pyth.herokuapp.com/?code=qQ_XQ%22ACGT&test_suite=1&test_suite_input=%22ATCGCGAT%22%0A%22AGT%22%0A%22GTGACGTCAC%22%0A%22GCAGTGA%22%0A%22GCGC%22%0A%22AACTGCGTTTAC%22&debug=1).
A 9 byte version: [Try it online here](http://pyth.herokuapp.com/?code=q_XQ%22ACGT&test_suite=1&test_suite_input=%22ATCGCGAT%22%0A%22AGT%22%0A%22GTGACGTCAC%22%0A%22GCAGTGA%22%0A%22GCGC%22%0A%22AACTGCGTTTAC%22&debug=1).
[Answer]
## JavaScript (ES6), 59 bytes
```
f=s=>!s||/^(A.*T|C.*G|G.*C|T.*A)$/.test(s)&f(s.slice(1,-1))
```
Best I could do without using Regexp was 62 bytes:
```
f=s=>!s||parseInt(s[0]+s.slice(-1),33)%32%7<1&f(s.slice(1,-1))
```
[Answer]
# Ruby, 35
I tried other ways, but the obvious way was the shortest:
```
->s{s.tr('ACGT','TGCA').reverse==s}
```
**in test program**
```
f=->s{s.tr('ACGT','TGCA').reverse==s}
puts f['ATCGCGAT']
puts f['AGT']
puts f['GTGACGTCAC']
puts f['GCAGTGA']
puts f['GCGC']
puts f['AACTGCGTTTAC'] 
```
[Answer]
## Haskell, ~~48~~ 45 bytes
```
(==)=<<reverse.map((cycle"TCG_A"!!).fromEnum)
```
Usage example: `(==)=<<reverse.map((cycle"_T_GA__C"!!).fromEnum) $ "ATCGCGAT"`-> `True`.
A non-pointfree version is
```
f x = reverse (map h x) == x           -- map h to x, reverse and compare to x
h c = cycle "TCG_A" !! fromEnum c      -- take the ascii-value of c and take the
                                       -- char at this position of string
                                       -- "TCG_ATCG_ATCG_ATCG_A..."
```
Edit: @Mathias Dolidon saved 3 bytes. Thanks!
[Answer]
# Retina, 52 bytes
```
^G(.*)C$
$1
^A(.*)T$
$1
^T(.*)A$
$1
}`^C(.*)G$
$1
^$
```
[Answer]
# Julia, ~~47~~ 38 bytes
```
s->((x=map(Int,s)%8)+reverse(x))%5⊆0
```
This is an anonymous function that accepts a `Char` array and returns a boolean. To call it, assign it to a variable.
This uses Dennis' algorithm, which is shorter than the naïve solution. We get the remainder of each code point divided by 8, add that to itself reversed, get the remainders from division by 5, and check whether all are 0. The last step is accomplished using `⊆`, the infix version of `issubset`, which casts both arguments to `Set` before checking. This means that `[0,0,0]` is declared a subset of `0`, since `Set([0,0,0]) == Set(0)`. This is shorter than an explicit check against 0.
[Try it online!](http://julia.tryitonline.net/#code=Zj1zLT4oKHg9bWFwKEludCxzKSU4KStyZXZlcnNlKHgpKSU14oqGMAoKZm9yIHRlc3QgaW4gKCJBVENHQ0dBVCIsICJBR1QiLCAiR1RHQUNHVENBQyIsICJHQ0FHVEdBIiwgIkdDR0MiLCAiQUFDVEdDR1RUVEFDIikKICAgIHByaW50bG4oZihbdGVzdC4uLl0pKQplbmQ&input=)
Saved 9 bytes thanks to Dennis!
[Answer]
# Bash + coreutils, ~~43~~ 32 bytes
```
[ `tr ATCG TAGC<<<$1|rev` = $1 ]
```
### Tests:
```
for i in ATCGCGAT AGT GTGACGTCAC GCAGTGA GCGC AACTGCGTTTAC; do ./78410.sh $i && echo $i = true || echo $i = false; done
ATCGCGAT = true
AGT = false
GTGACGTCAC = true
GCAGTGA = false
GCGC = true
AACTGCGTTTAC = false
```
[Answer]
# Jolf, 15 Bytes
[Try it!](http://conorobrien-foxx.github.io/Jolf/#code=PX5BX2nOsyJBR0NUIl_Os2k)
```
=~A_iγ"AGCT"_γi
```
Explanation:
```
   _i            Reverse the input
 ~A_iγ"AGCT"_γ   DNA swap the reversed input
=~A_iγ"AGCT"_γi  Check if the new string is the same as the original input
```
[Answer]
# Jolf, 16 bytes
[Try it here!](http://conorobrien-foxx.github.io/Jolf/#code=cGUraX5Bac6zIkdBVEMiX86z)
```
pe+i~Aiγ"GATC"_γ
```
## Explanation
```
pe+i~Aiγ"GATC"_γ
    ~Aiγ"GATC"_γ  perform DNA transformation
  +i              i + (^)
pe                is a palindrome
```
[Answer]
## Actually, 19 bytes
```
O`8@%`M;RZ`5@Σ%Y`Mπ
```
This uses [Dennis's algorithm](https://codegolf.stackexchange.com/a/78413/45941).
[Try it online!](http://actually.tryitonline.net/#code=T2A4QCVgTTtSWmA1QM6jJVlgTc-A&input=J0FUQ0dDR0FUJw)
Explanation:
```
O`8@%`M;RZ`5@Σ%Y`Mπ
O                    push an array containing the Unicode code points of the input
 `8@%`M              modulo each code point by 8
       ;RZ           zip with reverse
          `5@Σ%Y`M   test sum for divisibility by 5
                  π  product
```
[Answer]
# Oracle SQL 11.2, 68 bytes
```
SELECT DECODE(TRANSLATE(REVERSE(:1),'ATCG','TAGC'),:1,1,0)FROM DUAL; 
```
[Answer]
# R, 101 bytes
```
g=function(x){y=unlist(strsplit(x,""));all(sapply(rev(y),switch,"C"="G","G"="C","A"="T","T"="A")==y)}
```
### Test Cases
```
g("ATCGCGAT")
[1] TRUE
g("AGT")
[1] FALSE
g("GTGACGTCAC")
[1] TRUE
g("GCAGTGA")
[1] FALSE
g("GCGC")
[1] TRUE
g("AACTGCGTTTAC")
[1] FALSE
g("ACTG")
[1] FALSE
```
[Answer]
# Julia 0.4, 22 bytes
```
s->s$reverse(s)⊆""
```
The string contains the control characters EOT (4) and NAK (21). Input must be in form of a character array.
This approach XORs the characters of the input with the corresponding characters in the reversed input. For valid pairings, this results in the characters EOT or NAK. Testing for inclusion in the string of those characters produces the desired Boolean.
[Try it online!](http://julia.tryitonline.net/#code=ZiA9IHMtPnMkcmV2ZXJzZShzKeKKhiIEFSIKCmZvciBzIGluICgiQVRDR0NHQVQiLCAiQUdUIiwgIkdUR0FDR1RDQUMiLCAiR0NBR1RHQSIsICJHQ0dDIiwgIkFBQ1RHQ0dUVFRBQyIsICJBQ1RHIikKICAgIHByaW50bG4oZihbcy4uLl0pKQplbmQ&input=)
[Answer]
# C,71
```
r,e;f(char*s){for(r=0,e=strlen(s)+1;*s;s++)r|=*s*s[e-=2]%5^2;return!r;}
```
2 bytes saved by Dennis. Additional 2 bytes saved by adapting for lowercase input: constants `37` and `21` are revised to `5` and `2`.
# C,75
```
i,j;f(char*s){for(i=j=0;s[i];i++)j|=s[i]*s[strlen(s)-i-1]%37!=21;return!j;}
```
Saved one byte: Eliminated parenthesis by taking the product of the two ASCII codes mod 37. The valid pairs evaluate to 21. Assumes uppercase input.
# C,76
```
i,j;f(char*s){for(i=j=0;s[i];i++)j|=(s[i]+s[strlen(s)-i-1])%11!=6;return!j;}
```
Uses the fact that ASCII codes of the valid pairs sum to 138 or 149. When taken mod 11, these are the only pairs that sum to 6. Assumes uppercase input.
**ungolfed in test program**
```
i,j;
f(char *s){
   for(i=j=0;s[i];i++)                  //initialize i and j to 0; iterate i through the string
     j|=(s[i]+s[strlen(s)-i-1])%11!=6;  //add characters at i from each end of string, take result mod 11. If not 6, set j to 1
return!j;}                              //return not j (true if mismatch NOT detected.)
main(){
  printf("%d\n", f("ATCGCGAT"));
  printf("%d\n", f("AGT"));
  printf("%d\n", f("GTGACGTCAC"));
  printf("%d\n", f("GCAGTGA"));
  printf("%d\n", f("GCGC"));
  printf("%d\n", f("AACTGCGTTTAC"));
} 
```
[Answer]
# [Factor](http://factorcode.org), 72 bytes
Unfortunately regex can't help me here.
```
[ dup reverse [ { { 67 71 } { 65 84 } { 71 67 } { 84 65 } } at ] map = ]
```
Reverse, lookup table, compare equal.
[Answer]
# J - 21 bytes
```
0=[:+/5|[:(+|.)8|3&u:
```
Based on Dennis' method
## Usage
```
   f =: 0=[:+/5|[:(+|.)8|3&u:
   f 'ATCGCGAT'
1
   f 'AGT'
0
   f 'GTGACGTCAC'
1
   f 'GCAGTGA'
0
   f 'GCGC'
1
   f 'AACTGCGTTTAC'
0
   f 'ACTG'
0
```
## Explanation
```
0=[:+/5|[:(+|.)8|3&u:
                 3&u:    - Convert from char to int
               8|        - Residues from division by 8 for each
            |.           - Reverse the list
           +             - Add from the list and its reverse element-wise
        [:               - Cap, compose function
      5|                 - Residues from division by 5 for each
    +/                   - Fold right using addition to create a sum
  [:                     - Cap, compose function
0=                       - Test the sum for equality to zero
```
[Answer]
## [Labyrinth](https://github.com/mbuettner/labyrinth), 42 bytes
```
_8
,%
;
"}{{+_5
"=    %_!
 = """{
 ;"{" )!
```
Terminates with a division-by-zero error (error message on STDERR).
[Try it online!](http://labyrinth.tryitonline.net/#code=XzgKLCUKOwoifXt7K181CiI9ICAgICVfIQogPSAiIiJ7CiA7InsiICkh&input=R1RHQUNHVENBQw)
The layout feels really inefficient but I'm just not seeing a way to golf it right now.
### Explanation
This solution is based on Dennis's arithmetic trick: take all character codes modulo `8`, add a pair from both ends and make sure it's divisible by `5`.
Labyrinth primer:
* Labyrinth has two stacks of arbitrary-precision integers, *main* and *aux*(iliary), which are initially filled with an (implicit) infinite amount of zeros.
* The source code resembles a maze, where the instruction pointer (IP) follows corridors when it can (even around corners). The code starts at the first valid character in reading order, i.e. in the top left corner in this case. When the IP comes to any form of junction (i.e. several adjacent cells in addition to the one it came from), it will pick a direction based on the top of the main stack. The basic rules are: turn left when negative, keep going ahead when zero, turn right when positive. And when one of these is not possible because there's a wall, then the IP will take the opposite direction. The IP also turns around when hitting dead ends.
* Digits are processed by multiplying the top of the main stack by 10 and then adding the digit.
The code starts with a small 2x2, clockwise loop, which reads all input modulo 8:
```
_   Push a 0.
8   Turn into 8.
%   Modulo. The last three commands do nothing on the first iteration
    and will take the last character code modulo 8 on further iterations.
,   Read a character from STDIN or -1 at EOF. At EOF we will leave loop.
```
Now `;` discards the `-1`. We enter another clockwise loop which moves the top of the main stack (i.e. the last character) down to the bottom:
```
"   No-op, does nothing.
}   Move top of the stack over to aux. If it was at the bottom of the stack
    this will expose a zero underneath and we leave the loop.
=   Swap top of main with top of aux. The effect of the last two commands
    together is to move the second-to-top stack element from main to aux.
"   No-op.
```
Now there's a short linear bit:
```
{{  Pull two characters from aux to main, i.e. the first and last (remaining)
    characters of the input (mod 8).
+   Add them.
_5  Push 5.
%   Modulo.
```
The IP is now at a junction which acts as a branch to test divisibility by 5. If the result of the modulo is non-zero, we know that the input is not a Watson-Crick palindrome and we turn east:
```
_   Push 0.
!   Print it. The IP hits a dead end and turns around.
_   Push 0.
%   Try to take modulo, but division by zero fails and the program terminates.
```
Otherwise, we need to keep checking the rest of the input, so the IP keeps going south. The `{` pulls over the bottom of the remaining input. If we've exhausted the input, then this will be a `0` (from the bottom of *aux*), and the IP continues moving south:
```
)   Increment 0 to 1.
!   Print it. The IP hits a dead end and turns around.
)   Increment 0 to 1.
{   Pull a zero over from aux, IP keeps moving north.
%   Try to take modulo, but division by zero fails and the program terminates.
```
Otherwise, there are more characters in the string to be checked. The IP turns west and moves into the next (clockwise) 2x2 loop which consists largely of no-ops:
```
"   No-op.
"   No-op.
{   Pull one value over from aux. If it's the bottom of aux, this will be
    zero and the IP will leave the loop eastward.
"   No-op.
```
After this loop, we've got the input on the main stack again, except for its first and last character and with a zero on top. The `;` discards the `0` and then `=` swaps the tops of the stacks, but this is just to cancel the first `=` in the loop, because we're now entering the loop in a different location. Rinse and repeat.
[Answer]
# sed, ~~67~~ 61 bytes
```
G;H;:1;s/\(.\)\(.*\n\)/\2\1/;t1;y/ACGT/TGCA/;G;s/^\(.*\)\1$/1/;t;c0
```
(67 bytes)
### Test
```
for line in ATCGCGAT AGT GTGACGTCAC GCAGTGA GCGC AACTGCGTTTAC ACTG
do echo -n "$line "
    sed 'G;H;:1;s/\(.\)\(.*\n\)/\2\1/;t1;y/ACGT/TGCA/;G;s/^\(.*\)\1$/1/;t;c0' <<<"$line"
done
```
### Output
```
ATCGCGAT 1
AGT 0
GTGACGTCAC 1
GCAGTGA 0
GCGC 1
AACTGCGTTTAC 0
ACTG 0
```
---
By using extended regular expressions, the byte count can be reduced to 61.
```
sed -r 'G;H;:1;s/(.)(.*\n)/\2\1/;t1;y/ACGT/TGCA/;G;s/^(.*)\1$/1/;t;c0'
```
[Answer]
# C#, 65 bytes
```
bool F(string s)=>s.SequenceEqual(s.Reverse().Select(x=>"GACT"[("GACT".IndexOf(x)+2)%4]));
```
.NET has some fairly long framework method names at times, which doesn't necessarily make for the best code golf framework. In this case, framework method names make up 33 characters out of 90. :)
Based on the modulus trick from elsewhere in the thread:
```
bool F(string s)=>s.Zip(s.Reverse(),(a,b)=>a%8+b%8).All(x=>x%5==0);
```
Now weighs in at 67 characters whereof 13 are method names.
Another minor optimization to shave off a whopping 2 characters:
```
bool F(string s)=>s.Zip(s.Reverse(),(a,b)=>(a%8+b%8)%5).Sum()<1;
```
So, 65 of which 13 are framework names.
Edit:
Omitting some of the limited "boilerplate" from the solution and adding a couple of conditions leaves us with the expression
```
s.Zip(s.Reverse(),(a,b)=>(a%8+b%8)%5).Sum()
```
Which gives 0 if and only if the string s is a valid answer.
As cat points out, "bool F(string s)=>" is actually replacable with "s=>" *if* it's otherwise clear in the code that the expression is a `Func<string,bool>`, ie. maps a string to a boolean.
[Answer]
**REXX** 37
```
s='ATCGCGAT';say s=translate(reverse(s),'ATCG','TAGC')
```
[Answer]
# Octave, 52 bytes
```
f=@(s) prod(mod((i=mod(toascii(s),8))+flip(i),5)==0)
```
Following Denis's trick ... take the ASCII values mod 8, flip and add together; if every sum is a multiple of five, you're golden.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), ~~17~~ ~~11~~ ~~10~~ 8 bytes
```
Ṙ«Wṁ«ḂĿ=
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyJBIiwiIiwi4bmYwqtX4bmBwqvhuILEvz0iLCIiLCJhdGNnY2dhdFxuYWd0XG5hYWN0Z2NndHR0YWMiXQ=)
### Explained
```
Ṙ«Wṁ«ḂĿ=
Ṙ        # Input reverse
 «Wṁ«ḂĿ  # Changes DNA and translate with string compression
       = # If original input is equal to the result output 1/0
```
[Answer]
# Clojure/ClojureScript, 49 chars
```
#(=(list* %)(map(zipmap"ATCG""TAGC")(reverse %)))
```
Works on strings. If the requirements are loosened to allow lists, I can take off the `(list* )` and save 7 chars.
[Answer]
# R, 70 bytes
```
f=function(x)all(chartr("GCTA","CGAT",y<-strsplit(x,"")[[1]])==rev(y))
```
Usage:
```
> f=function(x)all(chartr("GCTA","CGAT",y<-strsplit(x,"")[[1]])==rev(y))
> f("GTGACGTCAC")
[1] TRUE
> f("AACTGCGTTTAC")
[1] FALSE
> f("AGT")
[1] FALSE
> f("ATCGCGAT")
[1] TRUE
```
[Answer]
# C, 71 bytes
Requires ASCII codes for the relevant characters, but accepts uppercase, lowercase or mixed-case input.
```
f(char*s){char*p=s+strlen(s),b=0;for(;*s;b&=6)b|=*--p^*s++^4;return!b;}
```
This code maintains two pointers, `s` and `p`, traversing the string in opposite directions. At each step, we compare the corresponding characters, setting `b` true if they don't match. The matching is based on XOR of the character values:
```
'A' ^ 'T' = 10101
'C' ^ 'G' = 00100
'C' ^ 'T' = 10111
'G' ^ 'A' = 00110
'A' ^ 'C' = 00010
'T' ^ 'G' = 10011
 x  ^  x  = 00000
```
We can see in the above table that we want to record success for `xx10x` and failure for anything else, so we XOR with `00100` (four) and mask with `00110` (six) to get zero for `AT` or `CG` and non-zero otherwise. Finally, we return true if all the pairs accumulated a zero result in `b`, false otherwise.
## Test program:
```
#include <stdio.h>
int main(int argc, char **argv)
{
    while (*++argv)
        printf("%s = %s\n", *argv, f(*argv)?"true":"false");
}
```
]