Teaching on CuriousCoding

Intro to Rust

Tue, 16 Jan 2024 00:00:00 +0100

These are notes for a quick introduction to Rust.

Overview Link to heading

Statically typed & Compiled language.
Great developer experience:
- cargo build system
- rust-analyzer LSP

Rust features Link to heading

Basics Link to heading

C++	Rust
std::size_t	usize
std::pointerdiff_t	isize
int	i32
unsigned int	u32
long long	i64
unsigned long long	u64

string	String
string_view	&str
byte	u8
char	char

vector<T>	Vec<T>
array<int, 4>	[u32; 4]
int[]	&[u32]

T	T
const T&	&T
T&	&mut T
T*	unsafe { T* }
unique_ptr<T>	Box<T>

optional<T>	Option<T>
variant<T, E>	Result<T, E>

C++	Rust
for(int i = 0; i < n; ++i) {}	for i in 0..n {}
while(true) {}	loop {}
while(f()) {}	while f() {}
do { } while (f());	loop { if !f() { break; } }
switch x { case 1:; }	match x { 1 => {} }

C++	Rust
cout << “text” << endl;	println!(“text”);
cout << 1+1 << endl;	println!("{}", 1+1);
cout << n << endl;	println!("{n}");

Basic syntax Link to heading

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56


// trailing return type
fn square(x: u32) -> u32 {
 // return on last line can be omitted
 x*x
}

// mutable reference
fn increment(x: &mut u32) {
 *x += 1;
}

fn main(){
 // Introduce variables with let.
 // Types are automatically inferred.
 let a = 1;
 // b is mutable.
 let mut b = 1;
 b += 1;
 // c, d, and e are usize:
 let c: usize = 1;
 let d = 1usize;
 let e = usize::MAX;

 // No parentheses needed.
 if a > b {
 // This shouldn't happen.
 panic!();
 }

 // 0..n is a `Range`.
 // Ranges are `IntoIterator` and converted into an iterator, which is looped over.
 for i in 0..n {
 // Print i to a line on stderr.
 eprintln!("{i}");
 }

 while b < 1000 {
 increment(b);
 }

 loop {
 b = square(b);
 if b > 1000000000 {
 break;
 }
 }

 // Pattern matching
 match 5 {
 0 => panic!(),
 1 => todo!(),
 2..3 => eprintln!("small"),
 x if x%2==0 => eprintln!("even {x}"),
 _ => eprintln!("odd");
 }
}

Expressions everywhere! Link to heading

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


let a = { 1 + 1 };
let b = if a > 10 { a } else { 10 };
let c = loop {
 break 3;
};
let d = {
 let mut x = 1;
 while x < 1000 {
 x *= 2;
 }
 x
};
let a = match Some(5) {
 None => 0,
 Some(x) => 2*x,
};

Closures Link to heading

1
2
3
4


let double = |x| 2*x;
let a = double(1);
let multiply = |x: usize, y: usize| -> usize { x * y };
let b = multiply(2, 3);

Pattern matching Link to heading

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


let a: Option<i32> = Some(1);
match a {
 Some(0) => eprintln!("I am 0"),
 Some(x) if x % 2 == 0 => eprintln!("I am even"),
 Some(x) => eprintln!("I am {x}"),
 None => eprintln!("I am none"),
}

if let Some(x) = a {
 eprintln!("a = Some({x})");
}

let Some(x) = a else {
 return;
};
eprintln!("{x}");

let x = a.unwrap();

References Link to heading

Ownership Link to heading

Containers Link to heading

1
2
3
4
5


// Create an array
let a: [usize; 10] = [1; 10];
// Create a vec
let v: Vec<usize> = vec![1usize; 10];
assert_eq!(&a, &v, "Slices are not equal!");

Traits Link to heading

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


trait MyTrait {
 fn my_fn(&self);
}

