Wednesday, 6 October 2021

Open Reading Frames (Rosalind)

rosalind


Halo teman-teman, apa kabar? Kali ini saya ingin membahas sedikit tentang salah satu problem yang ada di web rosalind.info. Judulnya ialah "Open Reading Frames". Sebagai acuan, teman-teman bisa cek dahulu problem yang akan kita bahas (disini). 



Di problem ini kita akan disajikan sebuah string dalam bentuk FASTA format yang berisikan urutan DNA, sebut saja string s. Untuk menjawab problem ini, terlebih dahulu kita perlu mengetahui apa itu open reading frame. 

Singkatnya, Open reading frame (ORF) ialah cara membaca string yang dibagi atas 4 langkah. 

Langkah pertama ialah, mengubah string DNA menjadi string RNA. Misal, 

"ATGGCCATGGCGTGA" menjadi "AUGGCCAUGGCGUGA". 

Langkah kedua ialah membagi string tersebut per 3 huruf. Kelanjutan dari string diatas, yaitu string  

"AUGGCCAUGGCGUGA" diubah menjadi

AUG-GCC-AUG-GCG-UGA,
UGG-CCA-UGG-CGU,
dan GGC-CAU-GGC-GUG. 

Langkah ketiga ialah membuat reverse complement dari "string per 3 huruf" diatas (tanpa menghapusnya). Kita lanjutkan, 

reverse complement dari AUG-GCC-AUG-GCG-UGA ialah UAC-CGG-UAC-CGC-ACU,
reverse complement dari UGG-CCA-UGG-CGU ialah ACC-GGU-ACC-GCA ,
reverse complement dari GGC-CAU-GGC-GUG ialah CGG-GUA-CCG-CAC

Langkah keempat ialah mengubah semua "string per 3 huruf" diatas (ada 6) menjadi string protein. Sebelum ini, kita pernah men-translate string RNA ke protein menggunakan tabel kodon RNA. Langkah ini sama seperti itu. Seperti aturan translate RNA, disini kita akan men-translate mulai dari start kodon (AUG) sampai ke stop kodon (UAA, UGA, UAG). Misal, 

translate dari AUG-GCC-AUG-GCG-UGA ialah MAMA.

Untuk lebih memahami open reading frame, saya ada video referensinya disini. 

