non-greedy повторители

Програмиране с Go

Курс във Факултета по Математика и Информатика към СУ

Решение на Log Parsing от Ясен Висулчев

Обратно към всички решения

Към профила на Ясен Висулчев

Резултати

  • 10 точки от тестове
  • 0 бонус точки
  • 10 точки общо
  • 10 успешни тест(а)
  • 0 неуспешни тест(а)

Код

// Written by Yasen Visulchev
// 21/10/2014
// http://fmi.golang.bg/users/18
package main
// Map maps every member of data to an output, as defined by mutator.
func Map(data []string, mutator func(string) string) []string {
result := make([]string, len(data), len(data))
for i, value := range data {
result[i] = mutator(value)
}
return result
}
// Filter filters data to return only the members for which the predicate returns true.
func Filter(data []string, predicate func(string) bool) []string {
result := make([]string, 0, len(data))
for _, value := range data {
if predicate(value) {
result = append(result, value)
}
}
return result
}
// Reduce reduces the data into a single string with the help of the combinator.
func Reduce(data []string, combinator func(string, string) string) string {
if len(data) == 0 {
return ""
}
result := data[0]
for i := 1; i < len(data); i++ {
result = combinator(result, data[i])
}
return result
}
// Any checks whether for any member of data predicate returns true.
func Any(data []string, predicate func(string) bool) bool {
for _, value := range data {
if predicate(value) {
return true
}
}
return false
}
// All checks whether for all members of data predicate returns true.
func All(data []string, predicate func(string) bool) bool {
if len(data) == 0 {
return true
}
for _, value := range data {
if !predicate(value) {
return false
}
}
return true
}

Лог от изпълнението

PASS
ok  	_/tmp/d20141023-10368-pppyx2	0.011s
PASS
ok  	_/tmp/d20141023-10368-pppyx2	0.011s
PASS
ok  	_/tmp/d20141023-10368-pppyx2	0.011s
PASS
ok  	_/tmp/d20141023-10368-pppyx2	0.012s
PASS
ok  	_/tmp/d20141023-10368-pppyx2	0.011s
PASS
ok  	_/tmp/d20141023-10368-pppyx2	0.011s
PASS
ok  	_/tmp/d20141023-10368-pppyx2	0.011s
PASS
ok  	_/tmp/d20141023-10368-pppyx2	0.011s
PASS
ok  	_/tmp/d20141023-10368-pppyx2	0.011s
PASS
ok  	_/tmp/d20141023-10368-pppyx2	0.011s

История (7 версии и 9 коментара)

Ясен обнови решението на 17.10.2014 12:35 (преди над 3 години)

+// Written by Yasen Visulchev
+// 17/10/2014
+// http://fmi.golang.bg/users/18
+package main
+
+// Map maps every member of data to an output, as defined by mutator.
+func Map(data []string, mutator func(string) string) []string {
+
+ var result []string
+ result = make([]string, len(data), len(data))
+ for i, value := range data {
+ result[i] = mutator(value)
+ }
+ return result
+}
+
+// Filter filters data to return only the members for which the predicate returns true.
+func Filter(data []string, predicate func(string) bool) []string {
+ var result []string
+ result = make([]string, 0, len(data))
+ j := 0
+ for _, value := range data {
+ if predicate(value) {
+ result[j] = value
+ j++
+ }
+ }
+ return result
+}
+
+// Reduce reduces the data into a single string with the help of the combinator.
+func Reduce(data []string, combinator func(string, string) string) string {
+ result := ""
+ for _, value := range data {
+ result = combinator(result, value)
+ }
+ return result
+}
+
+// Any checks whether for any member of data predicate returns true.
+func Any(data []string, predicate func(string) bool) bool {
+ for _, value := range data {
+ if predicate(value) {
+ return true
+ }
+ }
+ return false
+}
+
+// All checks whether for all members of data predicate returns true.
+func All(data []string, predicate func(string) bool) bool {
+ for _, value := range data {
+ if !predicate(value) {
+ return false
+ }
+ }
+ return true
+}

