Bioinformatics/base count: Difference between revisions

{{Template:Strings}}

<br><br>

=={{header|11l}}==

{{trans|Python}}

 

DefaultDict[Char, Int] d

L(c) dna

TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC\

GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT"

 

{{out}}

TOT= 500

</pre>

 

=={{header|Action!}}==

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

 

PROC PrettyPrint(PTR ARRAY data INT count,gsize,gcount)

 

LMARGIN=oldLMARGIN ;restore left margin on the screen

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Bioinformatics_base_count.png Screenshot from Atari 8-bit computer]

Total: 500

</pre>

=={{header|Ada}}==

 

procedure Base_Count is

Put (Test);

Count (Test);

{{out}}

<pre> 1.. 70 CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCAATTATGT

T: 155

Total: 500</pre>

=={{header|ALGOL 68}}==

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

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

# totals #

print( ( newline, "Total: ", whole( total, - width ), newline ) )

{{out}}

<pre>

Total: 500

</pre>

 

=={{header|Arturo}}==

 

CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG

CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG

]

 

 

{{out}}

450 : GACCGGGGAC TTGCATGATG GGAGCAGCTT TGTTAAACTA CGAACGTAAT

Total count => A: 129 T: 155 G: 119 C: 97</pre>

=={{header|AWK}}==

# syntax: GAWK -f BIOINFORMATICS_BASE_COUNT.AWK

# converted from FreeBASIC

exit(0)

}

{{out}}

<pre>

500 total

</pre>

 

=={{header|C}}==

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

#include<string.h>

#include<stdlib.h>

return 0;

}

Run and output :

<pre>

Total: 500

</pre>

=={{header|C++}}==

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

#include <string>

#include <iostream>

delete d;

return 0;

{{out}}

<pre>Sequence:

{{libheader| Generics.Collections}}

{{libheader| System.Console}}

program base_count;

 

 

readln;

Color [https://ibb.co/VH5pR29]

{{out}}

Σ: 500

======</pre>

 

=={{header|Factor}}==

math.statistics prettyprint qw sequences sorting ;

 

[ "TOTAL: " write [ second ] [ + ] map-reduce . ] bi ;

 

{{out}}

<pre>

 

=={{header|Forth}}==

( Gforth 0.7.3 )

 

 

dnacode basecount

{{out}}

<pre>

==========

</pre>

=={{header|FreeBASIC}}==

#define GRP 3

 

print " T: " + str(bases(3))

print

{{out}}

<pre> 1-- 36: CGT AAA AAA TTA CAA CGT CCT TTG GCT ATC TCT TAA

 

total: 500</pre>

 

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Go}}==

 

import (

fmt.Println(" Σ:", le)

fmt.Println(" ======")

 

{{out}}

======

</pre>

=={{header|Haskell}}==

import Data.List.Split (chunksOf)

import Text.Printf (printf, IsChar(..), PrintfArg(..), fmtChar, fmtPrecision, formatString)

putStrLn "\nBase Counts:"

mapM_ (uncurry (printf "%2s: %2d\n")) $ baseCounts test

{{out}}

<pre>Sequence:

=={{header|J}}==

'''Solution:'''

totalBases=: #@,

 

'%5s: %4d' printf countBases y

'-----------\nTotal = %3d' printf totalBases y

'''Required Example:'''

CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG

CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG

A: 129

-----------

=={{header|Java}}==

For counting the bases, we simply use a <code>HashMap</code>, and then use the <code>Map.merge</code>, inserting <code>1</code>, and using <code>Integer::sum</code> as the aggregation function. This effectively creates a <code>Map</code> that keeps a running count for us. Java ''does'' provide the <code>groupingBy</code> and <code>counting</code> collectors, which would ''generally'' make these kinds of operation easier. However, <code>String</code>’s <code>chars()</code> method returns a <code>IntStream</code>, 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 <code>MultiSet</code>, 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 <code>String</code> is a poor choice, as opposed to, say <code>byte[]</code>. For the purpose of this exercise though, using <code>byte[]</code> would just add uninteresting casts and bloat to the code, so we stick to <code>String</code>.

 

import java.util.Map;

 

}

 

