From ec452bdb88a808c21d4b63faea57c565e7e246a1 Mon Sep 17 00:00:00 2001 From: lee Date: Thu, 30 Jul 2020 11:11:28 +0100 Subject: [PATCH 1/8] go raids --- subjects/raid1/README.md | 569 +++++++++++++++++++++++++++++++++ subjects/raid1/audit/README.md | 437 +++++++++++++++++++++++++ subjects/raid1a/README.md | 111 ------- subjects/raid1b/README.md | 111 ------- subjects/raid1c/README.md | 111 ------- subjects/raid1d/README.md | 111 ------- subjects/raid1e/README.md | 111 ------- subjects/raid3/audit/README.md | 73 +++++ 8 files changed, 1079 insertions(+), 555 deletions(-) create mode 100644 subjects/raid1/README.md create mode 100644 subjects/raid1/audit/README.md delete mode 100644 subjects/raid1a/README.md delete mode 100644 subjects/raid1b/README.md delete mode 100644 subjects/raid1c/README.md delete mode 100644 subjects/raid1d/README.md delete mode 100644 subjects/raid1e/README.md create mode 100644 subjects/raid3/audit/README.md diff --git a/subjects/raid1/README.md b/subjects/raid1/README.md new file mode 100644 index 000000000..f0e04eb30 --- /dev/null +++ b/subjects/raid1/README.md @@ -0,0 +1,569 @@ +# raid1 + +## raid1a + +### Instructions + +Write a function `Raid1a` that prints a **valid** rectangle of width `x` and of height `y`. + +The function must draw the rectangles as in the examples. + +`x` and `y` will always be positive numbers. Otherwise, the function should print nothing. + +### Expected function + +```go +func Raid1a(x,y int) { + +} +``` + +### Usage + +Here are possible programs to test your function : + +Program #1 + +```go +package main + +import piscine ".." + +func main() { + piscine.Raid1a(5,3) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +o---o +| | +o---o +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #2 + +```go +package main + +import piscine ".." + +func main() { + piscine.Raid1a(5,1) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +o---o +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #3 + +```go +package main + +import piscine ".." + +func main() { + piscine.Raid1a(1,1) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +o +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #4 + +```go +package main + +import piscine ".." + +func main() { + piscine.Raid1a(1,5) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +o +| +| +| +o +student@ubuntu:~/[[ROOT]]/test$ +``` + +---- + +## raid1b + +### Instructions + +Write a function `Raid1b` that prints a **valid** rectangle of width `x` and of height `y`. + +The function must draw the rectangles as in the examples. + +`x` and `y` will always be positive numbers. Otherwise, the function should print nothing. + +### Expected function + +```go +func Raid1b(x,y int) { + +} +``` + +### Usage + +Here are possible programs to test your function : + +Program #1 + +```go +package main + +import piscine ".." + +func main() { + piscine.Raid1b(5,3) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +/***\ +* * +\***/ +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #2 + +```go +package main + +import piscine ".." + +func main() { + piscine.Raid1b(5,1) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +/***\ +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #3 + +```go +package main + +import piscine ".." + +func main() { + piscine.Raid1b(1,1) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +/ +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #4 + +```go +package main + +import piscine ".." + +func main() { + piscine.Raid1b(1,5) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +/ +* +* +* +\ +student@ubuntu:~/[[ROOT]]/test$ +``` + +---- + +## raid1c + +### Instructions + +Write a function `Raid1c` that prints a **valid** rectangle of width `x` and of height `y`. + +The function must draw the rectangles as in the examples. + +`x` and `y` will always be positive numbers. Otherwise, the function should print nothing. + +### Expected function + +```go +func Raid1c(x,y int) { + +} +``` + +### Usage + +Here are possible programs to test your function : + +Program #1 + +```go +package main + +import piscine ".." + +func main() { + piscine.Raid1c(5,3) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +ABBBA +B B +CBBBC +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #2 + +```go +package main + +import piscine ".." + +func main() { + piscine.Raid1c(5,1) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +ABBBA +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #3 + +```go +package main + +import piscine ".." + +func main() { + piscine.Raid1c(1,1) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +A +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #4 + +```go +package main + +import piscine ".." + +func main() { + piscine.Raid1c(1,5) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +A +B +B +B +C +student@ubuntu:~/[[ROOT]]/test$ +``` + +---- + +## raid1d + +### Instructions + +Write a function `Raid1d` that prints a **valid** rectangle of width `x` and of height `y`. + +The function must draw the rectangles as in the examples. + +`x` and `y` will always be positive numbers. Otherwise, the function should print nothing. + +### Expected function + +```go +func Raid1d(x,y int) { + +} +``` + +### Usage + +Here are possible programs to test your function : + +Program #1 + +```go +package main + +import piscine ".." + +func main() { + piscine.Raid1d(5,3) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +ABBBC +B B +ABBBC +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #2 + +```go +package main + +import piscine ".." + +func main() { + piscine.Raid1d(5,1) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +ABBBC +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #3 + +```go +package main + +import piscine ".." + +func main() { + piscine.Raid1d(1,1) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +A +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #4 + +```go +package main + +import piscine ".." + +func main() { + piscine.Raid1d(1,5) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +A +B +B +B +A +student@ubuntu:~/[[ROOT]]/test$ +``` + +---- + +## raid1e + +### Instructions + +Write a function `Raid1e` that prints a **valid** rectangle of width `x` and of height `y`. + +The function must draw the rectangles as in the examples. + +`x` and `y` will always be positive numbers. Otherwise, the function should print nothing. + +### Expected function + +```go +func Raid1e(x,y int) { + +} +``` + +### Usage + +Here are possible programs to test your function : + +Program #1 + +```go +package main + +import piscine ".." + +func main() { + piscine.Raid1e(5,3) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +ABBBC +B B +CBBBA +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #2 + +```go +package main + +import piscine ".." + +func main() { + piscine.Raid1e(5,1) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +ABBBC +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #3 + +```go +package main + +import piscine ".." + +func main() { + piscine.Raid1e(1,1) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +A +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #4 + +```go +package main + +import piscine ".." + +func main() { + piscine.Raid1e(1,5) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +A +B +B +B +C +student@ubuntu:~/[[ROOT]]/test$ +``` diff --git a/subjects/raid1/audit/README.md b/subjects/raid1/audit/README.md new file mode 100644 index 000000000..86718583c --- /dev/null +++ b/subjects/raid1/audit/README.md @@ -0,0 +1,437 @@ +#### raid1a + +##### Try running the function with the arguments: `"x=5 and y=3"` + +``` +o---o +| | +o---o +``` + +###### Does the function returns the value above? + +##### Try running the function with the arguments: `"x=5 and y=1"` + +``` +o---o +``` + +###### Does the function returns the value above? + +##### Try running the function with the arguments: `"x=1 and y=1"` + +``` +o +``` + +###### Does the function returns the value above? + +##### Try running the function with the arguments: `"x=1 and y=5"` + +``` +o +| +| +| +o +``` + +###### Does the function returns the value above? + +##### Try running the function with the arguments: `"x=0 and y=0"` + +###### Does the function returns nothing? + +##### Try running the function with the arguments: `"x=-1 and y=6"` + +###### Does the function returns nothing? + +##### Try running the function with the arguments: `"x=6 and y=-1"` + +###### Does the function returns nothing? + +##### Try running the function with the arguments: `"x=20 and y=1"` + +``` +o------------------o +``` + +###### Does the function returns the value above? + + +##### Try running the function with the arguments: `"x=10 and y=8"` + +``` +o--------o +| | +| | +| | +| | +| | +| | +o--------o +``` + +###### Does the function returns the value above? + +#### raid1b + +##### Try running the function with the arguments: `"x=5 and y=3"` + +``` +/***\ +* * +\***/ +``` + +###### Does the function returns the value above? + +##### Try running the function with the arguments: `"x=5 and y=1"` + +``` +/***\ +``` + +###### Does the function returns the value above? + + +##### Try running the function with the arguments: `"x=1 and y=1"` + +``` +/ +``` + +###### Does the function returns the value above? + +##### Try running the function with the arguments: `"x=1 and y=5"` + +``` +/ +* +* +* +\ +``` + +###### Does the function returns the value above? + +##### Try running the function with the arguments: `"x=0 and y=0"` + +###### Does the function returns nothing? + +##### Try running the function with the arguments: `"x=-1 and y=6"` + +###### Does the function returns nothing? + +##### Try running the function with the arguments: `"x=6 and y=-1"` + +###### Does the function returns nothing? + +##### Try running the function with the arguments: `"x=18 and y=6"` + +``` +/****************\ +* * +* * +* * +* * +\****************/ +``` + +###### Does the function returns the value above? + +##### Try running the function with the arguments: `"x=9 and y=3"` + +``` +/*******\ +* * +\*******/ +``` + +###### Does the function returns the value above? + +#### raid1c + +##### Try running the function with the arguments: `"x=5 and y=3"` + +``` +ABBBA +B B +CBBBC +``` + +###### Does the function returns the value above? + +##### Try running the function with the arguments: `"x=5 and y=1"` + +``` +ABBBA +``` + +###### Does the function returns the value above? + +##### Try running the function with the arguments: `"x=1 and y=1"` + +``` +A +``` + +###### Does the function returns the value above? + +##### Try running the function with the arguments: `"x=1 and y=5"` + +``` +A +B +B +B +C +``` + +###### Does the function returns the value above? + +##### Try running the function with the arguments: `"x=0 and y=0"` + +###### Does the function returns nothing? + +##### Try running the function with the arguments: `"x=-1 and y=6"` + +###### Does the function returns nothing? + +##### Try running the function with the arguments: `"x=6 and y=-1"` + +###### Does the function returns nothing? + +##### Try running the function with the arguments: `"x=13 and y=7"` + +``` +ABBBBBBBBBBBA +B B +B B +B B +B B +B B +CBBBBBBBBBBBC +``` + +###### Does the function returns the value above? + +##### Try running the function with the arguments: `"x=10 and y=15"` + +``` +ABBBBBBBBA +B B +B B +B B +B B +B B +B B +B B +B B +B B +B B +B B +B B +B B +CBBBBBBBBC +``` + +###### Does the function returns the value above? + +#### raid1d + +##### Try running the function with the arguments: `"x=5 and y=3"` + +``` +ABBBC +B B +ABBBC +``` + +###### Does the function returns the value above? + +##### Try running the function with the arguments: `"x=5 and y=1"` + +``` +ABBBC +``` + +###### Does the function returns the value above? + +##### Try running the function with the arguments: `"x=1 and y=1"` + +``` +A +``` + +###### Does the function returns the value above? + +##### Try running the function with the arguments: `"x=1 and y=5"` + +``` +A +B +B +B +A +``` + +###### Does the function returns the value above? + +##### Try running the function with the arguments: `"x=0 and y=0"` + +###### Does the function returns nothing? + +##### Try running the function with the arguments: `"x=-1 and y=6"` + +###### Does the function returns nothing? + +##### Try running the function with the arguments: `"x=6 and y=-1"` + +###### Does the function returns nothing? + +##### Try running the function with the arguments: `"x=3 and y=16"` + +``` +ABC +B B +B B +B B +B B +B B +B B +B B +B B +B B +B B +B B +B B +B B +B B +ABC +``` + +###### Does the function returns the value above? + +##### Try running the function with the arguments: `"x=7 and y=16"` + +``` +ABBBBBC +B B +B B +B B +B B +B B +B B +B B +B B +B B +B B +B B +B B +B B +B B +ABBBBBC +``` + +###### Does the function returns the value above? + +#### raid1e + +##### Try running the function with the arguments: `"x=5 and y=3"` + +``` +ABBBC +B B +CBBBA +``` + +###### Does the function returns the value above? + +##### Try running the function with the arguments: `"x=5 and y=1"` + +``` +ABBBC +``` + +###### Does the function returns the value above? + +##### Try running the function with the arguments: `"x=1 and y=1"` + +``` +A +``` + +###### Does the function returns the value above? + +##### Try running the function with the arguments: `"x=1 and y=5"` + +``` +A +B +B +B +C +``` + +###### Does the function returns the value above? + +##### Try running the function with the arguments: `"x=0 and y=0"` + +###### Does the function returns nothing? + +##### Try running the function with the arguments: `"x=-1 and y=6"` + +###### Does the function returns nothing? + +##### Try running the function with the arguments: `"x=6 and y=-1"` + +###### Does the function returns nothing? + +##### Try running the function with the arguments: `"x=21 and y=24"` + +``` +ABBBBBBBBBBBBBBBBBBBC +B B +B B +B B +B B +B B +B B +B B +B B +B B +B B +B B +B B +B B +B B +B B +B B +B B +B B +B B +B B +B B +B B +CBBBBBBBBBBBBBBBBBBBA + +``` + +###### Does the function returns the value above? + +##### Try running the function with the arguments: `"x=18 and y=8"` + +``` +ABBBBBBBBBBBBBBBBC +B B +B B +B B +B B +B B +B B +CBBBBBBBBBBBBBBBBA + +``` + +###### Does the function returns the value above? diff --git a/subjects/raid1a/README.md b/subjects/raid1a/README.md deleted file mode 100644 index 6d8989ccf..000000000 --- a/subjects/raid1a/README.md +++ /dev/null @@ -1,111 +0,0 @@ -## raid1a - -### Instructions - -Write a function `Raid1a` that prints a **valid** rectangle of width `x` and of height `y`. - -The function must draw the rectangles as in the examples. - -`x` and `y` will always be positive numbers. Otherwise, the function should print nothing. - -### Expected function - -```go -func Raid1a(x,y int) { - -} -``` - -### Usage - -Here is are possible programs to test your function : - -Program #1 - -```go -package main - -import piscine ".." - -func main() { - piscine.Raid1a(5,3) -} -``` - -And its output : - -```console -student@ubuntu:~/[[ROOT]]/test$ go build -student@ubuntu:~/[[ROOT]]/test$ ./test -o---o -| | -o---o -student@ubuntu:~/[[ROOT]]/test$ -``` - -Program #2 - -```go -package main - -import piscine ".." - -func main() { - piscine.Raid1a(5,1) -} -``` - -And its output : - -```console -student@ubuntu:~/[[ROOT]]/test$ go build -student@ubuntu:~/[[ROOT]]/test$ ./test -o---o -student@ubuntu:~/[[ROOT]]/test$ -``` - -Program #3 - -```go -package main - -import piscine ".." - -func main() { - piscine.Raid1a(1,1) -} -``` - -And its output : - -```console -student@ubuntu:~/[[ROOT]]/test$ go build -student@ubuntu:~/[[ROOT]]/test$ ./test -o -student@ubuntu:~/[[ROOT]]/test$ -``` - -Program #4 - -```go -package main - -import piscine ".." - -func main() { - piscine.Raid1a(1,5) -} -``` - -And its output : - -```console -student@ubuntu:~/[[ROOT]]/test$ go build -student@ubuntu:~/[[ROOT]]/test$ ./test -o -| -| -| -o -student@ubuntu:~/[[ROOT]]/test$ -``` diff --git a/subjects/raid1b/README.md b/subjects/raid1b/README.md deleted file mode 100644 index fbe73adea..000000000 --- a/subjects/raid1b/README.md +++ /dev/null @@ -1,111 +0,0 @@ -## raid1b - -### Instructions - -Write a function `Raid1b` that prints a **valid** rectangle of width `x` and of height `y`. - -The function must draw the rectangles as in the examples. - -`x` and `y` will always be positive numbers. Otherwise, the function should print nothing. - -### Expected function - -```go -func Raid1b(x,y int) { - -} -``` - -### Usage - -Here is are possible programs to test your function : - -Program #1 - -```go -package main - -import piscine ".." - -func main() { - piscine.Raid1b(5,3) -} -``` - -And its output : - -```console -student@ubuntu:~/[[ROOT]]/test$ go build -student@ubuntu:~/[[ROOT]]/test$ ./test -/***\ -* * -\***/ -student@ubuntu:~/[[ROOT]]/test$ -``` - -Program #2 - -```go -package main - -import piscine ".." - -func main() { - piscine.Raid1b(5,1) -} -``` - -And its output : - -```console -student@ubuntu:~/[[ROOT]]/test$ go build -student@ubuntu:~/[[ROOT]]/test$ ./test -/***\ -student@ubuntu:~/[[ROOT]]/test$ -``` - -Program #3 - -```go -package main - -import piscine ".." - -func main() { - piscine.Raid1b(1,1) -} -``` - -And its output : - -```console -student@ubuntu:~/[[ROOT]]/test$ go build -student@ubuntu:~/[[ROOT]]/test$ ./test -/ -student@ubuntu:~/[[ROOT]]/test$ -``` - -Program #4 - -```go -package main - -import piscine ".." - -func main() { - piscine.Raid1b(1,5) -} -``` - -And its output : - -```console -student@ubuntu:~/[[ROOT]]/test$ go build -student@ubuntu:~/[[ROOT]]/test$ ./test -/ -* -* -* -\ -student@ubuntu:~/[[ROOT]]/test$ -``` diff --git a/subjects/raid1c/README.md b/subjects/raid1c/README.md deleted file mode 100644 index 1dd3e2ef8..000000000 --- a/subjects/raid1c/README.md +++ /dev/null @@ -1,111 +0,0 @@ -## raid1c - -### Instructions - -Write a function `Raid1c` that prints a **valid** rectangle of width `x` and of height `y`. - -The function must draw the rectangles as in the examples. - -`x` and `y` will always be positive numbers. Otherwise, the function should print nothing. - -### Expected function - -```go -func Raid1c(x,y int) { - -} -``` - -### Usage - -Here is are possible programs to test your function : - -Program #1 - -```go -package main - -import piscine ".." - -func main() { - piscine.Raid1c(5,3) -} -``` - -And its output : - -```console -student@ubuntu:~/[[ROOT]]/test$ go build -student@ubuntu:~/[[ROOT]]/test$ ./test -ABBBA -B B -CBBBC -student@ubuntu:~/[[ROOT]]/test$ -``` - -Program #2 - -```go -package main - -import piscine ".." - -func main() { - piscine.Raid1c(5,1) -} -``` - -And its output : - -```console -student@ubuntu:~/[[ROOT]]/test$ go build -student@ubuntu:~/[[ROOT]]/test$ ./test -ABBBA -student@ubuntu:~/[[ROOT]]/test$ -``` - -Program #3 - -```go -package main - -import piscine ".." - -func main() { - piscine.Raid1c(1,1) -} -``` - -And its output : - -```console -student@ubuntu:~/[[ROOT]]/test$ go build -student@ubuntu:~/[[ROOT]]/test$ ./test -A -student@ubuntu:~/[[ROOT]]/test$ -``` - -Program #4 - -```go -package main - -import piscine ".." - -func main() { - piscine.Raid1c(1,5) -} -``` - -And its output : - -```console -student@ubuntu:~/[[ROOT]]/test$ go build -student@ubuntu:~/[[ROOT]]/test$ ./test -A -B -B -B -C -student@ubuntu:~/[[ROOT]]/test$ -``` diff --git a/subjects/raid1d/README.md b/subjects/raid1d/README.md deleted file mode 100644 index fc68d54db..000000000 --- a/subjects/raid1d/README.md +++ /dev/null @@ -1,111 +0,0 @@ -## raid1d - -### Instructions - -Write a function `Raid1d` that prints a **valid** rectangle of width `x` and of height `y`. - -The function must draw the rectangles as in the examples. - -`x` and `y` will always be positive numbers. Otherwise, the function should print nothing. - -### Expected function - -```go -func Raid1d(x,y int) { - -} -``` - -### Usage - -Here is are possible programs to test your function : - -Program #1 - -```go -package main - -import piscine ".." - -func main() { - piscine.Raid1d(5,3) -} -``` - -And its output : - -```console -student@ubuntu:~/[[ROOT]]/test$ go build -student@ubuntu:~/[[ROOT]]/test$ ./test -ABBBC -B B -ABBBC -student@ubuntu:~/[[ROOT]]/test$ -``` - -Program #2 - -```go -package main - -import piscine ".." - -func main() { - piscine.Raid1d(5,1) -} -``` - -And its output : - -```console -student@ubuntu:~/[[ROOT]]/test$ go build -student@ubuntu:~/[[ROOT]]/test$ ./test -ABBBC -student@ubuntu:~/[[ROOT]]/test$ -``` - -Program #3 - -```go -package main - -import piscine ".." - -func main() { - piscine.Raid1d(1,1) -} -``` - -And its output : - -```console -student@ubuntu:~/[[ROOT]]/test$ go build -student@ubuntu:~/[[ROOT]]/test$ ./test -A -student@ubuntu:~/[[ROOT]]/test$ -``` - -Program #4 - -```go -package main - -import piscine ".." - -func main() { - piscine.Raid1d(1,5) -} -``` - -And its output : - -```console -student@ubuntu:~/[[ROOT]]/test$ go build -student@ubuntu:~/[[ROOT]]/test$ ./test -A -B -B -B -A -student@ubuntu:~/[[ROOT]]/test$ -``` diff --git a/subjects/raid1e/README.md b/subjects/raid1e/README.md deleted file mode 100644 index ed66922eb..000000000 --- a/subjects/raid1e/README.md +++ /dev/null @@ -1,111 +0,0 @@ -## raid1e - -### Instructions - -Write a function `Raid1e` that prints a **valid** rectangle of width `x` and of height `y`. - -The function must draw the rectangles as in the examples. - -`x` and `y` will always be positive numbers. Otherwise, the function should print nothing. - -### Expected function - -```go -func Raid1e(x,y int) { - -} -``` - -### Usage - -Here is are possible programs to test your function : - -Program #1 - -```go -package main - -import piscine ".." - -func main() { - piscine.Raid1e(5,3) -} -``` - -And its output : - -```console -student@ubuntu:~/[[ROOT]]/test$ go build -student@ubuntu:~/[[ROOT]]/test$ ./test -ABBBC -B B -CBBBA -student@ubuntu:~/[[ROOT]]/test$ -``` - -Program #2 - -```go -package main - -import piscine ".." - -func main() { - piscine.Raid1e(5,1) -} -``` - -And its output : - -```console -student@ubuntu:~/[[ROOT]]/test$ go build -student@ubuntu:~/[[ROOT]]/test$ ./test -ABBBC -student@ubuntu:~/[[ROOT]]/test$ -``` - -Program #3 - -```go -package main - -import piscine ".." - -func main() { - piscine.Raid1e(1,1) -} -``` - -And its output : - -```console -student@ubuntu:~/[[ROOT]]/test$ go build -student@ubuntu:~/[[ROOT]]/test$ ./test -A -student@ubuntu:~/[[ROOT]]/test$ -``` - -Program #4 - -```go -package main - -import piscine ".." - -func main() { - piscine.Raid1e(1,5) -} -``` - -And its output : - -```console -student@ubuntu:~/[[ROOT]]/test$ go build -student@ubuntu:~/[[ROOT]]/test$ ./test -A -B -B -B -C -student@ubuntu:~/[[ROOT]]/test$ -``` diff --git a/subjects/raid3/audit/README.md b/subjects/raid3/audit/README.md new file mode 100644 index 000000000..97f6a9532 --- /dev/null +++ b/subjects/raid3/audit/README.md @@ -0,0 +1,73 @@ +#### Raid 3 + +##### Try running the program: `"./raid1a 3 3 | ./raid3"` + +``` +[raid1a] [3] [3] +``` + +###### Does the program returns the value above? + +##### Try running the program: `"./raid1b 3 3 | ./raid3"` + +``` +[raid1b] [3] [3] +``` + +###### Does the program returns the value above? + +##### Try running the program: `"./raid1c 1 1 | ./raid3"` + +``` +[raid1c] [1] [1] || [raid1d] [1] [1] || [raid1e] [1] [1] +``` + +###### Does the program returns the value above? + +##### Try running the program: `"./raid1e 1 2 | ./raid3"` + +``` +[raid1c] [1] [2] || [raid1e] [1] [2] +``` + +###### Does the program returns the value above? + +##### Try running the program: `"./raid1e 2 1 | ./raid3"` + +``` +[raid1d] [2] [1] || [raid1e] [2] [1] +``` + +###### Does the program returns the value above? + +##### Try running the program: `"./raid1c 2 1 | ./raid3"` + +``` +[raid1c] [2] [1] +``` + +###### Does the program returns the value above? + +##### Try running the program: `"./raid1d 1 2 | ./raid3"` + +``` +[raid1d] [1] [2] +``` + +###### Does the program returns the value above? + +##### Try running the program: `"./raid1e 1 1 | ./raid3"` + +``` +[raid1c] [1] [1] || [raid1d] [1] [1] || [raid1e] [1] [1] +``` + +###### Does the program returns the value above? + +##### Try running the program: `"echo 0 0 | ./raid3"` + +``` +Not a Raid function +``` + +###### Does the program returns the value above? From 5dfbf1de419f32a843114b2615f21378719b9089 Mon Sep 17 00:00:00 2001 From: lee Date: Thu, 30 Jul 2020 11:25:53 +0100 Subject: [PATCH 2/8] js raids --- subjects/clonernews1/audit/README.md | 0 subjects/sortable1/README.md | 37 ++++++++++++++-------------- subjects/sortable1/audit/README.md | 5 ++++ 3 files changed, 23 insertions(+), 19 deletions(-) create mode 100644 subjects/clonernews1/audit/README.md create mode 100644 subjects/sortable1/audit/README.md diff --git a/subjects/clonernews1/audit/README.md b/subjects/clonernews1/audit/README.md new file mode 100644 index 000000000..e69de29bb diff --git a/subjects/sortable1/README.md b/subjects/sortable1/README.md index bd0302f25..c21ac3adb 100644 --- a/subjects/sortable1/README.md +++ b/subjects/sortable1/README.md @@ -32,21 +32,21 @@ fetch('https://rawcdn.githack.com/akabab/superhero-api/0.2.0/api/all.json') .then(loadData) // .then will call the function with the JSON value ``` - #### Display Not every field should be presented in a `` element, the necessary data will be: - - Icon (`.images.xs`, should be displayed as images and not as a string) - - Name (`.name`) - - Full Name (`.biography.fullName`) - - Powerstats (each entry of `.powerstats`) - - Race (`.appearance.race`) - - Gender (`.appearance.gender`) - - Height (`.appearance.height`) - - Weight (`.appearance.weight`) - - Place Of Birth (`.biography.placeOfBirth`) - - Alignement (`.biography.alignment`) + +- Icon (`.images.xs`, should be displayed as images and not as a string) +- Name (`.name`) +- Full Name (`.biography.fullName`) +- Powerstats (each entry of `.powerstats`) +- Race (`.appearance.race`) +- Gender (`.appearance.gender`) +- Height (`.appearance.height`) +- Weight (`.appearance.weight`) +- Place Of Birth (`.biography.placeOfBirth`) +- Alignement (`.biography.alignment`) The information must be displayed in multiple pages. \ A `` input is used to chose from `10`, `20`,`50`, `100` or `all results` It must be possible to filter information by searching the name as a string *(ex: superheroes that contain **man** in their name).* - - The search should be interactive, in other words, the results should be +- The search should be interactive, in other words, the results should be displaying as you write, not needing a button for you to click. - #### Sort It must be possible to sort by any columns of the table *(either alphabetically or numerically).* - - Initially all rows should be sorted by the column `name` by `ascending` order - - First click will order the column by `ascending` value - - Consecutive clicks will toggle between `ascending` and `descending` order - - Note that, for example, the column `weight` will be composed of strings, so + +- Initially all rows should be sorted by the column `name` by `ascending` order +- First click will order the column by `ascending` value +- Consecutive clicks will toggle between `ascending` and `descending` order +- Note that, for example, the column `weight` will be composed of strings, so the correct order would be `['78 kg', '100 kg']` instead of the other way around - - Missing values should always be sorted last. +- Missing values should always be sorted last. > As you know, when you are against heroes, **speed** is critical, every operations on > the database should be very fast and not slow down the browser - ### Optional Any additional features will be critical to your success, everything count: diff --git a/subjects/sortable1/audit/README.md b/subjects/sortable1/audit/README.md new file mode 100644 index 000000000..d162d5ce3 --- /dev/null +++ b/subjects/sortable1/audit/README.md @@ -0,0 +1,5 @@ +#### Functionals + +#### Generals + +#### Bonus From 2c3617b6ffb56cc35ee9eff427dca3ce83274c2a Mon Sep 17 00:00:00 2001 From: lee Date: Thu, 30 Jul 2020 12:28:17 +0100 Subject: [PATCH 3/8] clonernews1 --- subjects/clonernews1/README.md | 4 +++ subjects/clonernews1/audit/README.md | 39 ++++++++++++++++++++++++++++ 2 files changed, 43 insertions(+) diff --git a/subjects/clonernews1/README.md b/subjects/clonernews1/README.md index 3df52b293..5cf40714d 100644 --- a/subjects/clonernews1/README.md +++ b/subjects/clonernews1/README.md @@ -16,6 +16,10 @@ You must handle at least: - [polls](https://github.com/HackerNews/API#items) - [comments](https://github.com/HackerNews/API#items), each comment must have the proper post parent. +Post and comments must be ordered by newest post to oldest. +You must not load all posts at once. You must be able to load posts when ever the users need to see more posts. This can be done with the help of [event](https://developer.mozilla.org/en-US/docs/Web/Events). + + [Live Data](https://github.com/HackerNews/API#live-data) : is one of the features from this Hacker News API, you can handle requests so that the news you provide are updated. - You must have a section that present the newest information. You will have to notify the user at least every 5 seconds, whenever the live data is updated. In other words, after every 5 seconds if a change was made in the live data, you have to notify the user. diff --git a/subjects/clonernews1/audit/README.md b/subjects/clonernews1/audit/README.md index e69de29bb..182805e57 100644 --- a/subjects/clonernews1/audit/README.md +++ b/subjects/clonernews1/audit/README.md @@ -0,0 +1,39 @@ +#### Functionals + +##### Try to open a story post + +###### Does this post open without problems? + +##### Try to open a job post + +###### Does this post open without problems? + +##### Try to open a poll post + +###### Does this post open without problems? + +##### Try to load more posts + +###### Did the posts loaded without error or without spamming the user? + +##### Try to open a post with comments + +###### Are the comments being displayed in the correct order (from newest to oldest)? + +#### General + +###### Does the UI have at least stories, jobs and polls? + +###### Are the posts displayed in the correct order(from newest to oldest)? + +###### Does each comment present the right parent post? + +###### Is the UI notifying the user that there is a new update on a certain post? + +###### Is the project using Throttle to regulate the amount of request (every 5 seconds)? + +#### Bonus + +###### +Does the UI have more types of posts than stories, jobs and polls? + +###### +Are there sub-comments(nested comments) on the UI? From 9b540fd0eff9fcc3797fd84dd0e1d6abf52e9a19 Mon Sep 17 00:00:00 2001 From: lee Date: Wed, 5 Aug 2020 16:48:59 +0100 Subject: [PATCH 4/8] adding: raids 1 --- subjects/raid1a/README.md | 102 ++++++++++++++++++++++++++++++++++++++ subjects/raid1b/README.md | 102 ++++++++++++++++++++++++++++++++++++++ subjects/raid1c/README.md | 102 ++++++++++++++++++++++++++++++++++++++ subjects/raid1d/README.md | 102 ++++++++++++++++++++++++++++++++++++++ subjects/raid1e/README.md | 102 ++++++++++++++++++++++++++++++++++++++ 5 files changed, 510 insertions(+) create mode 100644 subjects/raid1a/README.md create mode 100644 subjects/raid1b/README.md create mode 100644 subjects/raid1c/README.md create mode 100644 subjects/raid1d/README.md create mode 100644 subjects/raid1e/README.md diff --git a/subjects/raid1a/README.md b/subjects/raid1a/README.md new file mode 100644 index 000000000..9a4d0d9e9 --- /dev/null +++ b/subjects/raid1a/README.md @@ -0,0 +1,102 @@ +## raid1a + +### Instructions + +Write a function `Raid1a` that prints a **valid** rectangle of width `x` and of height `y`. + +The function must draw the rectangles as in the examples. + +`x` and `y` will always be positive numbers. Otherwise, the function should print nothing. + +### Expected function + +```go +func Raid1a(x,y int) { +} +``` + +### Usage + +Here is are possible programs to test your function : + +Program #1 + +```go +package main +import piscine ".." +func main() { + piscine.Raid1a(5,3) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +o---o +| | +o---o +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #2 + +```go +package main +import piscine ".." +func main() { + piscine.Raid1a(5,1) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +o---o +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #3 + +```go +package main +import piscine ".." +func main() { + piscine.Raid1a(1,1) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +o +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #4 + +```go +package main +import piscine ".." +func main() { + piscine.Raid1a(1,5) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +o +| +| +| +o +student@ubuntu:~/[[ROOT]]/test$ +``` diff --git a/subjects/raid1b/README.md b/subjects/raid1b/README.md new file mode 100644 index 000000000..497aa2faa --- /dev/null +++ b/subjects/raid1b/README.md @@ -0,0 +1,102 @@ +## raid1b + +### Instructions + +Write a function `Raid1b` that prints a **valid** rectangle of width `x` and of height `y`. + +The function must draw the rectangles as in the examples. + +`x` and `y` will always be positive numbers. Otherwise, the function should print nothing. + +### Expected function + +```go +func Raid1b(x,y int) { +} +``` + +### Usage + +Here is are possible programs to test your function : + +Program #1 + +```go +package main +import piscine ".." +func main() { + piscine.Raid1b(5,3) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +/***\ +* * +\***/ +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #2 + +```go +package main +import piscine ".." +func main() { + piscine.Raid1b(5,1) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +/***\ +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #3 + +```go +package main +import piscine ".." +func main() { + piscine.Raid1b(1,1) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +/ +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #4 + +```go +package main +import piscine ".." +func main() { + piscine.Raid1b(1,5) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +/ +* +* +* +\ +student@ubuntu:~/[[ROOT]]/test$ +``` diff --git a/subjects/raid1c/README.md b/subjects/raid1c/README.md new file mode 100644 index 000000000..dc4cc3f28 --- /dev/null +++ b/subjects/raid1c/README.md @@ -0,0 +1,102 @@ +## raid1c + +### Instructions + +Write a function `Raid1c` that prints a **valid** rectangle of width `x` and of height `y`. + +The function must draw the rectangles as in the examples. + +`x` and `y` will always be positive numbers. Otherwise, the function should print nothing. + +### Expected function + +```go +func Raid1c(x,y int) { +} +``` + +### Usage + +Here is are possible programs to test your function : + +Program #1 + +```go +package main +import piscine ".." +func main() { + piscine.Raid1c(5,3) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +ABBBA +B B +CBBBC +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #2 + +```go +package main +import piscine ".." +func main() { + piscine.Raid1c(5,1) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +ABBBA +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #3 + +```go +package main +import piscine ".." +func main() { + piscine.Raid1c(1,1) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +A +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #4 + +```go +package main +import piscine ".." +func main() { + piscine.Raid1c(1,5) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +A +B +B +B +C +student@ubuntu:~/[[ROOT]]/test$ +``` diff --git a/subjects/raid1d/README.md b/subjects/raid1d/README.md new file mode 100644 index 000000000..8a18b472c --- /dev/null +++ b/subjects/raid1d/README.md @@ -0,0 +1,102 @@ +## raid1d + +### Instructions + +Write a function `Raid1d` that prints a **valid** rectangle of width `x` and of height `y`. + +The function must draw the rectangles as in the examples. + +`x` and `y` will always be positive numbers. Otherwise, the function should print nothing. + +### Expected function + +```go +func Raid1d(x,y int) { +} +``` + +### Usage + +Here is are possible programs to test your function : + +Program #1 + +```go +package main +import piscine ".." +func main() { + piscine.Raid1d(5,3) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +ABBBC +B B +ABBBC +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #2 + +```go +package main +import piscine ".." +func main() { + piscine.Raid1d(5,1) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +ABBBC +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #3 + +```go +package main +import piscine ".." +func main() { + piscine.Raid1d(1,1) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +A +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #4 + +```go +package main +import piscine ".." +func main() { + piscine.Raid1d(1,5) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +A +B +B +B +A +student@ubuntu:~/[[ROOT]]/test$ +``` diff --git a/subjects/raid1e/README.md b/subjects/raid1e/README.md new file mode 100644 index 000000000..62d6ca743 --- /dev/null +++ b/subjects/raid1e/README.md @@ -0,0 +1,102 @@ +## raid1e + +### Instructions + +Write a function `Raid1e` that prints a **valid** rectangle of width `x` and of height `y`. + +The function must draw the rectangles as in the examples. + +`x` and `y` will always be positive numbers. Otherwise, the function should print nothing. + +### Expected function + +```go +func Raid1e(x,y int) { +} +``` + +### Usage + +Here is are possible programs to test your function : + +Program #1 + +```go +package main +import piscine ".." +func main() { + piscine.Raid1e(5,3) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +ABBBC +B B +CBBBA +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #2 + +```go +package main +import piscine ".." +func main() { + piscine.Raid1e(5,1) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +ABBBC +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #3 + +```go +package main +import piscine ".." +func main() { + piscine.Raid1e(1,1) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +A +student@ubuntu:~/[[ROOT]]/test$ +``` + +Program #4 + +```go +package main +import piscine ".." +func main() { + piscine.Raid1e(1,5) +} +``` + +And its output : + +```console +student@ubuntu:~/[[ROOT]]/test$ go build +student@ubuntu:~/[[ROOT]]/test$ ./test +A +B +B +B +C +student@ubuntu:~/[[ROOT]]/test$ +``` From 19b5d2a260984f890474225b322afa9486fbc53c Mon Sep 17 00:00:00 2001 From: lee Date: Thu, 6 Aug 2020 09:52:09 +0100 Subject: [PATCH 5/8] renaming raids and undoing deletion of raid1* --- .../func/{raid1a_test => quada_test}/main.go | 4 +- .../func/{raid1b_test => quadb_test}/main.go | 12 +-- .../func/{raid1c_test => quadc_test}/main.go | 12 +-- .../func/{raid1d_test => quadd_test}/main.go | 12 +-- .../func/{raid1e_test => quade_test}/main.go | 12 +-- .../prog/{raid2_prog => sudoku_prog}/main.go | 0 .../prog/{raid2_test => sudoku_test}/main.go | 8 +- subjects/{raid1 => quad}/README.md | 72 +++++++++--------- subjects/{raid1 => quad}/audit/README.md | 12 ++- subjects/{raid1a => quada}/README.md | 23 ++++-- subjects/{raid1b => quadb}/README.md | 23 ++++-- subjects/{raid1c => quadc}/README.md | 23 ++++-- subjects/{raid1d => quadd}/README.md | 23 ++++-- subjects/{raid1e => quade}/README.md | 23 ++++-- subjects/quadverifier/README.md | 62 ++++++++++++++++ subjects/quadverifier/audit/README.md | 73 +++++++++++++++++++ subjects/raid2/README.md | 42 ----------- subjects/raid3/README.md | 62 ---------------- subjects/raid3/audit/README.md | 73 ------------------- subjects/sudoku/README.md | 42 +++++++++++ subjects/{raid2 => sudoku}/audit/README.md | 2 +- 21 files changed, 329 insertions(+), 286 deletions(-) rename go/tests/func/{raid1a_test => quada_test}/main.go (91%) rename go/tests/func/{raid1b_test => quadb_test}/main.go (78%) rename go/tests/func/{raid1c_test => quadc_test}/main.go (78%) rename go/tests/func/{raid1d_test => quadd_test}/main.go (78%) rename go/tests/func/{raid1e_test => quade_test}/main.go (78%) rename go/tests/prog/{raid2_prog => sudoku_prog}/main.go (100%) rename go/tests/prog/{raid2_test => sudoku_test}/main.go (96%) rename subjects/{raid1 => quad}/README.md (84%) rename subjects/{raid1 => quad}/audit/README.md (99%) rename subjects/{raid1a => quada}/README.md (84%) rename subjects/{raid1b => quadb}/README.md (84%) rename subjects/{raid1c => quadc}/README.md (84%) rename subjects/{raid1d => quadd}/README.md (84%) rename subjects/{raid1e => quade}/README.md (84%) create mode 100644 subjects/quadverifier/README.md create mode 100644 subjects/quadverifier/audit/README.md delete mode 100644 subjects/raid2/README.md delete mode 100644 subjects/raid3/README.md delete mode 100644 subjects/raid3/audit/README.md create mode 100644 subjects/sudoku/README.md rename subjects/{raid2 => sudoku}/audit/README.md (99%) diff --git a/go/tests/func/raid1a_test/main.go b/go/tests/func/quada_test/main.go similarity index 91% rename from go/tests/func/raid1a_test/main.go rename to go/tests/func/quada_test/main.go index 7c2f220fb..a1f12efaf 100644 --- a/go/tests/func/raid1a_test/main.go +++ b/go/tests/func/quada_test/main.go @@ -40,7 +40,7 @@ func printTheLines(x, y int, strBeg, strMed, strEnd string) { } } -func raid1a(x, y int) { +func quadA(x, y int) { if x < 1 || y < 1 { return } @@ -67,7 +67,7 @@ func main() { // Tests all possibilities including 0 0, -x y, x -y for i := 0; i < len(table); i += 2 { if i != len(table)-1 { - lib.Challenge("Raid1a", raid1a, student.Raid1a, table[i], table[i+1]) + lib.Challenge("QuadA", quadA, student.QuadA, table[i], table[i+1]) } } } diff --git a/go/tests/func/raid1b_test/main.go b/go/tests/func/quadb_test/main.go similarity index 78% rename from go/tests/func/raid1b_test/main.go rename to go/tests/func/quadb_test/main.go index 966ed6b6d..658d51e83 100644 --- a/go/tests/func/raid1b_test/main.go +++ b/go/tests/func/quadb_test/main.go @@ -8,7 +8,7 @@ import ( "lib" ) -func drawLineRaid1b(x int, s string) { +func drawLineQuadB(x int, s string) { beg := s[0] med := s[1] end := s[2] @@ -26,7 +26,7 @@ func drawLineRaid1b(x int, s string) { fmt.Println() } -func raid1b(x, y int) { +func quadB(x, y int) { if x < 1 || y < 1 { return } @@ -35,15 +35,15 @@ func raid1b(x, y int) { strEnd := "\\*/" if y >= 1 { - drawLineRaid1b(x, strBeg) + drawLineQuadB(x, strBeg) } if y > 2 { for i := 0; i < y-2; i++ { - drawLineRaid1b(x, strMed) + drawLineQuadB(x, strMed) } } if y > 1 { - drawLineRaid1b(x, strEnd) + drawLineQuadB(x, strEnd) } } @@ -67,7 +67,7 @@ func main() { // Tests all possibilities including 0 0, -x y, x -y for i := 0; i < len(table); i += 2 { if i != len(table)-1 { - lib.Challenge("Raid1b", raid1b, student.Raid1b, table[i], table[i+1]) + lib.Challenge("QuadB", quadB, student.QuadB, table[i], table[i+1]) } } } diff --git a/go/tests/func/raid1c_test/main.go b/go/tests/func/quadc_test/main.go similarity index 78% rename from go/tests/func/raid1c_test/main.go rename to go/tests/func/quadc_test/main.go index 7e948335a..b512b50b8 100644 --- a/go/tests/func/raid1c_test/main.go +++ b/go/tests/func/quadc_test/main.go @@ -8,7 +8,7 @@ import ( "lib" ) -func drawLineRaid1c(x int, s string) { +func drawLineQuadC(x int, s string) { beg := s[0] med := s[1] end := s[2] @@ -26,7 +26,7 @@ func drawLineRaid1c(x int, s string) { fmt.Println() } -func raid1c(x, y int) { +func quadC(x, y int) { if x < 1 || y < 1 { return } @@ -35,15 +35,15 @@ func raid1c(x, y int) { strEnd := "CBC" if y >= 1 { - drawLineRaid1c(x, strBeg) + drawLineQuadC(x, strBeg) } if y > 2 { for i := 0; i < y-2; i++ { - drawLineRaid1c(x, strMed) + drawLineQuadC(x, strMed) } } if y > 1 { - drawLineRaid1c(x, strEnd) + drawLineQuadC(x, strEnd) } } @@ -67,7 +67,7 @@ func main() { // Tests all possibilities including 0 0, -x y, x -y for i := 0; i < len(table); i += 2 { if i != len(table)-1 { - lib.Challenge("Raid1c", raid1c, student.Raid1c, table[i], table[i+1]) + lib.Challenge("QuadC", quadC, student.QuadC, table[i], table[i+1]) } } } diff --git a/go/tests/func/raid1d_test/main.go b/go/tests/func/quadd_test/main.go similarity index 78% rename from go/tests/func/raid1d_test/main.go rename to go/tests/func/quadd_test/main.go index 589ba7c38..f7ef33e04 100644 --- a/go/tests/func/raid1d_test/main.go +++ b/go/tests/func/quadd_test/main.go @@ -8,7 +8,7 @@ import ( "lib" ) -func drawLineRaid1d(x int, s string) { +func drawLineQuadD(x int, s string) { beg := s[0] med := s[1] end := s[2] @@ -26,7 +26,7 @@ func drawLineRaid1d(x int, s string) { fmt.Println() } -func raid1d(x, y int) { +func quadD(x, y int) { if x < 1 || y < 1 { return } @@ -35,15 +35,15 @@ func raid1d(x, y int) { strEnd := "ABC" if y >= 1 { - drawLineRaid1d(x, strBeg) + drawLineQuadD(x, strBeg) } if y > 2 { for i := 0; i < y-2; i++ { - drawLineRaid1d(x, strMed) + drawLineQuadD(x, strMed) } } if y > 1 { - drawLineRaid1d(x, strEnd) + drawLineQuadD(x, strEnd) } } @@ -67,7 +67,7 @@ func main() { // Tests all possibilities including 0 0, -x y, x -y for i := 0; i < len(table); i += 2 { if i != len(table)-1 { - lib.Challenge("Raid1d", raid1d, student.Raid1d, table[i], table[i+1]) + lib.Challenge("QuadD", quadD, student.QuadD, table[i], table[i+1]) } } } diff --git a/go/tests/func/raid1e_test/main.go b/go/tests/func/quade_test/main.go similarity index 78% rename from go/tests/func/raid1e_test/main.go rename to go/tests/func/quade_test/main.go index 5c80c3f38..90332f2a4 100644 --- a/go/tests/func/raid1e_test/main.go +++ b/go/tests/func/quade_test/main.go @@ -8,7 +8,7 @@ import ( "lib" ) -func drawLineRaid1e(x int, s string) { +func drawLineQuadE(x int, s string) { beg := s[0] med := s[1] end := s[2] @@ -26,7 +26,7 @@ func drawLineRaid1e(x int, s string) { fmt.Println() } -func raid1e(x, y int) { +func quadE(x, y int) { if x < 1 || y < 1 { return } @@ -35,15 +35,15 @@ func raid1e(x, y int) { strEnd := "CBA" if y >= 1 { - drawLineRaid1e(x, strBeg) + drawLineQuadE(x, strBeg) } if y > 2 { for i := 0; i < y-2; i++ { - drawLineRaid1e(x, strMed) + drawLineQuadE(x, strMed) } } if y > 1 { - drawLineRaid1e(x, strEnd) + drawLineQuadE(x, strEnd) } } @@ -67,7 +67,7 @@ func main() { // Tests all possibilities including 0 0, -x y, x -y for i := 0; i < len(table); i += 2 { if i != len(table)-1 { - lib.Challenge("Raid1e", raid1e, student.Raid1e, table[i], table[i+1]) + lib.Challenge("QuadE", quadE, student.QuadE, table[i], table[i+1]) } } } diff --git a/go/tests/prog/raid2_prog/main.go b/go/tests/prog/sudoku_prog/main.go similarity index 100% rename from go/tests/prog/raid2_prog/main.go rename to go/tests/prog/sudoku_prog/main.go diff --git a/go/tests/prog/raid2_test/main.go b/go/tests/prog/sudoku_test/main.go similarity index 96% rename from go/tests/prog/raid2_test/main.go rename to go/tests/prog/sudoku_test/main.go index cbcde7d65..73686fa4a 100644 --- a/go/tests/prog/raid2_test/main.go +++ b/go/tests/prog/sudoku_test/main.go @@ -286,13 +286,13 @@ func main() { } for _, v := range valid { - lib.ChallengeMain("raid2", v...) + lib.ChallengeMain("sudoku", v...) } for _, v := range invalid { - lib.ChallengeMain("raid2", v...) + lib.ChallengeMain("sudoku", v...) } - lib.ChallengeMain("raid2") - lib.ChallengeMain("raid2", "not", "a", "sudoku") + lib.ChallengeMain("sudoku") + lib.ChallengeMain("sudoku", "not", "a", "sudoku") } diff --git a/subjects/raid1/README.md b/subjects/quad/README.md similarity index 84% rename from subjects/raid1/README.md rename to subjects/quad/README.md index f0e04eb30..3658e078f 100644 --- a/subjects/raid1/README.md +++ b/subjects/quad/README.md @@ -1,10 +1,10 @@ -# raid1 +# quadrangle -## raid1a +## quadA ### Instructions -Write a function `Raid1a` that prints a **valid** rectangle of width `x` and of height `y`. +Write a function `QuadA` that prints a **valid** rectangle of width `x` and of height `y`. The function must draw the rectangles as in the examples. @@ -13,7 +13,7 @@ The function must draw the rectangles as in the examples. ### Expected function ```go -func Raid1a(x,y int) { +func QuadA(x,y int) { } ``` @@ -30,7 +30,7 @@ package main import piscine ".." func main() { - piscine.Raid1a(5,3) + piscine.QuadA(5,3) } ``` @@ -53,7 +53,7 @@ package main import piscine ".." func main() { - piscine.Raid1a(5,1) + piscine.QuadA(5,1) } ``` @@ -74,7 +74,7 @@ package main import piscine ".." func main() { - piscine.Raid1a(1,1) + piscine.QuadA(1,1) } ``` @@ -95,7 +95,7 @@ package main import piscine ".." func main() { - piscine.Raid1a(1,5) + piscine.QuadA(1,5) } ``` @@ -114,11 +114,11 @@ student@ubuntu:~/[[ROOT]]/test$ ---- -## raid1b +## quadB ### Instructions -Write a function `Raid1b` that prints a **valid** rectangle of width `x` and of height `y`. +Write a function `QuadB` that prints a **valid** rectangle of width `x` and of height `y`. The function must draw the rectangles as in the examples. @@ -127,7 +127,7 @@ The function must draw the rectangles as in the examples. ### Expected function ```go -func Raid1b(x,y int) { +func QuadB(x,y int) { } ``` @@ -144,7 +144,7 @@ package main import piscine ".." func main() { - piscine.Raid1b(5,3) + piscine.QuadB(5,3) } ``` @@ -167,7 +167,7 @@ package main import piscine ".." func main() { - piscine.Raid1b(5,1) + piscine.QuadB(5,1) } ``` @@ -188,7 +188,7 @@ package main import piscine ".." func main() { - piscine.Raid1b(1,1) + piscine.QuadB(1,1) } ``` @@ -209,7 +209,7 @@ package main import piscine ".." func main() { - piscine.Raid1b(1,5) + piscine.QuadB(1,5) } ``` @@ -228,11 +228,11 @@ student@ubuntu:~/[[ROOT]]/test$ ---- -## raid1c +## quadC ### Instructions -Write a function `Raid1c` that prints a **valid** rectangle of width `x` and of height `y`. +Write a function `QuadC` that prints a **valid** rectangle of width `x` and of height `y`. The function must draw the rectangles as in the examples. @@ -241,7 +241,7 @@ The function must draw the rectangles as in the examples. ### Expected function ```go -func Raid1c(x,y int) { +func QuadC(x,y int) { } ``` @@ -258,7 +258,7 @@ package main import piscine ".." func main() { - piscine.Raid1c(5,3) + piscine.QuadC(5,3) } ``` @@ -281,7 +281,7 @@ package main import piscine ".." func main() { - piscine.Raid1c(5,1) + piscine.QuadC(5,1) } ``` @@ -302,7 +302,7 @@ package main import piscine ".." func main() { - piscine.Raid1c(1,1) + piscine.QuadC(1,1) } ``` @@ -323,7 +323,7 @@ package main import piscine ".." func main() { - piscine.Raid1c(1,5) + piscine.QuadC(1,5) } ``` @@ -342,11 +342,11 @@ student@ubuntu:~/[[ROOT]]/test$ ---- -## raid1d +## quadD ### Instructions -Write a function `Raid1d` that prints a **valid** rectangle of width `x` and of height `y`. +Write a function `QuadD` that prints a **valid** rectangle of width `x` and of height `y`. The function must draw the rectangles as in the examples. @@ -355,7 +355,7 @@ The function must draw the rectangles as in the examples. ### Expected function ```go -func Raid1d(x,y int) { +func QuadD(x,y int) { } ``` @@ -372,7 +372,7 @@ package main import piscine ".." func main() { - piscine.Raid1d(5,3) + piscine.QuadD(5,3) } ``` @@ -395,7 +395,7 @@ package main import piscine ".." func main() { - piscine.Raid1d(5,1) + piscine.QuadD(5,1) } ``` @@ -416,7 +416,7 @@ package main import piscine ".." func main() { - piscine.Raid1d(1,1) + piscine.QuadD(1,1) } ``` @@ -437,7 +437,7 @@ package main import piscine ".." func main() { - piscine.Raid1d(1,5) + piscine.QuadD(1,5) } ``` @@ -456,11 +456,11 @@ student@ubuntu:~/[[ROOT]]/test$ ---- -## raid1e +## quadE ### Instructions -Write a function `Raid1e` that prints a **valid** rectangle of width `x` and of height `y`. +Write a function `QuadE` that prints a **valid** rectangle of width `x` and of height `y`. The function must draw the rectangles as in the examples. @@ -469,7 +469,7 @@ The function must draw the rectangles as in the examples. ### Expected function ```go -func Raid1e(x,y int) { +func QuadE(x,y int) { } ``` @@ -486,7 +486,7 @@ package main import piscine ".." func main() { - piscine.Raid1e(5,3) + piscine.QuadE(5,3) } ``` @@ -509,7 +509,7 @@ package main import piscine ".." func main() { - piscine.Raid1e(5,1) + piscine.QuadE(5,1) } ``` @@ -530,7 +530,7 @@ package main import piscine ".." func main() { - piscine.Raid1e(1,1) + piscine.QuadE(1,1) } ``` @@ -551,7 +551,7 @@ package main import piscine ".." func main() { - piscine.Raid1e(1,5) + piscine.QuadE(1,5) } ``` diff --git a/subjects/raid1/audit/README.md b/subjects/quad/audit/README.md similarity index 99% rename from subjects/raid1/audit/README.md rename to subjects/quad/audit/README.md index 86718583c..0faf4a48b 100644 --- a/subjects/raid1/audit/README.md +++ b/subjects/quad/audit/README.md @@ -1,4 +1,4 @@ -#### raid1a +#### quadA ##### Try running the function with the arguments: `"x=5 and y=3"` @@ -58,7 +58,6 @@ o------------------o ###### Does the function returns the value above? - ##### Try running the function with the arguments: `"x=10 and y=8"` ``` @@ -74,7 +73,7 @@ o--------o ###### Does the function returns the value above? -#### raid1b +#### quadC ##### Try running the function with the arguments: `"x=5 and y=3"` @@ -94,7 +93,6 @@ o--------o ###### Does the function returns the value above? - ##### Try running the function with the arguments: `"x=1 and y=1"` ``` @@ -150,7 +148,7 @@ o--------o ###### Does the function returns the value above? -#### raid1c +#### quadC ##### Try running the function with the arguments: `"x=5 and y=3"` @@ -238,7 +236,7 @@ CBBBBBBBBC ###### Does the function returns the value above? -#### raid1d +#### quadD ##### Try running the function with the arguments: `"x=5 and y=3"` @@ -336,7 +334,7 @@ ABBBBBC ###### Does the function returns the value above? -#### raid1e +#### quadE ##### Try running the function with the arguments: `"x=5 and y=3"` diff --git a/subjects/raid1a/README.md b/subjects/quada/README.md similarity index 84% rename from subjects/raid1a/README.md rename to subjects/quada/README.md index 9a4d0d9e9..2a9f30392 100644 --- a/subjects/raid1a/README.md +++ b/subjects/quada/README.md @@ -1,8 +1,8 @@ -## raid1a +## quadrangle ### Instructions -Write a function `Raid1a` that prints a **valid** rectangle of width `x` and of height `y`. +Write a function `QuadA` that prints a **valid** rectangle of width `x` and of height `y`. The function must draw the rectangles as in the examples. @@ -11,7 +11,8 @@ The function must draw the rectangles as in the examples. ### Expected function ```go -func Raid1a(x,y int) { +func QuadA(x,y int) { + } ``` @@ -23,9 +24,11 @@ Program #1 ```go package main + import piscine ".." + func main() { - piscine.Raid1a(5,3) + piscine.QuadA(5,3) } ``` @@ -44,9 +47,11 @@ Program #2 ```go package main + import piscine ".." + func main() { - piscine.Raid1a(5,1) + piscine.QuadA(5,1) } ``` @@ -63,9 +68,11 @@ Program #3 ```go package main + import piscine ".." + func main() { - piscine.Raid1a(1,1) + piscine.QuadA(1,1) } ``` @@ -82,9 +89,11 @@ Program #4 ```go package main + import piscine ".." + func main() { - piscine.Raid1a(1,5) + piscine.QuadA(1,5) } ``` diff --git a/subjects/raid1b/README.md b/subjects/quadb/README.md similarity index 84% rename from subjects/raid1b/README.md rename to subjects/quadb/README.md index 497aa2faa..573a61c98 100644 --- a/subjects/raid1b/README.md +++ b/subjects/quadb/README.md @@ -1,8 +1,8 @@ -## raid1b +## quadrangle ### Instructions -Write a function `Raid1b` that prints a **valid** rectangle of width `x` and of height `y`. +Write a function `QuadB` that prints a **valid** rectangle of width `x` and of height `y`. The function must draw the rectangles as in the examples. @@ -11,7 +11,8 @@ The function must draw the rectangles as in the examples. ### Expected function ```go -func Raid1b(x,y int) { +func QuadB(x,y int) { + } ``` @@ -23,9 +24,11 @@ Program #1 ```go package main + import piscine ".." + func main() { - piscine.Raid1b(5,3) + piscine.QuadB(5,3) } ``` @@ -44,9 +47,11 @@ Program #2 ```go package main + import piscine ".." + func main() { - piscine.Raid1b(5,1) + piscine.QuadB(5,1) } ``` @@ -63,9 +68,11 @@ Program #3 ```go package main + import piscine ".." + func main() { - piscine.Raid1b(1,1) + piscine.QuadB(1,1) } ``` @@ -82,9 +89,11 @@ Program #4 ```go package main + import piscine ".." + func main() { - piscine.Raid1b(1,5) + piscine.QuadB(1,5) } ``` diff --git a/subjects/raid1c/README.md b/subjects/quadc/README.md similarity index 84% rename from subjects/raid1c/README.md rename to subjects/quadc/README.md index dc4cc3f28..0bdbad69c 100644 --- a/subjects/raid1c/README.md +++ b/subjects/quadc/README.md @@ -1,8 +1,8 @@ -## raid1c +## quadrangle ### Instructions -Write a function `Raid1c` that prints a **valid** rectangle of width `x` and of height `y`. +Write a function `QuadC` that prints a **valid** rectangle of width `x` and of height `y`. The function must draw the rectangles as in the examples. @@ -11,7 +11,8 @@ The function must draw the rectangles as in the examples. ### Expected function ```go -func Raid1c(x,y int) { +func QuadC(x,y int) { + } ``` @@ -23,9 +24,11 @@ Program #1 ```go package main + import piscine ".." + func main() { - piscine.Raid1c(5,3) + piscine.QuadC(5,3) } ``` @@ -44,9 +47,11 @@ Program #2 ```go package main + import piscine ".." + func main() { - piscine.Raid1c(5,1) + piscine.QuadC(5,1) } ``` @@ -63,9 +68,11 @@ Program #3 ```go package main + import piscine ".." + func main() { - piscine.Raid1c(1,1) + piscine.QuadC(1,1) } ``` @@ -82,9 +89,11 @@ Program #4 ```go package main + import piscine ".." + func main() { - piscine.Raid1c(1,5) + piscine.QuadC(1,5) } ``` diff --git a/subjects/raid1d/README.md b/subjects/quadd/README.md similarity index 84% rename from subjects/raid1d/README.md rename to subjects/quadd/README.md index 8a18b472c..8e709ed62 100644 --- a/subjects/raid1d/README.md +++ b/subjects/quadd/README.md @@ -1,8 +1,8 @@ -## raid1d +## quadrangle ### Instructions -Write a function `Raid1d` that prints a **valid** rectangle of width `x` and of height `y`. +Write a function `QuadD` that prints a **valid** rectangle of width `x` and of height `y`. The function must draw the rectangles as in the examples. @@ -11,7 +11,8 @@ The function must draw the rectangles as in the examples. ### Expected function ```go -func Raid1d(x,y int) { +func QuadD(x,y int) { + } ``` @@ -23,9 +24,11 @@ Program #1 ```go package main + import piscine ".." + func main() { - piscine.Raid1d(5,3) + piscine.QuadD(5,3) } ``` @@ -44,9 +47,11 @@ Program #2 ```go package main + import piscine ".." + func main() { - piscine.Raid1d(5,1) + piscine.QuadD(5,1) } ``` @@ -63,9 +68,11 @@ Program #3 ```go package main + import piscine ".." + func main() { - piscine.Raid1d(1,1) + piscine.QuadD(1,1) } ``` @@ -82,9 +89,11 @@ Program #4 ```go package main + import piscine ".." + func main() { - piscine.Raid1d(1,5) + piscine.QuadD(1,5) } ``` diff --git a/subjects/raid1e/README.md b/subjects/quade/README.md similarity index 84% rename from subjects/raid1e/README.md rename to subjects/quade/README.md index 62d6ca743..13b380b9c 100644 --- a/subjects/raid1e/README.md +++ b/subjects/quade/README.md @@ -1,8 +1,8 @@ -## raid1e +## quadrangle ### Instructions -Write a function `Raid1e` that prints a **valid** rectangle of width `x` and of height `y`. +Write a function `QuadE` that prints a **valid** rectangle of width `x` and of height `y`. The function must draw the rectangles as in the examples. @@ -11,7 +11,8 @@ The function must draw the rectangles as in the examples. ### Expected function ```go -func Raid1e(x,y int) { +func QuadE(x,y int) { + } ``` @@ -23,9 +24,11 @@ Program #1 ```go package main + import piscine ".." + func main() { - piscine.Raid1e(5,3) + piscine.QuadE(5,3) } ``` @@ -44,9 +47,11 @@ Program #2 ```go package main + import piscine ".." + func main() { - piscine.Raid1e(5,1) + piscine.QuadE(5,1) } ``` @@ -63,9 +68,11 @@ Program #3 ```go package main + import piscine ".." + func main() { - piscine.Raid1e(1,1) + piscine.QuadE(1,1) } ``` @@ -82,9 +89,11 @@ Program #4 ```go package main + import piscine ".." + func main() { - piscine.Raid1e(1,5) + piscine.QuadE(1,5) } ``` diff --git a/subjects/quadverifier/README.md b/subjects/quadverifier/README.md new file mode 100644 index 000000000..77820e2f1 --- /dev/null +++ b/subjects/quadverifier/README.md @@ -0,0 +1,62 @@ +## quadverifier + +### Instructions + +This raid is based on the `quad` functions. + +Create a program `quadVerifier` that takes a `string` as an argument and displays the name of the matching `quad` and its dimensions. + +- If the argument is not a `raid` the program should print `Not a Raid function`. + +- All answers must end with a newline (`'\n'`). + +- If there is more than one `quad` matches, the program must display them all alphabetically ordered and separated by a `||`. + +### Usage + +- If it's `quadA` + +```console +student@ubuntu:~/[[ROOT]]/quadverifier$ ls -l +-rw-r--r-- 1 student student nov 23 14:30 main.go +-rwxr-xr-x 1 student student nov 23 19:18 quadVerifier +-rwxr-xr-x 1 student student nov 23 19:50 quadA +-rwxr-xr-x 1 student student nov 23 19:50 quadB +-rwxr-xr-x 1 student student nov 23 19:50 quadC +-rwxr-xr-x 1 student student nov 23 19:50 quadD +-rwxr-xr-x 1 student student nov 23 19:50 quadE +student@ubuntu:~/[[ROOT]]/quadverifier$ ./quadA 3 3 | ./quadVerifier +[quadA] [3] [3] +student@ubuntu:~/[[ROOT]]/quadverifier$ +student@ubuntu:~/[[ROOT]]/quadverifier$ +student@ubuntu:~/[[ROOT]]/quadverifier$ +student@ubuntu:~/[[ROOT]]/quadverifier$ +``` + +- If it's `quadC 1 1` : + +```console +student@ubuntu:~/[[ROOT]]/quadverifier$ ./quadC 1 1 +A +student@ubuntu:~/[[ROOT]]/quadverifier$ ./quadD 1 1 +A +student@ubuntu:~/[[ROOT]]/quadverifier$ ./quadE 1 1 +A +student@ubuntu:~/[[ROOT]]/quadverifier$ ./quadC 1 1 | ./quadVerifier +[quadC] [1] [1] || [quadD] [1] [1] || [quadE] [1] [1] +student@ubuntu:~/[[ROOT]]/quadverifier$ +``` + +- If it's `quadC 1 2` : + +```console +student@ubuntu:~/[[ROOT]]/quadverifier$ ./quadE 1 2 +A +C +student@ubuntu:~/[[ROOT]]/quadverifier$ ./quadC 1 2 +A +C +student@ubuntu:~/[[ROOT]]/quadverifier$ ./quadE 1 2 | ./quadVerifier +[quadC] [1] [2] || [quadE] [1] [2] +student@ubuntu:~/[[ROOT]]/quadverifier$ +``` diff --git a/subjects/quadverifier/audit/README.md b/subjects/quadverifier/audit/README.md new file mode 100644 index 000000000..fb555dc9b --- /dev/null +++ b/subjects/quadverifier/audit/README.md @@ -0,0 +1,73 @@ +#### Quadrangle verifier + +##### Try running the program: `"./quadA 3 3 | ./quadVerifier"` + +``` +[quadA] [3] [3] +``` + +###### Does the program returns the value above? + +##### Try running the program: `"./quadB 3 3 | ./quadVerifier"` + +``` +[quadB] [3] [3] +``` + +###### Does the program returns the value above? + +##### Try running the program: `"./quadC 1 1 | ./quadVerifier"` + +``` +[quadC] [1] [1] || [quadD] [1] [1] || [quadE] [1] [1] +``` + +###### Does the program returns the value above? + +##### Try running the program: `"./quadE 1 2 | ./quadVerifier"` + +``` +[quadC] [1] [2] || [quadE] [1] [2] +``` + +###### Does the program returns the value above? + +##### Try running the program: `"./quadE 2 1 | ./quadVerifier"` + +``` +[quadD] [2] [1] || [quadE] [2] [1] +``` + +###### Does the program returns the value above? + +##### Try running the program: `"./quadC 2 1 | ./quadVerifier"` + +``` +[quadC] [2] [1] +``` + +###### Does the program returns the value above? + +##### Try running the program: `"./quadD 1 2 | ./quadVerifier"` + +``` +[quadD] [1] [2] +``` + +###### Does the program returns the value above? + +##### Try running the program: `"./quadE 1 1 | ./quadVerifier"` + +``` +[quadC] [1] [1] || [quadD] [1] [1] || [quadE] [1] [1] +``` + +###### Does the program returns the value above? + +##### Try running the program: `"echo 0 0 | ./quadVerifier"` + +``` +Not a Raid function +``` + +###### Does the program returns the value above? diff --git a/subjects/raid2/README.md b/subjects/raid2/README.md deleted file mode 100644 index e22f7752e..000000000 --- a/subjects/raid2/README.md +++ /dev/null @@ -1,42 +0,0 @@ -## raid2 - -### Instructions - -- Create a program that resolves a sudoku. - -- A valid sudoku has only one possible solution. - -### Usage - -#### Example 1: - -Example of output for one valid sudoku : - -```console -student@ubuntu:~/[[ROOT]]/raid2$ go build -student@ubuntu:~/[[ROOT]]/raid2$ ./raid2 ".96.4...1" "1...6...4" "5.481.39." "..795..43" ".3..8...." "4.5.23.18" ".1.63..59" ".59.7.83." "..359...7" | cat -e -3 9 6 2 4 5 7 8 1$ -1 7 8 3 6 9 5 2 4$ -5 2 4 8 1 7 3 9 6$ -2 8 7 9 5 1 6 4 3$ -9 3 1 4 8 6 2 7 5$ -4 6 5 7 2 3 9 1 8$ -7 1 2 6 3 8 4 5 9$ -6 5 9 1 7 4 8 3 2$ -8 4 3 5 9 2 1 6 7$ -student@ubuntu:~/[[ROOT]]/raid2$ -``` - -#### Example 2: - -Examples of output for invalid input or sudokus : - -```console -student@ubuntu:~/[[ROOT]]/raid2$ ./raid2 1 2 3 4 | cat -e -Error$ -student@ubuntu:~/[[ROOT]]/raid2$ ./raid2 | cat -e -Error$ -student@ubuntu:~/[[ROOT]]/raid2$ ./raid2 ".96.4...1" "1...6.1.4" "5.481.39." "..795..43" ".3..8...." "4.5.23.18" ".1.63..59" ".59.7.83." "..359...7" | cat -e -Error$ -student@ubuntu:~/[[ROOT]]/raid2$ -``` diff --git a/subjects/raid3/README.md b/subjects/raid3/README.md deleted file mode 100644 index a2eea0cc2..000000000 --- a/subjects/raid3/README.md +++ /dev/null @@ -1,62 +0,0 @@ -## raid3 - -### Instructions - -This raid is based on the `raid1` functions. - -Create a program `raid3` that takes a `string` as an argument and displays the name of the matching `raid1` and its dimensions. - -- If the argument is not a `raid1` the program should print `Not a Raid function`. - -- All answers must end with a newline (`'\n'`). - -- If there is more than one `raid1` matches, the program must display them all alphabetically ordered and separated by a `||`. - -### Usage - -- If it's `raid1a` - -```console -student@ubuntu:~/[[ROOT]]/raid3$ ls -l --rw-r--r-- 1 student student nov 23 14:30 main.go --rwxr-xr-x 1 student student nov 23 19:18 raid3 --rwxr-xr-x 1 student student nov 23 19:50 raid1a --rwxr-xr-x 1 student student nov 23 19:50 raid1b --rwxr-xr-x 1 student student nov 23 19:50 raid1c --rwxr-xr-x 1 student student nov 23 19:50 raid1d --rwxr-xr-x 1 student student nov 23 19:50 raid1e -student@ubuntu:~/[[ROOT]]/raid3$ ./raid1a 3 3 | ./raid3 -[raid1a] [3] [3] -student@ubuntu:~/[[ROOT]]/raid3$ -student@ubuntu:~/[[ROOT]]/raid3$ -student@ubuntu:~/[[ROOT]]/raid3$ -student@ubuntu:~/[[ROOT]]/raid3$ -``` - -- If it's `raidc 1 1` : - -```console -student@ubuntu:~/[[ROOT]]/raid3$ ./raid1c 1 1 -A -student@ubuntu:~/[[ROOT]]/raid3$ ./raid1d 1 1 -A -student@ubuntu:~/[[ROOT]]/raid3$ ./raid1e 1 1 -A -student@ubuntu:~/[[ROOT]]/raid3$ ./raid1c 1 1 | ./raid3 -[raid1c] [1] [1] || [raid1d] [1] [1] || [raid1e] [1] [1] -student@ubuntu:~/[[ROOT]]/raid3$ -``` - -- If it's `raidc 1 2` : - -```console -student@ubuntu:~/[[ROOT]]/raid3$ ./raid1e 1 2 -A -C -student@ubuntu:~/[[ROOT]]/raid3$ ./raid1c 1 2 -A -C -student@ubuntu:~/[[ROOT]]/raid3$ ./raid1e 1 2 | ./raid3 -[raid1c] [1] [2] || [raid1e] [1] [2] -student@ubuntu:~/[[ROOT]]/raid3$ -``` diff --git a/subjects/raid3/audit/README.md b/subjects/raid3/audit/README.md deleted file mode 100644 index 97f6a9532..000000000 --- a/subjects/raid3/audit/README.md +++ /dev/null @@ -1,73 +0,0 @@ -#### Raid 3 - -##### Try running the program: `"./raid1a 3 3 | ./raid3"` - -``` -[raid1a] [3] [3] -``` - -###### Does the program returns the value above? - -##### Try running the program: `"./raid1b 3 3 | ./raid3"` - -``` -[raid1b] [3] [3] -``` - -###### Does the program returns the value above? - -##### Try running the program: `"./raid1c 1 1 | ./raid3"` - -``` -[raid1c] [1] [1] || [raid1d] [1] [1] || [raid1e] [1] [1] -``` - -###### Does the program returns the value above? - -##### Try running the program: `"./raid1e 1 2 | ./raid3"` - -``` -[raid1c] [1] [2] || [raid1e] [1] [2] -``` - -###### Does the program returns the value above? - -##### Try running the program: `"./raid1e 2 1 | ./raid3"` - -``` -[raid1d] [2] [1] || [raid1e] [2] [1] -``` - -###### Does the program returns the value above? - -##### Try running the program: `"./raid1c 2 1 | ./raid3"` - -``` -[raid1c] [2] [1] -``` - -###### Does the program returns the value above? - -##### Try running the program: `"./raid1d 1 2 | ./raid3"` - -``` -[raid1d] [1] [2] -``` - -###### Does the program returns the value above? - -##### Try running the program: `"./raid1e 1 1 | ./raid3"` - -``` -[raid1c] [1] [1] || [raid1d] [1] [1] || [raid1e] [1] [1] -``` - -###### Does the program returns the value above? - -##### Try running the program: `"echo 0 0 | ./raid3"` - -``` -Not a Raid function -``` - -###### Does the program returns the value above? diff --git a/subjects/sudoku/README.md b/subjects/sudoku/README.md new file mode 100644 index 000000000..d263c4948 --- /dev/null +++ b/subjects/sudoku/README.md @@ -0,0 +1,42 @@ +## sudoku + +### Instructions + +- Create a program that resolves a sudoku. + +- A valid sudoku has only one possible solution. + +### Usage + +#### Example 1: + +Example of output for one valid sudoku : + +```console +student@ubuntu:~/[[ROOT]]/sudoku$ go build +student@ubuntu:~/[[ROOT]]/sudoku$ ./sudoku ".96.4...1" "1...6...4" "5.481.39." "..795..43" ".3..8...." "4.5.23.18" ".1.63..59" ".59.7.83." "..359...7" | cat -e +3 9 6 2 4 5 7 8 1$ +1 7 8 3 6 9 5 2 4$ +5 2 4 8 1 7 3 9 6$ +2 8 7 9 5 1 6 4 3$ +9 3 1 4 8 6 2 7 5$ +4 6 5 7 2 3 9 1 8$ +7 1 2 6 3 8 4 5 9$ +6 5 9 1 7 4 8 3 2$ +8 4 3 5 9 2 1 6 7$ +student@ubuntu:~/[[ROOT]]/sudoku$ +``` + +#### Example 2: + +Examples of output for invalid input or sudokus : + +```console +student@ubuntu:~/[[ROOT]]/sudoku$ ./sudoku 1 2 3 4 | cat -e +Error$ +student@ubuntu:~/[[ROOT]]/sudoku$ ./sudoku | cat -e +Error$ +student@ubuntu:~/[[ROOT]]/sudoku$ ./sudoku ".96.4...1" "1...6.1.4" "5.481.39." "..795..43" ".3..8...." "4.5.23.18" ".1.63..59" ".59.7.83." "..359...7" | cat -e +Error$ +student@ubuntu:~/[[ROOT]]/sudoku$ +``` diff --git a/subjects/raid2/audit/README.md b/subjects/sudoku/audit/README.md similarity index 99% rename from subjects/raid2/audit/README.md rename to subjects/sudoku/audit/README.md index c8dff73ed..5e7f42ba3 100644 --- a/subjects/raid2/audit/README.md +++ b/subjects/sudoku/audit/README.md @@ -1,4 +1,4 @@ -#### Raid 2 +#### Sudoku ##### Try running the program with the arguments: `"".96.4...1" "1...6...4" "5.481.39." "..795..43" ".3..8...." "4.5.23.18" ".1.63..59" ".59.7.83." "..359...7""` From 632d357dcd0bc5e10e1ab137ef27419512a12f3f Mon Sep 17 00:00:00 2001 From: lee Date: Thu, 6 Aug 2020 14:15:13 +0100 Subject: [PATCH 6/8] renaming: quadverifier -> quadchecker --- subjects/quadchecker/README.md | 62 +++++++++++++++++++ .../audit/README.md | 20 +++--- subjects/quadverifier/README.md | 62 ------------------- 3 files changed, 72 insertions(+), 72 deletions(-) create mode 100644 subjects/quadchecker/README.md rename subjects/{quadverifier => quadchecker}/audit/README.md (57%) delete mode 100644 subjects/quadverifier/README.md diff --git a/subjects/quadchecker/README.md b/subjects/quadchecker/README.md new file mode 100644 index 000000000..809e39114 --- /dev/null +++ b/subjects/quadchecker/README.md @@ -0,0 +1,62 @@ +## quadChecker + +### Instructions + +This raid is based on the `quad` functions. + +Create a program `quadChecker` that takes a `string` as an argument and displays the name of the matching `quad` and its dimensions. + +- If the argument is not a `raid` the program should print `Not a Raid function`. + +- All answers must end with a newline (`'\n'`). + +- If there is more than one `quad` matches, the program must display them all alphabetically ordered and separated by a `||`. + +### Usage + +- If it's `quadA` + +```console +student@ubuntu:~/[[ROOT]]/quadChecker$ ls -l +-rw-r--r-- 1 student student nov 23 14:30 main.go +-rwxr-xr-x 1 student student nov 23 19:18 quadChecker +-rwxr-xr-x 1 student student nov 23 19:50 quadA +-rwxr-xr-x 1 student student nov 23 19:50 quadB +-rwxr-xr-x 1 student student nov 23 19:50 quadC +-rwxr-xr-x 1 student student nov 23 19:50 quadD +-rwxr-xr-x 1 student student nov 23 19:50 quadE +student@ubuntu:~/[[ROOT]]/quadChecker$ ./quadA 3 3 | ./quadChecker +[quadA] [3] [3] +student@ubuntu:~/[[ROOT]]/quadChecker$ +student@ubuntu:~/[[ROOT]]/quadChecker$ +student@ubuntu:~/[[ROOT]]/quadChecker$ +student@ubuntu:~/[[ROOT]]/quadChecker$ +``` + +- If it's `quadC 1 1` : + +```console +student@ubuntu:~/[[ROOT]]/quadChecker$ ./quadC 1 1 +A +student@ubuntu:~/[[ROOT]]/quadChecker$ ./quadD 1 1 +A +student@ubuntu:~/[[ROOT]]/quadChecker$ ./quadE 1 1 +A +student@ubuntu:~/[[ROOT]]/quadChecker$ ./quadC 1 1 | ./quadChecker +[quadC] [1] [1] || [quadD] [1] [1] || [quadE] [1] [1] +student@ubuntu:~/[[ROOT]]/quadChecker$ +``` + +- If it's `quadC 1 2` : + +```console +student@ubuntu:~/[[ROOT]]/quadChecker$ ./quadE 1 2 +A +C +student@ubuntu:~/[[ROOT]]/quadChecker$ ./quadC 1 2 +A +C +student@ubuntu:~/[[ROOT]]/quadChecker$ ./quadE 1 2 | ./quadChecker +[quadC] [1] [2] || [quadE] [1] [2] +student@ubuntu:~/[[ROOT]]/quadChecker$ +``` diff --git a/subjects/quadverifier/audit/README.md b/subjects/quadchecker/audit/README.md similarity index 57% rename from subjects/quadverifier/audit/README.md rename to subjects/quadchecker/audit/README.md index fb555dc9b..cd91b065d 100644 --- a/subjects/quadverifier/audit/README.md +++ b/subjects/quadchecker/audit/README.md @@ -1,6 +1,6 @@ -#### Quadrangle verifier +#### Quadrangle Checker -##### Try running the program: `"./quadA 3 3 | ./quadVerifier"` +##### Try running the program: `"./quadA 3 3 | ./quadChecker"` ``` [quadA] [3] [3] @@ -8,7 +8,7 @@ ###### Does the program returns the value above? -##### Try running the program: `"./quadB 3 3 | ./quadVerifier"` +##### Try running the program: `"./quadB 3 3 | ./quadChecker"` ``` [quadB] [3] [3] @@ -16,7 +16,7 @@ ###### Does the program returns the value above? -##### Try running the program: `"./quadC 1 1 | ./quadVerifier"` +##### Try running the program: `"./quadC 1 1 | ./quadChecker"` ``` [quadC] [1] [1] || [quadD] [1] [1] || [quadE] [1] [1] @@ -24,7 +24,7 @@ ###### Does the program returns the value above? -##### Try running the program: `"./quadE 1 2 | ./quadVerifier"` +##### Try running the program: `"./quadE 1 2 | ./quadChecker"` ``` [quadC] [1] [2] || [quadE] [1] [2] @@ -32,7 +32,7 @@ ###### Does the program returns the value above? -##### Try running the program: `"./quadE 2 1 | ./quadVerifier"` +##### Try running the program: `"./quadE 2 1 | ./quadChecker"` ``` [quadD] [2] [1] || [quadE] [2] [1] @@ -40,7 +40,7 @@ ###### Does the program returns the value above? -##### Try running the program: `"./quadC 2 1 | ./quadVerifier"` +##### Try running the program: `"./quadC 2 1 | ./quadChecker"` ``` [quadC] [2] [1] @@ -48,7 +48,7 @@ ###### Does the program returns the value above? -##### Try running the program: `"./quadD 1 2 | ./quadVerifier"` +##### Try running the program: `"./quadD 1 2 | ./quadChecker"` ``` [quadD] [1] [2] @@ -56,7 +56,7 @@ ###### Does the program returns the value above? -##### Try running the program: `"./quadE 1 1 | ./quadVerifier"` +##### Try running the program: `"./quadE 1 1 | ./quadChecker"` ``` [quadC] [1] [1] || [quadD] [1] [1] || [quadE] [1] [1] @@ -64,7 +64,7 @@ ###### Does the program returns the value above? -##### Try running the program: `"echo 0 0 | ./quadVerifier"` +##### Try running the program: `"echo 0 0 | ./quadChecker"` ``` Not a Raid function diff --git a/subjects/quadverifier/README.md b/subjects/quadverifier/README.md deleted file mode 100644 index 77820e2f1..000000000 --- a/subjects/quadverifier/README.md +++ /dev/null @@ -1,62 +0,0 @@ -## quadverifier - -### Instructions - -This raid is based on the `quad` functions. - -Create a program `quadVerifier` that takes a `string` as an argument and displays the name of the matching `quad` and its dimensions. - -- If the argument is not a `raid` the program should print `Not a Raid function`. - -- All answers must end with a newline (`'\n'`). - -- If there is more than one `quad` matches, the program must display them all alphabetically ordered and separated by a `||`. - -### Usage - -- If it's `quadA` - -```console -student@ubuntu:~/[[ROOT]]/quadverifier$ ls -l --rw-r--r-- 1 student student nov 23 14:30 main.go --rwxr-xr-x 1 student student nov 23 19:18 quadVerifier --rwxr-xr-x 1 student student nov 23 19:50 quadA --rwxr-xr-x 1 student student nov 23 19:50 quadB --rwxr-xr-x 1 student student nov 23 19:50 quadC --rwxr-xr-x 1 student student nov 23 19:50 quadD --rwxr-xr-x 1 student student nov 23 19:50 quadE -student@ubuntu:~/[[ROOT]]/quadverifier$ ./quadA 3 3 | ./quadVerifier -[quadA] [3] [3] -student@ubuntu:~/[[ROOT]]/quadverifier$ -student@ubuntu:~/[[ROOT]]/quadverifier$ -student@ubuntu:~/[[ROOT]]/quadverifier$ -student@ubuntu:~/[[ROOT]]/quadverifier$ -``` - -- If it's `quadC 1 1` : - -```console -student@ubuntu:~/[[ROOT]]/quadverifier$ ./quadC 1 1 -A -student@ubuntu:~/[[ROOT]]/quadverifier$ ./quadD 1 1 -A -student@ubuntu:~/[[ROOT]]/quadverifier$ ./quadE 1 1 -A -student@ubuntu:~/[[ROOT]]/quadverifier$ ./quadC 1 1 | ./quadVerifier -[quadC] [1] [1] || [quadD] [1] [1] || [quadE] [1] [1] -student@ubuntu:~/[[ROOT]]/quadverifier$ -``` - -- If it's `quadC 1 2` : - -```console -student@ubuntu:~/[[ROOT]]/quadverifier$ ./quadE 1 2 -A -C -student@ubuntu:~/[[ROOT]]/quadverifier$ ./quadC 1 2 -A -C -student@ubuntu:~/[[ROOT]]/quadverifier$ ./quadE 1 2 | ./quadVerifier -[quadC] [1] [2] || [quadE] [1] [2] -student@ubuntu:~/[[ROOT]]/quadverifier$ -``` From cfc198d830ca71b27b18829a4e5e1bd38d247259 Mon Sep 17 00:00:00 2001 From: lee Date: Thu, 6 Aug 2020 14:38:31 +0100 Subject: [PATCH 7/8] sortable questions --- subjects/sortable1/audit/README.md | 52 +++++++++++++++++++++++++++++- 1 file changed, 51 insertions(+), 1 deletion(-) diff --git a/subjects/sortable1/audit/README.md b/subjects/sortable1/audit/README.md index d162d5ce3..37f1850a2 100644 --- a/subjects/sortable1/audit/README.md +++ b/subjects/sortable1/audit/README.md @@ -1,5 +1,55 @@ #### Functionals -#### Generals +###### Does the data appear in a table element? + +###### Does the table presents just the requested data (icon, name, full name, powerstats, race, gender, height, weight, place of birth, alignment), instead of all of it? + +###### Are there different pages that display different information? + +###### Can you change the amount of results displayed between **10**, **20**, **50**, **100** or **all results**? + +###### Does the table initially displays 20 results? + +###### Are the results initially sorted by the column **name** by **ascending** order? + +###### Are all columns of the table clickable in order to sort the results? + +##### Try to click once to sort the table by weight. + +###### Did the results became sorted numerically by weight in **ascending** order? (be aware that cases like [75 kg, 100kg] should be in that order and not the other way around) + +##### Try to click twice to sort the by place of birth. + +###### Did the results became sorted alphabetically by place of birth in **descending** order? + +##### Try to click several times on a column and observe its behavior. + +###### Did the results became sorted in **ascending** and **descending** order, alternately? + +##### Try to search for `Superman`. + +###### Are the missing values always shown last? + +###### As you type, does the results on the table change? + +##### Write only `Cat` on the search field. + +###### Does Catwoman appear on the results? + +###### Does the project contains the use of `fetch`? #### Bonus + +###### +Can you search for any fields apart from the name? + +###### +Can you do a search with search operators (include/exclude for strings and equal/not equal/greater than/lesser than)? + +###### +If you click on a hero, does the site displays the details and a large image of it? + +###### +Does the URL changes when you make a search? + +###### +After making a search and the URL changes, if you copy and paste it in a different window, are the results displayed in the table the same as the ones from the search? + +###### +Does the project runs quickly and effectively? (Favoring recursive, no unnecessary data requests, etc) + +###### +Does the code obey the [good practices](https://public.01-edu.org/subjects/good-practices/README.md)? \ No newline at end of file From 1600d27abfb96787ef9221f38cf8429052c32a04 Mon Sep 17 00:00:00 2001 From: lee Date: Thu, 6 Aug 2020 17:56:11 +0100 Subject: [PATCH 8/8] correction: namings --- subjects/quadchecker/README.md | 36 ++++++++++++++-------------- subjects/quadchecker/audit/README.md | 18 +++++++------- 2 files changed, 27 insertions(+), 27 deletions(-) diff --git a/subjects/quadchecker/README.md b/subjects/quadchecker/README.md index 809e39114..74a1577d5 100644 --- a/subjects/quadchecker/README.md +++ b/subjects/quadchecker/README.md @@ -1,10 +1,10 @@ -## quadChecker +## quadchecker ### Instructions This raid is based on the `quad` functions. -Create a program `quadChecker` that takes a `string` as an argument and displays the name of the matching `quad` and its dimensions. +Create a program `quadchecker` that takes a `string` as an argument and displays the name of the matching `quad` and its dimensions. - If the argument is not a `raid` the program should print `Not a Raid function`. @@ -17,46 +17,46 @@ Create a program `quadChecker` that takes a `string` as an argument and displays - If it's `quadA` ```console -student@ubuntu:~/[[ROOT]]/quadChecker$ ls -l +student@ubuntu:~/[[ROOT]]/quadchecker$ ls -l -rw-r--r-- 1 student student nov 23 14:30 main.go --rwxr-xr-x 1 student student nov 23 19:18 quadChecker +-rwxr-xr-x 1 student student nov 23 19:18 quadchecker -rwxr-xr-x 1 student student nov 23 19:50 quadA -rwxr-xr-x 1 student student nov 23 19:50 quadB -rwxr-xr-x 1 student student nov 23 19:50 quadC -rwxr-xr-x 1 student student nov 23 19:50 quadD -rwxr-xr-x 1 student student nov 23 19:50 quadE -student@ubuntu:~/[[ROOT]]/quadChecker$ ./quadA 3 3 | ./quadChecker +student@ubuntu:~/[[ROOT]]/quadchecker$ ./quadA 3 3 | ./quadchecker [quadA] [3] [3] -student@ubuntu:~/[[ROOT]]/quadChecker$ -student@ubuntu:~/[[ROOT]]/quadChecker$ -student@ubuntu:~/[[ROOT]]/quadChecker$ -student@ubuntu:~/[[ROOT]]/quadChecker$ +student@ubuntu:~/[[ROOT]]/quadchecker$ +student@ubuntu:~/[[ROOT]]/quadchecker$ +student@ubuntu:~/[[ROOT]]/quadchecker$ +student@ubuntu:~/[[ROOT]]/quadchecker$ ``` - If it's `quadC 1 1` : ```console -student@ubuntu:~/[[ROOT]]/quadChecker$ ./quadC 1 1 +student@ubuntu:~/[[ROOT]]/quadchecker$ ./quadC 1 1 A -student@ubuntu:~/[[ROOT]]/quadChecker$ ./quadD 1 1 +student@ubuntu:~/[[ROOT]]/quadchecker$ ./quadD 1 1 A -student@ubuntu:~/[[ROOT]]/quadChecker$ ./quadE 1 1 +student@ubuntu:~/[[ROOT]]/quadchecker$ ./quadE 1 1 A -student@ubuntu:~/[[ROOT]]/quadChecker$ ./quadC 1 1 | ./quadChecker +student@ubuntu:~/[[ROOT]]/quadchecker$ ./quadC 1 1 | ./quadchecker [quadC] [1] [1] || [quadD] [1] [1] || [quadE] [1] [1] -student@ubuntu:~/[[ROOT]]/quadChecker$ +student@ubuntu:~/[[ROOT]]/quadchecker$ ``` - If it's `quadC 1 2` : ```console -student@ubuntu:~/[[ROOT]]/quadChecker$ ./quadE 1 2 +student@ubuntu:~/[[ROOT]]/quadchecker$ ./quadE 1 2 A C -student@ubuntu:~/[[ROOT]]/quadChecker$ ./quadC 1 2 +student@ubuntu:~/[[ROOT]]/quadchecker$ ./quadC 1 2 A C -student@ubuntu:~/[[ROOT]]/quadChecker$ ./quadE 1 2 | ./quadChecker +student@ubuntu:~/[[ROOT]]/quadchecker$ ./quadE 1 2 | ./quadchecker [quadC] [1] [2] || [quadE] [1] [2] -student@ubuntu:~/[[ROOT]]/quadChecker$ +student@ubuntu:~/[[ROOT]]/quadchecker$ ``` diff --git a/subjects/quadchecker/audit/README.md b/subjects/quadchecker/audit/README.md index cd91b065d..0a240c635 100644 --- a/subjects/quadchecker/audit/README.md +++ b/subjects/quadchecker/audit/README.md @@ -1,6 +1,6 @@ #### Quadrangle Checker -##### Try running the program: `"./quadA 3 3 | ./quadChecker"` +##### Try running the program: `"./quadA 3 3 | ./quadchecker"` ``` [quadA] [3] [3] @@ -8,7 +8,7 @@ ###### Does the program returns the value above? -##### Try running the program: `"./quadB 3 3 | ./quadChecker"` +##### Try running the program: `"./quadB 3 3 | ./quadchecker"` ``` [quadB] [3] [3] @@ -16,7 +16,7 @@ ###### Does the program returns the value above? -##### Try running the program: `"./quadC 1 1 | ./quadChecker"` +##### Try running the program: `"./quadC 1 1 | ./quadchecker"` ``` [quadC] [1] [1] || [quadD] [1] [1] || [quadE] [1] [1] @@ -24,7 +24,7 @@ ###### Does the program returns the value above? -##### Try running the program: `"./quadE 1 2 | ./quadChecker"` +##### Try running the program: `"./quadE 1 2 | ./quadchecker"` ``` [quadC] [1] [2] || [quadE] [1] [2] @@ -32,7 +32,7 @@ ###### Does the program returns the value above? -##### Try running the program: `"./quadE 2 1 | ./quadChecker"` +##### Try running the program: `"./quadE 2 1 | ./quadchecker"` ``` [quadD] [2] [1] || [quadE] [2] [1] @@ -40,7 +40,7 @@ ###### Does the program returns the value above? -##### Try running the program: `"./quadC 2 1 | ./quadChecker"` +##### Try running the program: `"./quadC 2 1 | ./quadchecker"` ``` [quadC] [2] [1] @@ -48,7 +48,7 @@ ###### Does the program returns the value above? -##### Try running the program: `"./quadD 1 2 | ./quadChecker"` +##### Try running the program: `"./quadD 1 2 | ./quadchecker"` ``` [quadD] [1] [2] @@ -56,7 +56,7 @@ ###### Does the program returns the value above? -##### Try running the program: `"./quadE 1 1 | ./quadChecker"` +##### Try running the program: `"./quadE 1 1 | ./quadchecker"` ``` [quadC] [1] [1] || [quadD] [1] [1] || [quadE] [1] [1] @@ -64,7 +64,7 @@ ###### Does the program returns the value above? -##### Try running the program: `"echo 0 0 | ./quadChecker"` +##### Try running the program: `"echo 0 0 | ./quadchecker"` ``` Not a Raid function