I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

Bioinformatics/base count

Bioinformatics/base count
You are encouraged to solve this task according to the task description, using any language you may know.

Given this string representing ordered DNA bases:

```CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT
```

•   "Pretty print" the sequence followed by a summary of the counts of each of the bases:   (A, C, G, and T)   in the sequence
•   print the total count of each base in the string.

11l

Translation of: Python
`F basecount(dna)   DefaultDict[Char, Int] d   L(c) dna      d[c]++   R sorted(d.items()) F seq_split(dna, n = 50)   R (0 .< dna.len).step(n).map(i -> @dna[i .+ @n]) F seq_pp(dna, n = 50)   L(part) seq_split(dna, n)      print(‘#5: #.’.format(L.index * n, part))   print("\n  BASECOUNT:")   V tot = 0   L(base, count) basecount(dna)      print(‘    #3: #.’.format(base, count))      tot += count   V (base, count) = (‘TOT’, tot)   print(‘    #3= #.’.format(base, count)) print(‘SEQUENCE:’)V sequence = "\CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG\CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG\AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT\GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT\CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG\TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA\TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT\CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG\TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC\GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT"seq_pp(sequence)`
Output:
```SEQUENCE:
0: CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
50: CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
100: AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
150: GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
200: CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
250: TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
300: TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
350: CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
400: TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
450: GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT

BASECOUNT:
A: 129
C: 97
G: 119
T: 155
TOT= 500
```

Action!

I the solution the number of nucleotides per row is equal 30 to fit the screen on Atari 8-bit computer.

`DEFINE PTR="CARD" PROC PrettyPrint(PTR ARRAY data INT count,gsize,gcount)  INT index,item,i,ingroup,group,a,t,c,g  CHAR ARRAY s  CHAR ch   index=0 item=0 i=1 ingroup=0 group=0  a=0 t=0 g=0 c=0  s=data(0)  DO    WHILE i>s(0)    DO      i=1 item==+1      IF item>=count THEN EXIT FI      s=data(item)    OD    IF item>=count THEN EXIT FI     index==+1    IF group=0 AND ingroup=0 THEN      IF index<10 THEN Put(32) FI      IF index<100 THEN Put(32) FI      PrintI(index) Print(":")    FI    IF ingroup=0 THEN Put(32) FI    ch=s(i) i==+1    Put(ch)    IF ch='A THEN a==+1    ELSEIF ch='T THEN t==+1    ELSEIF ch='C THEN c==+1    ELSEIF ch='G THEN g==+1 FI    ingroup==+1    IF ingroup>=gsize THEN      ingroup=0 group==+1      IF group>=gcount THEN        group=0      FI    FI  OD  PrintF("%E%EBases: A:%I, T:%I, C:%I, G:%I%E",a,t,c,g)  PrintF("%ETotal: %I",a+t+g+c)RETURN PROC Main()  PTR ARRAY data(10)  BYTE LMARGIN=\$52,oldLMARGIN   oldLMARGIN=LMARGIN  LMARGIN=0 ;remove left margin on the screen  Put(125) PutE() ;clear the screen   data(0)="CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG"  data(1)="CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG"  data(2)="AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT"  data(3)="GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT"  data(4)="CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG"  data(5)="TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA"  data(6)="TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT"  data(7)="CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG"  data(8)="TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC"  data(9)="GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT"   PrettyPrint(data,10,5,6)   LMARGIN=oldLMARGIN ;restore left margin on the screenRETURN`
Output:
```  1: CGTAA AAAAT TACAA CGTCC TTTGG CTATC
31: TCTTA AACTC CTGCT AAATG CTCGT GCTTT
61: CCAAT TATGT AAGCG TTCCG AGACG GGGTG
91: GTCGA TTCTG AGGAC AAAGG TCAAG ATGGA
121: GCGCA TCGAA CGCAA TAAGG ATCAT TTGAT
151: GGGAC GTTTC GTCGA CAAAG TCTTG TTTCG
181: AGAGT AACGG CTACC GTCTT CGATT CTGCT
211: TATAA CACTA TGTTC TTATG AAATG GATGT
241: TCTGA GTTGG TCAGT CCCAA TGTGC GGGGT
271: TTCTT TTAGT ACGTC GGGAG TGGTA TTATA
301: TTTAA TTTTT CTATA TAGCG ATCTG TATTT
331: AAGCA ATTCA TTTAG GTTAT CGCCG CGATG
361: CTCGG TTCGG ACCGC CAAGC ATCTG GCTCC
391: ACTGC TAGTG TCCTA AATTT GAATG GCAAA
421: CACAA ATAAG ATTTA GCAAT TCGTG TAGAC
451: GACCG GGGAC TTGCA TGATG GGAGC AGCTT
481: TGTTA AACTA CGAAC GTAAT

Bases: A:129, T:155, C:97, G:119

Total: 500
```

`with Ada.Text_Io; procedure Base_Count is    type Sequence is new String;   Test : constant Sequence :=     "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG" &     "CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG" &     "AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT" &     "GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT" &     "CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG" &     "TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA" &     "TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT" &     "CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG" &     "TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC" &     "GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT";    Line_Width : constant := 70;    procedure Put (Seq : Sequence) is      use Ada.Text_Io;      package Position_Io is new Ada.Text_Io.Integer_Io (Natural);      First : Natural := Seq'First;      Last  : Natural;   begin      loop         Last := Natural'Min (Seq'Last, First + Line_Width - 1);         Position_Io.Put (First, Width => 3);         Put (String'(".."));         Position_Io.Put (Last, Width => 3);         Put (String'("  "));         Put (String (Seq (First .. Last)));         New_Line;         exit when Last = Seq'Last;         First := First + Line_Width;      end loop;   end Put;    procedure Count (Seq : Sequence) is      use Ada.Text_Io;      A_Count, C_Count : Natural := 0;      G_Count, T_Count : Natural := 0;   begin      for B of Seq loop         case B is            when 'A' =>  A_Count := A_Count + 1;            when 'C' =>  C_Count := C_Count + 1;            when 'G' =>  G_Count := G_Count + 1;            when 'T' =>  T_Count := T_Count + 1;            when others =>               raise Constraint_Error;         end case;      end loop;      Put_Line ("A: " & A_Count'Image);      Put_Line ("C: " & C_Count'Image);      Put_Line ("G: " & G_Count'Image);      Put_Line ("T: " & T_Count'Image);      Put_Line ("Total: " & Seq'Length'Image);   end Count; begin   Put (Test);   Count (Test);end Base_Count;`
Output:
```  1.. 70  CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCAATTATGT
71..140  AAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGG
141..210  ATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGATTCTGCT
211..280  TATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGT
281..350  ACGTCGGGAGTGGTATTATATTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
351..420  CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTGTCCTAAATTTGAATGGCAAA
421..490  CACAAATAAGATTTAGCAATTCGTGTAGACGACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTA
491..500  CGAACGTAAT
A:  129
C:  97
G:  119
T:  155
Total:  500```

ALGOL 68

Includes a count for non-bases if they are present in the sequence, as this would presumably indicate an error.

`BEGIN # count DNA bases in a sequence                                        #    # returns an array of counts of the characters in s that are in c        #    #         an extra final element holds the count of characters not in c  #    PRIO COUNT = 9;    OP   COUNT = ( STRING s, STRING c )[]INT:         BEGIN            [ LWB c : UPB c + 1 ]INT results; # extra element for "other"    #            [ 0     : 255       ]INT counts;  # only counts ASCII characters #            FOR i FROM LWB counts  TO UPB counts  DO counts[  i ] := 0 OD;            FOR i FROM LWB results TO UPB results DO results[ i ] := 0 OD;            # count the occurrences of each ASCII character in s              #            FOR i FROM LWB s TO UPB s DO                IF INT ch pos = ABS s[ i ];                   ch pos >= LWB counts AND ch pos <= UPB counts                THEN                    # have a character we can count                          #                    counts[ ch pos ] +:= 1                ELSE                    # not an ASCII character ?                               #                    results[ UPB results ] +:= 1                FI            OD;            # return the counts of the required characters                   #            # set the results for the expected characters and clear their    #            # counts so we can count the "other" characters                  #            FOR i FROM LWB results TO UPB results - 1 DO                IF INT ch pos = ABS c[ i ];                   ch pos >= LWB counts AND ch pos <= UPB counts                THEN                    results[ i ]     := counts[ ch pos ];                    counts[ ch pos ] := 0                FI            OD;            # count the "other" characters                                   #            FOR i FROM LWB counts TO UPB counts DO                IF counts[ i ] /= 0 THEN                    results[ UPB results ] +:= counts[ i ]                FI            OD;            results         END; # COUNT #    # returns the combined counts of the characters in the elements of s     #    #         that are in c                                                  #    #         an extra final element holds the count of characters not in c  #    OP   COUNT = ( []STRING s, STRING c )[]INT:         BEGIN            [ LWB c : UPB c + 1 ]INT results;            FOR i FROM LWB results TO UPB results DO results[ i ] := 0 OD;            FOR i FROM LWB s TO UPB s DO                []INT counts = s[ i ] COUNT c;                FOR i FROM LWB results TO UPB results DO                   results[ i ] +:= counts[ i ]                OD            OD;            results         END; # COUNT #    # returns the length of s                                                #    OP   LEN = ( STRING s )INT: ( UPB s - LWB s ) + 1;    # count the bases in the required sequence                               #    []STRING seq = ( "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG"                   , "CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG"                   , "AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT"                   , "GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT"                   , "CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG"                   , "TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA"                   , "TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT"                   , "CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG"                   , "TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC"                   , "GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT"                   );    STRING bases  = "ATCG";    []INT  counts = seq COUNT bases;    # print the sequence with leading character positions                    #    # find the overall length of the sequence                                #    INT   seq len := 0;    FOR i FROM LWB seq TO UPB seq DO        seq len +:= LEN seq[ i ]    OD;    # compute the minimum field width required for the positions             #    INT   s len   := seq len;    INT   width   := 1;    WHILE  s len >= 10 DO        width +:= 1;        s len OVERAB 10    OD;    # show the sequence                                                      #    print( ( "Sequence:", newline, newline ) );    INT start := 0;    FOR i FROM LWB seq TO UPB seq DO        print( ( " ", whole( start, - width ), " :", seq[ i ], newline ) );        start +:= LEN seq[ i ]    OD;    # show the base counts                                                   #    print( ( newline, "Bases: ", newline, newline ) );    INT total := 0;    FOR i FROM LWB bases TO UPB bases DO        print( ( "  ", bases[ i ], "  : ", whole( counts[ i ], - width ), newline ) );        total +:= counts[ i ]    OD;    # show the count of other characters (invalid bases) - if there are any  #    IF INT others = UPB counts;       counts[ others ] /= 0    THEN        # there were characters other than the bases                         #        print( ( newline, "Other: ", whole( counts[ others ], - width ), newline, newline ) );        total +:= counts[ UPB counts ]    FI;    # totals                                                                 #    print( ( newline, "Total: ", whole( total, - width ), newline ) )END`
Output:
```Sequence:

0 :CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
50 :CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
100 :AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
150 :GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
200 :CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
250 :TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
300 :TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
350 :CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
400 :TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
450 :GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT

Bases:

A  : 129
T  : 155
C  :  97
G  : 119

Total: 500
```

