<https://github.com/issue9/sliceutil> sliceutil 提供了针对数组和切片的功能 - Reverse 反转数组中的元素； - Delete 删除符合条件的切片元素； - QuickDelete 删除符合条件的切片元素，性能稍高于 Delete； - Count 统计数组或切片中包含指定什的数量； - Dup 查看数组或切片中是否包含重得的值； - Contains 判断一个数组或是切片是否包含了另一个的所有元素...阅读全文
// code_012_array_element project main.go package main import ( "fmt" ) func modify(array [5]int) { array[0] = 10 fmt.Println("In modify(), array values:", array) } func modify01(array01 *[5]int) { (*array01)[0] = 10 fmt.Println("In modify(), array01 values:", *array01) } func main() { // var n int = 10 // var a[n]int //数组长度不能为变量 var a [10]int //ok...阅读全文
// 切片 // 1: 占用资源很小 // 2: slice[a:b] 包含a索引值，不包含b索引值，默认容量上界索引为被操作对象容量上界索引 // 3: slice[a:b:c] 包含a索引值，不包含b索引值，容量上界索引为c // 4: slice 只能向后扩展，不能向前扩展 // 5: slice append // (1)某次操作未超过该slice容量上界索引，此次改变会更新原数组; // (2)某次操作超过该slice容量上界索引则新的被操作对象数组会被新建，此次改变不会更新原数组 numArr := [10]uint{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} slice0 := numArr[3:9] // 容量上界索引为10 slice1 := numArr[...阅读全文
题目描述 等级: 简单 给定两个数组，编写一个函数来计算它们的交集。 示例1： 输入: nums1 = [1,2,2,1], nums2 = [2,2] 输出: [2,2] 示例2： 输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4] 输出: [4,9] 说明： 输出结果中每个元素出现的次数，应与元素在两个数组中出现的次数一致。我们可以不考虑输出结果的顺序。 进阶: 如果给定的数组已经排好序呢？你将如何优化你的算法？如果 nums1 的大小比 nums2 小很多，哪种方法更优？如果 nums2 的元素存储在磁盘上，磁盘内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？ 思路 对于hash与数组的考察。 求两个数组并集，并且每个元素出现次数应与元素在...阅读全文
Python def test2(list1, list2): res = [] for item1 in list1: for item2 in list2: res.append( item1 + ' ' + item2 ) return res def test(data_list): list1 = data_list[0] for tmp_list in data_list[1:]: res = test2(list1, tmp_list) list1 = res print(list1) a = ['a', 'b', 'c'] b = ['d', 'e', 'f'] c = ['g', 'h'] test([a, b, c]) Out ['a d g', 'a d h', 'a ...阅读全文
在json编码中，最麻烦的是json数组，下面记录一下我在json编码遇到的难题和解决的源代码： 如果要打包这种格式： {"key":222,"msg":{"ed":"aaa","gf":"23.45","rs":"23"},"status":1} 代码如下： package main import ( "encoding/json" "fmt" ) func main() { t := make(map[string]interface{}) t["ed"] = "aaa" t["rs"] = "23" t["gf"] = "23.45" res := make(map[string]interface{}) res["status"] = 1 res["key"] = 222 res["...阅读全文
关于golang的slice我认为是go几个特点之一，它充分得改善了数组的几个局限地方，本文简单分析slice使用过程中你会遇到的几个问题： 我们看以下例子： sliceA:=[]int{1,2,3} sliceB:=sliceA[0:2] sliceA[0]=4 fmt.Println(sliceB)//此处输出什么？ 以上代码说明,slice的赋值操作是引用类型（地址拷贝）更改原slice后自己会受影响。那么如果你想要不受影响，可以选择复制操作： sliceA:=[]int{1,2,3} sliceB:=make([]int,len(sliceA)) copy(sliceA,sliceB) 注意copy操作需要对操作对象先创建地址空间。 我们看下面的问题： sliceA:=[]int{1...阅读全文
为类型添加方法package main import ( "fmt" ) type Integer int func (a Integer) Less(b Integer) bool { return a < b } func main() { var a Integer = 1 if a.Less(2) { fmt.Println("Less true.") } } 结果输出：Less true.只有在你需要修改对象的时候，才必须用指针 因为数组切片的内部是指向数组的指针，所以可以改变数组的内容 package main import ( "fmt" ) func modifyslice(array []int) { slice1 := array[1:2] fmt.Println(sli...阅读全文
>数组初始化，赋值，遍历 ```golang package main import "fmt" func modify (array [10] int) { // 试图修改数组的第一个元素 array[0] = 10 array[9] = 999 fmt.Println("In modify(), array values:", array) } func main() { // 定义并初始化一个数组 array := [10]int{1,2,3,4,5} // 传递给一个函数，并试图在函数体内修改这个数组内容 modify(array) fmt.Println("In main(), array values:", array) fmt.Println(len(array)) for i...阅读全文
package main import "fmt" func main() { //全局初始化 var a [5]int =[5]int{1,2,3,4,5} fmt.Println("a=",a) //全局初始化简写 b:=[5]int{1,2,3,4,5} fmt.Println("b=",b) //部分初始化，没有初始化的数组元素 int类型自动赋值为0 c:=[5]int{1,2,3} fmt.Println("c=",c) //部分初始化，没有初始化的数组元素 BOOL类型自动赋值为false f:=[2]bool{true} fmt.Println("f=",f) } ...阅读全文
函数参数为interface{}可以接收各种类型参数，为什么[]interface{}数组就不能接收[]string数...阅读全文
# 起始 在 golang 文档中，对数组与切片有一些详细的讲解，本文主要讲解数组与切片的关系 `由于是个人理解，可能有些偏差，烦请指正` ## 数组 golang 的数组比较简单，我们理解几个概念即可 1. 数组是固定长度与容量，并且具有相同类型的一组值 2. 此定义的数组长度为 5 ，那么容量也会固定为 5 3. 数组的索引都是从 0 开始的 ` 记住，我们在此定义了一个 int 类型的数组，长度容量均为 5，在后面的切片讲解中，我们将对此数组进行切片` ``` // 此定义的数组长度为 5 ，那么容量也会固定为 5 arr := [5]int{0, 1, 2, 3, 4} // 数组 p = 0xc00001c0f0,arr = [0 1 2 3 4],len = 5,cap = 5 ...阅读全文
求救啊大佬们x; (指针符号打不出来...阅读全文
Golang: 思路：这题想不通就很难，想通了就很简单，思路的话，简单描述就是逆向思维，将题目所给的条件换一种说法，一切就豁然开朗了。这题理解上首先就挺绕的，我觉得应该翻译为：一个长度为n的数组，我们每次只能让n-1个元素都增加1。问多少次以后，数组内所有元素可以相等。这样一描述，估计就看懂了，但还是很难对不对。我们逆向一下，n-1个元素均加一，等同于剩下那1个元素减一，对吧。那这题就变成了，n个元素的数组，每次都有一个元素减一，问多少次以后数组内元素全部相等。这样，解法就很简单了对吧，因此我就不多做陈述了。 代码如下： func minMoves(nums []int) int { if len(nums)==1 { return 0 } sum:=0 temp:=nums[0] for ...阅读全文
golang使用array表示固定大小的数组，使用slice表示动态数组。 package main import "fmt" func main() { var a = [5]int{2,3,5,7,11} fmt.Printf("type of array: %T\n", a) fmt.Printf("address of array: %p\n", &a) fmt.Printf("address of arrar[0]: %p\n", &a[0]) s := a[:] fmt.Printf("slice = %v, len = %d, cap = %d\n", s, len(s), cap(s)) fmt.Printf("address of slice: %p\n", &s) fmt...阅读全文
1 go语言数组简介 数组是Go语言编程中最常用的数据结构之一。顾名思义，数组就是指一系列同一类型数据的集合。数组中包含的每个数据被称为数组元素（element），一个数组包含的元素个数被称为数组的长度。 在Go语言中数组是一个值类型（value type）。是真真实实的数组，而不是一个指向数组内存起始位置的指针，也不能和同类型的指针进行转化，这一点严重不同于C语言。所有的值类型变量在赋值和作为参数传递时都将产生一次复制动作。如果将数组作为函数的参数类型，则在函数调用时该参数将发生数据复制。因此，在函数体中无法修改传入的数组的内容，因为函数内操作的只是所传入数组的一个副本。 2 数组定义 定义方式如下 var arr [n]type n表示数组长度，type表示数组存储类型。 在Go语言中，...阅读全文
多米诺骨牌 image.png 结果： image.png 分析过程： 准备一个二维数组存储每个阶段的状态结果值 将问题分解为前一个骨块和下一个骨块左右的关系 找到递推关系 result[0] = append(result[0], int64(math.Max(float64(result[0][i]+node.Rnext.L), float64(result[1][i]+node.Lnext.L)))) result[1] = append(result[1], int64(math.Max(float64(result[0][i]+node.Rnext.R), float64(result[1][i]+node.Lnext.R)))) golang代码： package main im...阅读全文
# 数组 ### 定义：是同一种数据类型的**固定长度**的序列。var a [len]int #### 长度是数组类型的一部分，因此，var a[5] int和var a[10]int是不同的类型，数组可以通过下标进行访问，下标是从0开始，最后一个元素下标是：len-1，访问越界，如果下标在数组合法范围之外，则触发访问越界，会panic #### 数组是值类型，因此改变副本的值，不会改变本身的值 example:fibonacci非递归： ``` func fibonacci() { fib := [20]int64{0: 1, 1: 1} for i := range fib { if i == 0 || i == 1 { continue } fib[i] = fib[i-1] + f...阅读全文
题目描述 在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007 输入描述 题目保证输入的数组中没有的相同的数字 数据范围： 对于%50的数据,size<=10^4 对于%75的数据,size<=10^5 对于%100的数据,size<=2*10^5 示例 输入 1,2,3,4,5,6,7,0 输出 7 思路 1.可以通过移动数字发现，计算逆序对的方式和归并排序的merge操作有相似之处。 2.当进行merge操作时，若左边数组的元素大于右边数组的某一元素时，说明存在mid-left-l个逆序对。 因为左边数组和右边数组都是排好序的 l索引代表左...阅读全文
**数组 Array**数组是一种内建的类型，是一组同类型数据的集合，是一种值类型，可以通过从0开始的下标索引访问元素值，在初始化后其长度就固定了，无法修改其长度，而且Array的长度也是其类型的一部分，可以通过其内置函数len(array)获取其长度，当它作为方法的参数传入时，将复制一份数组，而不是引用同一个指针。初始化：[5]int{1,2,3,4,5} #长度为5的数组，其值分别为1，2，3，4，5[5]int{1,2} #长度为5的数组，其值分别为1，2，0，0，0 在初始化时，没有指定初值的元素，int类型的默认为0，string类型默认为""，bool类型默认为false[...]int{1,2,3,4,5} #长度为5的数组，其长度由初始化时元素的个数决定[5]int{2:1,...阅读全文
package main import "fmt" func modify(arr [5]int) { arr[0] = 10 // 试图修改数组的第一元素 fmt.Println("In modify() arr values:", arr) } func main() { arrmain := [5]int{1, 2, 3, 4, 5} //定义并初始化一个数组 modify(arrmain) // 传递给一个函数,并试图在函数体内修改这个数组的内容 fmt.Println("In main, arrmain values:", arrmain) } $(function () { $('pre.prettyprint code').each(function () { var line...阅读全文
JS写多了各种数组的操作已经很熟悉，到Golang里面... 啥方法也没有只能自己手撸了... 简单先自己记录一下 修改id对应数组中位置的函数 平时golang写得少 总是忘。。。 类型写死了，并不通用 func AddToTargetPos(id int64, position int32) error { // oldOrderList 就先不管从哪来了 newList := make([]int64, 0) for _, _id := range oldOrderList { if id != _id { newList = append(newList, _id) } } if position == 0 { newList = append([]int64{id}, newLis...阅读全文
~~~ var ab [3]int ab[0] = 2 ab[1] = 8 ab[2] = 0 比如以上 怎么按小到大排成 0,2,8呢 【备注】 这个数组长度是不固定的 我默认演示的3个 也可能更多或则更少 最好有代码演示啦！再次感谢！ ~~...阅读全文
最近项目中有遇到类似问题，做个记录。 举个例子，[5]int为数组，[]int为slice(数组切片)，数组是值类型，而slice为引用类型，值类型作为参数传入函数，只是拷贝了个副本，修改并不会作用到传入的那个参数，所以一般使用slice作为参数,免去了拷贝的消耗，但是有坑在里面，下面写例子说明。 1.slice作为参数 package main import "fmt" type DbItem struct { Id int16 Cnt int32 } func combineItem(itemList []DbItem, id int16, cnt int32) { item := DbItem{Id: int16(id), Cnt: int32(cnt)} itemList[0] = ...阅读全文
# go string类型 ## string类型变量 ```c //go语言中的string类型像是c语言中的 struct string{ size_t len ; char const * data ; //指向[...]byte类型的数组 }; ``` ## string = 运算符赋值操作 ```go /* string类型 = 赋值运算符, 推测使用浅copy, string类型不提供修改索引的[...]byte类型数组的方法,并且go语言实现了gc垃圾回收机制,不需要关心内存释放的问题,所以单纯的赋值操作,没有必要进行深copy,使用浅copy可以提高性能,节省内存空间 */ ``` # go [...]TYPE array类型 ## [...]TYPE类型变量 ```c /*...阅读全文
补充知识：讲解了golang内置make函数的三个参数https://blog.csdn.net/weiyuefei/article/details/77968699 func generate(numRows int) [][]int { //res:=[][]int{[]int{1},[][]int{1,1}} 这个地方的错误 //beg:=[]int{1} 这个地方的错误 beg数组是每一行 res:= [][]int{[]int{1}, []int{1,1}} for i:=2;i
1.array的定义 定义数组的格式: var a[4]int //元素自动初始化为零 a := [...]int{19:1} //编译器按照初始化值数量确定数组长度 a := [5]int{1,2} //未提供初始值的元素自动初始化为零 数组长度也是类型的一部分，因此具有不同长度的数组为不同类型 数组在go中为值类型 2.数组指针和指针数组 //数组指针是指获取数组变量的地址。 //此时变量p就是指向数组的指针。特别注意p定义的类型为长度为100的数组的指针。 长度必须相等才能赋值。 func main() { var a = [...]int{99:1} var p *[100]int = &a fmt.Println(p) } //指针数组是指元素为指针类型的数组 func main(...阅读全文
1 go语言数组简介 数组是Go语言编程中最常用的数据结构之一。顾名思义，数组就是指一系列同一类型数据的集合。数组中包含的每个数据被称为数组元素（element），一个数组包含的元素个数被称为数组的长度。 在Go语言中数组是一个值类型（value type）。是真真实实的数组，而不是一个指向数组内存起始位置的指针，也不能和同类型的指针进行转化，这一点严重不同于C语言。所有的值类型变量在赋值和作为参数传递时都将产生一次复制动作。如果将数组作为函数的参数类型，则在函数调用时该参数将发生数据复制。因此，在函数体中无法修改传入的数组的内容，因为函数内操作的只是所传入数组的一个副本。 2 数组定义 定义方式如下 var arr [n]type n表示数组长度，type表示数组存储类型。 在Go语言中，...阅读全文
Golang: 思路：这题需要对数组进行排序，然后将数组内的元素的实际排位存进map里，然后对数组进行依次赋值 代码如下： func arrayRankTransform(arr []int) []int { if len(arr)==0{ return []int{} } if len(arr)==1 { return []int{1} } arr2:=make([]int,len(arr)) copy(arr2,arr) sort.Ints(arr2) mp:=make(map[int]int) temp:=1 for i:=1;i
结构 type slice struct { array unsafe.Pointer // 底层是个数组 len int // slice元素个数 cap int // 数组容量 } 扩容策略 当要扩成的大小newCap>2*currentCap,扩为newCap 当currentCap<1024时,扩为两倍 当currentCap>=1024时,currentCap * 1.25 * 1.25 * ... (直到>newCap) 扩容:memmove(newSlice, oldSilce, lenmem)做内存拷...阅读全文
``` package main import "fmt" type Color int func main() { c := new([]int) fmt.Println(c) c[1] = 2 } ``` c := new([]int) 可以创建成功，但是怎么用呢 c[1] = 2 .\point.go:11: invalid operation: c[1] (type *[]int does not support indexing...阅读全文
1 go语言数组简介 数组是Go语言编程中最常用的数据结构之一。顾名思义，数组就是指一系列同一类型数据的集合。数组中包含的每个数据被称为数组元素（element），一个数组包含的元素个数被称为数组的长度。 在Go语言中数组是一个值类型（value type）。是真真实实的数组，而不是一个指向数组内存起始位置的指针，也不能和同类型的指针进行转化，这一点严重不同于C语言。所有的值类型变量在赋值和作为参数传递时都将产生一次复制动作。如果将数组作为函数的参数类型，则在函数调用时该参数将发生数据复制。因此，在函数体中无法修改传入的数组的内容，因为函数内操作的只是所传入数组的一个副本。 2 数组定义 定义方式如下 var arr [n]type n表示数组长度，type表示数组存储类型。 在Go语言中，...阅读全文
我用的orm查询出的一组数组list
如下：
[
map[cname:大小 itemId:1 cid:1 itemName:大]
map[cname:大小 itemId:2 cid:1 itemName:小]
map[cname:颜色 itemId:3 cid:2 itemName:黄色]
map[cname:颜色 itemId:4 cid:2 itemName:绿色]
]
我想得到一个数组或切片Arr，通过cid分类
for _,v:=range list{
Arr[v["cid"]]["name"] = v["name"]
Arr[v["cid"]]["list"][...阅读全文
package main import "fmt" func f1() { a := [...]string{"a", "b", "c", "d"} for i := range a { fmt.Println("Array item", i, "is", a[i]) } } func f2() { var arr1=new([5]int) for i:=0;i<5;i++ { arr1[i]=i*3 } for _,val:=range arr1{ fmt.Printf("-----%d----arr1----\n",val) } var arr[5] int for i:=0;i<5;i++ { arr[i]=i*2 } for _,val:=range arr{ fmt.Printf(...阅读全文
s2=s[x:y] 创建出的切片s2与s共享数组 那么s2的len cap分别是？ s2的len=y-x cap=cap(s)-x 比如 s := make([]int, 30, 40) s2 := s[10:20] fmt.Println(len(s2)) // 10 fmt.Println(cap(s2)) // 30 s和s2共享的数组中10-19对s2可见 修改s2的某个值同时反应在s中 对于appends2的操作 上文中s2的cap=y-x 在cap的范围内append 修改的依然是共享数组 s2=append(s2,n) n会反映在s[20]上 替换s[20]的值 当append超过cap时s2底层指向一个新数组 容量提升25% s和s2分道扬镳 使用s2=s[x:y]这种形式创...阅读全文
215. 数组中的第K个最大元素 1、使用sort源码 func findKthLargest(nums []int, k int) int { sort.Ints(nums) //fmt.Println() return nums[len(nums)-k] } 2、冒泡排序 func bubble_sort(nums []int) []int { for i:=len(nums)-1; i >=0; i-- { for j:=0; j
package main import "fmt" func main(){ arr := [2]*int{new(int),new(int)} *arr[0] = 2 *arr[1] = 3 fmt.Printf("%v",*arr) } error: command-line-arguments ./1.go:8: invalid indirect of arr (type [2]*int...阅读全文
本文系第十一篇Golang语言学习教程 数组 数组是同一类型元素的集合。一个数组可以由0个或多个元素组成。 定义数组的格式： var
复合数据类型 数组 数组是具有相同类型的一组已知编号且长度固定的数据项序列，这个序列可以是有序的也可以是无序的，组成数组的各个变量称为数组的元素。数组的长度必须是一个非负整数的常量（或常量表达式），数组长度也是数组类型的一部分，所以[4]int和[10]int不是同一种类型。 声明数组 声明数组需要指定元素的数据类型和数组长度（存储元素的数量） //声明一个长度为20的整型数组 var array [20]int 数组一旦声明，它的数据类型和数组长度都不能再更改了。所以，如果需要存储更多的元素，就必须先创建一个更长的数组，然后再把原来数组里的值复制到新数组里。 数组初始化时候，它的每个元素都被初始化为对应类型的零值。 使用数组字面量创建并初始化数组 //声明一个包含5个元素的整型数组 //用...阅读全文
Go编程语言：支持并发、垃圾回收的编译型系统级编程语言！本文主要是按照无闻的《Go 编程基础》开源视频学习并记录笔记。 一、数组Array 定义数组的格式：var
一、数组 array 声明数组时，必须声明数组大小，声明后大小不可变，未赋值的空间默认值为数组存储类型的 0 值。 数组是值类型数据，相同空间大小的数组可以用 == 来比较是否相同。 package main import "fmt" func main() { var a1 = [2]int{1, 2} var a2 = [2]int{1, 2} fmt.Println(a1 == a2) // 输出：true } 2.数组遍历 package main import "fmt" func main() { // range 推荐 arr := [3]string{"aa", "bb", "cc"} for index, v := range arr { fmt.Printf("index...阅读全文
Golang: 思路：这题最好的思路是桶排序，因为限制条件明确而清晰，这里不得不说大佬还是大佬。常规思路自然是：将数组复制一遍，然后排序，排完序后的数组与原数组对比，求出所有同一位上数值不同的元素的数量。 代码如下： func heightChecker(heights []int) int { if len(heights)<=1 { return len(heights) } temp:=make([]int,len(heights)) copy(temp,heights) sort.Ints(temp) res:=0 for i:=0;i
数组类型的值（以下简称数组）的长度是固定的，而切片类型的值（以下简称切片）是可变长的。 数组的长度在声明它的时候就必须给定，并且在之后不会再改变。可以说，数组的长度是其类型的一部分。 golang数组的四种声明方法 第一种 // var <数组名称> [<数组长度>]<数组元素> var arra [2]int arr[0]=1 arrp1[=2 第二种 // var <数组名称> = [<数组长度>]<数组元素>{元素1，元素2，...} var arr = [2]int{1,2} //或者 arr := [2]int{1,2} 第三种 // var <数组名称>[<数组长度>]<数组元素>=[...]<元素类型>{元素1，元素2，...} var arr =[...]int{1,2} ...阅读全文