Тези тестове така и не разбрах "как" се пускат :(

Това, което правех до сега е: правя си нов файл, namename_test.go В него са тестовите функции. Но той не може да достъпи функциите от моя файл - така че ги копирам в него. Правилно ли е така?

Някакси ще ги направя, но поне когато писах задачите, тестовете не бяха допълнени - имаше само две функции, нито една от които Тест функция.

Всичко ще оправя както искате! Само ми кажете как да си правя тестовете, моля ви се! :v

Минава тестовете!!!

Хиляди благодарности за упътването! :)

А за двете функции - където е тест функцията сега в гитхъб бяха само първите две функции. Явно някой още ги е редактирал!

Ясен обнови решението на 17.10.2014 21:03 (преди над 3 години)

// Written by Yasen Visulchev
// 17/10/2014
// http://fmi.golang.bg/users/18
package main
// Map maps every member of data to an output, as defined by mutator.
func Map(data []string, mutator func(string) string) []string {
- var result []string
- result = make([]string, len(data), len(data))
- for i, value := range data {
- result[i] = mutator(value)
- }
- return result
+ result := make([]string, len(data), len(data))
+ for i, value := range data {
+ result[i] = mutator(value)
+ }
+ return result
}
// Filter filters data to return only the members for which the predicate returns true.
func Filter(data []string, predicate func(string) bool) []string {
- var result []string
- result = make([]string, 0, len(data))
- j := 0
- for _, value := range data {
- if predicate(value) {
- result[j] = value
- j++
- }
- }
- return result
+ result := make([]string, 0, len(data))
+ j := 0
+ for _, value := range data {
+ if predicate(value) {
+ result[j] = value
+ j++
+ }
+ }
+ return result
}
// Reduce reduces the data into a single string with the help of the combinator.
func Reduce(data []string, combinator func(string, string) string) string {
- result := ""
- for _, value := range data {
- result = combinator(result, value)
- }
- return result
+ result := ""
+ for _, value := range data {
+ result = combinator(result, value)
+ }
+ return result
}
// Any checks whether for any member of data predicate returns true.
func Any(data []string, predicate func(string) bool) bool {
- for _, value := range data {
- if predicate(value) {
- return true
- }
- }
- return false
+ for _, value := range data {
+ if predicate(value) {
+ return true
+ }
+ }
+ return false
}
// All checks whether for all members of data predicate returns true.
func All(data []string, predicate func(string) bool) bool {
- for _, value := range data {
- if !predicate(value) {
+ for _, value := range data {
- return false
+ if !predicate(value) {
- }
+ return false
- }
+ }
- return true
+ }
-}
+ return true
+}

Ясен обнови решението на 19.10.2014 13:47 (преди над 3 години)

// Written by Yasen Visulchev
// 17/10/2014
// http://fmi.golang.bg/users/18
package main
// Map maps every member of data to an output, as defined by mutator.
func Map(data []string, mutator func(string) string) []string {
result := make([]string, len(data), len(data))
for i, value := range data {
result[i] = mutator(value)
}
return result
}
// Filter filters data to return only the members for which the predicate returns true.
func Filter(data []string, predicate func(string) bool) []string {
result := make([]string, 0, len(data))
j := 0
for _, value := range data {
if predicate(value) {
result[j] = value
j++
}
}
return result
}
// Reduce reduces the data into a single string with the help of the combinator.
func Reduce(data []string, combinator func(string, string) string) string {
result := ""
for _, value := range data {
result = combinator(result, value)
}
return result
}
// Any checks whether for any member of data predicate returns true.
func Any(data []string, predicate func(string) bool) bool {
for _, value := range data {
if predicate(value) {
return true
}
}
return false
}
// All checks whether for all members of data predicate returns true.
func All(data []string, predicate func(string) bool) bool {
+ if len(data) == 0 {
+ return false
+ }
for _, value := range data {
if !predicate(value) {
return false
}
}
return true
-}
+}
+
+
+/*
+//Test function implemented in solution_test.go to test for null inputs
+func TestNullInput(t *testing.T) {
+ inputSlice := []string{}
+ outputSlice := []string{}
+ outputString := ""
+ testOutput(t, Map(inputSlice, length), outputSlice)
+ testOutput(t, Filter(inputSlice, func(s string) bool {return false}), outputSlice)
+ if Reduce(inputSlice, concat) != outputString {
+ t.Errorf("Reduce null input, realized output of %v", Reduce(inputSlice, concat))
+ }
+ if Any(inputSlice, isNumber) {
+ t.Errorf("Any null input: got true")
+ }
+ if All(inputSlice, isNotNumber) {
+ t.Errorf("All null input: got true")
+ }
+}
+*/

