DNA golfüne metin

Meydan okuma

Bir DNA çıkışına girişi dönüştürün.

Algoritma

• Metni ASCII kod noktalarına dönüştürün (örneğin codegolf-> [99, 111, 100, 101, 103, 111, 108, 102])
• ASCII kodlarını birlikte yazın (örn. 99111100101103111108102)
• İkili dosyaya dönüştür (örn. 10100111111001101001011010001000011001101011011110000110010111111011000000110)
• Tampon 0(örneğin karakter eşit sayıda yapmak ucuna s 101001111110011010010110100010000110011010110111100001100101111110110000001100)
• Değiştir 00ile A, 01birlikte C, 10ile G, ve 11ile T(örneğin GGCTTGCGGCCGGAGACGCGGTCTGACGCCTTGTAAATA)
• Çıktı

Test Kılıfları

codegolf > GGCTTGCGGCCGGAGACGCGGTCTGACGCCTTGTAAATA
ppcg > GGCTAATTGTCGCACTT
} > TTGG (padding)

Özellikler

• Bu kod golfü
• Programınız girilen boşlukları kabul etmelidir.
• Programınız için çalışmalıdır codegolf.

Jöle , 15 13 bayt

OVBs2UḄị“GCTA

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

Nasıl çalışır

OVBs2UḄị“GCTA    Main link. Argument: s (string)

