=========================
Jocs de proves per a adn
========================

>>> import adn


>>> seqA = 'TCACCTAAGAAAGAAC'
>>> seqB = 'CCACCTAAGTCAGTAC'
>>> it = adn.fusiona(iter(seqA), iter(seqB))
>>> iter(it) is it
True
>>> ''.join(it)
'*CACCTAAG**AG*AC'

>>> it = adn.sense_asteriscs(iter('*CACCTAAG**AG*AC'))
>>> iter(it) is it
True
>>> ''.join(it)
'CACCTAAGAGAC'

>>> adn.iter_a_cadena(iter('*CACCTAAG**AG*AC'))
'*CACCTAAG**AG*AC'

>>> s1, s2 = adn.dues_cadenes(seqA, seqB)
>>> s1
'*CACCTAAG**AG*AC'
>>> s2
'CACCTAAGAGAC'

>>> seqA = 'CGGCGTATCCAGCGGG'
>>> seqB = 'CGGCGTATCTAGTGGC'
>>> it = adn.fusiona(iter(seqA), iter(seqB))
>>> iter(it) is it
True
>>> ''.join(it)
'CGGCGTATC*AG*GG*'

>>> it = adn.sense_asteriscs(iter('CGGCGTATC*AG*GG*'))
>>> iter(it) is it
True
>>> ''.join(it)
'CGGCGTATCAGGG'

>>> adn.iter_a_cadena(iter('CGGCGTATC*AG*GG*'))
'CGGCGTATC*AG*GG*'

>>> s1, s2 = adn.dues_cadenes(seqA, seqB)
>>> s1
'CGGCGTATC*AG*GG*'
>>> s2
'CGGCGTATCAGGG'

>>> seqA = 'ACCGGGGTGGTGTTATCCAG'
>>> seqB = 'ACCGGGGATGTGTTGTCCGG'
>>> it = adn.fusiona(iter(seqA), iter(seqB))
>>> iter(it) is it
True
>>> ''.join(it)
'ACCGGGG**GTGTT*TCC*G'

>>> it = adn.sense_asteriscs(iter('ACCGGGG**GTGTT*TCC*G'))
>>> iter(it) is it
True
>>> ''.join(it)
'ACCGGGGGTGTTTCCG'

>>> adn.iter_a_cadena(iter('ACCGGGG**GTGTT*TCC*G'))
'ACCGGGG**GTGTT*TCC*G'

>>> s1, s2 = adn.dues_cadenes(seqA, seqB)
>>> s1
'ACCGGGG**GTGTT*TCC*G'
>>> s2
'ACCGGGGGTGTTTCCG'

>>> seqA = 'GGGAGGACGGTCTTCTGAGCTCTCCTTAGCCGAGA'
>>> seqB = 'TCACCTGGTAGGATTTCAGTCTGCTCCCATAAAAG'
>>> it = adn.fusiona(iter(seqA), iter(seqB))
>>> iter(it) is it
True
>>> ''.join(it)
'*************T*T*AG****C********A**'

>>> it = adn.sense_asteriscs(iter('*************T*T*AG****C********A**'))
>>> iter(it) is it
True
>>> ''.join(it)
'TTAGCA'

>>> adn.iter_a_cadena(iter('*************T*T*AG****C********A**'))
'*************T*T*AG****C********A**'

>>> s1, s2 = adn.dues_cadenes(seqA, seqB)
>>> s1
'*************T*T*AG****C********A**'
>>> s2
'TTAGCA'

>>> seqA = 'CACCTGCGTAGCACGTAGCGCGGCCTGCCGGTATGTTGACGCACACAAA'
>>> seqB = 'AAGGGCGCACGTCACATCTCGTCTGCGAAAGTTGGCCACAGGCATTCCC'
>>> it = adn.fusiona(iter(seqA), iter(seqB))
>>> iter(it) is it
True
>>> ''.join(it)
'*A********G***************G***GT**G*****G********'

>>> it = adn.sense_asteriscs(iter('*A********G***************G***GT**G*****G********'))
>>> iter(it) is it
True
>>> ''.join(it)
'AGGGTGG'

>>> adn.iter_a_cadena(iter('*A********G***************G***GT**G*****G********'))
'*A********G***************G***GT**G*****G********'

>>> s1, s2 = adn.dues_cadenes(seqA, seqB)
>>> s1
'*A********G***************G***GT**G*****G********'
>>> s2
'AGGGTGG'