Berikut kode pengerjaannya dalam bahasa java :
  1. static String reverseComplement (String s, HashMap<Character, Character> thisPair) {
  2. char[] ch = s.toCharArray();
  3. int n = ch.length;
  4. for (int i = 0; i < n / 2; i++) {
  5. char swap = ch[i];
  6. ch[i] = ch[n - 1 - i];
  7. ch[n - 1 - i] = swap;
  8. }
  9. s = "";
  10. for (char x : ch) {
  11. s += thisPair.get(x);
  12. }
  13. return s;
  14. }
  15. static void solve() {
  16. HashMap<Character, Character> thisPair = new HashMap<>();
  17. thisPair.put('A', 'T');
  18. thisPair.put('T', 'A');
  19. thisPair.put('G', 'C');
  20. thisPair.put('C', 'G');
  21. HashMap<String, String> codonTable = new HashMap<>();
  22. codonTable.put("ATT", "I");
  23. codonTable.put("ATC", "I");
  24. codonTable.put("ATA", "I");
  25. codonTable.put("ATG", "M");
  26. codonTable.put("ACT", "T");
  27. codonTable.put("ACC", "T");
  28. codonTable.put("ACA", "T");
  29. codonTable.put("ACG", "T");
  30. codonTable.put("AAT", "N");
  31. codonTable.put("AAC", "N");
  32. codonTable.put("AAA", "K");
  33. codonTable.put("AAG", "K");
  34. codonTable.put("AGT", "S");
  35. codonTable.put("AGC", "S");
  36. codonTable.put("AGA", "R");
  37. codonTable.put("AGG", "R");
  38. codonTable.put("TTT", "F");                  
  39. codonTable.put("TTC", "F");                  
  40. codonTable.put("TTA", "L");                  
  41. codonTable.put("TTG", "L");                  
  42. codonTable.put("TCT", "S");                  
  43. codonTable.put("TCC", "S");                  
  44. codonTable.put("TCA", "S");                  
  45. codonTable.put("TCG", "S");                  
  46. codonTable.put("TAT", "Y");                  
  47. codonTable.put("TAC", "Y");                  
  48. codonTable.put("TAA", "Stop");               
  49. codonTable.put("TAG", "Stop");               
  50. codonTable.put("TGT", "C");                  
  51. codonTable.put("TGC", "C");                  
  52. codonTable.put("TGA", "Stop");
  53. codonTable.put("TGG", "W");                  
  54. codonTable.put("CTT", "L");
  55. codonTable.put("CTC", "L");
  56. codonTable.put("CTA", "L");
  57. codonTable.put("CTG", "L");
  58. codonTable.put("CCT", "P");
  59. codonTable.put("CCC", "P");
  60. codonTable.put("CCA", "P");
  61. codonTable.put("CCG", "P");
  62. codonTable.put("CAT", "H");
  63. codonTable.put("CAC", "H");
  64. codonTable.put("CAA", "Q");
  65. codonTable.put("CAG", "Q");
  66. codonTable.put("CGT", "R");
  67. codonTable.put("CGC", "R");
  68. codonTable.put("CGA", "R");
  69. codonTable.put("CGG", "R");
  70. codonTable.put("GTT", "V");
  71. codonTable.put("GTC", "V");
  72. codonTable.put("GTA", "V");
  73. codonTable.put("GTG", "V");
  74. codonTable.put("GCT", "A");
  75. codonTable.put("GCC", "A");
  76. codonTable.put("GCA", "A");
  77. codonTable.put("GCG", "A");
  78. codonTable.put("GAT", "D");
  79. codonTable.put("GAC", "D");
  80. codonTable.put("GAA", "E");
  81. codonTable.put("GAG", "E");
  82. codonTable.put("GGT", "G");
  83. codonTable.put("GGC", "G");
  84. codonTable.put("GGA", "G");
  85. codonTable.put("GGG", "G"); 

  87. Scanner sc = new Scanner(System.in);
  88. sc.next();
  89. String s = "";
  90. while (sc.hasNext()) {
  91. s += sc.next();
  92. }
  93. Vector<String> res = new Vector<>();
  94. HashMap<String, Boolean> udah = new HashMap<>();
  95. for (int j = 0; j < 3; j++) {
  96. for (int i = 0; i + j <= s.length() - 3; i += 3) {
  97. int ii = i + j;
  98. String now = s.substring(ii, ii + 3);
  99. if (now.equals("ATG")) {
  100. res.add("");
  101. }
  102. else if (now.equals("TAA") || now.equals("TAG") || now.equals("TGA")) {
  103. for (String ss : res) {
  104. if (udah.get(ss) == null) out.println(ss);
  105. udah.put(ss, true);
  106. }
  107. res = new Vector<>();
  108. }
  109. for (int k = 0; k < res.size(); k++) {
  110. res.set(k, res.get(k) + codonTable.get(now));
  111. }
  112. }
  113. res = new Vector<>();
  114. }
  115. s = reverseComplement(s, thisPair);
  116. res = new Vector<>();
  117. for (int j = 0; j < 3; j++) {
  118. for (int i = 0; i + j <= s.length() - 3; i += 3) {
  119. int ii = i + j;
  120. String now = s.substring(ii, ii + 3);
  121. if (now.equals("ATG")) {
  122. res.add("");
  123. }
  124. else if (now.equals("TAA") || now.equals("TAG") || now.equals("TGA")) {
  125. for (String ss : res) {
  126. if (udah.get(ss) == null) out.println(ss);
  127. udah.put(ss, true);
  128. }
  129. res = new Vector<>();
  130. }
  131. for (int k = 0; k < res.size(); k++) {
  132. res.set(k, res.get(k) + codonTable.get(now));
  133. }
  134. }
  135. res = new Vector<>();
  136. }
  137. }    
    138.   
Pertama, kita buat katalog tabel kodon RNA/DNA dahulu. Untuk lebih cepatnya kita bisa langsung memakai tabel kodon DNA, jadi bisa langsung men-translate DNA menjadi protein (baris 21-85). 

Kemudian, kita jadikan string dari input (string s) menjadi "string per 3 huruf " dan langsung men-translate-nya menjadi protein (baris 95-114). 

Jangan lupa membuat reverse complement dari string s (baris 115), lalu men-translate-nya seperti langkah diatas (baris 117-136). 

Seperti yang teman-teman lihat; disini, saya memakai fungsi next() (baris 91) untuk meng-input data string. Sebelumnya saya juga menggunakan hasNext() (baris 90) dikarenakan fungsi tersebut mampu meng-input data yang tidak diketahui jumlahnya. Fungsi tersebut sangat cocok jika dipakai untuk menangani input dengan format FASTA. 

Sedangkan untuk output-nya saya memakai fungsi out.println() (baris 126). Fungsi tersebut juga adalah modifikasi dari fungsi System.out.println() yang merupakan fungsi default di java. Untuk lebih jelasnya teman-teman bisa melihat kode tambahan untuk memodifikasi fungsi tersebut (input maupun output) di versi lengkap kode saya di github. 

Sekian dari saya. Jika teman-teman ingin menanyakan sesuatu, teman-teman bisa menulisnya di kolom komentar. Semoga bermanfaat dan sampai jumpa di artikel berikutnya!


Referensi :
Sumber gambar 1 :https://www.facebook.com/ProjectRosalind/
Sumber gambar 2 :https://www.pngdownload.id/png-e9lrt0/
Diposting oleh
Label: , ,

No comments:

Post a Comment

Subscribe to: Post Comments (Atom)