string

package main

import (
	"fmt"
)

type question8 struct {
	para8
	ans8
}

// para 是参数
// one 代表第一个参数
type para8 struct {
	one string
}

// ans 是答案
// one 代表第一个答案
type ans8 struct {
	one int
}

func main() {

	qs := []question8{

		{
			para8{"42"},
			ans8{42},
		},

		{
			para8{"   -42"},
			ans8{-42},
		},

		{
			para8{"4193 with words"},
			ans8{4193},
		},

		{
			para8{"words and 987"},
			ans8{0},
		},

		{
			para8{"-91283472332"},
			ans8{-2147483648},
		},
	}

	for _, q := range qs {
		_, p := q.ans8, q.para8
		fmt.Println(p.one, Atoi(p.one))
	}

}

Output:

	42 42
   -42 -42
4193 with words 4193
words and 987 0
-91283472332 -2147483648

package main

import (
	"fmt"
)

type question30 struct {
	para30
	ans30
}

// para 是参数
// one 代表第一个参数
type para30 struct {
	one string
	two []string
}

// ans 是答案
// one 代表第一个答案
type ans30 struct {
	one []int
}

func main() {

	qs := []question30{

		{
			para30{"aaaaaaaa", []string{"aa", "aa", "aa"}},
			ans30{[]int{0, 1, 2}},
		},

		{
			para30{"barfoothefoobarman", []string{"foo", "bar"}},
			ans30{[]int{0, 9}},
		},

		{
			para30{"wordgoodgoodgoodbestword", []string{"word", "good", "best", "word"}},
			ans30{[]int{}},
		},

		{
			para30{"goodgoodgoodgoodgood", []string{"good"}},
			ans30{[]int{0, 4, 8, 12, 16}},
		},

		{
			para30{"barofoothefoolbarman", []string{"foo", "bar"}},
			ans30{[]int{}},
		},

		{
			para30{"bbarffoothefoobarman", []string{"foo", "bar"}},
			ans30{[]int{}},
		},

		{
			para30{"ooroodoofoodtoo", []string{"foo", "doo", "roo", "tee", "oo"}},
			ans30{[]int{}},
		},

		{
			para30{"abc", []string{"a", "b", "c"}},
			ans30{[]int{0}},
		},

		{
			para30{"a", []string{"b"}},
			ans30{[]int{}},
		},

		{
			para30{"ab", []string{"ba"}},
			ans30{[]int{}},
		},

		{
			para30{"n", []string{}},
			ans30{[]int{}},
		},
	}

	for _, q := range qs {
		_, p := q.ans30, q.para30
		fmt.Println(p, FindSubstring(p.one, p.two))
	}
}

Output:

{aaaaaaaa [aa aa aa]} [0 1 2]
{barfoothefoobarman [foo bar]} [0 9]
{wordgoodgoodgoodbestword [word good best word]} []
{goodgoodgoodgoodgood [good]} [0 4 8 12 16]
{barofoothefoolbarman [foo bar]} []
{bbarffoothefoobarman [foo bar]} [11]
{ooroodoofoodtoo [foo doo roo tee oo]} []
{abc [a b c]} [0]
{a [b]} []
{ab [ba]} []
{n []} []

package main

import (
	"fmt"
)

type question22 struct {
	para22
	ans22
}

// para 是参数
// one 代表第一个参数
type para22 struct {
	one int
}

// ans 是答案
// one 代表第一个答案
type ans22 struct {
	one []string
}

func main() {

	qs := []question22{

		{
			para22{3},
			ans22{[]string{
				"((()))",
				"(()())",
				"(())()",
				"()(())",
				"()()()",
			}},
		},
		// 如需多个测试，可以复制上方元素。
	}

	for _, q := range qs {
		_, p := q.ans22, q.para22
		fmt.Println(p, GenerateParenthesis(p.one))
	}

}

Output:

{3} [((())) (()()) (())() ()(()) ()()()]

package main

import (
	"fmt"
)

type question49 struct {
	para49
	ans49
}

// para 是参数
// one 代表第一个参数
type para49 struct {
	one []string
}

// ans 是答案
// one 代表第一个答案
type ans49 struct {
	one [][]string
}

func main() {

	qs := []question49{

		{
			para49{[]string{"eat", "tea", "tan", "ate", "nat", "bat"}},
			ans49{[][]string{{"ate", "eat", "tea"}, {"nat", "tan"}, {"bat"}}},
		},
	}

	for _, q := range qs {
		_, p := q.ans49, q.para49
		fmt.Println(p, GroupAnagrams(p.one))
	}
	// {[eat tea tan ate nat bat]} [[eat tea ate] [tan nat] [bat]]
}

package main

import (
	"fmt"
)

type question12 struct {
	para12
	ans12
}

// para 是参数
// one 代表第一个参数
type para12 struct {
	one int
}

