golang,Code片段,代码实例,代码示例,代码片段库

golang 选取第我个数

在O（N）的时间内找到第我大的数

randSelect.go

import "math/rand"

func partition(A []int, p, r int) int {
	x, i := A[r-1], p
	for j := p; j < r-1; j++ {
		if A[j] <= x {
			A[i], A[j] = A[j], A[i]
			i++
		}
	}
	A[i], A[r-1] = A[r-1], A[i]
	return i
}

func randPartition(A []int, p, r int) int {
	i := rand.Intn(r-p) + p
	A[i], A[r-1] = A[r-1], A[i]
	return partition(A, p, r)
}

// RandSelect return the ith element O(n)
func RandSelect(A []int, p, r, i int) int {
	if p+1 == r {
		return A[p]
	}
	q := randPartition(A, p, r)
	k := q - p + 1
	if i == k {
		return A[q]
	} else if i < k {
		return RandSelect(A, p, q, i)
	} else {
		return RandSelect(A, q+1, r, i-k)
	}

}

golang 最大最小值

minMax.go

// MinMax return min and max O(1.5n)
func MinMax(A []int) (min int, max int) {
	if len(A) < 1 {
		return 0, 0
	}
	min, max = A[0], A[0]
	mi, ma := 0, 0
	for i := 1; i < len(A)-1; i += 2 {
		if A[i] > A[i+1] {
			mi, ma = A[i+1], A[i]
		} else {
			mi, ma = A[i], A[i+1]
		}
		if ma > max {
			max = ma
		}
		if mi < min {
			min = mi
		}
	}
	return min, max
}

golang 最大值

max.go


func Max(A []int) int {
	if len(A) < 1 {
		return 0
	}
	max := A[0]
	for _, a := range A {
		if a > max {
			max = a
		}
	}
	return max
}

golang 最小值

min.go

func Min(A []int) int {
	if len(A) < 1 {
		return 0
	}
	min := A[0]
	for _, a := range A {
		if a < min {
			min = a
		}
	}
	return min
}

golang 基数排序

radixSort.go

// CountSortForRadixSort O(n)
func CountSortForRadixSort(A []int, d int, k int) {
	dNum := 1
	for i := 0; i < d; i++ {
		dNum *= k
	}
	c := make([]int, 11)
	for _, a := range A {
		c[a/dNum%k]++
	}
	for i := 1; i < 11; i++ {
		c[i] += c[i-1]
	}
	b := make([]int, len(A))
	for j := len(A) - 1; j >= 0; j-- {
		c[A[j]/dNum%k]--
		b[c[A[j]/dNum%k]] = A[j]
	}
	for i := range A {
		A[i] = b[i]
	}
}

// RadixSort O(d(n + k))
func RadixSort(A []int, d int, k int) {
	for i := 1; i < d+1; i++ {
		CountSortForRadixSort(A, i, k)
	}
}

golang 计数排序

countSort.go


// CountSort O(n + k)
func CountSort(A []int, k int) {
	c := make([]int, k+1)
	for _, a := range A {
		c[a]++
	}
	for i := 1; i < k+1; i++ {
		c[i] += c[i-1]
	}
	b := make([]int, len(A))
	for j := len(A) - 1; j >= 0; j-- {
		c[A[j]]--
		b[c[A[j]]] = A[j]
	}
	for i := range A {
		A[i] = b[i]
	}
}

golang 桶排序

bucketSort.go

// InsertionSortForBucketSort O(n^2)
func InsertionSortForBucketSort(A []float64) {
	for j := 1; j < len(A); j++ {
		key, i := A[j], j-1
		for i >= 0 && A[i] > key {
			A[i+1] = A[i]
			i--
		}
		A[i+1] = key
	}
}

// BucketSort O(n)
func BucketSort(A []float64) {
	n := len(A)
	B := make([][]float64, n)
	fN := float64(n)
	for _, a := range A {
		B[int(a * fN)] = append(B[int(a * fN)], a)
	}
	for _, b := range B {
		InsertionSortForBucketSort(b)
	}
	i := 0
	for j:= 0; j < n; j++ {
		m := len(B[j])
		for k := 0; k < m; k++ {
			A[i] = B[j][k]
			i++
		}
	}
}

golang 使用编码自动检测读取文本文件

使用regexp模式替换文本文件中的子字符串

main.py

import sys
import re
import locale
import chardet # pip install chardet

print('locale pref encoding = ', locale.getpreferredencoding())
print('sys filesyste encoding = ', sys.getfilesystemencoding())

PROTOCOL = "https"
IP_PORT = "localhost"
TARGET = "target.js"

def print_help():
	print('Error: Bad parameters')
	print('Use: <program> <target> <ip>[:port] [http/https]')
	print('e.g.: main.py main.chunk.js 172.16.0.1 https')
	print('e.g.: main.py main.chunk.js 172.16.0.1:8080 https')
	exit(1)

if len(sys.argv) == 3: # only ip address
	TARGET = sys.argv[1]
	IP_PORT = sys.argv[2]

elif len(sys.argv) == 4: # ip address and http protocol
	TARGET = sys.argv[1]
	IP_PORT = sys.argv[2]
	PROTOCOL = sys.argv[3]

else: # wrong amount of params
	print_help()

# Read in the file
filename = TARGET
pattern = r'http.{0,1}://.*?/api'

with open(filename, 'rb') as file:
	filedata = file.read()

enc = chardet.detect(filedata)['encoding']
filedata = filedata.decode(enc) # decode bytes to string with enc