Ясен обнови решението на 19.10.2014 13:51 (преди над 3 години)

// Written by Yasen Visulchev
// 17/10/2014
// http://fmi.golang.bg/users/18
package main
// Map maps every member of data to an output, as defined by mutator.
func Map(data []string, mutator func(string) string) []string {
- result := make([]string, len(data), len(data))
- for i, value := range data {
- result[i] = mutator(value)
- }
- return result
+ result := make([]string, len(data), len(data))
+ for i, value := range data {
+ result[i] = mutator(value)
+ }
+ return result
}
// Filter filters data to return only the members for which the predicate returns true.
func Filter(data []string, predicate func(string) bool) []string {
- result := make([]string, 0, len(data))
- j := 0
- for _, value := range data {
- if predicate(value) {
- result[j] = value
- j++
- }
- }
- return result
+ result := make([]string, 0, len(data))
+ j := 0
+ for _, value := range data {
+ if predicate(value) {
+ result[j] = value
+ j++
+ }
+ }
+ return result
}
// Reduce reduces the data into a single string with the help of the combinator.
func Reduce(data []string, combinator func(string, string) string) string {
- result := ""
- for _, value := range data {
- result = combinator(result, value)
- }
- return result
+ result := ""
+ for _, value := range data {
+ result = combinator(result, value)
+ }
+ return result
}
// Any checks whether for any member of data predicate returns true.
func Any(data []string, predicate func(string) bool) bool {
- for _, value := range data {
- if predicate(value) {
- return true
- }
- }
- return false
+ for _, value := range data {
+ if predicate(value) {
+ return true
+ }
+ }
+ return false
}
// All checks whether for all members of data predicate returns true.
func All(data []string, predicate func(string) bool) bool {
- if len(data) == 0 {
+ if len(data) == 0 {
+ return false
+ }
+ for _, value := range data {
+ if !predicate(value) {
return false
}
- for _, value := range data {
- if !predicate(value) {
- return false
- }
- }
- return true
+ }
+ return true
}
-
/*
-//Test function implemented in solution_test.go to test for null inputs
+//Test function to test output with null inputs
func TestNullInput(t *testing.T) {
inputSlice := []string{}
outputSlice := []string{}
outputString := ""
testOutput(t, Map(inputSlice, length), outputSlice)
testOutput(t, Filter(inputSlice, func(s string) bool {return false}), outputSlice)
if Reduce(inputSlice, concat) != outputString {
t.Errorf("Reduce null input, realized output of %v", Reduce(inputSlice, concat))
}
if Any(inputSlice, isNumber) {
t.Errorf("Any null input: got true")
}
if All(inputSlice, isNotNumber) {
t.Errorf("All null input: got true")
}
}
*/

Не се притеснявай за версиите - не ги четем всичките :), даже и нотификации не получаваме(за съжаление).

Според мен Filter-а ти ще гърми.

За All-а - връща true (но понеже съм съгласен че в условието не е казано както трябва - точно за това няма да отнемаме точки :)).

Прочети условието за Reduce имаш проблеми във всички случаи освен len(data) == 0

Ясен обнови решението на 21.10.2014 10:29 (преди над 3 години)

