commit 5973f75411061c8a7d67cc2e38b96c85d017c120 · drubery.com/icfp2007

+67 -27

dna2rna/src/dna.rs

···

       4
        
       use std::ops::Index;

     

       5
        
       use std::rc::Rc;

     

       6
        
       

     

       7
       -
       #[derive(Clone)]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       8
        
       pub enum Dna {

     

       9
        
           Empty,

     

       10
       -
           Leaf(char),

     

       11
        
           TwoNode(TwoNode),

     

       12
        
           ThreeNode(ThreeNode),

     

       13
        
       }

     

       14
        
       

     

       15
       -
       #[derive(Clone)]

     

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

     

       17
        
       pub enum DnaRef {

     

       18
        
           DnaRef(Rc<Dna>),

     

       19
        
       }

     

       20
        
       

     

       21
       -
       #[derive(Clone)]

     

       22
        
       pub struct TwoNode {

     

       23
        
           len: usize,

     

       24
        
           depth: usize,

     

       25
        
           children: (DnaRef, DnaRef),

     

       26
        
       }

     

       27
        
       

     

       28
       -
       #[derive(Clone)]

     

       29
        
       pub struct ThreeNode {

     

       30
        
           len: usize,

     

       31
        
           depth: usize,

     

       32
        
           children: (DnaRef, DnaRef, DnaRef),

     

       33
        
       }

     

       34
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       35
        
       impl DnaRef {

     

       36
        
           pub fn new() -> Self {

     

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

     

       38
        
           }

     

       39
        
       

     

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

     

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

     

       42
        
           }

     

       43
        
       

     

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

     
···

       61
        
           }

     

       62
        
       

     

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

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       65
        
           }

     

       66
        
       

     

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

     
···

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

     

       93
        
               match &**self {

     

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

     

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

     

       96
        
                       if n == 0 {

     

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

     

       98
        
                       } else {

     

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

     

       100
        
                       }

     

       101
        
                   }

     

       102
        
                   Dna::TwoNode(node) => {

     
···

       129
        
                       }

     

       130
        
                   }

     

       131
        
               }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       132
        
           }

     

       133
        
       }

     

       134
        
       

     
···

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

     

       203
        
               }

     

       204
        
       

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       206
        
           }

     

       207
        
       }

     

       208
        
       

     
