Java에서 합의 시퀀스를 구현하는 좋은 방법은 무엇입니까?

Question

I는 다음과 같은 문제가있다 :

• I 한두 점이 다르다 DNA 시퀀스 (ACGT 이루어진)의 2 문자열을 갖는다. 차이점을 찾기
• 은 사소한, 그래서 난 그냥 수 알고

모두 가능성을 나타냅니다 그냥 각각의 차이

, 내가 consensus symbol (A 또는 C 예 : M)를 얻고 싶은 것을 무시하자 커다란 인 경우 캐스케이드하지만 추악하고 유지하기가 어려울뿐만 아니라 느려지기도합니다.

구현하기 쉽고 빠르게 유지 보수 할 수있는 방법은 무엇입니까? 어떤 종류의 룩업 테이블일까요, 아니면 조합에 대한 매트릭스일까요? 모든 코드 샘플은 크게 감사하겠습니다. Biojava를 사용했을 것입니다. 그러나 이미 사용하고있는 현재 버전은 해당 기능을 제공하지 않습니다. 또는 아직 찾지 못했습니다.

업데이트 : 여기서 다소 혼란스러워 보입니다. 컨센서스 기호는 두 개의 시퀀스에서 단일 문자를 나타내는 단일 문자입니다.

문자열 1과 문자열 2, 예를 "ACGT"와 "ACCT"에 대한 - 그들은 S는 "C 또는 G 중 하나"

을 의미하기 때문에 나는 합의 문자열 ACST가되고 싶어요, SOOO 위치 2. 불일치 나는 방법이처럼 만들고 싶어 :

char getConsensus(char a, char b) 

업데이트 2 : 만 2 개 시퀀스가있는 경우 제안 된 방법의 일부가 작동합니다. 이러한 "합의"에 대해 여러 번 반복 할 필요가있을 수 있으므로 입력 알파벳이 "ACGT"에서 "ACGTRYKMSWBDHVN"로 증가하여 제안 된 접근법 중 일부가 쓰기 및 유지 관리가 쉽지 않을 수 있습니다.

Answer 1

enum을 사용하는 가능한 해결책은 insp biostar.stackexchange.com에서 약간의 입력으로, pablochan에 의해 IRED :

enum lut { 
    AA('A'), AC('M'), AG('R'), AT('W'), AR('R'), AY('H'), AK('D'), AM('M'), AS('V'), AW('W'), AB('N'), AD('D'), AH('H'), AV('V'), AN('N'), 
    CA('M'), CC('C'), CG('S'), CT('Y'), CR('V'), CY('Y'), CK('B'), CM('M'), CS('S'), CW('H'), CB('B'), CD('N'), CH('H'), CV('V'), CN('N'), 
    GA('R'), GC('S'), GG('G'), GT('K'), GR('R'), GY('B'), GK('K'), GM('V'), GS('S'), GW('D'), GB('B'), GD('D'), GH('N'), GV('V'), GN('N'), 
    TA('W'), TC('Y'), TG('K'), TT('T'), TR('D'), TY('Y'), TK('K'), TM('H'), TS('B'), TW('W'), TB('B'), TD('D'), TH('H'), TV('N'), TN('N'), 
    RA('R'), RC('V'), RG('R'), RT('D'), RR('R'), RY('N'), RK('D'), RM('V'), RS('V'), RW('D'), RB('N'), RD('D'), RH('N'), RV('V'), RN('N'), 
    YA('H'), YC('Y'), YG('B'), YT('Y'), YR('N'), YY('Y'), YK('B'), YM('H'), YS('B'), YW('H'), YB('B'), YD('N'), YH('H'), YV('N'), YN('N'), 
    KA('D'), KC('B'), KG('K'), KT('K'), KR('D'), KY('B'), KK('K'), KM('N'), KS('B'), KW('D'), KB('B'), KD('D'), KH('N'), KV('N'), KN('N'), 
    MA('M'), MC('M'), MG('V'), MT('H'), MR('V'), MY('H'), MK('N'), MM('M'), MS('V'), MW('H'), MB('N'), MD('N'), MH('H'), MV('V'), MN('N'), 
    SA('V'), SC('S'), SG('S'), ST('B'), SR('V'), SY('B'), SK('B'), SM('V'), SS('S'), SW('N'), SB('B'), SD('N'), SH('N'), SV('V'), SN('N'), 
    WA('W'), WC('H'), WG('D'), WT('W'), WR('D'), WY('H'), WK('D'), WM('H'), WS('N'), WW('W'), WB('N'), WD('D'), WH('H'), WV('N'), WN('N'), 
    BA('N'), BC('B'), BG('B'), BT('B'), BR('N'), BY('B'), BK('B'), BM('N'), BS('B'), BW('N'), BB('B'), BD('N'), BH('N'), BV('N'), BN('N'), 
    DA('D'), DC('N'), DG('D'), DT('D'), DR('D'), DY('N'), DK('D'), DM('N'), DS('N'), DW('D'), DB('N'), DD('D'), DH('N'), DV('N'), DN('N'), 
    HA('H'), HC('H'), HG('N'), HT('H'), HR('N'), HY('H'), HK('N'), HM('H'), HS('N'), HW('H'), HB('N'), HD('N'), HH('H'), HV('N'), HN('N'), 
    VA('V'), VC('V'), VG('V'), VT('N'), VR('V'), VY('N'), VK('N'), VM('V'), VS('V'), VW('N'), VB('N'), VD('N'), VH('N'), VV('V'), VN('N'), 
    NA('N'), NC('N'), NG('N'), NT('N'), NR('N'), NY('N'), NK('N'), NM('N'), NS('N'), NW('N'), NB('N'), ND('N'), NH('N'), NV('N'), NN('N'); 

