feat: sunset spr in favor of native cargo commands and cargo-generate

Author: icyJoseph

.gitignore

@@ -4,13 +4,12 @@ utils
 *.py
 src/main.rs
 Cargo.lock
-Cargo.toml
 target
 rust_builds
 tests/overrandomized.in
 rls
-!spr/Cargo.toml
-!spr/Cargo.lock
 !src/**/Cargo.toml
 !template/Cargo.toml
 .vscode/
+.rustc_info.json
+release

Cargo.toml

@@ -0,0 +1,3 @@
+[workspace]
+members = ["./src/*/src/.."]
+ 

README.md

@@ -8,7 +8,7 @@ Solutions to Kick Start Problems, Codeforces and CodeJam are all mixed up in the
 
 ## Quick start
 
-In this competitions speed is everything, that's why there's a file, `src/example.src`, which can be used to start solving a problem.
+In this competitions speed is everything, that's why there's a file, `template/src/main.src`, which can be used to start solving a problem.
 
 It contains number parsing, and vector parsing for `i32`, `usize`, `u32`, etc. All generics that implement `FromStr`.
 
@@ -49,49 +49,27 @@ fn main() -> Res<()> {
 }
 ```
 
-## `spr`
+## Creating a new problem
 
-`spr` is a Rust CLI to simplify and speed up problem solving.
-
-It has two modes, `create` and `run`. The default mode is to `run`.
-
-### Compiling
-
-From the root of the project:
+Enter to the `src` folder and run:
 
 ```
-cd spr
+cargo generate --path ./template --name <problem_name> --force
 ```
 
-Build the binary:
+## Solving a problem
 
-```
-cargo build --release
-```
+Place your solution inside the `main` function. Create as many helpers as necessary.
 
-### Creating a new problem
+## Run a problem
 
-From the root of the project:
+From the problem directory:
 
 ```
-./spr/target/release/spr <problem-name> -m create
+cargo build --release --target-dir .
+./release/<problem_name> < <problem_name>.in
 ```
 
-This copies the contents of `src/example.rs` to `src/<problem-name>.rs` and also creates a test file `tests/<problem-name>.in`.
-
-### Run a problem
-
-From the root of the project:
-
-```
-./spr/target/release/spr <problem-name>
-```
-
-This runs `rustc src/<problem-name>.rs --out-dir rls` and then pipes `tests/<problem-name>.in` to `./rls/<problem-name>`.
-
-- If an error should occur at any stage, the error message shows in the `stdout`.
-- If all goes well, then your program output shows in the `stdin`.
-
 ## Legacy
 
 ### CodeJam 2019

spr/Cargo.lock

@@ -1,13 +1,13 @@
 [package]
-name = "spr"
-version = "0.1.0"
 authors = ["Joseph Chamochumbi <sephxd1234@gmail.com>"]
 edition = "2018"
+name = "seven-segment-display"
+version = "0.1.0"
+  
+# See more keys and their definitions at https://doc.rust-lang.org/car
+
+
+
+
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
-[dependencies]
-structopt = "0.3.13"
-confy = "0.4.0"
-serde= "^1.0"
-serde_derive= "^1.0"

spr/src/main.rs

@@ -0,0 +1,46 @@
+use std::io;
+
+fn main() -> Res<()> {
+    let n = parse_num::<u32>();
+    for case in 1..=n {
+        println!("Case #{}: {}", case, 0);
+    }
+
+    Ok(())
+}
+
+type Res<T> = Result<T, Box<dyn std::error::Error>>;
+
+fn nxt() -> String {
+    let mut input = String::new();
+    match io::stdin().read_line(&mut input) {
+        Ok(_) => input,
+        _ => panic!("Error reading line"),
+    }
+}
+
+fn parse_num<T: std::str::FromStr>() -> T {
+    match nxt().trim().parse::<T>() {
+        Ok(n) => n,
+        _ => panic!("Error parsing"),
+    }
+}
+
+#[allow(dead_code)]
+fn parse_vec<T: std::str::FromStr>() -> Vec<T> {
+    nxt()
+        .split_whitespace()
+        .map(|x| match x.parse::<T>() {
+            Ok(n) => n,
+            _ => panic!("Could not parse vector"),
+        })
+        .collect()
+}
+
+#[allow(dead_code)]
+fn string_vec<T: std::string::ToString>(vec: &Vec<T>, separator: &str) -> String {
+    vec.iter()
+        .map(|x| x.to_string())
+        .collect::<Vec<String>>()
+        .join(separator)
+}

spr/Cargo.toml src/seven-segment-display/Cargo.toml

@@ -0,0 +1,5 @@
+4
+1 1111111
+2 0000000 0001010
+3 0100000 0000111 0000011
+5 1011011 1011111 1010000 1011111 1011011