···

       211
        
       }

     

       212
        
       

     

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

     

       214
       -
           type Item = char;

     

       215
        
       

     

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

     

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

     
···

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

     

       248
        
               match &*rhs {

     

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

     

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

     

       251
        
                   Dna::TwoNode(node) => {

     

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

     

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

     
···

       273
        
           } else {

     

       274
        
               match &*lhs {

     

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

     

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

     

       277
        
                   Dna::TwoNode(node) => {

     

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

     

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

     
···

       311
        
       }

     

       312
        
       

     

       313
        
       impl Index<usize> for DnaRef {

     

       314
       -
           type Output = char;

     

       315
        
       

     

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

     

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

     
···

       354
        
           #[test]

     

       355
        
           fn test_to_from_string() {

     

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

     

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

     

       358
        
           }

     

       359
        
       

     

       360
        
           #[test]

     

       361
        
           fn test_index() {

     

       362
        
               let s = "ICFP";

     

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

     

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

     

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

     

       366
       -
               }

     

       0
        
       
     

       367
        
           }

     

       368
        
       

     

       369
        
           #[test]

     

       370
       -
           fn test_concat() {

     

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

     

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

     

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

     

       374
        
           }

     

       375
        
       

     

       376
        
           #[test]

     

       377
        
           fn test_split() {

     

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

     

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

     

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

     

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

     

       382
        
           }

     

       383
        
       }

···

       4
        
       use std::ops::Index;

     

       5
        
       use std::rc::Rc;

     

       6
        
       

     

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

     

       8
       +
       pub enum Base {

     

       9
       +
           I,

     

       10
       +
           C,

     

       11
       +
           F,

     

       12
       +
           P,

     

       13
       +
       }

     

       14
       +
       

     

       15
       +
       #[derive(Clone, Debug)]

     

       16
        
       pub enum Dna {

     

       17
        
           Empty,

     

       18
       +
           Leaf(Base),

     

       19
        
           TwoNode(TwoNode),

     

       20
        
           ThreeNode(ThreeNode),

     

       21
        
       }

     

       22
        
       

     

       23
       +
       #[derive(Clone, Debug)]

     

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

     

       25
        
       pub enum DnaRef {

     

       26
        
           DnaRef(Rc<Dna>),

     

       27
        
       }

     

       28
        
       

     

       29
       +
       #[derive(Clone, Debug)]

     

       30
        
       pub struct TwoNode {

     

       31
        
           len: usize,

     

       32
        
           depth: usize,

     

       33
        
           children: (DnaRef, DnaRef),

     

       34
        
       }

     

       35
        
       

     

       36
       +
       #[derive(Clone, Debug)]

     

       37
        
       pub struct ThreeNode {

     

       38
        
           len: usize,

     

       39
        
           depth: usize,

     

       40
        
           children: (DnaRef, DnaRef, DnaRef),

     

       41
        
       }

     

       42
        
       

     

       43
       +
       impl Base {

     

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

     

       45
       +
               match c {

     

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

     

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

     

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

     

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

     

       50
       +
                   _ => None,

     

       51
       +
               }

     

       52
       +
           }

     

       53
       +
       

     

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

     

       55
       +
               match self {

     

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

     

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

     

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

     

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

     

       60
       +
               }

     

       61
       +
           }

     

       62
       +
       }

     

       63
       +
       

     

       64
        
       impl DnaRef {

     

       65
        
           pub fn new() -> Self {

     

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

     

       67
        
           }

     

       68
        
       

     

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

     

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

     

       71
        
           }

     

       72
        
       

     

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

     
···

       90
        
           }

     

       91
        
       

     

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

     

       93
       +
               s.chars()

     

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

     

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

     

       96
       +
                   .collect::<DnaRef>()

     

       97
        
           }

     

       98
        
       

     

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

     
···

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

     

       125
        
               match &**self {

     

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

     

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

     

       128
        
                       if n == 0 {

     

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

     

       130
        
                       } else {

     

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

     

       132
        
                       }

     

       133
        
                   }

     

       134
        
                   Dna::TwoNode(node) => {

     
···

       161
        
                       }

     

       162
        
                   }

     

       163
        
               }

     

       164
       +
           }

     

       165
       +
       

     

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

     

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

     

       168
        
           }

     

       169
        
       }

     

       170
        
       

     
···

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

     

       239
        
               }

     

       240
        
       

     

       241
       +
               match cur.pop() {

     

       242
       +
                   Some(dna) => dna,

     

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

     

       244
       +
               }

     

       245
        
           }

     

       246
        
       }

     

       247
        
       

     
