Browse Source

Merge pull request #662 from 01-edu/harmonise-raids

harmonising raids
pull/666/head
OGordoo 4 years ago committed by GitHub
parent
commit
0cb81d3d22
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
  1. 4
      go/tests/func/quada_test/main.go
  2. 12
      go/tests/func/quadb_test/main.go
  3. 12
      go/tests/func/quadc_test/main.go
  4. 12
      go/tests/func/quadd_test/main.go
  5. 12
      go/tests/func/quade_test/main.go
  6. 0
      go/tests/prog/sudoku_prog/main.go
  7. 8
      go/tests/prog/sudoku_test/main.go
  8. 4
      subjects/clonernews1/README.md
  9. 39
      subjects/clonernews1/audit/README.md
  10. 569
      subjects/quad/README.md
  11. 435
      subjects/quad/audit/README.md
  12. 14
      subjects/quada/README.md
  13. 14
      subjects/quadb/README.md
  14. 14
      subjects/quadc/README.md
  15. 62
      subjects/quadchecker/README.md
  16. 73
      subjects/quadchecker/audit/README.md
  17. 14
      subjects/quadd/README.md
  18. 14
      subjects/quade/README.md
  19. 42
      subjects/raid2/README.md
  20. 62
      subjects/raid3/README.md
  21. 37
      subjects/sortable1/README.md
  22. 55
      subjects/sortable1/audit/README.md
  23. 42
      subjects/sudoku/README.md
  24. 2
      subjects/sudoku/audit/README.md

4
go/tests/func/raid1a_test/main.go → 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 { if x < 1 || y < 1 {
return return
} }
@ -67,7 +67,7 @@ func main() {
// Tests all possibilities including 0 0, -x y, x -y // Tests all possibilities including 0 0, -x y, x -y
for i := 0; i < len(table); i += 2 { for i := 0; i < len(table); i += 2 {
if i != len(table)-1 { 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])
} }
} }
} }

12
go/tests/func/raid1b_test/main.go → go/tests/func/quadb_test/main.go

@ -8,7 +8,7 @@ import (
"lib" "lib"
) )
func drawLineRaid1b(x int, s string) { func drawLineQuadB(x int, s string) {
beg := s[0] beg := s[0]
med := s[1] med := s[1]
end := s[2] end := s[2]
@ -26,7 +26,7 @@ func drawLineRaid1b(x int, s string) {
fmt.Println() fmt.Println()
} }
func raid1b(x, y int) { func quadB(x, y int) {
if x < 1 || y < 1 { if x < 1 || y < 1 {
return return
} }
@ -35,15 +35,15 @@ func raid1b(x, y int) {
strEnd := "\\*/" strEnd := "\\*/"
if y >= 1 { if y >= 1 {
drawLineRaid1b(x, strBeg) drawLineQuadB(x, strBeg)
} }
if y > 2 { if y > 2 {
for i := 0; i < y-2; i++ { for i := 0; i < y-2; i++ {
drawLineRaid1b(x, strMed) drawLineQuadB(x, strMed)
} }
} }
if y > 1 { 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 // Tests all possibilities including 0 0, -x y, x -y
for i := 0; i < len(table); i += 2 { for i := 0; i < len(table); i += 2 {
if i != len(table)-1 { 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])
} }
} }
} }

12
go/tests/func/raid1c_test/main.go → go/tests/func/quadc_test/main.go

@ -8,7 +8,7 @@ import (
"lib" "lib"
) )
func drawLineRaid1c(x int, s string) { func drawLineQuadC(x int, s string) {
beg := s[0] beg := s[0]
med := s[1] med := s[1]
end := s[2] end := s[2]
@ -26,7 +26,7 @@ func drawLineRaid1c(x int, s string) {
fmt.Println() fmt.Println()
} }
func raid1c(x, y int) { func quadC(x, y int) {
if x < 1 || y < 1 { if x < 1 || y < 1 {
return return
} }
@ -35,15 +35,15 @@ func raid1c(x, y int) {
strEnd := "CBC" strEnd := "CBC"
if y >= 1 { if y >= 1 {
drawLineRaid1c(x, strBeg) drawLineQuadC(x, strBeg)
} }
if y > 2 { if y > 2 {
for i := 0; i < y-2; i++ { for i := 0; i < y-2; i++ {
drawLineRaid1c(x, strMed) drawLineQuadC(x, strMed)
} }
} }
if y > 1 { 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 // Tests all possibilities including 0 0, -x y, x -y
for i := 0; i < len(table); i += 2 { for i := 0; i < len(table); i += 2 {
if i != len(table)-1 { 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])
} }
} }
} }

