Watson-Crick palindromları


31

Sorun

Keyfi bir DNA dizisinin bir Watson-Crick palindromu olup olmadığını belirleyebilecek bir fonksiyon yaratın. İşlev bir DNA dizgisini alır ve dizge bir Watson-Crick palindromuysa gerçek bir değer, değilse de yanlış bir değer verir. (Doğru ve Yanlış, sırasıyla 1 ve 0 olarak gösterilebilir.)

DNA dizisi tercihinize bağlı olarak tüm büyük harf veya küçük harf olabilir.

Ayrıca, DNA dizisi boş olmayacak.

açıklama

Bir DNA dizisi, tersinin tamamlayıcısı kendisine eşit olduğunda bir Watson-Crick palindromudur.

Bir DNA dizisi verildiğinde, önce onu ters çevirin ve sonra her karakteri DNA bazlarına göre (A ↔ T ve C ↔ G) tamamlayın. Orijinal dize, tamamlanmış geri dizgeye eşitse, Watson-Crick palindromudur.

Daha fazla bilgi için bu soruya bakın . Bir DNA dizisinin en uzun alt dizesini bu alt dizinin Watson-Crick palindrom olduğu yerde bulmanız gereken farklı bir zorluktur.

Hedef

Bu kod golf ve en kısa kod kazanır.

Test Kılıfları

Biçimdir <input> = <output>.

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


3
Birisi DNA # da bir Watson-Crick palindromu olan bir program yazmalı . : D (mümkün olmayabilir)
mbomb007

Veya, eğer istersen, "2 grupta serbest grupta 2. sıraya sahipse bir kelime Watson-Crick palindromudur" (ya da n jeneratörlerde!).
wchargin

(Teknik olarak "sipariş en fazla 2" dir.)
wchargin

1
@AndrasDeak Watsons kitabına göre, Franklin görünüşe göre onların tarafında bir dikendi. Tekrar tekrar sarmalı gösteren x-ışınlarını teslim etmeyi reddetti (hatırladığım kadarıyla), çünkü inanmayı reddetti. Keşifte herhangi bir oranda ilgileniyorsanız, bir okumaya değer.
Obsidian Anka

Yanıtlar:


27

05AB1E , 10 7 bayt

Kod:

Â'š×‡Q

Açıklama:

Bir dizginin bir palindrom olup olmadığını kontrol etmek için sadece girişi atdeğiştirilmiş , değiştirilmiş ve cgdeğiştirilmiş girişle kontrol etmemiz ve sonra tersine çevirmemiz gerekir. Demek yapacağımız şey bu. Girdiyi ve girişi ters Âçevirdik (bifurcate). Şimdi zor bir kısım geliyor. 'š×sıkıştırılmış sürümüdür creating. Bunu tersine çevirirsek, neden kodda olduğunu görebilirsiniz:

CreATinG
|  ||  |
GniTAerC

Bu, ters çevrilmiş girişi çevirmek için kullanılacaktır. Harf çevirisi ile yapılır . Ondan sonra, sadece giriş ve çevrilen girişin normal olup olmadığını kontrol ederiz Qve bu değeri yazdırırız. Yani yığın giriş için böyle gözükür actg:

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

Hangi hata ayıklama bayrağı ile görülebilir ( burada deneyin ).

CP-1252 kodlamasını kullanır . Çevrimiçi deneyin! .


4
Çok, çok, yaratıcı ...
Toby Speight

2
Bu dil çok zarif özelliklere sahip
mil

18

Jöle , 9 bayt

O%8µ+U5ḍP

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Nasıl çalışır

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.

4
Bence Python bu cevapla rekabet etmeye oldukça yakın! Cevabım ilk dokuz bayt karşılaştırın: lambda s:. Neredeyse tam çözüm bu!
orlp

Bekle, "Nasıl çalışıyor" kısmı gerçekten nasıl çalıştığını açıklamıyor ... Neden 8 artıkları ve 5 toplamları? Harfler nerede tamamlanıyor?
ZeroOne,