>>> seqA = 'TGACAATTATGGTAATTGCCACTGAGCCCACCATCCCAGCCTCCTTCGGT'
>>> seqB = 'TGACAATTATGGGCGTTGCCACTGAGGGCCCCATCCCGGCATTCTTTGGG'
>>> it = adn.fusiona(iter(seqA), iter(seqB))
>>> iter(it) is it
True
>>> ''.join(it)
'TGACAATTATGG***TTGCCACTGAG**C*CCATCCC*GC*T*CTT*GG*'

>>> it = adn.sense_asteriscs(iter('TGACAATTATGG***TTGCCACTGAG**C*CCATCCC*GC*T*CTT*GG*'))
>>> iter(it) is it
True
>>> ''.join(it)
'TGACAATTATGGTTGCCACTGAGCCCATCCCGCTCTTGG'

>>> adn.iter_a_cadena(iter('TGACAATTATGG***TTGCCACTGAG**C*CCATCCC*GC*T*CTT*GG*'))
'TGACAATTATGG***TTGCCACTGAG**C*CCATCCC*GC*T*CTT*GG*'

>>> s1, s2 = adn.dues_cadenes(seqA, seqB)
>>> s1
'TGACAATTATGG***TTGCCACTGAG**C*CCATCCC*GC*T*CTT*GG*'
>>> s2
'TGACAATTATGGTTGCCACTGAGCCCATCCCGCTCTTGG'

>>> seqA = 'AGTAGGGGACGGGGGGTATATATAG'
>>> seqB = 'AGTAAATGAGTCCCCTTCTATCTAG'
>>> it = adn.fusiona(iter(seqA), iter(seqB))
>>> iter(it) is it
True
>>> ''.join(it)
'AGTA***GA*******T*TAT*TAG'

>>> it = adn.sense_asteriscs(iter('AGTA***GA*******T*TAT*TAG'))
>>> iter(it) is it
True
>>> ''.join(it)
'AGTAGATTATTAG'

>>> adn.iter_a_cadena(iter('AGTA***GA*******T*TAT*TAG'))
'AGTA***GA*******T*TAT*TAG'

>>> s1, s2 = adn.dues_cadenes(seqA, seqB)
>>> s1
'AGTA***GA*******T*TAT*TAG'
>>> s2
'AGTAGATTATTAG'

>>> seqA = 'GGCAATAAGGGGATGACTAGGTCTACTGCCG'
>>> seqB = 'GAAAATAACGCAGTACCGAGCGTGTCTGCAT'
>>> it = adn.fusiona(iter(seqA), iter(seqB))
>>> iter(it) is it
True
>>> ''.join(it)
'G**AATAA*G***T**C*AG*****CTGC**'

>>> it = adn.sense_asteriscs(iter('G**AATAA*G***T**C*AG*****CTGC**'))
>>> iter(it) is it
True
>>> ''.join(it)
'GAATAAGTCAGCTGC'

>>> adn.iter_a_cadena(iter('G**AATAA*G***T**C*AG*****CTGC**'))
'G**AATAA*G***T**C*AG*****CTGC**'

>>> s1, s2 = adn.dues_cadenes(seqA, seqB)
>>> s1
'G**AATAA*G***T**C*AG*****CTGC**'
>>> s2
'GAATAAGTCAGCTGC'

>>> seqA = 'TTCGAGCGCCAGTCACTCTGGATG'
>>> seqB = 'GTTGACCCTACGACAACAAGCCCT'
>>> it = adn.fusiona(iter(seqA), iter(seqB))
>>> iter(it) is it
True
>>> ''.join(it)
'*T*GA*C****G*CA****G****'

>>> it = adn.sense_asteriscs(iter('*T*GA*C****G*CA****G****'))
>>> iter(it) is it
True
>>> ''.join(it)
'TGACGCAG'

>>> adn.iter_a_cadena(iter('*T*GA*C****G*CA****G****'))
'*T*GA*C****G*CA****G****'

>>> s1, s2 = adn.dues_cadenes(seqA, seqB)
>>> s1
'*T*GA*C****G*CA****G****'
>>> s2
'TGACGCAG'

>>> seqA = 'TCGCTGCTACCT'
>>> seqB = 'CCACCACCCGTA'
>>> it = adn.fusiona(iter(seqA), iter(seqB))
>>> iter(it) is it
True
>>> ''.join(it)
'*C*C**C*****'

>>> it = adn.sense_asteriscs(iter('*C*C**C*****'))
>>> iter(it) is it
True
>>> ''.join(it)
'CCC'

>>> adn.iter_a_cadena(iter('*C*C**C*****'))
'*C*C**C*****'

>>> s1, s2 = adn.dues_cadenes(seqA, seqB)
>>> s1
'*C*C**C*****'
>>> s2
'CCC'