Arturo

`dna: {    CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG    CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG    AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT    GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT    CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG    TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA    TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT    CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG    TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC    GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT} prettyPrint: function [in][    count: #[ A: 0, T: 0, G: 0, C: 0 ]     loop.with:'i split.lines in 'line [        prints [pad to :string i*50 3 ":"]        print split.every:10 line         loop split line 'ch [            case [ch=]                when? -> "A" -> count\A: count\A + 1                when? -> "T" -> count\T: count\T + 1                when? -> "G" -> count\G: count\G + 1                when? -> "C" -> count\C: count\C + 1                else []        ]    ]    print ["Total count => A:" count\A, "T:" count\T "G:" count\G "C:" count\C]] prettyPrint dna`
Output:
```  0 : CGTAAAAAAT TACAACGTCC TTTGGCTATC TCTTAAACTC CTGCTAAATG
50 : CTCGTGCTTT CCAATTATGT AAGCGTTCCG AGACGGGGTG GTCGATTCTG
100 : AGGACAAAGG TCAAGATGGA GCGCATCGAA CGCAATAAGG ATCATTTGAT
150 : GGGACGTTTC GTCGACAAAG TCTTGTTTCG AGAGTAACGG CTACCGTCTT
200 : CGATTCTGCT TATAACACTA TGTTCTTATG AAATGGATGT TCTGAGTTGG
250 : TCAGTCCCAA TGTGCGGGGT TTCTTTTAGT ACGTCGGGAG TGGTATTATA
300 : TTTAATTTTT CTATATAGCG ATCTGTATTT AAGCAATTCA TTTAGGTTAT
350 : CGCCGCGATG CTCGGTTCGG ACCGCCAAGC ATCTGGCTCC ACTGCTAGTG
400 : TCCTAAATTT GAATGGCAAA CACAAATAAG ATTTAGCAAT TCGTGTAGAC
450 : GACCGGGGAC TTGCATGATG GGAGCAGCTT TGTTAAACTA CGAACGTAAT
Total count => A: 129 T: 155 G: 119 C: 97```

AWK

` # syntax: GAWK -f BIOINFORMATICS_BASE_COUNT.AWK# converted from FreeBASIC## sorting:#   PROCINFO["sorted_in"] is used by GAWK#   SORTTYPE is used by Thompson Automation's TAWK#BEGIN {    dna = "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG" \          "CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG" \          "AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT" \          "GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT" \          "CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG" \          "TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA" \          "TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT" \          "CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG" \          "TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC" \          "GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT"    curr = first = 1    while (curr <= length(dna)) {      curr_base = substr(dna,curr,1)      base_arr[curr_base]++      rec = sprintf("%s%s",rec,curr_base)      curr++      if (curr % 10 == 1) {        rec = sprintf("%s ",rec)      }      if (curr % 50 == 1) {        printf("%3d-%3d: %s\n",first,curr-1,rec)        rec = ""        first = curr      }    }    PROCINFO["sorted_in"] = "@ind_str_asc" ; SORTTYPE = 1    printf("\nBase count\n")    for (i in base_arr) {      printf("%s %8d\n",i,base_arr[i])      total += base_arr[i]    }    printf("%10d total\n",total)    exit(0)} `
Output:
```  1- 50: CGTAAAAAAT TACAACGTCC TTTGGCTATC TCTTAAACTC CTGCTAAATG
51-100: CTCGTGCTTT CCAATTATGT AAGCGTTCCG AGACGGGGTG GTCGATTCTG
101-150: AGGACAAAGG TCAAGATGGA GCGCATCGAA CGCAATAAGG ATCATTTGAT
151-200: GGGACGTTTC GTCGACAAAG TCTTGTTTCG AGAGTAACGG CTACCGTCTT
201-250: CGATTCTGCT TATAACACTA TGTTCTTATG AAATGGATGT TCTGAGTTGG
251-300: TCAGTCCCAA TGTGCGGGGT TTCTTTTAGT ACGTCGGGAG TGGTATTATA
301-350: TTTAATTTTT CTATATAGCG ATCTGTATTT AAGCAATTCA TTTAGGTTAT
351-400: CGCCGCGATG CTCGGTTCGG ACCGCCAAGC ATCTGGCTCC ACTGCTAGTG
401-450: TCCTAAATTT GAATGGCAAA CACAAATAAG ATTTAGCAAT TCGTGTAGAC
451-500: GACCGGGGAC TTGCATGATG GGAGCAGCTT TGTTAAACTA CGAACGTAAT

Base count
A      129
C       97
G      119
T      155
500 total
```

C

Reads genome from a file, determines string length to ensure optimal formatting

` #include<string.h>#include<stdlib.h>#include<stdio.h> typedef struct genome{    char* strand;    int length;    struct genome* next;}genome; genome* genomeData;int totalLength = 0, Adenine = 0, Cytosine = 0, Guanine = 0, Thymine = 0; int numDigits(int num){    int len = 1;     while(num>10){        num = num/10;        len++;    }     return len;} void buildGenome(char str[100]){    int len = strlen(str),i;    genome *genomeIterator, *newGenome;      totalLength += len;     for(i=0;i<len;i++){        switch(str[i]){            case 'A': Adenine++;                break;            case 'T': Thymine++;                break;            case 'C': Cytosine++;                break;            case 'G': Guanine++;                break;        };    }     if(genomeData==NULL){        genomeData = (genome*)malloc(sizeof(genome));         genomeData->strand = (char*)malloc(len*sizeof(char));        strcpy(genomeData->strand,str);        genomeData->length = len;         genomeData->next = NULL;    }     else{        genomeIterator = genomeData;         while(genomeIterator->next!=NULL)            genomeIterator = genomeIterator->next;         newGenome = (genome*)malloc(sizeof(genome));         newGenome->strand = (char*)malloc(len*sizeof(char));        strcpy(newGenome->strand,str);        newGenome->length = len;         newGenome->next = NULL;        genomeIterator->next = newGenome;    }} void printGenome(){    genome* genomeIterator = genomeData;     int width = numDigits(totalLength), len = 0;     printf("Sequence:\n");     while(genomeIterator!=NULL){        printf("\n%*d%3s%3s",width+1,len,":",genomeIterator->strand);        len += genomeIterator->length;         genomeIterator = genomeIterator->next;    }     printf("\n\nBase Count\n----------\n\n");     printf("%3c%3s%*d\n",'A',":",width+1,Adenine);    printf("%3c%3s%*d\n",'T',":",width+1,Thymine);    printf("%3c%3s%*d\n",'C',":",width+1,Cytosine);    printf("%3c%3s%*d\n",'G',":",width+1,Guanine);    printf("\n%3s%*d\n","Total:",width+1,Adenine + Thymine + Cytosine + Guanine);     free(genomeData);} int main(int argc,char** argv){    char str[100];    int counter = 0, len;     if(argc!=2){        printf("Usage : %s <Gene file name>\n",argv[0]);        return 0;    }     FILE *fp = fopen(argv[1],"r");     while(fscanf(fp,"%s",str)!=EOF)        buildGenome(str);    fclose(fp);     printGenome();     return 0;} `

Run and output :

```[email protected]:~/doodles\$ ./a.out genome.txt
Sequence:

0  :CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
50  :CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
100  :AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
150  :GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
200  :CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
250  :TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
300  :TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
350  :CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
400  :TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
450  :GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT

Base Count
----------

A  : 129
T  : 155
C  :  97
G  : 119

Total: 500
```

C++

Creates a class DnaBase which either uses a provided string or the default DNA sequence.

`#include <map>#include <string>#include <iostream>#include <iomanip> const std::string DEFAULT_DNA = "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG"                                "CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG"                                "AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT"                                "GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT"                                "CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG"                                "TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA"                                "TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT"                                "CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG"                                "TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC"                                "GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT"; class DnaBase {public:    DnaBase(const std::string& dna = DEFAULT_DNA, int width = 50) : genome(dna), displayWidth(width) {        // Map each character to a counter        for (auto elm : dna) {            if (count.find(elm) == count.end())                count[elm] = 0;            ++count[elm];        }    }     void viewGenome() {        std::cout << "Sequence:" << std::endl;        std::cout << std::endl;        int limit = genome.size() / displayWidth;        if (genome.size() % displayWidth != 0)            ++limit;         for (int i = 0; i < limit; ++i) {            int beginPos = i * displayWidth;            std::cout << std::setw(4) << beginPos << "  :" << std::setw(4) << genome.substr(beginPos, displayWidth) << std::endl;        }        std::cout << std::endl;        std::cout << "Base Count" << std::endl;        std::cout << "----------" << std::endl;        std::cout << std::endl;        int total = 0;        for (auto elm : count) {            std::cout << std::setw(4) << elm.first << " : " << elm.second << std::endl;            total += elm.second;        }        std::cout << std::endl;        std::cout << "Total: " << total << std::endl;    } private:    std::string genome;    std::map<char, int> count;    int displayWidth;}; int main(void) {    auto d = new DnaBase();    d->viewGenome();    delete d;    return 0;}`
Output:
```Sequence:

0  :CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
50  :CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
100  :AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
150  :GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
200  :CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
250  :TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
300  :TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
350  :CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
400  :TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
450  :GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT

Base Count
----------

A : 129
C : 97
G : 119
T : 155

Total: 500```

Delphi