12
go/tests/func/raid1d_test/main.go → go/tests/func/quadd_test/main.go

@ -8,7 +8,7 @@ import (
"lib" "lib"
) )
func drawLineRaid1d(x int, s string) { func drawLineQuadD(x int, s string) {
beg := s[0] beg := s[0]
med := s[1] med := s[1]
end := s[2] end := s[2]
@ -26,7 +26,7 @@ func drawLineRaid1d(x int, s string) {
fmt.Println() fmt.Println()
} }
func raid1d(x, y int) { func quadD(x, y int) {
if x < 1 || y < 1 { if x < 1 || y < 1 {
return return
} }
@ -35,15 +35,15 @@ func raid1d(x, y int) {
strEnd := "ABC" strEnd := "ABC"
if y >= 1 { if y >= 1 {
drawLineRaid1d(x, strBeg) drawLineQuadD(x, strBeg)
} }
if y > 2 { if y > 2 {
for i := 0; i < y-2; i++ { for i := 0; i < y-2; i++ {
drawLineRaid1d(x, strMed) drawLineQuadD(x, strMed)
} }
} }
if y > 1 { 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 // Tests all possibilities including 0 0, -x y, x -y
for i := 0; i < len(table); i += 2 { for i := 0; i < len(table); i += 2 {
if i != len(table)-1 { 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])
} }
} }
} }

12
go/tests/func/raid1e_test/main.go → go/tests/func/quade_test/main.go

@ -8,7 +8,7 @@ import (
"lib" "lib"
) )
func drawLineRaid1e(x int, s string) { func drawLineQuadE(x int, s string) {
beg := s[0] beg := s[0]
med := s[1] med := s[1]
end := s[2] end := s[2]
@ -26,7 +26,7 @@ func drawLineRaid1e(x int, s string) {
fmt.Println() fmt.Println()
} }
func raid1e(x, y int) { func quadE(x, y int) {
if x < 1 || y < 1 { if x < 1 || y < 1 {
return return
} }
@ -35,15 +35,15 @@ func raid1e(x, y int) {
strEnd := "CBA" strEnd := "CBA"
if y >= 1 { if y >= 1 {
drawLineRaid1e(x, strBeg) drawLineQuadE(x, strBeg)
} }
if y > 2 { if y > 2 {
for i := 0; i < y-2; i++ { for i := 0; i < y-2; i++ {
drawLineRaid1e(x, strMed) drawLineQuadE(x, strMed)
} }
} }
if y > 1 { 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 // Tests all possibilities including 0 0, -x y, x -y
for i := 0; i < len(table); i += 2 { for i := 0; i < len(table); i += 2 {
if i != len(table)-1 { 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])
} }
} }
} }

0
go/tests/prog/raid2_prog/main.go → go/tests/prog/sudoku_prog/main.go

8
go/tests/prog/raid2_test/main.go → go/tests/prog/sudoku_test/main.go

@ -286,13 +286,13 @@ func main() {
} }
for _, v := range valid { for _, v := range valid {
lib.ChallengeMain("raid2", v...) lib.ChallengeMain("sudoku", v...)
} }
for _, v := range invalid { for _, v := range invalid {
lib.ChallengeMain("raid2", v...) lib.ChallengeMain("sudoku", v...)
} }
lib.ChallengeMain("raid2") lib.ChallengeMain("sudoku")
lib.ChallengeMain("raid2", "not", "a", "sudoku") lib.ChallengeMain("sudoku", "not", "a", "sudoku")
} }

4
subjects/clonernews1/README.md