// Written by Yasen Visulchev
// 17/10/2014
// http://fmi.golang.bg/users/18
package main
// Map maps every member of data to an output, as defined by mutator.
func Map(data []string, mutator func(string) string) []string {
result := make([]string, len(data), len(data))
for i, value := range data {
result[i] = mutator(value)
}
return result
}
// Filter filters data to return only the members for which the predicate returns true.
func Filter(data []string, predicate func(string) bool) []string {
- result := make([]string, 0, len(data))
j := 0
for _, value := range data {
if predicate(value) {
+ j++
+ }
+ }
+ result := make([]string, j, j)
+ j = 0
+ for _, value := range data {
+ if predicate(value) {
result[j] = value
j++
}
}
return result
}
// Reduce reduces the data into a single string with the help of the combinator.
func Reduce(data []string, combinator func(string, string) string) string {
- result := ""
- for _, value := range data {
- result = combinator(result, value)
+ if len(data) == 0 {
+ return ""
}
- return result
+ for i := 1; i < len(data); i++ {
+ data[0] = combinator(data[0], data[i])
+ }
+ return data[0]
}
// Any checks whether for any member of data predicate returns true.
func Any(data []string, predicate func(string) bool) bool {
for _, value := range data {
if predicate(value) {
return true
}
}
return false
}
// All checks whether for all members of data predicate returns true.
func All(data []string, predicate func(string) bool) bool {
if len(data) == 0 {
- return false
+ return true
}
for _, value := range data {
if !predicate(value) {
return false
}
}
return true
}
/*
//Test function to test output with null inputs
func TestNullInput(t *testing.T) {
- inputSlice := []string{}
- outputSlice := []string{}
- outputString := ""
- testOutput(t, Map(inputSlice, length), outputSlice)
- testOutput(t, Filter(inputSlice, func(s string) bool {return false}), outputSlice)
- if Reduce(inputSlice, concat) != outputString {
- t.Errorf("Reduce null input, realized output of %v", Reduce(inputSlice, concat))
- }
- if Any(inputSlice, isNumber) {
- t.Errorf("Any null input: got true")
- }
- if All(inputSlice, isNotNumber) {
- t.Errorf("All null input: got true")
- }
+ inputSlice := []string{}
+ outputSlice := []string{}
+ outputString := ""
+ testOutput(t, Map(inputSlice, length), outputSlice)
+ testOutput(t, Filter(inputSlice, func(s string) bool {return false}), outputSlice)
+ if Reduce(inputSlice, concat) != outputString {
+ t.Errorf("Reduce null input, realized output of %v", Reduce(inputSlice, concat))
+ }
+ if Any(inputSlice, isNumber) {
+ t.Errorf("Any null input: got true")
+ }
+ if All(inputSlice, isNotNumber) {
+ t.Errorf("All null input: got true")
+ }
}
-*/
+*/

Ясен обнови решението на 21.10.2014 10:36 (преди над 3 години)

// Written by Yasen Visulchev
// 17/10/2014
// http://fmi.golang.bg/users/18
package main
// Map maps every member of data to an output, as defined by mutator.
func Map(data []string, mutator func(string) string) []string {
result := make([]string, len(data), len(data))
for i, value := range data {
result[i] = mutator(value)
}
return result
}
// Filter filters data to return only the members for which the predicate returns true.
func Filter(data []string, predicate func(string) bool) []string {
- j := 0
+ result := make([]string, 0, len(data))
for _, value := range data {
if predicate(value) {
- j++
- }
- }
- result := make([]string, j, j)
- j = 0
- for _, value := range data {
- if predicate(value) {
- result[j] = value
- j++
+ result = append(result, value)
}
}
return result
}
// Reduce reduces the data into a single string with the help of the combinator.
func Reduce(data []string, combinator func(string, string) string) string {
if len(data) == 0 {
return ""
}
for i := 1; i < len(data); i++ {
data[0] = combinator(data[0], data[i])
}
return data[0]
}
// Any checks whether for any member of data predicate returns true.
func Any(data []string, predicate func(string) bool) bool {
for _, value := range data {
if predicate(value) {
return true
}
}
return false
}
// All checks whether for all members of data predicate returns true.
func All(data []string, predicate func(string) bool) bool {
if len(data) == 0 {
return true
}
for _, value := range data {
if !predicate(value) {
return false
}
}
return true
}
/*
//Test function to test output with null inputs
func TestNullInput(t *testing.T) {
inputSlice := []string{}
outputSlice := []string{}
outputString := ""
testOutput(t, Map(inputSlice, length), outputSlice)
testOutput(t, Filter(inputSlice, func(s string) bool {return false}), outputSlice)
if Reduce(inputSlice, concat) != outputString {
t.Errorf("Reduce null input, realized output of %v", Reduce(inputSlice, concat))
}
if Any(inputSlice, isNumber) {
t.Errorf("Any null input: got true")
}
if All(inputSlice, isNotNumber) {
t.Errorf("All null input: got true")
}
}
*/

Благодаря за heads up-a. Сложих All да връща true при null input.

Filter имаше грешка при инициализацията на slice-а. Имах грешната идея, че slice-a автоматично се разширява при индексиране на len+1 елемент. Затова сега използвам append.

Reduce си работеше супер, само че в условието пише:

   ...За начална стойност ползвайте първата стойност от масива.

Което ми се струваше леко неясно, поради което съм игнорирал инструкцията първоначално. Този път я тълкувах буквално. Комбинаторът работи върху първия елемент от входния слайс и Reduce връща този променен първи елемент. Надявам се, че това е било условието!

Човек може сам да си джитка до края на времето, особено когато няма кой да направи един хубав proofread. Благодаря за което!

Поздрави!

Както казах - не разбрах какъв беше проблемът с Reduce от самото начало, тъй като си минаваше всичките тестове (и нулевия)... Реших, че гледате дали са ви променени входните данни - грешно.

Връщам го както си беше, пък каквото сабя покаже! :)