` program base_count; {\$APPTYPE CONSOLE} uses  System.SysUtils,  Generics.Collections,  System.Console; const  DNA = 'CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG' +    'CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG' +    'AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT' +    'GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT' +    'CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG' +    'TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA' +    'TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT' +    'CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG' +    'TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC' +    'GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT'; procedure Println(code: ansistring);var  c: ansichar;begin  console.ForegroundColor := TConsoleColor.Black;  for c in code do  begin    case c of      'A':        console.BackgroundColor := TConsoleColor.Red;      'C':        console.BackgroundColor := TConsoleColor.Blue;      'T':        console.BackgroundColor := TConsoleColor.Green;      'G':        console.BackgroundColor := TConsoleColor.Yellow;    else      console.BackgroundColor := TConsoleColor.Black;    end;    console.Write(c);  end;  console.ForegroundColor := TConsoleColor.White;  console.BackgroundColor := TConsoleColor.Black;  console.WriteLine;end; begin  console.WriteLine('SEQUENCE:');  var le := Length(DNA);  var index := 0;  while index < le do  begin    Write(index: 5, ': ');    Println(dna.Substring(index, 50));     inc(index, 50);  end;   var baseMap := TDictionary<byte, integer>.Create;   for var i := 1 to le do  begin    var key := ord(dna[i]);    if baseMap.ContainsKey(key) then      baseMap[key] := baseMap[key] + 1    else      baseMap.Add(key, 1);  end;   var bases: TArray<byte>;  for var k in baseMap.Keys do  begin    SetLength(bases, Length(bases) + 1);    bases[High(bases)] := k;  end;  TArray.Sort<Byte>(bases);   console.WriteLine(#10'BASE COUNT:');   for var base in bases do    console.WriteLine('    {0}: {1}', [ansichar(base), baseMap[base]]);   console.WriteLine('    ------');  console.WriteLine('    S: {0}', [le]);  console.WriteLine('    ======');   readln;end.`

Color [1]

Output:
```SEQUENCE:
0: CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
50: CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
100: AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
150: GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
200: CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
250: TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
300: TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
350: CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
400: TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
450: GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT

BASE COUNT:
A: 129
C: 97
G: 119
T: 155
------
Σ: 500
======```

Factor

`USING: assocs formatting grouping io kernel literals mathmath.statistics prettyprint qw sequences sorting ; CONSTANT: dna\$[    qw{        CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG        CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG        AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT        GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT        CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG        TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA        TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT        CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG        TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC        GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT    } concat] : .dna ( seq n -- )    "SEQUENCE:" print [ group ] keep    [ * swap "  %3d: %s\n" printf ] curry each-index ; : show-counts ( seq -- )    "BASE COUNTS:" print histogram >alist [ first ] sort-with    [ [ "    %c: %3d\n" printf ] assoc-each ]    [ "TOTAL: " write [ second ] [ + ] map-reduce . ] bi ; dna [ 50 .dna nl ] [ show-counts ] bi`
Output:
```SEQUENCE:
0: CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
50: CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
100: AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
150: GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
200: CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
250: TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
300: TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
350: CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
400: TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
450: GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT

BASE COUNTS:
A: 129
C:  97
G: 119
T: 155
TOTAL: 500
```

Forth

` ( Gforth 0.7.3 ) : dnacode s" CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATATTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTATCGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTGTCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGACGACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT" ; variable #A \ Gforth initialises variables to 0variable #Cvariable #Gvariable #Tvariable #ch50 constant pplength : basecount ( adr u -- )    ." Sequence:"    swap dup rot + swap ?do  \ count while pretty-printing        #ch @ pplength mod 0= if cr #ch @ 10 .r 2 spaces then        i [email protected] dup emit        dup 'A = if drop #A @ 1+ #A ! else        dup 'C = if drop #C @ 1+ #C ! else        dup 'G = if drop #G @ 1+ #G ! else        dup 'T = if drop #T @ 1+ #T ! else drop then then then then        #ch @ 1+ #ch !    loop    cr cr ." Base counts:"    cr 4 spaces 'A emit ': emit #A @ 5 .r    cr 4 spaces 'C emit ': emit #C @ 5 .r    cr 4 spaces 'G emit ': emit #G @ 5 .r    cr 4 spaces 'T emit ': emit #T @ 5 .r    cr ."  ----------"    cr ."   Sum:"  #ch @ 5 .r    cr ."  ==========" cr cr; ( demo run: ) dnacode basecount `
Output:
```Sequence:
0  CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
50  CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
100  AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
150  GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
200  CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
250  TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
300  TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
350  CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
400  TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
450  GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT

Base counts:
A:  129
C:   97
G:  119
T:  155
----------
Sum:  500
==========
```

FreeBASIC

`#define SCW 36#define GRP 3 function padto( n as integer, w as integer ) as string    dim as string r = str(n)    while len(r)<w       r = " "+r    wend    return rend function dim as string dna = "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG"+_                    "CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG"+_                    "AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT"+_                    "GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT"+_                    "CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG"+_                    "TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA"+_                    "TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT"+_                    "CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG"+_                    "TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC"+_                    "GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT" dim as string outstr = "", currbdim as integer bases(0 to 3), curr = 1, first = 1while curr <= len(dna)    currb = mid(dna, curr, 1)    if currb = "A" then bases(0) += 1    if currb = "C" then bases(1) += 1    if currb = "G" then bases(2) += 1    if currb = "T" then bases(3) += 1    outstr += currb    curr += 1    if curr mod GRP = 1 then outstr += " "    if curr mod SCW = 1 or curr=len(dna)+1 then        outstr = padto(first,3) + "--" + padto(curr-1,3) + ":   " + outstr        print outstr        outstr = ""        first = curr    end ifwendprintprint "Base counts"print "-----------"print "     A:  " + str(bases(0))print "     C:  " + str(bases(1))print "     G:  " + str(bases(2))print "     T:  " + str(bases(3))print print " total:  " + str(bases(0)+bases(1)+bases(2)+bases(3))`
Output:
```  1-- 36:   CGT AAA AAA TTA CAA CGT CCT TTG GCT ATC TCT TAA
37-- 72:   ACT CCT GCT AAA TGC TCG TGC TTT CCA ATT ATG TAA
73--108:   GCG TTC CGA GAC GGG GTG GTC GAT TCT GAG GAC AAA
109--144:   GGT CAA GAT GGA GCG CAT CGA ACG CAA TAA GGA TCA
145--180:   TTT GAT GGG ACG TTT CGT CGA CAA AGT CTT GTT TCG
181--216:   AGA GTA ACG GCT ACC GTC TTC GAT TCT GCT TAT AAC
217--252:   ACT ATG TTC TTA TGA AAT GGA TGT TCT GAG TTG GTC
253--288:   AGT CCC AAT GTG CGG GGT TTC TTT TAG TAC GTC GGG
289--324:   AGT GGT ATT ATA TTT AAT TTT TCT ATA TAG CGA TCT
325--360:   GTA TTT AAG CAA TTC ATT TAG GTT ATC GCC GCG ATG
361--396:   CTC GGT TCG GAC CGC CAA GCA TCT GGC TCC ACT GCT
397--432:   AGT GTC CTA AAT TTG AAT GGC AAA CAC AAA TAA GAT
433--468:   TTA GCA ATT CGT GTA GAC GAC CGG GGA CTT GCA TGA
469--500:   TGG GAG CAG CTT TGT TAA ACT ACG AAC GTA AT

Base counts
-----------
A:  129
C:  97
G:  119
T:  155

total:  500```

Fōrmulæ

Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.

Programs in Fōrmulæ are created/edited online in its website, However they run on execution servers. By default remote servers are used, but they are limited in memory and processing power, since they are intended for demonstration and casual use. A local server can be downloaded and installed, it has no limitations (it runs in your own computer). Because of that, example programs can be fully visualized and edited, but some of them will not run if they require a moderate or heavy computation/memory resources, and no local server is being used.

In this page you can see the program(s) related to this task and their results.

Go

`package main import (    "fmt"    "sort") func main() {    dna := "" +        "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG" +        "CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG" +        "AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT" +        "GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT" +        "CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG" +        "TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA" +        "TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT" +        "CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG" +        "TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC" +        "GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT"     fmt.Println("SEQUENCE:")    le := len(dna)    for i := 0; i < le; i += 50 {        k := i + 50        if k > le {            k = le        }        fmt.Printf("%5d: %s\n", i, dna[i:k])    }    baseMap := make(map[byte]int) // allows for 'any' base    for i := 0; i < le; i++ {        baseMap[dna[i]]++    }    var bases []byte    for k := range baseMap {        bases = append(bases, k)    }    sort.Slice(bases, func(i, j int) bool { // get bases into alphabetic order        return bases[i] < bases[j]    })     fmt.Println("\nBASE COUNT:")    for _, base := range bases {        fmt.Printf("    %c: %3d\n", base, baseMap[base])    }    fmt.Println("    ------")    fmt.Println("    Σ:", le)    fmt.Println("    ======")}`
Output:
```SEQUENCE:
0: CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
50: CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
100: AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
150: GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
200: CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
250: TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
300: TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
350: CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
400: TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
450: GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT

BASE COUNT:
A: 129
C:  97
G: 119
T: 155
------
Σ: 500
======
```

`import Data.List       (group, sort)import Data.List.Split (chunksOf)import Text.Printf     (printf, IsChar(..), PrintfArg(..), fmtChar, fmtPrecision, formatString) data DNABase = A | C | G | T deriving (Show, Read, Eq, Ord)type DNASequence = [DNABase] instance IsChar DNABase where  toChar = head . show  fromChar = read . pure instance PrintfArg DNABase where  formatArg x fmt = formatString (show x) (fmt { fmtChar = 's', fmtPrecision = Nothing }) test :: DNASequencetest = read . pure <\$> concat  [ "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG"  , "CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG"  , "AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT"  , "GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT"  , "CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG"  , "TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA"  , "TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT"  , "CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG"  , "TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC"  , "GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT" ] chunkedDNASequence :: DNASequence -> [(Int, [DNABase])]chunkedDNASequence = zip [50,100..] . chunksOf 50 baseCounts :: DNASequence -> [(DNABase, Int)]baseCounts = fmap ((,) . head <*> length) . group . sort main :: IO ()main = do  putStrLn "Sequence:"  mapM_ (uncurry (printf "%3d: %s\n")) \$ chunkedDNASequence test  putStrLn "\nBase Counts:"  mapM_ (uncurry (printf "%2s: %2d\n")) \$ baseCounts test  putStrLn (replicate 8 '-') >> printf " Σ: %d\n\n" (length test)`
Output:
```Sequence:
50: CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
100: CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
150: AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
200: GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
250: CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
300: TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
350: TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
400: CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
450: TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
500: GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT

Base Counts:
A: 129
C: 97
G: 119
T: 155
--------
Σ: 500```

J

Solution:

`countBases=: (({.;#)/.~)@,totalBases=: #@, require 'format/printf' printSequence=: verb define'Sequence:' printf '''%4d: %s' printf ((- {.)@(+/\)@:(#"1) ,.&<"_1 ]) y'\n Base Count\n-----------' printf '''%5s: %4d' printf countBases y'-----------\nTotal = %3d' printf totalBases y)`