@ ZeroOne Bu kısmı açıklığa kavuşturdum.
Dennis,

Vayy! Çok zekice. :) Teşekkürler!
ZeroOne

12

Python 2, 56 45 44 bayt

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

lambda s:s==s[::-1].translate("TCG_A"*99)Python 3'te çalışıyor
Alex Varga

8

Perl, 27 bayt

İçin +2 içerir -lp

STDIN'e giriş yapın, 1 veya hiçbir şey basmaz:

dnapalin.pl <<< ATCGCGAT

dnapalin.pl:

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

Değiştir $_=tarafından $_+=almak için 0yanlış durum için boş yerine



7

Retina , 34 33 bayt

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

Çevrimiçi deneyin! (Tüm test durumlarını bir kerede çalıştırmak için hafifçe değiştirilmiş.)

açıklama

$
;$_

Dizenin sonunu eşleştirerek ve ;ardından tüm girişi izleyerek girişi kopyalayın.

T`ACGT`Ro`;.+

Girişin yalnızca ikinci yarısını ;.+eşleştirin ve çiftlerin yerini çevirisi ile değiştirin. Hedef sete gelince Ro: diğer sete oatıfta bulunur , bunun yerine . Fakat bu seti tersine çevirir, yani iki set aslında:oACGTR

ACGT
TGCA

Girdi bir DNA palindromuysa, şimdi girişi tersine çevirerek ayırırız ;.

+`(.);\1
;

Tekrarlayan ( +) etrafında bir çift aynı karakterleri kaldırır ;. Bu, sadece kalana kadar ;veya etrafındaki iki karakter ;artık aynı olmadıkça devam eder, bu, dizelerin birbirinin tersi olmadığı anlamına gelir.

^;

İlk karakterin olup olmadığını kontrol edin ;ve yazdırın 0veya 1buna göre.


6

JavaScript (ES6), 59 bayt

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

Regexp kullanmadan yapabileceğim en iyi 62 bayt:

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

5

Ruby, 35

Başka yollar denedim, ama bariz yol en kısa yoluydu:

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

test programında

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

2
->s{s.==s.reverse.tr'ACGT','TGCA'}bir bayt kısaltmasıdır
Mitch Schwartz

@WitchSchwartz vay, işe yarıyor, ama bunun ne işe yaradığı hakkında hiçbir fikrim yok .. Kod onsuz bana daha doğru görünüyor , ancak çalışmasını sağlamak için gereklidir. Herhangi bir yerde belgelenmiş mi?
Level River St

Bunu kendi başına çözmek istemediğine emin misin?
Mitch Schwartz

@MitchSchwartz hahaha Çoktan denedim. Ruby'nin beyaz alan için gereksinimlerini çok kendine özgü buluyorum. Dönemler için tuhaf şartlar başka bir konudur. Birkaç teorim var ama hepsi yanlış olabilir. ==Bir operatör yerine bir yöntem olarak ele almanın bir ilgisi olabileceğinden şüpheleniyorum , ancak sembollerle arama yapmak imkansız.
Seviye River St

Doğru düsündün. :) Bu sadece düz eski yöntem çağrısı.
Mitch Schwartz

5

Haskell, 48 45 bayt

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

Kullanım örneği: (==)=<<reverse.map((cycle"_T_GA__C"!!).fromEnum) $ "ATCGCGAT"-> True.

Noktasız sürüm

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

Düzenleme: @Mathias Dolidon 3 bayt kaydetti. Teşekkürler!


İle cycle "TCG_A" de çalışır . :)
Mathias Dolidon


4

Julia, 47 38 bayt

s->((x=map(Int,s)%8)+reverse(x))%50

Bu, bir Chardiziyi kabul eden ve bir boolean döndüren adsız bir işlevdir . Aramak için değişkene atayın.

