Browse Source

Merge pull request #32 from 01-edu/readmes-a

readmes for binary trees exercises and some of quest 10
pull/37/head
Frenchris 6 years ago committed by GitHub
parent
commit
1aadbbc632
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
  1. 42
      subjects/abort.md
  2. 43
      subjects/activebits.md
  3. 48
      subjects/btreeapplybylevel.md
  4. 60
      subjects/btreedeletenode.md
  5. 45
      subjects/btreeisbinary.md
  6. 43
      subjects/btreelevelcount.md
  7. 46
      subjects/btreemax.md
  8. 46
      subjects/btreemin.md
  9. 51
      subjects/btreetransplant.md
  10. 42
      subjects/collatzcountdown.md
  11. 16
      subjects/displayalpham.md
  12. 16
      subjects/displayalrevm.md
  13. 86
      subjects/enigma.md
  14. 44
      subjects/join.md
  15. 28
      subjects/lastword.md
  16. 44
      subjects/max.md
  17. 4
      subjects/onlyz.md
  18. 26
      subjects/pilot.md
  19. 29
      subjects/repeatalpha.md
  20. 20
      subjects/reversebits.md
  21. 20
      subjects/swapbits.md
  22. 27
      subjects/union.md
  23. 44
      subjects/unmatch.md
  24. 13
      subjects/ztail.md

42
subjects/abort.md

@ -0,0 +1,42 @@
# abort
## Instructions
Write a function that returns the the value in the middle of 5 five arguments.
This function must have the following signature.
## Expected function
```go
func Abort(a, b, c, d, e int) int {
}
```
## Usage
Here is a possible [program](TODO-LINK) to test your function :
```go
package main
import (
"fmt"
student ".."
)
func main() {
middle := student.Abort(2, 3, 8, 5, 7)
fmt.Println(middle)
}
```
And its output :
```console
student@ubuntu:~/student/abort$ go build
student@ubuntu:~/student/abort$ ./abort
5
student@ubuntu:~/student/abort$
```

43
subjects/activebits.md

@ -0,0 +1,43 @@
# activebits
## Instructions
Write a function, ActiveBitsthat, that returns the number of active bits (bits with the value 1) in the binary representation of an integer number.
The function must have the next signature.
## Expected function
```go
func ActiveBits(n int) uint {
}
```
## Usage
Here is a possible [program](TODO-LINK) to test your function :
```go
package main
import (
"fmt"
student ".."
)
func main() {
nbits := student.ActiveBits(7)
fmt.Println(nbits)
}
```
And its output :
```console
student@ubuntu:~/student/activebits$ go build
student@ubuntu:~/student/activebits$ ./activebits
10
student@ubuntu:~/student/activebits$
```

48
subjects/btreeapplybylevel.md

@ -0,0 +1,48 @@
# btreeapplybylevel
## Instructions
Write a function, BTreeApplyByLevel, that applies the function given by fn to each node of the tree given by root.
This function must have the following signature.
## Expected function
```go
func BTreeApplyByLevel(root *TreeNode, fn interface{}) {
}
```
## Usage
Here is a possible [program](TODO-LINK) to test your function :
```go
package main
import (
"fmt"
student ".."
)
func main() {
root := &student.TreeNode{Data: "4"}
student.BTreeInsertData(root, "1")
student.BTreeInsertData(root, "7")
student.BTreeInsertData(root, "5")
student.BTreeApplyByLevel(root, fmt.Println)
}
```
And its output :
```console
student@ubuntu:~/student/btreeapplybylevel$ go build
student@ubuntu:~/student/btreeapplybylevel$ ./btreeapplybylevel
4
1
7
5
student@ubuntu:~/student/btreeapplybylevel$
```

60
subjects/btreedeletenode.md