# Replace the target string
filedata = re.sub(pattern, f"{PROTOCOL}://{IP_PORT}/api", filedata)

# Write the file out again
with open(filename, 'w') as file:
	file.write(filedata)

main.rb

PROTOCOL = "https"
IP_PORT = "localhost"
TARGET = "target.js"

def print_help()
	puts 'Error: Bad parameters'
	puts 'Use: <program> <target> <ip>[:port] [http/https]'
	puts 'e.g.: main.py main.chunk.js 172.16.0.1 https'
	puts 'e.g.: main.py main.chunk.js 172.16.0.1:8080 https'
	exit 1
end

filename = 'main.chunk.js'
file = File.open(filename, "rb")
file = file.read

p file.encoding.name
file = file.encode('utf-8', 'utf-16')

value = file.sub(/http/, "HTTP")

File.write('output.js', value)

main.cs

using System;
using System.IO;
using System.Text.RegularExpressions;

namespace IPchanger
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                string filename = args[0];
                string strIpPort = args[1];

                string protocol = "https";
                if (args.Length > 2)
                    protocol = args[2];

                string data = File.ReadAllText(filename);
                string pattern = "http.{0,1}://.*?/api";
                string newData = Regex.Replace(data, pattern, string.Concat(protocol, "://", strIpPort, "/api"));
                File.WriteAllText(filename, newData);
            } catch (Exception ex) {
                Console.WriteLine(ex);
            }
        }
    }
}

main.go

package main

import (
    "fmt"
	"io/ioutil"
	"regexp"
	"unicode/utf8"
	"golang.org/x/text/transform"
	"golang.org/x/text/encoding/unicode"
)

func log(line string) {
	fmt.Println(line)
}

func main() {
    rawdata, err := ioutil.ReadFile("main.chunk.js") // just pass the file name
    if err != nil {
        fmt.Print(err)
    }

	// bs_UTF16LE, _, _ := transform.Bytes(unicode.UTF16(unicode.LittleEndian, unicode.IgnoreBOM).NewEncoder(), rawdata))
	// bs_UTF16BE, _, _ := transform.Bytes(unicode.UTF16(unicode.BigEndian, unicode.IgnoreBOM).NewEncoder(), rawdata))
	//bs_UTF8LE, _, _ := transform.Bytes(unicode.UTF16(unicode.LittleEndian, unicode.IgnoreBOM).NewDecoder(), bs_UTF16LE)
	// bs_UTF8BE, _, _ := transform.Bytes(unicode.UTF16(unicode.BigEndian, unicode.IgnoreBOM).NewDecoder(), bs_UTF16BE)
	
	utf8filedata, _, _ := transform.Bytes(unicode.UTF16(unicode.LittleEndian, unicode.IgnoreBOM).NewDecoder(), rawdata)
	strfile := string(utf8filedata)

	pattern := "http.{0,1}://.*?/api"
	fmt.Println(utf8.ValidString(strfile))   
	r := regexp.MustCompile(pattern)
	if r.MatchString(strfile) {
		log("true")
	} else {
		log("false")
	}
	fmt.Println(r.FindString(strfile)) 
}

golang 6 Z字形变换

- 设一个数组，元素是strings.Builder，长度是入参数字n，进行初始化 - 设置curRow，标记当前行 - 设goDown bool变量，标记row运动方向 - 遍历字符串s - 在curRow行写入字符c - 判断curRow，如果是第0行，或者n-1行，goingDown反转 - 如果goingDown ，curRow ++，否则 - - 最后整合所有行的内容，返回 -

convert.go

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "LEETCODEISHIRING"
	fmt.Println(convert(s, 4))
}
func convert(s string, numRows int) string {
	if numRows == 1 {
		return s
	}
	rows := make([]strings.Builder, 0)
	for i := 0; i < numRows; i++ {
		rows = append(rows, strings.Builder{})
	}
	curRow := 0
	goingDown := false

	for _, c := range s {
		rows[curRow].WriteByte(byte(c))
		if curRow == 0 || curRow == numRows-1 {
			goingDown = !goingDown
		}
		if goingDown {
			curRow++
		} else {
			curRow--
		}
	}
	ret := strings.Builder{}
	for _, v := range rows {
		ret.WriteString(v.String())
	}
	return ret.String()
}

golang 3无重复字符的最长子串

- 遍历字符串，使用一个队列进行入队操作 - 入队之后检查队列内是否有重复字符，如果有，则将重复字符和它之前的全部字符出队 - 使用一个map存储当前队列内容的长度 - 遍历字符串结束后，遍历地图，查找最大长度的内容返回

lengthOfLongestSubstring.go

package main

import "fmt"

func main() {
	s := "abcabcbb"
	fmt.Println(lengthOfLongestSubstring(s))
}
func lengthOfLongestSubstring(s string) int {
	q := Queue{}
	dict := make(map[string]int)
	for i := 0; i < len(s); i++ {
		q.Push(s[i])
		q.Trim(s[i])
		dict[q.Value()] = q.Len()
	}
	fmt.Println(dict)
	max := 0
	for _, v := range dict {
		if v > max {
			max = v
		}
	}
	return max
}

type Queue struct {
	data []byte
}

func (this *Queue) Push(s byte) {
	this.data = append(this.data, s)
}
func (this *Queue) Trim(s byte) {
	for i, v := range this.data {
		if v == s && i != this.Len()-1 {
			this.data = this.data[i+1:]
			break
		}
	}

}
func (this *Queue) Len() int {
	return len(this.data)
}
func (this *Queue) Value() string {
	return string(this.data)

}