commit 5b66bdd59348b3857a3bc99062916e1c034c53d9 · drubery.com/icfp2007

dna2rna/src/main.rs

···

       1
        
       mod dna;

     

       2
        
       mod parser;

     

       3
        
       mod pattern;

     

       0
        
       
     

       4
        
       mod template;

     

       5
        
       

     

       6
        
       fn main() {

···

       1
        
       mod dna;

     

       2
        
       mod parser;

     

       3
        
       mod pattern;

     

       4
       +
       mod rna;

     

       5
        
       mod template;

     

       6
        
       

     

       7
        
       fn main() {

+62 -10

dna2rna/src/parser.rs

···

       2
        
       use crate::dna::DnaRef;

     

       3
        
       use crate::pattern::Pattern;

     

       4
        
       use crate::pattern::PatternItem;

     

       0
        
       
     

       5
        
       use crate::template::Template;

     

       6
        
       use crate::template::TemplateItem;

     

       7
        
       

     
···

       70
        
               }

     

       71
        
           }

     

       72
        
       

     

       73
       -
           pub fn pattern(&mut self) -> Option<Pattern> {

     

       74
        
               let mut ret = Vec::new();

     

       75
        
               let mut level = 0;

     

       76
        
               loop {

     
···

       108
        
                       level -= 1;

     

       109
        
                       ret.push(PatternItem::Close);

     

       110
        
                   } else if self.next_is(&[Base::I, Base::I, Base::I]) {

     

       111
       -
                       self.index += 10;

     

       112
       -
                       // TODO: RNA output

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       113
        
                   } else {

     

       114
        
                       return None;

     

       115
        
                   }

     

       116
        
               }

     

       117
        
           }

     

       118
        
       

     

       119
       -
           pub fn template(&mut self) -> Option<Template> {

     

       120
        
               let mut ret = Vec::new();

     

       121
        
               loop {

     

       122
        
                   if self.next_is(&[Base::C]) {

     
···

       146
        
                       let n = self.nat()?;

     

       147
        
                       ret.push(TemplateItem::Len(n));

     

       148
        
                   } else if self.next_is(&[Base::I, Base::I, Base::I]) {

     

       149
       -
                       self.index += 10;

     

       150
       -
                       // TODO: RNA output

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       151
        
                   } else {

     

       152
        
                       return None;

     

       153
        
                   }

     
···

       197
        
       

     

       198
        
           #[test]

     

       199
        
           fn test_pattern() {

     

       0
        
       
     

       0
        
       
     

       200
        
               let dna = DnaRef::from_string("CIIC");

     

       201
        
               let mut parser = Parser::new(&dna);

     

       202
       -
               assert_eq!(parser.pattern(), Some(vec![PatternItem::Base(Base::I)]));

     

       203
       -
               assert_eq!(parser.ijndex, 4);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       204
        
       

     

       205
        
               let dna = DnaRef::from_string("IIPIPICPIICICIIF");

     

       206
        
               let mut parser = Parser::new(&dna);

     

       207
        
               assert_eq!(

     

       208
       -
                   parser.pattern(),

     

       209
        
                   Some(vec![

     

       210
        
                       PatternItem::Open,

     

       211
        
                       PatternItem::Skip(2),

     
···

       214
        
                   ])

     

       215
        
               );

     

       216
        
               assert_eq!(parser.index, 16);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       217
        
           }

     

       218
        
       

     

       219
        
           #[test]

     

       220
        
           fn test_template() {

     

       0
        
       
     

       0
        
       
     

       221
        
               let dna = DnaRef::from_string("CFPICIFCPICPIIPIICPIIC");

     

       222
        
               let mut parser = Parser::new(&dna);

     

       223
        
               assert_eq!(

     

       224
       -
                   parser.template(),

     

       225
        
                   Some(vec![

     

       226
        
                       TemplateItem::Base(Base::I),

     

       227
        
                       TemplateItem::Base(Base::C),

     
···

       232
        
                   ])

     

       233
        
               );

     

       234
        
               assert_eq!(parser.index, 22);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       235
        
           }

     

       236
        
       }

···

       2
        
       use crate::dna::DnaRef;

     

       3
        
       use crate::pattern::Pattern;

     

       4
        
       use crate::pattern::PatternItem;

     

       5
       +
       use crate::rna::Rna;

     

       6
        
       use crate::template::Template;

     

       7
        
       use crate::template::TemplateItem;

     

       8
        
       

     
···

       71
        
               }

     

       72
        
           }

     

       73
        
       

     

       74
       +
           pub fn pattern(&mut self, rna: &mut Vec<Rna>) -> Option<Pattern> {

     

       75
        
               let mut ret = Vec::new();

     

       76
        
               let mut level = 0;

     

       77
        
               loop {

     
···

       109
        
                       level -= 1;

     

       110
        
                       ret.push(PatternItem::Close);

     

       111
        
                   } else if self.next_is(&[Base::I, Base::I, Base::I]) {

     

       112
       +
                       self.index += 3;

     

       113
       +
                       let mut new_rna = Vec::new();

     

       114
       +
                       for i in 0..7 {

     

       115
       +
                           new_rna.push(self.buf[self.index + i]);

     

       116
       +
                       }

     

       117
       +
                       self.index += 7;

     

       118
       +
                       rna.push(new_rna.try_into().unwrap());

     

       119
        
                   } else {

     

       120
        
                       return None;

     

       121
        
                   }

     

       122
        
               }

     

       123
        
           }

     

       124
        
       

     

       125
       +
           pub fn template(&mut self, rna: &mut Vec<Rna>) -> Option<Template> {

     

       126
        
               let mut ret = Vec::new();

     

       127
        
               loop {

     

       128
        
                   if self.next_is(&[Base::C]) {

     
···

       152
        
                       let n = self.nat()?;

     

       153
        
                       ret.push(TemplateItem::Len(n));

     

       154
        
                   } else if self.next_is(&[Base::I, Base::I, Base::I]) {

     

       155
       +
                       self.index += 3;

     

       156
       +
                       let mut new_rna = Vec::new();

     

       157
       +
                       for i in 0..7 {

     

       158
       +
                           new_rna.push(self.buf[self.index + i]);

     

       159
       +
                       }

     

       160
       +
                       self.index += 7;

     

       161
       +
                       rna.push(new_rna.try_into().unwrap());

     

       162
        
                   } else {

     

       163
        
                       return None;

     

       164
        
                   }

     
···

       208
        
       

     

       209
        
           #[test]

     

       210
        
           fn test_pattern() {

     

       211
       +
               let mut rna = Vec::new();

     

       212
       +
       

     

       213
        
               let dna = DnaRef::from_string("CIIC");

     

       214
        
               let mut parser = Parser::new(&dna);

     

       215
       +
               assert_eq!(

     

       216
       +
                   parser.pattern(&mut rna),

     

       217
       +
                   Some(vec![PatternItem::Base(Base::I)])

     

       218
       +
               );

     

       219
       +
               assert_eq!(parser.index, 4);

     

       220
        
       

     

       221
        
               let dna = DnaRef::from_string("IIPIPICPIICICIIF");

     

       222
        
               let mut parser = Parser::new(&dna);

     

       223
        
               assert_eq!(

     

       224
       +
                   parser.pattern(&mut rna),

     

       225
        
                   Some(vec![

     

       226
        
                       PatternItem::Open,

     

       227
        
                       PatternItem::Skip(2),

     
···

       230
        
                   ])

     

       231
        
               );

     

       232
        
               assert_eq!(parser.index, 16);

     

       233
       +
       

     

       234
       +
               let dna = DnaRef::from_string("IIIPFCICFPIIC");

     

       235
       +
               let mut parser = Parser::new(&dna);

     

       236
       +
               assert_eq!(parser.pattern(&mut rna), Some(vec![]));

     

       237
       +
               assert_eq!(parser.index, 13);

     

       238
       +
               assert_eq!(

     

       239
       +
                   rna,

     

       240
       +
                   vec![[

     

       241
       +
                       Base::P,

     

       242
       +
                       Base::F,

     

       243
       +
                       Base::C,

     

       244
       +
                       Base::I,

     

       245
       +
                       Base::C,

     

       246
       +
                       Base::F,

     

       247
       +
                       Base::P

     

       248
       +
                   ]]

     

       249
       +
               );

     

       250
        
           }

     

       251
        
       

     

       252
        
           #[test]

     

       253
        
           fn test_template() {

     

       254
       +
               let mut rna = Vec::new();

     

       255
       +
       

     

       256
        
               let dna = DnaRef::from_string("CFPICIFCPICPIIPIICPIIC");

     

       257
        
               let mut parser = Parser::new(&dna);

     

       258
        
               assert_eq!(

     

       259
       +
                   parser.template(&mut rna),

     

       260
        
                   Some(vec![

     

       261
        
                       TemplateItem::Base(Base::I),

     

       262
        
                       TemplateItem::Base(Base::C),

     
···

       267
        
                   ])

     

       268
        
               );

     

       269
        
               assert_eq!(parser.index, 22);

     

       270
       +
       

     

       271
       +
               let dna = DnaRef::from_string("IIIPFCICFPIIC");

     

       272
       +
               let mut parser = Parser::new(&dna);

     

       273
       +
               assert_eq!(parser.template(&mut rna), Some(vec![]));

     

       274
       +
               assert_eq!(parser.index, 13);

     

       275
       +
               assert_eq!(

     

       276
       +
                   rna,

     

       277
       +
                   vec![[

     

       278
       +
                       Base::P,

     

       279
       +
                       Base::F,

     

       280
       +
                       Base::C,

     

       281
       +
                       Base::I,

     

       282
       +
                       Base::C,

     

       283
       +
                       Base::F,

     

       284
       +
                       Base::P

     

       285
       +
                   ]]

     

       286
       +
               );

     

       287
        
           }

     

       288
        
       }

dna2rna/src/rna.rs

···

       1
       +
       use crate::dna::Base;

     

       2
       +
       

     

       3
       +
       pub type Rna = [Base; 7];