    char consensusChar = 'X'; 

    lut(char c) { 
     consensusChar = c; 
    } 

    char getConsensusChar() { 
     return consensusChar; 
    } 
} 

char getConsensus(char a, char b) { 
    return lut.valueOf("" + a + b).getConsensusChar(); 
} 

Answer 2

가능한 조합은 약 20입니다. 따라서 실제 성능 문제는 없습니다. 큰 블록을 수행하지 않으려면 가장 빠른 솔루션은 Tree 데이터 구조를 작성하는 것입니다. http://en.wikipedia.org/wiki/Tree_data_structure. 이것은 당신이하고 싶은 일을하는 가장 빠른 방법입니다. 나무에서

, 당신은 모든 가능한 조합을 넣어 당신에게 입력을 문자열과는 기호

당신이 도시의 예를 원하는가에 대한 가장 긴 일치 시퀀스를 찾기 위해 트리를 통과?

PS : 모든 인공 지능 소프트웨어는 가장 빠르고 적응 된 트리 apporach를 사용합니다.당신이 차이가 발생하는 경우

다음

public Enum ConsensusSymbol 
{ 
    A("A"), // simple case 
    // .... 
    GTUC("B"), 
    // etc 
    // last entry: 
    AGCTU("N"); 

    // Not sure what X means? 

    private final String symbol; 

    ConsensusSymbol(final String symbol) 
    { 
     this.symbol = symbol; 
    } 

    public String getSymbol() 
    { 
     return symbol; 
    } 
} 

, 사용 .valueOf() : 예를 들어

final ConsensusSymbol symbol; 

try { 
    symbol = ConsensusSymbol.valueOf("THESEQUENCE"); 
} catch (IllegalArgumentException e) { // Unknown sequence 
    // TODO 
} 

, 당신이 경우

Answer 3

은 내가 Enum 가고 싶어, 그들은 모든 고유 문자임을 감안할 때 GTUC을 문자열로 사용하면 Enum.valueOf("GTUC")은 GTUC 열거 형 값을 반환하고 해당 값에 getSymbol()을 호출하면 "B"을 반환합니다.

Answer 4

충돌/차이점을 합의 기호에 매핑하는 HashMap<String, String>을 사용할 수 있습니다. 일부 외부 소스 (파일, 데이터베이스 등)에서 앱을 시작하는 동안 앱의 코드를 "하드 코딩"(코드 작성)하거나 채울 수 있습니다. 그런 다음 차이가있을 때마다 사용하면됩니다.

String consensusSymbol = consensusMap.get(differenceString); 

편집 :;

Map<String, Character> consensusMap; // let's assume this is filled somewhere 
... 
char getConsensus(char a, char b) { 
    return consensusMap.get("" + a + b); 
} 

나는 표정이 원유를 실현하지만 난 당신이 요점을 파악 생각] 당신의 API 요청을 수용합니다. 이것은 룩업 테이블보다 약간 느릴 수 있지만 유지 보수하는 것이 훨씬 쉽습니다.

또 다른 편집 :

당신이 정말로 뭔가 슈퍼 빠른 원하고 당신이 (그들은 숫자로 해석하고 있기 때문에) 당신은 그냥 문자로 2 차원 테이블과 인덱스를 만들 수 char 유형을 사용 실제로 사용합니다. 한 번에 여러 시퀀스를 읽고 고려

char lookup[][] = new char[256][256]; // all "english" letters will be below 256 
//... fill it... e. g. lookup['A']['C'] = 'M'; 
char consensus = lookup['A']['C']; 

Answer 5

- I 것 :

1. 이 설정
2. 정렬하는 순서에서 같은 위치에서 모든 문자를 넣어 세트에 값을 연결하고 열거를 사용합니다. FGE의 예에서와 같이 valueOf()
가치관 등의 EnumMap는 consesus 갖는 심볼에 대한 키로서 취득 된 값
3. 사용

두 번째 및 첫 번째 단계를 최적화하는 방법이있을 수 있습니다.

Answer 6

간단하고 빠른 해결책은 비트 OR을 사용하는 것입니다.

• 희소 128 소자 테이블이 단일 비트에 매핑하는 뉴클레오티드 :
  시작시

  두 테이블을 초기화한다. '스파 스 (Sparse)'는 IUPAC 코드가 대문자와 소문자로만 구성된다는 것을 의미합니다.

• 비트 단위 컨센서스를 IUPAC 뉴클레오티드 코드에 매핑하는 16 개 요소 테이블입니다.

는 하나의 위치에 대한 합의를 얻으려면 :

1. 는 비트 표현을 얻기 위해, 첫 번째 테이블에서 인덱스로 뉴클레오티드를 사용합니다.
2. 비트 단위 OR 표현입니다.
3. 16 개 요소 테이블에 대한 인덱스로 비트 OR을 사용하십시오.

   private static final int A = 1 << 3; 
       private static final int C = 1 << 2; 
       private static final int G = 1 << 1; 
       private static final int T = 1 << 0; 
   

   은 다음과 같이 첫 번째 테이블의 구성원을 설정합니다 :

   characterToBitwiseTable[ 'd' ] = A | G | T; 
       characterToBitwiseTable[ 'D' ] = A | G | T; 
   

   이 같은 두 번째 테이블의 멤버를 설정

여기 시작하는 간단한 비트 표현입니다 :

bitwiseToCharacterTable[ A | G | T ] = 'd';