Go言語で自作パッケージをGithubに公開・利用する手順を解説

mkdir gmod
cd gmod

go mod init github.com/aruaru0/gmod

mkdir SequenceProcessor
cd SequenceProcessor

package SequenceProcessor

import "sort"

// NextPermutation generates the next permutation of the sortable collection x in lexical order.
//
// It takes a sort.Interface as a parameter, which represents the collection to be permuted.
// It returns a boolean indicating whether a next permutation exists.
func NextPermutation(x sort.Interface) bool {
	n := x.Len() - 1
	if n < 1 {
		return false
	}
	j := n - 1
	for ; !x.Less(j, j+1); j-- {
		if j == 0 {
			return false
		}
	}
	l := n
	for !x.Less(j, l) {
		l--
	}
	x.Swap(j, l)
	for k, l := j+1, n; k < l; {
		x.Swap(k, l)
		k++
		l--
	}
	return true
}

package SequenceProcessor

import (
	"sort"
	"testing"
)

func TestNextPermutation(t *testing.T) {
	a := []int{1, 2, 3}

	exp := [][]int{
		{1, 2, 3},
		{1, 3, 2},
		{2, 1, 3},
		{2, 3, 1},
		{3, 1, 2},
		{3, 2, 1},
	}
	cnt := 0
	for pos := 0; ; pos++ {
		// fmt.Println(a, exp[pos])
		for i := 0; i < len(a); i++ {
			if a[i] != exp[pos][i] {
				t.Error("mismatch a=1", a, "!=", exp[pos])
			}
		}
		cnt++
		if !NextPermutation(sort.IntSlice(a)) {
			break
		}
	}
	if cnt != len(exp) {
		t.Error("mismatch cnt", cnt, "!=", len(exp))
	}
}

package SequenceProcessor

// combinations generates all possible combinations of the given list with the specified length.
//
// list is the input list of integers, k is the length of the combinations, and buf is the buffer size of the output channel.
// chan []int is the channel that outputs all combinations.
func Combinations(list []int, k, buf int) (c chan []int) {
	c = make(chan []int, buf)
	n := len(list)

	pattern := make([]int, k)

	var body func(pos, begin int)
	body = func(pos, begin int) {
		if pos == k {
			t := make([]int, k)
			copy(t, pattern)
			c <- t
			return
		}

		for num := begin; num < n+pos-k+1; num++ {
			pattern[pos] = list[num]
			body(pos+1, num+1)
		}
	}
	go func() {
		defer close(c)
		body(0, 0)
	}()

	return
}

package SequenceProcessor

import (
	"testing"
)

func TestCombinations(t *testing.T) {
	a := []int{1, 2, 3, 4}

	exp := [][]int{
		{1, 2},
		{1, 3},
		{1, 4},
		{2, 3},
		{2, 4},
		{3, 4},
	}

	cnt := 0
	for e := range Combinations(a, 2, 1) {
		for i := 0; i < len(e); i++ {
			if e[i] != exp[cnt][i] {
				t.Error("mismatch ", e, "!=", exp[cnt])
			}
		}
		cnt++
	}

	if cnt != len(exp) {
		t.Error("mismatch cnt", cnt, "!=", len(exp))
	}
}

go test

go mod tidy

git add .
git commit -m "add functions"
git push

package main

import (
	"fmt"
	"sort"

	sp "github.com/aruaru0/gmod/SequenceProcessor"
)

func main() {
	a := []int{1, 2, 3}

	for {
		fmt.Println(a)
		if !sp.NextPermutation(sort.IntSlice(a)) {
			break
		}
	}
}

go get github.com/aruaru0/gmod/SequenceProcessor

go mod init xxxxx
go mod tidy