O                Ordinal; replace each character with its code point.
 V               Eval. This converts the list to a string before evaluating, so it
                 returns the integer that results of concatenating all the digits.
  B              Binary; convert from integer to base 2.
   s2            Split into chunks of length 2.
     U           Upend; reverse the digits of each chunk.
                 Reversing means that we would have to conditionally PREPEND a zero
                 to the last chunk, which makes no difference for base conversion.
      Ḅ          Unbinary; convert each chunk from base 2 to integer.
                 `UḄ' maps:
                     [0, 1   ] -> [1,    0] -> 2
                     [1, 0(?)] -> [0(?), 1] -> 1
                     [1, 1   ] -> [1,    1] -> 3
                     [0, 0(?)] -> [0(?), 0] -> 0
       ị“GCTA    Replace each number by the character at that index.
                 Indexing is 1-based, so the indices are [1, 2, 3, 0].

CJam, 24 23 bayt

1 baytı gerçekten zekice kaydettiği için Dennis'e teşekkürler. :)

l:isi2b2/Wf%2fb"AGCT"f=

Burada test et.

açıklama

Şartnamenin çok doğrudan uygulanması. Tek ilginç bit (hatta Dennis'in fikriydi) eşit sayıda sıfır doldurmak. Her çiftteki rakamları olağan sırayla ele almak yerine, ikinci ucu en belirgin olanı yaparız. Bunun anlamı, tek bir bitle bitmek, ona sıfır eklemekle aynıdır, yani sıfırı hiç eklememiz gerekmez.

l          e# Read input.
:i         e# Convert to character codes.
si         e# Convert to flat string and back to integer.
2b         e# Convert to binary.
2/         e# Split into pairs.
Wf%        e# Reverse each pair.
2fb        e# Convert each pair back from binary, to get a value in [0 1 2 3].
"AGCT"f=   e# Select corresponding letter for each number.

Python 2, 109 103 bayt

lambda s,j=''.join:j('ACGT'[int(j(t),2)]for t in
zip(*[iter(bin(int(j(`ord(c)`for c in s))*2)[2:])]*2))

İdeone üzerinde test et .

Ruby, 59 bayt

$_='%b0'.%$_.bytes*''
gsub(/../){:ACGT[$&.hex%7]}
chomp'0'

Tam bir program. -pBayrakla koş .

Python 3, 130 bayt.

Vaultah sayesinde 2 bayt kurtarıldı.
Kevin Lau sayesinde 6 byte kurtarıldı - Kenny değil.

Python'da ikiliye dönüştürmenin zorluğundan nefret ediyorum.

def f(x):c=bin(int(''.join(map(str,map(ord,x)))))[2:];return''.join('ACGT'[int(z+y,2)]for z,y in zip(*[iter(c+'0'*(len(c)%2))]*2))

Test durumları:

assert f('codegolf') == 'GGCTTGCGGCCGGAGACGCGGTCTGACGCCTTGTAAATA'
assert f('ppcg') == 'GGCTAATTGTCGCACTT'

Ruby, 80 bayt

->s{s=s.bytes.join.to_i.to_s 2;s+=?0*(s.size%2)
s.gsub(/../){"ACGT"[$&.to_i 2]}}

Mathematica, 108 bayt

{"A","C","G","T"}[[IntegerDigits[Mod[Floor@Log2@#,2,1]#&@FromDigits[""<>ToString/@ToCharacterCode@#],4]+1]]&

Girdi olarak bir dize alır ve bir taban listesi çıkarır.

Python 3, 126 bayt

lambda v:"".join(["ACGT"[int(x,2)]for x in map(''.join,zip(*[iter((bin(int("".join([str(ord(i))for i in v])))+"0")[2:])]*2))])

Pyth, 25 bayt

sm@"ACGT"id2Pc.B*4sjkCMQ2

Burada dene!

açıklama

Martins CJam'in cevabını doldurma hilesini oymak .

sm @ "ACGT" id2Pc.B * 4sjkCMQ2 # Q = giriş

                     CMQ # Her Q karakterini karakter koduyla eşleyin
                  sjk # Bir dizgeye katılın ve bir tamsayıya dönüştürün
              .B * 4 # 4 ile mulitply ve ikiliye dönüştürür
             c 2 # Çiftlere ayrıl
            P # Son çifti sil
 m # Her çifti eşleştir d
         id2 # Çifti ikiliden ondalıkya dönüştür
  @ "ACGT" # sonucunu ^ bir arama dizgisine indeks olarak kullanın
s # Sonuç listesine dize olarak katıl

05AB1E , 23 bayt

Kod:

SÇJb00«2÷¨C3210"TGCA"‡á

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

Java, 194 bayt

String a(int[]a){String s="",r=s;for(int i:a)s+=i;s=new BigInteger(s).toString(2)+0;for(int i=0,y,n=48;i<(s.length()/2)*2;r+=s.charAt(i++)==n?y==n?'A':'G':y==n?'C':'T')y=s.charAt(i++);return r;}

Ungolfed

String a(int[] a) {
    String s = "", r = s;
    for (int i : a) s += i;
    s = new BigInteger(s).toString(2) + 0;
    for (int i = 0, y, n = 48; i < (s.length() / 2) * 2; 
        r += s.charAt(i++) == n 
                 ? y == n 
                 ? 'A' 
                 : 'G' 
                 : y == n 
                 ? 'C' 
                 : 'T')
        y = s.charAt(i++);
    return r;
}

Not

• Giriş (bir String biçiminde sayılması gereken) bir karakter dizisidir, parametre bu türdür int[]çünkü bir byte kaydedilmiştir char[].

Çıktı

Input:  codegolf
Output: GGCTTGCGGCCGGAGACGCGGTCTGACGCCTTGTAAATA

Input:  .
Output: GTG

Input:  }
Output: TTGG

Input:  wow
Output: TGATAGTTGTGCTG

Input:  programming puzzles
Output: GTGTCAGAGTTGAAGGCCGTTCCGCAGTGCATTTGGCTCGTCTGGTGTCTACTAGCCTGCGAGAGGAGTTACTTTGGATCCTTGACTTGT

MATL , 21 bayt

'CGTA'joV4Y2HZa2e!XB)

Çevrimiçi deneyin!

açıklama

'CGTA'   % Push string to be indexed into
j        % Take input string
o        % Convert each char to its ASCII code
V        % Convert to string (*). Numbers are separated by spaces
4Y2      % Push the string '0123456789'
H        % Push number 2
Za       % Convert string (*) from base '0123456789' to base 2, ignoring spaces
2e       % Reshape into a 2-column matrix, padding with a trailing 0 if needed
!        % Transpose
XB       % Convert from binary to decimal
)        % Index into string with the DNA letters. Indexing is 1-based and modular

Pyth , 23 bayt

sm@"AGCT"i_d2c.BsjkCMQ2

Çevrimiçi deneyin!

açıklama

Numarayı Dennis'in Jelly cevabından ödünç alıyor .

sm@"AGCT"i_d2c.BsjkCMQ2
                   CMQ   convert each character to its byte value
                sjk      convert to a string and then to integer
              .B         convert to binary
             c        2  chop into pairs
 m         d             for each pair:
          _                  reverse it
         i  2                convert from binary to integer
  @"AGCT"                    find its position in "AGCT"
s                        join the string

Groovy, 114 bayt

{s->'ACGT'[(new BigInteger(((Byte[])s).join())*2).toString(2).toList().collate(2)*.with{0.parseInt(it.join(),2)}]}

Açıklama:

{s->
    'ACGT'[ //access character from string
        (new BigInteger( //create Big Integer from string
           ((Byte[])s).join() //split string to bytes and then join to string
        ) * 2) //multiply by 2 to add 0 at the end in binary
        .toString(2) //change to binary string
        .toList() //split to characters
        .collate(2) //group characters by two
        *.with{
            0.parseInt(it.join(),2) //join every group and parse to decimal
        }
     ]
}

Julia 0.4, 77 bayt

s->replace(bin(BigInt(join(int(s)))),r"..?",t->"AGCT"[1+int("0b"reverse(t))])

Bu anonim işlev bir karakter dizisini girdi olarak alır ve bir dize döndürür.

Çevrimiçi deneyin!

Python 2.7, 135 bayt

def f(A):g=''.join;B=bin(int(g(map(str,map(ord,A)))))[2:];B+=len(B)%2*'0';return g('ACGT'[int(B[i:i+2],2)] for i in range(len(B))[::2])

Ungolfed:

def f(A):
    g = ''.join
    B = bin(int(g(map(str,map(ord,A)))))[2:] # convert string input to binary
    B += len(B)%2 * '0' # add extra 0 if necessary
    return g('ACGT'[int(B[i:i+2],2)] for i in range(len(B))[::2]) # map every two characters into 'ACGT'

Çıktı

f('codegolf')
'GGCTTGCGGCCGGAGACGCGGTCTGACGCCTTGTAAATA'

Javascript ES7, 105 103 bayt

s=>((+[for(c of s)c.charCodeAt()].join``).toString(2)+'0').match(/../g).map(x=>"ACGT"['0b'+x-0]).join``

ES7 kısmı ise for(c of s)parçadır.

ES6 sürümü, 107 105 bayt

s=>((+[...s].map(c=>c.charCodeAt()).join``).toString(2)+'0').match(/../g).map(x=>"ACGT"['0b'+x-0]).join``

Ungolfed kod

dna = (str)=>{
  var codes = +[for(c of str)c.charCodeAt()].join``;
  var binaries = (codes.toString(2)+'0').match(/../g);
  return binaries.map(x=>"ACGT"['0b'+x-0]).join``
}

Bu PPCG'de golf oynamayı ilk denemem, yanlış bir şey olursa beni düzeltmekte özgürsün.

Küçük gelişme için @AlexA teşekkürler.

J, 52 bayt

 3 :'''ACGT''{~#._2,\#:".,&''x''":(,&:(":"0))/3&u:y'

Kullanım: 3 :'''ACGT''{~#._2,\#:".,&''x''":(,&:(":"0))/3&u:y' 'codegolf'==>GGCTTGCGGCCGGAGACGCGGTCTGACGCCTTGTAAATA

Ortak Lisp (Lispworks), 415 bayt

(defun f(s)(labels((p(e f)(concatenate'string e f)))(let((b"")(d""))(dotimes(i(length s))(setf b(p b(write-to-string(char-int(elt s i))))))(setf b(write-to-string(parse-integer b):base 2))(if(oddp #1=(length b))(setf b(p b"0")))(do((j 0(+ j 2)))((= j #1#)d)(let((c(subseq b j(+ j 2))))(cond((#2=string="00"c)(setf d(p d"A")))((#2#"01"c)(setf d(p d"C")))((#2#"10"c)(setf d(p d"G")))((#2#"11"c)(setf d(p d"T")))))))))

ungolfed:

(defun f (s)
  (labels ((p (e f)
             (concatenate 'string e f)))
  (let ((b "") (d ""))
    (dotimes (i (length s))
      (setf b
            (p b
               (write-to-string
                (char-int (elt s i))))))
    (setf b (write-to-string (parse-integer b) :base 2))
    (if (oddp #1=(length b))
        (setf b (p b "0")))
      (do ((j 0 (+ j 2)))
          ((= j #1#) d)
        (let ((c (subseq b j (+ j 2))))
          (cond ((#2=string=  "00" c)
                 (setf d (p d "A")))
                ((#2# "01" c)
                 (setf d (p d "C")))
                ((#2# "10" c)
                 (setf d (p d "G")))
                ((#2# "11" c)
                 (setf d (p d "T")))))))))

Kullanımı:

CL-USER 2060 > (f "}")
"TTGG"

CL-USER 2061 > (f "golf")
"TAAAAATTATCCATAAATA"

Perl, 155 148 137 + 1 ( -pbayrak) = 138 bayt

#!perl -p
s/./ord$&/sge;while($_){/.$/;$s=$&%2 .$s;$t=$v="";$t.=$v+$_/2|0,$v=$_%2*5
for/./g;s/^0// if$_=$t}$_=$s;s/(.)(.)?/([A,C],[G,T])[$1][$2]/ge

İdeone üzerinde test et .

Perl 6, 57 + 1 ( -pbayrak) = 58 bayt

$_=(+[~] .ords).base(2);s:g/..?/{<A G C T>[:2($/.flip)]}/

Adım adım açıklama:

-pflag, Perl 6 yorumlayıcısının kod satırını satır satır çalıştırmasına, geçerli satır $_koyup sonunda geri koymasına neden olur $_.

.ords- Bir süre önce hiçbir şey yoksa, bir yöntem çağrılır $_. ordsyöntemi bir dizedeki kod noktalarının listesini döndürür.

[~]- []redüksiyon operatörünü braketler arasında depolayan bir redüksiyon operatörüdür. Bu durumda, ~bir dize bitiştirme işlecidir. Örneğin [~] 1, 2, 3, eşdeğerdir 1 ~ 2 ~ 3.

+Argümanını bir sayıya çevirir, çünkü baseyöntem sadece tamsayılar için tanımlanır.

.base(2) - bir tamsayıyı taban 2'deki dizgeye dönüştürür

$_=- sonucu atar $_.

s:g/..?/{...}/- Bu, regex'in herhangi bir ( :g, global mod) örneğini ..?(bir veya iki karakter) değiştiren düzenli bir ifadedir . İkinci argüman bu durumda kodda (Perl 6'da, dizgelerde küme parantezleri ve değiştirme desenleri kod olarak yürütülür) bir değiştirme modelidir.

$/ - bir regex eşleşme değişkeni

.flip- bir dizgeyi ters çevirir. Örtülü olarak $/(bir regex eşleme nesnesi) bir dizeye dönüştürür. Bunun sebebi , aksine tek bir karakterin 1genişletilmesi gerektiğidir . Bu çevirme nedeniyle, dizideki öğelerin sırası G ve C'yi tersine çevirdi.1001

:2(...) - bir baz-2 dizesini bir tamsayıya ayrıştırır

<A G C T> - dört element dizisi.

...[...] - dizi erişim operatörü.

Bu ne anlama geliyor? Program bir dizgideki tüm kod noktalarının bir listesini alır, onları bir araya getirir, onları 2 tabanına dönüştürür. Sonra, bir sayının çevrilmiş temsiline bağlı olarak iki ya da bir karakterin tüm örneklerini A, G, C, T harflerinden birine değiştirir. İkili olarak

Hoon , 148 138 bayt

|*
*
=+
(scan (reel +< |=({a/@ b/tape} (weld <a> b))) dem)
`tape`(flop (turn (rip 1 (mul - +((mod (met 0 -) 2)))) |=(@ (snag +< "ACGT"))))

"abc" bir atom listesidir. <a>Listede katlanırken bunları yeni bir dizeye birleştirerek dizgilere ( ) yerleştirin. Numarayı ayrıştır++dem geri almak .

Dolgu yapmak için sayıyı (bit cinsinden uzunluk + 1)% 2 ile çarpın. Kullanım ++rip, bir liste halinde atomun her iki bayt çifti sökmek liste üzerinde harita ve dize "ACGT" dizin olarak numarayı kullanmak.

> =a |*
  *
  =+
  (scan (reel +< |=({a/@ b/tape} (weld <a> b))) dem)
  `tape`(flop (turn (rip 1 (mul - +((mod (met 0 -) 2)))) |=(@ (snag +< "ACGT"))))
> (a "codegolf")
"GGCTTGCGGCCGGAGACGCGGTCTGACGCCTTGTAAATA"
> (a "ppcg")
"GGCTAATTGTCGCACTT"
> (a "}")
"TTGG"