root
/
public
mirror of https://github.com/01-edu/public.git
14
27
Fork 3
Code Releases Wiki Activity
Browse Source

Merge pull request #227 from 01-edu/fixListSort 

fix readme listsort from quest 11
pull/228/head
augusto-mantilla 5 years ago committed by GitHub
parent
6b400d1540 3cc1ca3f38
commit
19a7edef81
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 236 additions and 127 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 52
      subjects/listsort.en.md
  2. 69
      subjects/listsort.fr.md
  3. 57
      subjects/sortedlistmerge.en.md
  4. 68
      subjects/sortedlistmerge.fr.md
  5. 51
      subjects/sortlistinsert.en.md
  6. 66
      subjects/sortlistinsert.fr.md

52
subjects/listsort.en.md
unescape_control_characters View File

@ -13,12 +13,12 @@ Write a function `ListSort` that sorts the linked list by ascending order.
### Expected function and structure ### Expected function and structure
```go ```go
type node struct { type Nodee struct {
data int Data int
next *node Next *Nodee
} }
func ListSort(l *node) *node { func ListSort(l *Nodee) *Nodee {
} }
``` ```
@ -32,53 +32,45 @@ package main
import ( import (
"fmt" "fmt"
piscine ".." piscine ".."
) )
//Prints the list func PrintList(l *piscine.Nodee) {
func PrintList(l *node) {
m := l m := l
for m != nil { for m != nil {
fmt.Print(m.data, " -> ") fmt.Print(m.Data, " -> ")
m = m.next m = m.Next
} }
fmt.Print(nil) fmt.Print(nil)
fmt.Println() fmt.Println()
} }
//insert elements func listPushBack(l *piscine.Nodee, data int) *piscine.Nodee {
func listPushBack(l *node, data int) { n := &piscine.Nodee{Data: data}
n := &node{}
n.data = data
n.next = nil
if l == nil { if l == nil {
l = n return n
return
} }
iterator := l iterator := l
for iterator.next != nil { for iterator.Next != nil {
iterator = iterator.next iterator = iterator.Next
} }
iterator.next = n iterator.Next = n
return l
} }
func main() { func main() {
link := &node{} var link *piscine.Nodee
listPushBack(link, 5) link = listPushBack(link, 5)
listPushBack(link, 4) link = listPushBack(link, 4)
listPushBack(link, 3) link = listPushBack(link, 3)
listPushBack(link, 2) link = listPushBack(link, 2)
listPushBack(link, 1) link = listPushBack(link, 1)
PrintList(piscine.ListSort(link)) PrintList(piscine.ListSort(link))
} }
``` ```
And its output : And its output :
@ -86,6 +78,6 @@ And its output :
```console ```console
student@ubuntu:~/piscine/test$ go build student@ubuntu:~/piscine/test$ go build
student@ubuntu:~/piscine/test$ ./test student@ubuntu:~/piscine/test$ ./test
0 -> 1 -> 2 -> 3 -> 4 -> 5 -> <nil> 1 -> 2 -> 3 -> 4 -> 5 -> <nil>
student@ubuntu:~/piscine/test$ student@ubuntu:~/piscine/test$
``` ```

69
subjects/listsort.fr.md
unescape_control_characters View File

