From 98cf1e002e0e27b290a775265fa3bafd0ad8e5b2 Mon Sep 17 00:00:00 2001 From: lee Date: Wed, 26 Jun 2019 12:55:47 +0100 Subject: [PATCH 1/3] fix readme listsort from quest 11 --- subjects/listsort.en.md | 52 +++++++++++++------------------ subjects/listsort.fr.md | 69 ++++++++++++++++++++++++++++++++--------- 2 files changed, 76 insertions(+), 45 deletions(-) diff --git a/subjects/listsort.en.md b/subjects/listsort.en.md index b690cb987..7672ad54c 100644 --- a/subjects/listsort.en.md +++ b/subjects/listsort.en.md @@ -13,12 +13,12 @@ Write a function `ListSort` that sorts the linked list by ascending order. ### Expected function and structure ```go -type node struct { - data int - next *node +type Nodee struct { + Data int + Next *Nodee } -func ListSort(l *node) *node { +func ListSort(l *Nodee) *Nodee { } ``` @@ -32,53 +32,45 @@ package main import ( "fmt" + piscine ".." ) -//Prints the list -func PrintList(l *node) { +func PrintList(l *piscine.Nodee) { m := l for m != nil { - fmt.Print(m.data, " -> ") - m = m.next + fmt.Print(m.Data, " -> ") + m = m.Next } - fmt.Print(nil) fmt.Println() } -//insert elements -func listPushBack(l *node, data int) { - - n := &node{} - n.data = data - n.next = nil +func listPushBack(l *piscine.Nodee, data int) *piscine.Nodee { + n := &piscine.Nodee{Data: data} if l == nil { - l = n - return + return n } - iterator := l - for iterator.next != nil { - iterator = iterator.next + for iterator.Next != nil { + iterator = iterator.Next } - iterator.next = n + iterator.Next = n + return l } func main() { - link := &node{} + var link *piscine.Nodee - listPushBack(link, 5) - listPushBack(link, 4) - listPushBack(link, 3) - listPushBack(link, 2) - listPushBack(link, 1) + link = listPushBack(link, 5) + link = listPushBack(link, 4) + link = listPushBack(link, 3) + link = listPushBack(link, 2) + link = listPushBack(link, 1) PrintList(piscine.ListSort(link)) - } - ``` And its output : @@ -86,6 +78,6 @@ And its output : ```console student@ubuntu:~/piscine/test$ go build student@ubuntu:~/piscine/test$ ./test -0 -> 1 -> 2 -> 3 -> 4 -> 5 -> +1 -> 2 -> 3 -> 4 -> 5 -> student@ubuntu:~/piscine/test$ ``` diff --git a/subjects/listsort.fr.md b/subjects/listsort.fr.md index 7db913a68..7672ad54c 100644 --- a/subjects/listsort.fr.md +++ b/subjects/listsort.fr.md @@ -1,44 +1,83 @@ -## countif +## listpushback ### 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 -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 package main import ( "fmt" + 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() { - tab1 := []string{"Hello", "how", "are", "you"} - tab2 := []string{"This","1", "is", "4", "you"} - answer1 := piscine.CountIf(piscine.IsNumeric, tab1) - answer2 := piscine.CountIf(piscine.IsNumeric, tab2) - fmt.Println(answer1) - fmt.Println(answer2) + var link *piscine.Nodee + + link = listPushBack(link, 5) + link = listPushBack(link, 4) + link = listPushBack(link, 3) + link = listPushBack(link, 2) + link = listPushBack(link, 1) + + PrintList(piscine.ListSort(link)) } ``` -Et son résultat : +And its output : ```console student@ubuntu:~/piscine/test$ go build student@ubuntu:~/piscine/test$ ./test -0 -2 +1 -> 2 -> 3 -> 4 -> 5 -> student@ubuntu:~/piscine/test$ ``` From f103a9c3301e7dcdceed700665fa731f1ddad28f Mon Sep 17 00:00:00 2001 From: lee Date: Wed, 26 Jun 2019 13:08:49 +0100 Subject: [PATCH 2/3] readme sortlistinsert from quest 11 --- subjects/sortlistinsert.en.md | 51 ++++++++++++--------------- subjects/sortlistinsert.fr.md | 66 +++++++++++++++++++++++++++-------- 2 files changed, 73 insertions(+), 44 deletions(-) diff --git a/subjects/sortlistinsert.en.md b/subjects/sortlistinsert.en.md index b84a35b9d..8b6ab31be 100644 --- a/subjects/sortlistinsert.en.md +++ b/subjects/sortlistinsert.en.md @@ -11,12 +11,7 @@ Write a function `SortListInsert` that inserts `data_ref` in the linked list, bu ### Expected function and structure ```go -type node struct { - data int - next *node -} - -func SortListInsert(l *node, data_ref int) *node{ +func SortListInsert(l *Nodee, data_ref int) *Nodee{ } ``` @@ -30,50 +25,48 @@ package main import ( "fmt" + piscine ".." ) -//Prints the list -func PrintList(l *node) { +func PrintList(l *piscine.Nodee) { m := l for m != nil { - fmt.Print(m.data, " -> ") - m = m.next + fmt.Print(m.Data, " -> ") + m = m.Next } fmt.Print(nil) fmt.Println() } -//insert elements -func listPushBack(l *node, data int) { - n := &node{} - n.data = data - n.next = nil + +func listPushBack(l *piscine.Nodee, data int) *piscine.Nodee { + n := &piscine.Nodee{Data: data} + if l == nil { - l = n - return + return n } iterator := l - for iterator.next != nil { - iterator = iterator.next + for iterator.Next != nil { + iterator = iterator.Next } - iterator.next = n + iterator.Next = n + return l } func main() { - link := &node{} + var link *piscine.Nodee - listPushBack(link, 1) - listPushBack(link, 4) - listPushBack(link, 9) + link = listPushBack(link, 1) + link = listPushBack(link, 4) + link = listPushBack(link, 9) PrintList(link) - link = sortListInsert(link, -2) - link = sortListInsert(link, 2) + link = piscine.SortListInsert(link, -2) + link = piscine.SortListInsert(link, 2) PrintList(link) } - ``` And its output : @@ -81,7 +74,7 @@ And its output : ```console student@ubuntu:~/piscine/test$ go build student@ubuntu:~/piscine/test$ ./test --2 -> 0 -> 1 -> 2 -> 4 -> 9 -> -lee@lee:~/Documents/work/day11/11-16-sortlistinsert/so +1 -> 4 -> 9 -> +-2 -> 1 -> 2 -> 4 -> 9 -> student@ubuntu:~/piscine/test$ ``` diff --git a/subjects/sortlistinsert.fr.md b/subjects/sortlistinsert.fr.md index 7db913a68..8b6ab31be 100644 --- a/subjects/sortlistinsert.fr.md +++ b/subjects/sortlistinsert.fr.md @@ -1,44 +1,80 @@ -## countif +## listpushback ### 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 -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 package main import ( "fmt" + 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() { - tab1 := []string{"Hello", "how", "are", "you"} - tab2 := []string{"This","1", "is", "4", "you"} - answer1 := piscine.CountIf(piscine.IsNumeric, tab1) - answer2 := piscine.CountIf(piscine.IsNumeric, tab2) - fmt.Println(answer1) - fmt.Println(answer2) + + var link *piscine.Nodee + + link = listPushBack(link, 1) + link = listPushBack(link, 4) + 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 student@ubuntu:~/piscine/test$ go build student@ubuntu:~/piscine/test$ ./test -0 -2 +1 -> 4 -> 9 -> +-2 -> 1 -> 2 -> 4 -> 9 -> student@ubuntu:~/piscine/test$ ``` From 3cc1ca3f382a7505da42a4b9addd640756db84f1 Mon Sep 17 00:00:00 2001 From: lee Date: Wed, 26 Jun 2019 13:31:57 +0100 Subject: [PATCH 3/3] readme sortedlistmerge from quest 11 --- subjects/sortedlistmerge.en.md | 57 ++++++++++++++++------------ subjects/sortedlistmerge.fr.md | 68 ++++++++++++++++++++++++++-------- 2 files changed, 87 insertions(+), 38 deletions(-) diff --git a/subjects/sortedlistmerge.en.md b/subjects/sortedlistmerge.en.md index 7653c3e0a..8db19ee14 100644 --- a/subjects/sortedlistmerge.en.md +++ b/subjects/sortedlistmerge.en.md @@ -2,7 +2,7 @@ ### 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. @@ -11,12 +11,7 @@ Write a function `SortedListMerge` that mereges two lists, `l1` and `l2`, but it ### Expected function and structure ```go -type node struct { - data interface{} - next *node -} - -func SortedListMerge(l1 *node, l2 *node) *node { +func SortedListMerge(n1 *Nodee, n2 *Nodee) *Nodee { } ``` @@ -30,35 +25,51 @@ package main import ( "fmt" + piscine ".." ) -func PrintList(l *list) { - m := l.head +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(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() { - link := &list{} - link2 := &list{} + var link *node + var link2 *nodes - piscine.ListPushBack(link, "5") - piscine.ListPushBack(link, "3") - piscine.ListPushBack(link, "7") + link = listPushBack(link, 5) + link = listPushBack(link, 3) + link = listPushBack(link, 7) - piscine.ListPushBack(link2, "1") - piscine.ListPushBack(link2, "-2") - piscine.ListPushBack(link2, "4") - piscine.ListPushBack(link2, "6") + link2 = listPushBack(link2, -2) + link2 = listPushBack(link2, 4) - PrintList(SortedListMerge(link, link2)) + PrintList(piscine.SortedListMerge(link2, link)) } + ``` And its output : @@ -66,6 +77,6 @@ And its output : ```console student@ubuntu:~/piscine/test$ go build student@ubuntu:~/piscine/test$ ./test --2 -> 0 -> 0 -> 1 -> 3 -> 4 -> 5 -> 6 -> 7 -> +-2 -> 3 -> 4 -> 5 -> 7 -> student@ubuntu:~/piscine/test$ ``` diff --git a/subjects/sortedlistmerge.fr.md b/subjects/sortedlistmerge.fr.md index 7db913a68..8db19ee14 100644 --- a/subjects/sortedlistmerge.fr.md +++ b/subjects/sortedlistmerge.fr.md @@ -1,44 +1,82 @@ -## countif +## listpushback ### 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 -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 package main import ( "fmt" + 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() { - tab1 := []string{"Hello", "how", "are", "you"} - tab2 := []string{"This","1", "is", "4", "you"} - answer1 := piscine.CountIf(piscine.IsNumeric, tab1) - answer2 := piscine.CountIf(piscine.IsNumeric, tab2) - fmt.Println(answer1) - fmt.Println(answer2) + var link *node + var link2 *nodes + + link = listPushBack(link, 5) + link = listPushBack(link, 3) + 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 student@ubuntu:~/piscine/test$ go build student@ubuntu:~/piscine/test$ ./test -0 -2 +-2 -> 3 -> 4 -> 5 -> 7 -> student@ubuntu:~/piscine/test$ ```