문제

임의의 DNA 문자열이 Watson-Crick palindrome인지 여부를 판별 할 수있는 함수를 작성하십시오. 함수는 DNA 문자열을 가져 와서 문자열이 Watson-Crick 회문이면 참 값을, 그렇지 않으면 거짓 값을 출력합니다. True와 False는 각각 1과 0으로 표시 될 수 있습니다.

DNA 문자열은 선호도에 따라 모두 대문자이거나 모두 소문자 일 수 있습니다.

또한 DNA 문자열은 비어 있지 않습니다.

설명

DNA 문자열은 그 역수의 보체가 자신과 같을 때 Watson-Crick 회문입니다.

DNA 문자열이 주어지면 먼저 그것을 뒤집은 다음 DNA 염기 (A ↔ T 및 C ↔ G)에 따라 각 문자를 보완하십시오. 원래 문자열이 보완-역 문자열과 같으면 Watson-Crick 회문입니다.

자세한 내용은이 질문을 참조하십시오 . 하위 문자열이 Watson-Crick palindrome 인 DNA 문자열의 가장 긴 하위 문자열을 찾아야하는 다른 도전입니다.

골

이것은 코드 골프이며 가장 짧은 코드가 승리합니다.

테스트 사례

형식은 <input> = <output>입니다.

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

05AB1E , 10 7 바이트

암호:

Â'š×‡Q

설명:

문자열이 회문인지 확인하려면 입력과 at스왑 및 cg스왑을 사용하여 입력을 확인한 다음 반전하면됩니다. 이것이 우리가 할 일입니다. 입력과 입력을 Â(bifurcate)를 사용하여 반전 시킵니다. 이제 까다로운 부분이 있습니다. 'š×에 대한 압축 버전입니다 creating. 우리가 그것을 뒤집 으면 왜 코드에 있는지 볼 수 있습니다.

CreATinG
|  ||  |
GniTAerC

반전 된 입력을 음역하는 데 사용됩니다. 음역은로 수행됩니다 ‡. 그런 다음 입력과 음역 입력이 동일한 지 확인 Q하고 해당 값을 인쇄합니다. 그래서 이것은 스택이 입력에 어떻게 보이는지입니다 actg.

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

어느 것도 디버그 플래그로 볼 수 있습니다 ( 여기에서 시도하십시오 ).

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오! .

젤리 , 9 바이트

O%8µ+U5ḍP

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

작동 원리

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.

파이썬 2, 56 45 44 바이트

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

펄, 27 바이트

에 +2 포함 -lp

STDIN에 입력하고 1을 인쇄하거나 아무것도 인쇄하지 않습니다.

dnapalin.pl <<< ATCGCGAT

dnapalin.pl:

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

교체 $_=로 $_+=얻을 0잘못된 경우에 빈 대신

Pyth-10 바이트

qQ_XQ"ACGT

여기에서 온라인으로 사용해보십시오 .

이 될 것이라고 9 바이트 가 아닌 경쟁 만드는 버그 수정 후 : 온라인 여기를보십시오 .

망막 , 34 33 바이트

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

온라인으로 사용해보십시오! (모든 테스트 사례를 한 번에 실행하도록 약간 수정했습니다.)

설명

$
;$_

문자열의 끝을 일치 ;시키고 전체 입력 다음에 입력을 삽입하여 입력을 복제하십시오 .

T`ACGT`Ro`;.+

입력의 후반 만 일치 ;.+시키고 음역으로 쌍을 대체하십시오. 타겟 세트로서 Ro: o참조합니다 다른 세트되어 o교체된다 ACGT. 그러나이 R세트를 뒤집어서 두 세트는 실제로 다음과 같습니다.

ACGT
TGCA

입력이 DNA 회 문인 경우, 이제 입력과 그 반대로 입력됩니다 (로 구분 ;).

+`(.);\1
;

에서 +주위에 동일한 문자 쌍을 반복적으로 제거합니다 ( ) ;. 이 ;문자 만 남을 때까지 또는 두 문자 ;가 더 이상 동일하지 않을 때까지 계속됩니다. 이는 문자열이 서로 반대가 아님을 의미합니다.

^;

첫 번째 문자가 ;인쇄되어 있는지 0또는 1적절하게 확인하십시오 .

자바 스크립트 (ES6), 59 바이트

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

Regexp를 사용하지 않고 할 수있는 최선은 62 바이트였습니다.

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

루비, 35

다른 방법을 시도했지만 가장 확실한 방법은 가장 짧았습니다.

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

테스트 프로그램에서

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

하스켈, 48 45 바이트

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

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

