Rosetta Code

Bioinformatics/base count: Difference between revisions

Page Discussion

Bioinformatics/base count (view source)

Revision as of 19:02, 9 March 2024

18,528 bytes added ,  2 months ago
m
→‎{{header|Fōrmulæ}}
(add RPL)
 
(10 intermediate revisions by 7 users not shown)
Line 80:
T: 155
TOT= 500
</pre>
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits <br> or android 64 bits with application Termux }}
<syntaxhighlight lang AArch64 Assembly>
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program cptAdn64.s */
 
/************************************/
/* Constantes */
/************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
.equ LIMIT, 30
.equ SHIFT, 8
 
//.include "../../ficmacros64.inc" // use for debugging
/************************************/
/* Initialized data */
/************************************/
.data
szMessResult: .asciz "Result: "
szDNA1: .ascii "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG"
.ascii "CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG"
.ascii "AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT"
.ascii "GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT"
.ascii "CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG"
.ascii "TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA"
.ascii "TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT"
.ascii "CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG"
.ascii "TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC"
.asciz "GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT"
 
szCarriageReturn: .asciz "\n"
szMessStart: .asciz "Program 64 bits start.\n"
szMessCounterA: .asciz "Base A : "
szMessCounterC: .asciz "Base C : "
szMessCounterG: .asciz "Base G : "
szMessCounterT: .asciz "Base T : "
szMessTotal: .asciz "Total : "
sPrintLine: .fill LIMIT + SHIFT + 2,1,' ' // init line with spaces
/************************************/
/* UnInitialized data */
/************************************/
.bss
sZoneConv: .skip 24
/************************************/
/* code section */
/************************************/
.text
.global main
main: // entry of program
ldr x0,qAdrszMessStart
bl affichageMess
 
ldr x0,qAdrszDNA1
bl printDNA
ldr x0,qAdrszDNA1
bl countBase
 
100: // standard end of the program
mov x0, #0 // return code
mov x8, #EXIT // request to exit program
svc 0 // perform the system call
qAdrszDNA1: .quad szDNA1
qAdrsZoneConv: .quad sZoneConv
qAdrszMessResult: .quad szMessResult
qAdrszCarriageReturn: .quad szCarriageReturn
qAdrszMessStart: .quad szMessStart
/***************************************************/
/* count dna line and print */
/***************************************************/
/* x0 contains dna string address */
printDNA:
stp x1,lr,[sp,-16]!
stp x2,x3,[sp,-16]!
stp x4,x5,[sp,-16]!
stp x6,x7,[sp,-16]!
stp x8,x9,[sp,-16]!
mov x8,x0 // save address
mov x4,#0 // counter
mov x3,#0 // index string
mov x4,#0 // byte line counter
mov x5,#1 // start line value
ldr x7,qAdrsPrintLine
ldr x9,qAdrsZoneConv
1:
ldrb w6,[x8,x3] // load byte of dna
cmp x6,#0 // end string ?
beq 4f // yes -> end
add x1,x7,#SHIFT
strb w6,[x1,x4] // store byte in display line
add x4,x4,#1 // increment index line
cmp x4,#LIMIT // end line ?
blt 3f
mov x0,x5 // convert decimal counter base
mov x1,x9
bl conversion10
mov x2,xzr
2: // copy decimal conversion in display line
ldrb w6,[x9,x2]
strb w6,[x7,x2]
add x2,x2,1
cmp x2,x0
blt 2b
 
mov x0,#0 // Zero final
add x1,x7,#LIMIT
add x1,x1,#SHIFT + 1
strb w0,[x1]
mov x0,x7 // line display
bl affichageMess
ldr x0,qAdrszCarriageReturn
bl affichageMess
add x5,x5,#LIMIT // add line size to counter
mov x4,#0 // and init line index
3:
add x3,x3,#1 // increment index string
b 1b // and loop
4: // display end line if line contains base
cmp x4,#0
beq 100f
mov x0,x5
mov x1,x9
bl conversion10
mov x2,xzr
5: // copy decimal conversion in display line
ldrb w6,[x9,x2]
strb w6,[x7,x2]
add x2,x2,1
cmp x2,x0
blt 5b
 