{{out}}

<pre>

 

=={{header|JavaScript}}==

 

const bases = ['A', 'C', 'G', 'T'];

prettyPrint(seq);

printBases(seq, bases);

{{out}}

<pre>

Total: 500

</pre>

=={{header|jq}}==

=== Naive (in-memory) solution ===

First, some general utility functions:

 

# Create a bag of words, i.e. a JSON object with counts of the items in the stream

def bow(stream):

def read_seq:

reduce inputs as $line (""; . + $line);

def pp_sequence($cols):

range(0; length / $cols) as $i

{{out}}

The invocation:

jq -nrR -f base_count.jq base_count.txt

0: CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG

50: CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG

G: 119

T: 155

 

=== Memory-efficient solution ===

 

# "bow" = bag of words, i.e. a JSON object with counts

 

# To illustrate reformatting:

{{out}}

0: CGTAAAAAATTACAACGTCCTTTGGCTATCTCT

33: TAAACTCCTGCTAAATGCTCGTGCTTTCCAATT

G: 119

T: 155

=={{header|Julia}}==

"CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG" *

"CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG" *

 

printcounts(sequence)

<pre>

500nt DNA sequence:

Total 500

</pre>

=={{header|Kotlin}}==

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

 

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

 

 

println("SEQUENCE:")

}

println("BASE:")