Required Example:

`   DNABases=: ];._2 noun defineCGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATATTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTATCGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTGTCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGACGACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT)   printSequence DNABasesSequence:   0: CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG  50: CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG 100: AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT 150: GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT 200: CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG 250: TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA 300: TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT 350: CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG 400: TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC 450: GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT  Base Count-----------    C:   97    G:  119    T:  155    A:  129-----------Total = 500`

Java

For counting the bases, we simply use a `HashMap`, and then use the `Map.merge`, inserting `1`, and using `Integer::sum` as the aggregation function. This effectively creates a `Map` that keeps a running count for us. Java does provide the `groupingBy` and `counting` collectors, which would generally make these kinds of operation easier. However, `String`’s `chars()` method returns a `IntStream`, which generally just makes everything more complicated. Or verbose. Or inefficient. Ultimately, doing it by hand is easier and more efficient than with streams. The best tool for this job though would be Guava’s `MultiSet`, which is a dedicated Key to Count container.

Note that Java’s native strings are UCS-2/UTF-16: Each character is 2-byte long. If parsing from a very large ASCII/UTF8 text file, then `String` is a poor choice, as opposed to, say `byte[]`. For the purpose of this exercise though, using `byte[]` would just add uninteresting casts and bloat to the code, so we stick to `String`.

`import java.util.HashMap;import java.util.Map; public class orderedSequence {    public static void main(String[] args) {        Sequence gene = new Sequence("CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATATTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTATCGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTGTCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGACGACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT");        gene.runSequence();    }} /** Separate class for defining behaviors */public class Sequence {     private final String seq;     public Sequence(String sq) {        this.seq = sq;    }     /** print the organized structure of the sequence */    public void prettyPrint() {        System.out.println("Sequence:");        int i = 0;        for ( ; i < seq.length() - 50 ; i += 50) {            System.out.printf("%5s : %s\n", i + 50, seq.substring(i, i + 50));        }        System.out.printf("%5s : %s\n", seq.length(), seq.substring(i));    }     /** display a base vs. frequency chart */    public void displayCount() {        Map<Character, Integer> counter = new HashMap<>();        for (int i = 0 ; i < seq.length() ; ++i) {            counter.merge(seq.charAt(i), 1, Integer::sum);        }         System.out.println("Base vs. Count:");        counter.forEach(            key, value -> System.out.printf("%5s : %s\n", key, value));        System.out.printf("%5s: %s\n", "SUM", seq.length());    }     public void runSequence() {        this.prettyPrint();        this.displayCount();    }}  `
Output:
```Sequence:
50 : CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
100 : CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
150 : AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
200 : GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
250 : CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
300 : TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
350 : TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
400 : CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
450 : TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
500 : GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT
Base vs. Count:
A : 129
C : 97
T : 155
G : 119
SUM: 500
```

JavaScript

`const rowLength = 50; const bases = ['A', 'C', 'G', 'T']; // Create the starting sequenceconst seq = `CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATATTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTATCGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTGTCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGACGACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT`    .split('')    .filter(e => bases.includes(e)) /** * Convert the given array into an array of smaller arrays each with the length * given by n. * @param {number} n * @returns {function(!Array<*>): !Array<!Array<*>>} */const chunk = n => a => a.reduce(    (p, c, i) => (!(i % n)) ? p.push([c]) && p : p[p.length - 1].push(c) && p,    []);const toRows = chunk(rowLength); /** * Given a number, return function that takes a string and left pads it to n * @param {number} n * @returns {function(string): string} */const padTo = n => v => ('' + v).padStart(n, ' ');const pad = padTo(5); /** * Count the number of elements that match the given value in an array * @param {Array<string>} arr * @returns {function(string): number} */const countIn = arr => s => arr.filter(e => e === s).length; /** * Utility logging function * @param {string|number} v * @param {string|number} n */const print = (v, n) => console.log(`\${pad(v)}:\t\${n}`) const prettyPrint = seq => {  const chunks = toRows(seq);  console.log('SEQUENCE:')  chunks.forEach((e, i) => print(i * rowLength, e.join('')))} const printBases = (seq, bases) => {  const filterSeq = countIn(seq);  const counts = bases.map(filterSeq);  console.log('\nBASE COUNTS:')  counts.forEach((e, i) => print(bases[i], e));  print('Total', counts.reduce((p,c) => p + c, 0));} prettyPrint(seq);printBases(seq, bases); `
Output:
```SEQUENCE:
0:	CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
50:	CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
100:	AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
150:	GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
200:	CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
250:	TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
300:	TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
350:	CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
400:	TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
450:	GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT

BASE COUNTS:
A:	129
C:	97
G:	119
T:	155
Total:	500
```

jq

Naive (in-memory) solution

First, some general utility functions:

`def lpad(\$len; \$fill): tostring | (\$len - length) as \$l | (\$fill * \$l)[:\$l] + .; # Create a bag of words, i.e. a JSON object with counts of the items in the streamdef bow(stream):   reduce stream as \$word ({}; .[(\$word|tostring)] += 1);`
Next, some helper functions:
` def read_seq:  reduce inputs as \$line (""; . + \$line); # Emit a bow of the letters in the input stringdef counts:  . as \$in | bow(range(0;length) | \$in[.:.+1]); def pp_counts:  "BASE COUNTS:",   (counts | to_entries | sort[] | "    \(.key):  \(.value | lpad(6;" "))"),   "Total: \(length|lpad(7;" "))" ; def pp_sequence(\$cols):  range(0; length / \$cols) as \$i    | "\(\$i*\$cols | lpad(5; " ")): " +  .[ \$i * \$cols : (\$i+1) * \$cols] ;`
Finally, the task at hand:
` read_seq | pp_sequence(50), "", pp_counts`
Output:

The invocation:

```   jq -nrR -f base_count.jq base_count.txt
```
produces:
`     0: CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG   50: CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG  100: AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT  150: GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT  200: CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG  250: TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA  300: TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT  350: CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG  400: TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC  450: GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT BASE COUNTS:    A:     129    C:      97    G:     119    T:     155Total:     500`

Memory-efficient solution

`def lpad(\$len; \$fill): tostring | (\$len - length) as \$l | (\$fill * \$l)[:\$l] + .; # "bow" = bag of words, i.e. a JSON object with counts# Input: a bow or null# Output: augmented bowdef bow(stream):   reduce stream as \$word (.; .[(\$word|tostring)] += 1); # The main function ignores its input in favor of `stream`:def report(stream; \$cols):   # input: a string, possibly longer than \$cols  def pp_sequence(\$start):  range(0; length / \$cols) as \$i    | "\(\$start + (\$i*\$cols) | lpad(5; " ")): " +  .[ \$i * \$cols : (\$i+1) * \$cols] ;   # input: a bow  def pp_counts:    "BASE COUNTS:",     (to_entries | sort[] | "    \(.key):  \(.value | lpad(6;" "))"),     "Total: \( [.[]] | add | lpad(7;" "))" ;   # state: {bow, emit, pending, start}  foreach (stream,null) as \$line ({start: - \$cols};    .start += \$cols    | if \$line == null      then .emit = .pending      else .bow |= bow(range(0; \$line|length) | \$line[.:.+1])      | ((\$line|length) + (.pending|length) ) as \$len      | if \$len >= \$cols        then (.pending + \$line) as \$new        | .emit = \$new[:\$cols]        | .pending = \$new[\$cols:]        else .pending = \$line        end      end;    (select(.emit|length > 0) | .start as \$start | .emit | pp_sequence(\$start)),    (select(\$line == null) | "", (.bow|pp_counts) ) )    ; # To illustrate reformatting:report(inputs; 33)`
Output:
`     0: CGTAAAAAATTACAACGTCCTTTGGCTATCTCT   33: TAAACTCCTGCTAAATGCTCGTGCTTTCCAATT   66: ATGTAAGCGTTCCGAGACGGGGTGGTCGATTCT   99: GAGGACAAAGGTCAAGATGGAGCGCATCGAACG  132: CAATAAGGATCATTTGATGGGACGTTTCGTCGA  165: CAAAGTCTTGTTTCGAGAGTAACGGCTACCGTC  198: TTCGATTCTGCTTATAACACTATGTTCTTATGA  231: AATGGATGTTCTGAGTTGGTCAGTCCCAATGTG  264: CGGGGTTTCTTTTAGTACGTCGGGAGTGGTATT  297: ATATTTAATTTTTCTATATAGCGATCTGTATTT  330: AAGCAATTCATTTAGGTTATCGCCGCGATGCTC  363: GGTTCGGACCGCCAAGCATCTGGCTCCACTGCT  396: AGTGTCCTAAATTTGAATGGCAAACACAAATAA  429: GATTTAGCAATTCGTGTAGACGACCGGGGACTT  462: GCATGATGGGAGCAGCTTTGTTAAACTACGAAC  495: GTAAT BASE COUNTS:    A:     129    C:      97    G:     119    T:     155Total:     500`

Julia

`const sequence = "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG" *"CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG" *"AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT" *"GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT" *"CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG" *"TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA" *"TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT" *"CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG" *"TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC" *"GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT" function dnasequenceprettyprint(seq, colsize=50)    println(length(seq), "nt DNA sequence:\n")    rows = [seq[i:min(length(seq), i + colsize - 1)] for i in 1:colsize:length(seq)]    for (i, r) in enumerate(rows)        println(lpad(colsize * (i - 1), 5), "   ", r)    endend dnasequenceprettyprint(sequence) function printcounts(seq)    bases = [['A', 0], ['C', 0], ['G', 0], ['T', 0]]    for c in seq, base in bases        if c == base[1]            base[2] += 1        end    end    println("\nNucleotide counts:\n")    for base in bases        println(lpad(base[1], 10), lpad(string(base[2]), 12))    end    println(lpad("Other", 10), lpad(string(length(seq) - sum(x[2] for x in bases)), 12))    println("     _________________\n", lpad("Total", 10), lpad(string(length(seq)), 12)) end printcounts(sequence) `
Output:
```500nt DNA sequence:

0   CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
50   CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
100   AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
150   GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
200   CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
250   TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
300   TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
350   CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
400   TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
450   GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT

Nucleotide counts:

A         129
C          97
G         119
T         155
Other           0
_________________
Total         500
```

Kotlin

For the first part, we can leverage the built-in `String.chunked` to transform a `String` into a `List<String>`, where each `String` has a defined chunk size. `Iterable.withIndex` allows you to loop over an `iterable`, while keeping track of the iteration index.