mov x0,#0 // Zero final
add x1,x7,x4
add x1,x1,#SHIFT
strb w0,[x1]
mov x0,x7 // last line display
bl affichageMess
ldr x0,qAdrszCarriageReturn
bl affichageMess
100:
ldp x8,x9,[sp],16
ldp x6,x7,[sp],16
ldp x4,x5,[sp],16
ldp x2,x3,[sp],16
ldp x1,lr,[sp],16
ret
qAdrsPrintLine: .quad sPrintLine
/***************************************************/
/* count bases */
/***************************************************/
/* x0 contains dna string address */
countBase:
stp x1,lr,[sp,-16]!
stp x2,x3,[sp,-16]!
stp x4,x5,[sp,-16]!
stp x6,x7,[sp,-16]!
mov x2,#0 // string index
mov x3,#0 // A counter
mov x4,#0 // C counter
mov x5,#0 // G counter
mov x6,#0 // T counter
1:
ldrb w1,[x0,x2] // load byte of dna
cmp x1,#0 // end string ?
beq 2f
cmp x1,#'A'
cinc x3,x3,eq
cmp x1,#'C'
cinc x4,x4,eq
cmp x1,#'G'
cinc x5,x5,eq
cmp x1,#'T'
cinc x6,x6,eq
add x2,x2,#1
b 1b
2:
mov x0,x3 // convert decimal counter A
ldr x1,qAdrsZoneConv
bl conversion10
ldr x0,qAdrszMessCounterA
bl affichageMess
ldr x0,qAdrsZoneConv
bl affichageMess
ldr x0,qAdrszCarriageReturn
bl affichageMess
mov x0,x4 // convert decimal counter C
ldr x1,qAdrsZoneConv
bl conversion10
ldr x0,qAdrszMessCounterC
bl affichageMess
ldr x0,qAdrsZoneConv
bl affichageMess
ldr x0,qAdrszCarriageReturn
bl affichageMess
mov x0,x5 // convert decimal counter G
ldr x1,qAdrsZoneConv
bl conversion10
ldr x0,qAdrszMessCounterG
bl affichageMess
ldr x0,qAdrsZoneConv
bl affichageMess
ldr x0,qAdrszCarriageReturn
bl affichageMess
mov x0,x6 // convert decimal counter T
ldr x1,qAdrsZoneConv
bl conversion10
ldr x0,qAdrszMessCounterT
bl affichageMess
ldr x0,qAdrsZoneConv
bl affichageMess
ldr x0,qAdrszCarriageReturn
bl affichageMess
add x0,x3,x4 // convert decimal total
add x0,x0,x5
add x0,x0,x6
ldr x1,qAdrsZoneConv
bl conversion10
ldr x0,qAdrszMessTotal
bl affichageMess
ldr x0,qAdrsZoneConv
bl affichageMess
ldr x0,qAdrszCarriageReturn
bl affichageMess
100:
ldp x6,x7,[sp],16
ldp x4,x5,[sp],16
ldp x2,x3,[sp],16
ldp x1,lr,[sp],16 // TODO: retaur à completer
ret
qAdrszMessCounterA: .quad szMessCounterA
qAdrszMessCounterC: .quad szMessCounterC
qAdrszMessCounterG: .quad szMessCounterG
qAdrszMessCounterT: .quad szMessCounterT
qAdrszMessTotal: .quad szMessTotal
/***************************************************/
/* ROUTINES INCLUDE */
/***************************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeARM64.inc"
</syntaxhighlight>
{{Out}}
<pre>
Program 64 bits start.
1 CGTAAAAAATTACAACGTCCTTTGGCTATC
31 TCTTAAACTCCTGCTAAATGCTCGTGCTTT
61 CCAATTATGTAAGCGTTCCGAGACGGGGTG
91 GTCGATTCTGAGGACAAAGGTCAAGATGGA
121 GCGCATCGAACGCAATAAGGATCATTTGAT
151 GGGACGTTTCGTCGACAAAGTCTTGTTTCG
181 AGAGTAACGGCTACCGTCTTCGATTCTGCT
211 TATAACACTATGTTCTTATGAAATGGATGT
241 TCTGAGTTGGTCAGTCCCAATGTGCGGGGT
271 TTCTTTTAGTACGTCGGGAGTGGTATTATA
301 TTTAATTTTTCTATATAGCGATCTGTATTT
331 AAGCAATTCATTTAGGTTATCGCCGCGATG
361 CTCGGTTCGGACCGCCAAGCATCTGGCTCC
391 ACTGCTAGTGTCCTAAATTTGAATGGCAAA
421 CACAAATAAGATTTAGCAATTCGTGTAGAC
451 GACCGGGGACTTGCATGATGGGAGCAGCTT
481 TGTTAAACTACGAACGTAAT
Base A : 129
Base C : 97
Base G : 119
Base T : 155
Total : 500
 
</pre>
=={{header|Action!}}==
Line 418 ⟶ 688:
 
Total: 500</pre>
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi <br> or android 32 bits with application Termux}}
<syntaxhighlight lang ARM Assembly>
/* ARM assembly Raspberry PI */
/* program cptAdn.s */
 