@ -1,44 +1,83 @@
## countif ## listpushback
### Instructions ### Instructions
Écrire une fonction `CountIf` qui retournes le nombre d'éléments d'un tableau de `string` pour lesquels la fonction `f` retourne `true`. Write a function `ListSort` that sorts the linked list by ascending order.
### Fonction attendue - This time you only will have the `node` structure.
- Try to use recursive.
- Use pointers when ever you can.
### Expected function and structure
```go ```go
func CountIf(f func(string) bool, tab []string) int { type Nodee struct {
Data int
Next *Nodee
}
func ListSort(l *Nodee) *Nodee {
} }
``` ```
### Utilisation ### Usage
Voici un éventuel [programme](TODO-LINK) pour tester votre fonction : Here is a possible [program](TODO-LINK) to test your function :
```go ```go
package main package main
import ( import (
"fmt" "fmt"
piscine ".." piscine ".."
) )
func PrintList(l *piscine.Nodee) {
m := l
for m != nil {
fmt.Print(m.Data, " -> ")
m = m.Next
}
fmt.Print(nil)
fmt.Println()
}
func listPushBack(l *piscine.Nodee, data int) *piscine.Nodee {
n := &piscine.Nodee{Data: data}
if l == nil {
return n
}
iterator := l
for iterator.Next != nil {
iterator = iterator.Next
}
iterator.Next = n
return l
}
func main() { func main() {
tab1 := []string{"Hello", "how", "are", "you"} var link *piscine.Nodee
tab2 := []string{"This","1", "is", "4", "you"}
answer1 := piscine.CountIf(piscine.IsNumeric, tab1) link = listPushBack(link, 5)
answer2 := piscine.CountIf(piscine.IsNumeric, tab2) link = listPushBack(link, 4)
fmt.Println(answer1) link = listPushBack(link, 3)
fmt.Println(answer2) link = listPushBack(link, 2)
link = listPushBack(link, 1)
PrintList(piscine.ListSort(link))
} }
``` ```
Et son résultat : And its output :
```console ```console
student@ubuntu:~/piscine/test$ go build student@ubuntu:~/piscine/test$ go build
student@ubuntu:~/piscine/test$ ./test student@ubuntu:~/piscine/test$ ./test
0 1 -> 2 -> 3 -> 4 -> 5 -> <nil>
2
student@ubuntu:~/piscine/test$ student@ubuntu:~/piscine/test$
``` ```

57
subjects/sortedlistmerge.en.md
unescape_control_characters View File

@ -2,7 +2,7 @@
### Instructions ### Instructions
Write a function `SortedListMerge` that mereges two lists, `l1` and `l2`, but it as to join them in ascending order. Write a function `SortedListMerge` that mereges two lists, `n1` and `n2`, but it as to join them in ascending order.
- Tip each list as to be already sorted. - Tip each list as to be already sorted.
@ -11,12 +11,7 @@ Write a function `SortedListMerge` that mereges two lists, `l1` and `l2`, but it
### Expected function and structure ### Expected function and structure
```go ```go
type node struct { func SortedListMerge(n1 *Nodee, n2 *Nodee) *Nodee {
data interface{}
next *node
}
func SortedListMerge(l1 *node, l2 *node) *node {
} }
``` ```
@ -30,35 +25,51 @@ package main
import ( import (
"fmt" "fmt"
piscine ".." piscine ".."
) )
func PrintList(l *list) { type node = piscine.Nodee
m := l.head type nodes = piscine.Nodee
func PrintList(l *piscine.Nodee) {
m := l
for m != nil { for m != nil {
fmt.Print(m.data, " -> ") fmt.Print(m.Data, " -> ")
m = m.next m = m.Next
} }
fmt.Print(nil) fmt.Print(nil)
fmt.Println() fmt.Println()
} }
func listPushBack(l *piscine.Nodee, data int) *piscine.Nodee {
n := &piscine.Nodee{Data: data}
if l == nil {
return n
}
iterator := l
for iterator.Next != nil {
iterator = iterator.Next
}
iterator.Next = n
return l
}
func main() { func main() {
link := &list{} var link *node
link2 := &list{} var link2 *nodes
piscine.ListPushBack(link, "5") link = listPushBack(link, 5)
piscine.ListPushBack(link, "3") link = listPushBack(link, 3)
piscine.ListPushBack(link, "7") link = listPushBack(link, 7)
piscine.ListPushBack(link2, "1") link2 = listPushBack(link2, -2)
piscine.ListPushBack(link2, "-2") link2 = listPushBack(link2, 4)
piscine.ListPushBack(link2, "4")
piscine.ListPushBack(link2, "6")
PrintList(SortedListMerge(link, link2)) PrintList(piscine.SortedListMerge(link2, link))
} }
``` ```
And its output : And its output :
@ -66,6 +77,6 @@ And its output :
```console ```console
student@ubuntu:~/piscine/test$ go build student@ubuntu:~/piscine/test$ go build
student@ubuntu:~/piscine/test$ ./test student@ubuntu:~/piscine/test$ ./test
-2 -> 0 -> 0 -> 1 -> 3 -> 4 -> 5 -> 6 -> 7 -> <nil> -2 -> 3 -> 4 -> 5 -> 7 -> <nil>
student@ubuntu:~/piscine/test$ student@ubuntu:~/piscine/test$
``` ```