For counting the bases, we use `groupingBy`, which is a versatile tool for aggregating objects based on a key-function. In this case, the key function is the identity function (`it`), and the aggregation function is the counting function: `eachCount`.

Finally, the total count is simply the input’s length.

`fun printSequence(sequence: String, width: Int = 50) {    fun <K, V> printWithLabel(k: K, v: V) {        val label = k.toString().padStart(5)        println("\$label: \$v")    }     println("SEQUENCE:")    sequence.chunked(width).withIndex().forEach { (i, line) ->        printWithLabel(i*width + line.length, line)    }    println("BASE:")    sequence.groupingBy { it }.eachCount().forEach { (k, v) ->        printWithLabel(k, v)    }    printWithLabel("TOTALS", sequence.length)} const val BASE_SEQUENCE = "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATATTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTATCGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTGTCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGACGACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT" fun main() {    printSequence(BASE_SEQUENCE)}`
Output:
```SEQUENCE:
50: CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
100: CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
150: AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
200: GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
250: CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
300: TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
350: TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
400: CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
450: TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
500: GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT
BASE:
C: 97
G: 119
T: 155
A: 129
TOTALS: 500
```

Lambdatalk

` {def DNA CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATATTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTATCGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTGTCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGACGACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT}-> DNA {def base_count {def base_count.r  {lambda {:dna :b :n :i :count}   {if {> :i :n}    then :count    else {base_count.r :dna :b :n {+ :i 1}                       {if {W.equal? {W.get :i :dna} :b}                        then {+ :count 1}                        else :count}} }}} {lambda {:dna :b}  {base_count.r :dna :b {- {W.length :dna} 1} 0 0} }}-> base_count {def S {S.map {base_count {DNA}}} A C G T}} -> S [A C G T] = (129 97 119 155) A+C+G+T = {+ {S}} -> A+C+G+T = 500 `

Lua

`function prettyprint(seq) -- approx DDBJ format  seq = seq:gsub("%A",""):lower()  local sums, n = { a=0, c=0, g=0, t=0 }, 1  seq:gsub("(%a)", function(c) sums[c]=sums[c]+1 end)  local function printf(s,...) io.write(s:format(...)) end  printf("LOCUS       AB000000     %12d bp    mRNA    linear   HUM 01-JAN-2001\n", #seq)  printf(" BASE COUNT %12d a %12d c %12d g %12d t\n", sums.a, sums.c, sums.g, sums.t)  printf("ORIGIN\n")  while n < #seq do    local sub60 = seq:sub(n,n+59)    printf("%9d %s\n", n, sub60:gsub("(..........)","%1 "))    n = n + #sub60  endend prettyprint[[CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATATTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTATCGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTGTCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGACGACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT]]`
Output:
```LOCUS       AB000000              500 bp    mRNA    linear   HUM 01-JAN-2001
BASE COUNT          129 a           97 c          119 g          155 t
ORIGIN
1 cgtaaaaaat tacaacgtcc tttggctatc tcttaaactc ctgctaaatg ctcgtgcttt
61 ccaattatgt aagcgttccg agacggggtg gtcgattctg aggacaaagg tcaagatgga
121 gcgcatcgaa cgcaataagg atcatttgat gggacgtttc gtcgacaaag tcttgtttcg
181 agagtaacgg ctaccgtctt cgattctgct tataacacta tgttcttatg aaatggatgt
241 tctgagttgg tcagtcccaa tgtgcggggt ttcttttagt acgtcgggag tggtattata
301 tttaattttt ctatatagcg atctgtattt aagcaattca tttaggttat cgccgcgatg
361 ctcggttcgg accgccaagc atctggctcc actgctagtg tcctaaattt gaatggcaaa
421 cacaaataag atttagcaat tcgtgtagac gaccggggac ttgcatgatg ggagcagctt
481 tgttaaacta cgaacgtaat```

Mathematica / Wolfram Language

`seq = "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCA\ATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATCGAACGC\AATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGA\TTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTC\TTTTAGTACGTCGGGAGTGGTATTATATTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTT\AGGTTATCGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTGTCCTAAATTTGAA\TGGCAAACACAAATAAGATTTAGCAATTCGTGTAGACGACCGGGGACTTGCATGATGGGAGCAGCTTTGT\TAAACTACGAACGTAAT";size = 70;parts = StringPartition[seq, UpTo[size]];begins = Most[Accumulate[Prepend[StringLength /@ parts, 1]]];ends = Rest[Accumulate[Prepend[StringLength /@ parts, 0]]];StringRiffle[MapThread[ToString[#1] <> "-" <> ToString[#2] <> ": " <> #3 &, {begins, ends, parts}], "\n"]StringRiffle[#1 <> ": " <> ToString[#2] & @@@ Tally[Characters[seq]], "\n"]`
Output:
```1-70: CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCAATTATGT
71-140: AAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGG
141-210: ATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGATTCTGCT
211-280: TATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGT
281-350: ACGTCGGGAGTGGTATTATATTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
351-420: CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTGTCCTAAATTTGAATGGCAAA
421-490: CACAAATAAGATTTAGCAATTCGTGTAGACGACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTA
491-500: CGAACGTAAT
C: 97
G: 119
T: 155
A: 129```

MATLAB / Octave

` function r = base_count(f)    fid = fopen(f,'r');    nn=[0,0,0,0];    	    while ~feof(fid)	s = fgetl(fid);	fprintf(1,'%5d :%s\n', sum(nn), s(s=='A'|s=='C'|s=='G'|s=='T'));	nn = nn+[sum(s=='A'),sum(s=='C'),sum(s=='G'),sum(s=='T')];    end    fclose(fid);     fprintf(1, '\nBases:\n\n  A  : %d\n  C  : %d\n  G  : %d\n  T  : %d\n', nn);    fprintf(1, '\nTotal: %d\n\n', sum(nn));end; `

Output:
```base_count('base_count_data.txt');
0 :CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
50 :CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
100 :AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
150 :GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
200 :CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
250 :TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
300 :TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
350 :CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
400 :TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
450 :GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT

Bases:

A  : 129
C  : 97
G  : 119
T  : 155

Total: 500

```

Nim

Rather than inventing a new presentation format, we have chosen to use the EMBL (European Molecular Biology Laboratory) format which is well documented. See specifications here: ftp://ftp.ebi.ac.uk/pub/databases/embl/doc/usrman.txt

`import strformatimport strutils const Source = "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG" &               "CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG" &               "AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT" &               "GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT" &               "CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG" &               "TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA" &               "TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT" &               "CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG" &               "TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC" &               "GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT" # Enumeration type for bases.type Base* {.pure.} = enum A, C, G, T, Other = "other" proc display*(dnaSeq: string) =  ## Display a DNA sequence using EMBL format.   var counts: array[Base, Natural]    # Count of bases.  for c in dnaSeq:    inc counts[parseEnum[Base](\$c, Other)]  # Use Other as default value.   # Display the SQ line.  var sqline = fmt"SQ   {dnaSeq.len} BP; "  for (base, count) in counts.pairs:    sqline &= fmt"{count} {base}; "  echo sqline   # Display the sequence.  var idx = 0  var row = newStringOfCap(80)  var remaining = dnaSeq.len   while remaining > 0:    row.setLen(0)    row.add("     ")     # Add groups of 10 bases.    for group in 1..6:      let nextIdx = idx + min(10, remaining)      row.add(dnaSeq[idx..<nextIdx] & ' ')      dec remaining, nextIdx - idx      idx = nextIdx      if remaining == 0:        break     # Append the number of the last base in the row.    row.add(spaces(72 - row.len))    row.add(fmt"{idx:>8}")    echo row   # Add termination.  echo "//"  when isMainModule:  Source.display()`
Output:
```SQ   500 BP; 129 A; 97 C; 119 G; 155 T; 0 other;
CGTAAAAAAT TACAACGTCC TTTGGCTATC TCTTAAACTC CTGCTAAATG CTCGTGCTTT        60
CCAATTATGT AAGCGTTCCG AGACGGGGTG GTCGATTCTG AGGACAAAGG TCAAGATGGA       120
GCGCATCGAA CGCAATAAGG ATCATTTGAT GGGACGTTTC GTCGACAAAG TCTTGTTTCG       180
AGAGTAACGG CTACCGTCTT CGATTCTGCT TATAACACTA TGTTCTTATG AAATGGATGT       240
TCTGAGTTGG TCAGTCCCAA TGTGCGGGGT TTCTTTTAGT ACGTCGGGAG TGGTATTATA       300
TTTAATTTTT CTATATAGCG ATCTGTATTT AAGCAATTCA TTTAGGTTAT CGCCGCGATG       360
CTCGGTTCGG ACCGCCAAGC ATCTGGCTCC ACTGCTAGTG TCCTAAATTT GAATGGCAAA       420
CACAAATAAG ATTTAGCAAT TCGTGTAGAC GACCGGGGAC TTGCATGATG GGAGCAGCTT       480
TGTTAAACTA CGAACGTAAT```

Pascal

`program DNA_Base_Count;{\$IFDEF FPC}  {\$MODE DELPHI}//String = AnsiString{\$ELSE}  {\$APPTYPE CONSOLE}{\$ENDIF}const    dna =        'CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG' +        'CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG' +        'AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT' +        'GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT' +        'CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG' +        'TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA' +        'TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT' +        'CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG' +        'TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC' +        'GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT';var  CntIdx : array of NativeUint;  DNABases : String;  SumBaseTotal : NativeInt; procedure OutFormatBase(var DNA: String;colWidth:NativeInt);var  j: NativeInt;Begin  j := 0;  Writeln(' DNA base sequence');  While j<Length(DNA) do  Begin    writeln(j:5,copy(DNA,j+1,colWidth):colWidth+2);    inc(j,colWidth);  end;  writeln;end; procedure Cnt(const DNA: String);var  i,p :NativeInt;Begin  SetLength(CntIdx,Length(DNABases));  i := 1;  while i <= Length(DNA) do  Begin    p := Pos(DNA[i],DNABases);    //found new base so extend list    if p = 0 then    Begin      DNABases := DNABases+DNA[i];      p := length(DNABases);      Setlength(CntIdx,p+1);    end;    inc(CntIdx[p]);    inc(i);  end;   Writeln('Base     Count');  SumBaseTotal := 0;  For i := 1 to Length(DNABases) do  Begin    p := CntIdx[i];    inc(SumBaseTotal,p);    writeln(DNABases[i]:4,p:10);  end;  Writeln('Total base count ',SumBaseTotal);  writeln;end; var  TestDNA: String;Begin  DNABases :='ACGT';// predefined  TestDNA := DNA;  OutFormatBase(TestDNA,50);  Cnt(TestDNA);end.`
Output:
``` DNA base sequence
0  CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
50  CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
100  AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
150  GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
200  CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
250  TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
300  TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
350  CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
400  TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
450  GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT

Base     Count
A       129
C        97
G       119
T       155
Total base count 500```