>>> seqA = 'CTCAGATCTTGGGCCG'
>>> seqB = 'AAGTGATCTCAGGCCT'
>>> it = adn.fusiona(iter(seqA), iter(seqB))
>>> iter(it) is it
True
>>> ''.join(it)
'****GATCT**GGCC*'

>>> it = adn.sense_asteriscs(iter('****GATCT**GGCC*'))
>>> iter(it) is it
True
>>> ''.join(it)
'GATCTGGCC'

>>> adn.iter_a_cadena(iter('****GATCT**GGCC*'))
'****GATCT**GGCC*'

>>> s1, s2 = adn.dues_cadenes(seqA, seqB)
>>> s1
'****GATCT**GGCC*'
>>> s2
'GATCTGGCC'

>>> seqA = 'TGACTGTCGACCGGTGAGCCCAT'
>>> seqB = 'TGATTGTCGACCGGTGAGCCCAA'
>>> it = adn.fusiona(iter(seqA), iter(seqB))
>>> iter(it) is it
True
>>> ''.join(it)
'TGA*TGTCGACCGGTGAGCCCA*'

>>> it = adn.sense_asteriscs(iter('TGA*TGTCGACCGGTGAGCCCA*'))
>>> iter(it) is it
True
>>> ''.join(it)
'TGATGTCGACCGGTGAGCCCA'

>>> adn.iter_a_cadena(iter('TGA*TGTCGACCGGTGAGCCCA*'))
'TGA*TGTCGACCGGTGAGCCCA*'

>>> s1, s2 = adn.dues_cadenes(seqA, seqB)
>>> s1
'TGA*TGTCGACCGGTGAGCCCA*'
>>> s2
'TGATGTCGACCGGTGAGCCCA'

>>> seqA = 'TTTCGCGGAAAAAACAGGTGCACTACCTCGGCGAGAA'
>>> seqB = 'GCTTTTCAATCAGTTGCGTGAATGACCCCAACCCGAA'
>>> it = adn.fusiona(iter(seqA), iter(seqB))
>>> iter(it) is it
True
>>> ''.join(it)
'**T*****A**A*****GTG*A**ACC*C**C**GAA'

>>> it = adn.sense_asteriscs(iter('**T*****A**A*****GTG*A**ACC*C**C**GAA'))
>>> iter(it) is it
True
>>> ''.join(it)
'TAAGTGAACCCCGAA'

>>> adn.iter_a_cadena(iter('**T*****A**A*****GTG*A**ACC*C**C**GAA'))
'**T*****A**A*****GTG*A**ACC*C**C**GAA'

>>> s1, s2 = adn.dues_cadenes(seqA, seqB)
>>> s1
'**T*****A**A*****GTG*A**ACC*C**C**GAA'
>>> s2
'TAAGTGAACCCCGAA'

>>> seqA = 'ATTTCTCTGGGTTAAAAGTCAAAGGCCAATACAGTAAGCGGAATGG'
>>> seqB = 'CTAAGTCTACCCTGACGTACCGTTATGTGGGTGACGGACTCAACCA'
>>> it = adn.fusiona(iter(seqA), iter(seqB))
>>> iter(it) is it
True
>>> ''.join(it)
'*T***TCT****T*A****C******************C**AA***'

>>> it = adn.sense_asteriscs(iter('*T***TCT****T*A****C******************C**AA***'))
>>> iter(it) is it
True
>>> ''.join(it)
'TTCTTACCAA'

>>> adn.iter_a_cadena(iter('*T***TCT****T*A****C******************C**AA***'))
'*T***TCT****T*A****C******************C**AA***'

>>> s1, s2 = adn.dues_cadenes(seqA, seqB)
>>> s1
'*T***TCT****T*A****C******************C**AA***'
>>> s2
'TTCTTACCAA'

>>> seqA = 'AAACCGATCAACAA'
>>> seqB = 'ACTCCGGTCATCCA'
>>> it = adn.fusiona(iter(seqA), iter(seqB))
>>> iter(it) is it
True
>>> ''.join(it)
'A**CCG*TCA*C*A'

>>> it = adn.sense_asteriscs(iter('A**CCG*TCA*C*A'))
>>> iter(it) is it
True
>>> ''.join(it)
'ACCGTCACA'

>>> adn.iter_a_cadena(iter('A**CCG*TCA*C*A'))
'A**CCG*TCA*C*A'

>>> s1, s2 = adn.dues_cadenes(seqA, seqB)
>>> s1
'A**CCG*TCA*C*A'
>>> s2
'ACCGTCACA'

>>> seqA = 'GGGACCTCTGGCATCCGTTGTCTCGTC'
>>> seqB = 'AAAATGATCCAATGAGACCGCGCCGCC'
>>> it = adn.fusiona(iter(seqA), iter(seqB))
>>> iter(it) is it
True
>>> ''.join(it)
'***A***************G***CG*C'

