वाटसन-क्रिक पैलिंड्रोम्स


31

संकट

एक फ़ंक्शन बनाएं जो यह निर्धारित कर सकता है कि एक मनमाना डीएनए स्ट्रिंग एक वाटसन-क्रिक पैलिंड्रोम है या नहीं। फ़ंक्शन एक डीएनए स्ट्रिंग लेगा और एक सही मूल्य आउटपुट करेगा यदि स्ट्रिंग एक वाटसन-क्रिक पैलिंड्रोम है और एक गलत मान है यदि यह नहीं है। (सत्य और असत्य को क्रमशः 1 और 0 के रूप में भी दर्शाया जा सकता है।)

डीएनए स्ट्रिंग या तो आपकी प्राथमिकता के आधार पर सभी अपरकेस या सभी लोअरकेस में हो सकती है।

साथ ही, डीएनए स्ट्रिंग खाली नहीं होगी।

व्याख्या

एक डीएनए स्ट्रिंग एक वाटसन-क्रिक पैलिंड्रोम है जब इसके रिवर्स का पूरक खुद के बराबर होता है।

डीएनए स्ट्रिंग को देखते हुए, पहले इसे उल्टा करें, और फिर डीएनए के आधार के अनुसार प्रत्येक चरित्र को पूरक करें (ए and टी और सी) जी)। यदि मूल स्ट्रिंग पूरक-उल्टे स्ट्रिंग के बराबर है, तो यह वाटसन-क्रिक पैलिंड्रोम है।

अधिक के लिए, इस प्रश्न को देखें । यह एक अलग चुनौती है, जहां आपको डीएनए स्ट्रिंग का सबसे लंबा प्रतिस्थापन होना चाहिए, जहां यह विकल्प एक वाटसन-क्रिक पैलिंड्रोम है।

लक्ष्य

यह कोड-गोल्फ है और सबसे छोटा कोड जीतता है।

परीक्षण के मामलों

प्रारूप है <input> = <output>

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


3
किसी को डीएनए में एक प्रोग्राम लिखना चाहिए # वह भी एक वाटसन-क्रिक पैलिंड्रोम है। : D (संभव नहीं हो सकता है)
mbomb007

या, यदि आपको पसंद है, "एक शब्द एक वाटसन-क्रिक पैलिंड्रोम है यदि इसमें 2 जनरेटर पर मुक्त समूह में 2 ऑर्डर है" (या एन जनरेटर पर!)।
वक्रीगिन

(मुझे लगता है कि तकनीकी रूप से यह "सबसे अधिक 2. आदेश" है)
wchargin

1
@AndrasDeak वाटसन पुस्तक के अनुसार, फ्रैंकलिन जाहिर तौर पर उनके पक्ष में एक कांटा था। उसने बार-बार एक्स-रे को हेलिक्स दिखाने से मना कर दिया (जैसा कि मुझे याद है), क्योंकि उसने इसे मानने से इनकार कर दिया था। यदि आप किसी भी दर पर खोज में रुचि रखते हैं तो इसका एक मूल्य है।
ओब्सीडियन फीनिक्स

जवाबों:


27

05AB1E , 10 7 बाइट्स

कोड:

Â'š×‡Q

स्पष्टीकरण:

यह जांचने के लिए कि क्या एक स्ट्रिंग एक पैलिंड्रोम है, हमें बस इनपुट के साथ इनपुट की जांच करनी होगी, atअदला- cgबदली के साथ और फिर उसे उल्टा करना होगा। तो वही हम करने जा रहे हैं। हम इनपुट को धक्का देते हैं और इनपुट का उपयोग करके उलट दिया जाता है Â(द्विभाजित)। अब एक मुश्किल हिस्सा आता है। 'š×के लिए संकुचित संस्करण है creating। यदि हम इसे उल्टा करते हैं, तो आप देख सकते हैं कि यह कोड में क्यों है:

CreATinG
|  ||  |
GniTAerC

इसका उपयोग उलटे इनपुट को बदलने के लिए किया जाएगा। लिप्यंतरण के साथ किया जाता है । उसके बाद, हम सिर्फ यह जांचते हैं कि इनपुट और ट्रांसलेटेड इनपुट ई Qual हैं और उस मान को प्रिंट करते हैं। तो यह है कि इनपुट के लिए स्टैक कैसा दिखता है actg:

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

जिसे डिबग फ्लैग के साथ भी देखा जा सकता है ( इसे यहां देखें )।

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!


