DNA 골프 텍스트

도전

입력을 DNA 출력으로 변환합니다.

연산

• 텍스트를 ASCII 코드 포인트로 변환 (예 : codegolf-> [99, 111, 100, 101, 103, 111, 108, 102])
• 문자열 함께 ASCII 코드 (예를 들어 99111100101103111108102)
• 바이너리로 변환 (예를 들어 10100111111001101001011010001000011001101011011110000110010111111011000000110)
• 패드 0(예를 들어, 문자의 짝수를 만들기 위해 마지막에이야 101001111110011010010110100010000110011010110111100001100101111110110000001100)
• 교체 00와 A, 01와 C, 10와 G,와 11와 T(예를 들어 GGCTTGCGGCCGGAGACGCGGTCTGACGCCTTGTAAATA)
• 산출

테스트 사례

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

명세서

• 이것은 코드 골프입니다
• 프로그램은 공백을 입력해야합니다.
• 귀하의 프로그램이 작동해야합니다 codegolf.

젤리 , 15 13 바이트

OVBs2UḄị“GCTA

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

작동 원리

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

정말 영리한 방식으로 1 바이트를 절약 해 준 Dennis에게 감사합니다. :)

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

여기에서 테스트하십시오.

설명

사양을 직접 구현합니다. 흥미로운 점은 짝수의 0으로 채워지는 것입니다 (실제로는 Dennis의 아이디어였습니다). 각 쌍의 숫자를 일반적인 순서대로 처리하는 대신 두 번째 비트를 가장 중요하게 만듭니다. 즉, 단일 비트로 끝나는 것은 0을 추가하는 것과 동일하므로 0을 전혀 추가 할 필요가 없습니다.

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.

파이썬 2, 109103 바이트

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

Ideone에서 테스트하십시오 .

루비, 59 바이트

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

전체 프로그램. -p플래그로 실행하십시오 .

파이썬 3, 130 바이트

vaultah 덕분에 2 바이트를 절약했습니다.
Kenny가 아닌 Kevin Lau 덕분에 6 바이트가 절약되었습니다.

파이썬에서 이진으로 변환하는 것이 얼마나 어려운지 싫어.

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

테스트 사례 :

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

루비, 80 바이트

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

수학, 108 바이트

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

문자열을 입력으로 받아서 밑면 목록을 출력합니다.

파이썬 3, 126 바이트

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

sm@"ACGT"id2Pc.B*4sjkCMQ2

여기 사용해보십시오!

설명

Martins CJam 의 패딩 트릭을 차용 .

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

                     CMQ # Q의 각 문자를 문자 코드에 매핑
                  sjk # 하나의 문자열로 결합하여 정수로 변환
              .B * 4 # 4로 Mulitply 및 이진수로 변환
             c 2 # 쌍으로 나누기
            P # 마지막 쌍을 버리십시오
 m # 각 쌍을 매핑합니다 d
         id2 # 쌍을 이진수에서 십진수로 변환
  @ "ACGT"# 결과 ^를 조회 문자열의 색인으로 사용
s # 결과 목록을 문자열에 결합

05AB1E , 23 바이트

암호:

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

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

자바, 194 바이트

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

언 골프

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

노트

• 입력은 문자 배열 (문자열 형식으로 계산되어야 함)이며 매개 변수는 int[]1 바이트 이상 저장 되었기 때문에 유형 char[]입니다.

산출

Input:  codegolf
Output: GGCTTGCGGCCGGAGACGCGGTCTGACGCCTTGTAAATA

Input:  .
Output: GTG

Input:  }
Output: TTGG

Input:  wow
Output: TGATAGTTGTGCTG

Input:  programming puzzles
Output: GTGTCAGAGTTGAAGGCCGTTCCGCAGTGCATTTGGCTCGTCTGGTGTCTACTAGCCTGCGAGAGGAGTTACTTTGGATCCTTGACTTGT