···

       250
        
       }

     

       251
        
       

     

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

     

       253
       +
           type Item = Base;

     

       254
        
       

     

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

     

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

     
···

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

     

       287
        
               match &*rhs {

     

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

     

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

     

       290
        
                   Dna::TwoNode(node) => {

     

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

     

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

     
···

       312
        
           } else {

     

       313
        
               match &*lhs {

     

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

     

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

     

       316
        
                   Dna::TwoNode(node) => {

     

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

     

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

     
···

       350
        
       }

     

       351
        
       

     

       352
        
       impl Index<usize> for DnaRef {

     

       353
       +
           type Output = Base;

     

       354
        
       

     

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

     

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

     
···

       393
        
           #[test]

     

       394
        
           fn test_to_from_string() {

     

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

     

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

     

       397
        
           }

     

       398
        
       

     

       399
        
           #[test]

     

       400
        
           fn test_index() {

     

       401
        
               let s = "ICFP";

     

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

     

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

     

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

     

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

     

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

     

       407
        
           }

     

       408
        
       

     

       409
        
           #[test]

     

       410
       +
           fn test_add() {

     

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

     

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

     

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

     

       414
        
           }

     

       415
        
       

     

       416
        
           #[test]

     

       417
        
           fn test_split() {

     

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

     

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

     

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

     

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

     

       422
        
           }

     

       423
        
       }

+2 -1

dna2rna/src/main.rs

···

       1
        
       mod dna;

     

       0
        
       
     

       2
        
       

     

       3
        
       use crate::dna::*;

     

       4
        
       

     

       5
        
       fn main() {

     

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

     

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

     

       8
        
       }

···

       1
        
       mod dna;

     

       2
       +
       mod parser;

     

       3
        
       

     

       4
        
       use crate::dna::*;

     

       5
        
       

     

       6
        
       fn main() {

     

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

     

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

     

       9
        
       }

+109

dna2rna/src/parser.rs

···

       1
       +
       use crate::Base;

     

       2
       +
       use crate::DnaRef;

     

       3
       +
       

     

       4
       +
       struct Parser<'a> {

     

       5
       +
           buf: &'a DnaRef,

     

       6
       +
           index: usize,

     

       7
       +
       }

     

       8
       +
       

     

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

     

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

     

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

     

       12
       +
           }

     

       13
       +
       

     

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

     

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

     

       16
       +
                   return false;

     

       17
       +
               }

     

       18
       +
       

     

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

     

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

     

       21
       +
                       return false;

     

       22
       +
                   }

     

       23
       +
               }

     

       24
       +
       

     

       25
       +
               return true;

     

       26
       +
           }

     

       27
       +
       

     

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

     

       29
       +
               let mut ret = 0;

     

       30
       +
               let mut bit = 1;

     

       31
       +
               loop {

     

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

     

       33
       +
                       self.index += 1;

     

       34
       +
                       return Some(ret);

     

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

     

       36
       +
                       self.index += 1;

     

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

     

       38
       +
                       ret += bit;

     

       39
       +
                       self.index += 1;

     

       40
       +
                   } else {

     

       41
       +
                       return None;

     

       42
       +
                   }

     

       43
       +
       

     

       44
       +
                   bit *= 2;

     

       45
       +
               }

     

       46
       +
           }

     

       47
       +
       

     

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

     

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

     

       50
       +
               loop {

     

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

     

       52
       +
                       self.index += 1;

     

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

     

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

     

       55
       +
                       self.index += 1;

     

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

     

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

     

       58
       +
                       self.index += 1;

     

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

     

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

     

       61
       +
                       self.index += 2;

     

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

     

       63
       +
                   } else {

     

       64
       +
                       return ret;

     

       65
       +
                   }

     

       66
       +
               }

     

       67
       +
           }

     

       68
       +
       }

     

       69
       +
       

     

       70
       +
       #[cfg(test)]

     

       71
       +
       mod tests {

     

       72
       +
           use super::*;

     

       73
       +
       

     

       74
       +
           #[test]

     

       75
       +
           fn test_base() {

     

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

     

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

     

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

     

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

     

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

     

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

     

       82
       +
           }

     

       83
       +
       

     

       84
       +
           #[test]

     

       85
       +
           fn test_nat() {

     

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

     

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

     

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

     

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

     

       90
       +
       

     

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

     

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

     

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

     

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

     

       95
       +
       

     

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

     

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

     

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

     

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

     

       100
       +
           }

     

       101
       +
       

     

       102
       +
           #[test]

     

       103
       +
           fn test_consts() {

     

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

     

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

     

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

     

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

     

       108
       +
           }

     

       109
       +
       }

dna2rna/src/pattern.rs

···

       1
       +
       use crate::Base; 

     

       2
       +
       

     

       3
       +
       pub enum PatternItem {

     

       4
       +
         Base(char),

     

       5
       +
         Skip(usize),

     

       6
       +
         Search(Vec<Base>),

     

       7
       +
         Open,

     

       8
       +
         Close

     

       9
       +
       }