68
subjects/sortedlistmerge.fr.md
unescape_control_characters View File

@ -1,44 +1,82 @@
## countif ## listpushback
### Instructions ### Instructions
Écrire une fonction `CountIf` qui retournes le nombre d'éléments d'un tableau de `string` pour lesquels la fonction `f` retourne `true`. Write a function `SortedListMerge` that mereges two lists, `n1` and `n2`, but it as to join them in ascending order.
### Fonction attendue - Tip each list as to be already sorted.
- Use pointers when ever you can.
### Expected function and structure
```go ```go
func CountIf(f func(string) bool, tab []string) int { func SortedListMerge(n1 *Nodee, n2 *Nodee) *Nodee {
} }
``` ```
### Utilisation ### Usage
Voici un éventuel [programme](TODO-LINK) pour tester votre fonction : Here is a possible [program](TODO-LINK) to test your function :
```go ```go
package main package main
import ( import (
"fmt" "fmt"
piscine ".." piscine ".."
) )
type node = piscine.Nodee
type nodes = piscine.Nodee
func PrintList(l *piscine.Nodee) {
m := l
for m != nil {
fmt.Print(m.Data, " -> ")
m = m.Next
}
fmt.Print(nil)
fmt.Println()
}
func listPushBack(l *piscine.Nodee, data int) *piscine.Nodee {
n := &piscine.Nodee{Data: data}
if l == nil {
return n
}
iterator := l
for iterator.Next != nil {
iterator = iterator.Next
}
iterator.Next = n
return l
}
func main() { func main() {
tab1 := []string{"Hello", "how", "are", "you"} var link *node
tab2 := []string{"This","1", "is", "4", "you"} var link2 *nodes
answer1 := piscine.CountIf(piscine.IsNumeric, tab1)
answer2 := piscine.CountIf(piscine.IsNumeric, tab2) link = listPushBack(link, 5)
fmt.Println(answer1) link = listPushBack(link, 3)
fmt.Println(answer2) link = listPushBack(link, 7)
link2 = listPushBack(link2, -2)
link2 = listPushBack(link2, 4)
PrintList(piscine.SortedListMerge(link2, link))
} }
``` ```
Et son résultat : And its output :
```console ```console
student@ubuntu:~/piscine/test$ go build student@ubuntu:~/piscine/test$ go build
student@ubuntu:~/piscine/test$ ./test student@ubuntu:~/piscine/test$ ./test
0 -2 -> 3 -> 4 -> 5 -> 7 -> <nil>
2
student@ubuntu:~/piscine/test$ student@ubuntu:~/piscine/test$
``` ```

51
subjects/sortlistinsert.en.md
unescape_control_characters View File