impl MyTrait for usize {
 fn my_fn(&self) {
 eprintln!("I am a usize!");
 }
}

impl MyTrait for i32 {
 fn my_fn(&self) {
 eprintln!("I am a i32!");
 }
}

fn f(t: impl MyTrait) {
 t.my_fn();
}

fn main() {
 let a = 1; // i32 by default
 a.my_fn();
 let b = 1usize;
 b.my_fn();
 f(a);
 f(b);
}

Iterators Link to heading

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


for i in 0..10 {
 eprintln!("i={}", i);
}

let v = (0..10).collect_vec();

for x in &v {
 eprintln!("x={}", x);
}

for (i, x) in v.iter().enumerate() {
 eprintln!("{i:>2} => {x}");
}

for x in v.iter().filter(|x| **x % 2 == 0) {
 eprintln!("x={}", x);
}

for x in v.iter().map(|x| x * x) {
 eprintln!("square: {}", x);
}

Common libraries Link to heading

See blessed.rs for a list of commonly used and recommended libraries.

A*PA talk @ CWI

Wed, 27 Dec 2023 00:00:00 +0100

I recently gave a talk about A*PA at CWI. Sadly the recording doesn’t show the blackboard, but either way, find it here.

BAPCtools instruction

Tue, 17 Oct 2023 00:00:00 +0200

Steps:

Clone https://github.com/RagnarGrootKoerkamp/BAPCtools

Make an alias to the executable:

1

ln -s ~/git/BAPCtools/bin/tools.py ~/bin/bt

Create a new problem:

1
2
3


cd ~/problems
bt new_problem my_problem_name
cd ~/problems/my_problem_name

You now have the following:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


.
├── data
│   ├── sample
│   │   └── 1.in # Sample testcase input
│   │   └── 1.ans # Sample testcase output
│   └── secret
├── generators # for later
│   └── ...
├── input_validators # for later
│   └── ...
├── output_validators # for later
│   └── ...
├── problem_statement
│   ├── figure.tex.template
│   ├── problem.en.tex # The problem statement
├── problem.yaml
└── submissions
 ├── accepted
 │   └── name.cpp # A submission
 ├── run_time_error
 ├── time_limit_exceeded
 └── wrong_answer

Edit the statement problem.en.tex
Make some samples by hand in data/samples/*.{in,ans}
Write a solution in submissions/accepted/<yourname>.{py,cpp,java}.
Use bt run or bt run submissions/accepted/<submission> to test your submission.

Competitive Programming Lecture

Wed, 28 Sep 2022 00:00:00 +0200

Table of Contents

Contest strategies
Pairwise Alignment using A*
Exercises

Contest strategies Link to heading

Preparation

Thinking costs energy!
Sleep enough; early to bed the 2 nights before.
No practising on contest day (and the day before); it just takes energy.

During the contest

Eat! At the very least take a break halfway with the entire team and eat some snacks.
Make sure to read all the problems before the end of the contest. In the beginning, split the problems to find the simple ones, but towards the end, find a problem you think you can solve (because of the scoreboard or because you like it), and work on it as a team.

Coding

Ideally, use C++. Otherwise, Python can be used too.
- For big-integer problems, prefer Python.
Use a TCR (e.g. https://github.com/TimonKnigge/TCR): a 25 page document containing algorithms. Ideally, implement all of them yourself so you know how they work. Otherwise download one.
Make a template, and add it to your TCR. One person should type this in the first minutes of the contest and copy it to A.cpp, B.cpp, … .
When you think you solved a problem:
- Decide exactly how the code will look. Maybe write pseudocode on paper.
- For hard problems: verify your solution with a teammate.
- Once the keyboard is free, start typing it out. If needed, ask one teammate to look while you code.
- Typical distribution:
  - 1 person typing
  - 1 person solving a new problem
  - 1 person helping the other 2: spotting typos or working on problems.

Pairwise Alignment using A* Link to heading

Some resources you can use: