DEV Community

Daily Challenge #175 - Complementary DNA

dev.to staff on January 29, 2020

Setup Deoxyribonucleic acid (DNA) is a chemical found in the nucleus of cells and carries the "instructions" for the development and fun...

Read full post

Isaac Lyman • Jan 29 '20 • Edited

This sounds like a one-liner in JS. Let's see...

const DNA_strand = str => str.split('').map(l => l === 'A' ? 'T' : l === 'T' ? 'A' : l === 'G' ? 'C' : l === 'C' ? 'G' : '').join('');

As a bonus, any non-DNA letters will be ignored.

Vansh.c • Aug 3 '23

i am fresher can you tell me what does this ( => )operator do.

Your help is appreciated.

Isaac Lyman • Aug 3 '23

It’s an arrow function (or anonymous function).

function(a, b) {return a + b;}

Is (almost) the same as:

(a, b) => a + b

There are a few differences but most of the time they aren’t anything to worry about. If you care, this is a good overview: levelup.gitconnected.com/7-differe...

Ruan Engelbrecht • Jan 29 '20

JavaScript:

const mapping = {
  A: 'T',
  T: 'A',
  C: 'G',
  G: 'C'
};

const DNA_strand = seq =>
  seq
    .split('')
    .map(x => mapping[x])
    .join('');

Jehiel Martinez • Jan 29 '20 • Edited

JS:

function DNA_strand (str) {
    let result = '';
    for(i=0; i<str.length; i++){    
        switch (str[i]) {
            case 'A':
                result = result + 'T';
                break;
            case 'T':
                result = result + 'A';
                break;
            case 'C':
                result = result + 'G';
                break;
            case 'G':
                result = result + 'C';
                break;
            default:
                return 'Your DNA is not from this planet';
        }
    }
    return result
};
```

Avalander • Jan 30 '20

Another javascript solution

const complementaryKeys = (prev, [ a, b ]) =>
  Object.assign(prev, {
    [a]: b,
    [b]: a,
  })

const pair = (...entries) => {
  const pairs = entries.reduce(complementaryKeys, {})
  return x => pairs[x] || ''
}

const dnaPairs = pair(
  [ 'A', 'T' ],
  [ 'C', 'G' ]
)

const mapStr = fn => str =>
  str.split('')
    .map(fn)
    .join('')

const dnaStrand = mapStr(dnaPairs)

Valts Liepiņš • Jan 29 '20

Ruby keeps on pleasantly surprising me:

def DNA_strand str
    str.tr 'ATCG', 'TAGC'
end

Valts Liepiņš • Jan 29 '20

Seems like Lua also has a neat solution:

function DNA_strand(str)
    return (str:gsub('.', {A='T',T='A',C='G',G='C'}))
end

Ryan Beckett • Jan 29 '20 • Edited

Swift:


func DNA_strand( _ dna: String) -> String {
  let swapTable = [("A", "T"), ("T", "A"), ("C", "G"), ("G", "C")]

  return dna.map { char in
    swapTable.map { (key, value) in
      String(char) == key ? value as String : ""
    }.joined()
  }.joined()

}

I'm trying to complete these everyday for 30 days (hopefully more) - feedback more that welcome here please, thank you! Github PR

Daniel Barwikowski • Jan 30 '20

private static string DNA_strand(string dna)
{
    var sb = new StringBuilder();
    var bytes = Encoding.ASCII.GetBytes(dna);
    foreach (var b in bytes)
    {
        if ((b & 0b0000_0010) == 0)
        {
            sb.Append((char) (b ^ 0b0001_0101));
        }
        else
        {
            sb.Append((char) (b ^ 0b0000_0100));
        }
    }

    return sb.ToString();
}

Daniel Barwikowski • Jan 30 '20 • Edited

A   100 0001
T   101 0100

C   100 0011
G   100 0111

---- -|-- - this bit always changes

---| ---| - this bits only changes when ---- --|- is set to 0

Craig McIlwrath • Jan 29 '20 • Edited

Haskell:

complement :: Char -> Either String Char
complement 'A' = Right 'T'
complement 'T' = Right 'A' 
complement 'C' = Right 'G' 
complement 'G' = Right 'C' 
complement c = Left $ "invalid nucleic acid " ++ [c]

dnaStrand :: String -> Either String String 
dnaStrand = sequence . map complement

Returns a Left value if there is a character other than AGTC

Klára Neumannová • Jan 29 '20

PHP:

function dnaStrand(string $dnaString)
{
    $symbols = str_split($dnaString);

    $complementaryString = '';
    foreach ($symbols as $symbol) {
        switch ($symbol) {
            case 'A':
                $complementaryString .= 'T';
                break;
            case 'T':
                $complementaryString .= 'A';
                break;  
            case 'C':
                $complementaryString .= 'G';
                break;
            case 'G':
                $complementaryString .= 'C';
                break;
            default:
                return "Is '" . $symbol ."' really in your DNA?";
        }
    }

    return $complementaryString;
}

There is always a better solution, suggest one please - I'm here to learn more .)

Klára Neumannová • Jan 29 '20

OK, I found another one for PHP (7.2 and higher):

function dnaStrand(string $dnaString)
{
    $translateTable = ['A' => 'T', 'T' => 'A', 'C' => 'G', 'G' => 'C'];

    $symbols = str_split($dnaString);

    $complementaryString = '';
    foreach ($symbols as $symbol) {
        $complementaryString .= $translateTable[$symbol] ?? '';
    }

    return $complementaryString;
}

Dimitri Marion • Jan 29 '20

Javascript using Map:

const dnaMatch = new Map();
dnaMatch.set("A", "T");
dnaMatch.set("T", "A");
dnaMatch.set("C", "G");
dnaMatch.set("G", "C");

const DNA_strand = (dna) => {
    const matchedDNA = Array.prototype.map.call(dna, sym => dnaMatch.get(sym));

    return matchedDNA.join('');
};

Kyle Jones • Jan 29 '20 • Edited

In Python:

def DNA_strand(strand):
    '''
    Returns the complementary strand of DNA for a given strand.
    '''
    complementary_strand = ""
    for symbol in strand:
        if symbol == 'A':
            complementary_strand += 'T'
            continue
        if symbol == 'T':
            complementary_strand += 'A'
            continue
        if symbol == 'C':
            complementary_strand += 'G'
            continue
        if symbol == 'G':
            complementary_strand += 'C'
            continue
    return complementary_strand


print(DNA_strand("ATTGC"))
print(DNA_strand("GTTAAC"))

kesprit • Jan 30 '20

Swift solution :

func dnaStand(dna: String) -> String {
    let dnaMatching: [Character:Character] = ["A":"T","T":"A","C":"G","G":"C"]
    return dna.reduce(into: "") { $0.append(dnaMatching[$1] ?? "" as! Character) }
}


dnaStand(dna:"ATTGC")
dnaStand(dna:"GTTAAC")
dnaStand(dna:"AAAA")
dnaStand(dna:"CTACC")
dnaStand(dna:"GTAT")

zoe-j-m • Jan 30 '20

Scala

def DNA_strand(dna : String) : String = (dna flatMap ("ATCG" zip "TAGC").toMap.get ).mkString