From 909bcfef6dd475a33e63cdc3797f0a5920fda792 Mon Sep 17 00:00:00 2001 From: electria Date: Mon, 20 Jul 2026 19:22:33 -0700 Subject: [PATCH 1/6] feat: trim out consective zeros instead of clamping the number of significant digits fixes `tylc "14.00643 + 1.00784 * 4 + 35.446 + 15.9994 * 4"` --- src/main.rs | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/src/main.rs b/src/main.rs index 247ba53..a056ef6 100644 --- a/src/main.rs +++ b/src/main.rs @@ -16,7 +16,19 @@ pub fn get_significant_digits(n: &Float) -> usize { let raw_string = format!("{n}"); let mut significant_digits = raw_string.len() - 1; - for (i, _) in raw_string.char_indices() { + let mut consecutive_zeros = 0; + for (i, c) in raw_string.char_indices() { + if c == '0' { + consecutive_zeros += 1; + } else { + consecutive_zeros = 0; + } + + if consecutive_zeros >= 10 { + significant_digits = i - consecutive_zeros; + break; + } + if !raw_string[i..raw_string.len()].contains(|c| matches!(c, '1'..'9')) { significant_digits = i; break; @@ -38,5 +50,5 @@ fn main() { let result = parse_and_calc(&input); - println!("{result:.0$}", get_significant_digits(&result).clamp(0, 6)); + println!("{result:.0$}", get_significant_digits(&result)); } From c8bc766e2a08f0361ed64d4d28c154db1920da26 Mon Sep 17 00:00:00 2001 From: electria Date: Mon, 20 Jul 2026 19:32:22 -0700 Subject: [PATCH 2/6] feat: also check consecutive nines fixes `tylc "12.0096 + 15.9994 * 2"` --- src/main.rs | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/main.rs b/src/main.rs index a056ef6..c9921ab 100644 --- a/src/main.rs +++ b/src/main.rs @@ -17,6 +17,7 @@ pub fn get_significant_digits(n: &Float) -> usize { let mut significant_digits = raw_string.len() - 1; let mut consecutive_zeros = 0; + let mut consecutive_nines = 0; for (i, c) in raw_string.char_indices() { if c == '0' { consecutive_zeros += 1; @@ -24,9 +25,18 @@ pub fn get_significant_digits(n: &Float) -> usize { consecutive_zeros = 0; } + if c == '9' { + consecutive_nines += 1; + } else { + consecutive_nines = 0; + } + if consecutive_zeros >= 10 { significant_digits = i - consecutive_zeros; break; + } else if consecutive_nines >= 10 { + significant_digits = i - consecutive_nines; + break; } if !raw_string[i..raw_string.len()].contains(|c| matches!(c, '1'..'9')) { From 6e14c4e967fefb2ea3e7bb1e79e54821b3053115 Mon Sep 17 00:00:00 2001 From: electria Date: Mon, 20 Jul 2026 19:34:44 -0700 Subject: [PATCH 3/6] style: don't bury `fn main` --- src/main.rs | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/src/main.rs b/src/main.rs index c9921ab..51c2775 100644 --- a/src/main.rs +++ b/src/main.rs @@ -8,6 +8,21 @@ use rug::Float; mod nodes; +fn main() { + let input = match env::args().skip(1).reduce(|x, a| a + &x) { + Some(s) => s, + None => { + let mut buf = String::new(); + io::stdin().read_to_string(&mut buf).unwrap(); + buf + } + }; + + let result = parse_and_calc(&input); + + println!("{result:.0$}", get_significant_digits(&result)); +} + pub fn parse_and_calc(s: &str) -> Float { nodes::Nodes::from_str(s).unwrap().evaluate() } @@ -47,18 +62,3 @@ pub fn get_significant_digits(n: &Float) -> usize { significant_digits } - -fn main() { - let input = match env::args().skip(1).reduce(|x, a| a + &x) { - Some(s) => s, - None => { - let mut buf = String::new(); - io::stdin().read_to_string(&mut buf).unwrap(); - buf - } - }; - - let result = parse_and_calc(&input); - - println!("{result:.0$}", get_significant_digits(&result)); -} From ca6af4d06fdd5e04464013fddf1074a50065ccb9 Mon Sep 17 00:00:00 2001 From: electria Date: Mon, 20 Jul 2026 19:41:50 -0700 Subject: [PATCH 4/6] tests: for significant digits --- src/main.rs | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/src/main.rs b/src/main.rs index 51c2775..2bc89f2 100644 --- a/src/main.rs +++ b/src/main.rs @@ -62,3 +62,14 @@ pub fn get_significant_digits(n: &Float) -> usize { significant_digits } + +#[test] +fn test_get_significant_digits() { + let many_zeros = parse_and_calc("14.00643 + 1.00784 * 4 + 35.446 + 15.9994 * 4"); + assert_eq!(many_zeros.to_f64(), 117.48139); + let many_nines = parse_and_calc("12.0096 + 15.9994 * 2"); + assert_eq!(many_nines.to_f64(), 44.0084); + + assert_eq!(get_significant_digits(&many_zeros), 8); + assert_eq!(get_significant_digits(&many_nines), 6); +} From 016e21ac5a63b7880be7d32e414a375543acd72b Mon Sep 17 00:00:00 2001 From: electria Date: Mon, 20 Jul 2026 20:13:39 -0700 Subject: [PATCH 5/6] fix: include '9' when checking for any more digits --- src/main.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/main.rs b/src/main.rs index 2bc89f2..368ef3d 100644 --- a/src/main.rs +++ b/src/main.rs @@ -54,7 +54,7 @@ pub fn get_significant_digits(n: &Float) -> usize { break; } - if !raw_string[i..raw_string.len()].contains(|c| matches!(c, '1'..'9')) { + if !raw_string[i..raw_string.len()].contains(|c| matches!(c, '1'..='9')) { significant_digits = i; break; } @@ -69,7 +69,10 @@ fn test_get_significant_digits() { assert_eq!(many_zeros.to_f64(), 117.48139); let many_nines = parse_and_calc("12.0096 + 15.9994 * 2"); assert_eq!(many_nines.to_f64(), 44.0084); + let zero_nine_zero = parse_and_calc("2+12321(5+123)"); + assert_eq!(zero_nine_zero.to_f64(), 1577090.0); assert_eq!(get_significant_digits(&many_zeros), 8); assert_eq!(get_significant_digits(&many_nines), 6); + assert_eq!(get_significant_digits(&zero_nine_zero), 6); } From 48a1da47fbd6ca2c40a40e71deefa76bec4ea971 Mon Sep 17 00:00:00 2001 From: electria Date: Mon, 20 Jul 2026 20:25:10 -0700 Subject: [PATCH 6/6] fix: implicit operator for adjacent parenthesis --- src/nodes/from_str.rs | 7 +++---- src/nodes/tests.rs | 5 +++++ 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/src/nodes/from_str.rs b/src/nodes/from_str.rs index a28b15a..94a4af4 100644 --- a/src/nodes/from_str.rs +++ b/src/nodes/from_str.rs @@ -111,10 +111,6 @@ impl FromStr for Nodes { } ParsingState::ReadingNumber(start_index) => { if !is_number_char(c) { - if matches!(nodes.last(), Some(Node::ParenthesisEnd)) { - nodes.push(Node::Operator(Default::default())); - } - nodes.push(Node::Number( Float::parse(&filtered_string[start_index..i]) .map_err(|e| { @@ -138,6 +134,9 @@ impl FromStr for Nodes { } else if c.is_alphabetic() { state = ParsingState::ReadingFunctionName(i); } else if c == '(' { + if matches!(nodes.last(), Some(Node::Number(_) | Node::ParenthesisEnd)) { + nodes.push(Node::Operator(Default::default())); + } nodes.push(Node::ParenthesisStart); } else if c == ')' { nodes.push(Node::ParenthesisEnd); diff --git a/src/nodes/tests.rs b/src/nodes/tests.rs index ae50576..405efe5 100644 --- a/src/nodes/tests.rs +++ b/src/nodes/tests.rs @@ -11,6 +11,11 @@ fn implicit_mult() { Nodes::from_str("10 sin(10)").unwrap().evaluate().to_f64(), -5.440211108893698 ); + + assert_eq!( + Nodes::from_str("(10)(10)").unwrap().evaluate().to_f64(), + 100., + ) } #[test]