Perl

`use strict;use warnings;use feature 'say'; my %cnt;my \$total = 0; while (\$_ = <DATA>) {    chomp;    printf "%4d: %s\n", \$total+1, s/(.{10})/\$1 /gr;    \$total += length;    \$cnt{\$_}++ for split //} say "\nTotal bases: \$total";say "\$_: " . (\$cnt{\$_}//0) for <A C G T>; __DATA__CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATATTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTATCGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTGTCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGACGACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT`
Output:
```   1: CGTAAAAAAT TACAACGTCC TTTGGCTATC TCTTAAACTC CTGCTAAATG
51: CTCGTGCTTT CCAATTATGT AAGCGTTCCG AGACGGGGTG GTCGATTCTG
101: AGGACAAAGG TCAAGATGGA GCGCATCGAA CGCAATAAGG ATCATTTGAT
151: GGGACGTTTC GTCGACAAAG TCTTGTTTCG AGAGTAACGG CTACCGTCTT
201: CGATTCTGCT TATAACACTA TGTTCTTATG AAATGGATGT TCTGAGTTGG
251: TCAGTCCCAA TGTGCGGGGT TTCTTTTAGT ACGTCGGGAG TGGTATTATA
301: TTTAATTTTT CTATATAGCG ATCTGTATTT AAGCAATTCA TTTAGGTTAT
351: CGCCGCGATG CTCGGTTCGG ACCGCCAAGC ATCTGGCTCC ACTGCTAGTG
401: TCCTAAATTT GAATGGCAAA CACAAATAAG ATTTAGCAAT TCGTGTAGAC
451: GACCGGGGAC TTGCATGATG GGAGCAGCTT TGTTAAACTA CGAACGTAAT

Total bases: 500
A: 129
C: 97
G: 119
T: 155```

Phix

```constant dna = substitute("""
CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT
""","\n","")
sequence acgt = repeat(0,5)
for i=1 to length(dna) do
acgt[find(dna[i],"ACGT")] += 1
end for
acgt[\$] = sum(acgt)
sequence s = split(trim(join_by(split(join_by(dna,1,10,""),"\n"),1,5," ")),"\n")
for i=1 to length(s) do
printf(1,"%3d: %s\n",{(i-1)*50+1,s[i]})
end for
printf(1,"\nBase counts: A:%d, C:%d, G:%d, T:%d, total:%d\n",acgt)
```
Output:
```  1: CGTAAAAAAT TACAACGTCC TTTGGCTATC TCTTAAACTC CTGCTAAATG
51: CTCGTGCTTT CCAATTATGT AAGCGTTCCG AGACGGGGTG GTCGATTCTG
101: AGGACAAAGG TCAAGATGGA GCGCATCGAA CGCAATAAGG ATCATTTGAT
151: GGGACGTTTC GTCGACAAAG TCTTGTTTCG AGAGTAACGG CTACCGTCTT
201: CGATTCTGCT TATAACACTA TGTTCTTATG AAATGGATGT TCTGAGTTGG
251: TCAGTCCCAA TGTGCGGGGT TTCTTTTAGT ACGTCGGGAG TGGTATTATA
301: TTTAATTTTT CTATATAGCG ATCTGTATTT AAGCAATTCA TTTAGGTTAT
351: CGCCGCGATG CTCGGTTCGG ACCGCCAAGC ATCTGGCTCC ACTGCTAGTG
401: TCCTAAATTT GAATGGCAAA CACAAATAAG ATTTAGCAAT TCGTGTAGAC
451: GACCGGGGAC TTGCATGATG GGAGCAGCTT TGTTAAACTA CGAACGTAAT

Base counts: A:129, C:97, G:119, T:155, total:500
```

Picat

`main =>  dna(DNA, ChunkSize),  Count = 0,  println("Sequence:"),  Map = new_map(['A'=0,'C'=0,'G'=0,'T'=0]),  foreach(Chunk in DNA.chunks_of(ChunkSize))    printf("%4d: %s\n", Count, Chunk),    Count := Count + Chunk.len,    foreach(C in Chunk)      Map.put(C,Map.get(C)+1)    end  end,  println("\nBase count:"),  foreach(C in "ACGT")    printf("%5c: %3d\n", C, Map.get(C))  end,  printf("Total: %d\n", Count),  nl. dna(DNA,ChunkSize) =>  DNA = "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATATTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTATCGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTGTCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGACGACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT".delete_all('\n'),  ChunkSize = 50.`
Output:
```Sequence:
0: CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
50: CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
100: AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
150: GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
200: CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
250: TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
300: TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
350: CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
400: TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
450: GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT

Base count:
A: 129
C:  97
G: 119
T: 155
Total: 500```

PicoLisp

`(let   (S (chop "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG\      CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG\      AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT\      GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT\      CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG\      TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA\      TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT\      CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG\      TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC\      GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT" )      R )   (for I S (accu 'R I 1))   (for I R (println I))   (println 'Total: (sum cdr R)) )`
Output:
```("A" . 129)
("T" . 155)
("G" . 119)
("C" . 97)
Total: 500
```

PureBasic

`dna\$ = "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG" +       "CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG" +              "AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT" +              "GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT" +              "CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG" +              "TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA" +              "TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT" +              "CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG" +              "TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC" +              "GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT" NewMap basecount.i() If OpenConsole("")  For i = 1 To Len(dna\$)    If (i % 50) = 1      Print(~"\n" + RSet(Str(i - 1), 5) + " : ")    EndIf        t\$ = Mid(dna\$, i, 1)    basecount(t\$) + 1    Print(t\$)  Next   PrintN(~"\n\n" + Space(2) + "Base  count")  PrintN(Space(2) + ~"----  -----")  ForEach basecount()    PrintN(RSet(MapKey(basecount()), 5) + " : " + RSet(Str(basecount()), 5))    sigma + basecount()  Next    PrintN(~"\n" + "Total = " + RSet(Str(sigma), 5))  Input()EndIf`
Output:
```    0 : CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
50 : CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
100 : AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
150 : GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
200 : CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
250 : TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
300 : TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
350 : CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
400 : TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
450 : GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT

Base  count
----  -----
A :   129
C :    97
G :   119
T :   155

Total =   500```

Python

Procedural

`from collections import Counter def basecount(dna):    return sorted(Counter(dna).items()) def seq_split(dna, n=50):    return [dna[i: i+n] for i in range(0, len(dna), n)] def seq_pp(dna, n=50):    for i, part in enumerate(seq_split(dna, n)):        print(f"{i*n:>5}: {part}")    print("\n  BASECOUNT:")    tot = 0    for base, count in basecount(dna):        print(f"    {base:>3}: {count}")        tot += count    base, count = 'TOT', tot    print(f"    {base:>3}= {count}") if __name__ == '__main__':    print("SEQUENCE:")    sequence = '''\CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG\CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG\AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT\GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT\CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG\TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA\TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT\CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG\TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC\GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT'''    seq_pp(sequence) `
Output:
```SEQUENCE:
0: CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
50: CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
100: AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
150: GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
200: CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
250: TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
300: TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
350: CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
400: TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
450: GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT

BASECOUNT:
A: 129
C: 97
G: 119
T: 155
TOT= 500```

Functional

Sequence and base counts displayed in GenBank format.

Works with: Python version 3.7
`'''Bioinformatics – base count''' from itertools import countfrom functools import reduce  # genBankFormatWithBaseCounts :: String -> Stringdef genBankFormatWithBaseCounts(sequence):    '''DNA Sequence displayed in a subset of the GenBank format.       See example at foot of:       https://www.genomatix.de/online_help/help/sequence_formats.html    '''    ks, totals = zip(*baseCounts(sequence))    ns = list(map(str, totals))    w = 2 + max(map(len, ns))     return '\n'.join([        'DEFINITION  len=' + str(sum(totals)),        'BASE COUNT  ' + ''.join(            n.rjust(w) + ' ' + k.lower() for (k, n)            in zip(ks, ns)        ),        'ORIGIN'    ] + [        str(i).rjust(9) + ' ' + k for i, k        in zip(            count(1, 60),            [                ' '.join(row) for row in                chunksOf(6)(chunksOf(10)(sequence))            ]        )    ] + ['//'])  # baseCounts :: String -> Zip [(String, Int)]def baseCounts(baseString):    '''Sums for each base type in the given sequence string, with       a fifth sum for any characters not drawn from {A, C, G, T}.'''    bases = {        'A': 0,        'C': 1,        'G': 2,        'T': 3    }    return zip(        list(bases.keys()) + ['Other'],        foldl(            lambda a: compose(                nthArrow(succ)(a),                flip(curry(bases.get))(4)            )        )((0, 0, 0, 0, 0))(baseString)    )  # -------------------------- TEST --------------------------# main :: IO ()def main():    '''Base counts and sequence displayed in GenBank format    '''    print(        genBankFormatWithBaseCounts('''\CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG\CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG\AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT\GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT\CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG\TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA\TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT\CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG\TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC\GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT''')    )  # ------------------------ GENERIC ------------------------- # chunksOf :: Int -> [a] -> [[a]]def chunksOf(n):    '''A series of lists of length n, subdividing the       contents of xs. Where the length of xs is not evenly       divible, the final list will be shorter than n.    '''    return lambda xs: reduce(        lambda a, i: a + [xs[i:n + i]],        range(0, len(xs), n), []    ) if 0 < n else []  # compose :: ((a -> a), ...) -> (a -> a)def compose(*fs):    '''Composition, from right to left,       of a series of functions.    '''    def go(f, g):        def fg(x):            return f(g(x))        return fg    return reduce(go, fs, lambda x: x)  # curry :: ((a, b) -> c) -> a -> b -> cdef curry(f):    '''A curried function derived       from an uncurried function.    '''    return lambda x: lambda y: f(x, y)  # flip :: (a -> b -> c) -> b -> a -> cdef flip(f):    '''The (curried or uncurried) function f with its       arguments reversed.    '''    return lambda a: lambda b: f(b)(a)  # foldl :: (a -> b -> a) -> a -> [b] -> adef foldl(f):    '''Left to right reduction of a list,       using the binary operator f, and       starting with an initial value a.    '''    def go(acc, xs):        return reduce(lambda a, x: f(a)(x), xs, acc)    return lambda acc: lambda xs: go(acc, xs)  # nthArrow :: (a -> b) -> Tuple -> Int -> Tupledef nthArrow(f):    '''A simple function lifted to one which applies       to a tuple, transforming only its nth value.    '''    def go(v, n):        return v if n > len(v) else [            x if n != i else f(x)            for i, x in enumerate(v)        ]    return lambda tpl: lambda n: tuple(go(tpl, n))  # succ :: Enum a => a -> adef succ(x):    '''The successor of a value.       For numeric types, (1 +).    '''    return 1 + x  # MAIN ---if __name__ == '__main__':    main()`
Output:
```DEFINITION  len=500
BASE COUNT    129 a   97 c  119 g  155 t    0 other
ORIGIN
1 CGTAAAAAAT TACAACGTCC TTTGGCTATC TCTTAAACTC CTGCTAAATG CTCGTGCTTT
61 CCAATTATGT AAGCGTTCCG AGACGGGGTG GTCGATTCTG AGGACAAAGG TCAAGATGGA
121 GCGCATCGAA CGCAATAAGG ATCATTTGAT GGGACGTTTC GTCGACAAAG TCTTGTTTCG
181 AGAGTAACGG CTACCGTCTT CGATTCTGCT TATAACACTA TGTTCTTATG AAATGGATGT
241 TCTGAGTTGG TCAGTCCCAA TGTGCGGGGT TTCTTTTAGT ACGTCGGGAG TGGTATTATA
301 TTTAATTTTT CTATATAGCG ATCTGTATTT AAGCAATTCA TTTAGGTTAT CGCCGCGATG
361 CTCGGTTCGG ACCGCCAAGC ATCTGGCTCC ACTGCTAGTG TCCTAAATTT GAATGGCAAA
421 CACAAATAAG ATTTAGCAAT TCGTGTAGAC GACCGGGGAC TTGCATGATG GGAGCAGCTT
481 TGTTAAACTA CGAACGTAAT
//```