@ -16,6 +16,10 @@ You must handle at least:
- [polls](https://github.com/HackerNews/API#items) - [polls](https://github.com/HackerNews/API#items)
- [comments](https://github.com/HackerNews/API#items), each comment must have the proper post parent. - [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. [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. - 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.

39
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?

569
subjects/quad/README.md

@ -0,0 +1,569 @@
# quadrangle
## quadA
### Instructions
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.
`x` and `y` will always be positive numbers. Otherwise, the function should print nothing.
### Expected function
```go
func QuadA(x,y int) {
}
```
### Usage
Here are possible programs to test your function :
Program #1
```go
package main
import piscine ".."
func main() {
piscine.QuadA(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.QuadA(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.QuadA(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.QuadA(1,5)
}
```
And its output :
```console
student@ubuntu:~/[[ROOT]]/test$ go build
student@ubuntu:~/[[ROOT]]/test$ ./test
o
|
|
|
o
student@ubuntu:~/[[ROOT]]/test$
```
----
## quadB
### Instructions
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.
`x` and `y` will always be positive numbers. Otherwise, the function should print nothing.
### Expected function
```go
func QuadB(x,y int) {
}
```
### Usage
Here are possible programs to test your function :
Program #1
```go
package main
import piscine ".."
func main() {
piscine.QuadB(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.QuadB(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.QuadB(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.QuadB(1,5)
}
```
And its output :
```console
student@ubuntu:~/[[ROOT]]/test$ go build
student@ubuntu:~/[[ROOT]]/test$ ./test
/
*
*
*
\
student@ubuntu:~/[[ROOT]]/test$
```
----
## quadC
### Instructions
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.
`x` and `y` will always be positive numbers. Otherwise, the function should print nothing.
### Expected function
```go
func QuadC(x,y int) {
}
```
### Usage
Here are possible programs to test your function :
Program #1
```go
package main
import piscine ".."
func main() {
piscine.QuadC(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.QuadC(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.QuadC(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.QuadC(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$
```
----
## quadD
### Instructions
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.
`x` and `y` will always be positive numbers. Otherwise, the function should print nothing.
### Expected function
```go
func QuadD(x,y int) {
}
```
### Usage
Here are possible programs to test your function :
Program #1
```go
package main
import piscine ".."
func main() {
piscine.QuadD(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.QuadD(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.QuadD(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.QuadD(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$
```
----
## quadE
### Instructions
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.
`x` and `y` will always be positive numbers. Otherwise, the function should print nothing.
### Expected function
```go
func QuadE(x,y int) {
}
```
### Usage
Here are possible programs to test your function :
Program #1
```go
package main
import piscine ".."
func main() {
piscine.QuadE(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.QuadE(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.QuadE(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.QuadE(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$
```

435
subjects/quad/audit/README.md

@ -0,0 +1,435 @@
#### quadA
##### 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?
#### quadC
##### 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?
#### quadC
##### 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?
#### quadD
##### 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?
#### quadE
##### 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?

14
subjects/raid1a/README.md → subjects/quada/README.md

@ -1,8 +1,8 @@
## raid1a ## quadrangle
### Instructions ### 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. The function must draw the rectangles as in the examples.
@ -11,7 +11,7 @@ The function must draw the rectangles as in the examples.
### Expected function ### Expected function
```go ```go
func Raid1a(x,y int) { func QuadA(x,y int) {
} }
``` ```
@ -28,7 +28,7 @@ package main
import piscine ".." import piscine ".."
func main() { func main() {
piscine.Raid1a(5,3) piscine.QuadA(5,3)
} }
``` ```
@ -51,7 +51,7 @@ package main
import piscine ".." import piscine ".."
func main() { func main() {
piscine.Raid1a(5,1) piscine.QuadA(5,1)
} }
``` ```
@ -72,7 +72,7 @@ package main
import piscine ".." import piscine ".."
func main() { func main() {
piscine.Raid1a(1,1) piscine.QuadA(1,1)
} }
``` ```
@ -93,7 +93,7 @@ package main
import piscine ".." import piscine ".."
func main() { func main() {
piscine.Raid1a(1,5) piscine.QuadA(1,5)
} }
``` ```

14
subjects/raid1b/README.md → subjects/quadb/README.md

@ -1,8 +1,8 @@
## raid1b ## quadrangle
### Instructions ### 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. The function must draw the rectangles as in the examples.
@ -11,7 +11,7 @@ The function must draw the rectangles as in the examples.
### Expected function ### Expected function
```go ```go
func Raid1b(x,y int) { func QuadB(x,y int) {
} }
``` ```
@ -28,7 +28,7 @@ package main
import piscine ".." import piscine ".."
func main() { func main() {
piscine.Raid1b(5,3) piscine.QuadB(5,3)
} }
``` ```
@ -51,7 +51,7 @@ package main
import piscine ".." import piscine ".."
func main() { func main() {
piscine.Raid1b(5,1) piscine.QuadB(5,1)
} }
``` ```
@ -72,7 +72,7 @@ package main
import piscine ".." import piscine ".."
func main() { func main() {
piscine.Raid1b(1,1) piscine.QuadB(1,1)
} }
``` ```
@ -93,7 +93,7 @@ package main
import piscine ".." import piscine ".."
func main() { func main() {
piscine.Raid1b(1,5) piscine.QuadB(1,5)
} }
``` ```

14
subjects/raid1c/README.md → subjects/quadc/README.md

@ -1,8 +1,8 @@
## raid1c ## quadrangle
### Instructions ### 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. The function must draw the rectangles as in the examples.
@ -11,7 +11,7 @@ The function must draw the rectangles as in the examples.
### Expected function ### Expected function
```go ```go
func Raid1c(x,y int) { func QuadC(x,y int) {
} }
``` ```
@ -28,7 +28,7 @@ package main
import piscine ".." import piscine ".."
func main() { func main() {
piscine.Raid1c(5,3) piscine.QuadC(5,3)
} }
``` ```
@ -51,7 +51,7 @@ package main
import piscine ".." import piscine ".."
func main() { func main() {
piscine.Raid1c(5,1) piscine.QuadC(5,1)
} }
``` ```
@ -72,7 +72,7 @@ package main
import piscine ".." import piscine ".."
func main() { func main() {
piscine.Raid1c(1,1) piscine.QuadC(1,1)
} }
``` ```
@ -93,7 +93,7 @@ package main
import piscine ".." import piscine ".."
func main() { func main() {
piscine.Raid1c(1,5) piscine.QuadC(1,5)
} }
``` ```

62
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$
```

73
subjects/quadchecker/audit/README.md

@ -0,0 +1,73 @@
#### Quadrangle Checker
##### Try running the program: `"./quadA 3 3 | ./quadchecker"`
```
[quadA] [3] [3]
```
###### Does the program returns the value above?
##### Try running the program: `"./quadB 3 3 | ./quadchecker"`
```
[quadB] [3] [3]
```
###### Does the program returns the value above?
##### Try running the program: `"./quadC 1 1 | ./quadchecker"`
```
[quadC] [1] [1] || [quadD] [1] [1] || [quadE] [1] [1]
```
###### Does the program returns the value above?
##### Try running the program: `"./quadE 1 2 | ./quadchecker"`
```
[quadC] [1] [2] || [quadE] [1] [2]
```
###### Does the program returns the value above?
##### Try running the program: `"./quadE 2 1 | ./quadchecker"`
```
[quadD] [2] [1] || [quadE] [2] [1]
```
###### Does the program returns the value above?
##### Try running the program: `"./quadC 2 1 | ./quadchecker"`
```
[quadC] [2] [1]
```
###### Does the program returns the value above?
##### Try running the program: `"./quadD 1 2 | ./quadchecker"`
```
[quadD] [1] [2]
```
###### Does the program returns the value above?
##### Try running the program: `"./quadE 1 1 | ./quadchecker"`
```
[quadC] [1] [1] || [quadD] [1] [1] || [quadE] [1] [1]
```
###### Does the program returns the value above?
##### Try running the program: `"echo 0 0 | ./quadchecker"`
```
Not a Raid function
```
###### Does the program returns the value above?

14
subjects/raid1d/README.md → subjects/quadd/README.md

@ -1,8 +1,8 @@
## raid1d ## quadrangle
### Instructions ### 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. The function must draw the rectangles as in the examples.
@ -11,7 +11,7 @@ The function must draw the rectangles as in the examples.
### Expected function ### Expected function
```go ```go
func Raid1d(x,y int) { func QuadD(x,y int) {
} }
``` ```
@ -28,7 +28,7 @@ package main
import piscine ".." import piscine ".."
func main() { func main() {
piscine.Raid1d(5,3) piscine.QuadD(5,3)
} }
``` ```
@ -51,7 +51,7 @@ package main
import piscine ".." import piscine ".."
func main() { func main() {
piscine.Raid1d(5,1) piscine.QuadD(5,1)
} }
``` ```
@ -72,7 +72,7 @@ package main
import piscine ".." import piscine ".."
func main() { func main() {
piscine.Raid1d(1,1) piscine.QuadD(1,1)
} }
``` ```
@ -93,7 +93,7 @@ package main
import piscine ".." import piscine ".."
func main() { func main() {
piscine.Raid1d(1,5) piscine.QuadD(1,5)
} }
``` ```

14
subjects/raid1e/README.md → subjects/quade/README.md

@ -1,8 +1,8 @@
## raid1e ## quadrangle
### Instructions ### 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. The function must draw the rectangles as in the examples.
@ -11,7 +11,7 @@ The function must draw the rectangles as in the examples.
### Expected function ### Expected function
```go ```go
func Raid1e(x,y int) { func QuadE(x,y int) {
} }
``` ```
@ -28,7 +28,7 @@ package main
import piscine ".." import piscine ".."
func main() { func main() {
piscine.Raid1e(5,3) piscine.QuadE(5,3)
} }
``` ```
@ -51,7 +51,7 @@ package main
import piscine ".." import piscine ".."
func main() { func main() {
piscine.Raid1e(5,1) piscine.QuadE(5,1)
} }
``` ```
@ -72,7 +72,7 @@ package main
import piscine ".." import piscine ".."
func main() { func main() {
piscine.Raid1e(1,1) piscine.QuadE(1,1)
} }
``` ```
@ -93,7 +93,7 @@ package main
import piscine ".." import piscine ".."
func main() { func main() {
piscine.Raid1e(1,5) piscine.QuadE(1,5)
} }
``` ```

42
subjects/raid2/README.md

@ -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$
```

62
subjects/raid3/README.md

@ -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$
```

37
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 .then(loadData) // .then will call the function with the JSON value
``` ```
#### Display #### Display
Not every field should be presented in a `<table>` element, Not every field should be presented in a `<table>` element,
the necessary data will be: the necessary data will be:
- Icon (`.images.xs`, should be displayed as images and not as a string)
- Name (`.name`) - Icon (`.images.xs`, should be displayed as images and not as a string)
- Full Name (`.biography.fullName`) - Name (`.name`)
- Powerstats (each entry of `.powerstats`) - Full Name (`.biography.fullName`)
- Race (`.appearance.race`) - Powerstats (each entry of `.powerstats`)
- Gender (`.appearance.gender`) - Race (`.appearance.race`)
- Height (`.appearance.height`) - Gender (`.appearance.gender`)
- Weight (`.appearance.weight`) - Height (`.appearance.height`)
- Place Of Birth (`.biography.placeOfBirth`) - Weight (`.appearance.weight`)
- Alignement (`.biography.alignment`) - Place Of Birth (`.biography.placeOfBirth`)
- Alignement (`.biography.alignment`)
The information must be displayed in multiple pages. \ The information must be displayed in multiple pages. \
A `<select>` input is used to chose from `10`, `20`,`50`, `100` or `all results`. A `<select>` input is used to chose from `10`, `20`,`50`, `100` or `all results`.
@ -57,26 +57,25 @@ A `<select>` 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 It must be possible to filter information by searching the name as a string
*(ex: superheroes that contain **man** in their name).* *(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. displaying as you write, not needing a button for you to click.
#### Sort #### Sort
It must be possible to sort by any columns of the table It must be possible to sort by any columns of the table
*(either alphabetically or numerically).* *(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 - Initially all rows should be sorted by the column `name` by `ascending` order
- Consecutive clicks will toggle between `ascending` and `descending` order - First click will order the column by `ascending` value
- Note that, for example, the column `weight` will be composed of strings, so - 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 the correct order would be `['78 kg', '100 kg']` instead of the other way
around 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 > 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 > the database should be very fast and not slow down the browser
### Optional ### Optional
Any additional features will be critical to your success, everything count: Any additional features will be critical to your success, everything count:

55
subjects/sortable1/audit/README.md

@ -0,0 +1,55 @@
#### Functionals
###### 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)?

42
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$
```

2
subjects/raid2/audit/README.md → 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""` ##### 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""`
Loading…
Cancel
Save