Bu, Dennis'in algoritmasını kullanır, ki bu naif çözümden daha kısadır. Biz 8 bölünür, her bir kod noktası geri kalanı, ters kendisine eklemek 5 ile bölünmesinden kalanlar almak ve tüm son adım kullanılarak gerçekleştirilir 0 değerini olup olmadığını kontrol olsun , bir çatı ve çatı versiyonu issubsetiçin iki bağımsız değişkenler yayınları, Setkontrol etmeden önce. Bu araçlar [0,0,0]bir alt kümesini ilan edilir 0beri, Set([0,0,0]) == Set(0). Bu, 0'a karşı yapılan açık bir kontrolden daha kısadır.

Çevrimiçi deneyin!

Dennis sayesinde 9 byte kurtarıldı!


4

Jolf, 15 Bayt

Dene!

=~A_iγ"AGCT"_γi

Açıklama:

   _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

3

Jolf, 16 bayt

Burada dene!

pe+i~Aiγ"GATC"_γ

açıklama

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

3

Aslında, 19 bayt

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

Bu Dennis'in algoritmasını kullanır .

Çevrimiçi deneyin!

Açıklama:

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

3

Oracle SQL 11.2, 68 bayt

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

2
Bunun gibi SQL ile bazı projelerim için daha önce raporlar yazmış olmanız gerektiğine eminim ...
corsiKa

3

Julia 0.4, 22 bayt

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

Dize, EOT (4) ve NAK (21) kontrol karakterlerini içerir. Giriş bir karakter dizisi biçiminde olmalıdır.

Bu yaklaşım XOR, girişin karakterlerini, tersi girilen karakterdeki karşılık gelen karakterlerle birlikte gösterir. Geçerli eşleştirmeler için bu, EOT veya NAK karakterleriyle sonuçlanır. Bu karakterlerin dizgisine dahil edilme testi, istenen Boole dilini üretir.

Çevrimiçi deneyin!


3

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 tarafından 2 bayt kurtardı. Sabitleri: Ek 2 byte küçük girişi için uyarlayarak kaydedilir 37ve 21şekilde revize edilir 5ve 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;}

Bir bayt kurtarıldı: mod 37'de iki ASCII kodunun ürününü alarak ortadan kaldırılmış parantez. Geçerli çiftler 21 olarak değerlendirilir. Büyük harf girişi yapar.

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

Geçerli çiftlerin ASCII kodlarının 138 veya 149 olduğu anlamına gelir. Mod 11 alındığında, bunlar 6 olan tek çiftlerdir. Büyük harfli giriş yapar.

test programında 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"));
} 

1
r,e;f(char*s){for(r=0,e=strlen(s)+1;*s;s++)r|=*s*s[e-=2]%37^21;return!r;}birkaç bayttan tasarruf eder.
Dennis,

@Dennis teşekkürler, işaretçileri değiştirmek için havamda değildim, ama bir bayt sıktı! Ben görmeliydin !=> ^kendim. Küçük harf girişine geçerek 2 tane daha düşürdüm: her iki sihirli sayı artık tek haneli.
Level River St

3

Faktör , 72 bayt

Maalesef regex bana burada yardımcı olamaz.

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

Ters, arama tablosu, eşit karşılaştırın.


Vay, bu çok fazla boşluk! Hepsi gerekli mi? Ayrıca, dil ana sayfasına bir bağlantı yararlı olacaktır.
Level River St

@LevelRiverSt Ne yazık ki, bunun her kısmı gereklidir. Başlığa bir link ekleyeceğim.
kedi

3

Bash + coreutils, 43 32 bayt

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

Testler:

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

3

J - 21 bayt

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

Dennis'in yöntemine göre

kullanım

   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

açıklama

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

3

Labirent , 42 bayt

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

