मैं गो में नया हूं ... और मैं दिए गए स्ट्रिंग से वाक्य में अधिकतम शब्दों को गिनने के लिए इस एल्गोरिदम को अनुकूलित और/या ठीक करने के नए तरीकों की तलाश में हूं। वाक्य '?' से समाप्त हो रहा है या '!' या '।' और फ़ंक्शन को इंट> = 0 वापस करना चाहिए।

// MaxWordsInSentences - return max words in one sentences
func MaxWordsInSentences(S string) (result int) {


    r, _ := regexp.Compile("[.||?||!]")
    count := strings.Count(S, ".") + strings.Count(S, "!") + strings.Count(S, "?") // Total sentaces

    for i := 0; i < count; i++ {
        sentence := r.Split(S, count)[i]
        splitSentence := strings.Split(sentence, " ")

        var R []string
        for _, str := range splitSentence {
            if str != "" {
                R = append(R, str)
            }
        }

        if len(R) > result {
            result = len(R)
        }
    }

    return

}

उदाहरण

वाक्य => "One two three four five six seven eight. One two? One two three four five six seven eight nine? One two three! One two three four."

परिणाम के रूप में 9 लौटना चाहिए

0
ljubon 27 जिंदा 2019, 17:57

2 जवाब

सबसे बढ़िया उत्तर

आपके द्वारा प्रदान किए गए छोटे परीक्षण मामले पर, आपका एल्गोरिदम काम करता प्रतीत होता है। आपका एल्गोरिथ्म वास्तविक पाठ पर बहुत अच्छी तरह से काम नहीं करता है।


मेरे सरल एल्गोरिदम पर विचार करें:

func maxSentenceWords(s string) int {
    maxWords, nWords := 0, 0
    inWord := false
    for _, r := range s {
        switch r {
        case '.', '?', '!':
            inWord = false
            if maxWords < nWords {
                maxWords = nWords
            }
            nWords = 0
        default:
            if unicode.IsSpace(r) {
                inWord = false
            } else if inWord == false {
                inWord = true
                nWords++
            }
        }
        if maxWords < nWords {
            maxWords = nWords
        }
    }
    return maxWords
}

खेल का मैदान: https://play.golang.org/p/OD8jNW1hyAa

यह आपकी सरल परीक्षा पास करता है। एक छोटा बेंचमार्क (लोरेम इप्सम) बहुत तेज़ी से चलता है और एक लंबा बेंचमार्क (शेक्सपियर) तेज़ी से चलता है

$ go test words_test.go -run=PeterSO -v -bench=PeterSO -benchmem -timeout=5m
=== RUN   TestPeterSO
--- PASS: TestPeterSO (0.00s)
BenchmarkPeterSOL-4    300000        4027 ns/op    0 B/op    0 allocs/op
BenchmarkPeterSOS-4        20    54084832 ns/op    0 B/op    0 allocs/op
$ 

अपने जटिल एल्गोरिदम पर विचार करें:

func MaxWordsInSentences(S string) (result int) {
    r, _ := regexp.Compile("[.||?||!]")
    count := strings.Count(S, ".") + strings.Count(S, "!") + strings.Count(S, "?") // Total sentaces

    for i := 0; i < count; i++ {
        sentence := r.Split(S, count)[i]
        splitSentence := strings.Split(sentence, " ")

        var R []string
        for _, str := range splitSentence {
            if str != "" {
                R = append(R, str)
            }
        }

        if len(R) > result {
            result = len(R)
        }
    }

    return
}

खेल का मैदान: https://play.golang.org/p/MCj-XxEid73

यह आपकी सरल परीक्षा पास करता है। एक छोटा बेंचमार्क (लोरेम इप्सम) धीरे-धीरे चलता है और एक लंबा बेंचमार्क (शेक्सपियर) बहुत लंबा चलता है (5 मिनट के बाद मारा जाता है)।

$ go test words_test.go -run=Ljubon -v -bench=Ljubon -benchmem -timeout=5m
=== RUN   TestLjubon
--- PASS: TestLjubon (0.00s)
BenchmarkLjubonL-4    20000    78623 ns/op    6984 B/op   62 allocs/op
*** Test killed with quit: ran too long (6m0s).
$ 

test words_test.go:

package main

import (
    "fmt"
    "io/ioutil"
    "regexp"
    "strings"
    "testing"
    "unicode"
)

