Problem

Erstellen Sie eine Funktion, mit der festgestellt werden kann, ob es sich bei einem beliebigen DNA-String um ein Watson-Crick-Palindrom handelt. Die Funktion nimmt einen DNA-String und gibt einen wahren Wert aus, wenn der String ein Watson-Crick-Palindrom ist, und einen falschen Wert, wenn dies nicht der Fall ist. (Wahr und Falsch können auch als 1 bzw. 0 dargestellt werden.)

Die DNA-Zeichenfolge kann je nach Belieben entweder in Groß- oder Kleinbuchstaben angegeben werden.

Auch der DNA-String wird nicht leer sein.

Erläuterung

Eine DNA-Kette ist ein Watson-Crick-Palindrom, wenn das Komplement ihrer Rückseite mit sich selbst übereinstimmt.

Wenn Sie einen DNA-String erhalten, kehren Sie ihn zunächst um und ergänzen Sie dann jedes Zeichen gemäß den DNA-Basen (A ↔ T und C ↔ G). Wenn die ursprüngliche Zeichenfolge der komplementierten umgekehrten Zeichenfolge entspricht, handelt es sich um ein Watson-Crick-Palindrom.

Weitere Informationen finden Sie in dieser Frage . Es ist eine andere Herausforderung, bei der Sie den längsten Teilstring eines DNA-Strings finden müssen, wobei dieser Teilstring ein Watson-Crick-Palindrom ist.

Tor

Dies ist Code-Golf und der kürzeste Code gewinnt.

Testfälle

Das Format ist <input> = <output>.

ATCGCGAT = true
AGT = false
GTGACGTCAC = true
GCAGTGA = false
GCGC = true
AACTGCGTTTAC = false
ACTG = false

05AB1E , 10 7 Bytes

Code:

Â'š×‡Q

Erläuterung:

Um zu überprüfen, ob es sich bei einer Zeichenfolge um ein Palindrom handelt, müssen wir nur die Eingabe mit der Eingabe überprüfen, mit atvertauschen und cgvertauschen und sie dann umkehren. Das werden wir also tun. Wir schieben die Eingabe und die Eingabe mit Â(Bifurkate) umgekehrt . Jetzt kommt ein schwieriger Teil. 'š×ist die komprimierte Version für creating. Wenn wir es umkehren, können Sie sehen, warum es im Code ist:

CreATinG
|  ||  |
GniTAerC

Dies wird zum Transliterieren der umgekehrten Eingabe verwendet. Die Transliteration erfolgt mit ‡. Danach prüfen wir nur, ob die Eingabe und die transliterierte Eingabe Qtatsächlich sind, und geben diesen Wert aus. So sieht der Stack für die Eingabe aus actg:

          # ["actg", "gtca"]
 'š×       # ["actg", "gtca", "creating"]
    Â      # ["actg", "gtca", "creating", "gnitaerc"]
     ‡     # ["actg", "cagt"]
      Q    # [0]

Welches kann auch mit dem Debug-Flag gesehen werden ( Versuchen Sie es hier ).

Verwendet CP-1252- Codierung. Probieren Sie es online! .

Gelee , 9 Bytes

O%8µ+U5ḍP

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

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.

Python 2, 56 45 44 Bytes

lambda s:s==s[::-1].translate("_T_GA__C"*32)

Perl, 27 Bytes

Beinhaltet +2 für -lp

Geben Sie auf STDIN eine Eingabe ein, und geben Sie 1 oder nichts aus:

dnapalin.pl <<< ATCGCGAT

dnapalin.pl:

#!/usr/bin/perl -lp
$_=y/ATCG/TAGC/r=~reverse

Ersetzen Sie $_=durch $_+=, um 0für den falschen Fall leer zu werden

Pyth - 10 Bytes

qQ_XQ"ACGT

Probieren Sie es hier online aus .

Dies wären 9 Bytes nach der Fehlerbehebung, wodurch es nicht konkurriert: Probieren Sie es hier online aus .

Retina , 34 33 Bytes

$
;$_
T`ACGT`Ro`;.+
+`(.);\1
;
^;

Probieren Sie es online!(Leicht modifiziert, um alle Testfälle gleichzeitig auszuführen.)

Erläuterung

$
;$_

Duplizieren Sie die Eingabe, indem Sie das Ende der Zeichenfolge abgleichen und ein ;gefolgt von der gesamten Eingabe einfügen .

T`ACGT`Ro`;.+

Ordnen Sie nur die zweite Hälfte der Eingabe zu ;.+und ersetzen Sie Paare durch eine Transliteration. Bezüglich der Zielmenge Ro: oBezieht sich auf die andere Menge, die odurch ersetzt wird ACGT. Aber Rkehrt diese Menge um, so dass die beiden Mengen tatsächlich sind:

ACGT
TGCA

Wenn es sich bei der Eingabe um ein DNA-Palindrom handelt, folgt auf die Eingabe die Umkehrung (getrennt durch ;).

+`(.);\1
;