Sıfıra bölme hatasıyla sona erer (STDERR'de hata mesajı).

Çevrimiçi deneyin!

Düzen gerçekten verimsiz hissediyor, ancak şu anda golf oynamak için bir yol göremiyorum.

açıklama

Bu çözüm Dennis'in aritmetik numarasına dayanıyor: tüm karakter kodlarını al 8 , her iki uçtan bir çift ekle ve bölüştürdüğünden emin ol5 .

Labirent astar:

  • Labirent rasgele hassas tamsayılar iki yığın sahiptir, ana ve yardımcı başlangıçta (örtük) sonsuz miktarda sıfır ile dolu (iliary) .
  • Kaynak kod, bir labirenti andırır, burada talimat göstergesinin (IP) olabildiğince koridorları izlediği (hatta köşelerinde). Kod, okuma sırasındaki ilk geçerli karakterde başlar, yani bu durumda sol üst köşede. IP herhangi bir birleşme şekline geldiğinde (yani, geldiğine ek olarak birkaç bitişik hücre), ana yığının tepesine dayalı bir yön seçecektir. Temel kurallar şunlardır: negatifken sola dönün, sıfırda ilerlemeye devam edin, pozitifken sağa dönün. Ve bunlardan biri mümkün olmadığında, çünkü bir duvar var, o zaman IP ters yön alır. IP ayrıca ölü uçlara çarptığında da döner.
  • Rakamlar ana yığının üst kısmı 10 ile çarpılarak ve sonra rakam eklenerek işlenir.

Kod, tüm giriş modülo 8'i okuyan küçük bir 2x2, saat yönünde döngü ile başlar:

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

Şimdi ;atar -1. Ana yığının üstünü (yani son karakter) aşağıya doğru hareket ettiren başka bir saat yönünde döngü giriyoruz:

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

Şimdi kısa bir doğrusal bit var:

{{  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 şimdi bölünebilirliği 5 ile test etmek için bir dal gibi davranan bir kavşakta. Modülün sonucu sıfır değilse, girişin bir Watson-Crick palindrom olmadığını biliyoruz ve doğuya dönüyoruz:

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

Aksi takdirde, girişin geri kalanını kontrol etmeye devam etmemiz gerekir, böylece IP güneye devam eder. {Geri kalan giriş alt kısmına çeker. Eğer girdiyi tükettikten sonra, bu bir 0( aux'in altından ) olacak ve IP güneye doğru ilerlemeye devam edecektir:

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

Aksi takdirde, kontrol edilecek dizgede daha fazla karakter vardır. IP batıya döner ve büyük ölçüde no-ops içeren bir sonraki (saat yönünde) 2x2 döngüye geçer:

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

Bu döngüden sonra, ilk ve son karakter dışında ve üstte sıfır olmak üzere, ana yığında girişi tekrar elde ettik. ;Atar 0ve sonra =yığınlarının tepelerini takaslar, ama bu sadece ilk iptal etmektir =şimdi farklı bir konumda döngü giriyorsanız, çünkü döngü içinde. Durulayın ve tekrarlayın.


3

sed, 67 61 bayt

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

(67 bayt)

Ölçek

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

Çıktı

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

Genişletilmiş düzenli ifadeler kullanılarak, bayt sayısı 61'e düşürülebilir.

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

Bunu 61 baytta yapabiliyorsanız, puanınız budur - NFA'ya veya turing-complete regexp'e karşı bu özel mücadelede hiçbir şey yoktur. Bazı zorluklar regex'e tamamen izin vermez, ancak genellikle sadece regex-golf düzenli olmayan ifadelere izin vermez .
kedi,

3

C #, 65 bayt

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

.NET, bazen en iyi kod golf çerçevesi için mutlaka yapılması gerekmeyen bazı oldukça uzun çerçeve yöntem adlarına sahiptir. Bu durumda, çerçeve yöntemi adları, 90 üzerinden 33 karakterden oluşur. :)

İplikte başka bir yerden gelen modül numarasına göre:

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

Şimdi 13 karakterin yöntem ismi olduğu 67 karakterde tartıştık.

Bir kuyruklu 2 karakteri tıraş etmek için başka bir küçük optimizasyon:

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

Yani, 65 tanesi 13'ü çerçeve adıdır.

Düzenleme: Sınırlı "kazan plakası" nın bir kısmının çözümden çıkarılması ve birkaç koşul eklenmesi, bizi ifade ile bırakır.

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

Hangi s verirse 0 verir ve sadece s dizesi geçerli bir cevap ise. Kedi çıkış noktaları gibi, "bool F (string s) =>" ile aslında Değişebilir olan "ler =>" eğer aksi ifadesi olduğunu kodunda temizlemek oluyor Func<string,bool>, yani. bir dizgiyi bir boole ile eşler.


1
PPCG'ye hoş geldiniz, ilk cevap güzel! : D
kedi

@cat Bunun için teşekkürler! :)
robhol

1
Ben yok gerçekten C # biliyorum, ama bu bir lambda ise anonim fonksiyonlar ince sürece atama gibi oldukları gibi, o zaman, atamadan türünü ve dışarı bırakabilir mümkün .
kedi

1
Ayrıca, !s.Zip...yerine yapamaz mısın s.Zip...==0? (Ya da !C # ' ya giremez misiniz ?) Boole-negatifi reddedemezseniz bile, cevabınıza bu şekilde <bu şeyi> ve <bu diğer determinist için <bu şeyi> döndürdüğünü söyleyebilirsiniz. açıkça farkedilebilir şey> truthy için.
kedi

1
@ cat: Türü bırakmakta haklısın. Kodun doğrudan çalıştırılabilir olması gerektiğini düşündüm, ancak giriş ve çıkışla ilgili basit varsayımlarda bulunmak biraz daha kolay hale geldi. Bununla birlikte, diğer şey işe yaramayacak - haklı olarak, bence, bir boolean işleminin bir sayıya uygulamanın mantıklı (renk tonu) bir yolu olmadığı için. 0 ve 1 değerlerinin atanması yanlış ve doğru değerlerdir, sonuçta, sadece kuraldır.
robhol,

2

REXX 37

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

2

R, 101 bayt

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

Test Kılıfları

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

strsplit(x,"")[[1]]3 bayttan daha kısa unlist(strsplit(x,""))ve burada, xher zaman tek bir karakter dizgesi olduğundan eşdeğerdir .
plannapus

2

Octave, 52 bayt

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

Denis'in numarasının ardından ... mod 8, ASCII değerlerini alır, çevirir ve ekler; Her toplam beşin katı ise, altınsınız.


Yani bir anlamlıdır boşluk? Bu garip.
kedi,

Ayrıca f=ödevi bırakabilirsiniz ; adsız işlevler tamamdır.
kedi,

1

Clojure / ClojureScript, 49 karakter

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

Dizelerde çalışır. Listelere izin vermek için gereksinimler gevşetilirse, (list* )7 karakterden kurtulabilir ve tasarruf edebilirim .


1

R, 70 bayt

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

Kullanımı:

> 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

1

C, 71 bayt

İlgili karakterler için ASCII kodlarını gerektirir, ancak büyük harf, küçük harf veya karma harf girişini kabul eder.

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

Bu kod iki işaretçiler korur, sve pzıt yönlerde dizisini gezinmesi. Her adımda, karşılık gelen karakterleri karşılaştırırız, beğer uyuşmazlarsa true değerini ayarlarız . Eşleştirme, karakter değerlerinin XOR değerini temel alır:

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

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

Yukarıdaki tabloda, xx10xbaşka bir şeyin başarısını ve başarısızlığını kaydetmek istediğimizi görüyoruz.00100 (dört) ile maske 00110için sıfır olsun (altı) ATveyaCG başka şekilde ve sıfırdan. Sonunda, eğer tüm çiftler sıfır sonuç biriktirirse doğru döneriz.b , aksi takdirde false döneriz.

Test programı:

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

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.