포인트가없는 버전은

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

편집 : @Mathias Dolidon은 3 바이트를 저장했습니다. 감사!

레티 나, 52 바이트

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

줄리아, 47 38 바이트

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

이것은 Char배열 을 받아들이고 부울을 반환 하는 익명 함수입니다 . 호출하려면 변수에 지정하십시오.

이것은 Naïve 솔루션보다 짧은 Dennis 알고리즘을 사용합니다. 우리는 각 코드 포인트의 나머지를 8로 나눈 다음 그 반대로 뒤집고 나머지를 5로 나눈 후 모든 것이 0인지 확인합니다. 마지막 단계는의 인수 ⊆버전 issubset을 Set확인하기 전에. 이는 이후로 [0,0,0]의 하위 집합으로 선언 됨을 의미합니다 . 이것은 0에 대한 명시 적 검사보다 짧습니다.0Set([0,0,0]) == Set(0)

온라인으로 사용해보십시오!

Dennis 덕분에 9 바이트가 절약되었습니다!

Jolf, 15 바이트

시도 해봐!

=~A_iγ"AGCT"_γi

설명:

   _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 바이트

여기 사용해보십시오!

pe+i~Aiγ"GATC"_γ

설명

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

실제로는 19 바이트

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

이것은 Dennis의 알고리즘을 사용 합니다 .

온라인으로 사용해보십시오!

설명:

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 바이트

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

줄리아 0.4, 22 바이트

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

문자열은 제어 문자 EOT (4) 및 NAK (21)를 포함합니다. 입력은 문자형 배열이어야합니다.

이 방법은 입력의 문자를 반전 된 입력의 해당 문자와 ​​XOR합니다. 유효한 페어링의 경우 문자 EOT 또는 NAK가됩니다. 해당 문자의 문자열에 포함되는지 테스트하면 원하는 부울이 생성됩니다.

온라인으로 사용해보십시오!

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

Dennis가 2 바이트를 절약했습니다. 상수 : 추가 2 바이트는 소문자로 입력을 적용하여 저장 37및 21에 개정 5하고 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 바이트 저장 : 두 개의 ASCII 코드 mod 37을 곱하여 괄호를 제거했습니다. 유효한 쌍은 21로 평가됩니다. 대문자 입력을 가정합니다.

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

유효한 쌍의 ASCII 코드는 138 또는 149의 합이라는 사실을 사용합니다. mod 11을 취하면 6의 합은 유일한 쌍입니다. 대문자 입력을 가정합니다.

테스트 프로그램에서 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"));
} 

인자 , 72 바이트

불행히도 정규 표현식은 나를 도울 수 없습니다.

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

역방향, 조회 테이블, 동일 비교

Bash + coreutils, 43 32 바이트

[ `tr ATCG TAGC<<<$1|rev` = $1 ]

테스트 :

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 바이트

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

Dennis의 방법에 기초

용법

   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

설명

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

미로 , 42 바이트

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

0으로 나누기 오류 (STDERR의 오류 메시지)로 종료됩니다.

온라인으로 사용해보십시오!

레이아웃은 실제로 비효율적으로 느껴지지만 지금은 골프를 치는 방법을 보지 못하고 있습니다.

설명

이 솔루션은 Dennis의 산술 기법을 기반으로합니다. 모든 문자 코드를 modulo 취하고 8양쪽 끝에서 쌍을 추가하고로 나눌 수 있는지 확인하십시오 5.

미로 프라이머 :

• Labyrinth에는 main 과 aux (iliary) 라는 두 개의 임의 정밀도 정수 스택 이 있으며 처음에는 (암시 적) 무한한 양의 0으로 채워집니다.
• 소스 코드는 미로와 유사하며, 명령 포인터 (IP)는 가능할 때 (모퉁이를 돌 때) 복도를 따라갑니다. 코드는 첫 번째 유효한 문자에서 읽기 순서로 시작합니다 (예 :이 경우 왼쪽 상단). IP가 어떤 형태의 접합 (즉, 여러 개의 인접 셀에서 나온 것)에 도달하면 메인 스택의 상단을 기준으로 방향을 선택합니다. 기본 규칙은 다음과 같습니다. 음수이면 왼쪽으로 돌리고 0이면 계속 진행하고 양수이면 오른쪽으로 돌리십시오. 벽이있어이 중 하나를 사용할 수없는 경우 IP는 반대 방향으로 진행됩니다. 데드 엔드를 칠 때 IP도 돌아갑니다.
• 숫자는 메인 스택의 상단에 10을 곱한 다음 숫자를 추가하여 처리됩니다.

