[Go] Array and string - Reverse Words in a String III

Given a string s, reverse the order of characters in each word within a sentence while still preserving whitespace and initial word order.

 

Example 1:

Input: s = "Let's take LeetCode contest"
Output: "s'teL ekat edoCteeL tsetnoc"

Example 2:

Input: s = "God Ding"
Output: "doG gniD"

 

Constraints:

• 1 <= s.length <= 5 * 104
• s contains printable ASCII characters.
• s does not contain any leading or trailing spaces.
• There is at least one word in s.
• All the words in s are separated by a single space.

My code

func reverseWords(s string) string {
	l := len(s)
	words := []rune(s)
	for i := 0; i < l; i++ {
		if words[i] == ' ' {
			continue
		}
		j := i
		for j < l && words[j] != ' ' {
			j++
		}
		reverse(words, i, j-1)
		i = j
	}
	return string(words)
}

func reverse(words []rune, l, r int) {
	for l < r {
		words[l], words[r] = words[r], words[l]
		l++
		r--
	}
}

https://go.dev/play/p/twN3mkeBUbC

• I converted string to rune for swaping strings.
• for loop will run until it reaches to end.
• When words[i] is not space, j will have a value of i.
• Next for loop will run until j meets space.
• if find space, reverse function will work with i and j-1(for removing space)
• after reverse, i will have j value.
•  

sample 0 ms submission & sample 6300 KB submission

func reverseWords(s string) string {
    strByte := []byte(s)
    l := 0
    r := 0
    for ii := 0; ii < len(strByte); ii++ {
        if strByte[ii] == ' ' {
            r  = ii - 1
            revWord(strByte, l, r)
            l = ii+1
        }
    }
    // rev last word
    revWord(strByte, l, len(strByte) - 1)
    return string(strByte)
}

func revWord(s []byte, l, r int) {
            for l < r {
                tmp := s[l]
                s[l] = s[r]
                s[r] = tmp
                l++
                r--
            }
    
}

sample 2 ms submission

func reverseWords(s string) string {
    arr := strings.Split(s, " ")
        
    for i := range arr {
        b := []byte(arr[i])
        reverseString(b)
        arr[i] = string(b)
    }
    
    return strings.Join(arr, " ")
}

func reverseString(s []byte) {
    for i, j := 0, len(s) - 1; i <= j; i, j = i+1,j-1 {
        s[i], s[j] = s[j],s[i]
    }
}

sample 3 ms submission

func reverseWords(s string) string {
    r := []rune(s)
    i, j := 0, 0
    for j < len(s) {
        if r[j] != ' ' {
            j++
            continue
        }
        c := j-1
        for i < c {
            r[i], r[c] = r[c],r[i]
            i++
            c--
        }
        j++
        i = j
    }
        c := j-1
        for i < c {
            r[i], r[c] = r[c],r[i]
            i++
            c--
        }
    return string(r)
}

sample 4 ms submission

func reverseString(s []byte, start, end int) {
	mid := (end - start) / 2
	for i := 0; i <= mid; i++ {
		s[start+i], s[end-i] = s[end-i], s[start+i]

	}
}

func reverseWords(s string) string {
	str := []byte(s)
	start := 0

	for i := 0; i < len(str); i++ {
		if str[i] == ' ' {
			reverseString(str, start, i-1)
			start = i + 1
		}
	}
	reverseString(str, start, len(str)-1)
	return string(str)
}

sample 5 ms submission

import "strings"

func reverseWords(s string) string {
    var answer strings.Builder
    startOfWord := 0
    for i, c := range s {
        if c == ' ' {
            for j := i - 1; j >= startOfWord; j-- {
                answer.WriteByte(s[j])
            }
            answer.WriteByte(' ')
            startOfWord = i + 1
        }
    }
    
    for j := len(s) - 1; j >= startOfWord; j-- {
        answer.WriteByte(s[j])
    }
    
    return answer.String()
}

sample 6 ms submission

func reverseWords(s string) string {
    splitted := strings.Split(s, " ")
    for i, v := range splitted {
        splitted[i] = reverseString(v)
    }
    
    return strings.Join(splitted, " ")
}

func reverseString(s string) string {
    res := []rune(s)
    for i, j := 0, len(s) - 1; i < j; i, j = i+1, j-1 {
        res[i], res[j] = res[j], res[i]
    }
    
    return string(res)
}

• This code looks simple.

sample 7 ms submission & sample 6400 KB submission

func reverseWords(s string) string {
    var res bytes.Buffer
    i := 0
    for i < len(s) {
        if s[i] == ' ' {
            res.WriteByte(s[i])
            i++
            continue
        }
        j := i
        for j < len(s) && s[j] != ' ' {
            j++
        }
        for k := j - 1; k >= i; k-- {
            res.WriteByte(s[k])
        } 
        i = j
    }
    return res.String()
}

sample 6200 KB submission

func reverseWords(s string) string {
    strs := strings.Split(s," ")
    for i,val := range strs{
        strs[i] = reverseString([]byte(val))
    }
    return strings.Join(strs," ")
}

func reverseString(s []byte)string{
    left,right := 0,len(s)-1
    for left <= right{
        s[left],s[right] = s[right],s[left]
        left ++
        right --
    }
    return string(s)
    
}

sample 6500 KB submission

func reverseWords(s string) string {
    b:=[]byte(s)
    startPos:=0
    for pos,char:=range s{
        if char == ' '{
            reverseWord(b,startPos,pos)        
            startPos=pos+1
        }
    }
    reverseWord(b,startPos,len(s))        

    return string(b)
}

func reverseWord(b []byte, startPos, endPos int){
    for startPos<endPos{
      b[startPos],b[endPos-1]=b[endPos-1],b[startPos]  
      startPos++
    endPos--
        
    }     
}

sample 6600 KB submission

func reverseWords(s string) string {
	l := 0
	var ss []byte

	for i, v := range s {
		if v == ' ' {
			ss = append(ss, rev(s[l:i])...)
			ss = append(ss, ' ')
			l = i + 1
		}
	}
	ss = append(ss, rev(s[l:])...)

	return string(ss)
}

func rev(s string) []byte {
	ss := []byte(s)

	for i := 0; i < len(ss)/2; i++ {
		ss[i], ss[len(ss)-1-i] = ss[len(ss)-1-i], ss[i]
	}

	return ss
}

sample 6700 KB submission

func reverse(s string) string {
    rns := []rune(s) // convert to rune
    for i, j := 0, len(rns)-1; i < j; i, j = i+1, j-1 {
  
        rns[i], rns[j] = rns[j], rns[i]
    }
  
    return string(rns)
}

func reverseWords(s string) string {
    arr := strings.Split(s, " ")
    
    for i := 0; i < len(arr); i++ {
        arr[i] = reverse(arr[i])
    }
    
    return strings.Join(arr, " ")
}

sample 6800 KB submission

func reverseWords(s string) string {
    b := bytes.Buffer{}
    i := 0
    
    for i < len(s) {
        j := i
        for j < len(s) {
            if s[j] == ' ' {
                break
            }
            j++
        }
        
        for r := j-1; r >= i; r-- {
            b.WriteByte(s[r])
        }
        
        i = j + 1
        if i < len(s) {
            b.WriteByte(' ')   
        }
    }
    
    return b.String()
}