+Entfernen Sie wiederholt ( ) ein Paar identischer Zeichen um das ;. Dies wird entweder fortgesetzt, bis nur noch das ;übrig ist oder bis die beiden Zeichen um das ;nicht mehr identisch sind, was bedeutet, dass die Zeichenfolgen nicht umgekehrt sind.

^;

Überprüfen Sie, ob das erste Zeichen ;und drucken 0oder 1entsprechend.

JavaScript (ES6), 59 Byte

f=s=>!s||/^(A.*T|C.*G|G.*C|T.*A)$/.test(s)&f(s.slice(1,-1))

Das Beste, was ich ohne Regexp machen konnte, waren 62 Bytes:

f=s=>!s||parseInt(s[0]+s.slice(-1),33)%32%7<1&f(s.slice(1,-1))

Rubin, 35

Ich habe andere Wege ausprobiert, aber der naheliegende war der kürzeste:

->s{s.tr('ACGT','TGCA').reverse==s}

im Testprogramm

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'] 

Haskell, 48-45 Bytes

(==)=<<reverse.map((cycle"TCG_A"!!).fromEnum)

Anwendungsbeispiel: (==)=<<reverse.map((cycle"_T_GA__C"!!).fromEnum) $ "ATCGCGAT"-> True.

Eine nicht pointfree Version ist

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 sparte 3 Bytes. Vielen Dank!

Netzhaut, 52 Bytes

