Teks ke DNA golf

Tantangan

Ubah input menjadi output DNA.

Algoritma

• Konversi teks menjadi poin kode ASCII (mis codegolf- - [99, 111, 100, 101, 103, 111, 108, 102])
• Rangkai kode ASCII bersama (mis. 99111100101103111108102)
• Konversikan ke biner (mis. 10100111111001101001011010001000011001101011011110000110010111111011000000110)
• Pad 0s ke ujung untuk membuat jumlah karakter genap (mis. 101001111110011010010110100010000110011010110111100001100101111110110000001100)
• Ganti 00dengan A, 01dengan C, 10dengan G, dan 11dengan T(misalnya GGCTTGCGGCCGGAGACGCGGTCTGACGCCTTGTAAATA)
• Keluaran

Uji Kasus

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

Spesifikasi

• Ini adalah kode-golf
• Program Anda harus menerima spasi dalam input.
• Program Anda harus bekerja codegolf.

Jelly , 15 13 byte

OVBs2UḄị“GCTA

Cobalah online! atau verifikasi semua kasus uji .

Bagaimana itu bekerja

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 byte

Terima kasih kepada Dennis karena telah menghemat 1 byte dengan cara yang sangat pintar. :)

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

Uji di sini.

Penjelasan

Implementasi spesifikasi yang sangat langsung. Satu-satunya yang menarik adalah padding ke angka nol (yang sebenarnya adalah ide Dennis). Alih-alih memperlakukan digit pada masing-masing pasangan dalam urutan yang biasa, kami membuat bit kedua yang paling signifikan. Itu berarti, mengakhiri dengan bit tunggal identik dengan menambahkan nol padanya, yang berarti kita tidak harus menambahkan nol sama sekali.

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 byte

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

Uji di Ideone .

Ruby, 59 byte

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

Program lengkap. Jalankan dengan -pbendera.

Python 3, 130 byte.

Disimpan 2 byte berkat vaultah.
Disimpan 6 byte berkat Kevin Lau - bukan Kenny.

Aku benci betapa sulitnya untuk mengkonversi ke biner dengan python.

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

Kasus uji:

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

Ruby, 80 byte

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

Mathematica, 108 byte

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

Mengambil string sebagai input, dan menampilkan daftar basis.

Python 3, 126 byte

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 byte

sm@"ACGT"id2Pc.B*4sjkCMQ2

Coba di sini!

Penjelasan

Membongkar trik padding dari jawaban Martins CJam .

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

                     CMQ # Memetakan setiap karakter Q ke kode karakternya
                  sjk # Bergabung menjadi satu string dan konversikan ke integer
              .B * 4 # Mulitply dengan 4 dan konversikan ke biner
             c 2 # Membagi menjadi pasangan
            P # Buang pasangan terakhir
 m # Memetakan setiap pasangan d
         id2 # Konversi pasangan dari biner ke desimal
  @ "ACGT" # Gunakan hasilnya ^ sebagai indeks ke dalam string pencarian
s # Gabung daftar yang dihasilkan ke dalam string

05AB1E , 23 byte

Kode:

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

Menggunakan pengodean CP-1252 . Cobalah online! .

Java, 194 byte

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

Tidak disatukan

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

Catatan

• Input adalah array karakter (yang harus dihitung sebagai bentuk String), parameter bertipe int[]karena satu byte disimpan char[].

Keluaran

Input:  codegolf
Output: GGCTTGCGGCCGGAGACGCGGTCTGACGCCTTGTAAATA

Input:  .
Output: GTG

Input:  }
Output: TTGG

Input:  wow
Output: TGATAGTTGTGCTG

Input:  programming puzzles
Output: GTGTCAGAGTTGAAGGCCGTTCCGCAGTGCATTTGGCTCGTCTGGTGTCTACTAGCCTGCGAGAGGAGTTACTTTGGATCCTTGACTTGT

MATL , 21 byte