Quackery

`   [ over size -     space swap of    swap join ]                 is justify     ( \$ n --> \$ )   [ 0 swap     [ dup \$ "" != while      cr over number\$       4 justify echo\$      5 times         [ dup \$ "" = iff             conclude done          sp          10 split swap echo\$ ]        dip [ 50 + ] again ]      2drop ]                   is prettyprint (   \$ -->   )    [ stack ]                    is adenine     (     --> s )   [ stack ]                    is cytosine    (     --> s )   [ stack ]                    is guanine     (     --> s )   [ stack ]                    is thymine     (     --> s )    [ table     adenine cytosine      guanine thymine ]          is bases       (     --> [ )        [ 4 times      [ 0 i^ bases put ]     witheach      [ \$ "ACGT" find bases         1 swap tally ]      4 times        [ sp           i^ bases dup echo          sp share echo cr ]      0 4 times         [ i^ bases take + ]      cr say " total " echo ]   is tallybases  (   [ -->   )    \$ "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG"  \$ "CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG" join  \$ "AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT" join  \$ "GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT" join  \$ "CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG" join  \$ "TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA" join  \$ "TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT" join  \$ "CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG" join  \$ "TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC" join  \$ "GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT" join  dup prettyprint cr cr tallybases`
Output:
```   0 CGTAAAAAAT TACAACGTCC TTTGGCTATC TCTTAAACTC CTGCTAAATG
50 CTCGTGCTTT CCAATTATGT AAGCGTTCCG AGACGGGGTG GTCGATTCTG
100 AGGACAAAGG TCAAGATGGA GCGCATCGAA CGCAATAAGG ATCATTTGAT
150 GGGACGTTTC GTCGACAAAG TCTTGTTTCG AGAGTAACGG CTACCGTCTT
200 CGATTCTGCT TATAACACTA TGTTCTTATG AAATGGATGT TCTGAGTTGG
250 TCAGTCCCAA TGTGCGGGGT TTCTTTTAGT ACGTCGGGAG TGGTATTATA
300 TTTAATTTTT CTATATAGCG ATCTGTATTT AAGCAATTCA TTTAGGTTAT
350 CGCCGCGATG CTCGGTTCGG ACCGCCAAGC ATCTGGCTCC ACTGCTAGTG
400 TCCTAAATTT GAATGGCAAA CACAAATAAG ATTTAGCAAT TCGTGTAGAC
450 GACCGGGGAC TTGCATGATG GGAGCAGCTT TGTTAAACTA CGAACGTAAT

cytosine 97
guanine 119
thymine 155

total 500
```

R

` #Datagene1 <- "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATATTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTATCGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTGTCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGACGACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT" #Analysis:gene2 <- gsub("\n", "", gene1) #remove \n charsgene3 <- strsplit(gene2, split = character(0)) #split into listgene4 <- gene3[[1]] #pull out character vector from listbasecounts <- as.data.frame(table(gene4)) #make table of base counts #quick helper function to print table resultsprint_row <- function(df, row){paste0(df\$gene[row],": ", df\$Freq[row])} #Print Function for Data with Results:cat(" Data: \n",    "  1:",substring(gene2, 1, 50),"\n",    " 51:",substring(gene2, 51, 100),"\n",    "101:",substring(gene2, 101, 150),"\n",    "151:",substring(gene2, 151, 200),"\n",    "201:",substring(gene2, 201, 250),"\n",    "251:",substring(gene2, 251, 300),"\n",    "301:",substring(gene2, 301, 350),"\n",    "351:",substring(gene2, 351, 400),"\n",    "401:",substring(gene2, 401, 450),"\n",    "451:",substring(gene2, 451, 500),"\n",     "\n",    "Base Count Results: \n",    print_row(basecounts,1), "\n",    print_row(basecounts,2), "\n",    print_row(basecounts,3), "\n",    print_row(basecounts,4), "\n",    "\n",    "Total Base Count:", paste(length(gene4))     )  `
Output:
```

Data:
1: CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
51: CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
101: AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
151: GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
201: CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
251: TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
301: TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
351: CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
401: TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
451: GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT

Base Count Results:
A: 129
C: 97
G: 119
T: 155

Total Base Count: 500
```

Racket

`#lang racket (define (fold-sequence seq kons #:finalise (finalise (λ x (apply values x))) . k0s)  (define (recur seq . ks)    (if (null? seq)      (call-with-values (λ () (apply finalise ks)) (λ vs (apply values vs)))      (call-with-values (λ () (apply kons (car seq) ks)) (λ ks+ (apply recur (cdr seq) ks+)))))  (apply recur (if (string? seq) (string->list (regexp-replace* #px"[^ACGT]" seq "")) seq) k0s)) (define (sequence->pretty-printed-string seq)  (define (fmt idx cs-rev) (format "~a: ~a" (~a idx #:width 3 #:align 'right) (list->string (reverse cs-rev))))  (fold-sequence    seq    (λ (b n start-idx lns-rev cs-rev)       (if (zero? (modulo n 50))	 (values (+ n 1) n (if (pair? cs-rev) (cons (fmt start-idx cs-rev) lns-rev) lns-rev) (cons b null))	 (values (+ n 1) start-idx lns-rev (cons b cs-rev))))    0 0 null null    #:finalise (λ (n idx lns-rev cs-rev)		(string-join (reverse (if (null? cs-rev) lns-rev (cons (fmt idx cs-rev) lns-rev))) "\n")))) (define (count-bases b as cs gs ts n)  (values (+ as (if (eq? b #\A) 1 0))	  (+ cs (if (eq? b #\C) 1 0))	  (+ gs (if (eq? b #\T) 1 0))	  (+ ts (if (eq? b #\G) 1 0))	  (add1 n))) (define (bioinformatics-Base_count s)  (define-values (as cs gs ts n) (fold-sequence s count-bases 0 0 0 0 0))  (printf "SEQUENCE:~%~%~a~%~%" (sequence->pretty-printed-string s))  (printf "BASE COUNT:~%-----------~%~%~a~%~%"	  (string-join (map (λ (c n) (format " ~a :~a" c (~a #:width 4 #:align 'right n)))			    '(A T C G)			    (list as ts cs gs)) "\n"))  (newline)  (printf "TOTAL: ~a~%" n)) (module+  main  (define the-string    #<<EOSCGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATATTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTATCGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTGTCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGACGACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAATEOS)  (bioinformatics-Base_count the-string))`
Output:
```SEQUENCE:

0: CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
50: CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
100: AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
150: GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
200: CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
250: TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
300: TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
350: CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
400: TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
450: GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT

BASE COUNT:
-----------

A : 129
T : 119
C :  97
G : 155

TOTAL: 500```

Raku

(formerly Perl 6)

Works with: Rakudo version 2019.07.1

It's the Letter frequency task all over again, just simpler and dressed up in different clothes.

The specs for what "pretty print" means are sadly lacking. Ah well, just makes it easily defensible if I do anything at all.

`my \$dna = join '', lines q:to/END/;    CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG    CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG    AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT    GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT    CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG    TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA    TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT    CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG    TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC    GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT    END  put pretty(\$dna, 80);put "\nTotal bases: ", +my \$bases = \$dna.comb.Bag;put \$bases.sort(~*.key).join: "\n"; sub pretty (\$string, \$wrap = 50) {    \$string.comb(\$wrap).map( { sprintf "%8d: %s", \$++ * \$wrap, \$_ } ).join: "\n"}`
Output:
```       0: CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCAATTATGTAAGCGTTCCG
80: AGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGATGGGACGTTTC
160: GTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGT
240: TCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATATTTAATTTTTCTATATAGCG
320: ATCTGTATTTAAGCAATTCATTTAGGTTATCGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
400: TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGACGACCGGGGACTTGCATGATGGGAGCAGCTT
480: TGTTAAACTACGAACGTAAT

Total bases: 500
A	129
C	97
G	119
T	155```

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.