@ -0,0 +1,60 @@
# btreedeletenode
## Instructions
Write a function, BTreeDeleteNode, that deletes 'node' from the tree given by root.
The resulting tree should still follow the binary search tree rules.
This function must have the following signature.
## Expected function
```go
func BTreeDeleteNode(root, node *TreeNode) *TreeNode {
}
```
## Usage
Here is a possible [program](TODO-LINK) to test your function :
```go
package main
import (
"fmt"
student ".."
)
func main() {
root := &student.TreeNode{Data: "4"}
student.BTreeInsertData(root, "1")
student.BTreeInsertData(root, "7")
student.BTreeInsertData(root, "5")
node := student.BTreeSearchItem(root, "4")
fmt.Println("Before delete:")
student.BTreeApplyInorder(root, fmt.Println)
root = student.BTreeDeleteNode(root, node)
fmt.Println("After delete:")
student.BTreeApplyInorder(root, fmt.Println)
}
```
And its output :
```console
student@ubuntu:~/student/btreedeletenode$ go build
student@ubuntu:~/student/btreedeletenode$ ./btreedeletenode
Before delete:
1
4
5
7
After delete:
1
5
7
student@ubuntu:~/student/btreedeletenode$
```

45
subjects/btreeisbinary.md

@ -0,0 +1,45 @@
# btreeisbinary
## Instructions
Write a function, BTreeIsBinary, that returns true only if the tree given by root follows the binary search tree properties.
This function must have the following signature.
## Expected function
```go
func BTreeIsBinary(root *TreeNode) bool {
}
```
## Usage
Here is a possible [program](TODO-LINK) to test your function :
```go
package main
import (
"fmt"
student ".."
)
func main() {
root := &student.TreeNode{Data: "4"}
student.BTreeInsertData(root, "1")
student.BTreeInsertData(root, "7")
student.BTreeInsertData(root, "5")
fmt.Println(student.BTreeIsBinary(root))
}
```
And its output :
```console
student@ubuntu:~/student/btreeisbinary$ go build
student@ubuntu:~/student/btreeisbinary$ ./btreeisbinary
true
student@ubuntu:~/student/btreeisbinary$
```

43
subjects/btreelevelcount.md

@ -0,0 +1,43 @@
# btreelevelcount
## Instructions
Write a function, BTreeLevelCount, that return the number of levels of the tree (height of the tree)
## Expected function
```go
func BTreeLevelCount(root *piscine.TreeNode) int {
}
```
## Usage
Here is a possible [program](TODO-LINK) to test your function :
```go
package main
import (
"fmt"
student ".."
)
func main() {
root := &student.TreeNode{Data: "4"}
student.BTreeInsertData(root, "1")
student.BTreeInsertData(root, "7")
student.BTreeInsertData(root, "5")
fmt.Println(BTreeLevelCount(root))
}
```
And its output :
```console
student@ubuntu:~/student/btreesearchitem$ go build
student@ubuntu:~/student/btreesearchitem$ ./btreesearchitem
3
student@ubuntu:~/student/btreesearchitem$
```

46
subjects/btreemax.md

@ -0,0 +1,46 @@
# btreemax
## Instructions
Write a function, BTreeMax, that returns the node with the maximum value in the tree given by root
This function must have the following signature.
## Expected function
```go
func BTreeMax(root *TreeNode) *TreeNode {
}
```
## Usage
Here is a possible [program](TODO-LINK) to test your function :
```go
package main
import (
"fmt"
student ".."
)
func main() {
root := &student.TreeNode{Data: "4"}
student.BTreeInsertData(root, "1")
student.BTreeInsertData(root, "7")
student.BTreeInsertData(root, "5")
max := student.BTreeMax(root)
fmt.Println(max.Data)
}
```
And its output :
```console
student@ubuntu:~/student/btreemax$ go build
student@ubuntu:~/student/btreemax$ ./btreemax
7
student@ubuntu:~/student/btreemax$
```

46
subjects/btreemin.md

