commit 5b66bdd59348b3857a3bc99062916e1c034c53d9 · drubery.com/icfp2007

dna2rna/src/main.rs

···

       1
       1
        
       mod dna;

     

       2
       2
        
       mod parser;

     

       3
       3
        
       mod pattern;

     

       4
       4
       +
       mod rna;

     

       4
       5
        
       mod template;

     

       5
       6
        
       

     

       6
       7
        
       fn main() {

+62 -10

dna2rna/src/parser.rs

···

       2
       2
        
       use crate::dna::DnaRef;

     

       3
       3
        
       use crate::pattern::Pattern;

     

       4
       4
        
       use crate::pattern::PatternItem;

     

       5
       5
       +
       use crate::rna::Rna;

     

       5
       6
        
       use crate::template::Template;

     

       6
       7
        
       use crate::template::TemplateItem;

     

       7
       8
        
       

     
···

       70
       71
        
               }

     

       71
       72
        
           }

     

       72
       73
        
       

     

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

     

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

     

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

     

       75
       76
        
               let mut level = 0;

     

       76
       77
        
               loop {

     
···

       108
       109
        
                       level -= 1;

     

       109
       110
        
                       ret.push(PatternItem::Close);

     

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

     

       111
       111
       -
                       self.index += 10;

     

       112
       112
       -
                       // TODO: RNA output

     

       112
       112
       +
                       self.index += 3;

     

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

     

       114
       114
       +
                       for i in 0..7 {

     

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

     

       116
       116
       +
                       }

     

       117
       117
       +
                       self.index += 7;

     

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

     

       113
       119
        
                   } else {

     

       114
       120
        
                       return None;

     

       115
       121
        
                   }

     

       116
       122
        
               }

     

       117
       123
        
           }

     

       118
       124
        
       

     

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

     

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

     

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

     

       121
       127
        
               loop {

     

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

     
···

       146
       152
        
                       let n = self.nat()?;

     

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

     

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

     

       149
       149
       -
                       self.index += 10;

     

       150
       150
       -
                       // TODO: RNA output

     

       155
       155
       +
                       self.index += 3;

     

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

     

       157
       157
       +
                       for i in 0..7 {

     

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

     

       159
       159
       +
                       }

     

       160
       160
       +
                       self.index += 7;

     

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

     

       151
       162
        
                   } else {

     

       152
       163
        
                       return None;

     

       153
       164
        
                   }

     
···

       197
       208
        
       

     

       198
       209
        
           #[test]

     

       199
       210
        
           fn test_pattern() {

     

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

     

       212
       212
       +
       

     

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

     

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

     

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

     

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

     

       215
       215
       +
               assert_eq!(

     

       216
       216
       +
                   parser.pattern(&mut rna),

     

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

     

       218
       218
       +
               );

     

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

     

       204
       220
        
       

     

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

     

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

     

       207
       223
        
               assert_eq!(

     

       208
       208
       -
                   parser.pattern(),

     

       224
       224
       +
                   parser.pattern(&mut rna),

     

       209
       225
        
                   Some(vec![

     

       210
       226
        
                       PatternItem::Open,

     

       211
       227
        
                       PatternItem::Skip(2),

     
···

       214
       230
        
                   ])

     

       215
       231
        
               );

     

       216
       232
        
               assert_eq!(parser.index, 16);

     

       233
       233
       +
       

     

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

     

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

     

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

     

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

     

       238
       238
       +
               assert_eq!(

     

       239
       239
       +
                   rna,

     

       240
       240
       +
                   vec![[

     

       241
       241
       +
                       Base::P,

     

       242
       242
       +
                       Base::F,

     

       243
       243
       +
                       Base::C,

     

       244
       244
       +
                       Base::I,

     

       245
       245
       +
                       Base::C,

     

       246
       246
       +
                       Base::F,

     

       247
       247
       +
                       Base::P

     

       248
       248
       +
                   ]]

     

       249
       249
       +
               );

     

       217
       250
        
           }

     

       218
       251
        
       

     

       219
       252
        
           #[test]

     

       220
       253
        
           fn test_template() {

     

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

     

       255
       255
       +
       

     

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

     

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

     

       223
       258
        
               assert_eq!(

     

       224
       224
       -
                   parser.template(),

     

       259
       259
       +
                   parser.template(&mut rna),

     

       225
       260
        
                   Some(vec![

     

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

     

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

     
···

       232
       267
        
                   ])

     

       233
       268
        
               );

     

       234
       269
        
               assert_eq!(parser.index, 22);

     

       270
       270
       +
       

     

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

     

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

     

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

     

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

     

       275
       275
       +
               assert_eq!(

     

       276
       276
       +
                   rna,

     

       277
       277
       +
                   vec![[

     

       278
       278
       +
                       Base::P,

     

       279
       279
       +
                       Base::F,

     

       280
       280
       +
                       Base::C,

     

       281
       281
       +
                       Base::I,

     

       282
       282
       +
                       Base::C,

     

       283
       283
       +
                       Base::F,

     

       284
       284
       +
                       Base::P

     

       285
       285
       +
                   ]]

     

       286
       286
       +
               );

     

       235
       287
        
           }

     

       236
       288
        
       }

dna2rna/src/rna.rs

···

       1
       1
       +
       use crate::dna::Base;

     

       2
       2
       +
       

     

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