The syntax is: a[start:stop] # items start through stop-1 a[start:] # items start through the rest of the array a[:stop] # items from the beginning through stop-1 a[:] # a copy of the whole array There is also the step value, which can be used with any of the above: a[start:stop:step] # start through not … Read more
a[x:y:z] gives the same result as a[slice(x, y, z)]. One of the advantages of a slice object is that it can be stored and retrieved later as a single object instead of storing x, y and z. It is often used to let the user define their own slice that can later be applied on … Read more
Order matters If you want to keep your array ordered, you have to shift all of the elements at the right of the deleting index by one to the left. Hopefully, this can be done easily in Golang: func remove(slice []int, s int) []int { return append(slice[:s], slice[s+1:]…) } However, this is inefficient because you … Read more
None of the default linq methods can do this lazily and with a single scan. Zipping the sequence with itself does 2 scans and grouping is not entirely lazy. Your best bet is to implement it directly: public static IEnumerable<T[]> Partition<T>(this IEnumerable<T> sequence, int partitionSize) { Contract.Requires(sequence != null) Contract.Requires(partitionSize > 0) var buffer = … Read more
Slice containing itself Besides a recursive type (such as type Foo []Foo, see ANisus’s answer) which is good for nothing besides demonstration, a slice may contain itself if for example the element type of the slice is interface{}: s := []interface{}{“one”, nil} s[1] = s In this example the slice s will have 2 interface … Read more
The accepted answer by John Zwinck is actually false (I just figured this out the hard way!). The problem in the question is a combination of doing “l-value indexing” with numpy’s fancy indexing. The following doc explains exactly this case https://scipy-cookbook.readthedocs.io/items/ViewsVsCopies.html in the section “But fancy indexing does seem to return views sometimes, doesn’t it?” … Read more
You don’t need to make new slices, just append slices of logs to the divided slice. http://play.golang.org/p/vyihJZlDVy var divided [][]string chunkSize := (len(logs) + numCPU – 1) / numCPU for i := 0; i < len(logs); i += chunkSize { end := i + chunkSize if end > len(logs) { end = len(logs) } divided … Read more
This is an old question, but here’s my two cents. PeterSO’s answer is slightly more concise, but slightly less efficient. You already know how big it’s going to be so you don’t even need to use append: keys := make([]int, len(mymap)) i := 0 for k := range mymap { keys[i] = k i++ } … Read more
Running any code for the first time may have some (significant) overhead, e.g. related code may be loaded, many things may be deferred until they are needed (e.g. internal buffers). Running the same thing again may take significantly less time, the difference may even be several orders of magnitude. Whenever you want to measure execution … Read more