4
बहुत, एर, रचनात्मक ...
टोबे स्पाइट

2
इस भाषा में कुछ बहुत ही साफ-सुथरी विशेषताएं हैं
मील

18

जेली , 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.

4
मुझे लगता है कि पायथन इस जवाब के साथ प्रतिस्पर्धा करने के लिए काफी करीब है! मेरे उत्तर के पहले नौ बाइट्स की तुलना करें lambda s::। यह लगभग पूर्ण समाधान है!
23

रुको, "यह कैसे काम करता है" भाग वास्तव में यह नहीं बताता है कि यह कैसे काम करता है ... क्यों 8 के अवशेष और 5 के योग? पत्र कहाँ से पूरक हैं?
ज़ीरोएन

@ZeroOne मैंने उस हिस्से को स्पष्ट कर दिया है।
डेनिस

ओह वाह! यह बहुत चालाक है। :) धन्यवाद!
ज़ीरोएन


8

पर्ल, 27 बाइट्स

के लिए +2 शामिल है -lp

STDIN पर इनपुट दें, 1 या कुछ प्रिंट करें:

dnapalin.pl <<< ATCGCGAT

dnapalin.pl:

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

बदलें $_=द्वारा $_+=प्राप्त करने के लिए 0झूठे मामले के लिए खाली करने के बजाय



7

रेटिना , 34 33 बाइट्स

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

इसे ऑनलाइन आज़माएं! (सभी परीक्षण मामलों को एक साथ चलाने के लिए थोड़ा संशोधित किया गया है।)

व्याख्या

$
;$_

स्ट्रिंग के अंत से मेल खाते हुए इनपुट को डुप्लिकेट करें और ;पूरे इनपुट के बाद डालें ।

T`ACGT`Ro`;.+

इनपुट के केवल दूसरे भाग से मिलान करें ;.+और लिप्यंतरण के साथ जोड़े के प्रतिस्थापन का प्रदर्शन करें। लक्ष्य सेट के रूप में Ro: दूसरे सेट का oसंदर्भ दिया जाता है , जिसे बदल दिया जाता है । लेकिन इस सेट को उलट देता है, इसलिए दो सेट वास्तव में हैं:oACGTR

ACGT
TGCA

यदि इनपुट एक डीएनए पैलिंड्रोम है, तो अब हमारे पास इनपुट होगा जिसके बाद इसका उल्टा (अलग ;) होगा।

+`(.);\1
;

बार-बार ( +) के आसपास समान वर्णों की एक जोड़ी को हटा दें ;। यह या तो तब तक जारी रहेगा जब तक कि केवल ;छोड़ दिया गया है या जब तक कि चारों ओर के दो अक्षर ;समान नहीं हैं, जिसका अर्थ होगा कि तार एक दूसरे के विपरीत नहीं हैं।

^;

जांचें कि पहला वर्ण है या ;प्रिंट 0और 1तदनुसार।


6

जावास्क्रिप्ट (ईएस 6), 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))

5

रूबी, ३५

मैंने अन्य तरीकों की कोशिश की, लेकिन स्पष्ट तरीका सबसे छोटा था:

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

2
->s{s.==s.reverse.tr'ACGT','TGCA'}एक बाइट छोटी है
मिच श्वार्ट्ज

@MitchSchwartz वाह, यह काम करता है, लेकिन मुझे पता नहीं है कि पहले क्या है .। इसके बिना मुझे कोड अधिक सही लगता है, लेकिन इसे चलाने के लिए आवश्यक है। क्या यह कहीं भी प्रलेखित है?
लेवल रिवर सेंट

क्या आप वाकई इसे अपने दम पर आंकना नहीं चाहते हैं?
मिच श्वार्ट्ज

@ मिचस्चवार्ट्ज हाहा मैं पहले ही कोशिश कर चुका हूं। मुझे व्हॉट्सएप के लिए रूबी की आवश्यकताएं बहुत मूर्खतापूर्ण लगती हैं। अवधि के लिए अजीब आवश्यकताएं एक पूरी अन्य समस्या है। मेरे पास कई सिद्धांत हैं लेकिन उनमें से सभी गलत हो सकते हैं। मुझे संदेह है कि इसे ==एक ऑपरेटर के बजाय एक विधि के रूप में व्यवहार करने के साथ कुछ करना पड़ सकता है , लेकिन प्रतीकों द्वारा खोज असंभव है।
लेवल रिवर सेंट।