sequence.groupingBy { it }.eachCount().forEach { (k, v) ->

const val BASE_SEQUENCE = "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATATTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTATCGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTGTCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGACGACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT"

 

 

{{out}}

 

=={{header|Lambdatalk}}==

{def DNA CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGATTCTGCTTATAACACTATGTTCTTATGAAATGGATGTTCTGAGTTGGTCAGTCCCAATGTGCGGGGTTTCTTTTAGTACGTCGGGAGTGGTATTATATTTAATTTTTCTATATAGCGATCTGTATTTAAGCAATTCATTTAGGTTATCGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTGTCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGACGACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT}

-> DNA

A+C+G+T = {+ {S}}

-> A+C+G+T = 500

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

ATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTGAGGACAAAGGTCAAGATGGAGCGCATCGAACGC\

AATAAGGATCATTTGATGGGACGTTTCGTCGACAAAGTCTTGTTTCGAGAGTAACGGCTACCGTCTTCGA\

ends = Rest[Accumulate[Prepend[StringLength /@ parts, 0]]];

StringRiffle[MapThread[ToString[#1] <> "-" <> ToString[#2] <> ": " <> #3 &, {begins, ends, parts}], "\n"]

{{out}}

<pre>1-70: CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCAATTATGT

T: 155

A: 129</pre>

=={{header|MATLAB}} / {{header|Octave}}==

 

function r = base_count(f)

fid = fopen(f,'r');

fprintf(1, '\nTotal: %d\n\n', sum(nn));

end;

 

 

 

</pre>

=={{header|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 strutils

 

 

when isMainModule:

 

{{out}}

CACAAATAAG ATTTAGCAAT TCGTGTAGAC GACCGGGGAC TTGCATGATG GGAGCAGCTT 480

TGTTAAACTA CGAACGTAAT</pre>

=={{header|Pascal}}==

{$IFDEF FPC}

{$MODE DELPHI}//String = AnsiString

OutFormatBase(TestDNA,50);

Cnt(TestDNA);

{{out}}

<pre> DNA base sequence

T 155

Total base count 500</pre>

=={{header|Perl}}==

use warnings;

use feature 'say';

CGCCGCGATGCTCGGTTCGGACCGCCAAGCATCTGGCTCCACTGCTAGTG

TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC

{{out}}

<pre> 1: CGTAAAAAAT TACAACGTCC TTTGGCTATC TCTTAAACTC CTGCTAAATG

G: 119

T: 155</pre>

=={{header|Phix}}==

<span style="color: #008080;">constant</span> <span style="color: #000000;">dna</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">substitute</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"""

CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\nBase counts: A:%d, C:%d, G:%d, T:%d, total:%d\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">acgt</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

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

</pre>

 

=={{header|PicoLisp}}==

CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG\

AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT\

GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT" )

R )

(for I R (println I))

{{out}}

<pre>

Total: 500

</pre>

=={{header|PureBasic}}==

"CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG" +

"AGGACAAAGGTCAAGATGGAGCGCATCGAACGCAATAAGGATCATTTGAT" +

PrintN(~"\n" + "Total = " + RSet(Str(sigma), 5))

Input()

{{out}}

<pre>

 

Total = 500</pre>

=={{header|Python}}==

===Procedural===

 

def basecount(dna):

GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT'''

seq_pp(sequence)

 

{{out}}

T: 155

TOT= 500</pre>

 

===Functional===

Sequence and base counts displayed in GenBank format.

{{Works with|Python|3.7}}

 

from itertools import count

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>DEFINITION len=500

481 TGTTAAACTA CGAACGTAAT

//</pre>

=={{header|Quackery}}==

 

[ over size -

space swap of

$ "GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT" join

 

{{out}}

total 500

</pre>

=={{header|R}}==

#Data

gene1 <- "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG

)

 

 

{{out}}

Total Base Count: 500

</pre>

=={{header|Racket}}==

 

 

(define (fold-sequence seq kons #:finalise (finalise (λ x (apply values x))) . k0s)

EOS

)

 

{{out}}

 

TOTAL: 500</pre>

=={{header|Raku}}==

(formerly Perl 6)

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

 

CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG

CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG

sub pretty ($string, $wrap = 50) {

$string.comb($wrap).map( { sprintf "%8d: %s", $++ * $wrap, $_ } ).join: "\n"

{{out}}

<pre> 0: CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTTCCAATTATGTAAGCGTTCCG

G 119

T 155</pre>

=={{header|REXX}}==

A little extra boilerplate was added to verify correct coding of the bases in a DNA string and the alignment of the (totals) numbers.

{{out|output|text=&nbsp; when using the default input:}}

<pre>

 

=={{header|Ring}}==

dna = "" +

"CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG" +

? "C : " + dnaBase["C"]

? "G : " + dnaBase["G"]

{{out}}

<pre>

C : 97

G : 119

</pre>

 

=={{header|Ruby}}==

CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG

CTCGTGCTTTCCAATTATGTAAGCGTTCCGAGACGGGGTGGTCGATTCTG

puts dna.chars.tally.sort.map{|ar| ar.join(" : ") }

puts "Total : #{dna.size}"

{{out}}

<pre>0 CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATGCTCGTGCTTT

 

=={{header|Rust}}==

use std::collections::HashMap;

 

println!("Total: {}", total_count);

}

{{out}}

<pre>

Total: 500

</pre>

=={{header|Swift}}==

 

 

let dna = """

 

print("Counts: \(counts)")

 

{{out}}

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

Total: 500</pre>

=={{header|Tcl}}==

 

proc process {data {width 50}} {

TCCTAAATTTGAATGGCAAACACAAATAAGATTTAGCAATTCGTGTAGAC \

GACCGGGGACTTGCATGATGGGAGCAGCTTTGTTAAACTACGAACGTAAT]

{{out}}

<pre> 0 CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG

T 155

Total 500</pre>

 

=={{header|Wren}}==

{{libheader|Wren-fmt}}

{{libheader|Wren-sort}}

 

var dna = "CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG" +

System.print(" ------")

System.print(" Σ: %(le)")

 

{{out}}

 

=={{header|XPL0}}==

int Counts(256), Cnt, I, Ch;

[Bases:= "

Text(0, "

Total: "); IntOut(0, Cnt); CrLf(0);

 

{{out}}

Total: 500

</pre>

=={{header|zkl}}==

#<<<"

CGTAAAAAATTACAACGTCCTTTGGCTATCTCTTAAACTCCTGCTAAATG

 

println("\nBase Counts: ", bases.counts().pump(String,Void.Read,"%s: %d ".fmt));

{{out}}

<pre>