dev.to staff

Posted on Mar 25, 2020

Daily Challenge #212 - DNA to RNA

#challenge

Deoxyribonucleic acid, DNA is the primary information storage molecule in biological systems. It is composed of four nucleic acid bases Guanine ('G'), Cytosine ('C'), Adenine ('A'), and Thymine ('T').

Ribonucleic acid, RNA, is the primary messenger molecule in cells. RNA differs slightly from DNA its chemical structure and contains no Thymine. In RNA Thymine is replaced by another nucleic acid Uracil ('U').

Create a function which translates a given DNA string into RNA.

For example:
DNAtoRNA("GCAT") returns ("GCAU")
The input string can be of arbitrary length - in particular, it may be empty. All input is guaranteed to be valid, i.e. each input string will only ever consist of 'G', 'C', 'A' and/or 'T'.

Tests

DNAtoRNA("TTTT")
DNAtoRNA("GCAT")
DNAtoRNA("GACCGCCGCC")

Good luck!

This challenge comes from torret on CodeWars. Thank you to CodeWars, who has licensed redistribution of this challenge under the 2-Clause BSD License!

Want to propose a challenge idea for a future post? Email yo+challenge@dev.to with your suggestions!

Top comments (11)

@nobody • Mar 25 '20

Super simple! I love the polyglot answers 👌🏿
Clojure

(ns dailyChallenge.206)

(def- NUCLEOTIDES
  "Valid Nucleotides"
  (re-pattern "G|C|T|A|U"))

(defn DNA->RNA [sequence] 
  "validates and converts DNA pairs to RNA"
 {:pre [(!= "" (re-match NUCLEOTIDES (uppercase sequence))]}
  ;;Java.String method interop
  (.toUpperCase (replace sequence #"t|T" "u")))

bravemaster619 • Mar 25 '20

Ruby

def DNAtoRNA(dna)
  reg_dna = /^(G|C|A|T)*$/i
  if dna.match(reg_dna)
    dna.gsub(/(T|t)/, 'U').upcase
  else
    raise "Not a valid DNA string"
  end
end

JavaScript

const DNAtoRNA = (dna) => {
   const dnaRegex = /^(G|C|A|T)*$/gi
   if (dnaRegex.test(dna)) {
      return dna.replace(/t/gi, 'U').toUpperCase()
   } else {
      throw new Error("Not a valid DNA string")
   }
}

PHP

function DNAtoRNA($dna) {
    $dnaRegex = "/^(G|C|A|T)*$/i";
    if (preg_match($dnaRegex, $dna)) {
        return strtoupper(str_ireplace("T", "U", $dna));
    } else {
        throw new \Exception("Not a valid DNA string");
    };
}

Mark vd Sman • Mar 26 '20

I wanted to see what this challenge was about, because I like these combinations of combined fields. So nice to see this come by!
But I am uncomfortable with the fact that this is not the correct way to code transcription (DNA to RNA). RNA is complementary to DNA because it is double-stranded: therefore GCAT should result in CGUA (on a side note: direction is also very important).

I'm curious if there is any particular reason why it is done in the way you described it?

Mihail Malo • Mar 26 '20 • Edited

Roost

fn dtoa(dna: &str) -> String {
    dna.chars().map(|c| match c {
        'G' | 'C' | 'A' => c,
        'T' => 'U',
        _ => panic!("you did this to yourself"),
    }).collect()
}
fn main() {
    for x in &["TTTT", "GCAT", "GACCGCCGCC", "💩"] {
        println!("{}=>{}", x, dtoa(x));
    }
}

"Rust"

use itertools::Itertools; // 0.9.0

#[derive(Debug)]
enum DToAError {
    Scat(usize, char),
}
use DToAError::*;

impl std::fmt::Display for DToAError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            Scat(i, c) => write!(f, "Is this a joke? At index {}, what is `{}`?! No you can't \"have the processed values back\", get out!", i, c),
        }
    }
}

impl std::error::Error for DToAError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        None
    }
}

fn dtoa(dna: &str) -> Result<String, DToAError> {
    dna.chars()
        .enumerate()
        .map(|(i, c)| {
            Ok(match c {
                'G' | 'C' | 'A' => c,
                'T' => 'U',
                _ => return Err(Scat(i, c)),
            })
        })
        .fold_results(String::with_capacity(dna.len()), |mut s, c| {
            s.push(c);
            s
        })
}
fn main() {
    for x in &["TTTT", "GCAT", "GACCGCCGCC", "💩"] {
        match dtoa(x) {
            Ok(res) => println!("{}=>{}", x, res),
            Err(err) => println!("{}=>OOPS: {}", x, err),
        }
    }
}

It works lol

When you don't listen at all

fn main() {
    for x in &["TTTT", "GCAT", "GACCGCCGCC", "💩"] {
        println!("{}=>{}", x, x.replace('T', "U"))
    }
}

James • Mar 25 '20 • Edited

Javascript solution:

function DNAtoRNA(dna) {
  return dna.replace(/T/g, 'U');
}

Ryan Burmeister-Morrison • Mar 26 '20 • Edited

Ruby

def DNAToRNA(str); str.gsub(/T/i, 'U') end

Nilbert • Mar 26 '20

Ruby

DNAtoRNA = ->(str) { str.gsub!(/T/,'U')}
DNAtoRNA.call('TTTT')
=> "UUUU"
DNAtoRNA.call('GCAT')
=> "GCAU"

Amin • Mar 25 '20

Elm

dnaToRna : String -> String
dnaToRna = String.replace "T" "U"

kesprit • Mar 30 '20

My Swift solution :

func DNAtoRNA(string: String) -> String {
    String(string.map { $0 == "T" ? "U" : $0 })
}

Vidit Sarkar • Mar 25 '20

Python solution

DNAtoRNA = lambda dna : dna.replace('T','U')

View full discussion (11 comments)

DEV Community

Daily Challenge #212 - DNA to RNA

Tests

Top comments (11)

Roost

"Rust"

When you don't listen at all

Read next

🚗💰 Car Coin Hunter: My Latest Submission in the Game Challenge! 🎮💪

A Day in the Life of a DevOps Engineer: Real Stories and Challenges

Creating a Dashboard with Streamlit

Writing Terraform Configurations