func solver(in *ProblemReader.ProblemReader) string {
	n := in.Num()
	v1 := in.NNums(n)
	v2 := in.NNums(n)

	sort.SortInts(v1)
	sort.SortInts(v2)

	var sum int64 = 0

	for j := 0; j < n; j++ {
		sum += int64(v1[j]) * int64(v2[n-j-1])
	}
	return fmt.Sprint(sum)
}
Beispiel #2
0
func testAfterQueuing(t *testing.T) os.Error {
	const (
		Delta = 100 * 1e6
	)
	// make the result channel buffered because we don't want
	// to depend on channel queueing semantics that might
	// possibly change in the future.
	result := make(chan afterResult, len(slots))

	t0 := Nanoseconds()
	for _, slot := range slots {
		go await(slot, result, After(int64(slot)*Delta))
	}
	sort.SortInts(slots)
	for _, slot := range slots {
		r := <-result
		if r.slot != slot {
			return fmt.Errorf("after queue got slot %d, expected %d", r.slot, slot)
		}
		ns := r.t - t0
		target := int64(slot * Delta)
		slop := int64(Delta) / 4
		if ns < target-slop || ns > target+slop {
			return fmt.Errorf("after queue slot %d arrived at %g, expected [%g,%g]", slot, float64(ns), float64(target-slop), float64(target+slop))
		}
	}
	return nil
}
Beispiel #3
0
func TestMemberSimple(t *testing.T) {
	st := store.New()
	defer close(st.Ops)
	fp := &test.FakeProposer{Store: st}
	c := make(chan string)
	go Clean(c, fp.Store, fp)

	fp.Propose([]byte(store.MustEncodeSet("/ctl/node/a/x", "a", store.Missing)))
	fp.Propose([]byte(store.MustEncodeSet("/ctl/node/a/y", "b", store.Missing)))
	fp.Propose([]byte(store.MustEncodeSet("/ctl/node/a/addr", "1.2.3.4", store.Missing)))
	fp.Propose([]byte(store.MustEncodeSet("/ctl/cal/0", "a", store.Missing)))

	calCh := fp.Watch(store.MustCompileGlob("/ctl/cal/0"))
	nodeCh := fp.Watch(store.MustCompileGlob("/ctl/node/a/?"))

	// indicate that this peer is inactive
	go func() { c <- "1.2.3.4" }()

	ev := <-calCh
	assert.T(t, ev.IsSet())
	assert.Equal(t, "", ev.Body)

	cs := []int{}

	ev = <-nodeCh
	assert.T(t, ev.IsDel())
	cs = append(cs, int(ev.Path[len(ev.Path)-1]))

	ev = <-nodeCh
	assert.T(t, ev.IsDel())
	cs = append(cs, int(ev.Path[len(ev.Path)-1]))

	sort.SortInts(cs)
	assert.Equal(t, []int{'x', 'y'}, cs)
}
func generateEquivalentProductsRecursive(product []int, resultMap map[string][]int) {

	productString := fmt.Sprint(product)
	if _, ok := resultMap[productString]; ok == true {
		return
	}
	resultMap[productString] = product

	done := make(map[int]bool)

	for i := 0; i < len(product); i += 1 {
		for j := i + 1; j < len(product); j += 1 {

			p := product[i] * product[j]

			done[p] = true

			productTmp := vector.IntVector(product)
			productCopy := productTmp.Copy()

			productCopy.Delete(j)
			productCopy.Set(i, p)

			sort.SortInts(productCopy)

			generateEquivalentProductsRecursive(productCopy, resultMap)

		}
	}
}
Beispiel #5
0
func main() {
	s := make([]int, 1000000)
	for i, _ := range s {
		s[i] = 1000000 - i
	}
	println(s[999999])
	sort.SortInts(s)
	println(s[999999])
}
Beispiel #6
0
func TestHeap(t *testing.T) {

	heap := NewSize(1) // make it short to test resize
	nums := randomInts(1000)
	elmts := make([]Heapable, len(nums))

	for i := 0; i < len(nums); i++ {
		elmts[i] = &heaper{nums[i]}
	}

	heap.AddSlice(elmts)

	if heap.Len() != len(nums) {
		t.Fatalf("heap.Len() != %d\n", len(nums))
	}

	sort.SortInts(nums)

	for i := 0; i < len(nums); i++ {
		if heap.Remove().Priority() != nums[i] {
			t.Fatalf("binheap: Priority() != %d\n", nums[i])
		}
	}

	if !heap.Empty() {
		t.Fatalf("heap not empty\n")
	}

	nums = randomInts(1000)

	// add single elements.. i.e. not slice
	for i := 0; i < len(nums); i++ {
		heap.Add(&heaper{nums[i]})
	}

	sort.SortInts(nums)

	for i := 0; i < len(nums); i++ {
		if heap.Remove().Priority() != nums[i] {
			t.Fatalf("binheap: Priority() != %d\n", nums[i])
		}
	}

}
Beispiel #7
0
// unique returns the list sorted and with duplicate entries removed
func unique(list []int) []int {
	sort.SortInts(list)
	var last int
	i := 0
	for _, x := range list {
		if i == 0 || x != last {
			last = x
			list[i] = x
			i++
		}
	}
	return list[0:i]
}
Beispiel #8
0
func Usage() {
	fmt.Fprintf(os.Stderr, "Use: %s [options] <command> [options] [args]\n", self)
	fmt.Fprint(os.Stderr, usage1)
	flag.PrintDefaults()
	fmt.Fprintln(os.Stderr)
	fmt.Fprintln(os.Stderr, "Exit Status (not an exhaustive list):")
	fmt.Fprintf(os.Stderr, "  %3d: %s\n", 0, "success")

	var ns []int
	for n := range proto.Response_Err_name {
		ns = append(ns, int(n))
	}
	sort.SortInts(ns)
	for _, n := range ns {
		name := proto.Response_Err_name[int32(n)]
		switch name {
		// These errors should never be exposed to the user,
		// so don't show them in the usage output.
		case "TAG_IN_USE", "UNKNOWN_VERB", "REDIRECT", "INVALID_SNAP":
			continue
		}
		var s string
		switch name {
		case "NOTDIR":
			s = "not a directory"
		case "ISDIR":
			s = "is a directory"
		default:
			s = strings.Replace(strings.ToLower(name), "_", " ", -1)
		}
		fmt.Fprintf(os.Stderr, "  %3d: %s\n", n, s)
	}

	fmt.Fprint(os.Stderr, usage2)
	var max int
	var names []string
	us := make(map[string]string)
	for k := range cmds {
		u := k + " " + cmds[k].a
		if len(u) > max {
			max = len(u)
		}
		names = append(names, k)
		us[k] = u
	}
	sort.SortStrings(names)
	for _, k := range names {
		fmt.Fprintf(os.Stderr, "  %-*s - %s\n", max, us[k], cmds[k].d)
	}

}
Beispiel #9
0
func verifyElements(tree *RBTree, a []int, t *testing.T) {
	c := make([]int, len(a))
	copy(c, a)
	sort.SortInts(c)

	index := 0
	tree.For(func(e interface{}) bool {
		i := e.(int)
		if i != c[index] {
			t.Errorf("Expected %d, Actual %d", c[index], i)
			return false
		}
		index++
		return true
	})
}
Beispiel #10
0
func generateDivisors(expandedProduct []int) []int {

	resultMap := make(map[int]bool)

	generateDivisorsRecursively(expandedProduct, 1, 0, resultMap)

	ret := make([]int, len(resultMap))
	i := 0
	for k, _ := range resultMap {
		ret[i] = k
		i += 1
	}

	sort.SortInts(ret)

	return ret[:len(ret)-1]
}
Beispiel #11
0
func (s *S) TestDistinct(c *C) {
	session, err := mgo.Mongo("localhost:40001")
	c.Assert(err, IsNil)
	defer session.Close()

	coll := session.DB("mydb").C("mycoll")

	for _, i := range []int{1, 4, 6, 2, 2, 3, 4} {
		coll.Insert(M{"n": i})
	}

	var result []int
	err = coll.Find(M{"n": M{"$gt": 2}}).Sort(M{"n": 1}).Distinct("n", &result)

	sort.SortInts(result)
	c.Assert(result, Equals, []int{3, 4, 6})
}
Beispiel #12
0
func fmtRuns(rs map[int64]*run) (s string) {
	var ns []int
	for i := range rs {
		ns = append(ns, int(i))
	}
	sort.SortInts(ns)
	for _, i := range ns {
		r := rs[int64(i)]
		if r.l.done {
			s += "X"
		} else if r.prop {
			s += "o"
		} else {
			s += "."
		}
	}
	return s
}
func testLookups(t *testing.T, src string, x *Index, tc *testCase, n int) {
	for _, s := range tc.lookups {
		res := x.Lookup([]byte(s), n)
		exp := find(tc.source, s, n)

		// check that the lengths match
		if len(res) != len(exp) {
			t.Errorf("test %q, lookup %q (n = %d): expected %d results; got %d", tc.name, s, n, len(exp), len(res))
		}

		// if n >= 0 the number of results is limited --- unless n >= all results,
		// we may obtain different positions from the Index and from find (because
		// Index may not find the results in the same order as find) => in general
		// we cannot simply check that the res and exp lists are equal

		// check that there are no duplicates
		sort.SortInts(res)
		for i, r := range res {
			if i > 0 && res[i-1] == r {
				t.Errorf("test %q, lookup %q, result %d (n = %d): found duplicate index %d", tc.name, s, i, n, r)
			}
		}

		// check that each result is in fact a correct match
		for i, r := range res {
			if r < 0 || len(src) <= r {
				t.Errorf("test %q, lookup %q, result %d (n = %d): index %d out of range [0, %d[", tc.name, s, i, n, r, len(src))
			} else if !strings.HasPrefix(src[r:], s) {
				t.Errorf("test %q, lookup %q, result %d (n = %d): index %d not a match", tc.name, s, i, n, r)
			}
		}

		if n < 0 {
			// all results computed - sorted res and exp must be equal
			for i, r := range res {
				e := exp[i]
				if r != e {
					t.Errorf("test %q, lookup %q, result %d: expected index %d; got %d", tc.name, s, i, e, r)
					continue
				}
			}
		}
	}
}
Beispiel #14
0
func main() {
	pr, pw, _ := os.Pipe()
	defer pr.Close()
	r := bufio.NewReader(pr)
	w := bufio.NewWriter(os.Stdout)
	defer w.Flush()
	pid, _ := os.StartProcess("/bin/ps", []string{"ps", "-e", "-opid,ppid,comm"}, nil, "", []*os.File{nil, pw, nil})
	defer os.Wait(pid, os.WNOHANG)
	pw.Close()

	child := make(map[int]*vector.IntVector)
	s, ok := r.ReadString('\n') // Discard the header line
	s, ok = r.ReadString('\n')
	for ok == nil {
		f := strings.Fields(s)
		if _, present := child[atoi(f[PPID])]; !present {
			v := new(vector.IntVector)
			child[atoi(f[PPID])] = v
		}
		// Save the child PIDs on a vector
		child[atoi(f[PPID])].Push(atoi(f[PID]))
		s, ok = r.ReadString('\n')
	}

	// Sort the PPIDs
	schild := make([]int, len(child))
	i := 0
	for k, _ := range child {
		schild[i] = k
		i++
	}
	sort.SortInts(schild)
	// Walk throught the sorted list
	for _, ppid := range schild {
		fmt.Printf("Pid %d has %d child", ppid, child[ppid].Len())
		if child[ppid].Len() == 1 {
			fmt.Printf(": %v\n", []int(*child[ppid]))
		} else {
			fmt.Printf("ren: %v\n", []int(*child[ppid]))
		}
	}
}
Beispiel #15
0
func main() {
	var ar [5]int
	fmt.Println(ar) // nice trick to output all elements

	// arrays and pointers
	try_to_transform_array(ar)
	fmt.Println(ar)
	transform_array(&ar)
	fmt.Println(ar)

	// Arrays with initializing
	// first 3 elements
	ar2 := [5]int{1, 2, 3}
	fmt.Println(ar2)
	// random elements
	ar3 := [5]int{0: 1, 2: 3, 4: 5}
	fmt.Println(ar3)

	// without size specifying
	ar4 := [...]int{1, 2, 3, 4, 5}
	fmt.Println(ar4)

	// without size specifying and just 1 ellement
	ar5 := [...]int{4: 5}
	fmt.Println(ar5)

	// passing array litteral as argument to function
	ar6 := array_reversing(&[5]int{1, 2, 3, 4, 5})
	fmt.Println(*ar6)

	// array functions
	// len - size
	ar7 := []int{1, 3, 2, 5, 1}
	fmt.Printf("Array size is %d\n", len(ar7))

	// sorting
	sort.SortInts(ar7)
	fmt.Println(ar7)
}
Beispiel #16
0
// Compute minimum, p percentil, median, average, 100-p percentil and maximum of values in data.
func SixvalInt(data []int, p int) (min, lq, med, avg, uq, max int) {
	min, max = math.MaxInt32, math.MinInt32
	sum, n := 0, len(data)
	if n == 0 {
		return
	}
	if n == 1 {
		min = data[0]
		lq = data[0]
		med = data[0]
		avg = data[0]
		uq = data[0]
		max = data[0]
		return
	}
	for _, v := range data {
		if v < min {
			min = v
		}
		if v > max {
			max = v
		}
		sum += v
	}

	avg = sum / n

	sort.SortInts(data)

	if n%2 == 1 {
		med = data[(n-1)/2]
	} else {
		med = (data[n/2] + data[n/2-1]) / 2
	}

	lq = PercentilInt(data, p)
	uq = PercentilInt(data, 100-p)
	return
}
Beispiel #17
0
// Generate description from ParsedOps
func arrange(desc ParsedOps) @[email protected] {
	nops := len(desc)
	clist := make([]int, nops)
	codes := make(map[int]string, nops)
	sdesc := make(@[email protected], nops)
	
	// Extract codes for each message type
	i := 0
	for op, spec := range desc {
		for _, atype := range spec {
			for argname, argtype := range atype {
				if argname == "code" {
					clist[i], _ = strconv.Atoi(argtype)
					codes[clist[i]] = op
					// Remove code from desc
					atype[argname] = "0", false
					
					i = i + 1
				}
			}
		}
	}
	
	// Populate description
	i = 0
	sort.SortInts(clist)
	
	for _, code := range clist {
		sdesc[i].Code = code
		sdesc[i].Name = codes[code]
		sdesc[i].Args = desc[codes[code]]
		i = i + 1
	}
	
	return sdesc
}
Beispiel #18
0
// FindAllIndex returns a sorted list of non-overlapping matches of the
// regular expression r, where a match is a pair of indices specifying
// the matched slice of x.Bytes(). If n < 0, all matches are returned
// in successive order. Otherwise, at most n matches are returned and
// they may not be successive. The result is nil if there are no matches,
// or if n == 0.
//
func (x *Index) FindAllIndex(r *regexp.Regexp, n int) (result [][]int) {
	// a non-empty literal prefix is used to determine possible
	// match start indices with Lookup
	prefix, complete := r.LiteralPrefix()
	lit := []byte(prefix)

	// worst-case scenario: no literal prefix
	if prefix == "" {
		return r.FindAllIndex(x.data, n)
	}

	// if regexp is a literal just use Lookup and convert its
	// result into match pairs
	if complete {
		// Lookup returns indices that may belong to overlapping matches.
		// After eliminating them, we may end up with fewer than n matches.
		// If we don't have enough at the end, redo the search with an
		// increased value n1, but only if Lookup returned all the requested
		// indices in the first place (if it returned fewer than that then
		// there cannot be more).
		for n1 := n; ; n1 += 2 * (n - len(result)) /* overflow ok */ {
			indices := x.Lookup(lit, n1)
			if len(indices) == 0 {
				return
			}
			sort.SortInts(indices)
			pairs := make([]int, 2*len(indices))
			result = make([][]int, len(indices))
			count := 0
			prev := 0
			for _, i := range indices {
				if count == n {
					break
				}
				// ignore indices leading to overlapping matches
				if prev <= i {
					j := 2 * count
					pairs[j+0] = i
					pairs[j+1] = i + len(lit)
					result[count] = pairs[j : j+2]
					count++
					prev = i + len(lit)
				}
			}
			result = result[0:count]
			if len(result) >= n || len(indices) != n1 {
				// found all matches or there's no chance to find more
				// (n and n1 can be negative)
				break
			}
		}
		if len(result) == 0 {
			result = nil
		}
		return
	}

	// regexp has a non-empty literal prefix; Lookup(lit) computes
	// the indices of possible complete matches; use these as starting
	// points for anchored searches
	// (regexp "^" matches beginning of input, not beginning of line)
	r = regexp.MustCompile("^" + r.String()) // compiles because r compiled

	// same comment about Lookup applies here as in the loop above
	for n1 := n; ; n1 += 2 * (n - len(result)) /* overflow ok */ {
		indices := x.Lookup(lit, n1)
		if len(indices) == 0 {
			return
		}
		sort.SortInts(indices)
		result = result[0:0]
		prev := 0
		for _, i := range indices {
			if len(result) == n {
				break
			}
			m := r.FindIndex(x.data[i:]) // anchored search - will not run off
			// ignore indices leading to overlapping matches
			if m != nil && prev <= i {
				m[0] = i // correct m
				m[1] += i
				result = append(result, m)
				prev = m[1]
			}
		}
		if len(result) >= n || len(indices) != n1 {
			// found all matches or there's no chance to find more
			// (n and n1 can be negative)
			break
		}
	}
	if len(result) == 0 {
		result = nil
	}
	return
}
Beispiel #19
0
func BenchmarkStdlibSortInts(b *testing.B) {
	for i := 0; i < b.N; i++ {
		nums := randomInts(1000)
		sort.SortInts(nums)
	}
}
Beispiel #20
0
func recursive(a, b map[int]bool, lastA, lastB int, results map[string]bool) {

	if len(a) < 6 {

		for i := lastA + 1; i < 10; i += 1 {

			if _, ok := a[i]; ok == true {
				continue
			} else {
				tmpA := make(map[int]bool)
				for k, v := range a {
					tmpA[k] = v
				}
				tmpA[i] = true

				recursive(tmpA, b, i, lastB, results)
			}
		}

	}

	if len(b) < 6 {

		for i := lastB + 1; i < 10; i += 1 {

			if _, ok := b[i]; ok == true {
				continue
			} else {
				tmpB := make(map[int]bool)
				for k, v := range b {
					tmpB[k] = v
				}
				tmpB[i] = true

				recursive(a, tmpB, lastA, i, results)
			}

		}

	}

	if len(a) == 6 && len(b) == 6 {

		if check(a, b) {

			str1, str2 := "", ""

			for k, _ := range a {
				str1 += fmt.Sprint(k)
			}
			for k, _ := range b {
				str2 += fmt.Sprint(k)
			}

			_, ok1 := results[str1+str2]
			_, ok2 := results[str2+str1]

			if ok1 == false && ok2 == false {

				results[str1+str2] = true

				str2 := ""

				vectorA := make([]int, 6)
				i := 0
				for k, _ := range a {
					vectorA[i] = k
					i += 1
				}

				vectorB := make([]int, 6)
				j := 0
				for k, _ := range b {
					vectorB[j] = k
					j += 1
				}

				sort.SortInts(vectorA)
				sort.SortInts(vectorB)

				for _, v := range vectorA {
					str2 += fmt.Sprint(v)
				}

				str2 += ","
				for _, v := range vectorB {
					str2 += fmt.Sprint(v)
				}

				fmt.Println(str2, len(results))
			}

		}
	}

}
func main() {
	fmt.Println()

	min := 2
	max := 15000

	kToProductSum := make([]int, 12000+1)
	for k, _ := range kToProductSum {
		kToProductSum[k] = 0x7fffffff
	}

	factorizedNumbers := generateAllNumbers(min, max)

	for number, factorization := range factorizedNumbers {

		expandedProduct := expandFactorization(factorization)
		sort.SortInts(expandedProduct)

		fmt.Println(number, "==", expandedProduct)

		products := generateEquivalentProducts(expandedProduct)

		for _, product := range products {

			k := isProductSum(product)

			fmt.Println("  ", k, product)

			if k <= 12000 {

				if kToProductSum[k] > number {
					kToProductSum[k] = number
				}
			}

		}
	}

	productSums := make(map[int]bool)
	for k, v := range kToProductSum {

		if k == 0 || k == 1 {
			continue
		}

		fmt.Println(k, v)

		productSums[v] = true
	}

	sumOfProductSums := uint64(0)
	for k, _ := range productSums {

		if k < 0 {
			panic("w00t")
		}

		sumOfProductSums += uint64(k)
	}

	fmt.Println(sumOfProductSums)

}