@ -11,12 +11,7 @@ Write a function `SortListInsert` that inserts `data_ref` in the linked list, bu
### Expected function and structure ### Expected function and structure
```go ```go
type node struct { func SortListInsert(l *Nodee, data_ref int) *Nodee{
data int
next *node
}
func SortListInsert(l *node, data_ref int) *node{
} }
``` ```
@ -30,50 +25,48 @@ package main
import ( import (
"fmt" "fmt"
piscine ".." piscine ".."
) )
//Prints the list func PrintList(l *piscine.Nodee) {
func PrintList(l *node) {
m := l m := l
for m != nil { for m != nil {
fmt.Print(m.data, " -> ") fmt.Print(m.Data, " -> ")
m = m.next m = m.Next
} }
fmt.Print(nil) fmt.Print(nil)
fmt.Println() fmt.Println()
} }
//insert elements
func listPushBack(l *node, data int) { func listPushBack(l *piscine.Nodee, data int) *piscine.Nodee {
n := &node{} n := &piscine.Nodee{Data: data}
n.data = data
n.next = nil
if l == nil { if l == nil {
l = n return n
return
} }
iterator := l iterator := l
for iterator.next != nil { for iterator.Next != nil {
iterator = iterator.next iterator = iterator.Next
} }
iterator.next = n iterator.Next = n
return l
} }
func main() { func main() {
link := &node{} var link *piscine.Nodee
listPushBack(link, 1) link = listPushBack(link, 1)
listPushBack(link, 4) link = listPushBack(link, 4)
listPushBack(link, 9) link = listPushBack(link, 9)
PrintList(link) PrintList(link)
link = sortListInsert(link, -2) link = piscine.SortListInsert(link, -2)
link = sortListInsert(link, 2) link = piscine.SortListInsert(link, 2)
PrintList(link) PrintList(link)
} }
``` ```
And its output : And its output :
@ -81,7 +74,7 @@ And its output :
```console ```console
student@ubuntu:~/piscine/test$ go build student@ubuntu:~/piscine/test$ go build
student@ubuntu:~/piscine/test$ ./test student@ubuntu:~/piscine/test$ ./test
-2 -> 0 -> 1 -> 2 -> 4 -> 9 -> <nil> 1 -> 4 -> 9 -> <nil>
lee@lee:~/Documents/work/day11/11-16-sortlistinsert/so -2 -> 1 -> 2 -> 4 -> 9 -> <nil>
student@ubuntu:~/piscine/test$ student@ubuntu:~/piscine/test$
``` ```

66
subjects/sortlistinsert.fr.md
unescape_control_characters View File

@ -1,44 +1,80 @@
## countif ## listpushback
### Instructions ### Instructions
Écrire une fonction `CountIf` qui retournes le nombre d'éléments d'un tableau de `string` pour lesquels la fonction `f` retourne `true`. Write a function `SortListInsert` that inserts `data_ref` in the linked list, but it as to remain sorted in ascending order.
### Fonction attendue - The list as to be alredy sorted.
- Use pointers when ever you can.
### Expected function and structure
```go ```go
func CountIf(f func(string) bool, tab []string) int { func SortListInsert(l *Nodee, data_ref int) *Nodee{
} }
``` ```
### Utilisation ### Usage
Voici un éventuel [programme](TODO-LINK) pour tester votre fonction : Here is a possible [program](TODO-LINK) to test your function :
```go ```go
package main package main
import ( import (
"fmt" "fmt"
piscine ".." piscine ".."
) )
func PrintList(l *piscine.Nodee) {
m := l
for m != nil {
fmt.Print(m.Data, " -> ")
m = m.Next
}
fmt.Print(nil)
fmt.Println()
}
func listPushBack(l *piscine.Nodee, data int) *piscine.Nodee {
n := &piscine.Nodee{Data: data}
if l == nil {
return n
}
iterator := l
for iterator.Next != nil {
iterator = iterator.Next
}
iterator.Next = n
return l
}
func main() { func main() {
tab1 := []string{"Hello", "how", "are", "you"}
tab2 := []string{"This","1", "is", "4", "you"} var link *piscine.Nodee
answer1 := piscine.CountIf(piscine.IsNumeric, tab1)
answer2 := piscine.CountIf(piscine.IsNumeric, tab2) link = listPushBack(link, 1)
fmt.Println(answer1) link = listPushBack(link, 4)
fmt.Println(answer2) link = listPushBack(link, 9)
PrintList(link)
link = piscine.SortListInsert(link, -2)
link = piscine.SortListInsert(link, 2)
PrintList(link)
} }
``` ```
Et son résultat : And its output :
```console ```console
student@ubuntu:~/piscine/test$ go build student@ubuntu:~/piscine/test$ go build
student@ubuntu:~/piscine/test$ ./test student@ubuntu:~/piscine/test$ ./test
0 1 -> 4 -> 9 -> <nil>
2 -2 -> 1 -> 2 -> 4 -> 9 -> <nil>
student@ubuntu:~/piscine/test$ student@ubuntu:~/piscine/test$
``` ```

Write Preview
Loading…
Cancel
Save