@ -0,0 +1,46 @@
# btreemin
## Instructions
Write a function, BTreeMin, that returns the node with the minimum value in the tree given by root
This function must have the following signature.
## Expected function
```go
func BTreeMin(root *TreeNode) *TreeNode {
}
```
## Usage
Here is a possible [program](TODO-LINK) to test your function :
```go
package main
import (
"fmt"
student ".."
)
func main() {
root := &student.TreeNode{Data: "4"}
student.BTreeInsertData(root, "1")
student.BTreeInsertData(root, "7")
student.BTreeInsertData(root, "5")
min := student.BTreeMin(root)
fmt.Println(min.Data)
}
```
And its output :
```console
student@ubuntu:~/student/btreemin$ go build
student@ubuntu:~/student/btreemin$ ./btreemin
1
student@ubuntu:~/student/btreemin$
```

51
subjects/btreetransplant.md

@ -0,0 +1,51 @@
# btreetransplant
## Instructions
In order to move subtrees around within the binary search tree, write a function, BTreeTransplant, which replaces the subtree started by node with the node called 'rplc' in the tree given by root.
This function must have the following signature.
## Expected function
```go
func BTreeTransplant(root, node, rplc *TreeNode) *TreeNode {
}
```
## Usage
Here is a possible [program](TODO-LINK) to test your function :
```go
package main
import (
"fmt"
student ".."
)
func main() {
root := &student.TreeNode{Data: "4"}
student.BTreeInsertData(root, "1")
student.BTreeInsertData(root, "7")
student.BTreeInsertData(root, "5")
node := student.BTreeSearchItem(root, "1")
replacement := &student.TreeNode{Data: "3"}
root = student.BTreeTransplant(root, node, replacement)
student.BTreeApplyInorder(root, fmt.Println)
}
```
And its output :
```console
student@ubuntu:~/student/btreetransplant$ go build
student@ubuntu:~/student/btreetrandsplant$ ./btreetransplant
3
4
5
7
student@ubuntu:~/student/btreetrandsplant$
```

42
subjects/collatzcountdown.md

@ -0,0 +1,42 @@
# collatzcountdown
## Instructions
Write a function, CollatzCountdown, that returns the number of steps to reach 1 using the collatz countdown.
The function must have the following signature.
## Expected function
```go
func CollatzCountdown(start int) int {
}
```
## Usage
Here is a possible [program](TODO-LINK) to test your function :
```go
package main
import (
"fmt"
student ".."
)
func main() {
steps := student.CollatzCountdown(12)
fmt.Println(steps)
}
```
And its output :
```console
student@ubuntu:~/student/collatzcountdown$ go build
student@ubuntu:~/student/collatzcountdown$ ./collatzcountdown
10
student@ubuntu:~/student/collatzcountdown$
```

16
subjects/displayalpham.md

@ -0,0 +1,16 @@
# displayalpham
## Instructions
Write a program that displays the alphabet, with even letters in uppercase, and
odd letters in lowercase, followed by a newline.
The function must have the next signature.
Example :
```console
student@ubuntu:~/student/displayalpham$ go build
student@ubuntu:~/student/displayalpham$ ./displayalpham | cat -e
aBcDeFgHiJkLmNoPqRsTuVwXyZ$
student@ubuntu:~/student/displayalpham$
```

16
subjects/displayalrevm.md

@ -0,0 +1,16 @@
# displayalrevm
## Instructions
Write a program that displays the alphabet in reverse, with even letters in
uppercase, and odd letters in lowercase, followed by a newline.
The function must have the next signature.
Example :
```console
student@ubuntu:~/student/displayalrevm$ go build
student@ubuntu:~/student/displayalrevm$ ./displayalrevm | cat -e
aBcDeFgHiJkLmNoPqRsTuVwXyZ$
student@ubuntu:~/student/displayalrevm$
```

86
subjects/enigma.md