// ans 是答案
// one 代表第一个答案
type ans12 struct {
	one string
}

func main() {

	qs := []question12{

		{
			para12{3},
			ans12{"III"},
		},

		{
			para12{4},
			ans12{"IV"},
		},

		{
			para12{9},
			ans12{"IX"},
		},

		{
			para12{58},
			ans12{"LVIII"},
		},

		{
			para12{1994},
			ans12{"MCMXCIV"},
		},
		{
			para12{123},
			ans12{"CXXIII"},
		},

		{
			para12{120},
			ans12{"CXX"},
		},
	}

	for _, q := range qs {
		_, p := q.ans12, q.para12
		fmt.Println(p.one, IntToRoman(p.one))
	}

}

Output:

3 III
4 IV
9 IX
58 LVIII
1994 MCMXCIV
123 CXXIII
120 CXX

tcs := []struct {
	s   string
	ans bool
}{

	{
		"0",
		true,
	},

	{
		"e",
		false,
	},

	{
		".",
		false,
	},

	{
		".1",
		true,
	},
}

for _, tc := range tcs {
	fmt.Println(tc, IsNumber(tc.s))
}

Output:

{0 true} true
{e false} false
{. false} false
{.1 true} true

package main

import (
	"fmt"
)

type question58 struct {
	para58
	ans58
}

// para 是参数
type para58 struct {
	s string
}

// ans 是答案
type ans58 struct {
	ans int
}

func main() {

	qs := []question58{

		{
			para58{"Hello World"},
			ans58{5},
		},

		{
			para58{"   fly me   to   the moon  "},
			ans58{4},
		},

		{
			para58{"luffy is still joyboy"},
			ans58{6},
		},
	}

	for _, q := range qs {
		_, p := q.ans58, q.para58
		fmt.Println(p, LengthOfLastWord(p.s))
	}
}

Output:

{Hello World} 5
{   fly me   to   the moon  } 4
{luffy is still joyboy} 6

package main

import (
	"fmt"
)

type question3 struct {
	para3
	ans3
}

// para 是参数
// one 代表第一个参数
type para3 struct {
	s string
}

// ans 是答案
// one 代表第一个答案
type ans3 struct {
	one int
}

func main() {

	qs := []question3{

		{
			para3{"abcabcbb"},
			ans3{3},
		},

		{
			para3{"bbbbb"},
			ans3{1},
		},

		{
			para3{"pwwkew"},
			ans3{3},
		},

		{
			para3{""},
			ans3{0},
		},
	}

	for _, q := range qs {
		_, p := q.ans3, q.para3
		fmt.Println(p, LengthOfLongestSubstring(p.s))
	}

}

Output:

	{abcabcbb} 3
{bbbbb} 1
{pwwkew} 3
{} 0

package main

import (
	"fmt"
)

type question17 struct {
	para17
	ans17
}

// para 是参数
// one 代表第一个参数
type para17 struct {
	s string
}

// ans 是答案
// one 代表第一个答案
type ans17 struct {
	one []string
}

func main() {

	qs := []question17{

		{
			para17{"23"},
			ans17{[]string{"ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"}},
		},
	}

	for _, q := range qs {
		_, p := q.ans17, q.para17
		fmt.Println(p, LetterCombinations(p.s))
	}

}

Output:

{23} [ad ae af bd be bf cd ce cf]

package main

import (
	"fmt"
)

type question14 struct {
	para14
	ans14
}

// para 是参数
type para14 struct {
	strs []string
}

// ans 是答案
type ans14 struct {
	ans string
}

func main() {

	qs := []question14{

		{
			para14{[]string{"flower", "flow", "flight"}},
			ans14{"fl"},
		},

		{
			para14{[]string{"dog", "racecar", "car"}},
			ans14{""},
		},

		{
			para14{[]string{"ab", "a"}},
			ans14{"a"},
		},
	}

	for _, q := range qs {
		_, p := q.ans14, q.para14
		fmt.Println(p.strs, LongestCommonPrefix(p.strs), "ex")
	}

}

Output:

[flower flow flight] fl ex
[dog racecar car]  ex
[ab a] a ex

package main

import (
	"fmt"
)

type question5 struct {
	para5
	ans5
}

// para 是参数
// one 代表第一个参数
type para5 struct {
	s string
}

// ans 是答案
// one 代表第一个答案
type ans5 struct {
	one string
}