이 코드는 작은 2x2의 시계 방향 루프로 시작하며 모든 입력 모듈로 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.

이제 ;삭제합니다 -1. 메인 스택의 상단 (즉, 마지막 문자)을 맨 아래로 이동시키는 또 다른 시계 방향 루프를 입력합니다.

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

이제 짧은 선형 비트가 있습니다.

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

IP는 이제 5로 나누기를 테스트하기위한 분기점 역할을하는 접합점에 있습니다. 모듈로 결과가 0이 아닌 경우 입력이 Watson-Crick 회문이 아니고 동쪽으로 바뀝니다.

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

그렇지 않으면 나머지 입력을 계속 확인해야하므로 IP가 계속 남쪽으로 이동합니다. {나머지 입력 하단 통해 당긴다. 입력을 다 써 버린 경우 0( aux 의 맨 아래부터 ) IP가 남쪽으로 계속 이동합니다.

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

그렇지 않으면 문자열에 검사 할 문자가 더 있습니다. IP는 서쪽으로 바뀌고 다음 (시계 방향) 2x2 루프로 이동합니다.

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

이 루프가 끝나면 첫 번째와 마지막 문자를 제외하고 맨 위에 0을 제외하고 기본 스택에서 입력을 다시 얻습니다. ;폐기는 0다음 =스택의 꼭대기를 교환합니다, 그러나 이것은 단지 첫 번째 취소하는 것입니다 =우리가 지금 다른 위치에 루프를 입력하고 있기 때문에, 루프있다. 헹구고 반복하십시오.

sed, 67 61 바이트

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

(67 바이트)

테스트

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

산출

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

확장 정규식을 사용하면 바이트 수를 61로 줄일 수 있습니다.

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

C #, 65 바이트

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

.NET은 때때로 상당히 긴 프레임 워크 메소드 이름을 가지므로 반드시 최상의 코드 골프 프레임 워크를 만들 필요는 없습니다. 이 경우 프레임 워크 메소드 이름은 90 개 중 33자를 구성합니다. :)

스레드의 다른 곳에서 모듈러스 트릭을 기반으로 :

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

이제 67 개의 문자 중 13 개가 메소드 이름입니다.

무려 2자를 줄이는 또 다른 사소한 최적화 :

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

따라서 65 개 중 13 개는 프레임 워크 이름입니다.

편집 : 솔루션에서 제한된 "boilerplate"을 생략하고 몇 가지 조건을 추가하면 표현이 남습니다.

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

문자열 s가 유효한 대답 인 경우에만 0을 제공합니다. 고양이 점 밖으로로서, "부울 F는 (문자열들) =>"로 실제로 대체 가능하다 "S =>" 경우 가 그렇지 않은 표현이 있음을 코드에서 분명 Func<string,bool>, 즉. 문자열을 부울에 매핑합니다.

REXX 37

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

R, 101 바이트

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

테스트 사례

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

옥타브, 52 바이트

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

Denis의 속임수에 따라 ... ASCII 값 mod 8을 가져 와서 뒤집어 추가하십시오. 모든 합이 5의 배수라면 황금색입니다.

Clojure / ClojureScript, 49 자

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

문자열에서 작동합니다. 목록을 허용하기 위해 요구 사항이 완화되면 (list* )7 자를 제외하고 저장할 수 있습니다 .

R, 70 바이트

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

용법:

> 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 바이트

관련 문자에 ASCII 코드가 필요하지만 대문자, 소문자 또는 대소 문자를 입력 할 수 있습니다.

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

이 코드는 두 개의 포인터를 유지 s하고 p반대 방향으로 문자열을 통과. 각 단계에서 해당 문자를 비교하여 b일치하지 않으면 true로 설정 합니다. 일치는 문자 값의 XOR을 기반으로합니다.

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

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

위의 표에서 우리는 xx10x다른 것에 대한 성공 과 실패 를 기록하고 싶다는 것을 알 수 있습니다. 따라서 우리는 00100(4)로 XOR 하고 00110(6)으로 마스크하여 0을 얻 AT거나 CG그렇지 않으면 0을 얻습니다 . 마지막으로 모든 쌍이에 0 결과를 축적하면 true를 반환 b하고 그렇지 않으면 false를 반환합니다.

테스트 프로그램 :

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

𝔼𝕊𝕄𝕚𝕟, 13 자 / 17 바이트

⟮ïĪ`ACGT”⟯ᴙ≔Ⅰ

Try it here (Firefox only).

설명

음역에서 입력 ACGT을 TGCA생성 문자열 회문이면 확인.