/************************************/
/* Constantes */
/************************************/
/* for this file see task include a file in language ARM assembly*/
.include "../constantes.inc"
.equ LIMIT, 50
.equ SHIFT, 11
 
/************************************/
/* Initialized data */
/************************************/
.data
szMessResult: .asciz "Result: "
szDNA1: .ascii "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG"
.ascii "CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG"
.ascii "AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT"
.ascii "GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT"
.ascii "CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG"
.ascii "TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA"
.ascii "TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT"
.ascii "CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG"
.ascii "TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC"
.asciz "GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT"
 
szCarriageReturn: .asciz "\n"
szMessStart: .asciz "Program 32 bits start.\n"
szMessCounterA: .asciz "Base A : "
szMessCounterC: .asciz "Base C : "
szMessCounterG: .asciz "Base G : "
szMessCounterT: .asciz "Base T : "
szMessTotal: .asciz "Total : "
/************************************/
/* UnInitialized data */
/************************************/
.bss
sZoneConv: .skip 24
sPrintLine: .skip LIMIT + SHIFT + 2
/************************************/
/* code section */
/************************************/
.text
.global main
main: @ entry of program
ldr r0,iAdrszMessStart
bl affichageMess
 
ldr r0,iAdrszDNA1
bl printDNA
ldr r0,iAdrszDNA1
bl countBase
 