@ -0,0 +1,86 @@
# enigma
## Instructions
Write a function called `Enigma` that receives poiters to functions and move its values around to hide them
This function will put a into c; c into d; d into b and b into a
This function must have the following signature.
## Expected function
```go
func Enigma(a ***int, b *int, c *******int, d ****int) {
}
```
## Usage
Here is a possible [program](TODO-LINK) to test your function :
```go
package main
import (
"fmt"
student ".."
)
func main() {
x := 5
y := &x
z := &y
a := &z
w := 2
b := &w
u := 7
e := &u
f := &e
g := &f
h := &g
i := &h
j := &i
c := &j
k := 6
l := &k
m := &l
n := &m
d := &n
fmt.Println(***a)
fmt.Println(*b)
fmt.Println(*******c)
fmt.Println(****d)
student.Enigma(a, b, c, d)
fmt.Println("After using Enigma")
fmt.Println(***a)
fmt.Println(*b)
fmt.Println(*******c)
fmt.Println(****d)
}
```
And its output :
```console
student@ubuntu:~/student/enigma$ go build
student@ubuntu:~/student/enigma$ ./enigma
5
2
7
6
After using Enigma
2
6
5
7
student@ubuntu:~/student/enigma$
```

44
subjects/join.md

@ -0,0 +1,44 @@
# join
## Instructions
Write a function, Join, that returns the elements of a slice strings (arstr) join together in one string. Using the string 'sep' as a separator between each element of the array
The function must have the next signature.
## Expected function
```go
func Join(arstr []string, sep string) string {
}
```
## Usage
Here is a possible [program](TODO-LINK) to test your function :
```go
package main
import (
"fmt"
student ".."
)
func main() {
arrStr := []string{"hello", "how", "are", "you"}
joined := student.Join(arrStr, "--")
fmt.Println(joined)
}
```
And its output :
```console
student@ubuntu:~/student/join$ go build
student@ubuntu:~/student/join$ ./join
hello--how--are--you
student@ubuntu:~/student/join$
```

28
subjects/lastword.md

@ -0,0 +1,28 @@
# lastword
## Instructions
Write a program that takes a string and displays its last word, followed by a
newline.
A word is a section of string delimited by spaces/tabs or by the start/end of
the string.
If the number of parameters is not 1, or if there are no words, simply display
a newline.
Example :
```console
student@ubuntu:~/student/lastword$ go build
student@ubuntu:~/student/lastword$ ./lastword "FOR PONY" | cat -e
PONY$
student@ubuntu:~/student/lastword$ ./lastword "this ... is sparta, then again, maybe not" | cat -e
not$
student@ubuntu:~/student/lastword$ ./lastword " " | cat -e
$
student@ubuntu:~/student/lastword$ ./lastword "a" "b" | cat -e
$
student@ubuntu:~/student/lastword$ ./lastword " lorem,ipsum " | cat -e
lorem,ipsum$
student@ubuntu:~/student/lastword$
```

44
subjects/max.md

@ -0,0 +1,44 @@
# max
## Instructions
Write a function, Max, that returns the maximum value in a slice of integers
The function must have the next signature.
## Expected function
```go
func Max(arr []int) int {
}
```
## Usage
Here is a possible [program](TODO-LINK) to test your function :
```go
package main
import (
"fmt"
student ".."
)
func main() {
arrInt := []int{23, 123, 1, 11, 55, 93}
max := student.Max(arrInt)
fmt.Println(max
}
```
And its output :
```console
student@ubuntu:~/student/max$ go build
student@ubuntu:~/student/max$ ./max
123
student@ubuntu:~/student/max$
```

4
subjects/onlyz.md

@ -0,0 +1,4 @@
# displayalpham
## Instructions
Write a program that displays a 'z' character on the standard output.

26
subjects/pilot.md

@ -0,0 +1,26 @@
# pilot
## Instructions
Write a go file so that the following program compile
## Usage
```go
package main
import (
"fmt"
student ".."
)
func main() {
var donnie student.Pilot
donnie.Name = "Donnie"
donnie.Life = 100.0
donnie.Age = 24
donnie.Aircraft = student.AIRCRAFT1
fmt.Println(donnie)
}
```

29
subjects/repeatalpha.md