var sentences = "One two three four five six seven eight. One two? One two three four five six seven eight nine? One two three! One two three four."

var loremipsum = `
Lorem ipsum dolor sit amet, consectetur adipiscing elit, 
sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. 
Ut enim ad minim veniam, 
quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. 
Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. 
Excepteur sint occaecat cupidatat non proident, 
sunt in culpa qui officia deserunt mollit anim id est laborum.
`

var shakespeare = func() string {
    // The Complete Works of William Shakespeare by William Shakespeare
    // http://www.gutenberg.org/files/100/100-0.txt
    data, err := ioutil.ReadFile(`/home/peter/shakespeare.100-0.txt`)
    if err != nil {
        panic(err)
    }
    return string(data)
}()

func maxSentenceWords(s string) int {
    maxWords, nWords := 0, 0
    inWord := false
    for _, r := range s {
        switch r {
        case '.', '?', '!':
            inWord = false
            if maxWords < nWords {
                maxWords = nWords
            }
            nWords = 0
        default:
            if unicode.IsSpace(r) {
                inWord = false
            } else if inWord == false {
                inWord = true
                nWords++
            }
        }
        if maxWords < nWords {
            maxWords = nWords
        }
    }
    return maxWords
}

func TestPeterSO(t *testing.T) {
    want := 9
    got := maxSentenceWords(sentences)
    if got != want {
        t.Errorf("want %d; got %d", want, got)
    }
}

func BenchmarkPeterSOL(b *testing.B) {
    for N := 0; N < b.N; N++ {
        maxSentenceWords(loremipsum)
    }
}

func BenchmarkPeterSOS(b *testing.B) {
    for N := 0; N < b.N; N++ {
        maxSentenceWords(shakespeare)
    }
}

// MaxWordsInSentences - return max words in one sentences
func MaxWordsInSentences(S string) (result int) {
    r, _ := regexp.Compile("[.||?||!]")
    count := strings.Count(S, ".") + strings.Count(S, "!") + strings.Count(S, "?") // Total sentaces

    for i := 0; i < count; i++ {
        sentence := r.Split(S, count)[i]
        splitSentence := strings.Split(sentence, " ")

        var R []string
        for _, str := range splitSentence {
            if str != "" {
                R = append(R, str)
            }
        }

        if len(R) > result {
            result = len(R)
        }
    }

    return
}

func TestLjubon(t *testing.T) {
    want := 9
    got := MaxWordsInSentences(sentences)
    if got != want {
        t.Errorf("want %d; got %d", want, got)
    }
}

func BenchmarkLjubonL(b *testing.B) {
    for N := 0; N < b.N; N++ {
        MaxWordsInSentences(loremipsum)
    }
}

func BenchmarkLjubonS(b *testing.B) {
    for N := 0; N < b.N; N++ {
        MaxWordsInSentences(shakespeare)
    }
}

func main() {
    s := "One two three four five six seven eight. One two? One two three four five six seven eight nine? One two three! One two three four."
    max := maxSentenceWords(s) // 9
    fmt.Println(max)
    s = "One two three! One two three four"
    max = maxSentenceWords(s) // 4
    fmt.Println(max)
    s = loremipsum
    max = maxSentenceWords(s)
    fmt.Println(max)
}

मैं इसे उपकरण का नियम कहता हूं, और इसे इस प्रकार तैयार किया जा सकता है: एक छोटे लड़के को एक हथौड़ा दें, और वह पाएगा कि उसे जो कुछ भी मिलता है उसे तेज़ करने की आवश्यकता होती है।

अब्राहम कापलान, द कंडक्ट ऑफ इंक्वायरी: मेथोडोलॉजी फॉर बिहेवियरल साइंस, 1964, पेज 28।


क्या गो regexp आपके हथौड़े को किसी भी और सभी टेक्स्ट को पाउंड करने के लिए पैकेज करता है?

2
peterSO 29 जिंदा 2019, 15:42
func MaxWordsInSentences(s string) (result int) {
    var offset, wordCount int
    for i, r := range s {
        switch r {
        default:
            if unicode.IsSpace(r) {
                wordCount++
            }

        case '.', '?', '!':
            if wordCount > result {
                result = wordCount
            }

            wordCount = 1
        }
    }

    return
}
-1
Pascal de Kloe 27 जिंदा 2019, 21:41