forked from CocDap/Rust-Bootcamp-2023
-
Notifications
You must be signed in to change notification settings - Fork 0
/
conditions.rs
173 lines (154 loc) · 3.72 KB
/
conditions.rs
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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
//Exercise 1
// Complete this function to return the bigger number!
// Do not use:
// - another function call
// - additional variables
pub fn bigger(a: i32, b: i32) -> i32 {
if a>b{
a
}
else{
b
}
}
//Exercise 2
// Input: Provide an arbitrary value of number
// Check number is Positive or Negative or Zero
// Output: &str
fn check_number(number: i32) -> &'static str {
if number>0{
"Positive"
}
else if number<0{
"Negative"
}
else{
"Zero"
}
}
// Exercise 3
// Step 1: Make me compile!
// Step 2: Get the bar_for_fuzz and default_to_baz tests passing!
pub fn foo_if_fizz(fizzish: &str) -> &str {
if fizzish == "fizz" {
"foo"
} else {
"bar"
}
}
// Exercise 4
// Determine if a given year is a leap year
// Implement logic
fn is_leap_year(year: i32) -> bool {
year%400==0 || (year%4==0 && year%100!=0)
}
// Exercise 5
// Calculate the factorial of a number
// Implement logic
fn factorial(n: u32) -> u32 {
let mut ans:u32=1;
for tmp in 1..n+1 {
ans=ans*tmp;
}
ans
}
// Exercise 6
// Check if a number is prime
// Implement logic
fn is_prime(n: u32) -> bool {
if n<2 {
return false;
}
for var in 2..n {
if n%var==0 {
return false;
}
}
true
}
// Don't mind this for now :)
#[cfg(test)]
mod tests {
use super::*;
// Test for exercise 1
#[test]
fn ten_is_bigger_than_eight() {
assert_eq!(10, bigger(10, 8));
}
// Test for exercise 1
#[test]
fn fortytwo_is_bigger_than_thirtytwo() {
assert_eq!(42, bigger(32, 42));
}
// Test for exercise 2
#[test]
fn test_check_number_positive() {
let result = check_number(10);
assert_eq!(result, "Positive");
}
// Test for exercise 2
#[test]
fn test_check_number_negative() {
let result = check_number(-5);
assert_eq!(result, "Negative");
}
// Test for exercise 2
#[test]
fn test_check_number_zero() {
let result = check_number(0);
assert_eq!(result, "Zero");
}
// Test for exercise 3
#[test]
fn foo_for_fizz() {
assert_eq!(foo_if_fizz("fizz"), "foo")
}
// Test for exercise 3
#[test]
fn bar_for_fuzz() {
assert_eq!(foo_if_fizz("fuzz"), "bar")
}
// Test for exercise 3
#[test]
fn default_to_baz() {
assert_eq!(foo_if_fizz("literally anything"), "bar")
}
// Test for exercise 4
#[test]
fn test_leap_year() {
assert_eq!(is_leap_year(2020), true);
assert_eq!(is_leap_year(2000), true);
assert_eq!(is_leap_year(1600), true);
}
// Test for exercise 4
#[test]
fn test_non_leap_year() {
assert_eq!(is_leap_year(2021), false);
assert_eq!(is_leap_year(1900), false);
assert_eq!(is_leap_year(1800), false);
}
// Test for exercise 5
#[test]
fn test_factorial() {
assert_eq!(factorial(0), 1);
assert_eq!(factorial(1), 1);
assert_eq!(factorial(5), 120);
assert_eq!(factorial(10), 3628800);
}
// Test for exercise 6
#[test]
fn test_prime_number() {
assert_eq!(is_prime(2), true);
assert_eq!(is_prime(7), true);
assert_eq!(is_prime(13), true);
assert_eq!(is_prime(19), true);
}
// Test for exercise 6
#[test]
fn test_non_prime_number() {
assert_eq!(is_prime(1), false);
assert_eq!(is_prime(4), false);
assert_eq!(is_prime(10), false);
assert_eq!(is_prime(15), false);
}
}