आपको सही से शक हुआ। :) यह सिर्फ एक सादे पुराने तरीके की कॉल है।
मिच श्वार्ट्ज

5

हास्केल, 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 बाइट्स बचाए। धन्यवाद!


के साथ cycle "TCG_A" भी काम करता है। :)
मथियास डोलिडॉन


4

जूलिया, 47 38 बाइट्स

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

यह एक अनाम फ़ंक्शन है जो किसी Charसरणी को स्वीकार करता है और एक बूलियन देता है। इसे कॉल करने के लिए, इसे किसी वैरिएबल पर असाइन करें।

यह डेनिस एल्गोरिथ्म का उपयोग करता है, जो भोले समाधान से छोटा है। हम 8 से विभाजित प्रत्येक कोड बिंदु के शेष भाग को जोड़ते हैं, जो कि उलट जाता है, 5 से विभाजन से अवशेष प्राप्त करें, और जांचें कि क्या सभी 0. 0. अंतिम चरण का उपयोग करके पूरा किया गया है , का इन्फिक्स संस्करण issubset, जो दोनों तर्कों को पूरा करता है। Setजाँच करने से पहले। इसका मतलब यह है कि के बाद [0,0,0]से 0, का एक सबसेट घोषित किया गया है Set([0,0,0]) == Set(0)। यह 0 के मुकाबले एक स्पष्ट जांच से कम है।

इसे ऑनलाइन आज़माएं!

डेनिस के लिए 9 बाइट्स बचाए गए!





3

ओरेकल SQL 11.2, 68 बाइट्स

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

2
एसक्यूएल के साथ, मुझे विश्वास है कि आपने मेरी कुछ परियोजनाओं के लिए पहले रिपोर्ट लिखी होगी ...
corsiKa

3

जूलिया 0.4, 22 बाइट्स

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

स्ट्रिंग में नियंत्रण अक्षर EOT (4) और NAK (21) हैं। इनपुट एक चरित्र सरणी के रूप में होना चाहिए।

यह दृष्टिकोण इनपुट के पात्रों को उलटे इनपुट में संबंधित वर्णों के साथ XORs करता है। मान्य युग्मों के लिए, यह अक्षर EOT या NAK में परिणाम करता है। उन पात्रों की स्ट्रिंग में शामिल करने के लिए परीक्षण वांछित बुलियन का उत्पादन करता है।

इसे ऑनलाइन आज़माएं!


3

सी, 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 बाइट्स। लोअरकेस इनपुट के लिए अडैप्टिंग द्वारा सहेजे गए अतिरिक्त 2 बाइट्स: स्थिरांक 37और 21संशोधित किए जाते हैं 5और 2

सी, 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;}

एक बाइट को सहेजा गया: दो ASCII कोड mod 37 के उत्पाद को लेते हुए कोष्ठक को हटा दिया। वैध जोड़े 21 का मूल्यांकन करते हैं। अपरकेस इनपुट मानता है।

सी, 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 के हैं। जब मॉड 11 लिया जाता है, तो ये एकमात्र जोड़े होते हैं जो 6. से अधिक होते हैं। अपरकेस इनपुट मान लेते हैं।

परीक्षण कार्यक्रम में अपुष्ट

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;}बाइट्स के एक जोड़े को बचाता है।
डेनिस

@ डेनिस धन्यवाद, मैं वास्तव में पॉइंटर्स को संशोधित करने के मूड में नहीं था, लेकिन इसने एक बाइट को निचोड़ लिया! मुझे खुद देखना चाहिए था !=> ^। मैंने लोअरकेस इनपुट में बदलाव करके एक और 2 घटाया: दोनों मैजिक नंबर अब सिंगल डिजिट के हैं।
लेवल रिवर सेंट

3

फैक्टर , 72 बाइट्स

दुर्भाग्य से रेगेक्स यहाँ मेरी मदद नहीं कर सकता।

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

रिवर्स, लुकअप टेबल, बराबर की तुलना करें।


वाह, बहुत सारा व्हाट्सएप !!! क्या यह सब आवश्यक है? इसके अलावा, भाषा मुखपृष्ठ का लिंक उपयोगी होगा।
लेवल रिवर सेंट

@LevelRiverSt दुर्भाग्य से, इसके हर बिट आवश्यक है। मैं शीर्ष लेख के लिए एक लिंक जोड़ूंगा।
बिल्ली

3

बैश + कोरुटिल्स, 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

3

जे - 21 बाइट्स

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

डेनिस की पद्धति पर आधारित है

प्रयोग

   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

3

भूलभुलैया , 42 बाइट्स

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

एक विभाजन-दर-शून्य त्रुटि (STDERR पर त्रुटि संदेश) के साथ निर्देश।

इसे ऑनलाइन आज़माएं!

लेआउट वास्तव में अक्षम लगता है, लेकिन मैं अभी इसे गोल्फ के लिए एक रास्ता नहीं देख रहा हूं।

व्याख्या

यह समाधान डेनिस की अंकगणितीय चाल पर आधारित है: सभी वर्ण कोड मोडुलो लें 8, दोनों सिरों से एक जोड़ी जोड़ें और सुनिश्चित करें कि यह विभाज्य है 5

भूलभुलैया प्राइमर:

  • लैब्रिंथ में मनमाने ढंग से सटीक पूर्णांक, मुख्य और ऑक्स (इलरी) के दो ढेर होते हैं, जो शुरू में शून्य (अनंत) अनंत राशि से भरे होते हैं।
  • स्रोत कोड एक भूलभुलैया जैसा दिखता है, जहां निर्देश सूचक (आईपी) गलियारों का अनुसरण करता है जब यह (यहां तक ​​कि कोनों के आसपास भी) हो सकता है। कोड पढ़ने के क्रम में पहले वैध चरित्र से शुरू होता है, अर्थात इस मामले में शीर्ष बाएं कोने में। जब आईपी जंक्शन के किसी भी रूप में आता है (यानी इसके अलावा कई आसन्न कोशिकाएं), तो यह मुख्य स्टैक के शीर्ष के आधार पर एक दिशा लेगा। बुनियादी नियम हैं: नकारात्मक होने पर बाएं मुड़ें, शून्य होने पर आगे बढ़ते रहें, सकारात्मक होने पर दाएं मुड़ें। और जब इनमें से एक भी संभव नहीं है क्योंकि दीवार है, तो आईपी विपरीत दिशा में ले जाएगा। मृत सिरों को मारते समय आईपी भी घूमता है।
  • अंकों को मुख्य स्टैक के शीर्ष 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.

आईपी ​​अब एक जंक्शन पर है जो 5. से विभाज्यता का परीक्षण करने के लिए एक शाखा के रूप में कार्य करता है। यदि मोड्यूलो का परिणाम गैर-शून्य है, तो हम जानते हैं कि इनपुट एक वाटसन-क्रिक पैलिंड्रोम नहीं है और हम पूर्व की ओर मुड़ते हैं:

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

अन्यथा, हमें शेष इनपुट की जांच करते रहना होगा, इसलिए आईपी दक्षिण की ओर जाता है। {शेष इनपुट के निचले हिस्से में खींचती है। यदि हमने इनपुट समाप्त कर दिया है, तो यह एक 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.

अन्यथा, जाँच किए जाने वाले स्ट्रिंग में अधिक वर्ण हैं। आईपी ​​पश्चिम की ओर मुड़ता है और अगले (दक्षिणावर्त) 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और फिर =ढेर की सबसे ऊपर अदला-बदली, लेकिन यह सिर्फ पहली रद्द करने के लिए है =, पाश में क्योंकि अब हम एक अलग स्थान में पाश में प्रवेश कर रहे हैं। धोये और दोहराएं।


3

एसईडी, 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'

यदि आप इसे 61 बाइट्स में कर सकते हैं, तो यह आपका स्कोर है - इस विशेष चुनौती पर एनएफए या ट्यूरिंग-पूर्ण रेगेक्स के खिलाफ कुछ भी नहीं है। कुछ चुनौतियाँ रेगेक्स को पूर्ण रूप से अस्वीकार कर देती हैं, लेकिन आमतौर पर केवल रेगेक्स-गोल्फ गैर- नियमित जांच को समाप्त कर देगा ।
बिल्ली

3

सी #, 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 फ्रेमवर्क नाम हैं।

संपादित करें: समाधान से कुछ सीमित "बॉयलरप्लेट" को छोड़ना और कुछ स्थितियों को जोड़ना हमें अभिव्यक्ति के साथ छोड़ देता है

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

जो 0 देता है और केवल अगर स्ट्रिंग s एक वैध उत्तर है। जैसा कि बिल्ली बताती है, "बूल एफ (स्ट्रिंग एस) =>" वास्तव में "एस =>" के साथ बदली है यदि यह कोड में अन्यथा स्पष्ट है कि अभिव्यक्ति एक है Func<string,bool>, अर्थात। एक स्ट्रिंग एक बूलियन को मैप करता है।


1
PPCG में आपका स्वागत है, अच्छा पहला जवाब! : D
बिल्ली

@cat इसके लिए धन्यवाद! :)
रॉथोल

1
मैं वास्तव में C # नहीं जानता, लेकिन अगर यह लंबोदर है, तो आप इसके प्रकार को छोड़ सकते हैं और इसे असाइन कर सकते हैं, क्योंकि जब तक वे कार्य करने में सक्षम नहीं होते हैं तब तक अनाम कार्य ठीक हैं ।
बिल्ली

1
इसके अलावा, आप के !s.Zip...बजाय नहीं कर सकते s.Zip...==0? (या आप !C # में स्याही नहीं लगा सकते ?) भले ही आप इसे गलत नहीं कह सकते हों, लेकिन आप अपने जवाब में किसी भी प्रकार का उलटा और स्टेट छोड़ सकते हैं कि यह रिटर्न <<चीज> फर्जी के लिए और <यह अन्य निर्धारक है, स्पष्ट रूप से समझ में आने वाली बात> सत्य के लिए।
बिल्ली

1
@ कोट: आप टाइप छोड़ने के बारे में सही हैं। मैंने सोचा कि कोड को सीधे निष्पादन योग्य होना चाहिए, लेकिन इनपुट और आउटपुट के बारे में सरल धारणाएं बनाना थोड़ा आसान है। हालांकि, दूसरी बात काम नहीं करेगी - ठीक है, मेरी राय में, चूंकि एक बूलियन ऑपरेशन में नंबर पर लागू करने का कोई तार्किक (ह्यू) तरीका नहीं है। झूठे और सच्चे के मूल्यों को 0 और 1 को सौंपना, आखिरकार, केवल सम्मेलन है।
रॉभोल

2

आरईएक्सएक्स 37

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

2

आर, 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

strsplit(x,"")[[1]]3 बाइट्स की तुलना में छोटा है unlist(strsplit(x,"")), यहाँ, बराबर है क्योंकि xहमेशा चरित्र का एक ही तार होता है।
प्लेनैपस

2

ऑक्टेव, 52 बाइट्स

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

डेनिस की चाल के बाद ... एएससीआईआई मान 8 मॉड ले लो, फ्लिप करें और एक साथ जोड़ें; यदि हर राशि पांच से अधिक है, तो आप सुनहरे हैं।


यह एक व्हाट्सएप महत्वपूर्ण है? अजीब है कि।
बिल्ली

इसके अलावा, आप f=असाइनमेंट छोड़ सकते हैं ; अनाम कार्य ठीक हैं।
बिल्ली

1

क्लोजर / क्लोजुरस्क्रिप्ट, 49 वर्ण

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

तार पर काम करता है। यदि आवश्यकताओं को सूचियों की अनुमति देने के लिए ढीला किया जाता है, तो मैं (list* )7 चार्ट को हटा सकता हूं और बचा सकता हूं ।


1

आर, 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

1

सी, 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यदि वे मेल नहीं खाते हैं , तो प्रत्येक चरण में, हम संबंधित वर्णों की तुलना करते हैं, यह सच है। मिलान चरित्र मूल्यों के XOR पर आधारित है:

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

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

हम उपरोक्त तालिका में देख सकते हैं कि हम xx10xकिसी अन्य चीज़ के लिए सफलता और असफलता को रिकॉर्ड करना चाहते हैं , इसलिए हम 00100(चार) और 00110(छह) के साथ मुखौटा XOR के साथ शून्य ATया CGगैर-शून्य के लिए प्राप्त करना चाहते हैं। अंत में, हम सच में लौटते हैं यदि सभी जोड़े शून्य परिणाम जमा करते हैं b, अन्यथा गलत।

परीक्षण कार्यक्रम:

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

1

S, 13 चार्ट / 17 बाइट्स

⟮ïĪ`ACGT”⟯ᴙ≔Ⅰ

Try it here (Firefox only).

व्याख्या

इनपुट से ट्रांसलेट ACGTकरें TGCAऔर जांचें कि क्या परिणामी स्ट्रिंग एक पैलिंड्रोम है।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.