Ясен обнови решението на 21.10.2014 12:11 (преди над 3 години)

// Written by Yasen Visulchev
-// 17/10/2014
+// 21/10/2014
// http://fmi.golang.bg/users/18
package main
// Map maps every member of data to an output, as defined by mutator.
func Map(data []string, mutator func(string) string) []string {
result := make([]string, len(data), len(data))
for i, value := range data {
result[i] = mutator(value)
}
return result
}
// Filter filters data to return only the members for which the predicate returns true.
func Filter(data []string, predicate func(string) bool) []string {
result := make([]string, 0, len(data))
for _, value := range data {
if predicate(value) {
result = append(result, value)
}
}
return result
}
// Reduce reduces the data into a single string with the help of the combinator.
func Reduce(data []string, combinator func(string, string) string) string {
if len(data) == 0 {
return ""
}
+ result := data[0]
for i := 1; i < len(data); i++ {
- data[0] = combinator(data[0], data[i])
+ result = combinator(result, data[i])
}
- return data[0]
+ return result
}
// Any checks whether for any member of data predicate returns true.
func Any(data []string, predicate func(string) bool) bool {
for _, value := range data {
if predicate(value) {
return true
}
}
return false
}
// All checks whether for all members of data predicate returns true.
func All(data []string, predicate func(string) bool) bool {
if len(data) == 0 {
return true
}
for _, value := range data {
if !predicate(value) {
return false
}
}
return true
}
-
-/*
-//Test function to test output with null inputs
-func TestNullInput(t *testing.T) {
- inputSlice := []string{}
- outputSlice := []string{}
- outputString := ""
- testOutput(t, Map(inputSlice, length), outputSlice)
- testOutput(t, Filter(inputSlice, func(s string) bool {return false}), outputSlice)
- if Reduce(inputSlice, concat) != outputString {
- t.Errorf("Reduce null input, realized output of %v", Reduce(inputSlice, concat))
- }
- if Any(inputSlice, isNumber) {
- t.Errorf("Any null input: got true")
- }
- if All(inputSlice, isNotNumber) {
- t.Errorf("All null input: got true")
- }
-}
-*/