>>> it = adn.sense_asteriscs(iter('***A***************G***CG*C'))
>>> iter(it) is it
True
>>> ''.join(it)
'AGCGC'

>>> adn.iter_a_cadena(iter('***A***************G***CG*C'))
'***A***************G***CG*C'

>>> s1, s2 = adn.dues_cadenes(seqA, seqB)
>>> s1
'***A***************G***CG*C'
>>> s2
'AGCGC'

>>> seqA = 'GATACGCTTGTGTATATATGAACGACGGGCTCGAT'
>>> seqB = 'TATCATCTTCGGCGTATGGTGTGGATAGCGATTAA'
>>> it = adn.fusiona(iter(seqA), iter(seqB))
>>> iter(it) is it
True
>>> ''.join(it)
'*AT***CTT**G**TAT******GA**G*****A*'

>>> it = adn.sense_asteriscs(iter('*AT***CTT**G**TAT******GA**G*****A*'))
>>> iter(it) is it
True
>>> ''.join(it)
'ATCTTGTATGAGA'

>>> adn.iter_a_cadena(iter('*AT***CTT**G**TAT******GA**G*****A*'))
'*AT***CTT**G**TAT******GA**G*****A*'

>>> s1, s2 = adn.dues_cadenes(seqA, seqB)
>>> s1
'*AT***CTT**G**TAT******GA**G*****A*'
>>> s2
'ATCTTGTATGAGA'

>>> seqA = 'ACGTGCCCCGCACGCTCCTTCCGCTCCCCTCCG'
>>> seqB = 'GAGCGGCTCGCTTAACACTATTTAATGTACTTG'
>>> it = adn.fusiona(iter(seqA), iter(seqB))
>>> iter(it) is it
True
>>> ''.join(it)
'**G*G*C*CGC******CT*************G'

>>> it = adn.sense_asteriscs(iter('**G*G*C*CGC******CT*************G'))
>>> iter(it) is it
True
>>> ''.join(it)
'GGCCGCCTG'

>>> adn.iter_a_cadena(iter('**G*G*C*CGC******CT*************G'))
'**G*G*C*CGC******CT*************G'

>>> s1, s2 = adn.dues_cadenes(seqA, seqB)
>>> s1
'**G*G*C*CGC******CT*************G'
>>> s2
'GGCCGCCTG'

>>> seqA = 'AATTGGGAGACCGGTCAGA'
>>> seqB = 'TGGCTGATCTCACGTTGGG'
>>> it = adn.fusiona(iter(seqA), iter(seqB))
>>> iter(it) is it
True
>>> ''.join(it)
'*****G****C**GT**G*'

>>> it = adn.sense_asteriscs(iter('*****G****C**GT**G*'))
>>> iter(it) is it
True
>>> ''.join(it)
'GCGTG'

>>> adn.iter_a_cadena(iter('*****G****C**GT**G*'))
'*****G****C**GT**G*'

>>> s1, s2 = adn.dues_cadenes(seqA, seqB)
>>> s1
'*****G****C**GT**G*'
>>> s2
'GCGTG'

>>> seqA = 'AAGCATGTAGGAGCGAGCAAACCGAGAGAAATTTGTCCCCGGAT'
>>> seqB = 'AAGCATGTAGGGGCGAGCAAACCGAGAGTAAGTTGTCCCAGGAT'
>>> it = adn.fusiona(iter(seqA), iter(seqB))
>>> iter(it) is it
True
>>> ''.join(it)
'AAGCATGTAGG*GCGAGCAAACCGAGAG*AA*TTGTCCC*GGAT'

>>> it = adn.sense_asteriscs(iter('AAGCATGTAGG*GCGAGCAAACCGAGAG*AA*TTGTCCC*GGAT'))
>>> iter(it) is it
True
>>> ''.join(it)
'AAGCATGTAGGGCGAGCAAACCGAGAGAATTGTCCCGGAT'

>>> adn.iter_a_cadena(iter('AAGCATGTAGG*GCGAGCAAACCGAGAG*AA*TTGTCCC*GGAT'))
'AAGCATGTAGG*GCGAGCAAACCGAGAG*AA*TTGTCCC*GGAT'

>>> s1, s2 = adn.dues_cadenes(seqA, seqB)
>>> s1
'AAGCATGTAGG*GCGAGCAAACCGAGAG*AA*TTGTCCC*GGAT'
>>> s2
'AAGCATGTAGGGCGAGCAAACCGAGAGAATTGTCCCGGAT'