'CGTA'joV4Y2HZa2e!XB)

Cobalah online!

Penjelasan

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

sm@"AGCT"i_d2c.BsjkCMQ2

Cobalah online!

Penjelasan

Meminjam trik dari jawaban Dennis 'Jelly .

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 byte

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

Penjelasan:

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

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

Fungsi anonim ini mengambil array karakter sebagai input dan mengembalikan string.

Cobalah online!

Python 2.7, 135 byte

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

Tidak Disatukan:

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'

Keluaran

f('codegolf')
'GGCTTGCGGCCGGAGACGCGGTCTGACGCCTTGTAAATA'

Javascript ES7, 105 103 byte

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

Bagian ES7 adalah for(c of s)bagiannya.

Versi ES6, 107 105 byte

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

Kode tidak dikunci

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

Ini adalah percobaan pertama saya bermain golf di PPCG, jangan ragu untuk mengoreksi saya jika ada sesuatu yang salah.

Terima kasih @AlexA untuk perbaikan kecilnya.

J, 52 byte

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

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

Gangguan Umum (Lispworks), 415 byte

(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")))))))))

Pemakaian:

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

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

Perl, 155 148 137 + 1 ( -pflag) = 138 byte

#!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

Uji di Ideone .

Perl 6, 57 +1 ( -pbendera) = 58 byte

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

Penjelasan langkah demi langkah:

-pflag menyebabkan penerjemah Perl 6 menjalankan kode baris demi baris, meletakkan baris saat ini $_, dan pada akhirnya mengembalikannya $_.

.ords- Jika tidak ada sebelum periode, suatu metode dipanggil $_. ordsmetode mengembalikan daftar codepoint dalam sebuah string.

[~]- []adalah operator reduksi, yang menyimpan operator reduksi di antara kurung. Dalam hal ini, itu ~, yang merupakan operator penggabungan string. Misalnya, [~] 1, 2, 3setara dengan1 ~ 2 ~ 3 .

+mengubah argumennya menjadi angka, diperlukan karena basemetode hanya didefinisikan untuk bilangan bulat.

.base(2) - Mengonversi bilangan bulat ke string di basis 2

$_=- Menugaskan hasilnya ke $_.

s:g/..?/{...}/- ini adalah ekspresi reguler yang menggantikan setiap :ginstance ( , mode global) regex ..?(satu atau dua karakter). Argumen kedua adalah pola penggantian, yang dalam hal ini dalam kode (dalam Perl 6, kurung keriting dalam string dan pola penggantian dijalankan sebagai kode).

$/ - variabel pencocokan regex

.flip- membalikkan sebuah string. Secara implisit mengkonversi $/(objek pencocokan regex) ke string. Ini karena satu karakter 1harus diperluas ke 10, sebagai lawan01 . Karena flip itu, urutan elemen dalam array memiliki G dan C terbalik.

:2(...) - mem-parsing string basis-2 ke dalam integer.

<A G C T> - Array empat elemen.

...[...] - Operator akses array.

Apa artinya? Program mendapatkan daftar semua codepoint dalam sebuah string, menggabungkannya bersama-sama, mengubahnya menjadi basis 2. Kemudian, ia mengganti semua instance dari dua atau satu karakter menjadi salah satu huruf A, G, C, T tergantung pada penggambaran representasi angka yang terbalik. dalam biner.

Hoon , 148 138 byte

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

"abc" adalah daftar atom. Interpolasi mereka menjadi string ( <a>) sambil melipat daftar, bergabung bersama menjadi string baru. Pisahkan nomor dengan ++demuntuk mengembalikannya ke atom.

Lipat gandakan angka dengan (panjang bitwise + 1)% 2 untuk memasangnya. Gunakan ++ripuntuk membongkar setiap pasangan dua byte atom ke dalam daftar, memetakan daftar dan menggunakan nomor sebagai indeks ke dalam string "ACGT".

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