^G(.*)C$
$1
^A(.*)T$
$1
^T(.*)A$
$1
}`^C(.*)G$
$1
^$

Julia, 47 38 Bytes

s->((x=map(Int,s)%8)+reverse(x))%5⊆0

Dies ist eine anonyme Funktion, die a akzeptiert Char Array und einen Booleschen Wert zurückgibt. Um es aufzurufen, weisen Sie es einer Variablen zu.

Dabei wird der Algorithmus von Dennis verwendet, der kürzer ist als die naive Lösung. Wir erhalten den Rest jedes Codepunkts geteilt durch 8, addieren diesen zu sich selbst umgekehrt, erhalten die Restwerte aus der Division durch 5 und prüfen, ob alle 0 sind. Der letzte Schritt wird mit ⊆der Infix-Version von ausgeführt issubset, die beide Argumente nach wirft Setvor der Prüfung. Dies bedeutet, dass [0,0,0]eine Teilmenge von deklariert wird0 , since wird Set([0,0,0]) == Set(0). Dies ist kürzer als eine explizite Prüfung gegen 0.

Probieren Sie es online!

9 Bytes gespart dank Dennis!

Jolf, 15 Bytes

Versuch es!

=~A_iγ"AGCT"_γi

Erläuterung:

   _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

Jolf, 16 Bytes

Probieren Sie es hier aus!

pe+i~Aiγ"GATC"_γ

Erläuterung

pe+i~Aiγ"GATC"_γ
    ~Aiγ"GATC"_γ  perform DNA transformation
  +i              i + (^)
pe                is a palindrome

Eigentlich 19 Bytes

O`8@%`M;RZ`5@Σ%Y`Mπ

Dies verwendet Dennis 'Algorithmus .

Probieren Sie es online!

Erläuterung:

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

Oracle SQL 11.2, 68 Byte

SELECT DECODE(TRANSLATE(REVERSE(:1),'ATCG','TAGC'),:1,1,0)FROM DUAL; 

Julia 0,4, 22 Bytes

s->s$reverse(s)⊆""

Die Zeichenfolge enthält die Steuerzeichen EOT (4) und NAK (21). Die Eingabe muss in Form eines Zeichenarrays erfolgen.

Dieser Ansatz XORs die Zeichen der Eingabe mit den entsprechenden Zeichen in der umgekehrten Eingabe. Für gültige Paarungen ergeben sich die Zeichen EOT oder NAK. Das Testen auf Aufnahme in die Zeichenfolge dieser Zeichen ergibt den gewünschten Booleschen Wert.

Probieren Sie es online!

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 von Dennis gespeichert. Zusätzliche 2 Bytes werden durch Anpassung für die Eingabe in Kleinbuchstaben gespart: Konstanten 37und 21werden zu 5und überarbeitet 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;}

1 Byte gespeichert: Die Klammer wurde entfernt, indem das Produkt der beiden ASCII-Codes mod 37 verwendet wurde. Die gültigen Paare werden mit 21 bewertet. Es wird die Eingabe in Großbuchstaben vorausgesetzt.

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;}

Verwendet die Tatsache, dass sich die ASCII-Codes der gültigen Paare zu 138 oder 149 summieren. Wenn Mod 11 verwendet wird, sind dies die einzigen Paare, die sich zu 6 summieren. Nimmt eine Eingabe in Großbuchstaben an.

im Testprogramm ungolfed

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"));
} 

Faktor 72 Bytes

Leider kann mir Regex hier nicht weiterhelfen.

[ dup reverse [ { { 67 71 } { 65 84 } { 71 67 } { 84 65 } } at ] map = ]

Rückwärts, Nachschlagetabelle, vergleiche gleich.

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

J - 21 Bytes

0=[:+/5|[:(+|.)8|3&u:

Basierend auf Dennis 'Methode

Verwendung

   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

Erläuterung

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

Labyrinth , 42 Bytes

_8
,%
;
"}{{+_5
"=    %_!
 = """{
 ;"{" )!

Beendet mit einem Division-durch-Null-Fehler (Fehlermeldung bei STDERR).

Probieren Sie es online!

Das Layout fühlt sich wirklich ineffizient an, aber ich sehe gerade keinen Weg, es zu spielen.

Erläuterung

Diese Lösung basiert auf Dennis 'arithmetischem Trick: Nehmen Sie alle Zeichencodes modulo 8, fügen Sie ein Paar von beiden Enden hinzu und stellen Sie sicher, dass es durch teilbar ist5 .

Labyrinth-Grundierung:

• Labyrinth hat zwei Stapel von Ganzzahlen mit beliebiger Genauigkeit, main und aux (iliary), die anfänglich mit einer (impliziten) unendlichen Menge von Nullen gefüllt sind.
• Der Quellcode ähnelt einem Labyrinth, in dem der Anweisungszeiger (IP) nach Möglichkeit Korridoren folgt (sogar um Ecken). Der Code beginnt beim ersten gültigen Zeichen in der Lesereihenfolge, in diesem Fall also in der linken oberen Ecke. Wenn die IP zu einer beliebigen Art von Junction gelangt (dh zu mehreren benachbarten Zellen zusätzlich zu derjenigen, von der sie stammt), wählt sie eine Richtung aus, die auf der Oberseite des Hauptstapels basiert. Die Grundregeln sind: Links abbiegen, wenn negativ, weiterfahren, wenn null, rechts abbiegen, wenn positiv. Und wenn eine davon nicht möglich ist, weil es eine Mauer gibt, dann geht die IP in die entgegengesetzte Richtung. Die IP dreht sich auch um, wenn Sackgassen getroffen werden.
• Ziffern werden verarbeitet, indem die Oberseite des Hauptstapels mit 10 multipliziert und dann die Ziffer hinzugefügt wird.

Der Code beginnt mit einer kleinen 2x2-Schleife im Uhrzeigersinn, die alle Eingangsmodule 8 liest:

_   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.

Jetzt ;wirft die -1. Wir betreten eine weitere Schleife im Uhrzeigersinn, die den oberen Teil des Hauptstapels (dh das letzte Zeichen) nach unten bewegt:

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

Jetzt gibt es ein kurzes lineares 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.

Die IP befindet sich jetzt an einer Kreuzung, die als Verzweigung dient, um die Teilbarkeit durch 5 zu testen. Wenn das Ergebnis des Modulos nicht Null ist, wissen wir, dass die Eingabe kein Watson-Crick-Palindrom ist, und wenden uns nach Osten:

_   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.

Andernfalls müssen wir den Rest der Eingabe überprüfen, damit die IP weiter nach Süden geht. Der {zieht über den unteren Rand der verbleibenden Eingabe. Wenn die Eingabe erschöpft ist, ist dies a 0(von der Unterseite von aux ), und die IP bewegt sich weiter nach Süden:

)   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.

Andernfalls müssen mehr Zeichen in der Zeichenfolge überprüft werden. Die IP dreht sich nach Westen und bewegt sich in die nächste (im Uhrzeigersinn) 2x2-Schleife, die größtenteils aus No-Ops besteht:

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

Nach dieser Schleife haben wir die Eingabe wieder auf dem Hauptstapel, mit Ausnahme des ersten und letzten Zeichens und mit einer Null oben. Die ;wirft die0 und dann =die Stapeloberseiten, aber dies dient nur dazu, das erste =in der Schleife abzubrechen , da wir die Schleife jetzt an einer anderen Stelle betreten. Spülen und wiederholen.

sed, 67 61 bytes

G;H;:1;s/\(.\)\(.*\n\)/\2\1/;t1;y/ACGT/TGCA/;G;s/^\(.*\)\1$/1/;t;c0

(67 Bytes)

Prüfung

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

Ausgabe

ATCGCGAT 1
AGT 0
GTGACGTCAC 1
GCAGTGA 0
GCGC 1
AACTGCGTTTAC 0
ACTG 0

Durch die Verwendung von erweiterten regulären Ausdrücken kann die Byteanzahl auf 61 reduziert werden.

sed -r 'G;H;:1;s/(.)(.*\n)/\2\1/;t1;y/ACGT/TGCA/;G;s/^(.*)\1$/1/;t;c0'

C #, 65 Bytes

bool F(string s)=>s.SequenceEqual(s.Reverse().Select(x=>"GACT"[("GACT".IndexOf(x)+2)%4]));

.NET hat manchmal ziemlich lange Framework-Methodennamen, was nicht unbedingt das beste Code-Golf-Framework darstellt. In diesem Fall bestehen die Namen der Framework-Methoden aus 33 von 90 Zeichen. :)

Basierend auf dem Modulus-Trick von einer anderen Stelle im Thread:

bool F(string s)=>s.Zip(s.Reverse(),(a,b)=>a%8+b%8).All(x=>x%5==0);

Wiegt jetzt 67 Zeichen, wovon 13 Methodennamen sind.

Eine weitere kleine Optimierung, um unglaubliche 2 Zeichen zu entfernen:

bool F(string s)=>s.Zip(s.Reverse(),(a,b)=>(a%8+b%8)%5).Sum()<1;

65 davon sind Framework-Namen.

Bearbeiten: Weglassen von einigen der begrenzten "Boilerplate" aus der Lösung und Hinzufügen von ein paar Bedingungen lässt uns mit dem Ausdruck

s.Zip(s.Reverse(),(a,b)=>(a%8+b%8)%5).Sum()

Was genau dann 0 ergibt, wenn der String s eine gültige Antwort ist. Wie cat betont, kann "bool F (string s) =>" tatsächlich durch "s =>" ersetzt werden, wenn im Code klar ist Func<string,bool>, dass der Ausdruck a ist , d. H. ordnet einen String einem Booleschen Wert zu.

REXX 37

s='ATCGCGAT';say s=translate(reverse(s),'ATCG','TAGC')

R 101 Bytes

g=function(x){y=unlist(strsplit(x,""));all(sapply(rev(y),switch,"C"="G","G"="C","A"="T","T"="A")==y)}

Testfälle

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

Oktave, 52 Bytes

f=@(s) prod(mod((i=mod(toascii(s),8))+flip(i),5)==0)

Nach Denis 'Trick ... nimm die ASCII-Werte Mod 8, drehe sie um und addiere sie; Wenn jede Summe ein Vielfaches von fünf ist, sind Sie golden.

Clojure / ClojureScript, 49 Zeichen

#(=(list* %)(map(zipmap"ATCG""TAGC")(reverse %)))

Arbeitet mit Streichern. Wenn die Anforderungen gelockert werden, um Listen zuzulassen, kann ich die abnehmen (list* )und 7 Zeichen sparen.

R, 70 Bytes

f=function(x)all(chartr("GCTA","CGAT",y<-strsplit(x,"")[[1]])==rev(y))

Verwendung:

> 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

C 71 Bytes

Erfordert ASCII-Codes für die relevanten Zeichen, akzeptiert jedoch Eingaben in Groß-, Klein- oder Mischbuchstaben.

f(char*s){char*p=s+strlen(s),b=0;for(;*s;b&=6)b|=*--p^*s++^4;return!b;}

Dieser Code verwaltet zwei Zeiger sund pdurchläuft die Zeichenfolge in entgegengesetzte Richtungen. Bei jedem Schritt vergleichen wir die entsprechenden Zeichen, Einstellungb true, wenn sie nicht übereinstimmen. Der Abgleich basiert auf der XOR-Verknüpfung der Zeichenwerte:

'A' ^ 'T' = 10101
'C' ^ 'G' = 00100

'C' ^ 'T' = 10111
'G' ^ 'A' = 00110
'A' ^ 'C' = 00010
'T' ^ 'G' = 10011
 x  ^  x  = 00000

Wir können in der obigen Tabelle sehen, dass wir Erfolg xx10xund Misserfolg für irgendetwas anderes aufzeichnen wollen , also XOR mit 00100(vier) und Maske mit 00110(sechs), um Null für zu erhaltenAT oder zu erhaltenCG und andernfalls ungleich Null zu erhalten. Schließlich geben wir true zurück, wenn alle Paare ein Null-Ergebnis angesammelt habenb , andernfalls false.

Testprogramm:

#include <stdio.h>
int main(int argc, char **argv)
{
    while (*++argv)
        printf("%s = %s\n", *argv, f(*argv)?"true":"false");
}

𝔼𝕊𝕄𝕚𝕟 13 Zeichen / 17 Bytes

⟮ïĪ`ACGT”⟯ᴙ≔Ⅰ

Try it here (Firefox only).

Erläuterung

Transkribieren Sie die Eingabe von ACGTbis TGCAund überprüfen Sie, ob die resultierende Zeichenfolge ein Palindrom ist.