@ -0,0 +1,29 @@
# repeatalpha
## Instructions
Write a program called repeat_alpha that takes a string and display it
repeating each alphabetical character as many times as its alphabetical index,
followed by a newline.
'a' becomes 'a', 'b' becomes 'bb', 'e' becomes 'eeeee', etc...
Case remains unchanged.
If the number of arguments is not 1, just display a newline.
Examples:
```console
student@ubuntu:~/student/repeatalpha$ go build
student@ubuntu:~/student/repeatalpha$ ./repeatalpha "abc" | cat -e
abbccc
student@ubuntu:~/student/repeatalpha$ ./repeatalpha "Alex." | cat -e
Alllllllllllleeeeexxxxxxxxxxxxxxxxxxxxxxxx.$
student@ubuntu:~/student/repeatalpha$ ./repeatalpha "abacadaba 42!" | cat -e
abbacccaddddabba 42!$
student@ubuntu:~/student/repeatalpha$ ./repeatalpha | cat -e
$
student@ubuntu:~/student/repeatalpha$ ./repeatalpha "" | cat -e
$
student@ubuntu:~/student/repeatalpha$
```

20
subjects/reversebits.md

@ -0,0 +1,20 @@
# reversebits
## Instructions
Write a function that takes a byte, reverses it, bit by bit (like the
example) and returns the result.
Your function must be declared as follows:
func ReverseBits(octet byte) byte {
...
}
Example:
1 byte
_____________
00100110
||
\/
01100100

20
subjects/swapbits.md

@ -0,0 +1,20 @@
# swapbits
## Instructions
Write a function that takes a byte, swaps its halves (like the example) and
returns the result.
Your function must be declared as follows:
func SwapBits(octet byte) byte {
...
}
Example:
1 byte
_____________
0100 | 0001
\ /
/ \
0001 | 0100

27
subjects/union.md

@ -0,0 +1,27 @@
# union
## Instructions
Write a program that takes two strings and displays, without doubles, the
characters that appear in either one of the strings.
The display will be in the order characters appear in the command line, and
will be followed by a \n.
If the number of arguments is not 2, the program displays \n.
Example :
```console
student@ubuntu:~/student/union$ go build
student@ubuntu:~/student/union$ ./union zpadinton "paqefwtdjetyiytjneytjoeyjnejeyj" | cat -e
zpadintoqefwjy$
student@ubuntu:~/student/union$ ./union ddf6vewg64f gtwthgdwthdwfteewhrtag6h4ffdhsd | cat -e
df6vewg4thras$
student@ubuntu:~/student/union$ ./union "rien" "cette phrase ne cache rien" | cat -e
rienct phas$
student@ubuntu:~/student/union$ ./union | cat -e
$
student@ubuntu:~/student/union$ ./union "rien" | cat -e
$
student@ubuntu:~/student/union$
```

44
subjects/unmatch.md

@ -0,0 +1,44 @@
# join
## Instructions
Write a function, Unmatch, that returns the element of the slice (arr) that does not have a correspondent pair.
The function must have the next signature.
## Expected function
```go
func Unmatch(arr []int) int {
}
```
## Usage
Here is a possible [program](TODO-LINK) to test your function :
```go
package main
import (
"fmt"
student ".."
)
func main() {
arr := []int{1, 2, 3, 1, 2, 3, 4}
unmatch := student.Unmatch(arr)
fmt.Println(unmatch)
}
```
And its output :
```console
student@ubuntu:~/student/unmatch$ go build
student@ubuntu:~/student/unmatch$ ./unmatch
4
student@ubuntu:~/student/unmatch$
```

13
subjects/ztail.md

@ -0,0 +1,13 @@
# ztail
## Instructions
Write a program called ztail that does the same thing as the system command tail, but witch takes at least one file as argument.
The only option you have to handle is -c. This option will be used in all tests.
For this program you can use the "os" package.
For the program to pass the test you should follow the convention for the return code of program in Unix sistems (see os.Exit)
For more information consult the man page for tail.
Loading…
Cancel
Save