MATL , 21 바이트

'CGTA'joV4Y2HZa2e!XB)

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

설명

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

sm@"AGCT"i_d2c.BsjkCMQ2

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

설명

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

그루비, 114 바이트

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

설명:

{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
        }
     ]
}

줄리아 0.4, 77 바이트

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

이 익명 함수는 문자 배열을 입력으로 받아서 문자열을 반환합니다.

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

파이썬 2.7, 135 바이트

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

언 골프 드 :

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'

산출

f('codegolf')
'GGCTTGCGGCCGGAGACGCGGTCTGACGCCTTGTAAATA'

자바 스크립트 ES7, (105) 103 바이트

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

ES7 파트가 for(c of s)파트입니다.

ES6 버전 107 105 바이트

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

Ungolfed 코드

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

이것은 PPCG에서 골프를 치기위한 첫 번째 시도입니다. 문제가 있으면 언제든지 바로 고쳐주십시오.

작은 개선을 위해 @AlexA에게 감사드립니다.

J, 52 바이트

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

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

공통 리스프 (Lispworks), 415 바이트

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

언 골프 :

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

용법:

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

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

펄 155 148 137 + 1 ( -p플래그) = 138 바이트

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

Ideone에서 테스트하십시오 .

Perl 6, 57 + 1 ( -p플래그) = 58 바이트

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

단계별 설명 :

-pflag는 Perl 6 인터프리터가 코드를 한 줄씩 실행하고, 현재 줄을 $_넣은 다음 다시 시작 $_합니다.

.ords-마침표 이전에 아무것도 없으면 메서드가 호출됩니다 $_. ords메소드는 문자열의 코드 포인트 목록을 리턴합니다.

[~]- []대괄호 사이에 축소 연산자를 저장하는 축소 연산자입니다. 이 경우 ~문자열 연결 연산자 인입니다. 예를 [~] 1, 2, 3들어와 같습니다 1 ~ 2 ~ 3.

+base메소드는 정수에 대해서만 정의 되므로 필요한 인수를 숫자로 변환합니다 .

.base(2) -밑이 2 인 정수를 문자열로 변환

$_=-결과를에 할당합니다 $_.

s:g/..?/{...}/-이것은 정규식의 ( :g, 전역 모드) 인스턴스를 ..?하나 또는 두 개의 문자로 대체하는 정규식 입니다. 두 번째 인수는 대체 패턴이며,이 경우 코드에서 사용됩니다 (Perl 6에서는 문자열의 중괄호와 대체 패턴이 코드로 실행 됨).

$/ -정규식 일치 변수

.flip-문자열을 반전시킵니다. 암시 적으로 $/(정규 일치 객체)를 문자열 로 변환 합니다. 하나의 문자가 있기 때문입니다 1에 확장되어야한다 10반대로, 01. 그 플립으로 인해 배열의 요소 순서는 G와 C가 반대입니다.

:2(...) -밑이 2 인 문자열을 정수로 구문 분석합니다.

<A G C T> -네 요소의 배열.

...[...] -배열 액세스 연산자.

그게 무슨 뜻이야? 이 프로그램은 문자열의 모든 코드 포인트 목록을 가져와 함께 연결하여 기본 2로 변환합니다. 그런 다음 숫자의 뒤집힌 표현에 따라 두 개 또는 한 문자의 모든 인스턴스를 문자 A, G, C, T 중 하나로 바꿉니다. 이진으로.

훈 , (148) 138 바이트

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

"abc"는 원자 목록입니다. <a>목록을 접어 새 문자열로 결합하면서 문자열 ( ) 로 보간합니다 . 숫자를 구문 분석하여 ++dem원자로 되돌립니다.

숫자에 (비트 길이 + 1) % 2를 곱하여 채 웁니다. 사용은 ++rip,리스트로 원자의 매 2 바이트 쌍을 분해 목록을 통해지도하고 문자열 "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"