`/*REXX program finds the number of each  base  in a  DNA  string  (along with a total). */parse arg dna .if dna==''   | dna==","  then dna= 'cgtaaaaaattacaacgtcctttggctatctcttaaactcctgctaaatg'  ,                                   'ctcgtgctttccaattatgtaagcgttccgagacggggtggtcgattctg'  ,                                   'aggacaaaggtcaagatggagcgcatcgaacgcaataaggatcatttgat'  ,                                   'gggacgtttcgtcgacaaagtcttgtttcgagagtaacggctaccgtctt'  ,                                   'cgattctgcttataacactatgttcttatgaaatggatgttctgagttgg'  ,                                   'tcagtcccaatgtgcggggtttcttttagtacgtcgggagtggtattata'  ,                                   'tttaatttttctatatagcgatctgtatttaagcaattcatttaggttat'  ,                                   'cgccgcgatgctcggttcggaccgccaagcatctggctccactgctagtg'  ,                                   'tcctaaatttgaatggcaaacacaaataagatttagcaattcgtgtagac'  ,                                   'gaccggggacttgcatgatgggagcagctttgttaaactacgaacgtaat'dna= space(dna, 0);  upper dna                   /*elide blanks from DNA; uppercase it. */say '────────length of the DNA string: '   length(dna)@.= 0                                            /*initialize the count for all bases.  */w= 1                                             /*the maximum width of a base count.   */\$=                                               /*a placeholder for the names of bases.*/       do j=1  for length(dna)                   /*traipse through the  DNA  string.    */       _= substr(dna, j, 1)                      /*obtain a base name from the DNA str. */       if pos(_, \$)==0  then \$= \$  ||  _         /*if not found before, add it to list. */       @._= @._ + 1                              /*bump the count of this base.         */       w= max(w, length(@._) )                   /*compute the maximum width number.    */       end   /*j*/say       do k=0  for 255;   z= d2c(k)              /*traipse through all possibilities.   */       if pos(z, \$)==0  then iterate             /*Was this base found?  No, then skip. */       say '     base '   z    " has a basecount of: "   right(@.z, w)       @.tot= @.tot + @.z                        /*add to a grand total to verify count.*/       end   /*k*/                               /*stick a fork in it,  we're all done. */saysay '────────total for all basecounts:'                  right(@.tot, w+1)`
output   when using the default input:
```────────length of the DNA string:  500

base  A  has a basecount of:  129
base  C  has a basecount of:   97
base  G  has a basecount of:  119
base  T  has a basecount of:  155

────────total for all basecounts:  500
```

Ring

` dna = "" +      "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG" +      "CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG" +      "AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT" +      "GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT" +      "CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG" +      "TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA" +      "TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT" +      "CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG" +      "TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC" +      "GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT" dnaBase = [:A=0, :C=0, :G=0, :T=0]lenDna = len(dna)for n = 1 to lenDna    dnaStr = substr(dna,n,1)    switch dnaStr           on "A"              strA = dnaBase["A"]              strA++              dnaBase["A"] = strA           on "C"              strC = dnaBase["C"]              strC++              dnaBase["C"] = strC           on "G"              strG = dnaBase["G"]              strG++              dnaBase["G"] = strG           on "T"              strT = dnaBase["T"]              strT++              dnaBase["T"] = strT     offnext? "A : " + dnaBase["A"] ? "T : " + dnaBase["T"]? "C : " + dnaBase["C"]? "G : " + dnaBase["G"] `
Output:
```A : 129
T : 155
C : 97
G : 119
```

Ruby

`dna = <<DNA_STRCGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATATTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTATCGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTGTCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGACGACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAATDNA_STR chunk_size = 60dna        = dna.delete("\n")size       = dna.size 0.step(size, chunk_size) do |pos|  puts "#{pos.to_s.ljust(6)} #{dna[pos, chunk_size]}"end puts dna.chars.tally.sort.map{|ar| ar.join(" : ") }puts "Total : #{dna.size}" `
Output:
```0      CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTT
60     CCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGA
120    GCGCATCGAACGCAATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCG
180    AGAGTAACGGCTACCGTCTTCGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGT
240    TCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
300    TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTATCGCCGCGATG
360    CTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTGTCCTAAATTTGAATGGCAAA
420    CACAAATAAGATTTAGCAATTCGTGTAGACGACCGGGGACTTGCATGATGGGAGCAGCTT
480    TGTTAAACTACGAACGTAAT
A : 129
C : 97
G : 119
T : 155
Total : 500
```

Rust

` use std::collections::HashMap; fn main() {    let dna = "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG\CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG\AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT\GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT\CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG\TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA\TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT\CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG\TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC\GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT";     let mut base_count = HashMap::new();    let mut total_count = 0;    print!("Sequence:");    for base in dna.chars() {        if total_count % 50 == 0 {            print!("\n{:3}: ", total_count);        }        print!("{}", base);        total_count += 1;        let count = base_count.entry(base).or_insert(0); // Return current count for base or insert 0        *count += 1;    }    println!("\n");    println!("Base count:");    println!("-----------");     let mut base_count: Vec<_> = base_count.iter().collect(); // HashMaps can't be sorted, so collect into Vec    base_count.sort_by_key(|bc| bc.0); // Sort bases alphabetically    for (base, count) in base_count.iter() {        println!("  {}: {:3}", base, count);    }    println!();    println!("Total: {}", total_count);} `
Output:
```Sequence:
0: CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
50: CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
100: AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
150: GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
200: CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
250: TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
300: TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
350: CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
400: TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
450: GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT

Base count:
-----------
A: 129
C:  97
G: 119
T: 155

Total: 500
```

Swift

`import Foundation let dna = """          CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG          CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG          AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT          GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT          CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG          TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA          TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT          CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG          TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC          GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT          """ print("input:\n\(dna)\n") let counts =  dna.replacingOccurrences(of: "\n", with: "").reduce(into: [:], { \$0[\$1, default: 0] += 1 }) print("Counts: \(counts)")print("Total: \(counts.values.reduce(0, +))")`
Output:
```input:
CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT

["C": 97, "T": 155, "G": 119, "A": 129]
Total: 500```

Tcl

`namespace path ::tcl::mathop proc process {data {width 50}} {	set len [string length \$data]	set addrwidth [string length [* [/ \$len \$width] \$width]]	for {set i 0} {\$i < \$len} {incr i \$width} {		puts "[format %\${addrwidth}u \$i] [string range \$data \$i \$i+[- \$width 1]]"	}	puts "\nBase count:"	foreach base {A C G T} {		puts "\$base     [regexp -all \$base \$data]"	}	puts "Total \$len"}  set test [string cat \			  CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG \			  CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG \			  AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT \			  GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT \			  CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG \			  TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA \			  TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT \			  CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG \			  TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC \			  GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT]process \$test 50`
Output:
```  0 CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
50 CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
100 AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
150 GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
200 CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
250 TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
300 TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
350 CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
400 TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
450 GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT

Base count:
A     129
C     97
G     119
T     155
Total 500```

Vlang

Translation of: go
`fn main() {    dna := "" +        "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG" +        "CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG" +        "AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT" +        "GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT" +        "CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG" +        "TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA" +        "TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT" +        "CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG" +        "TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC" +        "GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT"     println("SEQUENCE:")    le := dna.len    for i := 0; i < le; i += 50 {        mut k := i + 50        if k > le {            k = le        }        println("\${i:5}: \${dna[i..k]}")    }    mut base_map := map[byte]int{} // allows for 'any' base    for i in 0..le {        base_map[dna[i]]++    }    mut bases := base_map.keys()	bases.sort()     println("\nBASE COUNT:")    for base in bases {        println("    \$base: \${base_map[base]:3}")    }    println("    ------")    println("    Σ: \$le")    println("    ======")}`
Output:
```SEQUENCE:
0: CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
50: CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
100: AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
150: GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
200: CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
250: TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
300: TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
350: CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
400: TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
450: GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT

BASE COUNT:
A: 129
C:  97
G: 119
T: 155
------
Σ: 500
======
```

Wren

Translation of: Go
Library: Wren-fmt
Library: Wren-sort
Library: Wren-trait
`import "/fmt" for Fmtimport "/sort" for Sortimport "/trait" for Stepped var dna = "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG" +          "CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG" +          "AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT" +          "GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT" +          "CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG" +          "TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA" +          "TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT" +          "CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG" +          "TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC" +          "GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT" System.print("SEQUENCE:")var le = dna.countfor (i in Stepped.new(0...le, 50)) {    var k = i + 50    if (k > le) k = le    System.print("%(Fmt.d(5, i)): %(dna[i...k])")}var baseMap = {} // allows for 'any' basefor (i in 0...le) {    var d = dna[i]    var v = baseMap[d]    baseMap[d] = !v ? 1 : v + 1}var bases = baseMap.keys.toListSort.quick(bases) System.print("\nBASE COUNT:")for (base in bases) {    System.print("    %(base): %(Fmt.d(3, baseMap[base]))")}System.print("    ------")System.print("    Σ: %(le)")System.print("    ======")`
Output:
```SEQUENCE:
0: CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
50: CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
100: AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
150: GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
200: CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
250: TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
300: TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
350: CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
400: TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
450: GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT

BASE COUNT:
A: 129
C:  97
G: 119
T: 155
------
Σ: 500
======
```

XPL0

`char    Bases;int     Counts(256), Cnt, I, Ch;[Bases:= "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATATTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTATCGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTGTCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGACGACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAATx "; for I:= 0 to 255 do Counts(I):= 0;Format(5, 0);Cnt:= 0;I:= 0;loop    [repeat Ch:= Bases(I);                I:= I+1;                if Ch = ^x then quit;                Counts(Ch):= Counts(Ch)+1;                ChOut(0, Ch);        until   Ch = \LF\\$0A;        RlOut(0, float(Cnt));  Text(0, ": ");        Cnt:= Cnt + 50;        ];CrLf(0);  CrLf(0);Text(0, "Base counts A: ");  IntOut(0, Counts(^A));Text(0, " C: ");  IntOut(0, Counts(^C));Text(0, " G: ");  IntOut(0, Counts(^G));Text(0, " T: ");  IntOut(0, Counts(^T));Text(0, "Total: ");  IntOut(0, Cnt);  CrLf(0);]`
Output:
```    0: CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
50: CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
100: AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
150: GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
200: CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
250: TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
300: TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
350: CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
400: TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
450: GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT

Base counts A: 129 C: 97 G: 119 T: 155
Total: 500
```

zkl

`bases:=#<<<"CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATATTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTATCGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTGTCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGACGACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT" - " \n";#<<< [0..*,50].zipWith(fcn(n,bases){ println("%6d: %s".fmt(n,bases.concat())) },   bases.walker().walk.fp(50)).pump(Void);  // .pump forces the iterator println("\nBase Counts: ", bases.counts().pump(String,Void.Read,"%s: %d  ".fmt));println("Total: ",bases.len());`
Output:
```     0: CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG
50: CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG
100: AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT
150: GGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTT
200: CGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGG
250: TCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATA
300: TTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTAT
350: CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG
400: TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC
450: GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT

Base Counts: A: 129  C: 97  G: 119  T: 155
Total: 500
```