100: @ standard end of the program
mov r0, #0 @ return code
mov r7, #EXIT @ request to exit program
svc 0 @ perform the system call
iAdrszDNA1: .int szDNA1
iAdrsZoneConv: .int sZoneConv
iAdrszMessResult: .int szMessResult
iAdrszCarriageReturn: .int szCarriageReturn
iAdrszMessStart: .int szMessStart
/***************************************************/
/* count dna line and print */
/***************************************************/
/* r0 contains dna string address */
printDNA:
push {r1-r8,lr} @ save registers
mov r8,r0 @ save address
mov r4,#0 @ counter
mov r3,#0 @ index stone
mov r4,#0
mov r5,#1
ldr r7,iAdrsPrintLine
1:
ldrb r6,[r8,r3] @ load byte of dna
cmp r6,#0 @ end string ?
beq 4f
add r1,r7,#SHIFT
strb r6,[r1,r4] @ store byte in display line
add r4,r4,#1 @ increment index line
cmp r4,#LIMIT @ end line ?
blt 3f
mov r0,r5 @ convert decimal counter base
mov r1,r7
bl conversion10
mov r0,#0 @ Zero final
add r1,r7,#LIMIT
add r1,r1,#SHIFT + 1
strb r0,[r1]
mov r0,r7 @ line display
bl affichageMess
ldr r0,iAdrszCarriageReturn
bl affichageMess
add r5,r5,#LIMIT @ add line size to counter
mov r4,#0 @ and init line index
3:
add r3,r3,#1 @ increment index string
b 1b @ and loop
4: @ display end line if line contains base
cmp r4,#0
beq 100f
mov r0,r5
mov r1,r7
bl conversion10
mov r0,#0 @ Zero final
add r1,r7,r4
add r1,r1,#SHIFT
strb r0,[r1]
mov r0,r7 @ last line display
bl affichageMess
ldr r0,iAdrszCarriageReturn
bl affichageMess
100:
pop {r1-r8,pc}
iAdrsPrintLine: .int sPrintLine
/***************************************************/
/* count bases */
/***************************************************/
/* r0 contains dna string address */
countBase:
push {r1-r6,lr} @ save registers
mov r2,#0 @ string index
mov r3,#0 @ A counter
mov r4,#0 @ C counter
mov r5,#0 @ G counter
mov r6,#0 @ T counter
1:
ldrb r1,[r0,r2] @ load byte of dna
cmp r1,#0 @ end string ?
beq 2f
cmp r1,#'A'
addeq r3,r3,#1
cmp r1,#'C'
addeq r4,r4,#1
cmp r1,#'G'
addeq r5,r5,#1
cmp r1,#'T'
addeq r6,r6,#1
add r2,r2,#1
b 1b
2:
mov r0,r3 @ convert decimal counter A
ldr r1,iAdrsZoneConv
bl conversion10
ldr r0,iAdrszMessCounterA
bl affichageMess
ldr r0,iAdrsZoneConv
bl affichageMess
ldr r0,iAdrszCarriageReturn
bl affichageMess
mov r0,r4 @ convert decimal counter C
ldr r1,iAdrsZoneConv
bl conversion10
ldr r0,iAdrszMessCounterC
bl affichageMess
ldr r0,iAdrsZoneConv
bl affichageMess
ldr r0,iAdrszCarriageReturn
bl affichageMess
mov r0,r5 @ convert decimal counter G
ldr r1,iAdrsZoneConv
bl conversion10
ldr r0,iAdrszMessCounterG
bl affichageMess
ldr r0,iAdrsZoneConv
bl affichageMess
ldr r0,iAdrszCarriageReturn
bl affichageMess
mov r0,r6 @ convert decimal counter T
ldr r1,iAdrsZoneConv
bl conversion10
ldr r0,iAdrszMessCounterT
bl affichageMess
ldr r0,iAdrsZoneConv
bl affichageMess
ldr r0,iAdrszCarriageReturn
bl affichageMess
add r0,r3,r4 @ convert decimal total
add r0,r0,r5
add r0,r0,r6
ldr r1,iAdrsZoneConv
bl conversion10
ldr r0,iAdrszMessTotal
bl affichageMess
ldr r0,iAdrsZoneConv
bl affichageMess
ldr r0,iAdrszCarriageReturn
bl affichageMess
100:
pop {r1-r6,pc}
iAdrszMessCounterA: .int szMessCounterA
iAdrszMessCounterC: .int szMessCounterC
iAdrszMessCounterG: .int szMessCounterG
iAdrszMessCounterT: .int szMessCounterT
iAdrszMessTotal: .int szMessTotal
/***************************************************/
/* ROUTINES INCLUDE */
/***************************************************/
/* for this file see task include a file in language ARM assembly*/
.include "../affichage.inc"
 
</syntaxhighlight>
{{Out}}
<pre>
Program 32 bits start.
1 CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
51 CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
101 AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
151 GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
201 CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
251 TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
301 TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
351 CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
401 TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
451 GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT
Base A : 129
Base C : 97
Base G : 119
Base T : 155
Total : 500
 
</pre>
=={{header|Arturo}}==
 
Line 576 ⟶ 1,076:
500 total
</pre>
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<syntaxhighlight lang="bbcbasic"> DNA$="CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG" +\
\ "CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG" +\
\ "AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT" +\
\ "GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT" +\
\ "CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG" +\
\ "TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA" +\
\ "TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT" +\
\ "CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG" +\
\ "TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC" +\
\ "GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT" + CHR$0
 
@%=3 : REM Width of the print zone
P%=!^DNA$ : REM Address of string in memory
WHILE ?P%
IF I% MOD 50 == 0 PRINT 'I% ": ";
VDU ?P% : REM Output ASCII value at address P%
CASE ?P% OF
WHEN ASC"A" A+=1
WHEN ASC"C" C+=1
WHEN ASC"G" G+=1
WHEN ASC"T" T+=1
ENDCASE
I%+=1
P%+=1
ENDWHILE
PRINT '' "A: " A ' "C: " C ' "G: " G ' "T: " T
PRINT "Total: " A + C + G + T
</syntaxhighlight>
{{Out}}
<pre>
0: CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
50: CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
100: AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
150: GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
200: CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
250: TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
300: TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
350: CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
400: TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
450: GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT
 