func main() {

	qs := []question5{

		{
			para5{"babad"},
			ans5{"bab"},
		},

		{
			para5{"cbbd"},
			ans5{"bb"},
		},

		{
			para5{"a"},
			ans5{"a"},
		},

		{
			para5{"ac"},
			ans5{"a"},
		},

		{
			para5{"aa"},
			ans5{"aa"},
		},

		{
			para5{"ajgiljtperkvubjmdsefcylksrxtftqrehoitdgdtttswwttmfuvwgwrruuqmxttzsbmuhgfaoueumvbhajqsaxkkihjwevzzedizmrsmpxqavyryklbotwzngxscvyuqjkkaotitddlhhnutmotupwuwyltebtsdfssbwayuxrbgihmtphshdslktvsjadaykyjivbzhwujcdvzdxxfiixnzrmusqvwujjmxhbqbdpauacnzojnzxxgrkmupadfcsujkcwajsgintahwgbjnvjqubcxajdyyapposrkpqtpqfjcvbhlmwfutgognqxgaukpmdyaxghgoqkqnigcllachmwzrazwhpppmsodvxilrccfqgpkmdqhoorxpyjsrtbeeidsinpeyxxpsjnymxkouskyhenzgieybwkgzrhhrzgkwbyeigznehyksuokxmynjspxxyepnisdieebtrsjypxroohqdmkpgqfccrlixvdosmppphwzarzwmhcallcginqkqoghgxaydmpkuagxqngogtufwmlhbvcjfqptqpkrsoppayydjaxcbuqjvnjbgwhatnigsjawckjuscfdapumkrgxxznjozncauapdbqbhxmjjuwvqsumrznxiifxxdzvdcjuwhzbvijykyadajsvtklsdhshptmhigbrxuyawbssfdstbetlywuwputomtunhhlddtitoakkjquyvcsxgnzwtoblkyryvaqxpmsrmzidezzvewjhikkxasqjahbvmueuoafghumbszttxmquurrwgwvufmttwwstttdgdtioherqtftxrsklycfesdmjbuvkreptjligja"},
			ans5{"ajgiljtperkvubjmdsefcylksrxtftqrehoitdgdtttswwttmfuvwgwrruuqmxttzsbmuhgfaoueumvbhajqsaxkkihjwevzzedizmrsmpxqavyryklbotwzngxscvyuqjkkaotitddlhhnutmotupwuwyltebtsdfssbwayuxrbgihmtphshdslktvsjadaykyjivbzhwujcdvzdxxfiixnzrmusqvwujjmxhbqbdpauacnzojnzxxgrkmupadfcsujkcwajsgintahwgbjnvjqubcxajdyyapposrkpqtpqfjcvbhlmwfutgognqxgaukpmdyaxghgoqkqnigcllachmwzrazwhpppmsodvxilrccfqgpkmdqhoorxpyjsrtbeeidsinpeyxxpsjnymxkouskyhenzgieybwkgzrhhrzgkwbyeigznehyksuokxmynjspxxyepnisdieebtrsjypxroohqdmkpgqfccrlixvdosmppphwzarzwmhcallcginqkqoghgxaydmpkuagxqngogtufwmlhbvcjfqptqpkrsoppayydjaxcbuqjvnjbgwhatnigsjawckjuscfdapumkrgxxznjozncauapdbqbhxmjjuwvqsumrznxiifxxdzvdcjuwhzbvijykyadajsvtklsdhshptmhigbrxuyawbssfdstbetlywuwputomtunhhlddtitoakkjquyvcsxgnzwtoblkyryvaqxpmsrmzidezzvewjhikkxasqjahbvmueuoafghumbszttxmquurrwgwvufmttwwstttdgdtioherqtftxrsklycfesdmjbuvkreptjligja"},
		},
	}

	for _, q := range qs {
		_, p := q.ans5, q.para5
		fmt.Println(LongestPalindrome(p.s))
	}
}

Output:

	bab
bb
a
a
aa
ajgiljtperkvubjmdsefcylksrxtftqrehoitdgdtttswwttmfuvwgwrruuqmxttzsbmuhgfaoueumvbhajqsaxkkihjwevzzedizmrsmpxqavyryklbotwzngxscvyuqjkkaotitddlhhnutmotupwuwyltebtsdfssbwayuxrbgihmtphshdslktvsjadaykyjivbzhwujcdvzdxxfiixnzrmusqvwujjmxhbqbdpauacnzojnzxxgrkmupadfcsujkcwajsgintahwgbjnvjqubcxajdyyapposrkpqtpqfjcvbhlmwfutgognqxgaukpmdyaxghgoqkqnigcllachmwzrazwhpppmsodvxilrccfqgpkmdqhoorxpyjsrtbeeidsinpeyxxpsjnymxkouskyhenzgieybwkgzrhhrzgkwbyeigznehyksuokxmynjspxxyepnisdieebtrsjypxroohqdmkpgqfccrlixvdosmppphwzarzwmhcallcginqkqoghgxaydmpkuagxqngogtufwmlhbvcjfqptqpkrsoppayydjaxcbuqjvnjbgwhatnigsjawckjuscfdapumkrgxxznjozncauapdbqbhxmjjuwvqsumrznxiifxxdzvdcjuwhzbvijykyadajsvtklsdhshptmhigbrxuyawbssfdstbetlywuwputomtunhhlddtitoakkjquyvcsxgnzwtoblkyryvaqxpmsrmzidezzvewjhikkxasqjahbvmueuoafghumbszttxmquurrwgwvufmttwwstttdgdtioherqtftxrsklycfesdmjbuvkreptjligja

