commit 5973f75411061c8a7d67cc2e38b96c85d017c120 · drubery.com/icfp2007

+67 -27

dna2rna/src/dna.rs

···

       4
       4
        
       use std::ops::Index;

     

       5
       5
        
       use std::rc::Rc;

     

       6
       6
        
       

     

       7
       7
       -
       #[derive(Clone)]

     

       7
       7
       +
       #[derive(Copy, Clone, PartialEq, Debug)]

     

       8
       8
       +
       pub enum Base {

     

       9
       9
       +
           I,

     

       10
       10
       +
           C,

     

       11
       11
       +
           F,

     

       12
       12
       +
           P,

     

       13
       13
       +
       }

     

       14
       14
       +
       

     

       15
       15
       +
       #[derive(Clone, Debug)]

     

       8
       16
        
       pub enum Dna {

     

       9
       17
        
           Empty,

     

       10
       10
       -
           Leaf(char),

     

       18
       18
       +
           Leaf(Base),

     

       11
       19
        
           TwoNode(TwoNode),

     

       12
       20
        
           ThreeNode(ThreeNode),

     

       13
       21
        
       }

     

       14
       22
        
       

     

       15
       15
       -
       #[derive(Clone)]

     

       23
       23
       +
       #[derive(Clone, Debug)]

     

       16
       24
        
       // Wrap Rc in a single-value enum so I can implement traits for it.

     

       17
       25
        
       pub enum DnaRef {

     

       18
       26
        
           DnaRef(Rc<Dna>),

     

       19
       27
        
       }

     

       20
       28
        
       

     

       21
       21
       -
       #[derive(Clone)]

     

       29
       29
       +
       #[derive(Clone, Debug)]

     

       22
       30
        
       pub struct TwoNode {

     

       23
       31
        
           len: usize,

     

       24
       32
        
           depth: usize,

     

       25
       33
        
           children: (DnaRef, DnaRef),

     

       26
       34
        
       }

     

       27
       35
        
       

     

       28
       28
       -
       #[derive(Clone)]

     

       36
       36
       +
       #[derive(Clone, Debug)]

     

       29
       37
        
       pub struct ThreeNode {

     

       30
       38
        
           len: usize,

     

       31
       39
        
           depth: usize,

     

       32
       40
        
           children: (DnaRef, DnaRef, DnaRef),

     

       33
       41
        
       }

     

       34
       42
        
       

     

       43
       43
       +
       impl Base {

     

       44
       44
       +
           fn from_char(c: char) -> Option<Base> {

     

       45
       45
       +
               match c {

     

       46
       46
       +
                   'I' => Some(Base::I),

     

       47
       47
       +
                   'C' => Some(Base::C),

     

       48
       48
       +
                   'F' => Some(Base::F),

     

       49
       49
       +
                   'P' => Some(Base::P),

     

       50
       50
       +
                   _ => None,

     

       51
       51
       +
               }

     

       52
       52
       +
           }

     

       53
       53
       +
       

     

       54
       54
       +
           fn to_char(&self) -> char {

     

       55
       55
       +
               match self {

     

       56
       56
       +
                   Base::I => 'I',

     

       57
       57
       +
                   Base::C => 'C',

     

       58
       58
       +
                   Base::F => 'F',

     

       59
       59
       +
                   Base::P => 'P',

     

       60
       60
       +
               }

     

       61
       61
       +
           }

     

       62
       62
       +
       }

     

       63
       63
       +
       

     

       35
       64
        
       impl DnaRef {

     

       36
       65
        
           pub fn new() -> Self {

     

       37
       66
        
               Self::DnaRef(Rc::new(Dna::Empty))

     

       38
       67
        
           }

     

       39
       68
        
       

     

       40
       40
       -
           fn from_char(c: char) -> Self {

     

       41
       41
       -
               Self::DnaRef(Rc::new(Dna::Leaf(c)))

     

       69
       69
       +
           fn from_base(b: Base) -> Self {

     

       70
       70
       +
               Self::DnaRef(Rc::new(Dna::Leaf(b)))

     

       42
       71
        
           }

     

       43
       72
        
       

     

       44
       73
        
           fn from_two_children(a: DnaRef, b: DnaRef) -> Self {

     
···

       61
       90
        
           }

     

       62
       91
        
       

     

       63
       92
        
           pub fn from_string(s: &str) -> Self {

     

       64
       64
       -
               s.chars().map(|c| DnaRef::from_char(c)).collect::<DnaRef>()

     

       93
       93
       +
               s.chars()

     

       94
       94
       +
                   .filter_map(|c| Base::from_char(c))

     

       95
       95
       +
                   .map(|b| DnaRef::from_base(b))

     

       96
       96
       +
                   .collect::<DnaRef>()

     

       65
       97
        
           }

     

       66
       98
        
       

     

       67
       99
        
           pub fn len(&self) -> usize {

     
···

       92
       124
        
               debug_assert!(n <= self.len());

     

       93
       125
        
               match &**self {

     

       94
       126
        
                   Dna::Empty => (DnaRef::new(), DnaRef::new()),

     

       95
       95
       -
                   Dna::Leaf(c) => {

     

       127
       127
       +
                   Dna::Leaf(b) => {

     

       96
       128
        
                       if n == 0 {

     

       97
       97
       -
                           (DnaRef::new(), DnaRef::from_char(*c))

     

       129
       129
       +
                           (DnaRef::new(), DnaRef::from_base(*b))

     

       98
       130
        
                       } else {

     

       99
       99
       -
                           (DnaRef::from_char(*c), DnaRef::new())

     

       131
       131
       +
                           (DnaRef::from_base(*b), DnaRef::new())

     

       100
       132
        
                       }

     

       101
       133
        
                   }

     

       102
       134
        
                   Dna::TwoNode(node) => {

     
···

       129
       161
        
                       }

     

       130
       162
        
                   }

     

       131
       163
        
               }

     

       164
       164
       +
           }

     

       165
       165
       +
       

     

       166
       166
       +
           pub fn to_string(&self) -> String {

     

       167
       167
       +
               self.iter().map(|b| Base::to_char(&b)).collect::<String>()

     

       132
       168
        
           }

     

       133
       169
        
       }

     

       134
       170
        
       

     
···

       202
       238
        
                   cur = DnaRefIter::new(cur.into_iter()).collect();

     

       203
       239
        
               }

     

       204
       240
        
       

     

       205
       205
       -
               return cur.pop().unwrap();

     

       241
       241
       +
               match cur.pop() {

     

       242
       242
       +
                   Some(dna) => dna,

     

       243
       243
       +
                   None => DnaRef::new(),

     

       244
       244
       +
               }

     

       206
       245
        
           }

     

       207
       246
        
       }

     

       208
       247
        
       

     
···

       211
       250
        
       }

     

       212
       251
        
       

     

       213
       252
        
       impl<'a> Iterator for DnaIterator<'a> {

     

       214
       214
       -
           type Item = char;

     

       253
       253
       +
           type Item = Base;

     

       215
       254
        
       

     

       216
       255
        
           fn next(&mut self) -> Option<Self::Item> {

     

       217
       256
        
               while let Some(node) = self.stack.pop() {

     
···

       247
       286
        
           } else if lhs.depth() < rhs.depth() {

     

       248
       287
        
               match &*rhs {

     

       249
       288
        
                   Dna::Empty => unreachable!(),

     

       250
       250
       -
                   Dna::Leaf(_) => unreachable!(),

     

       289
       289
       +
                   Dna::Leaf(_) => AddState::One(rhs),

     

       251
       290
        
                   Dna::TwoNode(node) => {

     

       252
       291
        
                       let (a, b) = &node.children;

     

       253
       292
        
                       match add_helper(lhs, a.clone()) {

     
···

       273
       312
        
           } else {

     

       274
       313
        
               match &*lhs {

     

       275
       314
        
                   Dna::Empty => unreachable!(),

     

       276
       276
       -
                   Dna::Leaf(_) => unreachable!(),

     

       315
       315
       +
                   Dna::Leaf(_) => AddState::One(lhs.clone()),

     

       277
       316
        
                   Dna::TwoNode(node) => {

     

       278
       317
        
                       let (a, b) = &node.children;

     

       279
       318
        
                       match add_helper(b.clone(), rhs) {

     
···

       311
       350
        
       }

     

       312
       351
        
       

     

       313
       352
        
       impl Index<usize> for DnaRef {

     

       314
       314
       -
           type Output = char;

     

       353
       353
       +
           type Output = Base;

     

       315
       354
        
       

     

       316
       355
        
           fn index(&self, n: usize) -> &Self::Output {

     

       317
       356
        
               debug_assert!(n < self.len());

     
···

       354
       393
        
           #[test]

     

       355
       394
        
           fn test_to_from_string() {

     

       356
       395
        
               let dna: DnaRef = DnaRef::from_string("ICFP");

     

       357
       357
       -
               assert_eq!(dna.iter().collect::<String>(), "ICFP");

     

       396
       396
       +
               assert_eq!(dna.to_string(), "ICFP");

     

       358
       397
        
           }

     

       359
       398
        
       

     

       360
       399
        
           #[test]

     

       361
       400
        
           fn test_index() {

     

       362
       401
        
               let s = "ICFP";

     

       363
       402
        
               let dna: DnaRef = DnaRef::from_string(s);

     

       364
       364
       -
               for (i, c) in s.chars().enumerate() {

     

       365
       365
       -
                   assert_eq!(dna[i], c);

     

       366
       366
       -
               }

     

       403
       403
       +
               assert_eq!(dna[0], Base::I);

     

       404
       404
       +
               assert_eq!(dna[1], Base::C);

     

       405
       405
       +
               assert_eq!(dna[2], Base::F);

     

       406
       406
       +
               assert_eq!(dna[3], Base::P);

     

       367
       407
        
           }

     

       368
       408
        
       

     

       369
       409
        
           #[test]

     

       370
       370
       -
           fn test_concat() {

     

       371
       371
       -
               let lhs = DnaRef::from_string("ABCD");

     

       372
       372
       -
               let rhs = DnaRef::from_string("WXYZ");

     

       373
       373
       -
               assert_eq!((lhs + rhs).iter().collect::<String>(), "ABCDWXYZ");

     

       410
       410
       +
           fn test_add() {

     

       411
       411
       +
               let lhs = DnaRef::from_string("IIIC");

     

       412
       412
       +
               let rhs = DnaRef::from_string("PFFF");

     

       413
       413
       +
               assert_eq!((lhs + rhs).to_string(), "IIICPFFF");

     

       374
       414
        
           }

     

       375
       415
        
       

     

       376
       416
        
           #[test]

     

       377
       417
        
           fn test_split() {

     

       378
       378
       -
               let dna = DnaRef::from_string("ABCDWXYZ");

     

       418
       418
       +
               let dna = DnaRef::from_string("IIICPFFF");

     

       379
       419
        
               let (lhs, rhs) = dna.split(4);

     

       380
       380
       -
               assert_eq!(lhs.iter().collect::<String>(), "ABCD");

     

       381
       381
       -
               assert_eq!(rhs.iter().collect::<String>(), "WXYZ");

     

       420
       420
       +
               assert_eq!(lhs.to_string(), "IIIC");

     

       421
       421
       +
               assert_eq!(rhs.to_string(), "PFFF");

     

       382
       422
        
           }

     

       383
       423
        
       }

+2 -1

dna2rna/src/main.rs

···

       1
       1
        
       mod dna;

     

       2
       2
       +
       mod parser;

     

       2
       3
        
       

     

       3
       4
        
       use crate::dna::*;

     

       4
       5
        
       

     

       5
       6
        
       fn main() {

     

       6
       7
        
           let dna: DnaRef = DnaRef::from_string("ICFP");

     

       7
       7
       -
           println!("Back to string: {}", dna.iter().collect::<String>());

     

       8
       8
       +
           println!("Back to string: {}", dna.to_string());

     

       8
       9
        
       }

+109

dna2rna/src/parser.rs

···

       1
       1
       +
       use crate::Base;

     

       2
       2
       +
       use crate::DnaRef;

     

       3
       3
       +
       

     

       4
       4
       +
       struct Parser<'a> {

     

       5
       5
       +
           buf: &'a DnaRef,

     

       6
       6
       +
           index: usize,

     

       7
       7
       +
       }

     

       8
       8
       +
       

     

       9
       9
       +
       impl<'a> Parser<'a> {

     

       10
       10
       +
           pub fn new(buf: &'a DnaRef) -> Parser<'a> {

     

       11
       11
       +
               Parser { buf: buf, index: 0 }

     

       12
       12
       +
           }

     

       13
       13
       +
       

     

       14
       14
       +
           pub fn next_is(&mut self, next: &[Base]) -> bool {

     

       15
       15
       +
               if self.index + next.len() > self.buf.len() {

     

       16
       16
       +
                   return false;

     

       17
       17
       +
               }

     

       18
       18
       +
       

     

       19
       19
       +
               for i in 0..next.len() {

     

       20
       20
       +
                   if self.buf[self.index + i] != next[i] {

     

       21
       21
       +
                       return false;

     

       22
       22
       +
                   }

     

       23
       23
       +
               }

     

       24
       24
       +
       

     

       25
       25
       +
               return true;

     

       26
       26
       +
           }

     

       27
       27
       +
       

     

       28
       28
       +
           pub fn nat(&mut self) -> Option<usize> {

     

       29
       29
       +
               let mut ret = 0;

     

       30
       30
       +
               let mut bit = 1;

     

       31
       31
       +
               loop {

     

       32
       32
       +
                   if self.next_is(&[Base::P]) {

     

       33
       33
       +
                       self.index += 1;

     

       34
       34
       +
                       return Some(ret);

     

       35
       35
       +
                   } else if self.next_is(&[Base::I]) || self.next_is(&[Base::F]) {

     

       36
       36
       +
                       self.index += 1;

     

       37
       37
       +
                   } else if self.next_is(&[Base::C]) {

     

       38
       38
       +
                       ret += bit;

     

       39
       39
       +
                       self.index += 1;

     

       40
       40
       +
                   } else {

     

       41
       41
       +
                       return None;

     

       42
       42
       +
                   }

     

       43
       43
       +
       

     

       44
       44
       +
                   bit *= 2;

     

       45
       45
       +
               }

     

       46
       46
       +
           }

     

       47
       47
       +
       

     

       48
       48
       +
           pub fn consts(&mut self) -> Vec<Base> {

     

       49
       49
       +
               let mut ret = Vec::new();

     

       50
       50
       +
               loop {

     

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

     

       52
       52
       +
                       self.index += 1;

     

       53
       53
       +
                       ret.push(Base::I);

     

       54
       54
       +
                   } else if self.next_is(&[Base::F]) {

     

       55
       55
       +
                       self.index += 1;

     

       56
       56
       +
                       ret.push(Base::C);

     

       57
       57
       +
                   } else if self.next_is(&[Base::P]) {

     

       58
       58
       +
                       self.index += 1;

     

       59
       59
       +
                       ret.push(Base::F);

     

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

     

       61
       61
       +
                       self.index += 2;

     

       62
       62
       +
                       ret.push(Base::P);

     

       63
       63
       +
                   } else {

     

       64
       64
       +
                       return ret;

     

       65
       65
       +
                   }

     

       66
       66
       +
               }

     

       67
       67
       +
           }

     

       68
       68
       +
       }

     

       69
       69
       +
       

     

       70
       70
       +
       #[cfg(test)]

     

       71
       71
       +
       mod tests {

     

       72
       72
       +
           use super::*;

     

       73
       73
       +
       

     

       74
       74
       +
           #[test]

     

       75
       75
       +
           fn test_base() {

     

       76
       76
       +
               let dna = DnaRef::from_string("ICFP");

     

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

     

       78
       78
       +
               assert!(parser.next_is(&[Base::I]));

     

       79
       79
       +
               assert!(parser.next_is(&[Base::I, Base::C]));

     

       80
       80
       +
               assert!(parser.next_is(&[Base::I, Base::C, Base::F]));

     

       81
       81
       +
               assert!(parser.next_is(&[Base::I, Base::C, Base::F, Base::P]));

     

       82
       82
       +
           }

     

       83
       83
       +
       

     

       84
       84
       +
           #[test]

     

       85
       85
       +
           fn test_nat() {

     

       86
       86
       +
               let dna = DnaRef::from_string("CP");

     

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

     

       88
       88
       +
               assert_eq!(parser.nat(), Some(1));

     

       89
       89
       +
               assert_eq!(parser.index, 2);

     

       90
       90
       +
       

     

       91
       91
       +
               let dna = DnaRef::from_string("ICICP");

     

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

     

       93
       93
       +
               assert_eq!(parser.nat(), Some(10));

     

       94
       94
       +
               assert_eq!(parser.index, 5);

     

       95
       95
       +
       

     

       96
       96
       +
               let dna = DnaRef::from_string("III");

     

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

     

       98
       98
       +
               assert_eq!(parser.nat(), None);

     

       99
       99
       +
               assert_eq!(parser.index, 3);

     

       100
       100
       +
           }

     

       101
       101
       +
       

     

       102
       102
       +
           #[test]

     

       103
       103
       +
           fn test_consts() {

     

       104
       104
       +
               let dna = DnaRef::from_string("CFPICIIC");

     

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

     

       106
       106
       +
               assert_eq!(parser.consts(), &[Base::I, Base::C, Base::F, Base::P]);

     

       107
       107
       +
               assert_eq!(parser.index, 5);

     

       108
       108
       +
           }

     

       109
       109
       +
       }

dna2rna/src/pattern.rs

···

       1
       1
       +
       use crate::Base; 

     

       2
       2
       +
       

     

       3
       3
       +
       pub enum PatternItem {

     

       4
       4
       +
         Base(char),

     

       5
       5
       +
         Skip(usize),

     

       6
       6
       +
         Search(Vec<Base>),

     

       7
       7
       +
         Open,

     

       8
       8
       +
         Close

     

       9
       9
       +
       }