A: 129
C: 97
G: 119
T: 155
Total: 500</pre>
=={{header|C}}==
Reads genome from a file, determines string length to ensure optimal formatting
Line 925 ⟶ 1,473:
Σ: 500
======</pre>
=={{header|EasyLang}}==
<syntaxhighlight lang="easylang">
len d[] 26
pos = 1
numfmt 0 4
repeat
s$ = input
until s$ = ""
for c$ in strchars s$
if pos mod 40 = 1
write pos & ":"
.
if pos mod 4 = 1
write " "
.
write c$
if pos mod 40 = 0
print ""
.
pos += 1
c = strcode c$
d[c - 64] += 1
.
.
print ""
for i in [ 1 3 7 20 ]
write strchar (64 + i) & ": "
print d[i]
.
print "Total: " & d[1] + d[3] + d[7] + d[20]
input_data
CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT
</syntaxhighlight>
 
=={{header|Factor}}==
<syntaxhighlight lang="factor">USING: assocs formatting grouping io kernel literals math
Line 976 ⟶ 1,567:
TOTAL: 500
</pre>
 
=={{header|Forth}}==
<syntaxhighlight lang="forth">
Line 1,184 ⟶ 1,776:
 
{{FormulaeEntry|page=https://formulae.org/?script=examples/Bioinformatics_-_base_count}}
 
'''Solution'''
 
[[File:Fōrmulæ - Bioinformatics - base count 01.png]]
 
'''Test case'''
 
[[File:Fōrmulæ - Bioinformatics - base count 02.png]]
 
[[File:Fōrmulæ - Bioinformatics - base count 03.png]]
 
=={{header|Go}}==
Line 1,783 ⟶ 2,385:
</pre>
=={{header|Kotlin}}==
For the first part, we can leverage the built-in <code>String.chunked</code> to transform a <code>String</code> into a <code>List&lt;String&gt;</code>, where each <code>String</code> has a defined chunk size. <code>Iterable.withIndex</code> allows you to loop over an <code>iterable</code>, while keeping track of the iteration index.
 
For counting the bases, we use <code>groupingBy</code>, which is a versatile tool for aggregating objects based on a key-function. In this case, the key function is the identity function (<code>it</code>), and the aggregation function is the counting function: <code>eachCount</code>.
 
Finally, the total count is simply the input’s length.
 
<syntaxhighlight lang="kotlin">fun printSequence(sequence: String, width: Int = 50) {
 
fun <K, V> printWithLabel(k: K, v: V) {
fun printSequence(sequence: String, width: Int = 50) {
val label = k.toString().padStart(5)
 
println("$label: $v")
fun printWithLabel(label: Any, data: Any) =
}
label.toString().padStart(5).also { println("$it: $data") }
 
println("SEQUENCE:")
sequence.chunked(width).withIndexforEachIndexed().forEach { (i, line)chunk ->
printWithLabel(i * width + linechunk.length, linechunk)
}
 
println("BASE:")
sequence.groupingBy { it }.eachCount().forEach { (k, v) ->
Line 1,808 ⟶ 2,411:
const val BASE_SEQUENCE = "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATATTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTATCGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTGTCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGACGACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT"
 
fun main() {= printSequence(BASE_SEQUENCE)
 
printSequence(BASE_SEQUENCE)
}</syntaxhighlight>
 
{{out}}
Line 1,832 ⟶ 2,435:
TOTALS: 500
</pre>
 
=={{header|Lambdatalk}}==
<syntaxhighlight lang="scheme">
Line 2,940 ⟶ 3,544:
=={{header|REXX}}==
A little extra boilerplate was added to verify correct coding of the bases in a DNA string and the alignment of the (totals) numbers.
<syntaxhighlight lang="rexx">/*REXX program finds the number of each base in a DNA string (along with a total). */
/* (along with a total). */
parse arg dna .
Parse Arg dna .
if dna=='' | dna=="," then dna= 'cgtaaaaaattacaacgtcctttggctatctcttaaactcctgctaaatg' ,
If dna==''|dna==',' Then
'ctcgtgctttccaattatgtaagcgttccgagacggggtggtcgattctg' ,
dna='cgtaaaaaattacaacgtcctttggctatctcttaaactcctgctaaatg',
'aggacaaaggtcaagatggagcgcatcgaacgcaataaggatcatttgat' ,
'ctcgtgctttccaattatgtaagcgttccgagacggggtggtcgattctg',
'gggacgtttcgtcgacaaagtcttgtttcgagagtaacggctaccgtctt' ,
'aggacaaaggtcaagatggagcgcatcgaacgcaataaggatcatttgat',
'cgattctgcttataacactatgttcttatgaaatggatgttctgagttgg' ,
'gggacgtttcgtcgacaaagtcttgtttcgagagtaacggctaccgtctt',
'tcagtcccaatgtgcggggtttcttttagtacgtcgggagtggtattata' ,
'cgattctgcttataacactatgttcttatgaaatggatgttctgagttgg',
'tttaatttttctatatagcgatctgtatttaagcaattcatttaggttat' ,
'tcagtcccaatgtgcggggtttcttttagtacgtcgggagtggtattata',
'cgccgcgatgctcggttcggaccgccaagcatctggctccactgctagtg' ,
'tttaatttttctatatagcgatctgtatttaagcaattcatttaggttat',
'tcctaaatttgaatggcaaacacaaataagatttagcaattcgtgtagac' ,
'cgccgcgatgctcggttcggaccgccaagcatctggctccactgctagtg',
'gaccggggacttgcatgatgggagcagctttgttaaactacgaacgtaat'
'tcctaaatttgaatggcaaacacaaataagatttagcaattcgtgtagac',
dna= space(dna, 0); upper dna /*elide blanks from DNA; uppercase it. */
'gaccggggacttgcatgatgggagcagctttgttaaactacgaacgtaat'
say '────────length of the DNA string: ' length(dna)
dna=translate(space(dna,0)) /* elide blanks from DNA; uppercas*/
@.= 0 /*initialize the count for all bases. */
Say '--------length of the DNA string: ' length(dna)
w= 1 /*the maximum width of a base count. */
$count.= 0 /*a placeholder forinitialize the namescount offor all bases.*/
w=1 do j=1 for length(dna) /*traipse through the maximum DNA width string.of a base count */
names='' _= substr(dna, j, 1) /* list of all names /*obtain a base name from the DNA str. */
Do j=1 To if poslength(_, $dna)==0 then $= $ || _ /*if nottraipse through foundthe before, addDNA it tostring list. */
@._name= @._ + substr(dna,j,1 ) /*bump theobtain count of thisa base. name from the DNA */
If pos(name,names)==0 Then
w= max(w, length(@._) ) /*compute the maximum width number. */
names=names||name /* if not found, add it to the list */
end /*j*/
count.name=count.name+1 /* bump the count of this base. */
say
w=max(w,length(count.name)) /* compute the maximum number width */
do k=0 for 255; z= d2c(k) /*traipse through all possibilities. */
End
if pos(z, $)==0 then iterate /*Was this base found? No, then skip. */
Say
say ' base ' z " has a basecount of: " right(@.z, w)
Do k=0 To 255
@.tot= @.tot + @.z /*add to a grand total to verify count.*/
end /*z=d2c(k*/ ) /*stick a fork in it, traipse we'rethrough all done.possibilities */
If pos(z,names)>0 Then Do
say
say '────────total for all basecounts:Say ' base ' z ' has a basecount of: ' right(@count.totz, w+1)</syntaxhighlight>
count.tot=count.tot+count.z /* add to a grand total to verify */
End
End
Say
Say '--------total for all basecounts:' right(count.tot,w+1)
</syntaxhighlight>
{{out|output|text=&nbsp; when using the default input:}}
<pre>
Line 2,982 ⟶ 3,592:
────────total for all basecounts: 500
</pre>
 
=={{header|Ring}}==
<syntaxhighlight lang="ring">
Line 3,431 ⟶ 4,042:
{{libheader|Wren-sort}}
{{libheader|Wren-iterate}}
<syntaxhighlight lang="ecmascriptwren">import "./fmt" for Fmt
import "./sort" for Sort
import "./iterate" for Stepped
 
var dna = "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG" +
Laurence
2,120

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/344475...361472"