package main

import (
	"fmt"
)

type question32 struct {
	para32
	ans32
}

// para 是参数
// one 代表第一个参数
type para32 struct {
	s string
}

// ans 是答案
// one 代表第一个答案
type ans32 struct {
	one int
}

func main() {

	qs := []question32{

		{
			para32{"(()"},
			ans32{2},
		},

		{
			para32{")()())"},
			ans32{4},
		},

		{
			para32{"()(())"},
			ans32{6},
		},

		{
			para32{"()(())))"},
			ans32{6},
		},

		{
			para32{"()(()"},
			ans32{2},
		},
	}

	for _, q := range qs {
		_, p := q.ans32, q.para32
		fmt.Println(p, LongestValidParentheses(p.s))
	}
}

Output:

{(()} 2
{)()())} 4
{()(())} 6
{()(())))} 6
{()(()} 2

package main

import (
	"fmt"
)

type question43 struct {
	para43
	ans43
}

// para 是参数
// one 代表第一个参数
type para43 struct {
	num1 string
	num2 string
}

// ans 是答案
// one 代表第一个答案
type ans43 struct {
	one string
}

func main() {

	qs := []question43{

		{
			para43{"2", "3"},
			ans43{"6"},
		},

		{
			para43{"123", "456"},
			ans43{"56088"},
		},
	}

	for _, q := range qs {
		_, p := q.ans43, q.para43
		fmt.Println(p, Multiply(p.num1, p.num2))
	}
}

Output:

{2 3} 6
{123 456} 56088

package main

import (
	"fmt"
)

type question13 struct {
	para13
	ans13
}

// para 是参数
// one 代表第一个参数
type para13 struct {
	one string
}

// ans 是答案
// one 代表第一个答案
type ans13 struct {
	one int
}

func main() {

	qs := []question13{

		{
			para13{"III"},
			ans13{3},
		},

		{
			para13{"IV"},
			ans13{4},
		},

		{
			para13{"IX"},
			ans13{9},
		},

		{
			para13{"LVIII"},
			ans13{58},
		},

		{
			para13{"MCMXCIV"},
			ans13{1994},
		},

		{
			para13{"MCMXICIVI"},
			ans13{2014},
		},
	}

	for _, q := range qs {
		_, p := q.ans13, q.para13
		fmt.Println(p.one, RomanToInt(p.one))
	}

}

Output:

III 3
IV 4
IX 9
LVIII 58
MCMXCIV 1994
MCMXICIVI 2014

package main

import (
	"fmt"
)

type question28 struct {
	para28
	ans28
}

// para 是参数
// one 代表第一个参数
type para28 struct {
	s string
	p string
}

// ans 是答案
// one 代表第一个答案
type ans28 struct {
	one int
}

func main() {

	qs := []question28{

		{
			para28{"abab", "ab"},
			ans28{0},
		},

		{
			para28{"hello", "ll"},
			ans28{2},
		},

		{
			para28{"", "abc"},
			ans28{0},
		},

		{
			para28{"abacbabc", "abc"},
			ans28{5},
		},

		{
			para28{"abacbabc", "abcd"},
			ans28{-1},
		},

		{
			para28{"abacbabc", ""},
			ans28{0},
		},
	}

	for _, q := range qs {
		_, p := q.ans28, q.para28
		fmt.Println(p, StrStr(p.s, p.p))
	}
}

Output:

{abab ab} 0
{hello ll} 2
{ abc} -1
{abacbabc abc} 5
{abacbabc abcd} -1
{abacbabc } 0

package main

import (
	"fmt"
)

type question6 struct {
	para6
	ans6
}

// para 是参数
// one 代表第一个参数
type para6 struct {
	s       string
	numRows int
}

// ans 是答案
// one 代表第一个答案
type ans6 struct {
	one string
}

func main() {

	qs := []question6{

		{
			para6{"PAYPALISHIRING", 3},
			ans6{"PAHNAPLSIIGYIR"},
		},

		{
			para6{"PAYPALISHIRING", 4},
			ans6{"PINALSIGYAHRPI"},
		},

		{
			para6{"A", 1},
			ans6{"A"},
		},
	}

	for _, q := range qs {
		_, p := q.ans6, q.para6
		fmt.Println(p, Zigzag(p.s, p.numRows))
	}
}

Output:

	{PAYPALISHIRING 3} PAHNAPLSIIGYIR
{PAYPALISHIRING 4} PINALSIGYAHRPI
{A 1} A